Merge declare and define in one rule

bootstrap/constructors.alc

@@ -76,40 +76,49 @@ Action function construct_global():
 	declared_element = input()
 	dict_add_fast(this_element, "var", declared_element)
 
-	// Defines
-	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)
-
-	Element result
-	result = create_node()
-	dict_add_fast(result, "name", "")
-	dict_add_fast(result, "instruction", this_element)
-	dict_add_fast(result, "start", this_element)
-	dict_add_fast(result, "end", assign)
-	return result!
+	if (op != "none"):
+		// Defines
+		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)
+		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)
+
+		Element result
+		result = create_node()
+		dict_add_fast(result, "name", "")
+		dict_add_fast(result, "instruction", this_element)
+		dict_add_fast(result, "start", this_element)
+		dict_add_fast(result, "end", assign)
+		return result!
+	else:
+		Element result
+		result = create_node()
+		dict_add_fast(result, "name", "")
+		dict_add_fast(result, "instruction", this_element)
+		dict_add_fast(result, "start", this_element)
+		dict_add_fast(result, "end", this_element)
+		return result!
 
 Action function construct_funcdef(mutable : Boolean):
 	Action assign
@@ -329,34 +338,38 @@ Action function construct_declare():
 	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(assign, "next", construct_unknown())
+	if (op != "none"):
+		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)
+		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(assign, "next", construct_unknown())
+	else:
+		if (input()):
+			dict_add_fast(this_element, "next", construct_unknown())
 	return this_element!
 
 Action function construct_input():

interface/HUTN/grammars/actionlanguage.g

@@ -1,9 +1,8 @@
 grammar{
-    start: (include | vardecl | definition | funcdecl | newline)+;
+    start: (include | definition | funcdecl | newline)+;
 
     statement 
-        : (vardecl newline)
-        | (definition newline)
+        : (definition newline)
         | (assignment newline)
         | (return newline)
         | (func_call newline)
@@ -65,15 +64,13 @@ grammar{
         : (rvalue LSQUARE expression RSQUARE)
         | ID;
 
-    vardecl: type_specifier ID;
-
 	logical_not: NOT primary;
 
 	invert_sign: MINUS primary;
 
 	keep_sign: PLUS primary;
 
-    definition : type_specifier ID ASSIGN atomvalue;
+    definition : type_specifier ID (ASSIGN atomvalue)?;
 
     include: INCLUDE STRVALUE newline+;
 

interface/HUTN/hutn_compiler/constructors_visitor.py

@@ -278,25 +278,22 @@ class ConstructorsVisitor(Visitor):
         symbol = self.get_symbol(tree)
         self.declare(symbol)
 
-        # Determine whether it is just a constant, or a deref
-        atom = tree.get_child("atomvalue")
-        if atom.get_child("deref"):
-            # Deref
-            dest = atom.get_child("deref").get_child("ANYTHING")
-            if dest is None:
-                # Just an empty questionmark!
-                self.add_constructors("empty")
+        if tree.get_children("ASSIGN"):
+            # Determine whether it is just a constant, or a deref
+            atom = tree.get_child("atomvalue")
+            if atom.get_child("deref"):
+                # Deref
+                dest = atom.get_child("deref").get_child("ANYTHING")
+                if dest is None:
+                    # Just an empty questionmark!
+                    self.add_constructors("empty")
+                else:
+                    self.add_constructors("deref", dest.get_text())
             else:
-                self.add_constructors("deref", dest.get_text())
+                # Constant
+                self.visit(atom)
         else:
-            # Constant
-            self.visit(atom)
-        return True
-
-    def visit_vardecl(self, tree):
-        symbol = self.get_symbol(tree)
-        self.declare(symbol)
+            # TODO empty is not really the same as undefined!
+            self.add_constructors("empty")
 
-        # vardecl means it is empty
-        self.add_constructors("empty")
         return True

interface/HUTN/hutn_compiler/primitives_visitor.py

@@ -411,22 +411,6 @@ 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)
 
@@ -442,27 +426,29 @@ class PrimitivesVisitor(Visitor):
 
         symbol.node = root
 
-        resolve = self.value(Action("resolve"))
-        self.dict(resolve, "var", root)
-
-        assign = self.value(Action("assign"))
-        self.dict(assign, "var", resolve)
+        if tree.get_children("ASSIGN"):
+            resolve = self.value(Action("resolve"))
+            self.dict(resolve, "var", root)
 
-        self.visit_atomvalue(tree.get_tail()[-1])
-        value = self.get_primitive(tree.get_tail()[-1])
+            assign = self.value(Action("assign"))
+            self.dict(assign, "var", resolve)
 
-        if value is None:
-            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"))
-            value = call
+            self.visit_atomvalue(tree.get_tail()[-1])
+            value = self.get_primitive(tree.get_tail()[-1])
 
-        self.dict(assign, "value", value)
+            if value is None:
+                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"))
+                value = call
 
-        self.set_primitive(tree, (declare, assign))
+            self.dict(assign, "value", value)
+            self.set_primitive(tree, (declare, assign))
+        else:
+            self.set_primitive(tree, (declare, declare))
 
     def visit_parameter(self, tree):
         n = self.node()