Create evaluator for function call and basic atoms

smnp/main.py

@@ -7,7 +7,7 @@ from smnp.program.interpreter import Interpreter
 def main():
     try:
         #stdLibraryEnv = loadStandardLibrary()
-        Interpreter.interpretFile(sys.argv[1], printTokens=False, printAst=True, execute=False, baseEnvironment=None)
+        Interpreter.interpretFile(sys.argv[1], printTokens=False, printAst=True, execute=True, baseEnvironment=None)
         #draft()
         #tokens = tokenize(['function a(b...) { x+y}'])
         #FunctionDefinitionParser(tokens).node.print()

smnp/program/interpreter.py

@@ -1,7 +1,8 @@
 from smnp.ast.parser import parse
-#from smnp.environment.factory import createEnvironment
+from smnp.environment.factory import createEnvironment
 from smnp.error.runtime import RuntimeException
 from smnp.program.FileReader import readLines
+from smnp.runtime.evaluator import evaluate
 from smnp.token.tokenizer import tokenize
 
 
@@ -17,9 +18,9 @@ class Interpreter:
 
     @staticmethod
     def _interpret(lines, printTokens=False, printAst=False, execute=True, baseEnvironment=None):
-        #environment = createEnvironment()
-        #if baseEnvironment is not None:
-        #    environment.extend(baseEnvironment)
+        environment = createEnvironment()
+        if baseEnvironment is not None:
+            environment.extend(baseEnvironment)
 
         try:
             tokens = tokenize(lines)
@@ -30,10 +31,10 @@ class Interpreter:
             if printAst:
                 ast.print()
 
-            #if execute:
-            #    evaluate(ast, environment)
+            if execute:
+                evaluate(ast, environment)
 
-            #return environment
+            return environment
         except RuntimeException as e:
-            #e.environment = environment
+            e.environment = environment
             raise e

smnp/runtime/evaluator.py

@@ -1,9 +1,4 @@
-from smnp.ast.node.block import BlockNode
-from smnp.ast.node.extend import ExtendNode
-from smnp.ast.node.function import FunctionDefinitionNode
-from smnp.ast.node.imports import ImportNode
 from smnp.ast.node.program import Program
-from smnp.ast.node.ret import ReturnNode
 from smnp.error.runtime import RuntimeException
 from smnp.type.model import Type
 
@@ -68,20 +63,15 @@ class EvaluationResult():
 
 def evaluate(node, environment):
     from smnp.runtime.evaluators.program import ProgramEvaluator
-    from smnp.runtime.evaluators.expression import expressionEvaluator
 
-    from smnp.runtime.evaluators.function import FunctionDefinitionEvaluator
-    from smnp.runtime.evaluators.extend import ExtendEvaluator
-    from smnp.runtime.evaluators.block import BlockEvaluator
-    from smnp.runtime.evaluators.imports import ImportEvaluator
-    from smnp.runtime.evaluators.function import ReturnEvaluator
+    from smnp.runtime.evaluators.expression import expressionEvaluator
     result = Evaluator.oneOf(
         Evaluator.forNodes(ProgramEvaluator.evaluate, Program),
-        Evaluator.forNodes(ImportEvaluator.evaluate, ImportNode),
-        Evaluator.forNodes(FunctionDefinitionEvaluator.evaluate, FunctionDefinitionNode),
-        Evaluator.forNodes(ExtendEvaluator.evaluate, ExtendNode),
-        Evaluator.forNodes(BlockEvaluator.evaluate, BlockNode),
-        Evaluator.forNodes(ReturnEvaluator.evaluate, ReturnNode),
+        #Evaluator.forNodes(ImportEvaluator.evaluate, ImportNode),
+        #Evaluator.forNodes(FunctionDefinitionEvaluator.evaluate, FunctionDefinitionNode),
+        #Evaluator.forNodes(ExtendEvaluator.evaluate, ExtendNode),
+        #Evaluator.forNodes(BlockEvaluator.evaluate, BlockNode),
+        #Evaluator.forNodes(ReturnEvaluator.evaluate, ReturnNode),
         expressionEvaluator()
     )(node, environment)
 

smnp/runtime/evaluators/atom.py

@@ -0,0 +1,37 @@
+from smnp.runtime.evaluator import Evaluator
+from smnp.type.model import Type
+
+
+class IntegerEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.integer(node.value)
+
+
+class StringEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.string(node.value)
+
+
+class NoteEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.note(node.value)
+
+
+class BoolEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.bool(node.value)
+
+
+class TypeEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.type(node.value)

smnp/runtime/evaluators/expression.py

@@ -1,15 +1,5 @@
-from smnp.ast.node.assignment import AssignmentNode
-from smnp.ast.node.asterisk import AsteriskNode
-from smnp.ast.node.bool import BoolLiteralNode
-from smnp.ast.node.identifier import Identifier
-from smnp.ast.node.integer import IntegerLiteralNode
-from smnp.ast.node.invocation import FunctionCallNode
-from smnp.ast.node.list import List
-from smnp.ast.node.map import MapNode
-from smnp.ast.node.note import NoteLiteralNode
-from smnp.ast.node.operator import LeftAssociativeOperatorNode
-from smnp.ast.node.string import StringLiteralNode
-from smnp.ast.node.type import TypeNode
+from smnp.ast.node.atom import StringLiteral, IntegerLiteral, NoteLiteral, BoolLiteral, TypeLiteral
+from smnp.ast.node.identifier import FunctionCall
 from smnp.error.runtime import RuntimeException
 from smnp.runtime.evaluator import Evaluator
 from smnp.type.model import Type
