Add imports statements

smnp/ast/node/atom.py

@@ -43,32 +43,52 @@ class TypeLiteral(Atom):
     pass
 
 
-def LiteralParser(input):
+def IntegerParser(input):
-    integerParser = Parser.oneOf(
+    return Parser.oneOf(
         Parser.terminalParser(TokenType.INTEGER, lambda val, pos: IntegerLiteral.withValue(int(val), pos)),
         Parser.allOf(
             Parser.terminalParser(TokenType.MINUS),
             Parser.terminalParser(TokenType.INTEGER, lambda val, pos: IntegerLiteral.withValue(int(val), pos)),
-            createNode=lambda minus, integer: IntegerLiteral.withValue(-integer.value, minus.pos)
+            createNode=lambda minus, integer: IntegerLiteral.withValue(-integer.value, minus.pos),
-        )
+            name="negative integer"
         )
+    )(input)
 
+
+def StringParser(input):
+    return Parser.terminalParser(TokenType.STRING, createNode=StringLiteral.withValue)(input)
+
+
+def NoteParser(input):
+    return Parser.terminalParser(TokenType.NOTE, createNode=NoteLiteral.withValue)(input)
+
+
+def BoolParser(input):
+    return Parser.terminalParser(TokenType.BOOL, createNode=BoolLiteral.withValue)(input)
+
+
+def TypeParser(input):
+    return Parser.terminalParser(TokenType.TYPE, createNode=TypeLiteral.withValue)(input)
+
+
+def LiteralParser(input):
     return Parser.oneOf(
-        integerParser,
+        IntegerParser,
-        Parser.terminalParser(TokenType.STRING, createNode=StringLiteral.withValue),
+        StringParser,
-        Parser.terminalParser(TokenType.NOTE, createNode=NoteLiteral.withValue),
+        NoteParser,
-        Parser.terminalParser(TokenType.BOOL, createNode=BoolLiteral.withValue),
+        BoolParser,
-        Parser.terminalParser(TokenType.TYPE, createNode=TypeLiteral.withValue),
+        TypeParser,
+        name="literal"
     )(input)
 
 
 def AtomParser(input):
     from smnp.ast.node.identifier import IdentifierParser
 
-
+    return Parser.oneOf(
-    parser = Parser.oneOf(
         LiteralParser,
         IdentifierParser,
-    )
+        name="atom"
+    )(input)
+
 
-    return Parser(parser, "atom", parser)(input)

smnp/ast/node/imports.py

@@ -1,16 +1,21 @@
-from smnp.ast.node.identifier import Identifier
+# from smnp.ast.node.identifier import Identifier
+# from smnp.ast.node.model import Node
+# from smnp.ast.node.none import NoneNode
+# from smnp.ast.node.string import StringLiteralNode
+# from smnp.ast.node.type import TypeNode
+# from smnp.ast.parser import Parser
+# from smnp.token.type import TokenType
+#
+from smnp.ast.node.atom import StringParser
 from smnp.ast.node.model import Node
-from smnp.ast.node.none import NoneNode
-from smnp.ast.node.string import StringLiteralNode
-from smnp.ast.node.type import TypeNode
 from smnp.ast.parser import Parser
 from smnp.token.type import TokenType
 
 
-class ImportNode(Node):
+class Import(Node):
     def __init__(self, pos):
         super().__init__(pos)
-        self.children = [NoneNode(), NoneNode(), NoneNode()]
+        self.children = [None]
 
     @property
     def source(self):
@@ -20,57 +25,85 @@ class ImportNode(Node):
     def source(self, value):
         self[0] = value
 
-    @property
-    def type(self):
-        return self[1]
-
-    @type.setter
-    def type(self, value):
-        self[1] = value
-
-    @property
-    def variable(self):
-        return self[2]
-
-    @variable.setter
-    def variable(self, value):
-        self[2] = value
-
     @classmethod
