Added SyaNodeParser (finally, after one month)

src/parsers/PythonParser.py

@@ -1,4 +1,4 @@
-from core.builtin_concepts import BuiltinConcepts
+from core.builtin_concepts import BuiltinConcepts, ParserResultConcept
 from core.tokenizer import Tokenizer, LexerError, TokenKind
 from parsers.BaseParser import BaseParser, Node, ErrorNode
 from dataclasses import dataclass
@@ -6,7 +6,7 @@ import ast
 import logging
 import core.utils
 
-from parsers.ConceptLexerParser import ConceptNode
+from parsers.BnfNodeParser import ConceptNode
 
 log = logging.getLogger(__name__)
 
@@ -67,7 +67,7 @@ class PythonParser(BaseParser):
         BaseParser.__init__(self, "Python", 50)
         self.source = kwargs.get("source", "<undef>")
 
-    def parse(self, context, text):
+    def parse(self, context, parser_input):
         sheerka = context.sheerka
         tree = None
 
@@ -76,15 +76,9 @@ class PythonParser(BaseParser):
         }
 
         try:
-            if isinstance(text, str) and "c:" in text:
-                source = self.get_text_from_tokens(list(Tokenizer(text)), python_switcher)
-            elif isinstance(text, str):
-                source = text
-            else:
-                source = self.get_text_from_tokens(text, python_switcher)
+            source = self.get_input_as_text(parser_input, python_switcher)
             source = source.strip()
-
-            text = text if isinstance(text, str) else source
+            parser_input = parser_input if isinstance(parser_input, str) else source
 
             #  first, try to parse an expression
             res, tree, error = self.try_parse_expression(source)
@@ -92,25 +86,32 @@ class PythonParser(BaseParser):
                 # then try to parse a statement
                 res, tree, error = self.try_parse_statement(source)
                 if not res:
-                    self.has_error = True
-                    error_node = PythonErrorNode(text, error)
+                    error_node = PythonErrorNode(parser_input, error)
                     self.error_sink.append(error_node)
 
         except LexerError as e:
-            self.has_error = True
             self.error_sink.append(e)
 
-        ret = sheerka.ret(
-            self.name,
-            not self.has_error,
-            sheerka.new(
-                BuiltinConcepts.PARSER_RESULT,
-                parser=self,
-                source=text,
-                body=self.error_sink if self.has_error else PythonNode(text, tree),
-                try_parsed=None))
+        if self.has_error:
+            ret = sheerka.ret(
+                self.name,
+                False,
+                sheerka.new(
+                    BuiltinConcepts.NOT_FOR_ME,
+                    body=parser_input,
+                    reason=self.error_sink))
+        else:
+            ret = sheerka.ret(
+                self.name,
+                True,
+                sheerka.new(
+                    BuiltinConcepts.PARSER_RESULT,
+                    parser=self,
+                    source=parser_input,
+                    body=PythonNode(parser_input, tree),
+                    try_parsed=None))
 
-        self.log_result(context, text, ret)
+        self.log_result(context, parser_input, ret)
         return ret
 
     def try_parse_expression(self, text):