Fixed ambiguity between actions and strings in primitives_visitor

bootstrap/constructors.alc

@@ -23,7 +23,6 @@ Action function construct_global():
 	String declared_element
 	String op
 
-	log("Construct global")
 	this_element = create_value(!global)
 	declared_element = input()
 	dict_add(this_element, "var", declared_element)
@@ -42,7 +41,6 @@ Action function construct_global():
 		value = create_value(!constant)
 		dict_add(value, "node", import_node(input()))
 	elif (op == "empty"):
-		log("EMPTY")
 		value = create_value(!call)
 		Element res
 		Element acc
@@ -51,7 +49,6 @@ Action function construct_global():
 		dict_add(value, "func", acc)
 		dict_add(acc, "var", res)
 		dict_add(res, "var", "create_node")
-		log("Created create_node call")
 	elif (op == "const"):
 		value = create_value(!constant)
 		dict_add(value, "node", input())

integration/test_constructors_al.py

@@ -6,185 +6,185 @@ from utils import execute, kill, run_file, run_barebone
 
 class TestConstructorsActionLanguage(unittest.TestCase):
     def test_constructors_simple(self):
-        commands = ['"output"',                    # Output
-                        '"const"', 'true',
-                        'true',                     # (has next)
-                        '"return"',                # Return
-                            'true',                 # (has value)
-                            '"const"', 'true',
+        commands = ["output",                    # Output
+                        "const", True,
+                        True,                     # (has next)
+                        "return",                # Return
+                            True,                 # (has value)
+                            "const", True,
                 ]
         self.assertTrue(run_barebone(commands, ["True"], 1))
 
     def test_constructors_if_else_true(self):
-        commands = ['"if"',                    # If
-                        '"const"', 'true',    # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'true',                 # Has else
-                        '"output"',            # False-part
-                            '"const"', 'false',
-                            'false',            # Has next
-                        'true',                 # Has next
-                        '"return"',            # Return
-                            'true',             # Has value
-                            '"const"', "true",
+        commands = ["if",                    # If
+                        "const", True,    # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        True,                 # Has else
+                        "output",            # False-part
+                            "const", False,
+                            False,            # Has next
+                        True,                 # Has next
+                        "return",            # Return
+                            True,             # Has value
+                            "const", "true",
                 ]
         self.assertTrue(run_barebone(commands, ["True"], 1))
 
     def test_constructors_if_else_false(self):
-        commands = ['"if"',                    # If
-                        '"const"', 'false',   # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'true',                 # Has else
-                        '"output"',            # False-part
-                            '"const"', 'false',
-                            'false',            # Has next
-                        'true',                 # Has next
-                        '"return"',            # Return
-                            'true',             # Has value
-                            '"const"', "true",
+        commands = ["if",                    # If
+                        "const", False,   # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        True,                 # Has else
+                        "output",            # False-part
+                            "const", False,
+                            False,            # Has next
+                        True,                 # Has next
+                        "return",            # Return
+                            True,             # Has value
+                            "const", "true",
                 ]
         self.assertTrue(run_barebone(commands, ["False"], 1))
 
     def test_constructors_if_true(self):
-        commands = ['"if"',                    # If
-                        '"const"', 'true',    # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'false',                # Has else
-                        'true',                 # Has next
-                        '"return"',            # Return
-                            'true',             # Has value
-                            '"const"', "true",
+        commands = ["if",                    # If
+                        "const", True,    # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        False,                # Has else
+                        True,                 # Has next
+                        "return",            # Return
+                            True,             # Has value
+                            "const", "true",
                 ]
         self.assertTrue(run_barebone(commands, ["True"], 1))
 
     def test_constructors_if_false(self):
-        commands = ['"if"',                    # If
-                        '"const"', 'false',   # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'false',                # Has else
-                        'true',                 # Has next
-                        '"return"',            # Return
-                            'true',             # Has value
-                            '"const"', "true",
+        commands = ["if",                    # If
+                        "const", False,   # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        False,                # Has else
+                        True,                 # Has next
+                        "return",            # Return
+                            True,             # Has value
+                            "const", "true",
                 ]
         self.assertTrue(run_barebone(commands, [None], 1, timeout=True))
 
     def test_constructors_addition(self):
-        commands = ['"output"',
-                        '"call"',
-                            '"deref"', '"primitives/integer_addition"',
-                            '2',
-                            '"const"', '1',
-                            '"const"', '5',
-                            'false',
-                        'true',
-                        '"return"', 'true', '"const"', 'true',
+        commands = ["output",
+                        "call",
+                            "deref", "primitives/integer_addition",
+                            2,
+                            "const", 1,
+                            "const", 5,
+                            False,
+                        True,
+                        "return", True, "const", True,
                 ]
         self.assertTrue(run_barebone(commands, ["6"], 1))
 
     def test_constructors_while_false(self):
-        commands = ['"while"',                 # While
-                        '"const"', 'false',   # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'true',                 # Has next
-                        '"output"',            # Output false
-                            '"const"', 'false',
-                            'true',             # Has next
-                            '"return"',        # Return
-                                'true',         # Has value
-                                '"const"', "true",
+        commands = ["while",                 # While
+                        "const", False,   # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        True,                 # Has next
+                        "output",            # Output false
+                            "const", False,
+                            True,             # Has next
+                            "return",        # Return
+                                True,         # Has value
+                                "const", "true",
                 ]
         self.assertTrue(run_barebone(commands, ["False"], 1))
 
     def test_constructors_while_true(self):
-        commands = ['"while"',                 # While
-                        '"const"', 'true',    # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'true',                 # Has next
-                        '"output"',            # False-part
-                            '"const"', 'false',
-                            'true',            # Has next
-                        '"return"',            # Return
-                            'true',             # Has value
-                            '"const"', "true",
+        commands = ["while",                 # While
+                        "const", True,    # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        True,                 # Has next
+                        "output",            # False-part
+                            "const", False,
+                            True,            # Has next
+                        "return",            # Return
+                            True,             # Has value
+                            "const", "true",
                 ]
         self.assertTrue(run_barebone(commands, ["True", "True", "True", "True"], 1))
 
     def test_constructors_declare_and_assign(self):
-        commands = ['"declare"',
-                        '"1"',
-                        'true',
-                    '"assign"',
-                        '"resolve"', '"1"',
-                        '"const"', '5',
-                        'true',
-                    '"output"',
-                        '"access"', '"resolve"', '"1"',
-                        'true',
-                    '"return"',
-                        'true',
-                        '"const"', "true",
+        commands = ["declare",
+                        "1",
+                        True,
+                    "assign",
+                        "resolve", "1",
+                        "const", 5,
+                        True,
+                    "output",
+                        "access", "resolve", "1",
+                        True,
+                    "return",
+                        True,
+                        "const", "true",
                 ]
         self.assertTrue(run_barebone(commands, ["5"], 1))
 
     def test_constructors_output_input(self):
-        commands = ['"output"',
-                        '"input"',
-                        'true',
-                    '"return"',
-                        'true',
-                        '"const"', "true",
+        commands = ["output",
+                        "input",
+                        True,
+                    "return",
+                        True,
+                        "const", "true",
                 ]
-        self.assertTrue(run_barebone(commands + ['123456'], ["123456"], 1))
+        self.assertTrue(run_barebone(commands + [123456], ["123456"], 1))
 
     def test_constructors_continue(self):
-        commands = ['"while"',
-                        '"const"', 'true',
-                        '"output"', '"const"', '1',
-                            'true',
-                            '"if"',
-                                '"const"', 'true',
-                                '"continue"',
-                                'false',
-                                'true',
-                            '"output"', '"const"', '2',
-                                'false',
-                        'true',
-                    '"output"', '"const"', '3',
-                        'true',
-                    '"return"', 'true',
-                        '"const"', 'true',
+        commands = ["while",
+                        "const", True,
+                        "output", "const", 1,
+                            True,
+                            "if",
+                                "const", True,
+                                "continue",
+                                False,
+                                True,
+                            "output", "const", 2,
+                                False,
+                        True,
+                    "output", "const", 3,
+                        True,
+                    "return", True,
+                        "const", True,
                 ]
-        self.assertTrue(run_barebone(commands, ['1', '1', '1', '1', '1'], 1))
+        self.assertTrue(run_barebone(commands, [1, 1, 1, 1, 1], 1))
 
     def test_constructors_break(self):
-        commands = ['"while"',
-                        '"const"', 'true',
-                        '"output"', '"const"', '1',
-                            'true',
-                            '"if"',
-                                '"const"', 'true',
-                                '"break"',
-                                'false',
-                                'true',
-                            '"output"', '"const"', '2',
-                                'false',
-                        'true',
-                    '"output"', '"const"', '3',
-                        'true',
-                    '"return"', 'true',
-                        '"const"', 'true',
+        commands = ["while",
+                        "const", True,
+                        "output", "const", 1,
+                            True,
+                            "if",
+                                "const", True,
+                                "break",
+                                False,
+                                True,
+                            "output", "const", 2,
+                                False,
+                        True,
+                    "output", "const", 3,
+                        True,
+                    "return", True,
+                        "const", True,
                 ]
-        self.assertTrue(run_barebone(commands, ['1', '3'], 1))
+        self.assertTrue(run_barebone(commands, [1, 3], 1))

integration/test_constructors_al_linkable.py

@@ -7,221 +7,221 @@ from utils import execute, kill, run_file, run_barebone
 def extend_commands(commands):
     # Initially we communicate with the compilation_manager to add the bytecodes
     pre =   [
-                '3',
-                '"upload"',
-                '"test.o"',
-                '"MD5_HASH"',
-                'true',     # use NEW interface for constructors
-                '"funcdef"', '"main"', '0', # Main function
+                3,
+                "upload",
+                "test.o",
+                "MD5_HASH",
+                True,     # use NEW interface for constructors
+                "funcdef", "main", 0, # Main function
             ]
     # We only have to define "main" for now
     post =  [
-                'true',
-                '"main"',
-                'true',
-                'false',
+                True,
+                "main",
+                True,
+                False,
             ]
     return pre + commands + post
 
 class TestConstructorsActionLanguageLinkable(unittest.TestCase):
     def test_constructors_simple(self):
         commands = [
-                        '"output"',
-                            '"const"', 'true',
-                            'true',
-                        '"return"',
-                            'true',
-                            '"const"', 'true',
-                        'false',
+                        "output",
+                            "const", True,
+                            True,
+                        "return",
+                            True,
+                            "const", True,
+                        False,
                     ]
         commands = extend_commands(commands)
         self.assertTrue(run_barebone(commands, ["True"], None, link=["test.o"]))
 
     def test_constructors_if_else_true(self):
         commands = [
-                        '"if"',                    # If
-                        '"const"', 'true',    # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'true',                 # Has else
-                        '"output"',            # False-part
-                            '"const"', 'false',
-                            'false',            # Has next
-                        'true',                 # Has next
-                        '"return"',            # Return
-                            'true',             # Has value
-                            '"const"', "true",
-                        'false',
+                        "if",                    # If
+                        "const", True,    # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        True,                 # Has else
+                        "output",            # False-part
+                            "const", False,
+                            False,            # Has next
+                        True,                 # Has next
+                        "return",            # Return
+                            True,             # Has value
+                            "const", "true",
+                        False,
                 ]
         commands = extend_commands(commands)
         self.assertTrue(run_barebone(commands, ["True"], None, link=["test.o"]))
 
     def test_constructors_if_else_false(self):
         commands = [
-                        '"if"',                    # If
-                        '"const"', 'false',   # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'true',                 # Has else
-                        '"output"',            # False-part
-                            '"const"', 'false',
-                            'false',            # Has next
-                        'true',                 # Has next
-                        '"return"',            # Return
-                            'true',             # Has value
-                            '"const"', "true",
-                        'false',
+                        "if",                    # If
+                        "const", False,   # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        True,                 # Has else
+                        "output",            # False-part
+                            "const", False,
+                            False,            # Has next
+                        True,                 # Has next
+                        "return",            # Return
+                            True,             # Has value
+                            "const", "true",
+                        False,
                 ]
         commands = extend_commands(commands)
         self.assertTrue(run_barebone(commands, ["False"], None, link=["test.o"]))
 
     def test_constructors_if_true(self):
         commands = [
-                        '"if"',                    # If
-                        '"const"', 'true',    # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'false',                # Has else
-                        'true',                 # Has next
-                        '"return"',            # Return
-                            'true',             # Has value
-                            '"const"', "true",
-                    'false',
+                        "if",                    # If
+                        "const", True,    # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        False,                # Has else
+                        True,                 # Has next
+                        "return",            # Return
+                            True,             # Has value
+                            "const", "true",
+                    False,
                 ]
         commands = extend_commands(commands)
         self.assertTrue(run_barebone(commands, ["True"], None, link=["test.o"]))
 
     def test_constructors_if_false(self):
         commands = [
-                        '"if"',                    # If
-                        '"const"', 'false',   # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'false',                # Has else
-                        'true',                 # Has next
-                        '"return"',            # Return
-                            'true',             # Has value
-                            '"const"', "true",
-                        'false',
+                        "if",                    # If
+                        "const", False,   # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        False,                # Has else
+                        True,                 # Has next
+                        "return",            # Return
+                            True,             # Has value
+                            "const", "true",
+                        False,
                 ]
         commands = extend_commands(commands)
         self.assertTrue(run_barebone(commands, [None], None, timeout=True, link=["test.o"]))
 
     def test_constructors_while_false(self):
         commands = [
-                        '"while"',                 # While
-                        '"const"', 'false',   # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'true',                 # Has next
-                        '"output"',            # Output false
-                            '"const"', 'false',
-                            'true',             # Has next
-                            '"return"',        # Return
-                                'true',         # Has value
-                                '"const"', "true",
-                        'false',
+                        "while",                 # While
+                        "const", False,   # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        True,                 # Has next
+                        "output",            # Output false
+                            "const", False,
+                            True,             # Has next
+                            "return",        # Return
+                                True,         # Has value
+                                "const", "true",
+                        False,
                 ]
         commands = extend_commands(commands)
         self.assertTrue(run_barebone(commands, ["False"], None, link=["test.o"]))
 
     def test_constructors_while_true(self):
         commands = [
-                        '"while"',                 # While
-                        '"const"', 'true',    # Condition
-                        '"output"',            # True-part
-                            '"const"', 'true',
-                            'false',            # Has next
-                        'true',                 # Has next
-                        '"output"',            # False-part
-                            '"const"', 'false',
-                            'true',            # Has next
-                        '"return"',            # Return
-                            'true',             # Has value
-                            '"const"', "true",
-                        'false',
+                        "while",                 # While
+                        "const", True,    # Condition
+                        "output",            # True-part
+                            "const", True,
+                            False,            # Has next
+                        True,                 # Has next
+                        "output",            # False-part
+                            "const", False,
+                            True,            # Has next
+                        "return",            # Return
+                            True,             # Has value
+                            "const", "true",
+                        False,
                 ]
         commands = extend_commands(commands)
         self.assertTrue(run_barebone(commands, ["True", "True", "True", "True"], None, link=["test.o"]))
 
     def test_constructors_declare_and_assign(self):
         commands = [
-                    '"declare"',
-                        '"1"',
-                        'true',
-                    '"assign"',
-                        '"resolve"', '"1"',
-                        '"const"', '5',
-                        'true',
-                    '"output"',
-                        '"access"', '"resolve"', '"1"',
-                        'true',
-                    '"return"',
-                        'true',
-                        '"const"', "true",
-                    'false',
+                    "declare",
+                        "1",
+                        True,
+                    "assign",
+                        "resolve", "1",
+                        "const", 5,
+                        True,
+                    "output",
+                        "access", "resolve", "1",
+                        True,
+                    "return",
+                        True,
+                        "const", "true",
+                    False,
                 ]
         commands = extend_commands(commands)
         self.assertTrue(run_barebone(commands, ["5"], None, link=["test.o"]))
 
     def test_constructors_output_input(self):
         commands = [
-                     '"output"',
-                        '"input"',
-                        'true',
-                    '"return"',
-                        'true',
-                        '"const"', "true",
-                    'false',
+                     "output",
+                        "input",
+                        True,
+                    "return",
+                        True,
+                        "const", "true",
+                    False,
                 ]
         commands = extend_commands(commands)
         self.assertTrue(run_barebone(commands, ["123456"], None, link=["test.o"], inputs=["123456"]))
 
     def test_constructors_continue(self):
-        commands = ['"while"',
-                        '"const"', 'true',
-                        '"output"', '"const"', '1',
-                            'true',
-                            '"if"',
-                                '"const"', 'true',
-                                '"continue"',
-                                'false',
-                                'true',
-                            '"output"', '"const"', '2',
-                                'false',
-                        'true',
-                    '"output"', '"const"', '3',
-                        'true',
-                    '"return"', 'true',
-                        '"const"', 'true',
-                    'false'
+        commands = ["while",
+                        "const", True,
+                        "output", "const", 1,
+                            True,
+                            "if",
+                                "const", True,
+                                "continue",
+                                False,
+                                True,
+                            "output", "const", 2,
+                                False,
+                        True,
+                    "output", "const", 3,
+                        True,
+                    "return", True,
+                        "const", True,
+                    False
                 ]
         commands = extend_commands(commands)
-        self.assertTrue(run_barebone(commands, ['1', '1', '1', '1', '1'], None, link=["test.o"]))
+        self.assertTrue(run_barebone(commands, [1, 1, 1, 1, 1], None, link=["test.o"]))
 
     def test_constructors_break(self):
-        commands = ['"while"',
-                        '"const"', 'true',
-                        '"output"', '"const"', '1',
-                            'true',
-                            '"if"',
-                                '"const"', 'true',
-                                '"break"',
-                                'false',
-                                'true',
-                            '"output"', '"const"', '2',
-                                'false',
-                        'true',
-                    '"output"', '"const"', '3',
-                        'true',
-                    '"return"', 'true',
-                        '"const"', 'true',
-                    'false'
+        commands = ["while",
+                        "const", True,
+                        "output", "const", 1,
+                            True,
+                            "if",
+                                "const", True,
+                                "break",
+                                False,
+                                True,
+                            "output", "const", 2,
+                                False,
+                        True,
+                    "output", "const", 3,
+                        True,
+                    "return", True,
+                        "const", True,
+                    False
                 ]
         commands = extend_commands(commands)
-        self.assertTrue(run_barebone(commands, ['1', '3'], None, link=["test.o"]))
+        self.assertTrue(run_barebone(commands, [1, 3], None, link=["test.o"]))

interface/HUTN/hutn_compiler/linker.py

@@ -12,18 +12,9 @@ def link(address, username, objects):
     # Read out all symbol tables that are to be linked
     definers = {}
     users = {}
-    data = []
 
-    data.append('3')
-    data.append('"link_and_load"')
-    for obj in objects:
-        data.append('"%s"' % obj)
-    data.append('""')
+    flush_data(address, [3, "link_and_load"] + objects + ["", "main"], username)
 
-    # Call the main function
-    data.append('"main"')
-
-    data = flush_data(address, data, username)
     v = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read()
     v = json.loads(v)
     if "OK" not in v:

interface/HUTN/hutn_compiler/primitives_visitor.py

@@ -2,6 +2,10 @@ import string
 from visitor import Visitor
 import json
 
+class Action():
+    def __init__(self, value):
+        self.value = value
+
 class PrimitivesVisitor(Visitor):
     def __init__(self, args):
         Visitor.__init__(self, args)
@@ -22,10 +26,14 @@ class PrimitivesVisitor(Visitor):
     def dict(self, src, val, trgt):
         if src is None or trgt is None:
             raise Exception("Got None")
-        self.output.append(("D", (src, val, trgt)))
+        self.output.append(("D", (src, json.dumps(val), trgt)))
 
     def value(self, value):
-        self.output.append(("V", (self.free_id, json.dumps(value))))
+        if isinstance(value, Action):
+            v = value.value
+        else:
+            v = json.dumps(value)
+        self.output.append(("V", (self.free_id, v)))
         self.free_id += 1
         return self.free_id - 1
 
@@ -99,10 +107,10 @@ class PrimitivesVisitor(Visitor):
         symbol = self.get_symbol(tree)
 
         if symbol.is_global:
-            d = self.value("global")
+            d = self.value(Action("global"))
             n = self.value(symbol.name)
         else:
-            d = self.value("declare")
+            d = self.value(Action("declare"))
             n = self.node()
 
         symbol.node = n
@@ -114,7 +122,7 @@ class PrimitivesVisitor(Visitor):
     def visit_assignment(self, tree):
         self.visit_children(tree)
 
-        a = self.value("assign")
+        a = self.value(Action("assign"))
         var = self.get_primitive(tree.get_tail()[0])
         value = self.get_primitive(tree.get_tail()[-1])
         self.dict(a, "var", var)
@@ -176,11 +184,12 @@ class PrimitivesVisitor(Visitor):
         #     n = self.new_value(tree.get_text())
         #     self.set_id(tree, n)
         # else:
-        c = self.value("constant")
+        c = self.value(Action("constant"))
         if tree.get_text()[0] == "!":
             v = tree.get_text()[1:]
         else:
             v = tree.get_text()
+        #TODO does this work for actions?
         n = self.value(v)
         self.dict(c, "node", n)
         self.debug(c, tree)
@@ -198,7 +207,7 @@ class PrimitivesVisitor(Visitor):
         r = self.get_primitive(tree)
         if r is None:
             return
-        a = self.value("access")
+        a = self.value(Action("access"))
         self.dict(a, "var", r)
         self.debug(a, tree)
         self.set_primitive(tree, a)
@@ -207,7 +216,7 @@ class PrimitivesVisitor(Visitor):
         symbol = self.get_symbol(tree)
         if symbol.name in ["input", "output"]:
             return
-        r = self.value("resolve")
+        r = self.value(Action("resolve"))
         # print symbol.name, symbol.is_func(), symbol.node
         self.dict(r, "var", symbol.node)
         self.debug(r, tree)
@@ -238,7 +247,7 @@ class PrimitivesVisitor(Visitor):
 
             arg_nodes_reversed.append(arg_node)
 
-        c = self.value("call")
+        c = self.value(Action("call"))
         a = self.get_primitive(tree.get_tail()[0])
         self.dict(c, "func", a)
         self.debug(c, tree)
@@ -251,13 +260,13 @@ class PrimitivesVisitor(Visitor):
 
     def visit_input(self, tree):
         self.visit_children(tree)
-        v = self.value("input")
+        v = self.value(Action("input"))
         self.debug(v, tree)
         self.set_primitive(tree, v)
 
     def visit_output(self, tree):
         self.visit_children(tree)
-        v = self.value("output")
+        v = self.value(Action("output"))
         self.debug(v, tree)
         value = self.get_primitive(tree.get_child("expression"))
         self.dict(v, "value", value)
@@ -272,7 +281,7 @@ class PrimitivesVisitor(Visitor):
         first = None
         prev = None
         for e, b in zip(expressions, blocks):
-            v = self.value("if")
+            v = self.value(Action("if"))
             self.debug(v, tree)
             if first is None:
                 first = v
@@ -290,7 +299,7 @@ class PrimitivesVisitor(Visitor):
     def visit_while(self, tree):
         self.visit_children(tree)
 
-        w = self.value("while")
+        w = self.value(Action("while"))
         self.debug(w, tree)
         c = self.get_primitive(tree.get_child("expression"))
         b = self.get_primitive(tree.get_child("block"))
@@ -332,16 +341,16 @@ class PrimitivesVisitor(Visitor):
 
         root = self.value(symbol.name)
         symbol.node = root
-        declare = self.value("global")
+        declare = self.value(Action("global"))
         self.dict(declare, "var", root)
 
-        resolve = self.value("resolve")
+        resolve = self.value(Action("resolve"))
         self.dict(resolve, "var", root)
 
-        assign = self.value("assign")
+        assign = self.value(Action("assign"))
         self.dict(assign, "var", resolve)
 
-        const = self.value("constant")
+        const = self.value(Action("constant"))
         self.dict(const, "node", new_value)
         self.dict(assign, "value", const)
 
@@ -382,17 +391,17 @@ class PrimitivesVisitor(Visitor):
             else:
                 return
 
-            declare = self.value("global")
+            declare = self.value(Action("global"))
             self.dict(declare, "var", root)
             self.debug(declare, tree)
 
-            resolve = self.value("resolve")
+            resolve = self.value(Action("resolve"))
             self.dict(resolve, "var", root)
 
-            assign = self.value("assign")
+            assign = self.value(Action("assign"))
             self.dict(assign, "var", resolve)
 
-            const = self.value("constant")
+            const = self.value(Action("constant"))
             self.dict(const, "node", new_value)
             self.dict(assign, "value", const)
 
@@ -402,25 +411,25 @@ class PrimitivesVisitor(Visitor):
         symbol = self.get_symbol(tree)
         root = self.value(symbol.name)
 
-        declare = self.value("global")
+        declare = self.value(Action("global"))
         self.dict(declare, "var", root)
         self.debug(declare, tree)
 
         symbol.node = root
 
-        resolve = self.value("resolve")
+        resolve = self.value(Action("resolve"))
         self.dict(resolve, "var", root)
 
-        assign = self.value("assign")
+        assign = self.value(Action("assign"))
         self.dict(assign, "var", resolve)
 
         self.visit_atomvalue(tree.get_tail()[-1])
         value = self.get_primitive(tree.get_tail()[-1])
 
         if value is None:
-            call = self.value("call")
-            access = self.value("access")
-            resolve = self.value("resolve")
+            call = self.value(Action("call"))
+            access = self.value(Action("access"))
+            resolve = self.value(Action("resolve"))
             self.dict(call, "func", access)
             self.dict(access, "var", resolve)
             self.dict(resolve, "var", self.value("create_node"))
@@ -440,7 +449,7 @@ class PrimitivesVisitor(Visitor):
 
     def visit_return(self, tree):
         self.visit_children(tree)
-        r = self.value("return")
+        r = self.value(Action("return"))
         self.debug(r, tree)
         if len(tree.get_tail()) > 2:
             v = self.get_primitive(tree.get_tail()[1])

scripts/prompt.py

@@ -4,6 +4,7 @@ import threading
 import subprocess
 import os
 import sys
+import json
 
 sys.path.append("../interface/HUTN")
 sys.path.append("interface/HUTN")