Add possibility for a definition with value in the compiler

bootstrap/constructors.alc

@@ -327,8 +327,36 @@ Action function construct_declare():
 	dict_add_fast(this_element, "var", declared_element)
 	name = input()
 	dict_add_fast(variable_map, name, declared_element)
+
+	// Assign value
+	Action assign
+	Action resolve
+	Action value
+	assign = create_value(!assign)
+	dict_add_fast(this_element, "next", assign)
+	resolve = create_value(!resolve)
+	dict_add_fast(assign, "var", resolve)
+	dict_add_fast(resolve, "var", declared_element)
+	op = input()
+	if (op == "deref"):
+		value = create_value(!constant)
+		dict_add_fast(value, "node", import_node(input()))
+	elif (op == "empty"):
+		value = create_value(!call)
+		Element res
+		Element acc
+		res = create_value(!resolve)
+		acc = create_value(!access)
+		dict_add_fast(value, "func", acc)
+		dict_add_fast(acc, "var", res)
+		dict_add_fast(res, "var", "create_node")
+	elif (op == "const"):
+		value = create_value(!constant)
+		dict_add_fast(value, "node", input())
+	dict_add_fast(assign, "value", value)
+
 	if (input()):
-		dict_add_fast(this_element, "next", construct_unknown())
+		dict_add_fast(assign, "next", construct_unknown())
 	return this_element!
 
 Action function construct_input():

interface/HUTN/grammars/actionlanguage.g

@@ -3,6 +3,7 @@ grammar{
 
     statement 
         : (vardecl newline)
+        | (definition newline)
         | (assignment newline)
         | (return newline)
         | (func_call newline)

interface/HUTN/hutn_compiler/constructors_visitor.py

@@ -55,11 +55,6 @@ class ConstructorsVisitor(Visitor):
             self.add_constructors("declare", symbol.node)
             self.free_id += 1
 
-    def visit_vardecl(self, tree):
-        symbol = self.get_symbol(tree)
-        self.declare(symbol)
-        return True
-
     def visit_assignment(self, tree):
         self.add_constructors("assign")
         self.visit(tree.get_tail()[0])
@@ -281,10 +276,7 @@ class ConstructorsVisitor(Visitor):
     def visit_definition(self, tree):
         # First declare it
         symbol = self.get_symbol(tree)
-        symbol.node = symbol.name
-
-        # Now generate constructors
-        self.add_constructors("global", symbol.name)
+        self.declare(symbol)
 
         # Determine whether it is just a constant, or a deref
         atom = tree.get_child("atomvalue")
@@ -300,3 +292,11 @@ class ConstructorsVisitor(Visitor):
             # Constant
             self.visit(atom)
         return True
+
+    def visit_vardecl(self, tree):
+        symbol = self.get_symbol(tree)
+        self.declare(symbol)
+
+        # vardecl means it is empty
+        self.add_constructors("empty")
+        return True

interface/HUTN/hutn_compiler/primitives_visitor.py

@@ -104,22 +104,6 @@ class PrimitivesVisitor(Visitor):
             self.dict(primitives[i], "next", primitives[i+1])
         self.last_instruction = primitives[-1]
 
-    def visit_vardecl(self, tree):
-        symbol = self.get_symbol(tree)
-
-        if symbol.is_global:
-            d = self.value(Action("global"))
-            n = self.value(symbol.name)
-        else:
-            d = self.value(Action("declare"))
-            n = self.node()
-
-        symbol.node = n
-        self.dict(d, "var", n)
-        self.debug(d, tree)
-
-        self.set_primitive(tree, d)
-
     def visit_assignment(self, tree):
         self.visit_children(tree)
 
@@ -427,11 +411,32 @@ class PrimitivesVisitor(Visitor):
 
             self.set_primitive(tree, (declare, assign))
 
+    def visit_vardecl(self, tree):
+        symbol = self.get_symbol(tree)
+
+        if symbol.is_global:
+            d = self.value(Action("global"))
+            n = self.value(symbol.name)
+        else:
+            d = self.value(Action("declare"))
+            n = self.node()
+
+        symbol.node = n
+        self.dict(d, "var", n)
+        self.debug(d, tree)
+
+        self.set_primitive(tree, d)
+
     def visit_definition(self, tree):
         symbol = self.get_symbol(tree)
-        root = self.value(symbol.name)
 
-        declare = self.value(Action("global"))
+        if symbol.is_global:
+            declare = self.value(Action("global"))
+            root = self.value(symbol.name)
+        else:
+            declare = self.value(Action("declare"))
+            root = self.node()
+
         self.dict(declare, "var", root)
         self.debug(declare, tree)