本文整理汇总了Python中register.Register.adjust_bytes方法的典型用法代码示例。如果您正苦于以下问题:Python Register.adjust_bytes方法的具体用法?Python Register.adjust_bytes怎么用?Python Register.adjust_bytes使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类register.Register
的用法示例。
在下文中一共展示了Register.adjust_bytes方法的9个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: directive_word
# 需要导入模块: from register import Register [as 别名]
# 或者: from register.Register import adjust_bytes [as 别名]
def directive_word(self,value):
c = Convert()
if not c.is_hexadecimal(value):
value = int(float(value))
value = c.decimal_to_hexadecimal(value)
r = Register("T")
value = r.adjust_bytes(value,6,True)
value = r.filter_number(value)
del r
return value
示例2: make_register_d
# 需要导入模块: from register import Register [as 别名]
# 或者: from register.Register import adjust_bytes [as 别名]
def make_register_d(self,list_sym,tab_sym):
r =Register("X")
reg = "D"
for it in list_sym:
if len(reg) + 12 > 73:
self.list_registers_d.append(reg)
reg = "D"
item = self.exist_item(it,tab_sym)
name = r.adjust_name(it)
if item:
dir = r.adjust_bytes(item.get_dir_val(),6,False)
else:
dir = "FFFFFF"
reg+= (name+dir)
if not len(reg) == 1:
self.list_registers_d.append(reg)
示例3: charge_header
# 需要导入模块: from register import Register [as 别名]
# 或者: from register.Register import adjust_bytes [as 别名]
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]
示例4: operations_code
# 需要导入模块: from register import Register [as 别名]
# 或者: from register.Register import adjust_bytes [as 别名]
def operations_code(self,operator,m,is_index):
r = Register("T")
c = Convert()
op = self.operations[operator]
op = op+"H"
op = c.to_decimal(op)
op = int(op)
binary = c.decimal_to_binary(op,24)
binary = c.shift_binary_left(binary,16)
if is_index:
binary = c.mask_or(binary,"000000001000000000000000")
m = c.to_decimal(m)
m = int(m)
m = c.decimal_to_binary(m,24)
binary = c.mask_or(binary,m)
val = int(binary,2)
val = c.decimal_to_hexadecimal(val)
val = r.filter_number(val)
val = r.adjust_bytes(val,6,False)
del r
del c
return val
示例5: __init__
# 需要导入模块: from register import Register [as 别名]
# 或者: from register.Register import adjust_bytes [as 别名]
class Step2:
##constructor de la clase se inicializan los codigos de operacion
def __init__(self):
self.operations = {
'ADD':'18','ADDF':'58','ADDR':'90','AND':'40','CLEAR':'B4','COMP':'28',
'COMPF':'88','DIV':'24','COMPR':'A0','DIVF':'64','DIVR':'9C','FIX':'C4',
'FLOAT':'C0','HIO':'F4','J':'3C','JEQ':'30','JGT':'34','JLT':'38',
'JSUB':'48','LDA':'00','LDB':'68','LDCH':'50','LDF':'70','LDL':'08','LDS':'6C',
'LDT':'74','LDX':'04','LPS':'D0','MUL':'20','MULF':'60','MULR':'98','NORM':'C8',
'OR':'44','RD':'D8','RMO':'AC','RSUB':'4C','SHIFTL':'A4','SHIFTR':'A8','SIO':'F0',
'SSK':'EC','STA':'0C','STB':'78','STCH':'54','STF':'80','STI':'D4',
'STL':'14','STS':'7C','STSW':'E8','STT':'84','STX':'10',
'SUB':'1C','SUBF':'5C','SUBR':'94','SVC':'B0','TD':'E0','TIO':'F8','TIX':'2C',
'TIXR':'B8','WD':'DC'
}
self.d = Displacement()
self.list_registers_h = []
self.list_registers = []
self.list_registers_m = []
self.list_registers_r = []
self.list_registers_e = []
self.current_register = Register("T")
self.registers = {"A":"0","X":"1","L":"2","CP":"8","SW":"9","B":"3","S":"4","T":"5","F":"6"}
self.base = "1038H"
self.m_register = []
self.m_modif_register = []
self.h_name = ""
self.list_registers_d = []
self.list_word_m = []
self.list_op_m = []
## inserta una cadena de bytes en el registro T actual si no cabe genera
#otro registro nuevo para almacenar los datos
# @param str cadena que contiene la serie de bytes
# @param dir direccion donde se encontro la instruccion
def insert_str(self,str,dir):
if self.current_register.get_len() == 0:
self.current_register.init_dir = dir
self.current_register.instert_string(str)
print "nuevo",str,dir
else:
if self.current_register.fits_in(str):
self.current_register.instert_string(str)
print "agrega",str,dir
else:
self.complete_register()
self.insert_str(str,dir)
## termina el registro actual T y genera uno nuevo
def complete_register(self):
if not self.current_register.get_len()==0:
register_t = self.current_register.make_T()
self.list_registers.append(register_t)
self.current_register = Register("T")
## regresa el registro m de los elementos externos que se
# encontraron en un codigo de expresion
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
## elimina los registros m repetidos en una lista especificada
# este metodo elimina los registros relativos con signo contrario y que se encuentran
#en la misma direccion
def elimina_repetidos(self,list_r):
it = 0
re = 0
while it < len(list_r):
re = it + 1
eliminado = False
while re < len(list_r) and not eliminado:
if list_r[it][3] == list_r[re][3]:#direccion
if not list_r[it][2] == list_r[re][2]:#signos
if list_r[it][1] == "_" and list_r[re][1] == "_":
if list_r[it][0] == list_r[re][0]:#nombre
eliminado = True
elif list_r[it][1] == "relativo" and list_r[re][1] == "relativo":
eliminado = True
if not eliminado:
re += 1
if eliminado:
list_r.remove(list_r[re])
list_r.remove(list_r[it])
else:
it += 1
## regresa el registro m de los elementos externos que se
# encontraron en una directiva word
#.........这里部分代码省略.........
示例6: Cargadorx
# 需要导入模块: from register import Register [as 别名]
# 或者: from register.Register import adjust_bytes [as 别名]
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)
#.........这里部分代码省略.........
示例7: Simuladorx
# 需要导入模块: from register import Register [as 别名]
# 或者: from register.Register import adjust_bytes [as 别名]
#.........这里部分代码省略.........
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):
示例8: Cargador
# 需要导入模块: from register import Register [as 别名]
# 或者: from register.Register import adjust_bytes [as 别名]
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)
#.........这里部分代码省略.........
示例9: __init__
# 需要导入模块: from register import Register [as 别名]
# 或者: from register.Register import adjust_bytes [as 别名]
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