Add: structure detecting

Author: CrazyProger1

fastpy/parser/nodes.py

@@ -7,18 +7,16 @@ class BaseNode(ABC):
     @abstractmethod
     def line(self) -> int: ...
 
-    @abstractmethod
-    def have_body(self) -> bool: ...
 
+class NodeWithBody(BaseNode, ABC):
+    _body = []
 
-class BellyNode(BaseNode, ABC):
-    def have_body(self) -> bool:
-        return True
+    def push_node_to_body(self, node: BaseNode):
+        self._body.append(node)
 
 
-class ThinNode(BaseNode, ABC):
-    def have_body(self) -> bool:
-        return False
+class BasicNode(BaseNode, ABC):
+    pass
 
 
 class PrintableNode(BaseNode, ABC):
@@ -30,23 +28,23 @@ def __repr__(self):
         return self.__class__.__name__ + text
 
 
-class VariableNode(ThinNode, PrintableNode):
+class VariableNode(BasicNode, PrintableNode):
     def __init__(self, identifier: BaseToken):
         self.identifier = identifier
 
     def line(self) -> int:
         return self.identifier.line
 
 
-class ValueNode(ThinNode, PrintableNode):
+class ValueNode(BasicNode, PrintableNode):
     def __init__(self, value: BaseToken):
         self.value = value
 
     def line(self) -> int:
         return self.value.line
 
 
-class AssignNode(ThinNode, PrintableNode):
+class AssignNode(BasicNode, PrintableNode):
     def __init__(self,
                  identifier: BaseToken,
                  value_type: BaseToken = None,
@@ -59,29 +57,29 @@ def line(self) -> int:
         return self.identifier.line
 
 
-class FuncNode(BellyNode, PrintableNode):
+class FuncNode(NodeWithBody, PrintableNode):
     def __init__(self,
                  identifier: BaseToken,
                  arguments: list[AssignNode] = None,
                  body: list[BaseNode] = None,
                  return_type: BaseToken = None):
         self.identifier = identifier
         self.arguments = arguments or []
-        self.body = body or []
+        self._body = body or []
         self.return_type = return_type
 
     def line(self) -> int:
         return self.identifier.line
 
 
-class IfNode(BellyNode, PrintableNode):
+class IfNode(NodeWithBody, PrintableNode):
     def __init__(self,
                  condition: list[BaseNode] = None,
                  body: list[BaseNode] = None,
                  elif_cases: list = None,
                  else_body: list[BaseNode] = None):
         self.condition = condition
-        self.body = body or []
+        self._body = body or []
         self.elif_cases: list[IfNode.__init__] = elif_cases
         self.else_body = else_body
 
@@ -91,7 +89,7 @@ def line(self) -> int:
         return self.condition[0].line
 
 
-class BinOpNode(ThinNode, PrintableNode):
+class BinOpNode(BasicNode, PrintableNode):
     def __init__(self,
                  left_operand: BaseNode = None,
                  right_operand: BaseNode = None,
@@ -116,14 +114,14 @@ def line(self) -> int:
 #         pass
 
 
-class WhileNode(BellyNode, PrintableNode):
+class WhileNode(NodeWithBody, PrintableNode):
     def __init__(self,
                  condition: list[BaseNode] = None,
                  body: list[BaseNode] = None,
                  else_body: list[BaseNode] = None):
         self.condition = condition
-        self.body = body or []
         self.else_body = else_body or []
+        self._body = body
 
     def line(self) -> int:
         if not self.condition or len(self.condition) == 0:

fastpy/parser/parsers.py

@@ -4,6 +4,8 @@
 from .config import *
 from ..import_tools import import_class
 from ..log import Logger
+from .nodes import *
+from .structure import *
 
 
 class BaseParser(ABC):
@@ -18,13 +20,36 @@ class Parser(BaseParser):
     def __init__(self, tokens: list[BaseToken]):
         self._tokens = tokens
         self._ast = create_ast()
+        self._structures: list[Structure] = []
+        self._current_structure: Structure | None = None
 
-    def _parse_node(self, tokens: list[BaseToken]):
+    def _parse_node(self, tokens: list[BaseToken]) -> BaseNode | None:
         pass
 
+    def _detect_struct_start(self, node: BaseNode, level: int):
+        if isinstance(node, NodeWithBody):
+            self._current_structure = Structure(
+                node=node,
+                level=level
+            )
+            self._structures.append(self._current_structure)
+            Logger.log_info('Structure detected:', node, ': level:', level)
+
     @Logger.info_decorator(pattern='Parsing: {expr_tokens[0].line}: {expr_tokens}: level: {expr_level}')
     def _parse_expression(self, expr_tokens: list[BaseToken], expr_level: int):
-        pass
+        node = self._parse_node(expr_tokens)
+
+        if node:
+            self._detect_struct_start(node=node, level=expr_level)
+            if self._current_structure and self._current_structure.within_struct(expr_level):
+                self._current_structure.push_node(node)
+            else:
+                if self._current_structure and len(self._structures) >= 2:
+                    self._structures.pop(-1)
+                    self._current_structure = self._structures[-1]
+                else:
+                    self._current_structure = None
+                    self._structures.clear()
 
     @Logger.info_decorator('Start parsing...', ending_message='Parsing completed in {time}')
     def parse(self) -> BaseAST:

fastpy/parser/structure.py

@@ -0,0 +1,13 @@
+from .nodes import *
+
+
+class Structure:
+    def __init__(self, node, level: int):
+        self._level = level
+        self._node: NodeWithBody = node
+
+    def push_node(self, node: BaseNode):
+        self._node.push_node_to_body(node=node)
+
+    def within_struct(self, level: int):
+        return level == self._level