just style fixesHEADmaster

1 files changed, 744 insertions, 256 deletions

diff --git a/parse.py b/parse.py
index 3cf919d..ba3d8d5 100755
--- a/parse.py
+++ b/parse.py
@@ -12,10 +12,12 @@ import code
 
 _DBG_ = True
 
+
 def SigHandler_SIGINT(signum, frame):
     print()
     sys.exit(0)
 
+
 # we first read the object file and put all the sections in this class
 class ParsedStruct:
     def __init__(self):
@@ -38,48 +40,124 @@ def Conver2Int(little_endian, size, bytelist):
     if little_endian:
         for bit in reversed(bytelist):
             if bit != 0x80:
-                sum += bit*(pow(16, modifier))
+                sum += bit * (pow(16, modifier))
             modifier -= 1
-        return(sum)
+        return sum
     else:
         for bit in reversed(bytelist):
             if bit != 0x80:
-                sum += bit*(pow(16, modifier))
+                sum += bit * (pow(16, modifier))
             modifier -= 1
-        return(sum)
+        return sum
+
 
 # the argparser
 class Argparser(object):
     def __init__(self):
         parser = argparse.ArgumentParser()
-        parser.add_argument("--wast", type=str, help="path to the wasm text file")
-        parser.add_argument("--wasm", type=str, nargs='+', help="path to the wasm object file")
-        parser.add_argument("--asb", type=str, help="path to the wast file to assemble")
-        parser.add_argument("--dis", type=str, help="path to the wasm file to disassemble")
+        parser.add_argument(
+            "--wast", type=str, help="path to the wasm text file"
+        )
+        parser.add_argument(
+            "--wasm", type=str, nargs="+", help="path to the wasm object file"
+        )
+        parser.add_argument(
+            "--asb", type=str, help="path to the wast file to assemble"
+        )
+        parser.add_argument(
+            "--dis", type=str, help="path to the wasm file to disassemble"
+        )
         parser.add_argument("-o", type=str, help="the path to the output file")
-        parser.add_argument("--dbg", action='store_true', help="print debug info", default=False)
-        parser.add_argument("--unval", action='store_true', help="skips validation tests", default=False)
-        parser.add_argument("--memdump", type=int, help="dumps the linear memory")
-        parser.add_argument("--idxspc", action='store_true', help="print index space data", default=False)
-        parser.add_argument("--run", action='store_true', help="runs the start function", default=False)
-        parser.add_argument("--metric", action='store_true', help="print metrics", default=False)
-        parser.add_argument("--gas", action='store_true', help="print gas usage", default=False)
-        parser.add_argument("--entry", type=str, help="name of the function that will act as the entry point into execution")
-        parser.add_argument("--link", type=str, nargs="+", help="link the following wasm modules")
-        parser.add_argument("--sectiondump", type=str, help="dumps the section provided")
+        parser.add_argument(
+            "--dbg",
+            action="store_true",
+            help="print debug info",
+            default=False,
+        )
+        parser.add_argument(
+            "--unval",
+            action="store_true",
+            help="skips validation tests",
+            default=False,
+        )
+        parser.add_argument(
+            "--memdump", type=int, help="dumps the linear memory"
+        )
+        parser.add_argument(
+            "--idxspc",
+            action="store_true",
+            help="print index space data",
+            default=False,
+        )
+        parser.add_argument(
+            "--run",
+            action="store_true",
+            help="runs the start function",
+            default=False,
+        )
+        parser.add_argument(
+            "--metric",
+            action="store_true",
+            help="print metrics",
+            default=False,
+        )
+        parser.add_argument(
+            "--gas", action="store_true", help="print gas usage", default=False
+        )
+        parser.add_argument(
+            "--entry",
+            type=str,
+            help="name of the function that will act as the entry point into execution",
+        )
+        parser.add_argument(
+            "--link",
+            type=str,
+            nargs="+",
+            help="link the following wasm modules",
+        )
+        parser.add_argument(
+            "--sectiondump", type=str, help="dumps the section provided"
+        )
         parser.add_argument("--hexdump", type=int, help="dumps all sections")
-        parser.add_argument("--dbgsection", type=str, help="dumps the parsed section provided", default="")
-        parser.add_argument("--interactive", action='store_true', help="open in cli mode", default=False)
-        parser.add_argument("--rawdump", type=int, nargs=2, help="dumps all sections")
+        parser.add_argument(
+            "--dbgsection",
+            type=str,
+            help="dumps the parsed section provided",
+            default="",
+        )
+        parser.add_argument(
+            "--interactive",
+            action="store_true",
+            help="open in cli mode",
+            default=False,
+        )
+        parser.add_argument(
+            "--rawdump", type=int, nargs=2, help="dumps all sections"
+        )
         self.args = parser.parse_args()
         if self.args.wasm is not None and self.args.wast is not None:
-            raise Exception("the --wast option and the --wasm option cannot\
-                            be set at the same time. you need to choose one.")
+            raise Exception(
+                "the --wast option and the --wasm option cannot\
+                            be set at the same time. you need to choose one."
+            )
 
     def getParseFlags(self):
-        return(ParseFlags(self.args.wast, self.args.wasm, self.args.asb, self.args.dis,
-                          self.args.o, self.args.dbg, self.args.unval, self.args.memdump,
-                          self.args.idxspc, self.args.run, self.args.metric, self.args.gas, self.args.entry))
+        return ParseFlags(
+            self.args.wast,
+            self.args.wasm,
+            self.args.asb,
+            self.args.dis,
+            self.args.o,
+            self.args.dbg,
+            self.args.unval,
+            self.args.memdump,
+            self.args.idxspc,
+            self.args.run,
+            self.args.metric,
+            self.args.gas,
+            self.args.entry,
+        )
+
 
 # reads a wasm-obj file, returns a parsedstruct that holds all the sections'
 # bytecode, their section type and their length
@@ -89,20 +167,26 @@ def ReadWASM(file_path, endianness, is_extended_isa, dbg):
     parsedstruct = ParsedStruct()
     # read the magic cookie
     byte = wasm_file.read(WASM_OP_Code.uint32)
-    if byte != WASM_OP_Code.magic_number.to_bytes(WASM_OP_Code.uint32, byteorder=endianness, signed=False):
+    if byte != WASM_OP_Code.magic_number.to_bytes(
+        WASM_OP_Code.uint32, byteorder=endianness, signed=False
+    ):
         raise Exception("bad magic cookie")
 
     # read the version number
     byte = wasm_file.read(WASM_OP_Code.uint32)
