.gitignore

@@ -1,5 +1,4 @@
 fuzzer/
-exec/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

ast_generator/ast_generator.py

@@ -1,5 +1,4 @@
 import string
-import warnings
 
 from english_words import get_english_words_set
 
@@ -85,8 +84,8 @@ class AstGenerator:
 
     def _init_names(self):
         names = get_english_words_set(['web2'], alpha=True)
-        possible_names = filter(lambda x: (self.settings['properties']['id-length']['max'] <= len(x) <=
+        possible_names = filter(lambda x: self.settings['properties']['id-length']['max'] <= len(x) <=
-                                           self.settings['properties']['id-length']['max']) and not keyword.iskeyword(x),
+                                          self.settings['properties']['id-length']['max'] and not keyword.iskeyword(x),
                                 names)
         var_name_list = list(possible_names)
         var_name_len = len(var_name_list)
@@ -156,8 +155,6 @@ class AstGenerator:
             self.generate_return(return_type=return_type, return_value=return_value)
         if self.settings['generation-options']['generate-dead-code']:
             self.generate_statements(exclude='declaration')
-
-        self.print_all_current_scope_vars()
         self.pop_scope()
         self.current_ast_element = parent
 
@@ -645,7 +642,7 @@ class AstGenerator:
                                   self.comp_op_numline,
                                   self.comp_op_cutoffs,
                                   self.comp_op_options,
-                                  comparison=True)  #, evals=self.get_truth())
+                                  comparison=True)
 
     def push_scope(self, xml_element: ET.Element = None):
         scope = Scope(self.current_scope)
@@ -901,25 +898,3 @@ class AstGenerator:
                 self.generate_binary(op, random.choice([GAZ_INT_KEY, GAZ_FLOAT_KEY]))
         else:
             self.generate_binary(op, random.choice(expr_type))
-
-    def print_all_current_scope_vars(self):
-        for key, value in self.current_scope.symbols.items():
-            if isinstance(value, Variable):
-                self.print_variable(value)
-
-    def print_variable(self, var: Variable):
-        """
-        @brief generate an outstream for a variable
-
-        @param var: the variable to print
-        @return:
-        """
-        parent = self.current_ast_element
-
-        args = [
-            ("type", GAZ_OUT_STREAM),
-        ]
-        self.make_element(GAZ_STREAM_TAG, args)
-        self.current_ast_element.append(var.xml)
-
-        self.current_ast_element = parent

ast_generator/test/config.yaml

@@ -9,7 +9,7 @@ generation-options:
     max-globals: 5                               # maximum number of global variables
 properties:
     max-range-length: 5                          # maximum length of ranges, vectors and tuples, (AxA matrices can exist)
-    use-english-words: True                      # use english words instead of random names (if we run out, we switch to random)
+    use-english-words: True                      # use english words instead of random names (this may limit the maximum number of names)
     id-length:                                   # length of identifiers
         min: 1
         max: 5
@@ -68,12 +68,12 @@ statement-weights:                               # set to 0 for any statements y
     in-stream: 5
 
 type-weights:
-    atomic-types:
+    value-types:
-        int: 50  # TODO change these to the gaz types
+        integer: 50
-        float: 50
+        real: 50
-        bool: 50
+        boolean: 50
-        char: 50
+        character: 50
-        void: 0  # TODO add support for void
+        void: 10
     composite-types:
         vector: 20
         tuple: 5
@@ -90,9 +90,6 @@ misc-weights:
     type-qualifier-weights:
         const: 10
         var: 60
-    conditional-eval:
-        true: 50
-        false: 50
 
 block-termination-probability: 0.2               # probability for a block to terminate
 

ast_generator/test/test_ast_generator.py

@@ -309,22 +309,6 @@ class TestGeneration(unittest.TestCase):
 
         return res
 
