Python Register.adjust_bytes方法代码示例

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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]

# 需要导入模块: 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

# 需要导入模块: 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  
#.........这里部分代码省略.........

# 需要导入模块: 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)

#.........这里部分代码省略.........

# 需要导入模块: 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):

# 需要导入模块: 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)
#.........这里部分代码省略.........

# 需要导入模块: 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