From bfb509f41f349b463d142de0ceaf5f4d53302dc2 Mon Sep 17 00:00:00 2001
From: Tibo De Peuter <tibo.depeuter@ugent.be>
Date: Wed, 30 Apr 2025 09:18:46 +0200
Subject: [PATCH] Arithmetic ops parsing

---
 src/parser/grammars/TermsGrammar.kt | 41 ++++++++++++++++++++---------
 src/parser/grammars/Tokens.kt       |  4 ++-
 2 files changed, 31 insertions(+), 14 deletions(-)

diff --git a/src/parser/grammars/TermsGrammar.kt b/src/parser/grammars/TermsGrammar.kt
index 9a26f77..c57ab22 100644
--- a/src/parser/grammars/TermsGrammar.kt
+++ b/src/parser/grammars/TermsGrammar.kt
@@ -7,18 +7,12 @@ import com.github.h0tk3y.betterParse.combinators.unaryMinus
 import com.github.h0tk3y.betterParse.combinators.use
 import com.github.h0tk3y.betterParse.grammar.parser
 import com.github.h0tk3y.betterParse.parser.Parser
+import prolog.ast.arithmetic.ArithmeticOperator
+import prolog.ast.arithmetic.Expression
 import prolog.ast.arithmetic.Float
 import prolog.ast.arithmetic.Integer
 import prolog.ast.logic.LogicOperand
-import prolog.ast.logic.LogicOperator
-import prolog.ast.terms.Atom
-import prolog.ast.terms.Body
-import prolog.ast.terms.Head
-import prolog.ast.terms.Operator
-import prolog.ast.terms.Structure
-import prolog.ast.terms.Term
-import prolog.ast.terms.Variable
-import prolog.builtins.Conjunction
+import prolog.ast.terms.*
 
 open class TermsGrammar : Tokens() {
     // Basic named terms
@@ -37,19 +31,40 @@ open class TermsGrammar : Tokens() {
     protected val float: Parser<Float> by floatToken use { Float(text.toFloat()) }
 
     // Operators
+    protected val logOps: Parser<String> by (dummy
+            or comma
+            or semicolon
+            ) use { this.text }
     protected val simpleLogicOperand: Parser<LogicOperand> by (dummy
             or compound
             or atom
             )
     protected val logicOperand: Parser<LogicOperand> by (dummy
-            or parser(::operator)
+            or parser(::logicOperator)
             or simpleLogicOperand
             )
-    protected val logicOperator: Parser<LogicOperator> by (simpleLogicOperand * -comma * logicOperand) use {
-        Conjunction(t1, t2)
+    protected val logicOperator: Parser<CompoundTerm> by (simpleLogicOperand * logOps * logicOperand) use {
+        CompoundTerm(Atom(t2), listOf(t1, t3))
     }
-    protected val operator: Parser<Operator> by (dummy
+
+    protected val arithmeticOps: Parser<String> by (dummy
+            or plus
+            ) use { this.text }
+    protected val simpleArithmeticOperand: Parser<Expression> by (dummy
+            or int
+            or float
+            )
+    protected val arithmeticOperand: Parser<Expression> by (dummy
+            or parser(::arithmeticOperator)
+            or simpleArithmeticOperand
+            ) use { this as Expression }
+    protected val arithmeticOperator: Parser<CompoundTerm> by (simpleArithmeticOperand * arithmeticOps * arithmeticOperand) use {
+        CompoundTerm(Atom(t2), listOf(t1, t3))
+    }
+
+    protected val operator: Parser<CompoundTerm> by (dummy
             or logicOperator
+            or arithmeticOperator
             )
 
     // Parts
diff --git a/src/parser/grammars/Tokens.kt b/src/parser/grammars/Tokens.kt
index b2e8fd7..49afbee 100644
--- a/src/parser/grammars/Tokens.kt
+++ b/src/parser/grammars/Tokens.kt
@@ -18,9 +18,11 @@ abstract class Tokens : Grammar<Any>() {
 
     // Special tokens
     protected val neck by literalToken(":-")
-    protected val comma: Token by literalToken(",")
     protected val leftParenthesis: Token by literalToken("(")
     protected val rightParenthesis: Token by literalToken(")")
+    protected val comma: Token by literalToken(",")
+    protected val semicolon: Token by literalToken(";")
+    protected val plus: Token by literalToken("+")
     protected val dot by literalToken(".")
 
     // Ignored tokens