-    def _parse(cls, input):
+    def withValue(cls, value):
-        return Parser.oneOf(
+        node = cls(value.pos)
-            cls._literalImportParser(),
+        node.source = value
-            cls._fileImportParser()
+        return node
+
+
+def ImportParser(input):
+    return Parser.allOf(
+        Parser.terminalParser(TokenType.IMPORT),
+        StringParser,
+        createNode=lambda imp, source: Import.withValue(source),
+        name="import"
     )(input)
 
-    @classmethod
+# class ImportNode(Node):
-    def _literalImportParser(cls):
+#     def __init__(self, pos):
-        def createNode(importKeyword, type, fromKeyword, source, asKeyword, variable):
+#         super().__init__(pos)
-            node = ImportNode(importKeyword.pos)
+#         self.children = [NoneNode(), NoneNode(), NoneNode()]
-            node.source = source
+#
-            node.type = type
+#     @property
-            node.variable = variable
+#     def source(self):
-            return node
+#         return self[0]
-
+#
-        return Parser.allOf(
+#     @source.setter
-            Parser.terminalParser(TokenType.IMPORT),
+#     def source(self, value):
-            TypeNode.parse,
+#         self[0] = value
-            Parser.doAssert(Parser.terminalParser(TokenType.FROM), "'from <source> as <variable name>'"),
+#
-            Parser.doAssert(StringLiteralNode._literalParser(), "source as a string"),
+#     @property
-            Parser.doAssert(Parser.terminalParser(TokenType.AS), "'as <variable name>'"),
+#     def type(self):
-            Parser.doAssert(Identifier.identifierParser(), "variable name"),
+#         return self[1]
-            createNode=createNode
+#
-        )
+#     @type.setter
-
+#     def type(self, value):
-    @classmethod
+#         self[1] = value
-    def _fileImportParser(cls):
+#
-        def createNode(importKeyword, source):
+#     @property
-            node = ImportNode(importKeyword.pos)
+#     def variable(self):
-            node.source = source
+#         return self[2]
-            return node
+#
-
+#     @variable.setter
-        return Parser.allOf(
+#     def variable(self, value):
-            Parser.terminalParser(TokenType.IMPORT),
+#         self[2] = value
-            Parser.doAssert(StringLiteralNode._literalParser(), "source as a string"),
+#
-            createNode=createNode
+#     @classmethod
-        )
+#     def _parse(cls, input):
+#         return Parser.oneOf(
+#             cls._literalImportParser(),
+#             cls._fileImportParser()
+#         )(input)
+#
+#     @classmethod
+#     def _literalImportParser(cls):
+#         def createNode(importKeyword, type, fromKeyword, source, asKeyword, variable):
+#             node = ImportNode(importKeyword.pos)
+#             node.source = source
+#             node.type = type
+#             node.variable = variable
+#             return node
+#
+#         return Parser.allOf(
+#             Parser.terminalParser(TokenType.IMPORT),
+#             TypeNode.parse,
+#             Parser.doAssert(Parser.terminalParser(TokenType.FROM), "'from <source> as <variable name>'"),
+#             Parser.doAssert(StringLiteralNode._literalParser(), "source as a string"),
+#             Parser.doAssert(Parser.terminalParser(TokenType.AS), "'as <variable name>'"),
+#             Parser.doAssert(Identifier.identifierParser(), "variable name"),
+#             createNode=createNode
+#         )
+#
+#     @classmethod
+#     def _fileImportParser(cls):
+#         def createNode(importKeyword, source):
+#             node = ImportNode(importKeyword.pos)
+#             node.source = source
+#             return node
+#
+#         return Parser.allOf(
+#             Parser.terminalParser(TokenType.IMPORT),
+#             Parser.doAssert(StringLiteralNode._literalParser(), "source as a string"),
+#             createNode=createNode
+#         )

smnp/ast/node/program.py

@@ -1,3 +1,4 @@
+from smnp.ast.node.imports import ImportParser
 from smnp.ast.node.model import Node, ParseResult
 from smnp.ast.node.statement import StatementParser
 from smnp.ast.parser import Parser
@@ -12,6 +13,7 @@ def parse(input):
     while input.hasCurrent():
         result = Parser.oneOf(
             # Start Symbol
+            ImportParser,
             StatementParser,
             exception=RuntimeError("Nie znam tego wyrazenia")
         )(input)

smnp/ast/node/statement.py

@@ -9,8 +9,8 @@ class Statement(Node):
 
 def StatementParser(input):
     from smnp.ast.node.block import BlockParser
-
     from smnp.ast.node.condition import IfElseStatementParser
+
     parser = Parser.oneOf(
         IfElseStatementParser,
         BlockParser,