Add 'not' operator

smnp/ast/node/factor.py

@@ -1,5 +1,5 @@
 from smnp.ast.node.chain import ChainParser
-from smnp.ast.node.operator import BinaryOperator, Operator
+from smnp.ast.node.operator import BinaryOperator, Operator, UnaryOperator
 from smnp.ast.node.valuable import Valuable
 from smnp.ast.parser import Parser
 from smnp.token.type import TokenType
@@ -9,6 +9,9 @@ class Factor(Valuable):
     pass
 
 
+class NotOperator(UnaryOperator):
+    pass
+
 class Loop(BinaryOperator):
     pass
 
@@ -21,25 +24,41 @@ def FactorParser(input):
         ChainParser,
         [TokenType.DOUBLE_ASTERISK],
         ChainParser,
-        lambda left, op, right: Factor.withValue(BinaryOperator.withValues(left, op, right))
+        lambda left, op, right: Factor.withValue(BinaryOperator.withValues(left, op, right)),
+        name="power operator"
     )
 
     exprFactor = Parser.allOf(
         Parser.terminalParser(TokenType.OPEN_PAREN),
         MaxPrecedenceExpressionParser,
         Parser.terminalParser(TokenType.CLOSE_PAREN),
-        createNode=lambda open, expr, close: expr
+        createNode=lambda open, expr, close: expr,
+        name="grouping parentheses"
+    )
+
+    factorParser = Parser.oneOf(
+        powerFactor,
+        exprFactor,
+        name="basic factor"
+    )
+
+    notOperator = Parser.allOf(
+        Parser.terminalParser(TokenType.NOT, Operator.withValue),
+        factorParser,
+        createNode=NotOperator.withValues,
+        name="not"
     )
 
     loopFactor = Parser.allOf(
-        powerFactor,
+        factorParser,
         Parser.terminalParser(TokenType.DASH, createNode=Operator.withValue),
         StatementParser,
-        createNode=Loop.withValues
+        createNode=Loop.withValues,
+        name="dash-loop"
     )
 
     return Parser.oneOf(
         loopFactor,
-        powerFactor,
-        exprFactor,
+        notOperator,
+        factorParser
     )(input)

smnp/ast/node/operator.py

@@ -2,6 +2,35 @@ from smnp.ast.node.model import Node
 from smnp.ast.node.none import NoneNode
 
 
+class UnaryOperator(Node):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children=[NoneNode(), NoneNode()]
+
+    @property
+    def operator(self):
+        return self[0]
+
+    @operator.setter
+    def operator(self, value):
+        self[0] = value
+
+    @property
+    def value(self):
+        return self[1]
+
+    @value.setter
+    def value(self, value):
+        self[1] = value
+
+    @classmethod
+    def withValues(cls, operator, value):
+        node = cls(operator.pos)
+        node.operator = operator
+        node.value = value
+        return node
+
+
 class BinaryOperator(Node):
     def __init__(self, pos):
         super().__init__(pos)