Working on #48 : Refactored FunctionParser, introducting ExpressionParser

src/parsers/ExpressionParser.py

@@ -0,0 +1,72 @@
+from core.builtin_concepts_ids import BuiltinConcepts
+from core.sheerka.services.SheerkaExecute import ParserInput
+from parsers.BaseParser import BaseExprParser
+from parsers.FunctionParser import FunctionParser
+from parsers.LogicalOperatorParser import LogicalOperatorParser
+from parsers.RelationalOperatorParser import RelationalOperatorParser
+from parsers.expressions import ParenthesisNode, NameExprNode
+
+
+class ExpressionParser(BaseExprParser):
+    """
+    Parses xxx (== | > | < | >= | <= | != | in | not in) yyy
+    Nothing else
+    """
+
+    NAME = "Expression"
+
+    def __init__(self, **kwargs):
+        super().__init__(ExpressionParser.NAME, 60, False, yield_eof=True)
+        self.logical_parser = LogicalOperatorParser()
+        self.relational_parser = RelationalOperatorParser()
+        self.function_parser = FunctionParser()
+
+    def parse(self, context, parser_input: ParserInput):
+        """
+        :param context:
+        :param parser_input:
+        :return:
+        """
+
+        if not isinstance(parser_input, ParserInput):
+            return None
+
+        context.log(f"Parsing '{parser_input}' with {self.NAME}Parser", self.name)
+        sheerka = context.sheerka
+
+        if parser_input.is_empty():
+            return context.sheerka.ret(self.name,
+                                       False,
+                                       sheerka.new(BuiltinConcepts.IS_EMPTY))
+
+        if not self.reset_parser(context, parser_input):
+            return self.sheerka.ret(
+                self.name,
+                False,
+                context.sheerka.new(BuiltinConcepts.ERROR, body=self.error_sink))
+
+        self.parser_input.next_token()
+
+        node = self.parse_input()
+        if isinstance(node, ParenthesisNode):
+            node = node.node
+
+        value = self.get_return_value_body(context.sheerka, self.parser_input.as_text(), node, node)
+
+        ret = self.sheerka.ret(
+            self.name,
+            not self.has_error,
+            value)
+
+        return ret
+
+    def parse_input(self):
+        pos = self.parser_input.pos
+        for parser in []: # [self.logical_parser, self.relational_parser, self.function_parser]:
+            self.parser_input.seek(pos)  # reset position
+            if parser.reset_parser(self.context, self.parser_input):
+                res = parser.parse_input()
+                if res and not parser.has_error:
+                    return res
+
+        return NameExprNode(self.parser_input.start, self.parser_input.end, self.parser_input.as_tokens())