-    if byte != WASM_OP_Code.version_number.to_bytes(WASM_OP_Code.uint32, byteorder=endianness, signed=False):
+    if byte != WASM_OP_Code.version_number.to_bytes(
+        WASM_OP_Code.uint32, byteorder=endianness, signed=False
+    ):
         raise Exception("bad version number")
     else:
         parsedstruct.version_number = byte
 
     while True:
         byte = wasm_file.read(1)
-        if byte != b'':
-            temp_obj_file.append(int.from_bytes(byte, byteorder='big', signed=False))
+        if byte != b"":
+            temp_obj_file.append(
+                int.from_bytes(byte, byteorder="big", signed=False)
+            )
         else:
             break
 
@@ -111,18 +195,22 @@ def ReadWASM(file_path, endianness, is_extended_isa, dbg):
     while loop:
         try:
             # section_id, offset, dummy = Read(temp_obj_file, offset, 'varuint7')
-            section_id, offset, dummy = Read(temp_obj_file, offset, 'varuint32')
+            section_id, offset, dummy = Read(
+                temp_obj_file, offset, "varuint32"
+            )
         except IndexError:
             break
 
-        payload_length, offset, dummy = Read(temp_obj_file, offset, 'varuint32')
+        payload_length, offset, dummy = Read(
+            temp_obj_file, offset, "varuint32"
+        )
 
         if section_id == 0:
             is_custom_section = True
-            name_len, offset, dummy = Read(temp_obj_file, offset, 'varuint32')
+            name_len, offset, dummy = Read(temp_obj_file, offset, "varuint32")
             name = temp_obj_file[offset : offset + name_len]
             offset += name_len
