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)