@@ -17,32 +7,26 @@ from smnp.type.model import Type
 
 def expressionEvaluator(doAssert=False):
     def evaluateExpression(node, environment):
-            from smnp.runtime.evaluators.string import StringEvaluator
-            from smnp.runtime.evaluators.integer import IntegerEvaluator
-            from smnp.runtime.evaluators.note import NoteEvaluator
-            from smnp.runtime.evaluators.identifier import IdentifierEvaluator
-            from smnp.runtime.evaluators.list import ListEvaluator
-            from smnp.runtime.evaluators.function import FunctionCallEvaluator
+            from smnp.runtime.evaluators.atom import StringEvaluator
+            from smnp.runtime.evaluators.atom import TypeEvaluator
+            from smnp.runtime.evaluators.atom import IntegerEvaluator
+            from smnp.runtime.evaluators.atom import NoteEvaluator
+            from smnp.runtime.evaluators.atom import BoolEvaluator
 
-            from smnp.runtime.evaluators.access import AccessEvaluator
-            from smnp.runtime.evaluators.assignment import AssignmentEvaluator
-            from smnp.runtime.evaluators.asterisk import AsteriskEvaluator
-            from smnp.runtime.evaluators.map import MapEvaluator
-            from smnp.runtime.evaluators.type import TypeEvaluator
-            from smnp.runtime.evaluators.bool import BoolEvaluator
+            from smnp.runtime.evaluators.function import FunctionCallEvaluator
             result =  Evaluator.oneOf(
-                Evaluator.forNodes(FunctionCallEvaluator.evaluate, FunctionCallNode),
-                Evaluator.forNodes(StringEvaluator.evaluate, StringLiteralNode),
-                Evaluator.forNodes(IntegerEvaluator.evaluate, IntegerLiteralNode),
-                Evaluator.forNodes(NoteEvaluator.evaluate, NoteLiteralNode),
-                Evaluator.forNodes(BoolEvaluator.evaluate, BoolLiteralNode),
-                Evaluator.forNodes(TypeEvaluator.evaluate, TypeNode),
-                Evaluator.forNodes(IdentifierEvaluator.evaluate, Identifier),
-                Evaluator.forNodes(ListEvaluator.evaluate, List),
-                Evaluator.forNodes(AccessEvaluator.evaluate, LeftAssociativeOperatorNode),
-                Evaluator.forNodes(AssignmentEvaluator.evaluate, AssignmentNode),
-                Evaluator.forNodes(AsteriskEvaluator.evaluate, AsteriskNode),
-                Evaluator.forNodes(MapEvaluator.evaluate, MapNode)
+                Evaluator.forNodes(FunctionCallEvaluator.evaluate, FunctionCall),
+                Evaluator.forNodes(StringEvaluator.evaluate, StringLiteral),
+                Evaluator.forNodes(IntegerEvaluator.evaluate, IntegerLiteral),
+                Evaluator.forNodes(NoteEvaluator.evaluate, NoteLiteral),
+                Evaluator.forNodes(BoolEvaluator.evaluate, BoolLiteral),
+                Evaluator.forNodes(TypeEvaluator.evaluate, TypeLiteral),
+                # Evaluator.forNodes(IdentifierEvaluator.evaluate, Identifier),
+                # Evaluator.forNodes(ListEvaluator.evaluate, List),
+                # Evaluator.forNodes(AccessEvaluator.evaluate, LeftAssociativeOperatorNode),
+                # Evaluator.forNodes(AssignmentEvaluator.evaluate, AssignmentNode),
+                # Evaluator.forNodes(AsteriskEvaluator.evaluate, AsteriskNode),
+                # Evaluator.forNodes(MapEvaluator.evaluate, MapNode)
             )(node, environment)
 
             if doAssert and result.result and result.value.type == Type.VOID:

smnp/runtime/tools/signature.py

@@ -1,5 +1,5 @@
 from smnp.ast.node.none import NoneNode
-from smnp.ast.node.type import TypeNode, TypeSpecifier
+from smnp.ast.node.type import Type, TypesList
 from smnp.error.runtime import RuntimeException
 from smnp.function.signature import varargSignature, signature
 from smnp.runtime.tools.error import updatePos
@@ -16,9 +16,9 @@ def argumentsNodeToMethodSignature(node):
         argumentsCount = len(node.children)
         for i, child in enumerate(node.children):
             matchers = {
-                TypeNode: (lambda c: c.type, typeMatcher),
+                Type: (lambda c: c.type, typeMatcher),
                 NoneNode: (lambda c: c.type, lambda c: allTypes()),
-                TypeSpecifier: (lambda c: c, multipleTypeMatcher)
+                TypesList: (lambda c: c, multipleTypeMatcher)
             }
             evaluatedMatcher = matchers[type(child.type)][1](matchers[type(child.type)][0](child))
             if child.vararg: