Browse Source

Ported all scripts to Python

Yentl Van Tendeloo 5 years ago
parent
commit
fc13b47ac3
6 changed files with 324 additions and 339 deletions
  1. 290 289
      bootstrap/bootstrap.py
  2. 0 20
      run_tests.bat
  3. 0 22
      run_tests.sh
  4. 11 7
      scripts/flush_compiler_caches.py
  5. 5 1
      scripts/generate_bootstrap.py
  6. 18 0
      scripts/run_tests.py

+ 290 - 289
bootstrap/bootstrap.py

@@ -1,321 +1,322 @@
 ### Configuration for creating the bootstrap model using conformance_bottom.
 
-root = ["__hierarchy"]
+def bootstrap():
+    root = ["__hierarchy"]
 
-user_data = [   "input",
-                "output",
-                "globals",
-                "frame",
-                ]
+    user_data = [   "input",
+                    "output",
+                    "globals",
+                    "frame",
+                    ]
 
-user_frame = [  "evalstack",
-                "symbols",
-                "returnvalue",
-                ]
+    user_frame = [  "evalstack",
+                    "symbols",
+                    "returnvalue",
+                    ]
 
-primitives = {  "integer_addition": ["Integer", "Integer", "Integer"],
-                "integer_subtraction": ["Integer", "Integer", "Integer"],
-                "integer_multiplication": ["Integer", "Integer", "Integer"],
-                "integer_division": ["Integer", "Integer", "Integer"],
-                "integer_gt": ["Boolean", "Integer", "Integer"],
-                "integer_gte": ["Boolean", "Integer", "Integer"],
-                "integer_lt": ["Boolean", "Integer", "Integer"],
-                "integer_lte": ["Boolean", "Integer", "Integer"],
-                "integer_neg": ["Integer", "Integer"],
-                "float_addition": ["Float", "Float", "Float"],
-                "float_subtraction": ["Float", "Float", "Float"],
-                "float_multiplication": ["Float", "Float", "Float"],
-                "float_division": ["Float", "Float", "Float"],
-                "float_gt": ["Boolean", "Float", "Float"],
-                "float_gte": ["Boolean", "Float", "Float"],
-                "float_lt": ["Boolean", "Float", "Float"],
-                "float_lte": ["Boolean", "Float", "Float"],
-                "float_neg": ["Float", "Float"],
-                "bool_and": ["Boolean", "Boolean", "Boolean"],
-                "bool_or": ["Boolean", "Boolean", "Boolean"],
-                "bool_not": ["Boolean", "Boolean"],
-                "string_join": ["String", "String", "String"],
-                "string_get": ["String", "String", "Integer"],
-                "string_substr": ["String", "String", "Integer", "Integer"],
-                "string_len": ["Integer", "String"],
-                "string_split": ["Element", "String", "String"],
-                "string_startswith": ["Boolean", "String", "String"],
-                "value_eq":  ["Boolean", "Element", "Element"],
-                "value_neq": ["Boolean", "Element", "Element"],
-                "cast_i2f": ["Float", "Integer"],
-                "cast_i2s": ["String", "Integer"],
-                "cast_i2b": ["Boolean", "Integer"],
-                "cast_f2i": ["Integer", "Float"],
-                "cast_f2b": ["Boolean", "Float"],
-                "cast_f2s": ["String", "Float"],
-                "cast_s2i": ["Integer", "String"],
-                "cast_s2f": ["Float", "String"],
-                "cast_s2b": ["Boolean", "String"],
-                "cast_b2i": ["Integer", "Boolean"],
-                "cast_b2f": ["Float", "Boolean"],
-                "cast_b2s": ["String", "Boolean"],
-                "cast_e2s": ["String", "Element"],
-                "cast_a2s": ["String", "Action"],
-                "cast_v2s": ["String", "Element"],
-                "cast_id2s": ["String", "Element"],
-                "list_read": ["Element", "Element", "Integer"],
-                "list_append": ["Element", "Element", "Element"],
-                "list_insert": ["Element", "Element", "Integer", "Element"],
-                "list_delete": ["Element", "Element", "Integer"],
-                "list_len": ["Integer", "Element"],
-                "dict_add": ["Element", "Element", "Element", "Element"],
-                "dict_delete": ["Element", "Element", "Element"],
-                "dict_read": ["Element", "Element", "Element"],
-                "dict_read_edge": ["Element", "Element", "Element"],
-                "dict_read_node": ["Element", "Element", "Element"],
-                "dict_len": ["Integer", "Element"],
-                "dict_in": ["Boolean", "Element", "Element"],
-                "dict_in_node": ["Boolean", "Element", "Element"],
-                "dict_keys": ["Element", "Element"],
-                "set_add": ["Element", "Element", "Element"],
-                "set_pop": ["Element", "Element"],
-                "set_remove": ["Element", "Element", "Element"],
-                "set_remove_node": ["Element", "Element", "Element"],
-                "set_in": ["Boolean", "Element", "Element"],
-                "set_in_node": ["Boolean", "Element", "Element"],
-                "is_physical_int": ["Boolean", "Element"],
-                "is_physical_boolean": ["Boolean", "Element"],
-                "is_physical_string": ["Boolean", "Element"],
-                "is_physical_action": ["Boolean", "Element"],
-                "is_physical_float": ["Boolean", "Element"],
-                "has_value": ["Boolean", "Element"],
-                "create_node": ["Element"],
-                "create_edge": ["Element", "Element", "Element"],
-                "create_value": ["Element", "Element"],
-                "is_edge": ["Boolean", "Element"],
-                "read_nr_out": ["Integer", "Element"],
-                "read_out": ["Element", "Element", "Integer"],
-                "read_nr_in": ["Integer", "Element"],
-                "read_in": ["Element", "Element", "Integer"],
-                "read_edge_src": ["Element", "Element"],
-                "read_edge_dst": ["Element", "Element"],
-                "delete_element": ["Element", "Element"],
-                "element_eq": ["Boolean", "Element", "Element"],
-                "element_neq": ["Boolean", "Element", "Element"],
-                "read_root": ["Element"],
-                "deserialize": ["Element", "String"],
-                "log": ["String", "String"],
-            }
+    primitives = {  "integer_addition": ["Integer", "Integer", "Integer"],
+                    "integer_subtraction": ["Integer", "Integer", "Integer"],
+                    "integer_multiplication": ["Integer", "Integer", "Integer"],
+                    "integer_division": ["Integer", "Integer", "Integer"],
+                    "integer_gt": ["Boolean", "Integer", "Integer"],
+                    "integer_gte": ["Boolean", "Integer", "Integer"],
+                    "integer_lt": ["Boolean", "Integer", "Integer"],
+                    "integer_lte": ["Boolean", "Integer", "Integer"],
+                    "integer_neg": ["Integer", "Integer"],
+                    "float_addition": ["Float", "Float", "Float"],
+                    "float_subtraction": ["Float", "Float", "Float"],
+                    "float_multiplication": ["Float", "Float", "Float"],
+                    "float_division": ["Float", "Float", "Float"],
+                    "float_gt": ["Boolean", "Float", "Float"],
+                    "float_gte": ["Boolean", "Float", "Float"],
+                    "float_lt": ["Boolean", "Float", "Float"],
+                    "float_lte": ["Boolean", "Float", "Float"],
+                    "float_neg": ["Float", "Float"],
+                    "bool_and": ["Boolean", "Boolean", "Boolean"],
+                    "bool_or": ["Boolean", "Boolean", "Boolean"],
+                    "bool_not": ["Boolean", "Boolean"],
+                    "string_join": ["String", "String", "String"],
+                    "string_get": ["String", "String", "Integer"],
+                    "string_substr": ["String", "String", "Integer", "Integer"],
+                    "string_len": ["Integer", "String"],
+                    "string_split": ["Element", "String", "String"],
+                    "string_startswith": ["Boolean", "String", "String"],
+                    "value_eq":  ["Boolean", "Element", "Element"],
+                    "value_neq": ["Boolean", "Element", "Element"],
+                    "cast_i2f": ["Float", "Integer"],
+                    "cast_i2s": ["String", "Integer"],
+                    "cast_i2b": ["Boolean", "Integer"],
+                    "cast_f2i": ["Integer", "Float"],
+                    "cast_f2b": ["Boolean", "Float"],
+                    "cast_f2s": ["String", "Float"],
+                    "cast_s2i": ["Integer", "String"],
+                    "cast_s2f": ["Float", "String"],
+                    "cast_s2b": ["Boolean", "String"],
+                    "cast_b2i": ["Integer", "Boolean"],
+                    "cast_b2f": ["Float", "Boolean"],
+                    "cast_b2s": ["String", "Boolean"],
+                    "cast_e2s": ["String", "Element"],
+                    "cast_a2s": ["String", "Action"],
+                    "cast_v2s": ["String", "Element"],
+                    "cast_id2s": ["String", "Element"],
+                    "list_read": ["Element", "Element", "Integer"],
+                    "list_append": ["Element", "Element", "Element"],
+                    "list_insert": ["Element", "Element", "Integer", "Element"],
+                    "list_delete": ["Element", "Element", "Integer"],
+                    "list_len": ["Integer", "Element"],
+                    "dict_add": ["Element", "Element", "Element", "Element"],
+                    "dict_delete": ["Element", "Element", "Element"],
+                    "dict_read": ["Element", "Element", "Element"],
+                    "dict_read_edge": ["Element", "Element", "Element"],
+                    "dict_read_node": ["Element", "Element", "Element"],
+                    "dict_len": ["Integer", "Element"],
+                    "dict_in": ["Boolean", "Element", "Element"],
+                    "dict_in_node": ["Boolean", "Element", "Element"],
+                    "dict_keys": ["Element", "Element"],
+                    "set_add": ["Element", "Element", "Element"],
+                    "set_pop": ["Element", "Element"],
+                    "set_remove": ["Element", "Element", "Element"],
+                    "set_remove_node": ["Element", "Element", "Element"],
+                    "set_in": ["Boolean", "Element", "Element"],
+                    "set_in_node": ["Boolean", "Element", "Element"],
+                    "is_physical_int": ["Boolean", "Element"],
+                    "is_physical_boolean": ["Boolean", "Element"],
+                    "is_physical_string": ["Boolean", "Element"],
+                    "is_physical_action": ["Boolean", "Element"],
+                    "is_physical_float": ["Boolean", "Element"],
+                    "has_value": ["Boolean", "Element"],
+                    "create_node": ["Element"],
+                    "create_edge": ["Element", "Element", "Element"],
+                    "create_value": ["Element", "Element"],
+                    "is_edge": ["Boolean", "Element"],
+                    "read_nr_out": ["Integer", "Element"],
+                    "read_out": ["Element", "Element", "Integer"],
+                    "read_nr_in": ["Integer", "Element"],
+                    "read_in": ["Element", "Element", "Integer"],
+                    "read_edge_src": ["Element", "Element"],
+                    "read_edge_dst": ["Element", "Element"],
+                    "delete_element": ["Element", "Element"],
+                    "element_eq": ["Boolean", "Element", "Element"],
+                    "element_neq": ["Boolean", "Element", "Element"],
+                    "read_root": ["Element"],
+                    "deserialize": ["Element", "String"],
+                    "log": ["String", "String"],
+                }
 
-initial_user = "user_manager"
-initial_user_code = \
-'''
-Element function read_root() = ?primitives/read_root
-Element function dict_read(a: Element, b: Element) = ?primitives/dict_read
-Element function create_node() = ?primitives/create_node
-Element function create_value(a: Element) = ?primitives/create_value
-Element function dict_add(a: Element, b: Element, c: Element) = ?primitives/dict_add
-Boolean function value_eq(a: String, b: String) = ?primitives/value_eq
-Boolean function delete_element(a: Element) = ?primitives/delete_element
-Boolean function bool_not(a: Boolean) = ?primitives/bool_not
-Boolean function dict_in(a: Element, b: Element) = ?primitives/dict_in
+    initial_user = "user_manager"
+    initial_user_code = \
+    '''
+    Element function read_root() = ?primitives/read_root
+    Element function dict_read(a: Element, b: Element) = ?primitives/dict_read
+    Element function create_node() = ?primitives/create_node
+    Element function create_value(a: Element) = ?primitives/create_value
+    Element function dict_add(a: Element, b: Element, c: Element) = ?primitives/dict_add
+    Boolean function value_eq(a: String, b: String) = ?primitives/value_eq
+    Boolean function delete_element(a: Element) = ?primitives/delete_element
+    Boolean function bool_not(a: Boolean) = ?primitives/bool_not
+    Boolean function dict_in(a: Element, b: Element) = ?primitives/dict_in
 
-Element function input()
+    Element function input()
 
-Void function __main():
-\tString username
-\tElement user_root
-\tElement user_frame
-\tElement output_value
-\tElement input_value
-\t
-\twhile (True):
-\t\tusername = input()
-\t\tif (value_eq(username, "__delete")):
-\t\t\tuser_root = dict_read(read_root(), input())
-\t\t\tdelete_element(user_root)
-\t\telse:
-\t\t\tif (bool_not(dict_in(read_root(), username))):
-\t\t\t\tuser_root = create_node()
-\t\t\t\tuser_frame = create_node()
-\t\t\t\toutput_value = create_node()
-\t\t\t\tinput_value = create_node()
-\t\t\t\tdict_add(user_root, "frame", user_frame)
-\t\t\t\tdict_add(user_root, "globals", create_node())
-\t\t\t\tdict_add(user_root, "output", output_value)
-\t\t\t\tdict_add(user_root, "last_output", output_value)
-\t\t\t\tdict_add(user_root, "input", input_value)
-\t\t\t\tdict_add(user_root, "last_input", input_value)
-\t\t\t\tdict_add(user_frame, "evalstack", create_node())
-\t\t\t\tdict_add(user_frame, "returnvalue", create_node())
-\t\t\t\tdict_add(user_frame, "phase", "init")
-\t\t\t\tdict_add(user_frame, "IP", dict_read(dict_read(read_root(), "__hierarchy"), "__IP"))
-\t\t\t\tdict_add(user_frame, "symbols", create_node())
-\t\t\t\t//Add this only at the end, as otherwise the user will already be detected
-\t\t\t\tdict_add(read_root(), username, user_root)
-'''
+    Void function __main():
+    \tString username
+    \tElement user_root
+    \tElement user_frame
+    \tElement output_value
+    \tElement input_value
+    \t
+    \twhile (True):
+    \t\tusername = input()
+    \t\tif (value_eq(username, "__delete")):
+    \t\t\tuser_root = dict_read(read_root(), input())
+    \t\t\tdelete_element(user_root)
+    \t\telse:
+    \t\t\tif (bool_not(dict_in(read_root(), username))):
+    \t\t\t\tuser_root = create_node()
+    \t\t\t\tuser_frame = create_node()
+    \t\t\t\toutput_value = create_node()
+    \t\t\t\tinput_value = create_node()
+    \t\t\t\tdict_add(user_root, "frame", user_frame)
+    \t\t\t\tdict_add(user_root, "globals", create_node())
+    \t\t\t\tdict_add(user_root, "output", output_value)
+    \t\t\t\tdict_add(user_root, "last_output", output_value)
+    \t\t\t\tdict_add(user_root, "input", input_value)
+    \t\t\t\tdict_add(user_root, "last_input", input_value)
+    \t\t\t\tdict_add(user_frame, "evalstack", create_node())
+    \t\t\t\tdict_add(user_frame, "returnvalue", create_node())
+    \t\t\t\tdict_add(user_frame, "phase", "init")
+    \t\t\t\tdict_add(user_frame, "IP", dict_read(dict_read(read_root(), "__hierarchy"), "__IP"))
+    \t\t\t\tdict_add(user_frame, "symbols", create_node())
+    \t\t\t\t//Add this only at the end, as otherwise the user will already be detected
+    \t\t\t\tdict_add(read_root(), username, user_root)
+    '''
 
-code_new_users = \
-'''
-Element main
+    code_new_users = \
+    '''
+    Element main
 
-// Do this only in the bootstrapper
-include "io.alh"
-include "primitives.alc"
-include "compilation_manager.alc"
-include "constructors.alc"
-include "object_operations.alc"
-include "library.alc"
-include "conformance_scd.alc"
-include "modelling.alc"
+    // Do this only in the bootstrapper
+    include "io.alh"
+    include "primitives.alc"
+    include "compilation_manager.alc"
+    include "constructors.alc"
+    include "object_operations.alc"
+    include "library.alc"
+    include "conformance_scd.alc"
+    include "modelling.alc"
 
-Void function __main():
-\tInteger interface
-\twhile (True):
-\t\tlog("User interface select")
-\t\tinterface = input()
-\t\tif (interface == 0):
-\t\t\tlog("DO deserialize")
-\t\t\texec(deserialize(input()))
-\t\telif (interface == 1):
-\t\t\tlog("User entered constructors")
-\t\t\texec(construct_unknown())
-\t\telif (interface == 2):
-\t\t\tlog("Done signalled")
-\t\t\toutput("DONE")
-\t\telif (interface == 3):
-\t\t\tcompilation_manager()
-\t\telse:
-\t\t\tlog("Unsupported interface!")
-'''
+    Void function __main():
+    \tInteger interface
+    \twhile (True):
+    \t\tlog("User interface select")
+    \t\tinterface = input()
+    \t\tif (interface == 0):
+    \t\t\tlog("DO deserialize")
+    \t\t\texec(deserialize(input()))
+    \t\telif (interface == 1):
+    \t\t\tlog("User entered constructors")
+    \t\t\texec(construct_unknown())
+    \t\telif (interface == 2):
+    \t\t\tlog("Done signalled")
+    \t\t\toutput("DONE")
+    \t\telif (interface == 3):
+    \t\t\tcompilation_manager()
+    \t\telse:
+    \t\t\tlog("Unsupported interface!")
+    '''
 