-            '''
+            """
             if type(name) == list:
                 print(''.join([chr(elem) for elem in name]))
                 name = ''.join([chr(elem) for elem in name])
@@ -134,26 +222,39 @@ def ReadWASM(file_path, endianness, is_extended_isa, dbg):
                 for i in range(0, reloc_entry_count):
                     reloc_entry, offset, dummy = Read(tmp_obj, offset, 'varuint32')
                     reloc_entries.append(reloc_entry)
-                    '''
+                    """
         else:
             is_custom_section = False
             name_len = 0
-            name = ''
+            name = ""
             dummy = 0
 
-        payload_data = temp_obj_file[offset:offset + payload_length - name_len - dummy]
+        payload_data = temp_obj_file[
+            offset : offset + payload_length - name_len - dummy
+        ]
         offset += payload_length - name_len - dummy
 
         # @DEVI-the second field is for general use. it is unused right
         # now so we are filling it with jojo.
-        parsedstruct.section_list.append([section_id, 'jojo', payload_length, is_custom_section, name_len, name, payload_data])
+        parsedstruct.section_list.append(
+            [
+                section_id,
+                "jojo",
+                payload_length,
+                is_custom_section,
+                name_len,
+                name,
+                payload_data,
+            ]
+        )
 
     # prints out the sections in the wasm object
     for section in parsedstruct.section_list:
         pass
-        #print(section)
+        # print(section)
     wasm_file.close()
-    return(parsedstruct)
+    return parsedstruct
+
 
 # Receives a parsedstruct returned from ReadWASM, parses all the sections and
 # fills up a module class. the parse method, then can return the module.
@@ -177,7 +278,7 @@ class ObjReader(object):
         # @DEVI-FIXME-for v1.0 opcodes. needs to get fixed for extended
         # op-codes. ideally the mosule should hold its version number so we can
         # check it here.
-        byte = format(section_byte[6][offset], '02x')
+        byte = format(section_byte[6][offset], "02x")
         offset += 1
         read_bytes += 1
 
@@ -190,36 +291,46 @@ class ObjReader(object):
                 # we read(at least two ticks per opcode). I could have the
                 # br_table opcode done separately but kinda hurts the codes
                 # uniformity. anyways.
-                if op_code[1] == '0e':
+                if op_code[1] == "0e":
                     matched = True
-                    temp, offset, read_bytes_temp_iter = Read(section_byte[6], offset, op_code[3][0])
-                    instruction += repr(temp) + ' '
+                    temp, offset, read_bytes_temp_iter = Read(
+                        section_byte[6], offset, op_code[3][0]
+                    )
+                    instruction += repr(temp) + " "
                     operands.append(repr(temp))
                     read_bytes_temp += read_bytes_temp_iter
                     for target_table in range(0, temp):
-                        temp, offset, read_bytes_temp_iter = Read(section_byte[6], offset, op_code[3][1])
+                        temp, offset, read_bytes_temp_iter = Read(
+                            section_byte[6], offset, op_code[3][1]
+                        )
                         read_bytes_temp += read_bytes_temp_iter
-                        instruction += repr(temp) + ' '
+                        instruction += repr(temp) + " "
                         operands.append(repr(temp))
-                    temp, offset, read_bytes_temp_iter = Read(section_byte[6], offset, op_code[3][2])
-                    instruction += repr(temp) + ' '
+                    temp, offset, read_bytes_temp_iter = Read(
+                        section_byte[6], offset, op_code[3][2]
+                    )
+                    instruction += repr(temp) + " "
                     operands.append(repr(temp))
                     read_bytes_temp += read_bytes_temp_iter
                 elif op_code[2]:
                     if isinstance(op_code[3], tuple):
-                        for i in range(0, len(op_code [3])):
-                            temp, offset, read_bytes_temp_iter = Read(section_byte[6], offset, op_code[3][i])
+                        for i in range(0, len(op_code[3])):
+                            temp, offset, read_bytes_temp_iter = Read(
+                                section_byte[6], offset, op_code[3][i]
+                            )
                             read_bytes_temp += read_bytes_temp_iter
-                            instruction += repr(temp) + ' '
+                            instruction += repr(temp) + " "
                             operands.append(repr(temp))
                     else:
-                        temp, offset, read_bytes_temp = Read(section_byte[6], offset, op_code[3])
+                        temp, offset, read_bytes_temp = Read(
+                            section_byte[6], offset, op_code[3]
+                        )
                         instruction += repr(temp)
                         operands.append(repr(temp))
 
                 temp_wasm_ins.opcode = op_code[0]
                 temp_wasm_ins.opcodeint = int(byte, 16)
-                #temp_wasm_ins.operands = instruction
+                # temp_wasm_ins.operands = instruction
                 temp_wasm_ins.operands = operands
                 break
 
@@ -242,15 +353,19 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        fn_cn, offset, dummy = Read(code_section[6], offset, 'varuint32')
+        fn_cn, offset, dummy = Read(code_section[6], offset, "varuint32")
         function_cnt = fn_cn
         CS.count = function_cnt
 
         while function_cnt > 0:
-            function_body_length, offset, dummy = Read(code_section[6], offset, 'varuint32')
+            function_body_length, offset, dummy = Read(
+                code_section[6], offset, "varuint32"
+            )
             temp_func_bodies.body_size = function_body_length
 
-            local_count, offset, dummy = Read(code_section[6], offset, 'varuint32')
+            local_count, offset, dummy = Read(
+                code_section[6], offset, "varuint32"
+            )
             temp_func_bodies.local_count = local_count
 
             # local_count_size will eventually hold how many bytes we will read
@@ -258,9 +373,13 @@ class ObjReader(object):
             local_count_size = dummy
             if local_count != 0:
                 for i in range(0, local_count):
-                    partial_local_count, offset, dummy = Read(code_section[6], offset, 'varuint32')
+                    partial_local_count, offset, dummy = Read(
+                        code_section[6], offset, "varuint32"
+                    )
                     local_count_size += dummy
-                    partial_local_type, offset, dummy = Read(code_section[6], offset, 'uint8')
+                    partial_local_type, offset, dummy = Read(
+                        code_section[6], offset, "uint8"
+                    )
                     local_count_size += dummy
                     temp_local_entry.count = partial_local_count
                     temp_local_entry.type = partial_local_type
@@ -271,14 +390,31 @@ class ObjReader(object):
 
             read_bytes_so_far = local_count_size
             for i in range(0, function_body_length - local_count_size):
-                offset, matched, read_bytes, temp_wasm_ins = self.Disassemble(code_section, offset)
+                offset, matched, read_bytes, temp_wasm_ins = self.Disassemble(
+                    code_section, offset
+                )
                 temp_func_bodies.code.append(deepcopy(temp_wasm_ins))
 
                 if not matched:
-                    print(Colors.red + 'did not match anything' + Colors.ENDC)
-                    print(Colors.red + 'code section offset: ' + repr(offset) + Colors.ENDC)
-                    print(Colors.red + 'read bytes: ' + repr(read_bytes) + Colors.ENDC)
-                    print(Colors.red + 'wasm ins: ' + repr(temp_wasm_ins.opcode) + Colors.ENDC)
+                    print(Colors.red + "did not match anything" + Colors.ENDC)
+                    print(
+                        Colors.red
+                        + "code section offset: "
+                        + repr(offset)
+                        + Colors.ENDC
+                    )
+                    print(
+                        Colors.red
+                        + "read bytes: "
+                        + repr(read_bytes)
+                        + Colors.ENDC
+                    )
+                    print(
+                        Colors.red
+                        + "wasm ins: "
+                        + repr(temp_wasm_ins.opcode)
+                        + Colors.ENDC
+                    )
 
                     for iter in temp_func_bodies.code:
                         print(iter.opcode)
@@ -295,7 +431,7 @@ class ObjReader(object):
             temp_func_bodies.locals = []
             temp_func_bodies.code = []
             function_cnt -= 1
-        return(CS)
+        return CS
 
     # parsed the data section. returns a Data_Section class
     def ReadDataSection(self):
@@ -313,27 +449,35 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        data_entry_count, offset, dummy = Read(data_section[6], offset, 'varuint32')
+        data_entry_count, offset, dummy = Read(
+            data_section[6], offset, "varuint32"
+        )
         DS.count = data_entry_count
 
         while data_entry_count != 0:
-            linear_memory_index, offset, dummy = Read(data_section[6], offset, 'varuint32')
+            linear_memory_index, offset, dummy = Read(
+                data_section[6], offset, "varuint32"
+            )
             temp_data_segment.index = linear_memory_index
 
             # reading in the init-expr
             while loop:
                 # @DEVI-FIXME-this only works for none extended opcodes
-                if data_section[6][offset] == 0x0b:
+                if data_section[6][offset] == 0x0B:
                     loop = False
-                data_char, offset, dummy = Read(data_section[6], offset, 'uint8')
+                data_char, offset, dummy = Read(
+                    data_section[6], offset, "uint8"
+                )
                 init_expr.append(data_char)
 
             temp_data_segment.offset = init_expr
 
-            data_entry_length, offset, dummy = Read(data_section[6], offset, 'varuint32')
+            data_entry_length, offset, dummy = Read(
+                data_section[6], offset, "varuint32"
+            )
             temp_data_segment.size = data_entry_length
 
-            data_itself = data_section[6][offset:offset + data_entry_length]
+            data_itself = data_section[6][offset : offset + data_entry_length]
             temp_data_segment.data = data_itself
             offset += data_entry_length
 
@@ -342,7 +486,7 @@ class ObjReader(object):
             data_entry_count -= 1
             init_expr = []
             loop = True
-        return(DS)
+        return DS
 
     # parses the import section. returns an Import_Section class
     def ReadImportSection(self):
@@ -360,11 +504,15 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        import_cnt, offset, dummy = Read(import_section[6], offset, 'varuint32')
+        import_cnt, offset, dummy = Read(
+            import_section[6], offset, "varuint32"
+        )
         IS.count = import_cnt
 
         while import_cnt != 0:
-            module_length, offset, dummy = Read(import_section[6], offset, 'varuint32')
+            module_length, offset, dummy = Read(
+                import_section[6], offset, "varuint32"
+            )
             temp_import_entry.module_len = module_length
 
             for i in range(0, module_length):
@@ -372,44 +520,66 @@ class ObjReader(object):
             temp_import_entry.module_str = module_name
             offset += module_length
 
-            field_length, offset, dummy = Read(import_section[6], offset, 'varuint32')
+            field_length, offset, dummy = Read(
+                import_section[6], offset, "varuint32"
+            )
             temp_import_entry.field_len = field_length
             for i in range(0, field_length):
                 field_name.append(import_section[6][offset + i])
             temp_import_entry.field_str = field_name
             offset += field_length
 
-            kind, offset, dummy = Read(import_section[6], offset, 'uint8')
+            kind, offset, dummy = Read(import_section[6], offset, "uint8")
             temp_import_entry.kind = kind
 
             # function type
             if kind == 0:
-                import_type, offset, dummy = Read(import_section[6], offset, 'varuint32')
+                import_type, offset, dummy = Read(
+                    import_section[6], offset, "varuint32"
+                )
                 temp_import_entry.type = import_type
             # table type
             elif kind == 1:
                 table_type = Table_Type()
-                table_type.elemet_type, offset, dummy = Read(import_section[6], offset, 'varint7')
+                table_type.elemet_type, offset, dummy = Read(
+                    import_section[6], offset, "varint7"
+                )
                 rsz_limits = Resizable_Limits()
-                rsz_limits.flags, offset, dummy = Read(import_section[6], offset, 'varuint1')
-                rsz_limits.initial, offset, dummy = Read(import_section[6], offset, 'varuint32')
+                rsz_limits.flags, offset, dummy = Read(
+                    import_section[6], offset, "varuint1"
+                )
+                rsz_limits.initial, offset, dummy = Read(
+                    import_section[6], offset, "varuint32"
+                )
                 if rsz_limits.flags:
-                    rsz_limits.maximum, offset, dummy = Read(import_section[6], offset, 'varuint32')
+                    rsz_limits.maximum, offset, dummy = Read(
+                        import_section[6], offset, "varuint32"
+                    )
                 table_type.limit = rsz_limits
                 temp_import_entry.type = table_type
             elif kind == 2:
                 memory_type = Memory_Type()
                 rsz_limits = Resizable_Limits()
-                rsz_limits.flags, offset, dummy = Read(import_section[6], offset, 'varuint1')
-                rsz_limits.initial, offset, dummy = Read(import_section[6], offset, 'varuint32')
+                rsz_limits.flags, offset, dummy = Read(
+                    import_section[6], offset, "varuint1"
+                )
+                rsz_limits.initial, offset, dummy = Read(
+                    import_section[6], offset, "varuint32"
+                )
                 if rsz_limits.flags:
-                    rsz_limits.maximum, offset, dummy = Read(import_section[6], offset, 'varuint32')
+                    rsz_limits.maximum, offset, dummy = Read(
+                        import_section[6], offset, "varuint32"
+                    )
                 memory_type.limits = rsz_limits
                 temp_import_entry.type = memory_type
             elif kind == 3:
                 global_type = Global_Type()
-                global_type.content_type, offset, dummy = Read(import_section[6], offset, 'uint8')
-                global_type.mutability, offset, dummy = Read(import_section[6], offset, 'varuint1')
+                global_type.content_type, offset, dummy = Read(
+                    import_section[6], offset, "uint8"
+                )
+                global_type.mutability, offset, dummy = Read(
+                    import_section[6], offset, "varuint1"
+                )
                 temp_import_entry.type = global_type
 
             IS.import_entry.append(deepcopy(temp_import_entry))
@@ -417,7 +587,7 @@ class ObjReader(object):
             import_cnt -= 1
             module_name = []
             field_name = []
-        return(IS)
+        return IS
 
     # parses the export section, returns an Export_Section class
     def ReadExportSection(self):
@@ -434,11 +604,15 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        export_entry_cnt, offset, dummy = Read(export_section[6], offset, 'varuint32')
+        export_entry_cnt, offset, dummy = Read(
+            export_section[6], offset, "varuint32"
+        )
         ES.count = export_entry_cnt
 
         while export_entry_cnt != 0:
-            field_length, offset, dummy = Read(export_section[6], offset, 'varuint32')
+            field_length, offset, dummy = Read(
+                export_section[6], offset, "varuint32"
+            )
             temp_export_entry.field_len = field_length
 
             for i in range(0, field_length):
@@ -446,17 +620,17 @@ class ObjReader(object):
             temp_export_entry.fiels_str = field_name
             offset += field_length
 
-            kind, offset, dummy = Read(export_section[6], offset, 'uint8')
+            kind, offset, dummy = Read(export_section[6], offset, "uint8")
             temp_export_entry.kind = kind
 
-            index, offset, dummy = Read(export_section[6], offset, 'varuint32')
+            index, offset, dummy = Read(export_section[6], offset, "varuint32")
             temp_export_entry.index = index
 
             ES.export_entries.append(deepcopy(temp_export_entry))
 
             export_entry_cnt -= 1
             field_name = []
-        return(ES)
+        return ES
 
     # parses the type section, returns a Type_Section class
     def ReadTypeSection(self):
@@ -474,14 +648,18 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        type_entry_count, offset, dummy = Read(type_section[6], offset, 'varuint32')
+        type_entry_count, offset, dummy = Read(
+            type_section[6], offset, "varuint32"
+        )
         TS.count = type_entry_count
 
         while type_entry_count != 0:
-            form, offset, dummy = Read(type_section[6], offset, 'varint7')
+            form, offset, dummy = Read(type_section[6], offset, "varint7")
             temp_func_type.form = form
 
-            param_count, offset, dummy = Read(type_section[6], offset, 'varuint32')
+            param_count, offset, dummy = Read(
+                type_section[6], offset, "varuint32"
+            )
             temp_func_type.param_cnt = param_count
 
             for i in range(0, param_count):
@@ -490,7 +668,9 @@ class ObjReader(object):
             offset += param_count
 
             # @DEVI-FIXME- only works for MVP || single return value
-            return_count, offset, dummy = Read(type_section[6], offset, 'varuint1')
+            return_count, offset, dummy = Read(
+                type_section[6], offset, "varuint1"
+            )
             temp_func_type.return_cnt = return_count
 
             for i in range(0, return_count):
@@ -503,7 +683,7 @@ class ObjReader(object):
             type_entry_count -= 1
             param_list = []
             return_list = []
-        return(TS)
+        return TS
 
     # parses the function section, returns a Function_section class
     def ReadFunctionSection(self):
@@ -519,15 +699,19 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        function_entry_count, offset, dummy = Read(function_section[6], offset, 'varuint32')
+        function_entry_count, offset, dummy = Read(
+            function_section[6], offset, "varuint32"
+        )
         FS.count = function_entry_count
 
         for i in range(0, function_entry_count):
-            index, offset, dummy = Read(function_section[6], offset, 'varuint32')
+            index, offset, dummy = Read(
+                function_section[6], offset, "varuint32"
+            )
             index_to_type.append(index)
         FS.type_section_index = index_to_type
         offset += function_entry_count
-        return(FS)
+        return FS
 
     # parses the element secction, returns an Element_Section class
     def ReadElementSection(self):
@@ -547,26 +731,34 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        element_entry_count, offset, dummy = Read(element_section[6], offset, 'varuint32')
+        element_entry_count, offset, dummy = Read(
+            element_section[6], offset, "varuint32"
+        )
         ES.count = element_entry_count
 
         while element_entry_count != 0:
-            table_index, offset, dummy = Read(element_section[6], offset, 'varuint32')
+            table_index, offset, dummy = Read(
+                element_section[6], offset, "varuint32"
+            )
             temp_elem_segment.index = table_index
 
             # @DEVI-FIXME-only works for non-extneded opcodes
             while loop:
-                if element_section[6][offset] == 0x0b:
+                if element_section[6][offset] == 0x0B:
                     loop = False
                 init_expr.append(element_section[6][offset])
                 offset += 1
             temp_elem_segment.offset = init_expr
 
-            num_elements, offset, dummy = Read(element_section[6], offset, 'varuint32')
+            num_elements, offset, dummy = Read(
+                element_section[6], offset, "varuint32"
+            )
             temp_elem_segment.num_elem = num_elements
 
             for i in range(0, num_elements):
-                index, offset, dummy = Read(element_section[6], offset, 'varuint32')
+                index, offset, dummy = Read(
+                    element_section[6], offset, "varuint32"
+                )
                 function_indices.append(index)
             temp_elem_segment.elems = function_indices
             offset += num_elements
@@ -577,7 +769,7 @@ class ObjReader(object):
             init_expr = []
             function_indices = []
             element_entry_count -= 1
-        return(ES)
+        return ES
 
     # parses the memory section, returns a Memory_Section class
     def ReadMemorySection(self):
@@ -594,23 +786,29 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        num_linear_mems, offset, dummy = Read(memory_section[6], offset, 'varuint32')
+        num_linear_mems, offset, dummy = Read(
+            memory_section[6], offset, "varuint32"
+        )
         MS.count = num_linear_mems
 
         while num_linear_mems != 0:
-            flag, offset, dummy = Read(memory_section[6], offset, 'varuint1')
+            flag, offset, dummy = Read(memory_section[6], offset, "varuint1")
             temp_rsz_limits.flags = flag
 
-            initial,offset, dummy = Read(memory_section[6], offset, 'varuint32')
+            initial, offset, dummy = Read(
+                memory_section[6], offset, "varuint32"
+            )
             temp_rsz_limits.initial = initial
 
             if flag:
-                maximum, offset, dummy = Read(memory_section[6], offset, 'varuint32')
+                maximum, offset, dummy = Read(
+                    memory_section[6], offset, "varuint32"
+                )
                 temp_rsz_limits.maximum = maximum
 
             MS.memory_types.append(deepcopy(temp_rsz_limits))
             num_linear_mems -= 1
-        return(MS)
+        return MS
 
     # parses the table section, returns a Table_Section class
     def ReadTableSection(self):
@@ -628,28 +826,36 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        table_count, offset, dummy = Read(table_section[6], offset, 'varuint32')
+        table_count, offset, dummy = Read(
+            table_section[6], offset, "varuint32"
+        )
         TS.count = table_count
 
         while table_count != 0:
-            element_type, offset, dummy = Read(table_section[6], offset, 'varint7')
+            element_type, offset, dummy = Read(
+                table_section[6], offset, "varint7"
+            )
             temp_table_type.element_type = element_type
 
-            flag, offset, dummy = Read(table_section[6], offset, 'varuint1')
+            flag, offset, dummy = Read(table_section[6], offset, "varuint1")
             temp_rsz_limits.flags = flag
 
-            initial, offset, dummy = Read(table_section[6], offset, 'varuint32')
+            initial, offset, dummy = Read(
+                table_section[6], offset, "varuint32"
+            )
             temp_rsz_limits.initial = initial
 
             if flag:
-                maximum, offset, dummy = Read(table_section[6], offset, 'varuint32')
+                maximum, offset, dummy = Read(
+                    table_section[6], offset, "varuint32"
+                )
                 temp_rsz_limits.maximum = maximum
 
             temp_table_type.limit = temp_rsz_limits
             TS.table_types.append(deepcopy(temp_table_type))
 
             table_count -= 1
-        return(TS)
+        return TS
 
     # parses the global section, returns a Global_Section class
     def ReadGlobalSection(self):
@@ -669,19 +875,23 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        count, offset, dummy = Read(global_section[6], offset, 'varuint32')
+        count, offset, dummy = Read(global_section[6], offset, "varuint32")
         GS.count = count
 
         while count != 0:
-            content_type, offset, dummy = Read(global_section[6], offset, 'uint8')
+            content_type, offset, dummy = Read(
+                global_section[6], offset, "uint8"
+            )
             temp_gl_type.content_type = content_type
 
-            mutability, offset, dummy = Read(global_section[6], offset, 'varuint1')
+            mutability, offset, dummy = Read(
+                global_section[6], offset, "varuint1"
+            )
             temp_gl_type.mutability = mutability
 
             # @DEVI-FIXME-only works for non-extended opcodes
             while loop:
-                if global_section[6][offset] == 0x0b:
+                if global_section[6][offset] == 0x0B:
                     loop = False
                 init_expr.append(global_section[6][offset])
                 offset += 1
@@ -690,11 +900,10 @@ class ObjReader(object):
             temp_gl_var.global_type = temp_gl_type
             GS.global_variables.append(deepcopy(temp_gl_var))
 
-
             count -= 1
             loop = True
             init_expr = []
-        return(GS)
+        return GS
 
     # parses the start section, returns a Start_Section
     def ReadStartSection(self):
@@ -709,31 +918,33 @@ class ObjReader(object):
         if not section_exists:
             return None
 
-        function_index, offset, dummy = Read(start_section[6], offset, 'varuint32')
+        function_index, offset, dummy = Read(
+            start_section[6], offset, "varuint32"
+        )
         SS.function_section_index = function_index
-        return(SS)
+        return SS
 
     def ReadRelocationSection(self):
         section_exists = False
         RS = Relocation_Section()
         for whatever in self.parsedstruct.section_list:
             if whatever[0] == 0 and whatever[1] == "reloc":
-                #reloc_section = whatever.copy()
+                # reloc_section = whatever.copy()
                 section_exists = True
         if not section_exists:
             return None
-        return(RS)
+        return RS
 
     def ReadNameSection(self):
         section_exists = False
         NS = Name_Section()
         for whatever in self.parsedstruct.section_list:
             if whatever[0] == 0 and whatever[1] == "name":
-                #name_section = whatever.copy()
+                # name_section = whatever.copy()
                 section_exists = True
         if not section_exists:
             return None
-        return(NS)
+        return NS
 
     def ReadLinkingSection(self):
         pass
@@ -743,16 +954,23 @@ class ObjReader(object):
 
     # unused-returns the cursor location in the object file
     def getCursorLocation(self):
-        return(self.wasm_file.tell())
+        return self.wasm_file.tell()
 
     # a convinience method-builds a module class and returns it
     def parse(self):
-        return(Module(self.ReadTypeSection(), self.ReadImportSection(),
-                      self.ReadFunctionSection(), self.ReadTableSection(),
-                      self.ReadMemorySection(), self.ReadGlobalSection(),
-                      self.ReadExportSection(), self.ReadStartSection(),
-                      self.ReadElementSection(), self.ReadCodeSection(),
-                      self.ReadDataSection()))
+        return Module(
+            self.ReadTypeSection(),
+            self.ReadImportSection(),
+            self.ReadFunctionSection(),
+            self.ReadTableSection(),
+            self.ReadMemorySection(),
+            self.ReadGlobalSection(),
+            self.ReadExportSection(),
+            self.ReadStartSection(),
+            self.ReadElementSection(),
+            self.ReadCodeSection(),
+            self.ReadDataSection(),
+        )
 
 
 # WIP-basically how the assembler is constructed
@@ -783,12 +1001,12 @@ class ParserV1(object):
         header_stack = headerparser.ParseBodyV3(True)
 
         wasm_codeemitter = WASM_CodeEmitter(expr_stack)
-        #wasm_codeemitter.Obj_Header_32()
-        #wasm_codeemitter.Dump_Obj_STDOUT()
+        # wasm_codeemitter.Obj_Header_32()
+        # wasm_codeemitter.Dump_Obj_STDOUT()
 
-        #wasm_codeemitter.SetNewStack(header_stack)
-        #wasm_codeemitter.EmitTypeHeader()
-        #wasm_codeemitter.PrintTypeHeaderObj()
+        # wasm_codeemitter.SetNewStack(header_stack)
+        # wasm_codeemitter.EmitTypeHeader()
+        # wasm_codeemitter.PrintTypeHeaderObj()
 
 
 # our interpreter class
@@ -803,7 +1021,7 @@ class PythonInterpreter(object):
 
     # returns the list of modules that we have parsed so far
     def getmodules(self):
-        return(self.modules)
+        return self.modules
 
     def appendsection(self, section):
         self.sections.append(section)
@@ -814,171 +1032,431 @@ class PythonInterpreter(object):
     # convinience method.calls the ObjReader to parse a wasm obj file.
     # returns a module class.
     def parse(self, file_path):
-        section = ReadWASM(file_path, 'little', False, True)
+        section = ReadWASM(file_path, "little", False, True)
         self.appendsection(section)
         parser = ObjReader(section)
-        return(parser.parse())
+        return parser.parse()
 
     # dumps the object sections' info to stdout. pretty print.
     def dump_sections(self, module, dbgsection):
         all = False
         if dbgsection == "":
             all = True
-        print(Colors.blue + Colors.BOLD +
-                'BEGENNING OF MODULE' + Colors.ENDC)
+        print(Colors.blue + Colors.BOLD + "BEGENNING OF MODULE" + Colors.ENDC)
 
         # type_section
         if module.type_section is not None and (dbgsection == "type" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Type Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('count: ' + repr(module.type_section.count))
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(Colors.blue + Colors.BOLD + "Type Section:" + Colors.ENDC)
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print("count: " + repr(module.type_section.count))
             for iter in module.type_section.func_types:
-                print(Colors.cyan + 'form: ' + repr(iter.form) + Colors.ENDC)
-                print(Colors.green + 'param count: ' + repr(iter.param_cnt) + Colors.ENDC)
-                print(Colors.red + 'param types: ' + repr(iter.param_types) + Colors.ENDC)
-                print(Colors.purple + 'return count: ' + repr(iter.return_cnt) + Colors.ENDC)
-                print(Colors.yellow + 'return type: ' + repr(iter.return_type) + Colors.ENDC)
+                print(Colors.cyan + "form: " + repr(iter.form) + Colors.ENDC)
+                print(
+                    Colors.green
+                    + "param count: "
+                    + repr(iter.param_cnt)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.red
+                    + "param types: "
+                    + repr(iter.param_types)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.purple
+                    + "return count: "
+                    + repr(iter.return_cnt)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.yellow
+                    + "return type: "
+                    + repr(iter.return_type)
+                    + Colors.ENDC
+                )
 
         # import_section
-        if module.import_section is not None and (dbgsection == "import" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Import Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('count: ' + repr(module.import_section.count))
+        if module.import_section is not None and (
+            dbgsection == "import" or all
+        ):
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(Colors.blue + Colors.BOLD + "Import Section:" + Colors.ENDC)
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print("count: " + repr(module.import_section.count))
             for iter in module.import_section.import_entry:
-                print(Colors.cyan + 'module length: ' + repr(iter.module_len) + Colors.ENDC)
-                print(Colors.green + 'module str: ' + repr(iter.module_str) + Colors.ENDC)
-                print(Colors.red + 'field length: ' + repr(iter.field_len) + Colors.ENDC)
-                print(Colors.purple + 'field str: ' + repr(iter.field_str) + Colors.ENDC)
-                print(Colors.purple + 'field str: ' + ''.join([chr(elem) for elem in iter.field_str]) + Colors.ENDC)
-                print(Colors.yellow + 'kind: ' + repr(iter.kind) + Colors.ENDC)
-                print(Colors.grey + 'type: ' + repr(iter.type) + Colors.ENDC)
-                if (type(iter.type) == Table_Type):
-                    print('element_type: ' + repr(iter.type.element_type))
-                    print('limit: ' + repr(iter.type.limit))
-                    print('flags: ' + repr(iter.type.limit.flags))
-                    print('initial: ' + repr(iter.type.limit.initial))
-                    print('maximum: ' + repr(iter.type.limit.maximum))
-                if (type(iter.type) == Global_Type):
-                    print('value_type: ' + repr(iter.type.content_type))
-                    print('mutability: ' + repr(iter.type.mutability))
-                if (type(iter.type) == Memory_Type):
-                    print('flags: ' + repr(iter.type.limits.flags))
-                    print('flags: ' + repr(iter.type.limits.initial))
-                    print('flags: ' + repr(iter.type.limits.maximum))
+                print(
+                    Colors.cyan
+                    + "module length: "
+                    + repr(iter.module_len)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.green
+                    + "module str: "
+                    + repr(iter.module_str)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.red
+                    + "field length: "
+                    + repr(iter.field_len)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.purple
+                    + "field str: "
+                    + repr(iter.field_str)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.purple
+                    + "field str: "
+                    + "".join([chr(elem) for elem in iter.field_str])
+                    + Colors.ENDC
+                )
+                print(Colors.yellow + "kind: " + repr(iter.kind) + Colors.ENDC)
+                print(Colors.grey + "type: " + repr(iter.type) + Colors.ENDC)
+                if type(iter.type) == Table_Type:
+                    print("element_type: " + repr(iter.type.element_type))
+                    print("limit: " + repr(iter.type.limit))
+                    print("flags: " + repr(iter.type.limit.flags))
+                    print("initial: " + repr(iter.type.limit.initial))
+                    print("maximum: " + repr(iter.type.limit.maximum))
+                if type(iter.type) == Global_Type:
+                    print("value_type: " + repr(iter.type.content_type))
+                    print("mutability: " + repr(iter.type.mutability))
+                if type(iter.type) == Memory_Type:
+                    print("flags: " + repr(iter.type.limits.flags))
+                    print("flags: " + repr(iter.type.limits.initial))
+                    print("flags: " + repr(iter.type.limits.maximum))
 
         # function_section
-        if module.function_section is not None and (dbgsection == "function" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Function Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('count: ' + repr(module.function_section.count))
+        if module.function_section is not None and (
+            dbgsection == "function" or all
+        ):
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(
+                Colors.blue + Colors.BOLD + "Function Section:" + Colors.ENDC
+            )
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print("count: " + repr(module.function_section.count))
             for iter in module.function_section.type_section_index:
-                print(Colors.cyan + 'type section index: ' + repr(iter) + Colors.ENDC)
+                print(
+                    Colors.cyan
+                    + "type section index: "
+                    + repr(iter)
+                    + Colors.ENDC
+                )
 
         # table_section
         if module.table_section is not None and (dbgsection == "table" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Table Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('count: ' + repr(module.table_section.count))
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(Colors.blue + Colors.BOLD + "Table Section:" + Colors.ENDC)
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print("count: " + repr(module.table_section.count))
             for iter in module.table_section.table_types:
-                print(Colors.cyan + 'element type: ' + repr(iter.element_type) + Colors.ENDC)
-                print(Colors.green + 'Resizable_Limits:flags: ' + repr(iter.limit.flags) + Colors.ENDC)
-                print(Colors.red + 'Resizable_Limits:initial: ' + repr(iter.limit.initial) + Colors.ENDC)
-                print(Colors.purple + 'Resizable_Limits:maximum: ' + repr(iter.limit.maximum) + Colors.ENDC)
+                print(
+                    Colors.cyan
+                    + "element type: "
+                    + repr(iter.element_type)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.green
+                    + "Resizable_Limits:flags: "
+                    + repr(iter.limit.flags)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.red
+                    + "Resizable_Limits:initial: "
+                    + repr(iter.limit.initial)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.purple
+                    + "Resizable_Limits:maximum: "
+                    + repr(iter.limit.maximum)
+                    + Colors.ENDC
+                )
 
         # memory_section
-        if module.memory_section is not None and (dbgsection == "memory" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Memory Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('count: ' + repr(module.memory_section.count))
+        if module.memory_section is not None and (
+            dbgsection == "memory" or all
+        ):
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(Colors.blue + Colors.BOLD + "Memory Section:" + Colors.ENDC)
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print("count: " + repr(module.memory_section.count))
             for iter in module.memory_section.memory_types:
-                print(Colors.green + 'Resizable_Limits:flags: ' + repr(iter.flags) + Colors.ENDC)
-                print(Colors.red + 'Resizable_Limits:initial: ' + repr(iter.initial) + Colors.ENDC)
-                print(Colors.purple + 'Resizable_Limits:maximum: ' + repr(iter.maximum) + Colors.ENDC)
+                print(
+                    Colors.green
+                    + "Resizable_Limits:flags: "
+                    + repr(iter.flags)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.red
+                    + "Resizable_Limits:initial: "
+                    + repr(iter.initial)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.purple
+                    + "Resizable_Limits:maximum: "
+                    + repr(iter.maximum)
+                    + Colors.ENDC
+                )
 
         # global_section
-        if module.global_section is not None and (dbgsection == "global" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Global Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('count: ' + repr(module.global_section.count))
+        if module.global_section is not None and (
+            dbgsection == "global" or all
+        ):
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(Colors.blue + Colors.BOLD + "Global Section:" + Colors.ENDC)
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print("count: " + repr(module.global_section.count))
             for iter in module.global_section.global_variables:
-                print(Colors.green + 'global type: ' + repr(iter.global_type) + Colors.ENDC)
-                print(Colors.red + 'init expr: ' + repr(iter.init_expr) + Colors.ENDC)
+                print(
+                    Colors.green
+                    + "global type: "
+                    + repr(iter.global_type)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.red
+                    + "init expr: "
+                    + repr(iter.init_expr)
+                    + Colors.ENDC
+                )
 
         # export_section
-        if module.export_section is not None and (dbgsection == "export" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Export Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('count: ' + repr(module.export_section.count))
+        if module.export_section is not None and (
+            dbgsection == "export" or all
+        ):
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(Colors.blue + Colors.BOLD + "Export Section:" + Colors.ENDC)
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print("count: " + repr(module.export_section.count))
             for iter in module.export_section.export_entries:
-                print(Colors.green + 'field length: ' + repr(iter.field_len) + Colors.ENDC)
-                print(Colors.red + 'field str: ' + repr(iter.field_str) + Colors.ENDC)
-                print(Colors.purple + 'kind: ' + repr(iter.kind) + Colors.ENDC)
-                print(Colors.cyan + 'index: ' + repr(iter.index) + Colors.ENDC)
+                print(
+                    Colors.green
+                    + "field length: "
+                    + repr(iter.field_len)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.red
+                    + "field str: "
+                    + repr(iter.field_str)
+                    + Colors.ENDC
+                )
+                print(Colors.purple + "kind: " + repr(iter.kind) + Colors.ENDC)
+                print(Colors.cyan + "index: " + repr(iter.index) + Colors.ENDC)
 
         # start_section
         if module.start_section is not None and (dbgsection == "start" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Start Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('start function index: ' + repr(module.start_section.function_section_index))
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(Colors.blue + Colors.BOLD + "Start Section:" + Colors.ENDC)
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(
+                "start function index: "
+                + repr(module.start_section.function_section_index)
+            )
 
         # element_section
-        if module.element_section is not None and (dbgsection == "element" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Element Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('count: ' + repr(module.element_section.count))
+        if module.element_section is not None and (
+            dbgsection == "element" or all
+        ):
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(Colors.blue + Colors.BOLD + "Element Section:" + Colors.ENDC)
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print("count: " + repr(module.element_section.count))
             for iter in module.element_section.elem_segments:
-                print(Colors.green + 'index: ' + repr(iter.index) + Colors.ENDC)
-                print(Colors.red + 'offset: ' + repr(iter.offset) + Colors.ENDC)
-                print(Colors.purple + 'num_elem: ' + repr(iter.num_elem) + Colors.ENDC)
-                print(Colors.cyan + 'elemes:' + repr(iter.elems) + Colors.ENDC)
+                print(
+                    Colors.green + "index: " + repr(iter.index) + Colors.ENDC
+                )
+                print(
+                    Colors.red + "offset: " + repr(iter.offset) + Colors.ENDC
+                )
+                print(
+                    Colors.purple
+                    + "num_elem: "
+                    + repr(iter.num_elem)
+                    + Colors.ENDC
+                )
+                print(Colors.cyan + "elemes:" + repr(iter.elems) + Colors.ENDC)
 
         # code_section
         if module.code_section is not None and (dbgsection == "code" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Code Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('count: ' + repr(module.code_section.count))
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(Colors.blue + Colors.BOLD + "Code Section:" + Colors.ENDC)
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print("count: " + repr(module.code_section.count))
             for iter in module.code_section.func_bodies:
-                print(Colors.green + 'body size: ' + repr(iter.body_size) + Colors.ENDC)
-                print(Colors.red + 'local enrty count: ' + repr(iter.local_count) + Colors.ENDC)
+                print(
+                    Colors.green
+                    + "body size: "
+                    + repr(iter.body_size)
+                    + Colors.ENDC
+                )
+                print(
+                    Colors.red
+                    + "local enrty count: "
+                    + repr(iter.local_count)
+                    + Colors.ENDC
+                )
                 for iterer in iter.locals:
-                    print(Colors.blue + 'local count: ' + repr(iterer.count) + Colors.ENDC)
-                    print(Colors.blue + 'local type: ' + repr(iterer.type) + Colors.ENDC)
+                    print(
+                        Colors.blue
+                        + "local count: "
+                        + repr(iterer.count)
+                        + Colors.ENDC
+                    )
+                    print(
+                        Colors.blue
+                        + "local type: "
+                        + repr(iterer.type)
+                        + Colors.ENDC
+                    )
                 for iterer in iter.code:
-                    instruction = iterer.opcode + ' ' + repr(iterer.operands)
+                    instruction = iterer.opcode + " " + repr(iterer.operands)
                     print(Colors.yellow + instruction + Colors.ENDC, end="")
                     print("\t", end="")
-                    print(Colors.cyan + 'opcode: ' + repr(iterer.opcode) + Colors.ENDC, end="")
+                    print(
+                        Colors.cyan
+                        + "opcode: "
+                        + repr(iterer.opcode)
+                        + Colors.ENDC,
+                        end="",
+                    )
                     print("\t", end="")
-                    print(Colors.grey + 'immediate: ' + repr(iterer.operands) + Colors.ENDC, end="")
+                    print(
+                        Colors.grey
+                        + "immediate: "
+                        + repr(iterer.operands)
+                        + Colors.ENDC,
+                        end="",
+                    )
                     print("\t", end="")
-                    print(Colors.UNDERLINE + "num of operands: " + repr(len(iterer.operands)) + Colors.ENDC)
+                    print(
+                        Colors.UNDERLINE
+                        + "num of operands: "
+                        + repr(len(iterer.operands))
+                        + Colors.ENDC
+                    )
 
         # data_section
         if module.data_section is not None and (dbgsection == "data" or all):
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print(Colors.blue + Colors.BOLD + 'Data Section:' + Colors.ENDC)
-            print(Colors.blue + '------------------------------------------------------' + Colors.ENDC)
-            print('count: ' + repr(module.data_section.count))
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print(Colors.blue + Colors.BOLD + "Data Section:" + Colors.ENDC)
+            print(
+                Colors.blue
+                + "------------------------------------------------------"
+                + Colors.ENDC
+            )
+            print("count: " + repr(module.data_section.count))
             for iter in module.data_section.data_segments:
-                print(Colors.green + 'index: ' + repr(iter.index) + Colors.ENDC)
-                print(Colors.red + 'offset: ' + repr(iter.offset) + Colors.ENDC)
-                print(Colors.purple + 'size: ' + repr(iter.size) + Colors.ENDC)
-                print(Colors.cyan + 'data:' + repr(iter.data) + Colors.ENDC)
+                print(
+                    Colors.green + "index: " + repr(iter.index) + Colors.ENDC
+                )
+                print(
+                    Colors.red + "offset: " + repr(iter.offset) + Colors.ENDC
+                )
+                print(Colors.purple + "size: " + repr(iter.size) + Colors.ENDC)
+                print(Colors.cyan + "data:" + repr(iter.data) + Colors.ENDC)
 
     # palceholder for the validation tests
     def runValidations(self):
         modulevalidation = ModuleValidation(self.modules[0])
-        return(modulevalidation.ValidateAll())
+        return modulevalidation.ValidateAll()
+
 
 def premain(argparser):
     interpreter = PythonInterpreter()
@@ -990,9 +1468,13 @@ def premain(argparser):
             if argparser.args.dbg or argparser.args.dbgsection:
                 interpreter.dump_sections(module, argparser.args.dbgsection)
             if interpreter.runValidations():
-                print(Colors.red + "validations are not implemented yet" + Colors.ENDC)
+                print(
+                    Colors.red
+                    + "validations are not implemented yet"
+                    + Colors.ENDC
+                )
             else:
-                print(Colors.red + 'failed validation tests' + Colors.ENDC)
+                print(Colors.red + "failed validation tests" + Colors.ENDC)
             vm = VM(interpreter.getmodules())
             vm.setFlags(argparser.getParseFlags())
             ms = vm.getState()
@@ -1011,11 +1493,15 @@ def premain(argparser):
         shell = code.InteractiveConsole(variables)
         shell.interact(banner="WASM python REPL")
     if argparser.args.hexdump:
-        dumpprettysections(interpreter.getsections(), argparser.args.hexdump, "")
+        dumpprettysections(
+            interpreter.getsections(), argparser.args.hexdump, ""
+        )
     if argparser.args.sectiondump is not None:
-        dumpprettysections(interpreter.getsections(), 24, argparser.args.sectiondump)
+        dumpprettysections(
+            interpreter.getsections(), 24, argparser.args.sectiondump
+        )
     if argparser.args.wast:
-        #print(argparser.getWASTPath())
+        # print(argparser.getWASTPath())
         parser = ParserV1(argparser.getWASTPath())
         parser.run()
     # WIP-the assmebler
@@ -1027,6 +1513,7 @@ def premain(argparser):
         print("not implemented yet")
         sys.exit(1)
 
+
 def main():
     argparser = Argparser()
     if argparser.args.dbg:
@@ -1040,5 +1527,6 @@ def main():
     else:
         premain(argparser)
 
+
 if __name__ == "__main__":
     main()