Add equal ('==') operator to both identifiers and bools

smnp/ast/node/bool.py

@@ -17,8 +17,8 @@ class BoolLiteralNode(LiteralNode, AccessNode, RelationOperatorNode):
     @classmethod
     def _parse(cls, input):
         x = Parser.oneOf(
-            cls.relationParser(),
             cls.accessParser(),
+            cls.relationParser(),
             cls.literalParser()
         )(input)
         return x

smnp/ast/node/expression.py

@@ -52,12 +52,13 @@ class ExpressionNode(Node):
     def _expressionParser(cls):
         from smnp.ast.node.bool import BoolLiteralNode
 
+        from smnp.ast.node.identifier import IdentifierNode
         return Parser.oneOf(
             #IntegerLiteralNode.parse,
             #StringLiteralNode.parse,
             #NoteLiteralNode.parse,
             BoolLiteralNode.parse,
-            #IdentifierNode.parse,
+            IdentifierNode.parse,
             #MapNode.parse,
             #ListNode.parse,
             #TypeNode.parse,

smnp/ast/node/identifier.py

@@ -2,17 +2,34 @@ from smnp.ast.node.access import AccessNode
 from smnp.ast.node.assignment import AssignmentNode
 from smnp.ast.node.expression import ExpressionNode
 from smnp.ast.node.invocation import FunctionCallNode, ArgumentsListNode
+from smnp.ast.node.relation import RelationOperatorNode
 from smnp.ast.parser import Parser
 from smnp.token.type import TokenType
 
 
-class IdentifierNode(AccessNode):
+class IdentifierNode(AccessNode, RelationOperatorNode):
     def __init__(self, pos):
         super().__init__(pos)
         del self.children[1]
 
     @classmethod
-    def _literalParser(cls):
+    def _parse(cls, input):
+        return Parser.oneOf(
+            cls.accessParser(),
+            cls.relationParser(),
+            cls.literalParser()
+        )(input)
+
+    @classmethod
+    def _accessLhs(cls):
+        return cls.literalParser()
+
+    @classmethod
+    def _relationLhs(cls):
+        return cls.literalParser()
+
+    @classmethod
+    def literalParser(cls):
         return Parser.oneOf(
             IdentifierNode.functionCallParser(),
             IdentifierNode._assignmentParser(),

smnp/ast/node/relation.py

@@ -56,4 +56,11 @@ class RelationOperatorNode(ExpressionNode):
     @staticmethod
     def _relationRhs():
         # TODO doAssert
-        return ExpressionNode.parse
+        from smnp.ast.node.bool import BoolLiteralNode
+        from smnp.ast.node.identifier import IdentifierNode
+
+        return Parser.oneOf(
+            BoolLiteralNode.accessParser(),
+            BoolLiteralNode.literalParser(),
+            IdentifierNode.literalParser()
+        )

smnp/ast/parser.py

@@ -105,7 +105,7 @@ class Parser:
                     oneAtLeast = True
                     right = rightParser(input)
                     left = ParseResult.OK(createNode(left.node, operator.node, right.node))
-                    operator = Parser.terminalParser(operatorTokenType)(input)
+                    operator = Parser.terminalParser(operatorTokenType, lambda val, pos: OperatorNode.withChildren([val], pos))(input)
                 if oneAtLeast:
                     return left
 

smnp/main.py

@@ -1,14 +1,13 @@
-from smnp.ast.node.bool import BoolLiteralNode
+import sys
+
 from smnp.error.base import SmnpException
-from smnp.token.tokenizer import tokenize
+from smnp.program.interpreter import Interpreter
 
 
 def main():
     try:
-        tokens = tokenize([ "true == true == false.not.not" ])
-        BoolLiteralNode.parse(tokens).node.print()
         #stdLibraryEnv = loadStandardLibrary()
-        #Interpreter.interpretFile(sys.argv[1], printTokens=False, printAst=True, baseEnvironment=None)
+        Interpreter.interpretFile(sys.argv[1], printTokens=False, printAst=True, baseEnvironment=None)
 
     except SmnpException as e:
         print(e.message())