-### Actual script to generate the file
-import os
-import sys
+    ### Actual script to generate the file
+    import os
+    import sys
 
-class Writer(object):
-    def __init__(self, file_a, file_b):
-        self.file_a = file_a
-        self.file_b = file_b
+    class Writer(object):
+        def __init__(self, file_a, file_b):
+            self.file_a = file_a
+            self.file_b = file_b
 
-    def write(self, text, both=True):
-        self.file_a.write(text)
-        if both:
-            self.file_b.write(text)
+        def write(self, text, both=True):
+            self.file_a.write(text)
+            if both:
+                self.file_b.write(text)
 
-try:
-    with open("bootstrap/bootstrap.m", "w") as fa:
-        with open("bootstrap/minimal.m", "w") as fb:
-            f = Writer(fa, fb)
-            # Create the root first
-            f.write("Node root()\n")
+    try:
+        with open("bootstrap/bootstrap.m", "w") as fa:
+            with open("bootstrap/minimal.m", "w") as fb:
+                f = Writer(fa, fb)
+                # Create the root first
+                f.write("Node root()\n")
 
-            # Create all children of the root
-            for node in root:
-                f.write("Node %s()\n" % node)
-                f.write("Edge _%s(root, %s)\n" % (node, node))
-                f.write('Node __%s("%s")\n' % (node, node))
-                f.write("Edge ___%s(_%s, __%s)\n" % (node, node, node))
+                # Create all children of the root
+                for node in root:
+                    f.write("Node %s()\n" % node)
+                    f.write("Edge _%s(root, %s)\n" % (node, node))
+                    f.write('Node __%s("%s")\n' % (node, node))
+                    f.write("Edge ___%s(_%s, __%s)\n" % (node, node, node))
 
-            f.write("Node primitives()\n")
-            f.write("Edge _primitives(__hierarchy, primitives)\n")
-            f.write('Node __primitives("primitives")\n')
-            f.write("Edge ___primitives(_primitives, __primitives)\n")
+                f.write("Node primitives()\n")
+                f.write("Edge _primitives(__hierarchy, primitives)\n")
+                f.write('Node __primitives("primitives")\n')
+                f.write("Edge ___primitives(_primitives, __primitives)\n")
 
-            # Define all primitive functions
-            for function, parameters in primitives.iteritems():
-                #if parameters[0] == "Element":
-                #    f.write("Node _type_%s()\n" % function)
-                #else:
-                #    f.write("Node _type_%s(%s)\n" % (function, parameters[0]))
-                    
-                f.write("Node _func_signature_%s()\n" % function)
-                f.write("Node _func_params_%s()\n" % function)
-                f.write("Node _func_body_%s()\n" % function)
-                f.write("Edge _primitives_%s(primitives, _func_signature_%s)\n" % (function, function))
-                f.write('Node _name_%s("%s")\n' % (function, function))
-                f.write("Edge _primitives_name_%s(_primitives_%s, _name_%s)\n" % (function, function, function))
+                # Define all primitive functions
+                for function, parameters in primitives.iteritems():
+                    #if parameters[0] == "Element":
+                    #    f.write("Node _type_%s()\n" % function)
+                    #else:
+                    #    f.write("Node _type_%s(%s)\n" % (function, parameters[0]))
+                        
+                    f.write("Node _func_signature_%s()\n" % function)
+                    f.write("Node _func_params_%s()\n" % function)
+                    f.write("Node _func_body_%s()\n" % function)
+                    f.write("Edge _primitives_%s(primitives, _func_signature_%s)\n" % (function, function))
+                    f.write('Node _name_%s("%s")\n' % (function, function))
+                    f.write("Edge _primitives_name_%s(_primitives_%s, _name_%s)\n" % (function, function, function))
 
