def test_overloaded_casting():
grade = 0
try:
ten = Hexadecimal(10)
x = int(ten)
if type(x) is int and x == 10:
grade += 3
else:
print("Can't cast Hexadecimal objects as ints correctly.")
except Exception as ex:
print("Crashed when casting Hexadecimal objects as ints.")
try:
ten = Hexadecimal(10)
x = float(ten)
if type(x) is float and x == 10.0:
grade += 2
else:
print("Can't cast Hexadecimal objects as floats correctly.")
except Exception as ex:
print("Crashed when casting Hexadecimal object as ints.")
return grade
def __init__(self):
self.index = 0
self.list_n = []
self.conv = Convert()
self.reg = Register("X")
self.hexa = Hexadecimal()
self.last_code = 0
def relative_base(self,arg):
hex = Hexadecimal()
c = Convert()
res = hex.subs(arg,self.base)
res_dec = c.to_decimal(res)
if res_dec >= 0 and res_dec <= 4095:
return res
return None
def gen_table(self):
h = Hexadecimal()
dir_c = self.bloques[0].get_load_dir()
for x in self.bloques:
x.set_load_dir(dir_c)
if x.name == "por omision":
x.length = h.subs(x.last_cp,x.get_load_dir())
else:
x.length = x.last_cp
dir_c = h.plus(dir_c,x.length)
def gen_table(self):
h = Hexadecimal()
dir_c = self.bloques[0].get_load_dir()
for x in self.bloques:
x.set_load_dir(dir_c)
if x.name == "por omision":
x.length = h.subs(x.last_cp, x.get_load_dir())
else:
x.length = x.last_cp
dir_c = h.plus(dir_c, x.length)
def __init__(self, window):
self.window = window
self.tabse = Tabse()
self.lonsc = "0H"
self.dirsc = "0H"
self.dirprog = "0H"
self.direj = "0H"
self.hexa = Hexadecimal()
self.convert = Convert()
self.register = Register("A")
self.error_indefinido = False
self.error_duplicado = False
def is_relative_cp(self,cp,arg):
hex = Hexadecimal()
c = Convert()
res_hex = hex.subs_minus(arg,cp)
sign = res_hex[1]
res_hex = res_hex[0]
res = int(c.to_decimal(res_hex))
if sign == "-":
res = (res ^ 4095)+1
res = res * -1
if res <= 2047 and res >= -2048:
return c.exp_to_hexadecimal(res)
else:
return None
def get_m_register_op(self):
list_ret = []
hexa = Hexadecimal()
self.elimina_repetidos(self.list_op_m)
for it in self.list_op_m:
reg = "M"
val = hexa.plus(it[3],"1H")
reg += self.current_register.adjust_bytes(val,6,False)
reg += "05"
reg += it[2]
if it[1] == "_":
name = self.current_register.adjust_name(it[0])
else:
name = self.current_register.adjust_name(self.h_name)
reg += name
list_ret.append(reg)
return list_ret
def __init__(self,window):
self.window = window
self.tabse = Tabse()
self.lonsc = "0H"
self.dirsc = "0H"
self.dirprog = "0H"
self.direj = "0H"
self.hexa = Hexadecimal()
self.convert = Convert()
self.register = Register("A")
self.error_indefinido = False
self.error_duplicado = False
def test_str():
#As long as there is a constructor and an overloaded str() function,
#the try block shouldn't be necessary, but I included it, just in case.
grade = 0
try:
x = Hexadecimal('AF')
if str(x) == "AF":
grade += 5
else:
print("Overloaded str:", str(x), 'should be AF.')
print(
"Check the overloaded str(), but also could be in constructor."
)
x = Hexadecimal('0')
if str(x) == "0":
grade += 5
else:
print("Overloaded str:", str(x), 'should be 0.')
except Exception as ex:
print("Crashed when testing str().")
return grade
def make_register_m(self,obj_list,cp_list,num_bloque,bloques):
r = Register("M")
hx = Hexadecimal()
r.name = self.h_name
it = 0
while it < len(self.m_register):
index = self.m_register[it]
# print "normal",index
load_dir = bloques.get_load_dir_at(num_bloque[index-1])
cp = hx.plus(cp_list[index-1],load_dir)
register = r.make_M(obj_list[index-1],cp)
self.list_registers_m.append(register)
it += 1
it = 0
while it < len(self.m_modif_register):
index = self.m_modif_register[it]
# print "modifi",index,len(cp_list)
load_dir = bloques.get_load_dir_at(num_bloque[index-1])
cp = hx.plus(cp_list[index-1],load_dir)
register = r.make_M_modificado(obj_list[index-1],cp)
self.list_registers_m.append(register)
it += 1
def __init__(self,parent=None):
QtGui.QWidget.__init__(self)
self.window = Ui_DockWidget()
self.window.setupUi(self)
self.add_registers()
self.cargador = None
self.hexa = Hexadecimal()
self.convert = Convert()
self.register = Register("A")
self.init_registers()
self.end_program = "0H"
self.cc_val = "="
self.window.btnSimular.clicked.connect(self.simular)
self.operations_3 = {"18":"ADD","00":"LDA","40":"AND","28":"COMP","24":"DIV","3C":"J","30":"JEQ","34":"JGT","38":"JLT",
"48":"JSUB","50":"LDCH","08":"LDL","04":"LDX","20":"MUL","4C":"RSUB","0C":"STA","54":"STCH","14":"STL",
"E8":"STSW","10":"STX","1C":"SUB","2C":"TIX","58":"ADDF","88":"COMPF","64":"DIVF","68":"LDB","70":"LDF",
"6C":"LDS","74":"LDT","D0":"LPS","60":"MULF","EC":"SSK","78":"STB","80":"STF","D4":"STI","7C":"STS","E8":"STSW",
"84":"STT","5C":"SUBF","E0":"TD","DC":"WD","44":"OR"}
self.operations_1 = {"C4":"FIX","C0":"FLOAT","F4":"HIO","C8":"NORM","F0":"SIO","F8":"TIO"}
self.operations_2 = {"90":"ADDR","B4":"CLEAR","A0":"COMPR","9C":"DIVR","98":"MULR","AC":"RMO","A4":"SHIFTL","A8":"SHIFTR",
"94":"SUBR","B0":"SVC","B8":"TIXR"}
self.operations = {"18":self.add,"00":self.lda,"40":self.and_op,"28":self.comp,"24":self.div,"3C":self.j_op,
"30":self.jeq,"34":self.jgt,"38":self.jlt,"48":self.jsub,"50":self.ldch,
"08":self.ldl,"04":self.ldx,"20":self.mul,"4C":self.rsub,"0C":self.sta,"54":self.stch,"14":self.stl,
"E8":self.stsw,"10":self.stx,"1C":self.sub,"2C":self.tix,"58":self.float_operations,
"88":self.float_operations,
"64":self.float_operations,"68":self.ldb,"70":self.float_operations,"6C":self.lds,"74":self.ldt,
"D0":self.system_operations,"60":self.float_operations,"EC":self.system_operations,"78":self.stb,
"80":self.float_operations,"D4":self.system_operations,"7C":self.sts,"E8":self.system_operations,
"84":self.stt,"5C":self.float_operations,"E0":self.system_operations,"DC":self.system_operations,
"C4":self.float_operations,
"C0":self.float_operations,"F4":self.system_operations,"C8":self.float_operations,
"F0":self.system_operations,"44":self.or_op,
"F8":self.system_operations,"90":self.addr,"B4":self.clear,"A0":self.compr,
"9C":self.divr,"98":self.mulr,"AC":self.rmo,"A4":"SHIFTL",
"A8":"SHIFTR","94":self.subr,"B0":"SVC","B8":self.tixr}
self.registers = {"0":[self.REG_A,"A"],"1":[self.REG_X,"X"],"2":[self.REG_L,"L"],"8":[self.REG_CP,"CP"],"9":[self.REG_SW,"SW"],"3":[self.REG_B,"B"],
"4":[self.REG_S,"S"],"5":[self.REG_T,"T"],"6":[self.REG_F,"F"]}
self.operations_m = ["J","JLT","JEQ","JGT","JSUB","STA","STB","STCH","STL","STS","STSW","STT","STX","LDCH"]
class Cargadorx():
def __init__(self,window):
self.window = window
self.tabse = Tabse()
self.lonsc = "0H"
self.dirsc = "0H"
self.dirprog = "0H"
self.direj = "0H"
self.hexa = Hexadecimal()
self.convert = Convert()
self.register = Register("A")
self.error_indefinido = False
self.error_duplicado = False
def show_error(self,msg):
##QtGui.QMessageBox.about(self.window,"Error",msg)
self.window.textEdit_Actions.setText(msg)
def load_file_name(self,list_obj,dirprog):
val_int = self.convert.to_decimal(dirprog)
self.dirprog = self.convert.decimal_to_hexadecimal(val_int)
self.dirprog = self.register.adjust_bytes(self.dirprog,6,False)+"H"
self.dirsc = self.dirprog
self.step_1(list_obj)
if not self.error_duplicado:
self.create_memory()
self.dirsc = self.dirprog
self.direj = self.dirprog
self.step_2(list_obj)
self.init_empty_rows()
self.tabse.print_tabse()
if self.error_indefinido:
self.show_error("Error en simbolo indefinido")
else:
self.show_error("Error simbolo duplicado")
def step_1(self,list_obj):
for list_n in list_obj:
for n in list_n:
if len(n) > 0:
if n[0] == "H":
self.step_h(n,1)
elif n[0] == "D":
self.step_1_d(n)
self.dirsc = self.hexa.plus(self.dirsc,self.lonsc)
def step_h(self,n,step):
name = n[1:7]
name = name.strip()
self.lonsc = n[13:]+"H"
if step == 1:
if not self.tabse.exist_node(name):
self.tabse.insert_section(name,self.dirsc,self.lonsc)
else:
##print name
self.error_duplicado = True
def step_1_d(self,n):
num = (len(n)-1)/12
it = 0
# print "num",num,len(n)
while it < num:
index1 = (it * 12)+1
index2 = index1 + 6
index3 = index2 + 6
name = n[index1:index2].strip()
#print "name",name
if index3 >= len(n):
len_r = n[index2:]+"H"
else:
len_r = n[index2:index3]+"H"
if not self.tabse.exist_node(name):
val = self.hexa.plus(len_r,self.dirsc)
self.tabse.insert_variable(name,val)
else:
print "error",name
self.error_duplicado = True
it += 1
def step_2(self,list_obj):
for list_n in list_obj:
for n in list_n:
if len(n) > 0:
if n[0] == "H":
self.step_h(n,2)
elif n[0] == "T":
self.charge_obj_code(n)
elif n[0] == "M":
self.change_m_register(n)
elif n[0] == "E":
self.reg_e(n)
self.dirsc = self.hexa.plus(self.dirsc,self.lonsc)
def reg_e(self,r):
if len(r) > 1:
val = r[1:] + "H"
self.direj = self.hexa.plus(self.dirsc,val)
def charge_obj_code(self,r):
string = r[9:]
index = 0
init = r[1:7]
init = self.hexa.plus(init+"H",self.dirsc)[:-1]
col_start = init[-1]+"H"
col = int(self.convert.to_decimal(col_start) + 1)
dat1 = self.get_part_dat(init)
res = self.hexa.subs(dat1,self.dirprog[:-2])
dec_res = int(self.convert.to_decimal(res))
while index < len(string):
byte = string[index:index+2]
item = QtGui.QTableWidgetItem(byte)
self.window.tableWidget.setItem(dec_res,col,item)
index+=2
col = (col + 1) % 17
if col == 0:
col = 1
dec_res += 1
def get_part_dat(self,dat):
if len(dat) == 1:
return "0"
else:
return dat[:-1]
def change_m_register(self,r):
val = r[1:7]
med_byte = r[7:9]
sign = r[9]
name = r[10:].strip()
# print val,med_byte,sign,name
n = self.tabse.get_register(name)
if n:
# print "existe"
val = self.hexa.plus(val,self.dirsc)[:-1]
content = self.get_content_at(val,3)
# print val,content
ant_content = ""
if med_byte == "5":
ant_content = content[0]
content = content[1:]
dir_es = n.get_dir()
new_dir = self.make_operation(sign,content,dir_es)
# print "perico",new_dir,content,sign,dir_es
new_dir = self.register.adjust_bytes(new_dir,6,True)
if med_byte == "5":
new_dir = ant_content + new_dir[1:]
new_dir = ant_content + new_dir
# print new_dir
col_num = val[-1] + "H"
col = int(self.convert.to_decimal(col_num) + 1)
val = self.get_part_dat(val)
ren = self.hexa.subs(val,self.dirprog[:-2])
ren = int(self.convert.to_decimal(ren))
index = 0
while index < len(new_dir):
byte = new_dir[index:index+2]
item = QtGui.QTableWidgetItem(byte)
self.window.tableWidget.setItem(ren,col,item)
index+=2
col = (col + 1) % 17
if col == 0:
col = 1
ren += 1
else:
self.error_indefinido = True
def make_operation(self,sign,dat1,dat2):
val1 = self.get_int_operator(dat1)
val2 = self.get_int_operator(dat2)
if sign == "-":
ret = val1-val2
else:
ret = val1+val2
ret = self.exp_to_hexadecimal(ret)
return ret
def get_int_operator(self,dat):
if dat[-1] == "H":
dat = dat[:-1]
if dat[0] == "F":
string = ""
it = 0
while it < len(dat):
if not dat[it] == "F":
string += dat[it]
it += 1
if len(string) == 0:
return -1
else:
val = "1"+("0"*len(string))+"H"
val = self.convert.to_decimal(val)
val2 = self.convert.to_decimal(string+"H")
return val2-val
else:
return self.convert.to_decimal(dat+"H")
def get_content_at(self,dirr,num):
dir_n = dirr[-1]+"H"
col = int(self.convert.to_decimal(dir_n) + 1)
dire = self.get_part_dat(dirr)
ren = self.hexa.subs(dire,self.dirprog[:-2])
ren = int(self.convert.to_decimal(ren))
it = 0
text = ""
while it < num:
item = self.window.tableWidget.item(ren,col)
text += str(item.text())
it += 1
col = (col + 1) % 17
if col == 0:
col = 1
ren += 1
return text
def exp_to_hexadecimal(self,val):
if val < 0:
val = int(val * -1)
val = val ^ 65535
val += 1
if val == 0:
val = "0H"
else:
val = self.convert.decimal_to_hexadecimal(val)
if val[0] == "F" and len(val) > 6:
val = "0"+val
return val
def create_memory(self):
init = self.dirprog[:-1]
length = self.hexa.subs(self.dirsc,self.dirprog)[:-1]
star_rows= length[:-1]
index = init[:-1]
num_rows=star_rows+"H"
num_rows=int(self.convert.to_decimal(num_rows))
self.window.tableWidget.setRowCount(num_rows+1)
it = 0
while it <= num_rows:
dir = index+"0H"
dir = self.register.adjust_bytes(dir,6,False)
item = QtGui.QTableWidgetItem(dir)
self.window.tableWidget.setItem(it,0,item)
it += 1
index = self.hexa.plus(index,"1H")[:-1]
def init_empty_rows(self):
rows_count = self.window.tableWidget.rowCount()
colum_count = self.window.tableWidget.columnCount()
for i in range(rows_count):
for j in range(colum_count):
item = self.window.tableWidget.item(i,j)
if item == None:
item_text = QtGui.QTableWidgetItem("FF")
self.window.tableWidget.setItem(i,j,item_text)
def test_constructor():
grade = 0
#These should work
try:
a = Hexadecimal()
except Exception as ex:
print("Constructor doesn't have default arguments.")
else:
grade += 2
try:
b = Hexadecimal(10)
except Exception as ex:
print("Constructor doesn't accept positive ints.")
else:
grade += 2
try:
c = Hexadecimal(10.1)
except Exception as ex:
print("Constructor doesn't accept positive floats.")
else:
grade += 2
try:
d = Hexadecimal('10')
except Exception as ex:
print("Constructor doesn't accept string version of ints")
else:
grade += 2.5
#These shouldn't work
try:
e = Hexadecimal([1, 2, 3])
except Exception as ex:
grade += 1
else:
print("Constructor shouldn't accept lists")
try:
e = Hexadecimal('Q')
except Exception as ex:
grade += 1
else:
print("Constructor shouldn't accept a 'Q'")
try:
f = Hexadecimal(-1)
except Exception as ex:
grade += 1
else:
print("Constructor shouldn't accept negative integers.")
try:
g = Hexadecimal(-20.1)
except Exception as ex:
grade += 1
else:
print("Constructor shouldn't accept negative floats.")
#Decided that constructor should be worth 20 points, so multiplied by 2
grade *= 2
return grade
class Simuladorx(QtGui.QDockWidget):
REG_CP = 0
REG_A = 1
REG_X = 2
REG_L = 3
REG_SW = 4
REG_B = 5
REG_S = 6
REG_T = 7
REG_F = 8
def __init__(self,parent=None):
QtGui.QWidget.__init__(self)
self.window = Ui_DockWidget()
self.window.setupUi(self)
self.add_registers()
self.cargador = None
self.hexa = Hexadecimal()
self.convert = Convert()
self.register = Register("A")
self.init_registers()
self.end_program = "0H"
self.cc_val = "="
self.window.btnSimular.clicked.connect(self.simular)
self.operations_3 = {"18":"ADD","00":"LDA","40":"AND","28":"COMP","24":"DIV","3C":"J","30":"JEQ","34":"JGT","38":"JLT",
"48":"JSUB","50":"LDCH","08":"LDL","04":"LDX","20":"MUL","4C":"RSUB","0C":"STA","54":"STCH","14":"STL",
"E8":"STSW","10":"STX","1C":"SUB","2C":"TIX","58":"ADDF","88":"COMPF","64":"DIVF","68":"LDB","70":"LDF",
"6C":"LDS","74":"LDT","D0":"LPS","60":"MULF","EC":"SSK","78":"STB","80":"STF","D4":"STI","7C":"STS","E8":"STSW",
"84":"STT","5C":"SUBF","E0":"TD","DC":"WD","44":"OR"}
self.operations_1 = {"C4":"FIX","C0":"FLOAT","F4":"HIO","C8":"NORM","F0":"SIO","F8":"TIO"}
self.operations_2 = {"90":"ADDR","B4":"CLEAR","A0":"COMPR","9C":"DIVR","98":"MULR","AC":"RMO","A4":"SHIFTL","A8":"SHIFTR",
"94":"SUBR","B0":"SVC","B8":"TIXR"}
self.operations = {"18":self.add,"00":self.lda,"40":self.and_op,"28":self.comp,"24":self.div,"3C":self.j_op,
"30":self.jeq,"34":self.jgt,"38":self.jlt,"48":self.jsub,"50":self.ldch,
"08":self.ldl,"04":self.ldx,"20":self.mul,"4C":self.rsub,"0C":self.sta,"54":self.stch,"14":self.stl,
"E8":self.stsw,"10":self.stx,"1C":self.sub,"2C":self.tix,"58":self.float_operations,
"88":self.float_operations,
"64":self.float_operations,"68":self.ldb,"70":self.float_operations,"6C":self.lds,"74":self.ldt,
"D0":self.system_operations,"60":self.float_operations,"EC":self.system_operations,"78":self.stb,
"80":self.float_operations,"D4":self.system_operations,"7C":self.sts,"E8":self.system_operations,
"84":self.stt,"5C":self.float_operations,"E0":self.system_operations,"DC":self.system_operations,
"C4":self.float_operations,
"C0":self.float_operations,"F4":self.system_operations,"C8":self.float_operations,
"F0":self.system_operations,"44":self.or_op,
"F8":self.system_operations,"90":self.addr,"B4":self.clear,"A0":self.compr,
"9C":self.divr,"98":self.mulr,"AC":self.rmo,"A4":"SHIFTL",
"A8":"SHIFTR","94":self.subr,"B0":"SVC","B8":self.tixr}
self.registers = {"0":[self.REG_A,"A"],"1":[self.REG_X,"X"],"2":[self.REG_L,"L"],"8":[self.REG_CP,"CP"],"9":[self.REG_SW,"SW"],"3":[self.REG_B,"B"],
"4":[self.REG_S,"S"],"5":[self.REG_T,"T"],"6":[self.REG_F,"F"]}
self.operations_m = ["J","JLT","JEQ","JGT","JSUB","STA","STB","STCH","STL","STS","STSW","STT","STX","LDCH"]
def simular(self):
num_actions = self.get_count_next_actions()
print "num actions",num_actions
if num_actions == -1:
self.window.textEdit_Actions.setText("Numero de simulaciones no Validas")
else:
self.make_n_simulations(num_actions)
def make_n_simulations(self,number):
it = 0
while it < number:
cp = self.get_register(self.REG_CP)
if self.hexa.minus_than(cp,self.end_program):
op = self.get_operation()
type_op = op[2]
inst = op[1]
m = self.get_m(type_op,cp,inst)
if m == "Error":
self.window.textEdit_Actions.setText("El programa se termino debido a un error de operacion")
else:
fun = self.operations[op[0]]
fun(m)
self.show_next_instr()
else:
self.window.textEdit_Actions.setText("El programa se termino")
it += 1
def get_m(self,type_op,cp,inst):
if type_op == "Error":
return type_op
if type_op == "1":
self.increment_cp(1)
return "0"
if type_op == "2":
cp_n = self.hexa.plus(cp,"1H")
self.increment_cp(2)
return self.get_data_form_mem(cp_n,1)
if inst in self.operations_m:
print "\n\n"+inst+"\n\n"
return self.get_m_type3_m()
return self.get_m_type3()
def get_count_next_actions(self):
count_actions = str(self.window.textEdit_Num.toPlainText())
if count_actions == "":
count_actions = 1
elif not count_actions.isdigit():
return -1
return int(count_actions)
def system_operations(self,val):
self.window.textEdit_Actions.setText("No tiene los permisos \n para ejecutar esta instruccion")
def float_operations(self,val):
self.window.textEdit_Actions.setText("Las instrucciones flotantes \n no se pueden ejecutar")
def add_registers(self):
self.window.tableWidget_2.setRowCount(9)
item = QtGui.QTableWidgetItem()
item.setText("B")
self.window.tableWidget_2.setVerticalHeaderItem(5, item)
item = QtGui.QTableWidgetItem()
item.setText("S")
self.window.tableWidget_2.setVerticalHeaderItem(6, item)
item = QtGui.QTableWidgetItem()
item.setText("T")
self.window.tableWidget_2.setVerticalHeaderItem(7, item)
item = QtGui.QTableWidgetItem()
item.setText("F")
self.window.tableWidget_2.setVerticalHeaderItem(8, item)
def init_registers(self):
it = 0
while it < 9:
item_text = QtGui.QTableWidgetItem("FFFFFFFH")
self.window.tableWidget_2.setItem(it,0,item_text)
it += 1
def set_register(self,reg_num,val):
val_hex = self.register.adjust_bytes(val,6,False)
val_hex = self.hexa.change_hexadecimal(val_hex)
item_text = QtGui.QTableWidgetItem(val_hex)
self.window.tableWidget_2.setItem(reg_num,0,item_text)
def get_register(self,reg_num):
item = self.window.tableWidget_2.item(reg_num,0)
return str(item.text())
def carga(self,list_obj,dirprog):
self.cargador = Cargadorx(self.window)
self.cargador.load_file_name(list_obj,dirprog)
cp = self.cargador.direj
self.set_register(self.REG_CP,cp)
self.show_next_instr()
self.end_program = self.cargador.dirsc
if self.cargador.error_duplicado:
QtGui.QMessageBox.about(self,"Error","Error simbolo duplicado")
elif self.cargador.error_indefinido:
QtGui.QMessageBox.about(self,"Error","Error simbolo indefinido")
def increment_cp(self,num):
num_hexa = self.convert.decimal_to_hexadecimal(num)
cp = self.get_register(self.REG_CP)
res = self.hexa.plus(num_hexa,cp)
self.set_register(self.REG_CP,res)
def show_next_instr(self):
op = self.get_operation()
self.window.label_sig.setText(op[1])
def get_operation(self):
cp = self.get_register(self.REG_CP)
value = self.get_data_form_mem(cp,1)
val = value[0]
val2 = value[1]
val_d = int(self.convert.to_decimal(val2+"H"))
val_d = val_d & 12
value = val + self.convert.decimal_to_hexadecimal(str(val_d))[:-1]
tip = "Error"
op = self.operations_1.get(value,"Error")
if not op == "Error":
tip = "1"
else:
op = self.operations_2.get(value,"Error")
if not op == "Error":
tip = "2"
else:
op = self.operations_3.get(value,"Error")
if not op == "Error":
tip = "3"
return [value,op,tip]
##regresa los datos de una localidad y las licalidades
#siguientes
# @param localidad donde se obtendra el dato
# @param num_loc cuantas localidades siguientes accedera
def get_data_form_mem(self,location,num_loc):
loc = self.register.filter_number(location)
row = self.get_row_index(loc)
col = self.get_column_index(loc)
data = ""
it = col
count = 0
while count < num_loc:
item = self.window.tableWidget.item(row,it)
data += str(item.text())
it = (it+1)%17
if it == 0:
it = 1
row+=1
count += 1
return data
def get_row_index(self,value):
index = str(value[0:-1])+"0"
it = 0
index = self.register.adjust_bytes(index,6,False)
num_rows = self.window.tableWidget.rowCount()
while it < num_rows:
val = self.window.tableWidget.item(it,0)
if str(val.text()) == index:
return it
it += 1
return 0
def get_column_index(self,value):
index = str(value[-1])+"H"
index = self.convert.to_decimal(index)
return index+1
def get_m_type3(self):
cp = self.get_register(self.REG_CP)
data1 = self.get_data_form_mem(cp,1)
type_d = self.get_operation_type(data1)
next_loc = self.hexa.plus(cp,"1H")
data = self.get_data_form_mem(next_loc,1)
print data1,type_d,next_loc,data
msb = data[0]
msb_d = int(self.convert.to_decimal(msb+"H"))
tam = 3
if (msb_d & 1) == 1:
tam = 4
next_loc = self.hexa.plus(next_loc,"1H")
m = data[1] + self.get_data_form_mem(next_loc,tam-2)
print m,tam,next_loc
cp = self.get_register(self.REG_CP)
cp = self.hexa.plus(cp,str(tam))
self.set_register(self.REG_CP,cp)
if type_d == "simple_s":
m = str(msb_d & 7) + m
type_d = "simple"
elif (msb_d & 6) == 0:
m = m
else:
if (msb_d & 4) == 4:
b = self.get_register(self.REG_B)
m = self.hexa.change_hexadecimal(m)
print "rel base",b,m
m = self.hexa.suma(m,b)
if (msb_d & 2) == 2:
cp = self.get_register(self.REG_CP)
m = self.hexa.change_hexadecimal(m)
print "rel cp",cp,m
m = self.hexa.suma(m,cp)
if (msb_d & 8) == 8:
x = self.get_register(self.REG_X)
m = self.hexa.change_hexadecimal(m)
print ", X",x,m
m = self.hexa.suma(m,x)
print "mem",m
if not type_d == "inmediato":
m = self.register.adjust_bytes(m,6,False)
m = self.get_data_form_mem(m,3)
if not type_d == "simple":
m = self.register.adjust_bytes(m,6,False)
m = self.get_data_form_mem(m,3)
print "return",m
return m
def get_m_type3_m(self):
cp = self.get_register(self.REG_CP)
data1 = self.get_data_form_mem(cp,1)
type_d = self.get_operation_type(data1)
next_loc = self.hexa.plus(cp,"1H")
data = self.get_data_form_mem(next_loc,1)
print data1,type_d,next_loc,data
msb = data[0]
msb_d = int(self.convert.to_decimal(msb+"H"))
tam = 3
if (msb_d & 1) == 1:
tam = 4
next_loc = self.hexa.plus(next_loc,"1H")
m = data[1] + self.get_data_form_mem(next_loc,tam-2)
print m,tam,next_loc
cp = self.get_register(self.REG_CP)
cp = self.hexa.plus(cp,str(tam))
self.set_register(self.REG_CP,cp)
if type_d == "simple_s":
m = str(msb_d & 7) + m
type_d = "simple"
elif (msb_d & 6) == 0:
m = m
else:
if (msb_d & 4) == 4:
b = self.get_register(self.REG_B)
m = self.hexa.change_hexadecimal(m)
print "rel base",b,m
m = self.hexa.suma(m,b)
if (msb_d & 2) == 2:
cp = self.get_register(self.REG_CP)
m = self.hexa.change_hexadecimal(m)
print "rel cp",cp,m
m = self.hexa.suma(m,cp)
if (msb_d & 8) == 8:
x = self.get_register(self.REG_X)
m = self.hexa.change_hexadecimal(m)
print ", X",x,m
m = self.hexa.suma(m,x)
print "mem",m
# if not type_d == "inmediato":
# m = self.register.adjust_bytes(m,6,False)
# m = self.get_data_form_mem(m,3)
# if not type_d == "simple":
# m = self.register.adjust_bytes(m,6,False)
# m = self.get_data_form_mem(m,3)
# print "return",m
return m
def get_operation_type(self,data):
d = data[1]
d_d = int(self.convert.to_decimal(d+"H"))
val = d_d & 3
if val == 3:
return "simple"
elif val == 2:
return "indirecto"
elif val == 1:
return "inmediato"
return "simple_s"
def add(self,m):
string = "ADD\nA <- (A) + (m..m+2)"
a = self.get_register(self.REG_A)
res = self.hexa.plus(a,m)
string += "\n(A) = "+a+"\n(m..m+2) = "+m+"\n(A) = "+res
self.set_register(self.REG_A,res)
self.window.textEdit_Actions.setText(string)
def addr(self,m):
string ="ADDR\nr2 <- (r1) + (r2)"+"\n"
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
string += "(r1) = "+r1[1]+"\n (r2) = "+r2[1]+"\n"
dat1 = self.get_register(r1[0])
dat2 = self.get_register(r2[0])
res = self.hexa.plus(dat1,dat2)
string += "("+r2[1]+")<-"+res
self.set_register(r2[0],res)
self.window.textEdit_Actions.setText(string)
def and_op(self,m):
string = "AND\nA <- (A) & (m..m+2)\n"
a = self.get_register(self.REG_A)
string += "(A) : " + a +"\n" +"(m..m+2) : "+m
res = self.hexa.and_op(a,m)
self.set_register(self.REG_A,res)
self.window.textEdit_Actions.setText(string)
def clear(self,m):
r = self.registers[m[0]]
string = "CLEAR\nr1 <- 0\nr1:"+r[1]
self.set_register(r[0],"0H")
self.window.textEdit_Actions.setText(string)
def comp(self,m):
string = "COMP\nCC = (A) : (m..m+2)"
a = self.get_register(self.REG_A)
string += "\n (A) = "+a+"\n (m..m+2) = "+m
self.cc_val = self.hexa.cmp_op(a,m)
string += "\nCC ="+self.cc_val
self.window.textEdit_Actions.setText(string)
def compr(self,m):
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
dat1 = self.get_register(r1[0])
dat2 = self.get_register(r2[0])
string = "COMPR\nCC = r1 : r2\n"+"r1 = "+r1[1]+"\nr2 = "+r2[1]
self.cc_val = self.hexa.cmp_op(dat1,dat2)
string += "\n CC = "+self.cc_val
self.window.textEdit_Actions.setText(string)
def div(self,m):
string = "DIV\nA <- (A) / (m..m+2)"
a = self.get_register(self.REG_A)
res = self.hexa.div(a,m)
string += "\n(A) = "+a+"\n(m..m+2) = "+m+"\n(A) = "+res
self.set_register(self.REG_A,res)
self.window.textEdit_Actions.setText(string)
def divr(self,m):
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
dat1 = self.get_register(r1[0])
dat2 = self.get_register(r2[0])
string = "DIVR\nr2 <- (r2) / (r1)\nr1 = "+r1[1] +"\nr2 = "+r2[1]
res = self.hexa.div(dat2,dat1)
string += "r2 = "+res
self.set_register(r2[0],res)
self.window.textEdit_Actions.setText(string)
def j_op(self,m):
string = "J: \n CP <- m\nm = "+m
self.set_register(self.REG_CP,m)
self.window.textEdit_Actions.setText(string)
def jeq(self,m):
string = "JEQ: \nsi CC == '=':\n\tCP <- m\n"
string += "CC = '"+self.cc_val+"'"
if self.cc_val == "=":
self.set_register(self.REG_CP,m)
string += "\nCP <- "+m
self.window.textEdit_Actions.setText(string)
def jgt(self,m):
string = "JGT: \nsi CC == '>':\n\tCP <- m\n"
string += "CC = '"+self.cc_val+"'"
if self.cc_val == ">":
self.set_register(self.REG_CP,m)
string += "\nCP <- "+m
self.window.textEdit_Actions.setText(string)
def jlt(self,m):
string = "JLT: \nsi CC == '<':\n\tCP <- m\n"
string += "CC = '"+self.cc_val+"'"
if self.cc_val == "<":
self.set_register(self.REG_CP,m)
string += "\nCP <- "+m
self.window.textEdit_Actions.setText(string)
def jsub(self,m):
string = "JSUB:\n L <- (CP)\nCP <- m"
cp = self.get_register(self.REG_CP)
string += "\n(CP) = "+cp+"\nm = "+m
self.set_register(self.REG_L,cp)
self.set_register(self.REG_CP,m)
self.window.textEdit_Actions.setText(string)
def lda(self,m):
string = "LDA\nA <- (m..m+2)\n(m..m+2) = "+m
self.set_register(self.REG_A,m)
self.window.textEdit_Actions.setText(string)
def ldb(self,m):
string = "LDB\nB <- (m..m+2)\n(m..m+2) = "+m
self.set_register(self.REG_B,m)
self.window.textEdit_Actions.setText(string)
def ldch(self,m):
string = "LDCH\nA[+der] <- (m)"
a = self.get_register(self.REG_A)
m = self.register.adjust_bytes(m,6,False)
m = self.get_data_form_mem(m,1)
string += "\n(A) = "+a+"\n(m) = "+m
a = self.register.filter_number(a)
a = a[0:-2] + m
self.set_register(self.REG_A,a)
self.window.textEdit_Actions.setText(string)
def ldl(self,m):
string = "LDL\nL <- (m..m+2)\n(m..m+2) = "+m
self.set_register(self.REG_L,m)
self.window.textEdit_Actions.setText(string)
def lds(self,m):
string = "LDS\nS <- (m..m+2)\n(m..m+2) = "+m
self.set_register(self.REG_S,m)
self.window.textEdit_Actions.setText(string)
def ldt(self,m):
string = "LDT\nT <- (m..m+2)\n(m..m+2) = "+m
self.set_register(self.REG_T,m)
self.window.textEdit_Actions.setText(string)
def ldx(self,m):
string = "LDX\nX <- (m..m+2)\n(m..m+2) = "+m
self.set_register(self.REG_X,m)
self.window.textEdit_Actions.setText(string)
def mul(self,m):
a = self.get_register(self.REG_A)
string = "MUL\nA <- (A) * (m..m+2)\n(A) = "+a+"\n(m..m+2)="+m
res = self.hexa.mul(a,m)
string += "\n (A) <- "+res
self.set_register(self.REG_A,res)
self.window.textEdit_Actions.setText(string)
def mulr(self,m):
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
dat1 = self.get_register(r1[0])
dat2 = self.get_register(r2[0])
string = "MULR\nr2 <- (r2) * (r1)\nr1 = "+r1[1] +"\nr2 = "+r2[1]
res = self.hexa.mul(dat2,dat1)
string += "r2 = "+res
self.set_register(r2[0],res)
self.window.textEdit_Actions.setText(string)
def or_op(self,m):
string = "OR\nA <- (A) | (m..m+2)\n"
a = self.get_register(self.REG_A)
string += "(A) : " + a +"\n" +"(m..m+2) : "+m
res = self.hexa.or_op(a,m)
self.set_register(self.REG_A,res)
self.window.textEdit_Actions.setText(string)
def rmo(self,m):
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
dat1 = self.get_register(r1[0])
string = "RMO\nr2 <- (r1)\n r1 = "+r1[1]+"\nr2 ="+r2[1]
string += "\nr2 <- " + dat1
self.set_register(r2[0],dat1)
self.window.textEdit_Actions.setText(string)
def rsub(self,m):
l = self.get_register(self.REG_L)
string = "RSUB\nCP <- (L)\n(L) = "+l
string += "CP <-"+l
self.set_register(self.REG_CP,l)
self.window.textEdit_Actions.setText(string)
def sta(self,m):
m = self.register.adjust_bytes(m,6,False)
reg = self.get_register(self.REG_A)
string = "STA\n m..m+2 <- (A)\nm..m+2 = "+m+"\n(A) = "+reg
reg = self.register.filter_number(reg)
self.modf_reg(reg,m)
self.window.textEdit_Actions.setText(string)
def sta(self,m):
m = self.register.adjust_bytes(m,6,False)
reg = self.get_register(self.REG_A)
string = "STA\n m..m+2 <- (A)\nm..m+2 = "+m+"\n(A) = "+reg
reg = self.register.filter_number(reg)
self.modf_reg(reg,m)
self.window.textEdit_Actions.setText(string)
def stb(self,m):
m = self.register.adjust_bytes(m,6,False)
reg = self.get_register(self.REG_B)
string = "STB\n m..m+2 <- (B)\nm..m+2 = "+m+"\n(B) = "+reg
reg = self.register.filter_number(reg)
self.modf_reg(reg,m)
self.window.textEdit_Actions.setText(string)
def stch(self,m):
m = self.register.adjust_bytes(m,6,False)
reg = self.get_register(self.REG_A)
reg = self.register.filter_number(reg)[-2:]
string = "STCH\n m <- (A)[+der]\nm..m+2 = "+m+"\n(A)[+der] = "+reg
##S rm = self.hexa.plus(m,"2H")
m = self.register.adjust_bytes(m,6,False)
print "stsh",reg,m
self.modf_reg(reg,m)
self.window.textEdit_Actions.setText(string)
def stl(self,m):
m = self.register.adjust_bytes(m,6,False)
reg = self.get_register(self.REG_L)
string = "STL\n m..m+2 <- (L)\nm..m+2 = "+m+"\n(L) = "+reg
reg = self.register.filter_number(reg)
self.modf_reg(reg,m)
self.window.textEdit_Actions.setText(string)
def sts(self,m):
m = self.register.adjust_bytes(m,6,False)
reg = self.get_register(self.REG_S)
string = "STS\n m..m+2 <- (S)\nm..m+2 = "+m+"\n(S) = "+reg
reg = self.register.filter_number(reg)
self.modf_reg(reg,m)
self.window.textEdit_Actions.setText(string)
def stsw(self,m):
m = self.register.adjust_bytes(m,6,False)
reg = self.get_register(self.REG_SW)
string = "STSW\n m..m+2 <- (SW)\nm..m+2 = "+m+"\n(SW) = "+reg
reg = self.register.filter_number(reg)
self.modf_reg(reg,m)
self.window.textEdit_Actions.setText(string)
def stt(self,m):
m = self.register.adjust_bytes(m,6,False)
reg = self.get_register(self.REG_T)
string = "STT\n m..m+2 <- (T)\nm..m+2 = "+m+"\n(T) = "+reg
reg = self.register.filter_number(reg)
self.modf_reg(reg,m)
self.window.textEdit_Actions.setText(string)
def stx(self,m):
m = self.register.adjust_bytes(m,6,False)
reg = self.get_register(self.REG_X)
string = "STX\n m..m+2 <- (X)\nm..m+2 = "+m+"\n(X) = "+reg
reg = self.register.filter_number(reg)
self.modf_reg(reg,m)
self.window.textEdit_Actions.setText(string)
def modf_reg(self,reg,m):
row = self.get_row_index(m)
col = self.get_column_index(m)
it = col
count = 0
while count < len(reg):
item = self.window.tableWidget.item(row,it)
text = reg[count:count+2]
count += 2
item.setText(text)
it = (it+1)%17
if it == 0:
it = 1
row+=1
def sub(self,m):
string = "ADD\nA <- (A) - (m..m+2)"
a = self.get_register(self.REG_A)
res = self.hexa.subs(a,m)
string += "\n(A) = "+a+"\n(m..m+2) = "+m+"\n(A) = "+res
self.set_register(self.REG_A,res)
self.window.textEdit_Actions.setText(string)
def subr(self,m):
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
dat1 = self.get_register(r1[0])
dat2 = self.get_register(r2[0])
string = "SUBR\nr2 <- (r2) - (r1)\nr1 = "+r1[1] +"\nr2 = "+r2[1]
res = self.hexa.subs(dat2,dat1)
string += "r2 = "+res
self.set_register(r2[0],res)
self.window.textEdit_Actions.setText(string)
def tix(self,m):
x = self.get_register(self.REG_X)
string ="TIX\n(X) <- (X) + 1\n(X) : (m..m+2)\n(X)="+x
x = self.hexa.plus(x,"1H")
self.set_register(self.REG_X,x)
string +="\n(X)<- (X) + 1\n(X) <- "+x+"\n(m..m+2)="+m
self.cc_val = self.hexa.cmp_op(x,m)
string += "\nCC = "+self.cc_val
self.window.textEdit_Actions.setText(string)
def tixr(self,m):
r1 = self.registers[m[0]]
dat1 = self.get_register(r1[0])
string = "TIX\n X <- (X) + 1\n(X) : (r1)\nr1 = "+r1[1]
x = self.get_register(self.REG_X)
x = self.hexa.plus(x,"1H")
self.set_register(self.REG_X,x)
self.cc_val = self.hexa.cmp_op(x,dat1)
string += "CC = "+self.cc_val
self.window.textEdit_Actions.setText(string)
def test_combo_ops():
grade = 0
try:
one = Hexadecimal(1)
two = Hexadecimal(2)
three = Hexadecimal(3)
four = Hexadecimal(4)
#Testing +=
try:
one += two
if str(one) == str(three):
grade += 3
else:
print("Trouble with +=")
#resetting one
one = Hexadecimal(1)
except Exception as ex:
print("Crashed when testing +=")
#Testing -=
try:
one -= two
except Exception as ex:
grade += 1
else:
print(
"Your class stored a negative in an object as the result of -=."
)
print("It should have raised an exception and didn't.")
one = Hexadecimal(1)
try:
two -= one
if str(two) == str(one):
grade += 3
else:
print("Trouble when testing -=")
print(two, one)
two = Hexadecimal(2)
except Exception as ex:
print("Crashed when testing -=")
#Testing *=
try:
two *= two
if str(two) == str(four):
grade += 3
else:
print("Trouble when testing *=")
two = Hexadecimal(2)
except Exception as ex:
print("Crashed when testing *=")
#Testing /=
try:
four /= two
if str(four) == str(two):
grade += 3
else:
print("Trouble when testing /=")
four = Hexadecimal(4)
except Exception as ex:
print("Crashed when testing /=")
try:
zero = Hexadecimal(0)
four /= zero
except ZeroDivisionError as ex:
grade += 1
else:
print(
"Division by 0 is undefined, you should have raised an exception."
)
#Testing **=
try:
two **= two
if str(four) == str(two):
grade += 3
else:
print("Trouble when testing **=")
two = Hexadecimal(2)
except Exception as ex:
print("Crashed when testing **=")
#Testing %=
try:
four %= three
if str(four) == str(one):
grade += 2
else:
print("Trouble when testing %=")
four = Hexadecimal(4)
except Exception as ex:
print("Crashed when testing %=")
try:
four %= zero
except Exception as ex:
grade += 1
else:
print(
"Your class should have caused a crash when trying to % by 0, but didn't."
)
four = Hexadecimal(4)
except Exception as ex:
print("Crashed when testing combination operators")
return grade
class Simuladorx(QtGui.QDockWidget):
REG_CP = 0
REG_A = 1
REG_X = 2
REG_L = 3
REG_SW = 4
REG_B = 5
REG_S = 6
REG_T = 7
REG_F = 8
def __init__(self, parent=None):
QtGui.QWidget.__init__(self)
self.window = Ui_DockWidget()
self.window.setupUi(self)
self.add_registers()
self.cargador = None
self.hexa = Hexadecimal()
self.convert = Convert()
self.register = Register("A")
self.init_registers()
self.end_program = "0H"
self.cc_val = "="
self.window.btnSimular.clicked.connect(self.simular)
self.operations_3 = {
"18": "ADD",
"00": "LDA",
"40": "AND",
"28": "COMP",
"24": "DIV",
"3C": "J",
"30": "JEQ",
"34": "JGT",
"38": "JLT",
"48": "JSUB",
"50": "LDCH",
"08": "LDL",
"04": "LDX",
"20": "MUL",
"4C": "RSUB",
"0C": "STA",
"54": "STCH",
"14": "STL",
"E8": "STSW",
"10": "STX",
"1C": "SUB",
"2C": "TIX",
"58": "ADDF",
"88": "COMPF",
"64": "DIVF",
"68": "LDB",
"70": "LDF",
"6C": "LDS",
"74": "LDT",
"D0": "LPS",
"60": "MULF",
"EC": "SSK",
"78": "STB",
"80": "STF",
"D4": "STI",
"7C": "STS",
"E8": "STSW",
"84": "STT",
"5C": "SUBF",
"E0": "TD",
"DC": "WD",
"44": "OR"
}
self.operations_1 = {
"C4": "FIX",
"C0": "FLOAT",
"F4": "HIO",
"C8": "NORM",
"F0": "SIO",
"F8": "TIO"
}
self.operations_2 = {
"90": "ADDR",
"B4": "CLEAR",
"A0": "COMPR",
"9C": "DIVR",
"98": "MULR",
"AC": "RMO",
"A4": "SHIFTL",
"A8": "SHIFTR",
"94": "SUBR",
"B0": "SVC",
"B8": "TIXR"
}
self.operations = {
"18": self.add,
"00": self.lda,
"40": self.and_op,
"28": self.comp,
"24": self.div,
"3C": self.j_op,
"30": self.jeq,
"34": self.jgt,
"38": self.jlt,
"48": self.jsub,
"50": self.ldch,
"08": self.ldl,
"04": self.ldx,
"20": self.mul,
"4C": self.rsub,
"0C": self.sta,
"54": self.stch,
"14": self.stl,
"E8": self.stsw,
"10": self.stx,
"1C": self.sub,
"2C": self.tix,
"58": self.float_operations,
"88": self.float_operations,
"64": self.float_operations,
"68": self.ldb,
"70": self.float_operations,
"6C": self.lds,
"74": self.ldt,
"D0": self.system_operations,
"60": self.float_operations,
"EC": self.system_operations,
"78": self.stb,
"80": self.float_operations,
"D4": self.system_operations,
"7C": self.sts,
"E8": self.system_operations,
"84": self.stt,
"5C": self.float_operations,
"E0": self.system_operations,
"DC": self.system_operations,
"C4": self.float_operations,
"C0": self.float_operations,
"F4": self.system_operations,
"C8": self.float_operations,
"F0": self.system_operations,
"44": self.or_op,
"F8": self.system_operations,
"90": self.addr,
"B4": self.clear,
"A0": self.compr,
"9C": self.divr,
"98": self.mulr,
"AC": self.rmo,
"A4": "SHIFTL",
"A8": "SHIFTR",
"94": self.subr,
"B0": "SVC",
"B8": self.tixr
}
self.registers = {
"0": [self.REG_A, "A"],
"1": [self.REG_X, "X"],
"2": [self.REG_L, "L"],
"8": [self.REG_CP, "CP"],
"9": [self.REG_SW, "SW"],
"3": [self.REG_B, "B"],
"4": [self.REG_S, "S"],
"5": [self.REG_T, "T"],
"6": [self.REG_F, "F"]
}
self.operations_m = [
"J", "JLT", "JEQ", "JGT", "JSUB", "STA", "STB", "STCH", "STL",
"STS", "STSW", "STT", "STX", "LDCH"
]
def simular(self):
num_actions = self.get_count_next_actions()
print "num actions", num_actions
if num_actions == -1:
self.window.textEdit_Actions.setText(
"Numero de simulaciones no Validas")
else:
self.make_n_simulations(num_actions)
def make_n_simulations(self, number):
it = 0
while it < number:
cp = self.get_register(self.REG_CP)
if self.hexa.minus_than(cp, self.end_program):
op = self.get_operation()
type_op = op[2]
inst = op[1]
m = self.get_m(type_op, cp, inst)
if m == "Error":
self.window.textEdit_Actions.setText(
"El programa se termino debido a un error de operacion"
)
else:
fun = self.operations[op[0]]
fun(m)
self.show_next_instr()
else:
self.window.textEdit_Actions.setText("El programa se termino")
it += 1
def get_m(self, type_op, cp, inst):
if type_op == "Error":
return type_op
if type_op == "1":
self.increment_cp(1)
return "0"
if type_op == "2":
cp_n = self.hexa.plus(cp, "1H")
self.increment_cp(2)
return self.get_data_form_mem(cp_n, 1)
if inst in self.operations_m:
print "\n\n" + inst + "\n\n"
return self.get_m_type3_m()
return self.get_m_type3()
def get_count_next_actions(self):
count_actions = str(self.window.textEdit_Num.toPlainText())
if count_actions == "":
count_actions = 1
elif not count_actions.isdigit():
return -1
return int(count_actions)
def system_operations(self, val):
self.window.textEdit_Actions.setText(
"No tiene los permisos \n para ejecutar esta instruccion")
def float_operations(self, val):
self.window.textEdit_Actions.setText(
"Las instrucciones flotantes \n no se pueden ejecutar")
def add_registers(self):
self.window.tableWidget_2.setRowCount(9)
item = QtGui.QTableWidgetItem()
item.setText("B")
self.window.tableWidget_2.setVerticalHeaderItem(5, item)
item = QtGui.QTableWidgetItem()
item.setText("S")
self.window.tableWidget_2.setVerticalHeaderItem(6, item)
item = QtGui.QTableWidgetItem()
item.setText("T")
self.window.tableWidget_2.setVerticalHeaderItem(7, item)
item = QtGui.QTableWidgetItem()
item.setText("F")
self.window.tableWidget_2.setVerticalHeaderItem(8, item)
def init_registers(self):
it = 0
while it < 9:
item_text = QtGui.QTableWidgetItem("FFFFFFFH")
self.window.tableWidget_2.setItem(it, 0, item_text)
it += 1
def set_register(self, reg_num, val):
val_hex = self.register.adjust_bytes(val, 6, False)
val_hex = self.hexa.change_hexadecimal(val_hex)
item_text = QtGui.QTableWidgetItem(val_hex)
self.window.tableWidget_2.setItem(reg_num, 0, item_text)
def get_register(self, reg_num):
item = self.window.tableWidget_2.item(reg_num, 0)
return str(item.text())
def carga(self, list_obj, dirprog):
self.cargador = Cargadorx(self.window)
self.cargador.load_file_name(list_obj, dirprog)
cp = self.cargador.direj
self.set_register(self.REG_CP, cp)
self.show_next_instr()
self.end_program = self.cargador.dirsc
if self.cargador.error_duplicado:
QtGui.QMessageBox.about(self, "Error", "Error simbolo duplicado")
elif self.cargador.error_indefinido:
QtGui.QMessageBox.about(self, "Error", "Error simbolo indefinido")
def increment_cp(self, num):
num_hexa = self.convert.decimal_to_hexadecimal(num)
cp = self.get_register(self.REG_CP)
res = self.hexa.plus(num_hexa, cp)
self.set_register(self.REG_CP, res)
def show_next_instr(self):
op = self.get_operation()
self.window.label_sig.setText(op[1])
def get_operation(self):
cp = self.get_register(self.REG_CP)
value = self.get_data_form_mem(cp, 1)
val = value[0]
val2 = value[1]
val_d = int(self.convert.to_decimal(val2 + "H"))
val_d = val_d & 12
value = val + self.convert.decimal_to_hexadecimal(str(val_d))[:-1]
tip = "Error"
op = self.operations_1.get(value, "Error")
if not op == "Error":
tip = "1"
else:
op = self.operations_2.get(value, "Error")
if not op == "Error":
tip = "2"
else:
op = self.operations_3.get(value, "Error")
if not op == "Error":
tip = "3"
return [value, op, tip]
##regresa los datos de una localidad y las licalidades
#siguientes
# @param localidad donde se obtendra el dato
# @param num_loc cuantas localidades siguientes accedera
def get_data_form_mem(self, location, num_loc):
loc = self.register.filter_number(location)
row = self.get_row_index(loc)
col = self.get_column_index(loc)
data = ""
it = col
count = 0
while count < num_loc:
item = self.window.tableWidget.item(row, it)
data += str(item.text())
it = (it + 1) % 17
if it == 0:
it = 1
row += 1
count += 1
return data
def get_row_index(self, value):
index = str(value[0:-1]) + "0"
it = 0
index = self.register.adjust_bytes(index, 6, False)
num_rows = self.window.tableWidget.rowCount()
while it < num_rows:
val = self.window.tableWidget.item(it, 0)
if str(val.text()) == index:
return it
it += 1
return 0
def get_column_index(self, value):
index = str(value[-1]) + "H"
index = self.convert.to_decimal(index)
return index + 1
def get_m_type3(self):
cp = self.get_register(self.REG_CP)
data1 = self.get_data_form_mem(cp, 1)
type_d = self.get_operation_type(data1)
next_loc = self.hexa.plus(cp, "1H")
data = self.get_data_form_mem(next_loc, 1)
print data1, type_d, next_loc, data
msb = data[0]
msb_d = int(self.convert.to_decimal(msb + "H"))
tam = 3
if (msb_d & 1) == 1:
tam = 4
next_loc = self.hexa.plus(next_loc, "1H")
m = data[1] + self.get_data_form_mem(next_loc, tam - 2)
print m, tam, next_loc
cp = self.get_register(self.REG_CP)
cp = self.hexa.plus(cp, str(tam))
self.set_register(self.REG_CP, cp)
if type_d == "simple_s":
m = str(msb_d & 7) + m
type_d = "simple"
elif (msb_d & 6) == 0:
m = m
else:
if (msb_d & 4) == 4:
b = self.get_register(self.REG_B)
m = self.hexa.change_hexadecimal(m)
print "rel base", b, m
m = self.hexa.suma(m, b)
if (msb_d & 2) == 2:
cp = self.get_register(self.REG_CP)
m = self.hexa.change_hexadecimal(m)
print "rel cp", cp, m
m = self.hexa.suma(m, cp)
if (msb_d & 8) == 8:
x = self.get_register(self.REG_X)
m = self.hexa.change_hexadecimal(m)
print ", X", x, m
m = self.hexa.suma(m, x)
print "mem", m
if not type_d == "inmediato":
m = self.register.adjust_bytes(m, 6, False)
m = self.get_data_form_mem(m, 3)
if not type_d == "simple":
m = self.register.adjust_bytes(m, 6, False)
m = self.get_data_form_mem(m, 3)
print "return", m
return m
def get_m_type3_m(self):
cp = self.get_register(self.REG_CP)
data1 = self.get_data_form_mem(cp, 1)
type_d = self.get_operation_type(data1)
next_loc = self.hexa.plus(cp, "1H")
data = self.get_data_form_mem(next_loc, 1)
print data1, type_d, next_loc, data
msb = data[0]
msb_d = int(self.convert.to_decimal(msb + "H"))
tam = 3
if (msb_d & 1) == 1:
tam = 4
next_loc = self.hexa.plus(next_loc, "1H")
m = data[1] + self.get_data_form_mem(next_loc, tam - 2)
print m, tam, next_loc
cp = self.get_register(self.REG_CP)
cp = self.hexa.plus(cp, str(tam))
self.set_register(self.REG_CP, cp)
if type_d == "simple_s":
m = str(msb_d & 7) + m
type_d = "simple"
elif (msb_d & 6) == 0:
m = m
else:
if (msb_d & 4) == 4:
b = self.get_register(self.REG_B)
m = self.hexa.change_hexadecimal(m)
print "rel base", b, m
m = self.hexa.suma(m, b)
if (msb_d & 2) == 2:
cp = self.get_register(self.REG_CP)
m = self.hexa.change_hexadecimal(m)
print "rel cp", cp, m
m = self.hexa.suma(m, cp)
if (msb_d & 8) == 8:
x = self.get_register(self.REG_X)
m = self.hexa.change_hexadecimal(m)
print ", X", x, m
m = self.hexa.suma(m, x)
print "mem", m
# if not type_d == "inmediato":
# m = self.register.adjust_bytes(m,6,False)
# m = self.get_data_form_mem(m,3)
# if not type_d == "simple":
# m = self.register.adjust_bytes(m,6,False)
# m = self.get_data_form_mem(m,3)
# print "return",m
return m
def get_operation_type(self, data):
d = data[1]
d_d = int(self.convert.to_decimal(d + "H"))
val = d_d & 3
if val == 3:
return "simple"
elif val == 2:
return "indirecto"
elif val == 1:
return "inmediato"
return "simple_s"
def add(self, m):
string = "ADD\nA <- (A) + (m..m+2)"
a = self.get_register(self.REG_A)
res = self.hexa.plus(a, m)
string += "\n(A) = " + a + "\n(m..m+2) = " + m + "\n(A) = " + res
self.set_register(self.REG_A, res)
self.window.textEdit_Actions.setText(string)
def addr(self, m):
string = "ADDR\nr2 <- (r1) + (r2)" + "\n"
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
string += "(r1) = " + r1[1] + "\n (r2) = " + r2[1] + "\n"
dat1 = self.get_register(r1[0])
dat2 = self.get_register(r2[0])
res = self.hexa.plus(dat1, dat2)
string += "(" + r2[1] + ")<-" + res
self.set_register(r2[0], res)
self.window.textEdit_Actions.setText(string)
def and_op(self, m):
string = "AND\nA <- (A) & (m..m+2)\n"
a = self.get_register(self.REG_A)
string += "(A) : " + a + "\n" + "(m..m+2) : " + m
res = self.hexa.and_op(a, m)
self.set_register(self.REG_A, res)
self.window.textEdit_Actions.setText(string)
def clear(self, m):
r = self.registers[m[0]]
string = "CLEAR\nr1 <- 0\nr1:" + r[1]
self.set_register(r[0], "0H")
self.window.textEdit_Actions.setText(string)
def comp(self, m):
string = "COMP\nCC = (A) : (m..m+2)"
a = self.get_register(self.REG_A)
string += "\n (A) = " + a + "\n (m..m+2) = " + m
self.cc_val = self.hexa.cmp_op(a, m)
string += "\nCC =" + self.cc_val
self.window.textEdit_Actions.setText(string)
def compr(self, m):
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
dat1 = self.get_register(r1[0])
dat2 = self.get_register(r2[0])
string = "COMPR\nCC = r1 : r2\n" + "r1 = " + r1[1] + "\nr2 = " + r2[1]
self.cc_val = self.hexa.cmp_op(dat1, dat2)
string += "\n CC = " + self.cc_val
self.window.textEdit_Actions.setText(string)
def div(self, m):
string = "DIV\nA <- (A) / (m..m+2)"
a = self.get_register(self.REG_A)
res = self.hexa.div(a, m)
string += "\n(A) = " + a + "\n(m..m+2) = " + m + "\n(A) = " + res
self.set_register(self.REG_A, res)
self.window.textEdit_Actions.setText(string)
def divr(self, m):
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
dat1 = self.get_register(r1[0])
dat2 = self.get_register(r2[0])
string = "DIVR\nr2 <- (r2) / (r1)\nr1 = " + r1[1] + "\nr2 = " + r2[1]
res = self.hexa.div(dat2, dat1)
string += "r2 = " + res
self.set_register(r2[0], res)
self.window.textEdit_Actions.setText(string)
def j_op(self, m):
string = "J: \n CP <- m\nm = " + m
self.set_register(self.REG_CP, m)
self.window.textEdit_Actions.setText(string)
def jeq(self, m):
string = "JEQ: \nsi CC == '=':\n\tCP <- m\n"
string += "CC = '" + self.cc_val + "'"
if self.cc_val == "=":
self.set_register(self.REG_CP, m)
string += "\nCP <- " + m
self.window.textEdit_Actions.setText(string)
def jgt(self, m):
string = "JGT: \nsi CC == '>':\n\tCP <- m\n"
string += "CC = '" + self.cc_val + "'"
if self.cc_val == ">":
self.set_register(self.REG_CP, m)
string += "\nCP <- " + m
self.window.textEdit_Actions.setText(string)
def jlt(self, m):
string = "JLT: \nsi CC == '<':\n\tCP <- m\n"
string += "CC = '" + self.cc_val + "'"
if self.cc_val == "<":
self.set_register(self.REG_CP, m)
string += "\nCP <- " + m
self.window.textEdit_Actions.setText(string)
def jsub(self, m):
string = "JSUB:\n L <- (CP)\nCP <- m"
cp = self.get_register(self.REG_CP)
string += "\n(CP) = " + cp + "\nm = " + m
self.set_register(self.REG_L, cp)
self.set_register(self.REG_CP, m)
self.window.textEdit_Actions.setText(string)
def lda(self, m):
string = "LDA\nA <- (m..m+2)\n(m..m+2) = " + m
self.set_register(self.REG_A, m)
self.window.textEdit_Actions.setText(string)
def ldb(self, m):
string = "LDB\nB <- (m..m+2)\n(m..m+2) = " + m
self.set_register(self.REG_B, m)
self.window.textEdit_Actions.setText(string)
def ldch(self, m):
string = "LDCH\nA[+der] <- (m)"
a = self.get_register(self.REG_A)
m = self.register.adjust_bytes(m, 6, False)
m = self.get_data_form_mem(m, 1)
string += "\n(A) = " + a + "\n(m) = " + m
a = self.register.filter_number(a)
a = a[0:-2] + m
self.set_register(self.REG_A, a)
self.window.textEdit_Actions.setText(string)
def ldl(self, m):
string = "LDL\nL <- (m..m+2)\n(m..m+2) = " + m
self.set_register(self.REG_L, m)
self.window.textEdit_Actions.setText(string)
def lds(self, m):
string = "LDS\nS <- (m..m+2)\n(m..m+2) = " + m
self.set_register(self.REG_S, m)
self.window.textEdit_Actions.setText(string)
def ldt(self, m):
string = "LDT\nT <- (m..m+2)\n(m..m+2) = " + m
self.set_register(self.REG_T, m)
self.window.textEdit_Actions.setText(string)
def ldx(self, m):
string = "LDX\nX <- (m..m+2)\n(m..m+2) = " + m
self.set_register(self.REG_X, m)
self.window.textEdit_Actions.setText(string)
def mul(self, m):
a = self.get_register(self.REG_A)
string = "MUL\nA <- (A) * (m..m+2)\n(A) = " + a + "\n(m..m+2)=" + m
res = self.hexa.mul(a, m)
string += "\n (A) <- " + res
self.set_register(self.REG_A, res)
self.window.textEdit_Actions.setText(string)
def mulr(self, m):
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
dat1 = self.get_register(r1[0])
dat2 = self.get_register(r2[0])
string = "MULR\nr2 <- (r2) * (r1)\nr1 = " + r1[1] + "\nr2 = " + r2[1]
res = self.hexa.mul(dat2, dat1)
string += "r2 = " + res
self.set_register(r2[0], res)
self.window.textEdit_Actions.setText(string)
def or_op(self, m):
string = "OR\nA <- (A) | (m..m+2)\n"
a = self.get_register(self.REG_A)
string += "(A) : " + a + "\n" + "(m..m+2) : " + m
res = self.hexa.or_op(a, m)
self.set_register(self.REG_A, res)
self.window.textEdit_Actions.setText(string)
def rmo(self, m):
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
dat1 = self.get_register(r1[0])
string = "RMO\nr2 <- (r1)\n r1 = " + r1[1] + "\nr2 =" + r2[1]
string += "\nr2 <- " + dat1
self.set_register(r2[0], dat1)
self.window.textEdit_Actions.setText(string)
def rsub(self, m):
l = self.get_register(self.REG_L)
string = "RSUB\nCP <- (L)\n(L) = " + l
string += "CP <-" + l
self.set_register(self.REG_CP, l)
self.window.textEdit_Actions.setText(string)
def sta(self, m):
m = self.register.adjust_bytes(m, 6, False)
reg = self.get_register(self.REG_A)
string = "STA\n m..m+2 <- (A)\nm..m+2 = " + m + "\n(A) = " + reg
reg = self.register.filter_number(reg)
self.modf_reg(reg, m)
self.window.textEdit_Actions.setText(string)
def sta(self, m):
m = self.register.adjust_bytes(m, 6, False)
reg = self.get_register(self.REG_A)
string = "STA\n m..m+2 <- (A)\nm..m+2 = " + m + "\n(A) = " + reg
reg = self.register.filter_number(reg)
self.modf_reg(reg, m)
self.window.textEdit_Actions.setText(string)
def stb(self, m):
m = self.register.adjust_bytes(m, 6, False)
reg = self.get_register(self.REG_B)
string = "STB\n m..m+2 <- (B)\nm..m+2 = " + m + "\n(B) = " + reg
reg = self.register.filter_number(reg)
self.modf_reg(reg, m)
self.window.textEdit_Actions.setText(string)
def stch(self, m):
m = self.register.adjust_bytes(m, 6, False)
reg = self.get_register(self.REG_A)
reg = self.register.filter_number(reg)[-2:]
string = "STCH\n m <- (A)[+der]\nm..m+2 = " + m + "\n(A)[+der] = " + reg
##S rm = self.hexa.plus(m,"2H")
m = self.register.adjust_bytes(m, 6, False)
print "stsh", reg, m
self.modf_reg(reg, m)
self.window.textEdit_Actions.setText(string)
def stl(self, m):
m = self.register.adjust_bytes(m, 6, False)
reg = self.get_register(self.REG_L)
string = "STL\n m..m+2 <- (L)\nm..m+2 = " + m + "\n(L) = " + reg
reg = self.register.filter_number(reg)
self.modf_reg(reg, m)
self.window.textEdit_Actions.setText(string)
def sts(self, m):
m = self.register.adjust_bytes(m, 6, False)
reg = self.get_register(self.REG_S)
string = "STS\n m..m+2 <- (S)\nm..m+2 = " + m + "\n(S) = " + reg
reg = self.register.filter_number(reg)
self.modf_reg(reg, m)
self.window.textEdit_Actions.setText(string)
def stsw(self, m):
m = self.register.adjust_bytes(m, 6, False)
reg = self.get_register(self.REG_SW)
string = "STSW\n m..m+2 <- (SW)\nm..m+2 = " + m + "\n(SW) = " + reg
reg = self.register.filter_number(reg)
self.modf_reg(reg, m)
self.window.textEdit_Actions.setText(string)
def stt(self, m):
m = self.register.adjust_bytes(m, 6, False)
reg = self.get_register(self.REG_T)
string = "STT\n m..m+2 <- (T)\nm..m+2 = " + m + "\n(T) = " + reg
reg = self.register.filter_number(reg)
self.modf_reg(reg, m)
self.window.textEdit_Actions.setText(string)
def stx(self, m):
m = self.register.adjust_bytes(m, 6, False)
reg = self.get_register(self.REG_X)
string = "STX\n m..m+2 <- (X)\nm..m+2 = " + m + "\n(X) = " + reg
reg = self.register.filter_number(reg)
self.modf_reg(reg, m)
self.window.textEdit_Actions.setText(string)
def modf_reg(self, reg, m):
row = self.get_row_index(m)
col = self.get_column_index(m)
it = col
count = 0
while count < len(reg):
item = self.window.tableWidget.item(row, it)
text = reg[count:count + 2]
count += 2
item.setText(text)
it = (it + 1) % 17
if it == 0:
it = 1
row += 1
def sub(self, m):
string = "ADD\nA <- (A) - (m..m+2)"
a = self.get_register(self.REG_A)
res = self.hexa.subs(a, m)
string += "\n(A) = " + a + "\n(m..m+2) = " + m + "\n(A) = " + res
self.set_register(self.REG_A, res)
self.window.textEdit_Actions.setText(string)
def subr(self, m):
r1 = self.registers[m[0]]
r2 = self.registers[m[1]]
dat1 = self.get_register(r1[0])
dat2 = self.get_register(r2[0])
string = "SUBR\nr2 <- (r2) - (r1)\nr1 = " + r1[1] + "\nr2 = " + r2[1]
res = self.hexa.subs(dat2, dat1)
string += "r2 = " + res
self.set_register(r2[0], res)
self.window.textEdit_Actions.setText(string)
def tix(self, m):
x = self.get_register(self.REG_X)
string = "TIX\n(X) <- (X) + 1\n(X) : (m..m+2)\n(X)=" + x
x = self.hexa.plus(x, "1H")
self.set_register(self.REG_X, x)
string += "\n(X)<- (X) + 1\n(X) <- " + x + "\n(m..m+2)=" + m
self.cc_val = self.hexa.cmp_op(x, m)
string += "\nCC = " + self.cc_val
self.window.textEdit_Actions.setText(string)
def tixr(self, m):
r1 = self.registers[m[0]]
dat1 = self.get_register(r1[0])
string = "TIX\n X <- (X) + 1\n(X) : (r1)\nr1 = " + r1[1]
x = self.get_register(self.REG_X)
x = self.hexa.plus(x, "1H")
self.set_register(self.REG_X, x)
self.cc_val = self.hexa.cmp_op(x, dat1)
string += "CC = " + self.cc_val
self.window.textEdit_Actions.setText(string)
# @brief Practica 2 Paso 1 del ensamblador para SIC estandar
# clase para manejar los archivos y checar las extensiones de estos
# @date 29 de Agosto del 2013
# Modolu donde se definen las reglas gramaticales de
# el lenguaje sic estandar y se manejan los errores sintacticos
from scanner import tokens
from scanner import scann
import ply.yacc as yacc
from convert import Convert
from displacement import Displacement
from hexadecimal import Hexadecimal
from register import Register
from segment import Segment
seg = Segment()
hex = Hexadecimal()
conv = Convert()
disp = Displacement()
reg = Register("R")
extension = ""
registers = {
"A": 0,
"X": 1,
"L": 2,
"CP": 8,
"SW": 9,
"B": 3,
"S": 4,
"T": 5,
"F": 6
}
def __init__(self, parent=None):
QtGui.QWidget.__init__(self)
self.window = Ui_DockWidget()
self.window.setupUi(self)
self.file_name = None
self.init = None
self.header = None
self.registers = None
self.end = None
self.rows_count = None
self.end_program = None
self.cc = "="
self.hex = Hexadecimal()
self.reg = Register("T")
self.window.btnSimular.clicked.connect(self.simular)
self.operations = {
"18": self.add,
"00": self.lda,
"40": self.andop,
"28": self.cmp_op,
"24": self.div,
"3C": self.j_op,
"30": self.jeq,
"34": self.jgt,
"38": self.jlt,
"48": self.jsub,
"50": self.ldch,
"08": self.ldl,
"04": self.ldx,
"20": self.mul,
"4C": self.rsub,
"0C": self.sta,
"54": self.stch,
"14": self.stl,
"E8": self.stsw,
"10": self.stx,
"1C": self.sub,
"2C": self.tix,
}
self.operations_text = {
"18": "ADD",
"00": "LDA",
"40": "AND",
"28": "COMP",
"24": "DIV",
"3C": "J",
"30": "JEQ",
"34": "JGT",
"38": "JLT",
"48": "JSUB",
"50": "LDCH",
"08": "LDL",
"04": "LDX",
"20": "MUL",
"4C": "RSUB",
"0C": "STA",
"54": "STCH",
"14": "STL",
"E8": "STSW",
"10": "STX",
"1C": "SUB",
"2C": "TIX",
}
def test_relational_ops():
grade = 0
try:
one = Hexadecimal(1)
two = Hexadecimal(2)
#Testing <
try:
if one < two:
grade += 2
else:
print("Trouble with <")
if two < one:
print("Trouble with <")
else:
grade += 1
except Exception as ex:
print("Crashed when testing <")
#Testing <=
try:
if one <= two:
grade += 2
else:
print("Trouble with <=")
if one <= one:
grade += 1
else:
print("Trouble with <=")
if two <= one:
print("Trouble with <=")
else:
grade += 1
except Exception as ex:
print("Crashed when testing <=")
#Testing >
try:
if one > two:
print("Trouble with >")
else:
grade += 2
if two > one:
grade += 1
else:
print("Trouble with >")
except Exception as ex:
print("Crashed when testing >")
#Testing >=
try:
if two >= one:
grade += 2
else:
print("Trouble with >=")
if two >= two:
grade += 1
else:
print("Trouble with >=")
if one >= two:
print("Trouble with >=")
else:
grade += 1
except Exception as ex:
print("Crashed when testing >=")
#Testing ==
try:
if one == one:
grade += 2
else:
print("Trouble with ==")
if one == two:
print("Trouble with ==")
else:
grade += 1
except Exception as ex:
print("Crashed when testing ==")
#Testing !=
try:
if one != two:
grade += 2
else:
print("Trouble with !=")
if one != one:
print("Trouble with !=")
else:
grade += 1
except Exception as ex:
print("Crashed when testing !=")
except Exception as ex:
print("Crashed when testing Relational operators")
return grade
class Segment:
def __init__(self):
self.index = 0
self.list_n = []
self.conv = Convert()
self.reg = Register("X")
self.hexa = Hexadecimal()
self.last_code = 0
## regresa el segmento actual
def get_segment(self):
return self.list_n[self.index]
##crea un segmento con el nombre especificado
# @param name nombre del segmento que se creara
def new_segment(self,name):
self.index = len(self.list_n)
self.list_n.append(NodoS(name,self.index))
##inserta una etiqueta a la tabla de simbolos y si esta ya se encuentra marca un error
#@param name simbolo que se intentara insertar a la tabla
#@param dir_val direccion o valor del simbolo
#@param sym_type tipo del simbolo el cual puede ser relativo o absoluto
#@param lineno numero de linea donde se encontro la etiqueta
def insert_symbol(self,name,dir_val,sym_type,lineno,bloque_index,externo = False):
if self.exist_symbol(name):
self.insert_error(str(lineno),"etiqueta previamente definida")
else:
sym = Symbol(name,dir_val,sym_type,bloque_index,externo)
self.get_segment().symbols.append(sym)
def exist_symbol(self ,name):
for it in self.get_segment().symbols:
if it.get_name() == name:
return it
return None
##checa si en el diccionario de errores ya se inserto un error en esa linea de codigo
#y si no es asi la inserta
#@param line linea de codigo donde se encontro un error
#@param text cadena que se genera en el error
def insert_error(self,line,text):
l = int(line) - self.last_code -1
if not str(l) in self.get_segment().errors and l >= 0:
self.get_segment().errors[str(l)]= text
##checa si en el diccionario de advertencias ya se inserto un error en esa linea de codigo
#y si no es asi la inserta
#@param line linea de codigo donde se encontro un warnind
#@param text cadena que se genera en el warning
def insert_warning(self,line,text):
l = int(line) - self.last_code
if not str(l) in self.get_segment().warnings:
self.get_segment().warnings[str(line)] = text
##aumenta el contador de programa
#@param increment cantidad en hexadecimal que se le agregara al CP
def increment_PC(self,increment):
num1 = self.get_segment().pc[-1]
if not self.conv.is_hexadecimal(str(increment)):
increment = self.conv.decimal_to_hexadecimal(increment)
val = self.hexa.plus(num1,increment)
if val == "H":
val = "0H"
val = self.reg.adjust_bytes(val,6,False)+"H"
self.get_segment().bloques.set_last_cp(val)
self.get_segment().pc.append(val)
self.get_segment().num_bloque.append(self.get_segment().bloques.get_index())
## calcula el tamaño del programa
#@return regresa en hexadecimal el tamaño del programa
def get_len_program(self):
return self.get_segment().bloques.get_len_program()
## genera y completa la tabla de bloques de todos los segmentos
def genera_tabla_bloques(self):
for it in self.list_n:
it.bloques.gen_table()
## regresa un segmento en un index especificado
# @param index posicion del segmento que se quiere
def get_segment_at(self,index):
return self.list_n[index]
## imprime los resultados de un segmento
# @param extension es la extencion que tendran los archivos de salida de los segmentos
def print_results(self,extension):
for it in self.list_n:
# print it.errors,it.errors_s
it.archivo_intermedio(extension)
if len(it.errors) == 0 and len(it.errors_s) == 0:
it.archivo_objeto(extension)
print "Errors", len(it.errors)+len(it.errors_s)
def get_num_errors_all(self):
cant = 0
for it in self.list_n:
cant += len(it.errors_s)
cant += len(it.errors)
return cant
class Cargador(QtGui.QDockWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self)
self.window = Ui_DockWidget()
self.window.setupUi(self)
self.file_name = None
self.init = None
self.header = None
self.registers = None
self.end = None
self.rows_count = None
self.end_program = None
self.cc = "="
self.hex = Hexadecimal()
self.reg = Register("T")
self.window.btnSimular.clicked.connect(self.simular)
self.operations = {
"18": self.add,
"00": self.lda,
"40": self.andop,
"28": self.cmp_op,
"24": self.div,
"3C": self.j_op,
"30": self.jeq,
"34": self.jgt,
"38": self.jlt,
"48": self.jsub,
"50": self.ldch,
"08": self.ldl,
"04": self.ldx,
"20": self.mul,
"4C": self.rsub,
"0C": self.sta,
"54": self.stch,
"14": self.stl,
"E8": self.stsw,
"10": self.stx,
"1C": self.sub,
"2C": self.tix
}
self.operations_text = {
"18": "ADD",
"00": "LDA",
"40": "AND",
"28": "COMP",
"24": "DIV",
"3C": "J",
"30": "JEQ",
"34": "JGT",
"38": "JLT",
"48": "JSUB",
"50": "LDCH",
"08": "LDL",
"04": "LDX",
"20": "MUL",
"4C": "RSUB",
"0C": "STA",
"54": "STCH",
"14": "STL",
"E8": "STSW",
"10": "STX",
"1C": "SUB",
"2C": "TIX"
}
def simular(self):
num_actions = self.get_count_next_actions()
if num_actions == -1:
self.window.textEdit_Actions.setText(
"Numero de simulaciones no Validas")
else:
self.make_n_simulations(num_actions)
def make_n_simulations(self, number):
cp = self.get_CP_value()
if self.hex.minus_than(cp, self.end_program):
it = 0
while it < number:
register = self.get_instruct()
operation = register[0:2]
address = register[2:]
val = self.get_address_tarjet(address)
fun = self.operations[operation]
fun(val)
it += 1
else:
self.window.textEdit_Actions.setText(
"El programa se ha terminado no puede continuar la simulacion")
def add(self, m):
a = self.get_a_value()
string = "ADD: \nCP = 18" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.plus(a, m)
string += "A <- A + (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def andop(self, m):
a = self.get_a_value()
string = "AND: \nCP = 40" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.and_op(a, m)
string += "A <- A & (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def cmp_op(self, m):
a = self.get_a_value()
string = "COMP: \nA = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
self.cc = self.hex.cmp_op(a, m)
string += "(A):(m..m+2)\n"
string += "CC = " + self.cc
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def div(self, m):
a = self.get_a_value()
string = "DIV: \nCP = 24" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.div(a, m)
string += "A <- A / (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def lda(self, m):
string = "LDA: \nm = " + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2) = " + str(m) + "\n"
string += "A <- (m..m+2)"
a = self.reg.adjust_bytes(m, 6, False)
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def j_op(self, m):
string = "J:\nCP<-m\n"
string += "m = " + str(m)
m = self.reg.adjust_bytes(m, 6, False)
m = self.hex.change_hexadecimal(m)
self.set_cp_value(m)
self.window.textEdit_Actions.setText(string)
def jeq(self, m):
string = "JEQ \nCP<-m si CC == '='\n"
string += "m = " + str(m) + "\n"
string += "cc = " + str(self.cc)
m = self.reg.adjust_bytes(m, 6, False)
m = self.hex.change_hexadecimal(m)
if self.cc == "=":
self.set_cp_value(m)
else:
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def jgt(self, m):
string = "JGT \nCP<-m si CC == '>'\n"
string += "m = " + str(m) + "\n"
string += "cc = " + str(self.cc)
m = self.reg.adjust_bytes(m, 6, False)
m = self.hex.change_hexadecimal(m)
if self.cc == ">":
self.set_cp_value(m)
else:
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def jlt(self, m):
string = "JLT \nCP<-m si CC == '<'\n"
string += "m = " + str(m) + "\n"
string += "cc = " + str(self.cc)
m = self.reg.adjust_bytes(m, 6, False)
m = self.hex.change_hexadecimal(m)
if self.cc == "<":
self.set_cp_value(m)
else:
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def jsub(self, m):
string = "JSUB \n L->(CP);CP<-m"
cp = self.get_CP_value()
string += "CP = " + str(cp) + "\n"
cp = self.get_mem_value(cp)
string += "(CP) = " + str(cp) + "\n"
self.set_l_value(cp)
self.set_cp_value(m)
self.window.textEdit_Actions.setText(string)
def ldch(self, m):
string = "LDCH\nA[+der]<-(m)\n"
string += "m = " + str(m) + "\n"
m = self.get_mem_value(m)
m = m[0:2]
a = self.get_a_value()
string += "(m) = " + str(m) + "\n"
string += "A = " + str(a) + "\n"
a = self.reg.filter_number(a)
a = a[0:-2] + m
string += "A[+der]<-(m)\n"
string += "A = " + str(a)
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def ldl(self, m):
string = "LDL\nL<-(m..m+2)"
string += "m = " + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2) =" + str(m)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
self.set_l_value(m)
def ldx(self, m):
string = "LDX\nX<-(m..m+2)"
string += "m = " + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2) =" + str(m)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
self.set_x_value(m)
def mul(self, m):
a = self.get_a_value()
string = "MUL: \nCP = 20" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.mul(a, m)
string += "A <- A * (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def or_op(self, m):
a = self.get_a_value()
string = "OR: \nCP = 44" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.or_op(a, m)
string += "A <- A | (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def rsub(self, m):
string = "RSUB\nPC<-(L)"
l = self.get_l_value()
string += "L=" + str(l) + "\n"
l = self.get_mem_value(l)
string += "(L)=" + str(l) + "\n"
self.set_cp_value(l)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def sta(self, m):
string = "STA\nm..m+2<-(A)\nm=" + str(m) + "\n"
it = 0
row = self.get_row_index(m)
col = self.get_column_index(m)
a = self.get_a_value()
string += "(A)=" + str(a)
index = 0
while it < 3:
val = a[index:index + 2]
index += 2
item_text = QtGui.QTableWidgetItem(val)
self.window.tableWidget.setItem(row, col, item_text)
col = (col + 1) % 17
if col == 0:
col = 1
row += 1
it += 1
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def stch(self, m):
string = "STCH\nm<-(A)[+der]\nm=" + str(m) + "\n"
row = self.get_row_index(m)
col = self.get_column_index(m)
print row, col, m
a = self.get_a_value()
a = self.reg.filter_number(a)
a_der = str(a)[-2:]
string += "(A)[+der]=" + a_der
item = QtGui.QTableWidgetItem(a_der)
self.window.tableWidget.setItem(row, col, item)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def stl(self, m):
string = "STL\nm..m+2<-(L)\nm=" + str(m) + "\n"
it = 0
row = self.get_row_index(m)
col = self.get_column_index(m)
l = self.get_l_value()
string += "(l)=" + str(l)
index = 0
while it < 3:
val = l[index:index + 2]
index += 2
item_text = QtGui.QTableWidgetItem(val)
self.window.tableWidget.setItem(row, col, item_text)
col = (col + 1) % 17
if col == 0:
col = 1
row += 1
it += 1
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def stsw(self, m):
string = "STSW\nm..m+2<-(SW)\nm=" + str(m) + "\n"
it = 0
row = self.get_row_index(m)
col = self.get_column_index(m)
sw = self.get_sw_value()
string += "(SW)=" + str(sw)
index = 0
while it < 3:
val = sw[index:index + 2]
index += 2
item_text = QtGui.QTableWidgetItem(val)
self.window.tableWidget.setItem(row, col, item_text)
col = (col + 1) % 17
if col == 0:
col = 1
row += 1
it += 1
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def stx(self, m):
string = "STSX\nm..m+2<-(X)\nm=" + str(m) + "\n"
it = 0
row = self.get_row_index(m)
col = self.get_column_index(m)
x = self.get_x_value()
string += "(X)=" + str(x)
index = 0
while it < 3:
val = x[index:index + 2]
index += 2
item_text = QtGui.QTableWidgetItem(val)
self.window.tableWidget.setItem(row, col, item_text)
col = (col + 1) % 17
if col == 0:
col = 1
row += 1
it += 1
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def sub(self, m):
a = self.get_a_value()
string = "SUB: \nCP = 1C" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.subs(a, m)
string += "A <- A - (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def tix(self, m):
string = "TIX\nX<-(X)+1;(X):(m,,m+2)\n"
x = self.get_x_value()
string += "X =" + str(x) + "+1\n"
x = self.hex.plus(x, "1H")
string += "X =" + str(x) + "\n"
self.set_x_value(x)
m = self.get_mem_value(m)
string += "(m..m+2) +" + str(m) + "\n"
self.cc = self.hex.cmp_op(x, m)
string += "(X):(m..m+2)\nCC=" + self.cc
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def increment_cp(self, num):
c = Convert()
num = c.decimal_to_hexadecimal(num)
cp = self.get_CP_value()
cp = self.hex.plus(cp, num)
self.set_cp_value(cp)
def get_address_tarjet(self, value):
c = Convert()
addressing = value[0] + "H"
addressing = int(c.to_decimal(addressing))
val = value
bina = c.decimal_to_binary(addressing, 4)
bina = c.mask_and(bina, "1000")
if bina == "1000":
val = self.hex.subs(value, "8000H")
x = self.get_x_value()
val = self.hex.plus(val, x)
val = self.reg.filter_number(val)
return val
def set_a_value(self, value):
value = self.reg.adjust_bytes(value, 6, False)
value = self.hex.change_hexadecimal(value)
item_text = QtGui.QTableWidgetItem(value)
self.window.tableWidget_2.setItem(1, 0, item_text)
def get_a_value(self):
item = self.window.tableWidget_2.item(1, 0)
return str(item.text())
def get_l_value(self):
item = self.window.tableWidget_2.item(3, 0)
return str(item.text())
def set_l_value(self, value):
value = self.reg.adjust_bytes(value, 6, False)
value = self.hex.change_hexadecimal(value)
item_text = QtGui.QTableWidgetItem(value)
self.window.tableWidget_2.setItem(3, 0, item_text)
def get_x_value(self):
item = self.window.tableWidget_2.item(2, 0)
return str(item.text())
def set_x_value(self, value):
value = self.reg.adjust_bytes(value, 6, False)
value = self.hex.change_hexadecimal(value)
item_text = QtGui.QTableWidgetItem(value)
self.window.tableWidget_2.setItem(2, 0, item_text)
def get_sw_value(self):
item = self.window.tableWidget_2.item(4, 0)
return str(item.text())
def set_sw_value(self, value):
value = self.reg.adjust_bytes(value, 6, False)
value = self.hex.change_hexadecimal(value)
item_text = QtGui.QTableWidgetItem(value)
self.window.tableWidget_2.setItem(4, 0, item_text)
def get_CP_value(self):
item = self.window.tableWidget_2.item(0, 0)
return str(item.text())
def set_cp_value(self, cp):
cp = self.reg.adjust_bytes(cp, 6, False)
cp = self.hex.change_hexadecimal(cp)
item_text = QtGui.QTableWidgetItem(cp)
self.window.tableWidget_2.setItem(0, 0, item_text)
self.get_next_text_instruction()
def get_next_text_instruction(self):
cp = self.get_CP_value()
mem = self.get_mem_value(cp)
cod = mem[0:2]
op = self.operations_text.get(str(cod), "FIN")
self.window.label_sig.setText(op)
def get_row_index(self, value):
index = str(value[0:-1]) + "0"
it = 0
index = self.reg.adjust_bytes(index, 6, False)
num_rows = self.window.tableWidget.rowCount()
while it < num_rows:
val = self.window.tableWidget.item(it, 0)
if str(val.text()) == index:
return it
it += 1
return 0
def get_column_index(self, value):
c = Convert()
index = str(value[-1]) + "H"
index = c.to_decimal(index)
del c
return index + 1
def get_instruct(self):
cp = self.get_CP_value()
return self.get_mem_value(cp)
def get_mem_value(self, value):
value = self.reg.filter_number(str(value))
col = self.get_column_index(value)
row = self.get_row_index(value)
register = ""
it = col
cont = 0
while cont < 3:
item = self.window.tableWidget.item(row, it)
register += str(item.text())
it = (it + 1) % 17
if it == 0:
it = 1
row += 1
cont += 1
return register
def get_count_next_actions(self):
count_actions = str(self.window.textEdit_Num.toPlainText())
if count_actions == "":
count_actions = 1
elif not count_actions.isdigit():
return -1
return int(count_actions)
def get_list_register(self):
f = open(self.file_name)
text = f.read()
list = text.split("\n")
list.remove("")
return list
def load_file_name(self, file_name):
self.file_name = file_name + ".os"
list = self.get_list_register()
self.header = list[0]
self.end = list[-1]
self.registers = list[1:-1]
self.charge_in_memory()
def charge_text(self):
c = Convert()
for r in self.registers:
string = r[9:]
index = 0
init = r[1:7]
col_start = init[-1] + "H"
col = int(c.to_decimal(col_start) + 1)
res = self.hex.subs(init[:-1], self.init[:-1])
dec_res = int(c.to_decimal(res))
while index < len(string):
byte = string[index:index + 2]
item = QtGui.QTableWidgetItem(byte)
self.window.tableWidget.setItem(dec_res, col, item)
index += 2
col = (col + 1) % 17
if col == 0:
col = 1
dec_res += 1
def charge_header(self):
init = self.header[7:13]
self.init = init
length = self.header[13:]
self.end_program = self.hex.plus(init, length)
star_rows = length[:-1]
index = init[:-1]
num_rows = star_rows + "H"
c = Convert()
num_rows = int(c.to_decimal(num_rows))
self.window.tableWidget.setRowCount(num_rows + 1)
it = 0
while it <= num_rows:
dir = index + "0H"
r = Register("T")
dir = r.adjust_bytes(dir, 6, False)
item = QtGui.QTableWidgetItem(dir)
self.window.tableWidget.setItem(it, 0, item)
it += 1
index = self.hex.plus(index, "1H")[:-1]
def charge_end_file(self):
dir = self.end[1:]
dir = self.reg.adjust_bytes(dir, 6, False)
dir = self.hex.change_hexadecimal(dir)
item = QtGui.QTableWidgetItem(dir)
self.window.tableWidget_2.setItem(0, 0, item)
self.get_next_text_instruction()
it = 1
while it < 5:
item = QtGui.QTableWidgetItem("FFFFFFH")
self.window.tableWidget_2.setItem(it, 0, item)
it += 1
def charge_in_memory(self):
self.charge_header()
self.charge_text()
self.charge_end_file()
self.init_empty_rows()
def init_empty_rows(self):
rows_count = self.window.tableWidget.rowCount()
colum_count = self.window.tableWidget.columnCount()
for i in range(rows_count):
for j in range(colum_count):
item = self.window.tableWidget.item(i, j)
if item == None:
item_text = QtGui.QTableWidgetItem("FF")
self.window.tableWidget.setItem(i, j, item_text)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self)
self.window = Ui_DockWidget()
self.window.setupUi(self)
self.add_registers()
self.cargador = None
self.hexa = Hexadecimal()
self.convert = Convert()
self.register = Register("A")
self.init_registers()
self.end_program = "0H"
self.cc_val = "="
self.window.btnSimular.clicked.connect(self.simular)
self.operations_3 = {
"18": "ADD",
"00": "LDA",
"40": "AND",
"28": "COMP",
"24": "DIV",
"3C": "J",
"30": "JEQ",
"34": "JGT",
"38": "JLT",
"48": "JSUB",
"50": "LDCH",
"08": "LDL",
"04": "LDX",
"20": "MUL",
"4C": "RSUB",
"0C": "STA",
"54": "STCH",
"14": "STL",
"E8": "STSW",
"10": "STX",
"1C": "SUB",
"2C": "TIX",
"58": "ADDF",
"88": "COMPF",
"64": "DIVF",
"68": "LDB",
"70": "LDF",
"6C": "LDS",
"74": "LDT",
"D0": "LPS",
"60": "MULF",
"EC": "SSK",
"78": "STB",
"80": "STF",
"D4": "STI",
"7C": "STS",
"E8": "STSW",
"84": "STT",
"5C": "SUBF",
"E0": "TD",
"DC": "WD",
"44": "OR"
}
self.operations_1 = {
"C4": "FIX",
"C0": "FLOAT",
"F4": "HIO",
"C8": "NORM",
"F0": "SIO",
"F8": "TIO"
}
self.operations_2 = {
"90": "ADDR",
"B4": "CLEAR",
"A0": "COMPR",
"9C": "DIVR",
"98": "MULR",
"AC": "RMO",
"A4": "SHIFTL",
"A8": "SHIFTR",
"94": "SUBR",
"B0": "SVC",
"B8": "TIXR"
}
self.operations = {
"18": self.add,
"00": self.lda,
"40": self.and_op,
"28": self.comp,
"24": self.div,
"3C": self.j_op,
"30": self.jeq,
"34": self.jgt,
"38": self.jlt,
"48": self.jsub,
"50": self.ldch,
"08": self.ldl,
"04": self.ldx,
"20": self.mul,
"4C": self.rsub,
"0C": self.sta,
"54": self.stch,
"14": self.stl,
"E8": self.stsw,
"10": self.stx,
"1C": self.sub,
"2C": self.tix,
"58": self.float_operations,
"88": self.float_operations,
"64": self.float_operations,
"68": self.ldb,
"70": self.float_operations,
"6C": self.lds,
"74": self.ldt,
"D0": self.system_operations,
"60": self.float_operations,
"EC": self.system_operations,
"78": self.stb,
"80": self.float_operations,
"D4": self.system_operations,
"7C": self.sts,
"E8": self.system_operations,
"84": self.stt,
"5C": self.float_operations,
"E0": self.system_operations,
"DC": self.system_operations,
"C4": self.float_operations,
"C0": self.float_operations,
"F4": self.system_operations,
"C8": self.float_operations,
"F0": self.system_operations,
"44": self.or_op,
"F8": self.system_operations,
"90": self.addr,
"B4": self.clear,
"A0": self.compr,
"9C": self.divr,
"98": self.mulr,
"AC": self.rmo,
"A4": "SHIFTL",
"A8": "SHIFTR",
"94": self.subr,
"B0": "SVC",
"B8": self.tixr
}
self.registers = {
"0": [self.REG_A, "A"],
"1": [self.REG_X, "X"],
"2": [self.REG_L, "L"],
"8": [self.REG_CP, "CP"],
"9": [self.REG_SW, "SW"],
"3": [self.REG_B, "B"],
"4": [self.REG_S, "S"],
"5": [self.REG_T, "T"],
"6": [self.REG_F, "F"]
}
self.operations_m = [
"J", "JLT", "JEQ", "JGT", "JSUB", "STA", "STB", "STCH", "STL",
"STS", "STSW", "STT", "STX", "LDCH"
]
class Cargadorx():
def __init__(self, window):
self.window = window
self.tabse = Tabse()
self.lonsc = "0H"
self.dirsc = "0H"
self.dirprog = "0H"
self.direj = "0H"
self.hexa = Hexadecimal()
self.convert = Convert()
self.register = Register("A")
self.error_indefinido = False
self.error_duplicado = False
def show_error(self, msg):
##QtGui.QMessageBox.about(self.window,"Error",msg)
self.window.textEdit_Actions.setText(msg)
def load_file_name(self, list_obj, dirprog):
val_int = self.convert.to_decimal(dirprog)
self.dirprog = self.convert.decimal_to_hexadecimal(val_int)
self.dirprog = self.register.adjust_bytes(self.dirprog, 6, False) + "H"
self.dirsc = self.dirprog
self.step_1(list_obj)
if not self.error_duplicado:
self.create_memory()
self.dirsc = self.dirprog
self.direj = self.dirprog
self.step_2(list_obj)
self.init_empty_rows()
self.tabse.print_tabse()
if self.error_indefinido:
self.show_error("Error en simbolo indefinido")
else:
self.show_error("Error simbolo duplicado")
def step_1(self, list_obj):
for list_n in list_obj:
for n in list_n:
if len(n) > 0:
if n[0] == "H":
self.step_h(n, 1)
elif n[0] == "D":
self.step_1_d(n)
self.dirsc = self.hexa.plus(self.dirsc, self.lonsc)
def step_h(self, n, step):
name = n[1:7]
name = name.strip()
self.lonsc = n[13:] + "H"
if step == 1:
if not self.tabse.exist_node(name):
self.tabse.insert_section(name, self.dirsc, self.lonsc)
else:
##print name
self.error_duplicado = True
def step_1_d(self, n):
num = (len(n) - 1) / 12
it = 0
# print "num",num,len(n)
while it < num:
index1 = (it * 12) + 1
index2 = index1 + 6
index3 = index2 + 6
name = n[index1:index2].strip()
#print "name",name
if index3 >= len(n):
len_r = n[index2:] + "H"
else:
len_r = n[index2:index3] + "H"
if not self.tabse.exist_node(name):
val = self.hexa.plus(len_r, self.dirsc)
self.tabse.insert_variable(name, val)
else:
print "error", name
self.error_duplicado = True
it += 1
def step_2(self, list_obj):
for list_n in list_obj:
for n in list_n:
if len(n) > 0:
if n[0] == "H":
self.step_h(n, 2)
elif n[0] == "T":
self.charge_obj_code(n)
elif n[0] == "M":
self.change_m_register(n)
elif n[0] == "E":
self.reg_e(n)
self.dirsc = self.hexa.plus(self.dirsc, self.lonsc)
def reg_e(self, r):
if len(r) > 1:
val = r[1:] + "H"
self.direj = self.hexa.plus(self.dirsc, val)
def charge_obj_code(self, r):
string = r[9:]
index = 0
init = r[1:7]
init = self.hexa.plus(init + "H", self.dirsc)[:-1]
col_start = init[-1] + "H"
col = int(self.convert.to_decimal(col_start) + 1)
dat1 = self.get_part_dat(init)
res = self.hexa.subs(dat1, self.dirprog[:-2])
dec_res = int(self.convert.to_decimal(res))
while index < len(string):
byte = string[index:index + 2]
item = QtGui.QTableWidgetItem(byte)
self.window.tableWidget.setItem(dec_res, col, item)
index += 2
col = (col + 1) % 17
if col == 0:
col = 1
dec_res += 1
def get_part_dat(self, dat):
if len(dat) == 1:
return "0"
else:
return dat[:-1]
def change_m_register(self, r):
val = r[1:7]
med_byte = r[7:9]
sign = r[9]
name = r[10:].strip()
# print val,med_byte,sign,name
n = self.tabse.get_register(name)
if n:
# print "existe"
val = self.hexa.plus(val, self.dirsc)[:-1]
content = self.get_content_at(val, 3)
# print val,content
ant_content = ""
if med_byte == "5":
ant_content = content[0]
content = content[1:]
dir_es = n.get_dir()
new_dir = self.make_operation(sign, content, dir_es)
# print "perico",new_dir,content,sign,dir_es
new_dir = self.register.adjust_bytes(new_dir, 6, True)
if med_byte == "5":
new_dir = ant_content + new_dir[1:]
new_dir = ant_content + new_dir
# print new_dir
col_num = val[-1] + "H"
col = int(self.convert.to_decimal(col_num) + 1)
val = self.get_part_dat(val)
ren = self.hexa.subs(val, self.dirprog[:-2])
ren = int(self.convert.to_decimal(ren))
index = 0
while index < len(new_dir):
byte = new_dir[index:index + 2]
item = QtGui.QTableWidgetItem(byte)
self.window.tableWidget.setItem(ren, col, item)
index += 2
col = (col + 1) % 17
if col == 0:
col = 1
ren += 1
else:
self.error_indefinido = True
def make_operation(self, sign, dat1, dat2):
val1 = self.get_int_operator(dat1)
val2 = self.get_int_operator(dat2)
if sign == "-":
ret = val1 - val2
else:
ret = val1 + val2
ret = self.exp_to_hexadecimal(ret)
return ret
def get_int_operator(self, dat):
if dat[-1] == "H":
dat = dat[:-1]
if dat[0] == "F":
string = ""
it = 0
while it < len(dat):
if not dat[it] == "F":
string += dat[it]
it += 1
if len(string) == 0:
return -1
else:
val = "1" + ("0" * len(string)) + "H"
val = self.convert.to_decimal(val)
val2 = self.convert.to_decimal(string + "H")
return val2 - val
else:
return self.convert.to_decimal(dat + "H")
def get_content_at(self, dirr, num):
dir_n = dirr[-1] + "H"
col = int(self.convert.to_decimal(dir_n) + 1)
dire = self.get_part_dat(dirr)
ren = self.hexa.subs(dire, self.dirprog[:-2])
ren = int(self.convert.to_decimal(ren))
it = 0
text = ""
while it < num:
item = self.window.tableWidget.item(ren, col)
text += str(item.text())
it += 1
col = (col + 1) % 17
if col == 0:
col = 1
ren += 1
return text
def exp_to_hexadecimal(self, val):
if val < 0:
val = int(val * -1)
val = val ^ 65535
val += 1
if val == 0:
val = "0H"
else:
val = self.convert.decimal_to_hexadecimal(val)
if val[0] == "F" and len(val) > 6:
val = "0" + val
return val
def create_memory(self):
init = self.dirprog[:-1]
length = self.hexa.subs(self.dirsc, self.dirprog)[:-1]
star_rows = length[:-1]
index = init[:-1]
num_rows = star_rows + "H"
num_rows = int(self.convert.to_decimal(num_rows))
self.window.tableWidget.setRowCount(num_rows + 1)
it = 0
while it <= num_rows:
dir = index + "0H"
dir = self.register.adjust_bytes(dir, 6, False)
item = QtGui.QTableWidgetItem(dir)
self.window.tableWidget.setItem(it, 0, item)
it += 1
index = self.hexa.plus(index, "1H")[:-1]
def init_empty_rows(self):
rows_count = self.window.tableWidget.rowCount()
colum_count = self.window.tableWidget.columnCount()
for i in range(rows_count):
for j in range(colum_count):
item = self.window.tableWidget.item(i, j)
if item == None:
item_text = QtGui.QTableWidgetItem("FF")
self.window.tableWidget.setItem(i, j, item_text)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self)
self.window = Ui_DockWidget()
self.window.setupUi(self)
self.file_name = None
self.init = None
self.header = None
self.registers = None
self.end = None
self.rows_count = None
self.end_program = None
self.cc = "="
self.hex = Hexadecimal()
self.reg = Register("T")
self.window.btnSimular.clicked.connect(self.simular)
self.operations = {
"18": self.add,
"00": self.lda,
"40": self.andop,
"28": self.cmp_op,
"24": self.div,
"3C": self.j_op,
"30": self.jeq,
"34": self.jgt,
"38": self.jlt,
"48": self.jsub,
"50": self.ldch,
"08": self.ldl,
"04": self.ldx,
"20": self.mul,
"4C": self.rsub,
"0C": self.sta,
"54": self.stch,
"14": self.stl,
"E8": self.stsw,
"10": self.stx,
"1C": self.sub,
"2C": self.tix
}
self.operations_text = {
"18": "ADD",
"00": "LDA",
"40": "AND",
"28": "COMP",
"24": "DIV",
"3C": "J",
"30": "JEQ",
"34": "JGT",
"38": "JLT",
"48": "JSUB",
"50": "LDCH",
"08": "LDL",
"04": "LDX",
"20": "MUL",
"4C": "RSUB",
"0C": "STA",
"54": "STCH",
"14": "STL",
"E8": "STSW",
"10": "STX",
"1C": "SUB",
"2C": "TIX"
}
class Cargador(QtGui.QDockWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self)
self.window = Ui_DockWidget()
self.window.setupUi(self)
self.file_name = None
self.init = None
self.header = None
self.registers = None
self.end = None
self.rows_count = None
self.end_program = None
self.cc = "="
self.hex = Hexadecimal()
self.reg = Register("T")
self.window.btnSimular.clicked.connect(self.simular)
self.operations = {
"18": self.add,
"00": self.lda,
"40": self.andop,
"28": self.cmp_op,
"24": self.div,
"3C": self.j_op,
"30": self.jeq,
"34": self.jgt,
"38": self.jlt,
"48": self.jsub,
"50": self.ldch,
"08": self.ldl,
"04": self.ldx,
"20": self.mul,
"4C": self.rsub,
"0C": self.sta,
"54": self.stch,
"14": self.stl,
"E8": self.stsw,
"10": self.stx,
"1C": self.sub,
"2C": self.tix,
}
self.operations_text = {
"18": "ADD",
"00": "LDA",
"40": "AND",
"28": "COMP",
"24": "DIV",
"3C": "J",
"30": "JEQ",
"34": "JGT",
"38": "JLT",
"48": "JSUB",
"50": "LDCH",
"08": "LDL",
"04": "LDX",
"20": "MUL",
"4C": "RSUB",
"0C": "STA",
"54": "STCH",
"14": "STL",
"E8": "STSW",
"10": "STX",
"1C": "SUB",
"2C": "TIX",
}
def simular(self):
num_actions = self.get_count_next_actions()
if num_actions == -1:
self.window.textEdit_Actions.setText("Numero de simulaciones no Validas")
else:
self.make_n_simulations(num_actions)
def make_n_simulations(self, number):
cp = self.get_CP_value()
if self.hex.minus_than(cp, self.end_program):
it = 0
while it < number:
register = self.get_instruct()
operation = register[0:2]
address = register[2:]
val = self.get_address_tarjet(address)
fun = self.operations[operation]
fun(val)
it += 1
else:
self.window.textEdit_Actions.setText("El programa se ha terminado no puede continuar la simulacion")
def add(self, m):
a = self.get_a_value()
string = "ADD: \nCP = 18" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.plus(a, m)
string += "A <- A + (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def andop(self, m):
a = self.get_a_value()
string = "AND: \nCP = 40" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.and_op(a, m)
string += "A <- A & (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def cmp_op(self, m):
a = self.get_a_value()
string = "COMP: \nA = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
self.cc = self.hex.cmp_op(a, m)
string += "(A):(m..m+2)\n"
string += "CC = " + self.cc
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def div(self, m):
a = self.get_a_value()
string = "DIV: \nCP = 24" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.div(a, m)
string += "A <- A / (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def lda(self, m):
string = "LDA: \nm = " + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2) = " + str(m) + "\n"
string += "A <- (m..m+2)"
a = self.reg.adjust_bytes(m, 6, False)
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def j_op(self, m):
string = "J:\nCP<-m\n"
string += "m = " + str(m)
m = self.reg.adjust_bytes(m, 6, False)
m = self.hex.change_hexadecimal(m)
self.set_cp_value(m)
self.window.textEdit_Actions.setText(string)
def jeq(self, m):
string = "JEQ \nCP<-m si CC == '='\n"
string += "m = " + str(m) + "\n"
string += "cc = " + str(self.cc)
m = self.reg.adjust_bytes(m, 6, False)
m = self.hex.change_hexadecimal(m)
if self.cc == "=":
self.set_cp_value(m)
else:
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def jgt(self, m):
string = "JGT \nCP<-m si CC == '>'\n"
string += "m = " + str(m) + "\n"
string += "cc = " + str(self.cc)
m = self.reg.adjust_bytes(m, 6, False)
m = self.hex.change_hexadecimal(m)
if self.cc == ">":
self.set_cp_value(m)
else:
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def jlt(self, m):
string = "JLT \nCP<-m si CC == '<'\n"
string += "m = " + str(m) + "\n"
string += "cc = " + str(self.cc)
m = self.reg.adjust_bytes(m, 6, False)
m = self.hex.change_hexadecimal(m)
if self.cc == "<":
self.set_cp_value(m)
else:
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def jsub(self, m):
string = "JSUB \n L->(CP);CP<-m"
cp = self.get_CP_value()
string += "CP = " + str(cp) + "\n"
cp = self.get_mem_value(cp)
string += "(CP) = " + str(cp) + "\n"
self.set_l_value(cp)
self.set_cp_value(m)
self.window.textEdit_Actions.setText(string)
def ldch(self, m):
string = "LDCH\nA[+der]<-(m)\n"
string += "m = " + str(m) + "\n"
m = self.get_mem_value(m)
m = m[0:2]
a = self.get_a_value()
string += "(m) = " + str(m) + "\n"
string += "A = " + str(a) + "\n"
a = self.reg.filter_number(a)
a = a[0:-2] + m
string += "A[+der]<-(m)\n"
string += "A = " + str(a)
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def ldl(self, m):
string = "LDL\nL<-(m..m+2)"
string += "m = " + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2) =" + str(m)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
self.set_l_value(m)
def ldx(self, m):
string = "LDX\nX<-(m..m+2)"
string += "m = " + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2) =" + str(m)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
self.set_x_value(m)
def mul(self, m):
a = self.get_a_value()
string = "MUL: \nCP = 20" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.mul(a, m)
string += "A <- A * (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def or_op(self, m):
a = self.get_a_value()
string = "OR: \nCP = 44" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.or_op(a, m)
string += "A <- A | (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def rsub(self, m):
string = "RSUB\nPC<-(L)"
l = self.get_l_value()
string += "L=" + str(l) + "\n"
l = self.get_mem_value(l)
string += "(L)=" + str(l) + "\n"
self.set_cp_value(l)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def sta(self, m):
string = "STA\nm..m+2<-(A)\nm=" + str(m) + "\n"
it = 0
row = self.get_row_index(m)
col = self.get_column_index(m)
a = self.get_a_value()
string += "(A)=" + str(a)
index = 0
while it < 3:
val = a[index : index + 2]
index += 2
item_text = QtGui.QTableWidgetItem(val)
self.window.tableWidget.setItem(row, col, item_text)
col = (col + 1) % 17
if col == 0:
col = 1
row += 1
it += 1
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def stch(self, m):
string = "STCH\nm<-(A)[+der]\nm=" + str(m) + "\n"
row = self.get_row_index(m)
col = self.get_column_index(m)
print row, col, m
a = self.get_a_value()
a = self.reg.filter_number(a)
a_der = str(a)[-2:]
string += "(A)[+der]=" + a_der
item = QtGui.QTableWidgetItem(a_der)
self.window.tableWidget.setItem(row, col, item)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def stl(self, m):
string = "STL\nm..m+2<-(L)\nm=" + str(m) + "\n"
it = 0
row = self.get_row_index(m)
col = self.get_column_index(m)
l = self.get_l_value()
string += "(l)=" + str(l)
index = 0
while it < 3:
val = l[index : index + 2]
index += 2
item_text = QtGui.QTableWidgetItem(val)
self.window.tableWidget.setItem(row, col, item_text)
col = (col + 1) % 17
if col == 0:
col = 1
row += 1
it += 1
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def stsw(self, m):
string = "STSW\nm..m+2<-(SW)\nm=" + str(m) + "\n"
it = 0
row = self.get_row_index(m)
col = self.get_column_index(m)
sw = self.get_sw_value()
string += "(SW)=" + str(sw)
index = 0
while it < 3:
val = sw[index : index + 2]
index += 2
item_text = QtGui.QTableWidgetItem(val)
self.window.tableWidget.setItem(row, col, item_text)
col = (col + 1) % 17
if col == 0:
col = 1
row += 1
it += 1
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def stx(self, m):
string = "STSX\nm..m+2<-(X)\nm=" + str(m) + "\n"
it = 0
row = self.get_row_index(m)
col = self.get_column_index(m)
x = self.get_x_value()
string += "(X)=" + str(x)
index = 0
while it < 3:
val = x[index : index + 2]
index += 2
item_text = QtGui.QTableWidgetItem(val)
self.window.tableWidget.setItem(row, col, item_text)
col = (col + 1) % 17
if col == 0:
col = 1
row += 1
it += 1
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def sub(self, m):
a = self.get_a_value()
string = "SUB: \nCP = 1C" + str(m) + "\n"
string += "A = " + str(a) + "\n"
string += "m =" + str(m) + "\n"
m = self.get_mem_value(m)
string += "(m..m+2)=" + str(m) + "\n"
a = self.hex.subs(a, m)
string += "A <- A - (m...m+2)" + "\n"
a = self.reg.adjust_bytes(a, 6, False)
string += "A = " + str(a) + "\n"
self.set_a_value(a)
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def tix(self, m):
string = "TIX\nX<-(X)+1;(X):(m,,m+2)\n"
x = self.get_x_value()
string += "X =" + str(x) + "+1\n"
x = self.hex.plus(x, "1H")
string += "X =" + str(x) + "\n"
self.set_x_value(x)
m = self.get_mem_value(m)
string += "(m..m+2) +" + str(m) + "\n"
self.cc = self.hex.cmp_op(x, m)
string += "(X):(m..m+2)\nCC=" + self.cc
self.increment_cp(3)
self.window.textEdit_Actions.setText(string)
def increment_cp(self, num):
c = Convert()
num = c.decimal_to_hexadecimal(num)
cp = self.get_CP_value()
cp = self.hex.plus(cp, num)
self.set_cp_value(cp)
def get_address_tarjet(self, value):
c = Convert()
addressing = value[0] + "H"
addressing = int(c.to_decimal(addressing))
val = value
bina = c.decimal_to_binary(addressing, 4)
bina = c.mask_and(bina, "1000")
if bina == "1000":
val = self.hex.subs(value, "8000H")
x = self.get_x_value()
val = self.hex.plus(val, x)
val = self.reg.filter_number(val)
return val
def set_a_value(self, value):
value = self.reg.adjust_bytes(value, 6, False)
value = self.hex.change_hexadecimal(value)
item_text = QtGui.QTableWidgetItem(value)
self.window.tableWidget_2.setItem(1, 0, item_text)
def get_a_value(self):
item = self.window.tableWidget_2.item(1, 0)
return str(item.text())
def get_l_value(self):
item = self.window.tableWidget_2.item(3, 0)
return str(item.text())
def set_l_value(self, value):
value = self.reg.adjust_bytes(value, 6, False)
value = self.hex.change_hexadecimal(value)
item_text = QtGui.QTableWidgetItem(value)
self.window.tableWidget_2.setItem(3, 0, item_text)
def get_x_value(self):
item = self.window.tableWidget_2.item(2, 0)
return str(item.text())
def set_x_value(self, value):
value = self.reg.adjust_bytes(value, 6, False)
value = self.hex.change_hexadecimal(value)
item_text = QtGui.QTableWidgetItem(value)
self.window.tableWidget_2.setItem(2, 0, item_text)
def get_sw_value(self):
item = self.window.tableWidget_2.item(4, 0)
return str(item.text())
def set_sw_value(self, value):
value = self.reg.adjust_bytes(value, 6, False)
value = self.hex.change_hexadecimal(value)
item_text = QtGui.QTableWidgetItem(value)
self.window.tableWidget_2.setItem(4, 0, item_text)
def get_CP_value(self):
item = self.window.tableWidget_2.item(0, 0)
return str(item.text())
def set_cp_value(self, cp):
cp = self.reg.adjust_bytes(cp, 6, False)
cp = self.hex.change_hexadecimal(cp)
item_text = QtGui.QTableWidgetItem(cp)
self.window.tableWidget_2.setItem(0, 0, item_text)
self.get_next_text_instruction()
def get_next_text_instruction(self):
cp = self.get_CP_value()
mem = self.get_mem_value(cp)
cod = mem[0:2]
op = self.operations_text.get(str(cod), "FIN")
self.window.label_sig.setText(op)
def get_row_index(self, value):
index = str(value[0:-1]) + "0"
it = 0
index = self.reg.adjust_bytes(index, 6, False)
num_rows = self.window.tableWidget.rowCount()
while it < num_rows:
val = self.window.tableWidget.item(it, 0)
if str(val.text()) == index:
return it
it += 1
return 0
def get_column_index(self, value):
c = Convert()
index = str(value[-1]) + "H"
index = c.to_decimal(index)
del c
return index + 1
def get_instruct(self):
cp = self.get_CP_value()
return self.get_mem_value(cp)
def get_mem_value(self, value):
value = self.reg.filter_number(str(value))
col = self.get_column_index(value)
row = self.get_row_index(value)
register = ""
it = col
cont = 0
while cont < 3:
item = self.window.tableWidget.item(row, it)
register += str(item.text())
it = (it + 1) % 17
if it == 0:
it = 1
row += 1
cont += 1
return register
def get_count_next_actions(self):
count_actions = str(self.window.textEdit_Num.toPlainText())
if count_actions == "":
count_actions = 1
elif not count_actions.isdigit():
return -1
return int(count_actions)
def get_list_register(self):
f = open(self.file_name)
text = f.read()
list = text.split("\n")
list.remove("")
return list
def load_file_name(self, file_name):
self.file_name = file_name + ".os"
list = self.get_list_register()
self.header = list[0]
self.end = list[-1]
self.registers = list[1:-1]
self.charge_in_memory()
def charge_text(self):
c = Convert()
for r in self.registers:
string = r[9:]
index = 0
init = r[1:7]
col_start = init[-1] + "H"
col = int(c.to_decimal(col_start) + 1)
res = self.hex.subs(init[:-1], self.init[:-1])
dec_res = int(c.to_decimal(res))
while index < len(string):
byte = string[index : index + 2]
item = QtGui.QTableWidgetItem(byte)
self.window.tableWidget.setItem(dec_res, col, item)
index += 2
col = (col + 1) % 17
if col == 0:
col = 1
dec_res += 1
def charge_header(self):
init = self.header[7:13]
self.init = init
length = self.header[13:]
self.end_program = self.hex.plus(init, length)
star_rows = length[:-1]
index = init[:-1]
num_rows = star_rows + "H"
c = Convert()
num_rows = int(c.to_decimal(num_rows))
self.window.tableWidget.setRowCount(num_rows + 1)
it = 0
while it <= num_rows:
dir = index + "0H"
r = Register("T")
dir = r.adjust_bytes(dir, 6, False)
item = QtGui.QTableWidgetItem(dir)
self.window.tableWidget.setItem(it, 0, item)
it += 1
index = self.hex.plus(index, "1H")[:-1]
def charge_end_file(self):
dir = self.end[1:]
dir = self.reg.adjust_bytes(dir, 6, False)
dir = self.hex.change_hexadecimal(dir)
item = QtGui.QTableWidgetItem(dir)
self.window.tableWidget_2.setItem(0, 0, item)
self.get_next_text_instruction()
it = 1
while it < 5:
item = QtGui.QTableWidgetItem("FFFFFFH")
self.window.tableWidget_2.setItem(it, 0, item)
it += 1
def charge_in_memory(self):
self.charge_header()
self.charge_text()
self.charge_end_file()
self.init_empty_rows()
def init_empty_rows(self):
rows_count = self.window.tableWidget.rowCount()
colum_count = self.window.tableWidget.columnCount()
for i in range(rows_count):
for j in range(colum_count):
item = self.window.tableWidget.item(i, j)
if item == None:
item_text = QtGui.QTableWidgetItem("FF")
self.window.tableWidget.setItem(i, j, item_text)
def test_math_ops():
grade = 0
try:
two = Hexadecimal(2)
ten = Hexadecimal(10)
zero = Hexadecimal(0)
five = Hexadecimal(5)
fifteen = Hexadecimal(15)
fifty = Hexadecimal(50)
#Add
try:
total = ten + zero
if str(total) == str(ten):
grade += 3
else:
print("Overloaded + not working correctly.")
total = ten + five
if str(total) == str(fifteen):
grade += 2
else:
print("Overloaded + not working correctly.")
except Exception as ex:
print("Crashed when trying to add Hexadecimal objects.")
#Subtract
try:
difference = fifteen - five
if str(difference) == str(ten):
grade += 3
else:
print("Overloaded - not working correctly.")
except Exception as ex:
print("Crashed when trying to subtract Hexadecimal objects.")
try:
difference = ten - fifteen
except Exception as ex:
grade += 2
else:
print(
"Your class stored a negative in an object as the result of subtracting."
)
print("It should have raised an exception and didn't.")
#Multiply
try:
product = five * ten
if str(product) == str(fifty):
grade += 2
else:
print("Overloaded * not working correctly.")
product = five * zero
if str(product) == str(zero):
grade += 1
else:
print("Overloaded * not working correctly.")
except Exception as ex:
print("Crashed when trying to multiply Hexadecimal objects.")
#Divide
try:
quotient = fifty / five
if str(quotient) == str(ten):
grade += 2
else:
print("Overloaded / not working correctly.")
except Exception as ex:
print("Crashed when trying to divide Hexadecimal objects.")
try:
quotient = fifty / zero
except Exception as ex:
grade += 1
else:
print(
"Should have raised an exception when trying to divide by zero."
)
#Power
try:
answer = five**two
if str(answer) == str(Hexadecimal(25)):
grade += 2
else:
print("Overloaded ** not working correctly.")
except Exception as ex:
print("Crashed when trying to raise a hexadecimal to a power")
#Mod
try:
answer = ten % five
if str(answer) == str(zero):
grade += 1
else:
print("Overloaded % not working correctly.")
except Exception as ex:
print("Crashed when trying to calculate remainder.")
try:
answer = ten % zero
except Exception as ex:
grade += 1
else:
print(
"Should have raised an exception when trying to divide by zero -- which is used with % operations."
)
except Exception as ex:
print("Crashed when testing math operations.")
return grade
