Add: function & call parsing

Author: CrazyProger1

config/parser.json

@@ -90,8 +90,8 @@
         {
           "validate_data": {
             "methods": {
-              "check_min_tokens_length": {
-                "min_length": 3
+              "check_fixed_tokens_length": {
+                "length": 3
               },
               "check_tokens_types": {
                 "types": [
@@ -183,6 +183,84 @@
           }
         }
       ]
+    },
+    "FuncNode": {
+      "parser_class": "fastpy.parser.node_parsers.UniversalNodeParser",
+      "node_class": "fastpy.parser.nodes.FuncNode",
+      "cases": [
+        {
+          "validate_data": {
+            "methods": {
+              "check_min_tokens_length": {
+                "min_length": 5
+              },
+              "check_tokens_types": {
+                "types": [
+                  "operator",
+                  "identifier",
+                  "start_parenthesis"
+                ]
+              },
+              "check_tokens_names": {
+                "names": [
+                  "function"
+                ]
+              }
+            }
+          },
+          "parse_data": {
+            "identifier": {
+              "index": 1
+            },
+            "arguments": {
+              "parser_class": "fastpy.parser.node_parsers.ArgumentNodesParser",
+              "possible_node_classes": [
+                "fastpy.parser.nodes.AssignNode"
+              ],
+              "tokens_slice": {
+                "start_index": 3
+              }
+            }
+          }
+        }
+      ]
+    },
+    "CallNode": {
+      "parser_class": "fastpy.parser.node_parsers.UniversalNodeParser",
+      "node_class": "fastpy.parser.nodes.CallNode",
+      "cases": [
+        {
+          "validate_data": {
+            "methods": {
+              "check_min_tokens_length": {
+                "min_length": 3
+              },
+              "check_tokens_types": {
+                "types": [
+                  "identifier",
+                  "start_parenthesis"
+                ]
+              }
+            }
+          },
+          "parse_data": {
+            "identifier": {
+              "index": 0
+            },
+            "arguments": {
+              "parser_class": "fastpy.parser.node_parsers.ArgumentNodesParser",
+              "possible_node_classes": [
+                "fastpy.parser.nodes.ValueNode",
+                "fastpy.parser.nodes.VariableNode",
+                "fastpy.parser.nodes.CallNode"
+              ],
+              "tokens_slice": {
+                "start_index": 2
+              }
+            }
+          }
+        }
+      ]
     }
   }
 }

fastpy/lexer/tokens.py

@@ -56,7 +56,7 @@ def __repr__(self):
 def code_from_tokens(tokens: list[BaseToken] | tuple[BaseToken]):
     code = ''
     for token in tokens:
-        code += token.text
+        code += token.text + ' '
     return code
 
 

fastpy/parser/node_parsers.py

@@ -20,17 +20,18 @@ def parse(self,
               tokens: list[BaseToken],
               parse_node_clb: callable,
               supposed_node_type: type[BaseNode],
-              **extra_data) -> BaseNode: ...
+              **extra_data) -> BaseNode | list[BaseNode]: ...
 
 
 @singleton
 class UniversalNodeParser(BaseNodeParser):
-    parses = (AssignNode,)
+    parses = (AssignNode, FuncNode, CallNode, ValueNode, VariableNode)
 
     def validate(self,
                  tokens: list[BaseToken],
                  supposed_node_type: type[BaseNode],
                  **extra_data) -> bool:
+
         methods = extra_data.get('methods')
         if not methods:
             return False
@@ -41,6 +42,7 @@ def validate(self,
                     **method_kwargs
             ):
                 return False
+
         return True
 
     @staticmethod
@@ -77,6 +79,7 @@ def parse(self,
               supposed_node_type: type[BaseNode],
               parse_node_clb: callable,
               **extra_data) -> BaseNode:
+
         node_arguments = {}
         for key, value_data in extra_data.items():
             node_arguments.update({
@@ -226,3 +229,35 @@ def parse(self,
             operator=operator,
             right_operand=right_operand
         )
+
+
+@singleton
+class ArgumentNodesParser(BaseNodeParser):
+    def validate(self,
+                 tokens: list[BaseToken],
+                 supposed_node_type: type[BaseNode],
+                 **extra_data) -> bool:
+        return True
+
+    def parse(self,
+              tokens: list[BaseToken],
+              parse_node_clb: callable,
+              supposed_node_type: type[BaseNode],
+              **extra_data) -> BaseNode | list[BaseNode]:
+
+        if tokens[0].type == TokenTypes.end_parenthesis:
+            return []
+
+        arguments = []
+        expr_tokens = []
+        for token in tokens:
+            if token.type == TokenTypes.comma:
+                node = parse_node_clb(expr_tokens)
+                arguments.append(node)
+                expr_tokens.clear()
+                continue
+            elif token.type == TokenTypes.end_parenthesis:
+                node = parse_node_clb(expr_tokens)
+                arguments.append(node)
+                return arguments
+            expr_tokens.append(token)

fastpy/parser/nodes.py

@@ -73,22 +73,34 @@ def __init__(self,
                  return_type: BaseToken = None):
         self.identifier = identifier
         self.arguments = arguments or []
-        self._body = body or []
+        self.body = body or []
         self.return_type = return_type
 
     @property
     def line(self) -> int:
         return self.identifier.line
 
 
+class CallNode(BasicNode, PrintableNode):
+    def __init__(self,
+                 identifier: BaseToken,
+                 arguments: list[BaseNode] = None):
+        self.identifier = identifier
+        self.arguments = arguments or []
+
+    @property
+    def line(self) -> int:
+        return self.identifier.line
+
+
 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
 

fastpy/parser/parsers.py

@@ -91,7 +91,7 @@ def _detect_struct_start(self, node: BaseNode, level: int):
         if isinstance(node, NodeWithBody):
             self._current_struct = Structure(
                 node=node,
-                level=level
+                level=level + 4
             )
             self._structs.append(self._current_struct)
 
@@ -104,8 +104,6 @@ def _parse_expression(self, expr_tokens: list[BaseToken], expr_level: int):
 
         node = self._parse_node(expr_tokens)
 
-        self._detect_struct_start(node, expr_level)
-
         if self._within_struct(level=expr_level):
             self._current_struct.push_node(node=node)
         else:
@@ -119,6 +117,8 @@ def _parse_expression(self, expr_tokens: list[BaseToken], expr_level: int):
             else:
                 self._current_struct = None
 
+        self._detect_struct_start(node, expr_level)
+
     @Logger.info('Start parsing...', ending_message='Parsing completed in {time}')
     # @Logger.catch_errors()
     def parse(self) -> BaseAST:

main.fpy

@@ -6,3 +6,7 @@ c: int
 
 d = a
 e = (20 - 10) + (d + 20) + a
+
+
+fun world(a: int, b: bool, c: str) -> null:
+    log('World')