-                f.write('Node _body_%s("body")\n' % function)
-                f.write("Edge _signature_body_%s(_func_signature_%s, _func_body_%s)\n" % (function, function, function))
-                f.write("Edge _signature_body_str_%s(_signature_body_%s, _body_%s)\n" % (function, function, function))
+                    f.write('Node _body_%s("body")\n' % function)
+                    f.write("Edge _signature_body_%s(_func_signature_%s, _func_body_%s)\n" % (function, function, function))
+                    f.write("Edge _signature_body_str_%s(_signature_body_%s, _body_%s)\n" % (function, function, function))
 
-                f.write('Node _params_%s("params")\n' % function)
-                f.write("Edge _signature_params_%s(_func_signature_%s, _func_params_%s)\n" % (function, function, function))
-                f.write("Edge _signature_params_str_%s(_signature_params_%s, _params_%s)\n" % (function, function, function))
+                    f.write('Node _params_%s("params")\n' % function)
+                    f.write("Edge _signature_params_%s(_func_signature_%s, _func_params_%s)\n" % (function, function, function))
+                    f.write("Edge _signature_params_str_%s(_signature_params_%s, _params_%s)\n" % (function, function, function))
 
-                #f.write('Node _type_str_%s("type")\n' % function)
-                #f.write("Edge _signature_type_%s(_func_signature_%s, _type_%s)\n" % (function, function, function))
-                #f.write("Edge _signature_type_str_%s(_signature_type_%s, _type_str_%s)\n" % (function, function, function))
+                    #f.write('Node _type_str_%s("type")\n' % function)
+                    #f.write("Edge _signature_type_%s(_func_signature_%s, _type_%s)\n" % (function, function, function))
+                    #f.write("Edge _signature_type_str_%s(_signature_type_%s, _type_str_%s)\n" % (function, function, function))
 
-                parameter_names = "abcdefghijklmnopqrstuvwxyz"
-                for number, param in enumerate(parameters[1:]):
-                    param_encoding = "%s_%s" % (function, parameter_names[number])
-                    #if param == "Element":
-                    #    f.write("Node _type_%s()\n" % param_encoding)
-                    #else:
-                    #    f.write("Node _type_%s(%s)\n" % (param_encoding, param))
+                    parameter_names = "abcdefghijklmnopqrstuvwxyz"
+                    for number, param in enumerate(parameters[1:]):
+                        param_encoding = "%s_%s" % (function, parameter_names[number])
+                        #if param == "Element":
+                        #    f.write("Node _type_%s()\n" % param_encoding)
+                        #else:
+                        #    f.write("Node _type_%s(%s)\n" % (param_encoding, param))
 
-                    f.write("Node _func_params_%s()\n" % (param_encoding))
-                    f.write('Node _name_%s("%s")\n' % (param_encoding, parameter_names[number]))
-                    f.write("Edge _param_link_%s(_func_params_%s, _func_params_%s)\n" % (param_encoding, function, param_encoding))
-                    f.write("Edge _param_link_str_%s(_param_link_%s, _name_%s)\n" % (param_encoding, param_encoding, param_encoding))
-                    f.write('Node _name_str_%s("name")\n' % param_encoding)
-                    f.write("Edge _param_name_%s(_func_params_%s, _name_%s)\n" % (param_encoding, param_encoding, param_encoding))
-                    f.write("Edge _param_name_str_%s(_param_name_%s, _name_str_%s)\n" % (param_encoding, param_encoding, param_encoding))
-                    #f.write('Node _type_str_%s("type")\n' % param_encoding)
-                    #f.write("Edge _param_type_%s(_func_params_%s, _type_%s)\n" % (param_encoding, param_encoding, param_encoding))
-                    #f.write("Edge _param_type_str_%s(_param_type_%s, _type_str_%s)\n" % (param_encoding, param_encoding, param_encoding))
+                        f.write("Node _func_params_%s()\n" % (param_encoding))
+                        f.write('Node _name_%s("%s")\n' % (param_encoding, parameter_names[number]))
+                        f.write("Edge _param_link_%s(_func_params_%s, _func_params_%s)\n" % (param_encoding, function, param_encoding))
+                        f.write("Edge _param_link_str_%s(_param_link_%s, _name_%s)\n" % (param_encoding, param_encoding, param_encoding))
+                        f.write('Node _name_str_%s("name")\n' % param_encoding)
+                        f.write("Edge _param_name_%s(_func_params_%s, _name_%s)\n" % (param_encoding, param_encoding, param_encoding))
+                        f.write("Edge _param_name_str_%s(_param_name_%s, _name_str_%s)\n" % (param_encoding, param_encoding, param_encoding))
+                        #f.write('Node _type_str_%s("type")\n' % param_encoding)
+                        #f.write("Edge _param_type_%s(_func_params_%s, _type_%s)\n" % (param_encoding, param_encoding, param_encoding))
+                        #f.write("Edge _param_type_str_%s(_param_type_%s, _type_str_%s)\n" % (param_encoding, param_encoding, param_encoding))
 
