Fix bug with binary.

compiler.py

@@ -24,6 +24,8 @@
 #   P - Operand (only there if M is 01)
 #
 
+from sys import stdin, stdout, argv, exit
+
 class Data:
     def __init__(self, string):
         self.length = len(string) // 4
@@ -43,8 +45,12 @@ class Data:
         """
         Convert the instruction to a binary string.
         """
-        code = [bin(x)[2:] for x in self.data]
+        result = []
-        return "".join(('0' * (WORD_SIZE - len(x))) + x for x in code)
+        for x in self.data:
+            c = bin(x)[2:]
+            result.append(('0' * (4 - len(c))) + c)
+        return "".join(result)
+
 
 class Instruction:
     """
@@ -105,10 +111,11 @@ class Instruction:
         if self.length == 1:
             length = WORD_SIZE // 1
         else:
-            length = WORD_SIZE // 2
+            length = WORD_SIZE * 2
         code = bin(self.instruction)[2:]
         return ('0' * (length - len(code))) + code
 
+
 OPCODE_TABLE = {   
     "LOAD"  : 0b0000,
     "STORE" : 0b0001,
@@ -137,8 +144,6 @@ REGISTERS = {
 
 WORD_SIZE = 16
 
-from sys import stdin, stdout, argv, exit
-
 output_format = "hex"
 input_file = False
 output_file = False
@@ -232,83 +237,88 @@ def parse_instruction(args):
     return Instruction(opcode, register, mode, address)
 
 
-success = True
+def main():
-line_number = 0 # The line in the source file
+    success = True
-word = 0 # The current word
+    line_number = 0 # The line in the source file
-instructions = []
+    word = 0 # The current word
-tag_table = {}
+    instructions = []
-for line in input_file:
+    tag_table = {}
-    line_number += 1
+
-    if "#" in line:
+    for line in input_file:
-        line = line[:line.index("#")]
+        line_number += 1
-    args = line.replace(",", "").replace("_", "").strip().split()
+        if "#" in line:
-    if not args: continue
+            line = line[:line.index("#")]
-    OP = args[0].upper()
+        args = line.replace(",", "").replace("_", "").strip().split()
-    if OP in OPCODE_TABLE:
+        if not args: continue
-        # It's an op!
+        OP = args[0].upper()
-        try:
+        if OP in OPCODE_TABLE:
-            inst = parse_instruction(args)
+            # It's an op!
-            instructions.append(inst)
+            try:
-            word += inst.length
+                inst = parse_instruction(args)
-        except SyntaxError as e:
+                instructions.append(inst)
-            success = False
+                word += inst.length
-            print("ERROR:{} {}".format(line_number, str(e)))
+            except SyntaxError as e:
-    elif OP.endswith(":"):
+                success = False
-        # Tags for jumps
+                print("ERROR:{} {}".format(line_number, str(e)))
-        tag = args[0][:-1]
+        elif OP.endswith(":"):
-        if tag not in tag_table:
+            # Tags for jumps
-            tag_table[tag] = word
+            tag = args[0][:-1]
+            if tag not in tag_table:
+                tag_table[tag] = word
+            else:
+                print("ERROR:{} Multiple instances of tag \"{}\"".format(line_number, tag))
+                success = False
+        elif OP == ".":
+            # Data fields
+            data = Data("".join(args[1:]).replace(" ", "").replace("\t", ""))
+            instructions.append(data)
+            word += data.length
         else:
-            print("ERROR:{} Multiple instances of tag \"{}\"".format(line_number, tag))
+            print("ERROR:{} Unknown symbol \"{}\"".format(line_number, line))
             success = False
-    elif OP == ".":
+
-        # Data fields
+    for instruction in instructions:
-        data = Data("".join(args[1:]).replace(" ", "").replace("\t", ""))
+        try:
-        instructions.append(data)
+            if type(instruction) == Instruction:
-        word += data.length
+                instruction.bake(tag_table)
+        except SyntaxError as e:
+            print("LINKING ERROR: {}".format(e))
+            success = False
+
+    if not success:
+        return 1
+
+    def print_as_hex(out, inst, newlines):
+        string = instruction.to_hex()
+        if newlines:
+            while string:
+                out.write(string[:WORD_SIZE // 4])
+                out.write("\n")
+                string = string[WORD_SIZE // 4:]
+        out.write(string)
+
+    def print_as_bin(out, inst, newlines):
+        string = instruction.to_bin()
+        if newlines:
+            while string:
+                out.write(string[:WORD_SIZE])
+                out.write("\n")
+                string = string[WORD_SIZE:]
+        out.write(string)
+
+    if output_format == "hex":
+        print_func = print_as_hex
     else:
-        print("ERROR:{} Unknown symbol \"{}\"".format(line_number, line))
+        print_func = print_as_bin 
-        success = False
 
-for instruction in instructions:
+    for instruction in instructions:
-    try:
+        print_func(output_file, instruction, newlines)
-        if type(instruction) == Instruction:
-            instruction.bake(tag_table)
-    except SyntaxError as e:
-        print("LINKING ERROR: {}".format(e))
-        success = False
 
-if not success:
+    output_file.flush()
-    exit(1)
+    output_file.close()
 
-def print_as_hex(out, inst, newlines):
-    string = instruction.to_hex()
-    if newlines:
-        while string:
-            out.write(string[:WORD_SIZE // 4])
-            out.write("\n")
-            string = string[WORD_SIZE // 4:]
-    out.write(string)
 
-def print_as_bin(out, inst, newlines):
+if __name__ == "__main__":
-    string = instruction.to_bin()
+    exit(main())
-    if newlines:
-        while string:
-            out.write(string[:WORD_SIZE])
-            out.write("\n")
-            string = string[WORD_SIZE:]
-    out.write(string)
-
-if output_format == "hex":
-    print_func = print_as_hex
-else:
-    print_func = print_as_bin 
-
-for instruction in instructions:
-    print_func(output_file, instruction, newlines)
-output_file.flush()
-output_file.close()
-
-exit(0)