def __init__(self, args, dm): self.dm = dm # Global Debug Manager instance self.args = args # Tool Config object self.args.display() # If CINFO requested, display it self.clstats = args["stats"] # Command-line statistics flag # Enable any command line debug flags for flag in args["debug"]: self.dm.enable(flag) self.aout=assembler.AsmOut(\ deck=args["object"],\ image=args["image"],\ ldipl=args["gldipl"],\ listing=args["listing"],\ mc=args["store"],\ rc=args["rc"],\ vmc=args["vmc"]) msl, cpu = self.target() mslpath = args["mslpath"] # MSL PathMgr object cptrans, cpfile = self.code_page("94C") defn = self.defines() self.assembler=assembler.Assembler(cpu,msl,mslpath,self.aout,\ addr=args["addr"],\ case=args["case"],\ debug=dm,\ defines=defn,\ dump=args["dump"],\ error=args["error"],\ nest=args["nest"],\ otrace=args["oper"],\ cpfile=cpfile,\ cptrans=cptrans,\ mcall=args["mcall"],\ asmpath=args["asmpath"],\ maclib=args["maclib"]) self.source = args["input"] # Source input file # Gather together time related data saved outside this object. self.process_start = process_start self.wall_start = wall_start self.import_start = import_start self.import_start_w = import_start_w self.objects_start = objects_start self.objects_start_w = objects_start_w # Timer information gathered during run() method self.assemble_end = None self.assemble_end_w = None self.out_end = None self.out_end_w = None # Save some of my own time information self.objects_end = time.process_time() self.objects_end_w = time.time()
def __init__(self,args,dm): self.dm=dm # Global Debug Manager instance self.args=args # Command line arguments self.clstats=args.stats # Command-line statistics flag # Enable any command line debug flags for flag in self.args.debug: self.dm.enable(flag) self.aout=assembler.AsmOut(\ deck=args.object,\ image=args.image,\ ldipl=args.gldipl,\ listing=args.listing,\ mc=args.store,\ rc=args.rc,\ vmc=args.vmc) msl,cpu=self.target() cptrans,cpfile=self.code_page("94C") defn=self.defines() self.assembler=assembler.Assembler(cpu,msl,self.aout,\ msldft=satkutil.satkdir("asma/msl"),\ addr=args.addr,\ bltin=args.bltin,\ case=args.case,\ debug=dm,\ defines=defn,\ dump=args.dump,\ error=args.error,\ nest=self.args.nest,\ ptrace=args.pas,\ otrace=args.oper,\ cpfile=cpfile,\ cptrans=cptrans) self.source=args.source[0] # Source input file # Gather together time related data saved outside this object. self.process_start=process_start self.wall_start=wall_start self.import_start=import_start self.import_start_w=import_start_w self.objects_start=objects_start self.objects_start_w=objects_start_w # Timer information gathered during run() method self.assemble_end=None self.assemble_end_w=None self.out_end=None self.out_end_w=None # Save some of my own time information self.objects_end=time.process_time() self.objects_end_w=time.time()
class TestAssembler(unittest.TestCase): a = asm.Assembler('../test/tasks') def test_setupTask(self): flow = self.a.assembleFromText(['src 2', 'add -1']) flow.execute() self.assertTrue(flow.tasks[1].ready) def test_assembleText(self): flow = self.a.assembleFromText(['src 2']) self.assertIsInstance(flow, asm.MacroFlow) self.assertEqual(len(flow.tasks), 1) self.assertEqual(flow.execute()['item'], 2) def test_assembleFail(self): with self.assertRaises(ConstructException): flow = self.a.assembleFromText(['noTask']) def test_tolerateEmptyLines(self): text = ['src 3', '', 'add 2'] flow = self.a.assembleFromText(text) self.assertEqual(len(flow.tasks), 2) self.assertEqual(flow.execute()['item'], 5) def test_assembleMulti(self): flow = self.a.assembleFromText(['src 2', 'add 1', 'add 2']) self.assertEqual(flow.execute()['item'], 5) def test_assembleThreeway(self): flow = self.a.assembleFromText(['src 2', 'dup', 'add 3']) rslt = flow.execute() self.assertEqual(rslt['item'], 5) self.assertEqual(rslt['thing'], 2) def test_customFlow(self): text = [ 'src (>val) 0', 'dup (val>val1,val2)', 'add (val1 > val1) 3', 'add (val2>val2)1' ] flow = self.a.assembleFromText(text) rslt = flow.execute() self.assertEqual(rslt['val1'], 3) self.assertEqual(rslt['val2'], 1) def test_customFlowFailInputs(self): text = ['src 0', 'dup (item, item>item, val)'] with self.assertRaises(ConstructException): flow = self.a.assembleFromText(text) def test_customFlowFailScope(self): text = ['src (>val) -4', 'add (val1>val1) 3'] with self.assertRaises(ConstructException): flow = self.a.assembleFromText(text)
def test_max(self): self.test_code = assembler.Assembler(argv='max/Max.asm') self.f = open('max/Max.hack') test_file = self.f.read() self.test_code.parse_file() # This creates hack output file self.g = open('max/Max1.hack') # Open hack output file out_file = self.g.read() self.assertEqual(out_file, test_file) # Check both files the same self.f.close() # close the files to tidy up self.g.close()
def main_cli(args_from_parser, exc_reporter): if len(args_from_parser.file) > 1: print("Too many files") return 1 try: with open(args_from_parser.file[0] or input("Filename: ")) as f: code = f.read() except IOError as e: print("Could not open file:", e) return 1 print("Assembling...") assem = assembler.Assembler() assem.update_code(code) assem.assemble() if assem.problems: print("\n".join(i.show(code.splitlines()) for i in assem.problems)) if assem.in_error: print("Assembly failed") return 1 print("Assembly succeeded") machine_code, code_length = (assem.machine_code, assem.machine_code_length) if args_from_parser.debug: print("Code:") print(" ".join(map(str, machine_code[:code_length]))) print("Loading code...") run = runner.Runner(lambda x: print(">>>", x)) run.load_code(assem) print("Running...") while run.halt_reason != runner.HaltReason.hlt: if args_from_parser.debug >= 2: print("Memory:") print(*[i.value for i in run.memory]) print("Executing instruction {:03} at {:03}".format( run.memory[run.counter].value, run.counter)) try: run.next_step() except RuntimeError as e: print("Error", e.args[0]) except (KeyboardInterrupt, EOFError): break if run.halt_reason == runner.HaltReason.input: try: run.give_input(int(input("<<< "))) except (KeyboardInterrupt, EOFError): break if args_from_parser.debug >= 1: print(run.hint) return 0
class TestReduction(unittest.TestCase): a = asm.Assembler('../test/tasks') def test_reductionSP(self): expected = [500500] text = ['lst 1001', 'reduce_sum (item>sum)'] flow = self.a.assembleFromText(text, 1) flow.execute() self.assertEqual(flow.scope['sum'], expected) def test_reductionMP(self): expected = [500500] text = ['lst 1001', 'reduce_sum (item>sum)'] flow = self.a.assembleFromText(text, 8) flow.execute() self.assertEqual(flow.scope['sum'], expected)
def main(): """Initial setup operation function""" parser = argparse.ArgumentParser( description='Era - an Easy Retargetable Assembler') parser.add_argument('-t', '--target', help='target') parser.add_argument('-i', '--input', help='input file') parser.add_argument('-o', '--output', help='output file') parser.add_argument('-v', '--verbose', help='Verbose output', action='store_true') args = parser.parse_args() if len(sys.argv) <= 2: parser.print_help() quit(404) # Set targets path and import set target or default(MIPS I) sys.path.append('./targets') if args.target: target = __import__(args.target) else: target = __import__('target0') # Import assembly file with open(args.input, 'r') as asmfile: asmLines = asmfile.readlines() # Initialize asm_object = assembler.Assembler(asmLines, target, args.verbose) # Link identity pass asm_object.linkIdentityPass() # Second assembler pass asm_object.secondPass() # Link passes asm_object.linkPasses() # Assemble and convert to a binary object memoryArray = bytes(asm_object.assemble()) # Assembled file writer outname = args.output if args.output else 'a.out' with open(outname, 'wb') as outfile: outfile.write(memoryArray) quit(0)
def test_add(self): self.test_code = assembler.Assembler( argv='add/Add.asm' ) # create new assembler instance with file argument self.f = open( 'add/gAdd.hack' ) # first we open test file (created by course assembler) test_file = self.f.read() self.test_code.parse_file() # This creates hack output file self.g = open('add/Add1.hack') # Open hack output file out_file = self.g.read() self.assertEqual(out_file, test_file) # Check both files the same self.f.close() # close the files to tidy up self.g.close()
def test_assemble(self): test_cases = [ ("Rect.asm", "Rect_expected.hack"), ("Max.asm", "Max_expected.hack"), ("Pong.asm", "Pong_expected.hack"), ] for case in test_cases: source = Path(case[0]) expected = Path(case[1]).read_text() _parser = parser.Parser() with open(source) as f: commands = _parser.parse(f) _assembler = assembler.Assembler() hack_code = _assembler.assemble(commands) self.assertEqual(expected.strip(), hack_code.strip())
class TestAssemblerParallel(unittest.TestCase): a = asm.Assembler('../test/tasks') def test_parallelFlow(self): expected = [1, 2, 3, 4, 5] text = ['lst 5', 'incr (item>plus1) 1', 'dup(plus1>a,b)'] flow = self.a.assembleFromText(text) flow.execute() self.assertIn('plus1', flow.scope.keys()) self.assertEqual(flow.scope['plus1'], expected) def test_multipleOutputsFlow(self): expected_c = [0.5, 1.0, 1.5, 2.0] expected_d = [2, 4, 6, 8] text = [ 'lst (>a) 4', 'incr (a>b) 1', 'simo (b>c,d) 2', 'get(c)', 'get(d)' ] flow = self.a.assembleFromText(text) flow.execute() self.assertIn('c', flow.scope.keys()) self.assertIn('d', flow.scope.keys()) self.assertEqual(flow.scope['c'], expected_c) self.assertEqual(flow.scope['d'], expected_d) def test_multipleFlows(self): expected_b = [1, 2, 3, 4] expected_d = [2, 6, 12, 20] text = [ 'lst (>a) 4', 'incr (a>b) 1', 'get (b)', 'incr (a>c) 2', 'vmul (b,c>d)', 'get (d)' ] flow = self.a.assembleFromText(text) flow.execute() self.assertIn('b', flow.scope.keys()) self.assertIn('d', flow.scope.keys()) self.assertNotIn('c', flow.scope.keys()) self.assertEqual(flow.scope['b'], expected_b) self.assertEqual(flow.scope['d'], expected_d)
class TestImport(unittest.TestCase): assembler = asm.Assembler('../test/tasks') def test_importSerial(self): a = self.assembler self.assertEqual(len(a.tasks_serial.keys()), 5) self.assertIn('src', a.tasks_serial.keys()) self.assertIn('add', a.tasks_serial.keys()) self.assertIn('dup', a.tasks_serial.keys()) self.assertIn('lst', a.tasks_serial.keys()) self.assertIn('get', a.tasks_serial.keys()) def test_importParallel(self): a = self.assembler self.assertEqual(len(a.tasks_parallel.keys()), 3) self.assertIn('incr', a.tasks_parallel.keys()) self.assertIn('vmul', a.tasks_parallel.keys()) self.assertIn('simo', a.tasks_parallel.keys()) def test_importReducer(self): a = self.assembler self.assertEqual(len(a.tasks_reducer.keys()), 1) self.assertIn('reduce_sum', a.tasks_reducer.keys())
def set_name(self): pass def breakpoints_changed(self): master = self.master while hasattr(master, "master"): if hasattr(master, "breakpoints_changed"): return master.breakpoints_changed(self.breakpoints) master = master.master if __name__ == "__main__": import sys import tkinter.ttk as ttk assem = assembler.Assembler() assem.update_code(open(sys.argv[1]).read()) print(assem.assemble()) runner_ = runner.Runner(lambda x: print(">>>", x)) runner_.load_code(assem) root = tkinter.Tk(className='ToolTip-demo') t = ttk.Notebook(root) t.grid(sticky=tkinter.NE + tkinter.SW) ce = DebugCodeEditor(t) t.add(ce, text="Hi") root.columnconfigure(0, weight=1) root.rowconfigure(0, weight=1) ce.update_runner(runner_) def c(): runner_.next_step()
#import definition import definition_stackvm as definition import assembler code = """push 0 push 1 add out halt""" def pad(bin_str, l=8): return "0" * (l - len(bin_str)) + bin_str asm = assembler.Assembler(code, definition) data = asm.assemble() dl = len(data) len0 = (dl >> 24) & 0xFF len1 = (dl >> 16) & 0xFF len2 = (dl >> 8) & 0xFF len3 = (dl >> 0) & 0xFF lendata = chr(len0).encode("utf-8") + \ chr(len1).encode("utf-8") + \ chr(len2).encode("utf-8") + \ chr(len3).encode("utf-8") with open("test.vm", "wb") as f: f.write(lendata + b"".join(chr(x).encode("utf-8") for x in data)) #print("\n".join([pad(bin(x)[2:]) for x in asm.assemble()]))
def main(): asm = assembler.Assembler() r_list = [ "add x10, x11, x12", "sub x10, x11, x12", "sll x10, x11, x12", "slt x10, x11, x12", "sltu x10, x11, x12", "xor x10, x11, x12", "srl x10, x11, x12", "sra x10, x11, x12", "or x10, x11, x12", "and x10, x11, x12" ] j_list = [ "jal ra, 524287", "jal ra, 339064", "jal ra, -524288", "jal ra, -524289", "jalr ra, a0, 2047", "jalr ra, a0, 2048", "jalr ra, a0, -2048", "jalr ra, a0, -2049" ] b_list = [ "beq a0, a1, 4", "bne a0, a1, 4", "blt a0, a1, 4", "bge a0, a1, 4", "bltu a0, a1, 4", "bgeu a0, a1, 4" ] l_list = [ "lb a0, a1, 4", "lh a0, a1, 4", "lw a0, a1, 4", "lbu a0, a1, 4", "lhu a0, a1, 4" ] s_list = [ "sb a0, a1, 2201", "sh a0, a1, 2201", "sw a0, a1, 2201" ] i_list = [ "addi x10, x11, 29", "slli x10, x11, 29", "slti x10, x11, 29", "sltiu x10, x11, 29", "xori x10, x11, 29", "srli x10, x11, 29", "srai x10, x11, 29", "ori x10, x11, 29", "andi x10, x11, 29" ] for instr in instr_list: print(instr) print(hex(asm.convert(instr) & 0xFFFFFFFF))
def setUp(self): self.test_code = assembler.Assembler()
def __init__(self, master): super().__init__(master) self.tooltip_token = self.tooltip = self.tooltip_reg = self.tooltip_xy = None self.highlighted_tokens = [] self.highlight_reg = self.syntax_update_reg = None self.highlight_force = False self.hovered_token_mode = "cursor" # dict of address to breakpoint type self.breakpoints = collections.defaultdict( lambda: runner.BreakpointState.off) self.linebar_type = LineBarMode.address self.sidebar_markers = set() self.fname = None self.text = CustomText(self, bg="white", wrap=tkinter.NONE, undo=True) self.text.grid(column=1, row=0, sticky=tkinter.NE + tkinter.SW) self.sideframe = tkinter.Frame(self) self.sideframe.grid(column=0, row=0, sticky=tkinter.N + tkinter.S) self.sideframe.rowconfigure(0, weight=1) self.sideframe.columnconfigure(1, weight=1) self.linebar = tkinter.Text(self.sideframe, bg="white", width=2, wrap=tkinter.NONE) self.linebar.grid(column=0, row=0, sticky=tkinter.N + tkinter.S) self.linebar["yscrollcommand"] = functools.partial(self.yscroll, self.linebar, yxmode=True) self.breakbar = tkinter.Text(self.sideframe, bg="white", fg="red", width=2, wrap=tkinter.NONE) self.breakbar.grid(column=1, row=0, sticky=tkinter.N + tkinter.S) self.breakbar["yscrollcommand"] = functools.partial(self.yscroll, self.breakbar, yxmode=True) self.breakbar["state"] = "disabled" self.linebar["state"] = "disabled" self.vbar = tkinter.Scrollbar(self) self.vbar["command"] = functools.partial(self.yscroll, self.vbar) self.vbar.grid(column=2, row=0, sticky=tkinter.N + tkinter.S) self.hbar = tkinter.Scrollbar( self, orient=tkinter.HORIZONTAL, command=lambda *a: (self.nuke_tooltip(), self.text.xview(*a))) self.hbar.grid(column=0, row=1, columnspan=2, sticky=tkinter.E + tkinter.W) self.text["xscrollcommand"] = lambda y, x: (self.nuke_tooltip(), self.hbar.set(y, x)) self.text["yscrollcommand"] = functools.partial(self.yscroll, self.text, yxmode=True) self.columnconfigure(1, weight=1) self.rowconfigure(0, weight=1) self.assembler = assembler.Assembler() # Highlighting normal_font = self.text.cget("font") bold_font = tkfont.Font(self.text, normal_font) bold_font["weight"] = "bold" self.underline_font = tkfont.Font(self.text, normal_font) self.underline_font["underline"] = "1" self.underline_bold_font = tkfont.Font(self.text, bold_font) self.underline_bold_font["underline"] = "1" self.text.tag_configure("comment", foreground=COMMENT_COLOR, background="white") self.text.tag_configure("text", background="white") self.text.tag_configure("mnemonic", font=bold_font, background="white") self.text.tag_configure("label", font=bold_font, foreground=LABEL_COLOR, background="white") self.text.tag_configure("labelref", foreground=LABEL_COLOR, background="white") self.text.tag_configure("number", foreground=NUMBER_COLOR, background="white") self.text.tag_configure("breakpoint", background=BREAKPOINT_BG_COLOR) self.breakbar.tag_configure("breakpoint", foreground="red", font=bold_font) self.text.tag_raise( "sel" ) # Otherwise selecting a label, mnemonic, etc. will results in a white background self.text.bind("<Motion>", self.motion) self.text.bind("<Leave>", self.leave) self.text.bind("<Enter>", self.enter) self.text.bind("<FocusOut>", self.leave) self.text.bind("<FocusIn>", self.enter) self.text.bind("<Control-d>", self.comment_line) self.text.bind("<Control-D>", self.decomment_line) self.text.bind("<Tab>", self.indent) self.text.bind("<Shift-Tab>", self.deindent) self.text.bind("<ISO_Left_Tab>", self.deindent) self.text.set_insert_moved_callback(self.insert_moved) self.tags = collections.defaultdict(list) self.token_to_tag = {} self.token_to_problem_tag = {} self.change_breakpoint_var = tkinter.StringVar() self.text_menu = tkinter.Menu(self.text, tearoff=0, takefocus=True) self.change_breakpoint_menu = tkinter.Menu(self.text_menu, tearoff=0) for option in runner.BreakpointState: self.change_breakpoint_menu.add_radiobutton( label=option.value.title(), variable=self.change_breakpoint_var, value=option.value, command=self.do_change_breakpoint) self.breakbar.bind("<Button-3>", self.change_breakpoint) self.text_menu.add_cascade(label="Breakpoint", menu=self.change_breakpoint_menu) self.text_menu.add_separator() self.text_menu.add_command(label="Comment line", command=self.comment_line) self.text_menu.add_command(label="Decomment line", command=self.decomment_line) self.text_menu.add_separator() self.text_menu.add_command(label="Indent line", command=self.indent) self.text_menu.add_command(label="Deindent line", command=self.deindent) self.text.bind("<Button-3>", self.launch_text_menu)
def addSingleRobot(sim, controllerStr): ass0 = assembler.Assembler(sim, [0, 0, 3]) ass0.setController(controllerStr) return ass0
import startupProcess as start import assembler import constructor import solver import output if __name__ == '__main__': filename = "simple_truss2" + start.EXT #filename = start.handle_startup() element_type, units = start.get_filedata(filename) solver = solver.Solver() if element_type == start.ELEMENT_TRUSS: assembler = assembler.Assembler(filename) assembler.handle_truss() constructor = constructor.Constructor(elements=assembler.elements, nodes=assembler.nodes) k, f = constructor.get_simplified_system() u = constructor.get_final(solver.solve_all(k, f)) output.gen_output(filename, element_type, units, u) output.disp_output(filename, element_type, units, u)
import argparse import parser from pathlib import Path import assembler if __name__ == "__main__": command_line_parser = argparse.ArgumentParser( description="nand2tetris Hack assembler") command_line_parser.add_argument("source", type=str, nargs=1, help="hack computer .asm file") args = command_line_parser.parse_args() source = Path(args.source[0]).absolute() dest = Path(source.parent) / f"{source.stem}.hack" parser = parser.Parser() print("🏁 ASSEMBLING 🏁") with open(source) as f: instructions = parser.parse(f) assembler = assembler.Assembler() with open(dest, "w") as f: f.write(assembler.assemble(instructions)) print("🏆 DONE 🏆")
parser = argparse.ArgumentParser(usage="%(prog)s option filename", description="6502 Assembler/Disassembler/Simulator") parser.add_argument("-a", "--assemble", action="store_true", dest="assemble", default=False, help="assemble the code in FILE") parser.add_argument("-d", "--disassemble", action="store_true", dest="disassemble", default=False, help="disassemble the code in FILE") parser.add_argument("-q", "--quiet", action="store_true", dest="quiet", default=False, help="quiet mode") parser.add_argument("-t", "--trace", action="store_true", dest="trace", default=False, help="trace the code in FILE") parser.add_argument("-x", "--execute", action="store_true", dest="execute", default=False, help="execute the code in FILE") parser.add_argument("-v", "--version", action="version", version="%(prog)s " + app_version) parser.add_argument("filename") args = parser.parse_args() infile = args.filename if args.assemble: if not args.quiet: print ("Assembling...") assembler = assembler.Assembler(infile) code = assembler.assemble() if assembler.errorcount() > 0: sys.exit() outfile = infile + ".out" f = open(outfile, "w") json.dump(code, f) f.close() infile = outfile if args.disassemble: if not args.quiet: print ("Disassembling...")
def scan(self): #seperate tags from value self.tags = [] self.values = [] self.posValues = [[]] #where a value starts and ends self.elements = [[]] #tags + values self.UL_values = [] # all of the values of all ULs self.OL_values = [] # all of the values of all OLs self.TAB_values = [] # all of the values of all tables iter = 0 self.x_scan_index = 0 while self.x_scan_index < len(self.input): cnt = 0 # get mulitdimentional tags if self.input[self.x_scan_index:self.x_scan_index + 4] == "<ul>": self.scan_multidim_elements("<ul>", "</ul>") elif self.input[self.x_scan_index:self.x_scan_index + 4] == "<gl>": self.scan_multidim_elements("<gl>", "</gl>") elif self.input[self.x_scan_index:self.x_scan_index + 9] == "<tabelle>": self.scan_multidim_elements("<tabelle>", "</tabelle>") #get normal tags elif self.input[self.x_scan_index] == '<': strTag = "" while self.input[self.x_scan_index + cnt - 1] != '>': strTag += self.input[self.x_scan_index + cnt] cnt += 1 self.tags.append(strTag) self.posValues.insert( iter, [self.x_scan_index, self.x_scan_index + cnt]) iter += 1 self.x_scan_index += 1 self.x_scan_index = 0 print(self.tags) for x in range(len(self.posValues) - 2): bor1 = self.posValues[x][1] bor2 = self.posValues[x + 1][0] # get the end of the last and the beginning of the next if self.input[bor1:bor2] != "\n": self.values.append(self.input[bor1:bor2]) index = 0 temp_ul_count = 0 #count of the values assigned to element of ul temp_ol_count = 0 #count of the values assigned to element of ol # division to body and head for x in range(len(self.tags) - 1): for y in range(len(self.commands)): if self.tags[x] == self.commands[y]: if self.tags[x] == "<ul>": self.elements.insert( index, [self.tags[x], self.UL_values[temp_ul_count]]) temp_ul_count += 1 index += 1 elif self.tags[x] == "<gl>": self.elements.insert( index, [self.tags[x], self.OL_values[temp_ol_count]]) temp_ol_count += 1 index += 1 else: self.elements.insert( index, [self.tags[x], self.values[index]]) index += 1 # precheck if code is valid and run if len(self.tags) <= 2: self.check_code() elif self.tags[0] != "<!DOCTYPE htas>" or self.tags[ 1] != "<htas>" or self.tags[ len(self.tags) - 2] != "</koerper>" or self.tags[ len(self.tags) - 1] != "</htas>" or not "<koerper>" in self.tags: self.check_code() elif "<titel>" in self.tags: if "</kopf>" in self.tags and "<kopf>" in self.tags: if "<anknuepfen bez='Stilbogen' typ='text/ksb' hbez='index.ksb'>" in self.tags: htas = ksb_compiler.Compiler(self.canvas, self.input_ksb) assembler.Assembler(self.canvas, self.elements, htas.changes) else: assembler.Assembler(self.canvas, self.elements, self.input_ksb) else: self.check_code() else: assembler.Assembler(self.canvas, self.elements, self.input_ksb)
#-------------------------------------------- line_arr = [] for line in filetext: line_arr.append(line) #store each line in array #-------------------------------------------- mem = [] if len(line_arr) > 65536: print('Error: Overflow Memory') exit(1) for i in range(0, len(line_arr)): #สร้าง mem เท่ากับจำนวนบรรทัด mem.append(0) reg = [] #สร้าง register 8 ตัว ไว้เก็บค่า เอาไปใช้ใน simulator for i in range(0, 8): reg.append(0) #-------------------------------------------- PC = 0 while PC < len(line_arr): #วนจนกว่าจะหมดบรรทัด lineSplit = re.split( r"\s+", line_arr[PC], 5) #ตัด string ของแต่ละบรรทัดแบ่งช่องว่าง เป็น 5 index a.Assembler(lineSplit, mem, PC, label_addr) #go to assembler.py PC += 1 #--------------------------------------------- for i in range(0, len(mem)): print('Address[' + str(i) + ']=' + str(mem[i]) + ' (hex ' + str(hex(int(mem[i]) & (2**32 - 1))) + ' )') startPC = 0 s.simulate(startPC, reg, mem) exit(0)