-            # Create the initial user
-            f.write("Node user_root()\n")
+                # Create the initial user
+                f.write("Node user_root()\n")
 
-            for data in user_data:
-                f.write("Node user_%s()\n" % data)
-                f.write('Node ___user_%s("%s")\n' % (data, data))
-                f.write("Edge _user_%s(user_root, user_%s)\n" % (data, data))
-                f.write("Edge __user_%s(_user_%s, ___user_%s)\n" % (data, data, data))
+                for data in user_data:
+                    f.write("Node user_%s()\n" % data)
+                    f.write('Node ___user_%s("%s")\n' % (data, data))
+                    f.write("Edge _user_%s(user_root, user_%s)\n" % (data, data))
+                    f.write("Edge __user_%s(_user_%s, ___user_%s)\n" % (data, data, data))
 
-            for data in user_frame:
-                f.write("Node user_%s()\n" % data)
-                f.write('Node ___user_%s("%s")\n' % (data, data))
-                f.write("Edge _user_%s(user_frame, user_%s)\n" % (data, data))
-                f.write("Edge __user_%s(_user_%s, ___user_%s)\n" % (data, data, data))
+                for data in user_frame:
+                    f.write("Node user_%s()\n" % data)
+                    f.write('Node ___user_%s("%s")\n' % (data, data))
+                    f.write("Edge _user_%s(user_frame, user_%s)\n" % (data, data))
+                    f.write("Edge __user_%s(_user_%s, ___user_%s)\n" % (data, data, data))
 
-            # Add last_input and last_output links
-            for data in ["input", "output"]:
-                f.write('Node ___user_last_%s("last_%s")\n' % (data, data))
-                f.write("Edge _user_last_%s(user_root, user_%s)\n" % (data, data))
-                f.write("Edge __user_last_%s(_user_last_%s, ___user_last_%s)\n" % (data, data, data))
-                
-            # Bind user to the root
-            f.write('Node ___new_user("%s")\n' % initial_user)
-            f.write("Edge _new_user(root, user_root)\n")
-            f.write("Edge __new_user(_new_user, ___new_user)\n")
+                # Add last_input and last_output links
+                for data in ["input", "output"]:
+                    f.write('Node ___user_last_%s("last_%s")\n' % (data, data))
+                    f.write("Edge _user_last_%s(user_root, user_%s)\n" % (data, data))
+                    f.write("Edge __user_last_%s(_user_last_%s, ___user_last_%s)\n" % (data, data, data))
+                    
+                # Bind user to the root
+                f.write('Node ___new_user("%s")\n' % initial_user)
+                f.write("Edge _new_user(root, user_root)\n")
+                f.write("Edge __new_user(_new_user, ___new_user)\n")
 
-            def compile_code_AL(code, target):
-                import sys
-                sys.path.append("interface/HUTN/")
-                from hutn_compiler.compiler import main as compile_code
+                def compile_code_AL(code, target):
+                    import sys
+                    sys.path.append("interface/HUTN/")
+                    from hutn_compiler.compiler import main as compile_code
 
-                with open("bootstrap/bootstrap.al", "w") as f:
-                    f.write(code)
-                code = compile_code("bootstrap/bootstrap.al", "interface/HUTN/grammars/actionlanguage.g", "BS", ["--debug"])
-                os.remove("bootstrap/bootstrap.al")
-                return code.replace("auto_initial_IP", target)
+                    with open("bootstrap/bootstrap.al", "w") as f:
+                        f.write(code)
+                    code = compile_code("bootstrap/bootstrap.al", "interface/HUTN/grammars/actionlanguage.g", "BS", ["--debug"])
+                    os.remove("bootstrap/bootstrap.al")
+                    return code.replace("auto_initial_IP", target)
 
