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
def operation_type_3_4(self,cp,operator,arg,format_type,num_line,dir_type,type_c,is_index,valid_label):
c = Convert()
operator = self.get_binary_code(operator)
flags = self.get_flags(dir_type)
num_max = 3
res = arg
entra = True
if format_type == 4:
flags['e']=1
num_max=5
if not type_c and valid_label == "relativo":
self.m_register.append(num_line)
res = self.current_register.adjust_bytes(arg,num_max,True)
else:
if type_c:
if not self.is_type_c(arg):
entra = True
else:
entra = False
if not c.is_hexadecimal(arg):
arg = c.decimal_to_hexadecimal(arg)
res = self.current_register.adjust_bytes(arg,3,True)
if entra:
res = self.is_relative_cp(cp,arg)
if not res:
res = self.relative_base(arg)
if res:
flags['b'] = 1
else:
res = arg
valid_label = False
else:
flags['p'] = 1
res = self.current_register.adjust_bytes(res,num_max,True)
if is_index:
flags['x'] = 1
if not valid_label:
flags['b'] = 1
flags['p'] = 1
if valid_label == "_":
flags['b'] = 0
flags['p'] = 0
flags = self.flags_string(flags)
val = operator + flags
val = str(int(val,2))
val = c.decimal_to_hexadecimal(val)
if len(val)==3:
val = "0"+val
val = self.current_register.adjust_bytes(val,3,True)
val += str(res)
del c
return val
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