-    def test_print_all_current_scope_vars(self):
-        self.ast_gen.ast = ET.Element("block")
-        self.ast_gen.current_ast_element = self.ast_gen.ast
-        self.ast_gen.generate_declaration(mut='var')
-        self.ast_gen.generate_declaration(mut='var')
-        self.ast_gen.generate_declaration(mut='var')
-        self.ast_gen.generate_declaration(mut='var')
-
-        self.ast_gen.print_all_current_scope_vars()
-
-        print(ET.tostring(self.ast_gen.ast))
-
-        streams = self.ast_gen.ast.findall("stream")
-
-        self.assertEqual(4, len(streams))
-
     def write_ast(self):
         dom = xml.dom.minidom.parseString(ET.tostring(self.ast_gen.ast).decode('utf-8'))
         pretty: str = dom.toprettyxml()

ast_parser/gaz_unparser.py

@@ -98,6 +98,3 @@ class GazUnparser(GeneralUnparser):
 
     def format_single_arg(self, ty, name):
         return "{} {}".format(ty, name)
-
-    def setup(self):
-        pass

ast_parser/general_unparser.py

@@ -69,9 +69,6 @@ class GeneralUnparser:
         :return: a string of valid gazprea code
         """
         self.source = ""
-
-        self.setup()
-
         for node in self.xml:
             self.unparse_node(node)
 
@@ -327,9 +324,6 @@ class GeneralUnparser:
     def format_single_arg(self, param, param1):
         raise NotImplementedError
 
-    def setup(self):
-        raise NotImplementedError
-
     def pretty_xml(self):
         dom = xml.dom.minidom.parseString(ET.tostring(self.xml).decode('utf-8'))
         pretty: str = dom.toprettyxml()

ast_parser/python_unparser.py

@@ -59,7 +59,7 @@ class PythonUnparser(GeneralUnparser):
     def __init__(self, ast: ET.Element, debug=False):
         super().__init__(ast, debug,
                          endline='\n',
-                         outstream_begin_delimiter="gprint(",
+                         outstream_begin_delimiter="print(",
                          outstream_end_delimiter=", end='')",
                          function_return_type_indicator_predicate="->",
                          loop_start_delimiter="while ",
@@ -113,13 +113,3 @@ class PythonUnparser(GeneralUnparser):
     def unparse(self):
         super().unparse()
         self.source += "\nif __name__ == '__main__':\n    main()"
-
-    def setup(self):
-        self.source += ("def gprint(expr, end=''):\n"
-                        "    if type(expr) is bool:\n"
-                        "        if expr:\n"
-                        "            print('T', end=end)\n"
-                        "        else:\n"
-                        "            print('F', end=end)\n"
-                        "    else:\n"
-                        "        print(expr, end=end)\n\n")

config.yaml

@@ -90,9 +90,6 @@ misc-weights:
     type-qualifier-weights:
         const: 10
         var: 60
-    conditional-eval:
-        true: 50
-        false: 50
 
 block-termination-probability: 0.2               # probability for a block to terminate
 

constants.py

@@ -61,11 +61,3 @@ class NoneTagException(Exception):
         super().__init__(message)
         self.xml = xml
 
-class GazTypeError(Exception):
-
-    def __init__(self, message, op, ty1, ty2):
-        super().__init__(message)
-        self.op = op
-        self.ty1 = ty1
-        self.ty2 = ty2
-

fuzzer.py

@@ -28,11 +28,6 @@ class GazpreaFuzzer:
         self.ground_truth = None
         self.out = None
 
-        try:
-            os.makedirs('debug/ast')
-        except FileExistsError:
-            pass
-
     def fuzz(self):
         self.generator.generate_ast()
         self.write_ast()  # FIXME sometimes this is none
@@ -53,9 +48,8 @@ class GazpreaFuzzer:
         # input = "if __name__ == '__main__':\n    while True:\n        pass\n"  # debug
 
         with redirect_stdout(io.StringIO()) as buf:
-            pass
             # exec(str(self.ground_truth))
-            # exec(self.ground_truth, globals(), locals())  # FIXME the exec doesn't actually execute for some reason...
+            exec(self.ground_truth, globals(), locals())  # FIXME the exec doesn't actually execute for some reason...
 
         self.out = buf.getvalue()
 

gazprea_fuzzer.py

@@ -15,16 +15,6 @@ import xml.etree.ElementTree as ET
 from constants import NoneTagException
 
 
-def gprint(expr, end=''):
-    if type(expr) is bool:
-        if expr:
-            print('T', end=end)
-        else:
-            print('F', end=end)
-    else:
-        print(expr, end=end)
-
-
 class Fuzzer():
     def __init__(self, config: str, batch: int, seed: str, file_name: str = "fuzz"):
         with open(config) as yaml_file:
@@ -37,32 +27,16 @@ class Fuzzer():
         self.fuzzer = fz.GazpreaFuzzer(config)
 
     def fuzz(self):
-        base_dir = os.getcwd()
+        os.system("rm -rf fuzzer")
-        fuzzer_root = base_dir + '/fuzzer'
+        os.mkdir("fuzzer")
-
+        os.mkdir("fuzzer/input")
-        fuzzer_input = fuzzer_root + '/input/fuzzer'
+        os.mkdir("fuzzer/debug")
-        fuzzer_debug = fuzzer_root + '/debug'
+        os.mkdir("fuzzer/debug/ast_err")
-        fuzzer_asterr = fuzzer_debug + '/ast_err'
+        os.mkdir("fuzzer/instream")
-        fuzzer_instream = fuzzer_root + '/instream'
+        os.mkdir("fuzzer/outputs")
-        fuzzer_outputs = fuzzer_root + '/outputs/fuzzer'
+        os.mkdir("fuzzer/ground_truth")
-        fuzzer_ground_truth = fuzzer_root + '/ground_truth'
+        os.system("cp tester_config.json fuzzer/tester_config.json")
-
+        for i in range(self.batch):
-        os.system(f"rm -rf {fuzzer_root}")
-        os.makedirs(fuzzer_root)
-        os.makedirs(fuzzer_input)
-        os.makedirs(fuzzer_debug)
-        os.makedirs(fuzzer_asterr)
-        os.makedirs(fuzzer_instream)
-        os.makedirs(fuzzer_outputs)
-        os.makedirs(fuzzer_ground_truth)
-        try:
-            os.system(f"cp tester_config.json {fuzzer_root}/tester_config.json")
-        except Exception as e:
-            pass
-
-        i = 0
-        min_i = 0
-        while i < self.batch:
             try:
                 self.fuzzer.fuzz()
             except NoneTagException as n:
@@ -70,52 +44,38 @@ class Fuzzer():
                 warnings.warn("None Tag Exception encountered, writing stack trace and xml to debug/ast/{}.xml\n"
                               "Look for a top-level <argument> tag or send it to Ayrton and I'll see what I can see"
                               "".format(r))
-                with open(f"{fuzzer_asterr}/{r}.xml", 'w') as f:
+                with open("fuzzer/debug/ast_err/{}.xml".format(r), 'w') as f:
                     f.write(xml.dom.minidom.parseString(ET.tostring(self.fuzzer.ast).decode('utf-8')).toprettyxml())
-                if i - 1 >= min_i:
-                    i -= 1
-                else:
-                    i = min_i
                 continue
             dom = xml.dom.minidom.parseString(ET.tostring(self.fuzzer.ast).decode('utf-8'))
             pretty: str = dom.toprettyxml()
 
-            with open("{}/{}_{}.py".format(fuzzer_ground_truth, self.file_name, i), 'w') as f:
+            with open("fuzzer/ground_truth/{}_{}.py".format(self.file_name, i), 'w') as f:
                 f.write(self.fuzzer.ground_truth)
-            with open("{}/{}_{}.py".format(fuzzer_ground_truth, self.file_name, i), 'r') as f:
+            with open("fuzzer/ground_truth/{}_{}.py".format(self.file_name, i), 'r') as f:
-                with open("{}/{}_{}.out".format(fuzzer_outputs, self.file_name, i), 'w') as y:
+                with open("fuzzer/outputs/{}_{}.out".format(self.file_name, i), 'w') as y:
-                    with redirect_stdout(y):  # Workaround for fuzzer.py:49
+                    with redirect_stdout(y): # Workaround for fuzzer.py:49
                         try:
-                            read = f.read()
+                            exec(f.read(), globals(), locals())
-                            exec(read, globals())
+                        except (OverflowError, ZeroDivisionError, ValueError):
-                        except (OverflowError, ZeroDivisionError, ValueError, TypeError, SyntaxError):
+                            os.system("rm -f fuzzer/ground_truth/{}_{}.py".format(self.file_name, i))
-                            os.system("rm -f {}/{}_{}.py".format(fuzzer_ground_truth, self.file_name, i))
-                            os.system("rm -f {}/{}_{}.py".format(fuzzer_outputs, self.file_name, i))
-                            warnings.warn("Runtime error encountered, retrying")
-                            if i - 1 >= min_i:
-                                i -= 1
-                            else:
-                                i = min_i
                             continue
                         except KeyboardInterrupt:
                             r = random.randint(0, 1000000)
                             warnings.warn("Execution halted, result written to debug/ast/{}.xml\n"
                                           "".format(r))
-                            with open("{}/{}.xml".format(fuzzer_asterr, r), 'w') as f:
+                            with open("fuzzer/debug/ast_err/{}.xml".format(r), 'w') as f:
-                                f.write(xml.dom.minidom.parseString(
+                                f.write(xml.dom.minidom.parseString(ET.tostring(self.fuzzer.ast).decode('utf-8')).toprettyxml())
-                                    ET.tostring(self.fuzzer.ast).decode('utf-8')).toprettyxml())
                             sys.exit(1)
-            with open("{}/{}_{}.in".format(fuzzer_input, self.file_name, i), 'w') as f:
+            with open("fuzzer/input/{}_{}.in".format(self.file_name, i), 'w') as f:
                 f.write(self.fuzzer.source)
-            with open("{}/{}_{}.xml".format(fuzzer_debug, self.file_name, i), 'w') as f:
+            with open("fuzzer/debug/{}_{}.xml".format(self.file_name, i), 'w') as f:
                 f.write(pretty)
-                # y.write(self.fuzzer.out)
+                    # y.write(self.fuzzer.out)
             # with open("fuzzer/instream/{}.in".format(i), 'w') as f:
             #     f.write(self.fuzzer.source)
             # with open("fuzzer/outputs/{}.out".format(i), 'w') as f:
             #     f.write(self.fuzzer.out)
-            i += 1
-            min_i = i
 
 
 if __name__ == '__main__':
@@ -134,3 +94,5 @@ if __name__ == '__main__':
     args = parser.parse_args()
     fuzzer = Fuzzer(config=args.config_file, batch=args.batch_size, seed=args.seed)
     fuzzer.fuzz()
+
+

tester_config.json

@@ -1,12 +1,12 @@
 {
-  "inDir": "input",
+  "inDir": "<inDir>",
-  "outDir": "outputs",
+  "outDir": "<outDir>",
-  "inStrDir": "instream",
+  "inStrDir": "<inStrDir>",
   "testedExecutablePaths": {
-    "fuzzer": "../exec/gazc"
+    "<team id>": "<path_to_gazc_exe>"
   },
   "runtimes": {
-    "fuzzer": "../exec/libgazrt.so"
+    "<team id>": "<path_to_libgazrt.so>"
   },
   "toolchains": {
     "gazprea": [