-            # Create code for initial user
-            f.write(compile_code_AL(initial_user_code, "IP_initial"), both=False)
-            f.write('Node _IP_str("IP")\n', both=False)
-            f.write("Edge _user_frame(user_frame, IP_initial)\n", both=False)
-            f.write("Edge __user_frame(_user_frame, _IP_str)\n", both=False)
+                # Create code for initial user
+                f.write(compile_code_AL(initial_user_code, "IP_initial"), both=False)
+                f.write('Node _IP_str("IP")\n', both=False)
+                f.write("Edge _user_frame(user_frame, IP_initial)\n", both=False)
+                f.write("Edge __user_frame(_user_frame, _IP_str)\n", both=False)
 
-            f.write('Node __phase("init")\n', both=False)
-            f.write('Node __phase_str("phase")\n', both=False)
-            f.write("Edge _user_phase(user_frame, __phase)\n", both=False)
-            f.write("Edge __user_phase(_user_phase, __phase_str)\n", both=False)
+                f.write('Node __phase("init")\n', both=False)
+                f.write('Node __phase_str("phase")\n', both=False)
+                f.write("Edge _user_phase(user_frame, __phase)\n", both=False)
+                f.write("Edge __user_phase(_user_phase, __phase_str)\n", both=False)
 
-            # Create code for new users to start at
-            f.write(compile_code_AL(code_new_users, "IP_new"), both=False)
-            f.write('Node __IP_str("__IP")\n', both=False)
-            f.write("Edge _user_IP(__hierarchy, IP_new)\n", both=False)
-            f.write("Edge __user_IP(_user_IP, __IP_str)\n", both=False)
-except:
-    os.remove("bootstrap/bootstrap.m")
-    os.remove("bootstrap/minimal.m")
-    raise
+                # Create code for new users to start at
+                f.write(compile_code_AL(code_new_users, "IP_new"), both=False)
+                f.write('Node __IP_str("__IP")\n', both=False)
+                f.write("Edge _user_IP(__hierarchy, IP_new)\n", both=False)
+                f.write("Edge __user_IP(_user_IP, __IP_str)\n", both=False)
+    except:
+        os.remove("bootstrap/bootstrap.m")
+        os.remove("bootstrap/minimal.m")
+        raise

+ 0 - 20
run_tests.bat

@@ -1,20 +0,0 @@
-call flush_compiler_caches.bat
-
-cd state
-py.test
-cd ..
-
-call generate_bootstrap.bat
-
-cd kernel
-py.test
-cd ..
-
-call flush_compiler_caches.bat
-
-cd interface/HUTN
-py.test
-cd ../..
-
-py.test integration
-pause

+ 0 - 22
run_tests.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-set -e
-
-./flush_compiler_caches.sh
-
-cd state
-py.test
-cd ..
-
-./generate_bootstrap.sh
-
-cd kernel
-py.test
-cd ..
-
-./flush_compiler_caches.sh
-
-cd interface/HUTN
-py.test
-cd ../..
-
-py.test integration

+ 11 - 7
scripts/flush_compiler_caches.py

@@ -1,7 +1,11 @@
-import os, re, os.path
-pattern = "^.*\.pickle$"
-mypath = "."
-for root, dirs, files in os.walk(mypath):
-    for file in filter(lambda x: re.match(pattern, x), files):
-        print("Remove: %s" % os.path.join(root, file))
-        os.remove(os.path.join(root, file))
+def flush():
+    import os, re, os.path
+    pattern = "^.*\.pickle$"
+    mypath = "."
+    for root, dirs, files in os.walk(mypath):
+        for file in filter(lambda x: re.match(pattern, x), files):
+            print("Remove: %s" % os.path.join(root, file))
+            os.remove(os.path.join(root, file))
+
+if __name__ == "__main__":
+    flush()

+ 5 - 1
scripts/generate_bootstrap.py

@@ -1,3 +1,7 @@
 import sys
 sys.path.append(".")
-import bootstrap.bootstrap
+
+from bootstrap.bootstrap import bootstrap
+
+if __name__ == "__main__":
+    bootstrap()

+ 18 - 0
scripts/run_tests.py

@@ -0,0 +1,18 @@
+from flush_compiler_caches import flush
+from generate_bootstrap import bootstrap
+import subprocess
+import sys
+
+flush()
+
+subprocess.check_call([sys.executable, "-m", "pytest"], cwd="state")
+
+bootstrap()
+
+subprocess.check_call([sys.executable, "-m", "pytest"], cwd="kernel")
+
+flush()
+
+subprocess.check_call([sys.executable, "-m", "pytest"], cwd="interface/HUTN")
+
+subprocess.check_call([sys.executable, "-m", "pytest", "integration"])