Stricter checking enforced on duplicate entries: do not redefine global symbol if already exists

interface/HUTN/hutn_compiler/constructors_object_visitor.py

@@ -49,6 +49,8 @@ class ConstructorsObjectVisitor(ConstructorsVisitor):
     def dump(self):
         v = ConstructorsVisitor.dump(self)
 
+        print("Constructors: " + str(v))
+
         import json
         # Set up interface
         urllib2.urlopen(urllib2.Request("http://localhost:8001/", urllib.urlencode({"op": "set_input", "element_type": "V", "value": '3', "username": self.username}))).read()

kernel/modelverse_kernel/main.py

@@ -938,8 +938,13 @@ class ModelverseKernel(object):
                                ("CN", []),
                                ("CNV", ["finish"]),
                               ]
-        new_edge =      yield [("CE", [global_symbols, empty_node])]
-        _, _, _ =       yield [("CE", [new_edge, new_var]),
-                               ("CD", [user_frame, "phase", new_phase]),
-                               ("DE", [phase_link]),
+
+        value = yield [("RV", [new_var])]
+        exists = yield [("RD", [global_symbols, value])]
+
+        if exists is None:
+            yield [("CD", [global_symbols, value, empty_node])]
+
+        _, _ =          yield [("CD", [user_frame, "phase", new_phase]),
+                               ("DE", [phase_link])
                               ]

kernel/modelverse_kernel/primitives.py

@@ -339,9 +339,7 @@ def list_len(a, **remainder):
     raise PrimitiveFinished(result)
 
 def dict_add(a, b, c, **remainder):
-    is_here, new_edge = yield [("RD", [a, b]), ("CE", [a, c])]
-    if is_here is not None:
-        raise Exception("dict_add on existing value!")
+    new_edge = yield [("CE", [a, c])]
     yield [("CE", [new_edge, b])]
     raise PrimitiveFinished(a)
 

kernel/test/instructions/test_instruction_declare.py

@@ -43,7 +43,7 @@ class TestDeclare(unittest.TestCase):
     def test_global(self):
         self.global_symbols = self.mvs.execute("RD", [self.user_root, "globals"])[0]
         self.inst = self.mvs.execute("CNV", [{"value":"global"}])[0]
-        self.var = self.mvs.execute("CN", [])[0]
+        self.var = self.mvs.execute("CNV", ["abc"])[0]
 
         self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
@@ -55,4 +55,4 @@ class TestDeclare(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "global")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertNotEquals(self.mvs.execute("RDN", [self.global_symbols, self.var])[0], None)
+        self.assertNotEquals(self.mvs.execute("RD", [self.global_symbols, "abc"])[0], None)

kernel/test/rules/test_rules_call.py

@@ -57,7 +57,6 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [inst, "func", func])
         self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [inst, "params", params])
-        self.mvs.execute("CD", [inst, "func", func])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)

kernel/test/rules/test_rules_resolve.py

@@ -57,7 +57,6 @@ class Testresolve(unittest.TestCase):
 
         self.mvs.execute("CD", [root, "user_1", user_root])
         self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_root, "globals", _globals])
         self.mvs.execute("CD", [user_frame, "phase", phase])
         self.mvs.execute("CD", [user_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "var", var_inst])

make_all.sh

@@ -6,7 +6,7 @@ shift
 
 for f in "$@"
 do
-    ./compile.sh $f $RANDOM $f PO
+    ./compile.sh $f $RANDOM $f CO
 done
 
 ./link_and_load.sh $username "$@"

state/modelverse_state/main.py

@@ -196,7 +196,8 @@ class ModelverseState(object):
             return (None, {status.FAIL_RDICTE_UNKNOWN: status.FAIL_RDICT_UNKNOWN,
                            status.FAIL_RDICTE_UNCERTAIN: status.FAIL_RDICT_UNCERTAIN,
                            status.FAIL_RDICTE_OOB: status.FAIL_RDICT_OOB,
-                           status.FAIL_RDICTE_NOT_FOUND: status.FAIL_RDICT_NOT_FOUND}[s])
+                           status.FAIL_RDICTE_NOT_FOUND: status.FAIL_RDICT_NOT_FOUND,
+                           status.FAIL_RDICTE_AMBIGUOUS: status.FAIL_RDICT_AMBIGUOUS}[s])
         return (self.edges[e][1], status.SUCCESS)
 
     def read_dict_keys(self, node):
@@ -216,6 +217,7 @@ class ModelverseState(object):
             return (None, status.FAIL_RDICTE_OOB)
             
         # Get all outgoing links
+        found = None
         for e1 in self.outgoing.get(node, set()):
             data_links = self.outgoing.get(e1, set())
             # For each link, we read the links that might link to a data value
@@ -230,14 +232,21 @@ class ModelverseState(object):
                     if len(data_links) > 1:
                         return (None, status.FAIL_RDICTE_UNCERTAIN)
                     else:
-                        return (e1, status.SUCCESS)
-        return (None, status.FAIL_RDICTE_NOT_FOUND)
+                        if found is not None:
+                            #raise Exception("Duplicate key: %s (%s <-> %s)!" % (v, found, e1))
+                            return (None, status.FAIL_RDICTE_AMBIGUOUS)
+                        found = e1
+        if found is not None:
+            return (found, status.SUCCESS)
+        else:
+            return (None, status.FAIL_RDICTE_NOT_FOUND)
 
     def read_dict_node(self, node, value_node):
         e, s = self.read_dict_node_edge(node, value_node)
         if s != status.SUCCESS:
             return (None, {status.FAIL_RDICTNE_UNKNOWN: status.FAIL_RDICTN_UNKNOWN,
                            status.FAIL_RDICTNE_UNCERTAIN: status.FAIL_RDICTN_UNCERTAIN,
+                           status.FAIL_RDICTNE_AMBIGUOUS: status.FAIL_RDICTN_AMBIGUOUS,
                            status.FAIL_RDICTNE_OOB: status.FAIL_RDICTN_OOB,
                            status.FAIL_RDICTNE_NOT_FOUND: status.FAIL_RDICTN_NOT_FOUND}[s])
         return (self.edges[e][1], status.SUCCESS)
@@ -245,7 +254,9 @@ class ModelverseState(object):
     def read_dict_node_edge(self, node, value_node):
         if node not in self.nodes and node not in self.edges:
             return (None, status.FAIL_RDICTNE_UNKNOWN)
+
         # Get all outgoing links
+        found = None
         for e1 in self.outgoing.get(node, set()):
             data_links = self.outgoing.get(e1, set())
             # For each link, we read the links that might link to a data value
@@ -259,8 +270,14 @@ class ModelverseState(object):
                     if len(data_links) > 1:
                         return (None, status.FAIL_RDICTNE_UNCERTAIN)
                     else:
-                        return (e1, status.SUCCESS)
-        return (None, status.FAIL_RDICTNE_NOT_FOUND)
+                        if found is not None:
+                            #raise Exception("Duplicate key: %s (%s <-> %s)!" % (value_node, found, e1))
+                            return (None, status.FAIL_RDICTNE_AMBIGUOUS)
+                        found = e1
+        if found is not None:
+            return (found, status.SUCCESS)
+        else:
+            return (None, status.FAIL_RDICTNE_NOT_FOUND)
 
     def read_reverse_dict(self, node, value):
         if node not in self.nodes and node not in self.edges:

state/modelverse_state/status.py

@@ -67,18 +67,22 @@ FAIL_RV_NO_VALUE = 300
 ##### Read Dictionary #####
 FAIL_RDICT_NOT_FOUND = 301
 FAIL_RDICT_UNCERTAIN = 302
+FAIL_RDICT_AMBIGUOUS = 311
 
 ##### Read Dictionary Node #####
 FAIL_RDICTN_NOT_FOUND = 303
 FAIL_RDICTN_UNCERTAIN = 304
+FAIL_RDICTN_AMBIGUOUS = 313
 
 ##### Read Dictionary Edge #####
 FAIL_RDICTE_NOT_FOUND = 305
 FAIL_RDICTE_UNCERTAIN = 306
+FAIL_RDICTE_AMBIGUOUS = 312
 
 ##### Read Dictionary Node Edge #####
 FAIL_RDICTNE_NOT_FOUND = 307
 FAIL_RDICTNE_UNCERTAIN = 308
+FAIL_RDICTNE_AMBIGUOUS = 314
 
 ##### Read Reverse Dictionary #####
 FAIL_RRDICT_NOT_FOUND = 309

state/test/test_read_dict.py

@@ -123,9 +123,8 @@ class TestReadDict(unittest.TestCase):
         self.assertEquals(r, status.SUCCESS)
 
         l, r = self.mvs.read_dict(a, "f")
-        self.assertEquals(r, status.SUCCESS)
-        # Result is ambiguous, but is either of these
-        self.assertTrue(l == b or l == g)
+        self.assertEquals(l, None)
+        self.assertEquals(r, status.FAIL_RDICT_AMBIGUOUS)
 
     def test_read_dict_node_uncertain(self):
         a, r = self.mvs.create_node()

state/test/test_read_dict_edge.py

@@ -131,9 +131,8 @@ class TestReadDictEdge(unittest.TestCase):
         self.assertEquals(r, status.SUCCESS)
 
         l, r = self.mvs.read_dict_edge(a, "f")
-        self.assertEquals(r, status.SUCCESS)
-        # Result is ambiguous, but is either of these
-        self.assertTrue(l == d or l == i)
+        self.assertEquals(l, None)
+        self.assertEquals(r, status.FAIL_RDICTE_AMBIGUOUS)
 
     def test_read_dict_edge_node_uncertain(self):
         a, r = self.mvs.create_node()

state/test/test_read_dict_node.py

@@ -99,9 +99,8 @@ class TestReadDictNode(unittest.TestCase):
         self.assertEquals(r, status.SUCCESS)
 
         l, r = self.mvs.read_dict_node(a, c)
-        self.assertEquals(r, status.SUCCESS)
-        # Result is ambiguous, but is either of these
-        self.assertTrue(l == b or l == g)
+        self.assertEquals(r, status.FAIL_RDICTN_AMBIGUOUS)
+        self.assertEquals(l, None)
 
     def test_read_dict_node_uncertain(self):
         a, r = self.mvs.create_node()