def __init__(self):
self.lista_Tokens = list()
self.lista_error = list()
self.linea = 1
self.columna = 1
self.lexema = ""
self._reporte = Report()
self.newEntrada = ""
def __init__(self):
self.listado_tokens = list()
self.pila = list()
self.pop_pila = ''
self.entrada = ''
self.lista_Token = list()
self.estado = ''
self.cadena = ''
self.ireport = Report()
def __init__(self):
self.lista_Tokens = list()
self.lista_error = list()
self.linea = 1
self.columna = 1
self.lexema = ""
self.recorrido_automata = {}
self._reporte = Report()
self.now = datetime.now()
self.bitacora = ""
def __init__(self):
self.lista_token = list()
self.lista_error = list()
self.pos_error = {}
self.lexema = ""
self.linea = 1
self.columan = 1
self.contador = 1
self.cont_Comentario = 1
self.cont_ComentarioAS = 1
self.recorrido_automata = dict()
self.newEntrada = ""
self._reporte = Report()
class Anality_CSS():
lista_Tokens = list()
lista_error = list()
linea = 1
columna = 1
lexema = ""
recorrido_automata = {}
_reporte = Report()
bitacora = ""
now = datetime.now()
def __init__(self):
self.lista_Tokens = list()
self.lista_error = list()
self.linea = 1
self.columna = 1
self.lexema = ""
self.recorrido_automata = {}
self._reporte = Report()
self.now = datetime.now()
self.bitacora = ""
def read_caracter(self, texto):
self.bitacora = f"---------->Bitacora CSS <---------- [{self.getTime()}] \n"
self.entrada = texto + '$'
self.caracterActual = ''
self.newEntrada = texto
x = 0
while x < len(self.entrada):
self.caracterActual = self.entrada[x]
#print(self.caracterActual)
# qo -> q1(simbolos del lenguje)
if self.caracterActual == '{':
self.add_tokken(TipoCSS.LLABRE, '{', "")
elif self.caracterActual == '}':
self.add_tokken(TipoCSS.LLCIER, '}', "")
elif self.caracterActual == '(':
self.add_tokken(TipoCSS.PABRE, '(', "")
elif self.caracterActual == ')':
self.add_tokken(TipoCSS.PCIER, ')', "")
elif self.caracterActual == '"':
self.add_tokken(TipoCSS.COMIDOBLE, '"', "")
elif self.caracterActual == ',':
self.add_tokken(TipoCSS.COMA, ',', "")
elif self.caracterActual == ':':
self.add_tokken(TipoCSS.DPUNTOS, ':', "")
elif self.caracterActual == ';':
self.add_tokken(TipoCSS.PCOMA, ';', "")
elif self.caracterActual.isnumeric():
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q0 -> q2;{self.caracterActual}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
size_lexema = self.get_size_lexema_asterisco(x)
self.q2(x, x + size_lexema)
x = x + size_lexema
elif self.caracterActual.isalpha():
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q0 -> q4;{self.caracterActual}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
size_lexema = self.get_size_lexema_asterisco(x)
self.q4(x, x + size_lexema)
x = x + size_lexema
elif self.caracterActual == '/' and self.entrada[x + 1] == '*':
size_lexema = self.get_size_lexema_comentario(x)
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q0 - q7 ;{self.caracterActual}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q0 -> q8 ;{self.entrada[x + 1]}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
if (x + size_lexema + 2 <= len(self.entrada)):
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q8 -> q6 ;{self.entrada[x + 2]}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
self.q6(x, x + size_lexema + 2)
x = x + size_lexema + 2 # PENDIENTE DE REVISAR URGE PORNER MAS size_lexema +2
else:
self.q6(x, x + size_lexema)
x = x + size_lexema
self.add_error(x, self.linea, self.columna, '*/')
break
elif self.caracterActual == '#' or self.caracterActual == '.':
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q0 -> q4;{self.caracterActual}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-----------------------------------------------------------------------------
size_lexema = self.get_size_lexema_asterisco(x)
self.q4(x, x + size_lexema)
x = x + size_lexema
elif self.caracterActual == '-':
size_lexema = self.get_size_lexema_asterisco(x)
self.q2(x, x + size_lexema)
x = x + size_lexema
#elif self.caracterActual == "\n":
#print("Salto de linea")
elif self.caracterActual == "\n" or self.caracterActual == " " or self.caracterActual == "\t" or self.caracterActual == "\t":
if self.caracterActual == "\n":
self.linea += 1
self.columna = 1
#print("Salto de linea principal")
x += 1
self.columna += 1
continue
else:
if self.caracterActual == "$" and x == len(self.entrada) - 1:
print("Analicis Terminado")
else:
self.add_error(x, self.linea, self.columna,
self.caracterActual)
x += 1
self.columna += 1
#print(self.bitacora)
#return self.lista_error
return self.bitacora
# ----------------->ESTADO Q2 <--------------------------------------
# Numero
def q2(self, actual, fin):
c = ''
inicio = actual
while actual < fin:
c = self.entrada[actual]
# q2 -> q2 con numero (numero)
if c.isnumeric():
self.lexema += c
#transicion = f"{c},q2"
#self.add_diccionario('q2',transicion)
_trasBitacora = f"[q2 -> q2;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
if (actual + 1 == fin):
self.add_tokken(TipoCSS.VALOR, self.lexema, "blue")
_trasBitacora = f"[Acepatado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
# q2 -> q2 con % (%)
elif c == '%':
self.lexema += c
#transicion = f"{c},q7"
#self.add_diccionario('q2',transicion)
_trasBitacora = f"[q2 -> q2;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
if (actual + 1 == fin):
self.add_tokken(TipoCSS.VALOR, self.lexema, "blue")
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
# q2 -> q2 con . (.)
elif c == '.':
self.lexema += c
#transicion = f"{c},q2"
#self.add_diccionario('q2',transicion)
_trasBitacora = f"[q2 -> q2;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
if (actual + 1 == fin):
self.add_tokken(TipoCSS.VALOR, self.lexema, "blue")
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
elif c == '-' and actual == inicio:
self.lexema += c
_trasBitacora = f"[q2 -> q2;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#transicion = f"{c},q2"
#self.add_diccionario('q2',transicion)
# q2 -> q3 con letra (letra)
elif c.isalpha():
#transicion = f"{c},q3"
#self.add_diccionario('q2',transicion)
_trasBitacora = f"[q2 -> q3;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
self.q3(actual, fin)
break
else:
#Caracter No Reconocido
self.add_error(actual, self.linea, self.columna, c)
actual += 1
self.columna += 1
# ----------------->ESTADO Q3 <--------------------------------------
# Letra
def q3(self, actual, fin):
c = ''
while actual < fin:
c = self.entrada[actual]
# q3 -> q3 con letra (letra)
if c.isalpha():
self.lexema += c
_trasBitacora = f"[q3 -> q3;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
if (actual + 1 == fin):
self.add_tokken(TipoCSS.VALOR, self.lexema, "blue")
_trasBitacora = f"[Acepatado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
else:
#Caracter No Reconocido
self.add_error(actual, self.linea, self.columna, c)
actual += 1
self.columna += 1
# ----------------->ESTADO Q6 <--------------------------------------
# Comentario
def q6(self, actual, fin):
c = ''
while actual < fin:
c = self.entrada[actual]
self.lexema += c
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q6 -> q6 ;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
if (actual + 1 == fin):
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
self.add_tokken(TipoCSS.COMENTARIO, self.lexema, "gray")
self.columna += 1
actual += 1
# ----------------->Estado Q4 <--------------------------------------
# Reservadas
def q4(self, actual, fin):
self.lexema = self.get_lexema(actual, fin)
if self.lexema == "color":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.COLOR, 'color', 'red')
return
elif self.lexema == "border":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.BORDER, "border", "red")
return
elif self.lexema == "text-align":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.TEXT_ALIGN, "text-align", "red")
return
elif self.lexema == "font-weight":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.FONT_WEIGHT, "font-weight", "red")
return
elif self.lexema == "padding-left":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.PADDING_LEFT, "padding-left", "red")
return
elif self.lexema == "padding-top":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.PADDING_TOP, "padding-top", "red")
return
elif self.lexema == "line-height":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.LINE_HEIGHT, "line-height", "red")
return
elif self.lexema == "margin-top":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.MARGIN_TOP, "margin-top", "red")
return
elif self.lexema == "margin-left":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.MARGIN_LEFT, "margin-left", "red")
return
elif self.lexema == "display":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.DISPLAY, "display", "red")
return
elif self.lexema == "top":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.TOP, "top", "red")
return
elif self.lexema == "float":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.FLOAT, "float", "red")
return
elif self.lexema == "min-width":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.MIN_WIDTH, "min-width", "red")
return
elif self.lexema == "background-color":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.BACKGROUND_COLOR, "background-color",
"red")
return
elif self.lexema == "background":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.BACKGROUND, "background", "red")
return
elif self.lexema == "font-family":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.FONT_FAMILY, "font-family", "red")
return
elif self.lexema == "font-size":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.FONT_SIZE, "font-size", "red")
return
elif self.lexema == "padding-right":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.PADDING_RIGHT, "padding-right", "red")
return
elif self.lexema == "padding":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.PADDING, "padding", "red")
return
elif self.lexema == "width":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.WIDTH, "width", "red")
return
elif self.lexema == "margin-right":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.MARGIN_RIGHT, "margin-right", "red")
return
elif self.lexema == "margin":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.MARGIN, "margin", "red")
return
elif self.lexema == "bottom":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.BOTTOM, "bottom", "red")
return
elif self.lexema == "right":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.RIGHT, "right", "red")
return
elif self.lexema == "clear":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.CLEAR, "clear", "red")
return
elif self.lexema == "max-height":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.MAX_HEIGHT, "max-height", "red")
return
elif self.lexema == "background-image":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.BACKGROUND_IMAGE, "background-image",
"red")
return
elif self.lexema == "font-style":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.FONT_STYLE, "font-style", "red")
return
elif self.lexema == "font":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.FONT, "font", "red")
return
elif self.lexema == "padding-bottom":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.PADDING_BOTTOM, "padding-bottom", "red")
return
elif self.lexema == "margin-bottom":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.MARGIN_BOTTOM, "margin-bottom", "red")
return
elif self.lexema == "border-style":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.BORDER_STYLE, "border-style", "red")
return
elif self.lexema == "position":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.POSITION, "position", "red")
return
elif self.lexema == "left":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.LEFT, "left", "red")
return
elif self.lexema == "max-width":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.MAX_WIDTH, "max-width", "red")
return
elif self.lexema == "min-height":
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#--------------------------------------------------------------------------
self.add_tokken(TipoCSS.MIN_HEIGHT, "min-height", "red")
return
self.lexema = ""
c = ''
while actual < fin:
c = self.entrada[actual]
# q4 -> q5 (letra | numero)
if c == '#':
self.lexema += c
#-------------------Agregar bitacora-----------------------------------------------
_trasBitacora = f"[q4 -> q5;{self.entrada[actual + 1]}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#----------------------------------------------------------------------------------
self.q5(actual + 1, fin)
break
# q4 -> q5 (letra | numero)
elif c == '.':
self.lexema += c
#-------------------Agregar bitacora---------------------------------------------------
_trasBitacora = f"[q4 -> q5;{self.entrada[actual + 1]}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#------------------------------------------------------------------------------------
self.q5(actual + 1, fin)
break
# q4 -> q5 (letra | numero)
elif c.isalpha():
self.q5(actual, fin)
break
else:
self.add_error(actual, self.linea, self.columna, c)
actual += 1
self.columna += 1
# terminar de componer
#
#
# --------------------------> <--------------------------------------
# ----------------->ESTADO Q5 <--------------------------------------
def q5(self, actual, fin):
c = ''
while actual < fin:
c = self.entrada[actual]
# q5 -> q5 (letra)
if c.isalpha():
self.lexema += c
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q5 -> q5;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#----------------------------------------------------------------------------
if (actual + 1 == fin):
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
self.add_tokken(TipoCSS.ID, self.lexema, "green")
elif c.isnumeric():
self.lexema += c
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q5 -> q5;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-----------------------------------------------------------------------
if (actual + 1 == fin):
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
self.add_tokken(TipoCSS.ID, self.lexema, "green")
elif c == '-':
self.lexema += c
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q5 -> q5 ;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
if (actual + 1 == fin):
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
self.add_tokken(TipoCSS.ID, self.lexema, "green")
# q5 -> q4 (#)
elif c == '#' or c == '(' or c == ')' or c == '"' or c == '.' or c == '/':
self.lexema += c
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[q5 -> q5 ;{c}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
if (actual + 1 == fin):
#-------------------Agregar bitacora--------------------------------------
_trasBitacora = f"[Aceptado ;{self.lexema}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
#-------------------------------------------------------------------------
self.add_tokken(TipoCSS.ID, self.lexema, "green")
else:
#print(self.linea)
self.add_error(actual, self.linea, self.columna, c)
actual += 1
self.columna += 1
# --------------------------> <--------------------------------------
def get_size_lexema_asterisco(self, incio):
longitud = 0
for j in range(incio, len(self.entrada) - 1):
if self.entrada[j] == "\n":
self.linea += 1
self.columna = 1
#print("Salto de linea get_size_lexema")
if self.entrada[j] == " " or self.entrada[j] == "," or self.entrada[
j] == ';' or self.entrada[j] == ':' or self.entrada[
j] == "\n" or self.entrada[j] == '<' or self.entrada[
j] == '>' or self.entrada[j] == '{' or self.entrada[
j] == '}' or self.entrada[
j] == "\t" or self.entrada == "\r":
break
longitud += 1
return longitud
def get_size_lexema_comentario(self, incio):
longitud = 0
for j in range(incio, len(self.entrada) - 1):
if self.entrada[j] == "\n":
self.linea += 1
self.columna = 1
#print("Salto de linea comentraio")
if self.entrada[j] == "*" and self.entrada[j + 1] == '/':
break
longitud += 1
return longitud
def get_lexema(self, inicio, fin):
palabra = ""
for x in range(inicio, fin):
palabra += self.entrada[x]
_trasBitacora = f"[q4 -> q4 ;{palabra}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
if self.entrada[x] == "\n":
self.linea += 1
self.columna = 1
print("Salto de linea en get_lexema")
self.columna += 1
return palabra.lower()
def add_tokken(self, tipo, valor, color):
nuevo = TokenCSS(tipo, valor, color)
self.lista_Tokens.append(nuevo)
self.caracterActual = ''
self.lexema = ""
def add_error(self, posicion, linea, columna, caracter):
if (caracter == '/' or caracter == '*' or caracter == '{'
or caracter == '}' or caracter == '"' or caracter == ';'
or caracter == ':' or caracter == ',' or caracter == '<'
or caracter == '>' or caracter == '(' or caracter == ')'):
pass
else:
_trasBitacora = f"[NO ACEPTADO ;{caracter}] - [{self.getHora()}] \n"
self.bitacora += _trasBitacora
newError = Error_Lexico(posicion, linea, columna, caracter)
self.lista_error.append(newError)
def imprimirToken(self):
for valor in self.lista_Tokens:
print(
f"Tipo: {valor.getTipoToken()}; Valor: {valor.getValorToken()}"
)
print("--------------------------------------------------------")
def limpiarCarcateres(self):
self.caracterActual = ''
self.lexema = ""
self.entrada = ""
self.linea = 1
self.columna = 1
self.lista_Tokens = list()
self.lista_error = list()
def get_pathComenatrio(self):
ruta = ''
for valor in self.lista_Tokens:
if TipoCSS.COMENTARIO == valor.getTipoToken():
tokenValor = valor.getValorToken()
if (tokenValor.find("PATHW")) != -1:
if (tokenValor.find("c:") != -1):
ruta = tokenValor[tokenValor.find('c:'):tokenValor.
find('*/')].strip()
break
elif (tokenValor.find("C:") != -1):
ruta = tokenValor[tokenValor.find('C:'):tokenValor.
find('*/')].strip()
break
return ruta
def enviarReporte(self, ruta):
#self._reporte.genenarte_Graphivz(self.recorrido_automata)
self._reporte.writeReporte(ruta, self.newEntrada, self.lista_error,
'css')
self.newEntrada = ''
def getTime(self):
time = ""
time = f"{self.getHora()} - {self.now.day}/{self.now.month}/{self.now.year}"
return time
def getBitacora(self):
return self.bitacora
def getHora(self):
time = ""
minuto = self.now.minute
if (minuto <= 9):
minuto = f"0{self.now.minute}"
time = f"{self.now.hour}:{minuto}.{self.now.second} "
else:
time = f"{self.now.hour}:{self.now.minute}.{self.now.second} "
return time
class Analicis():
lista_token = list()
lista_error = list()
pos_error = {}
lexema = ""
linea = 1
columan = 1
contador = 1
cont_Comentario = 1
cont_ComentarioAS = 1
recorrido_automata = dict()
newEntrada = ""
_reporte = Report()
def __init__(self):
self.lista_token = list()
self.lista_error = list()
self.pos_error = {}
self.lexema = ""
self.linea = 1
self.columan = 1
self.contador = 1
self.cont_Comentario = 1
self.cont_ComentarioAS = 1
self.recorrido_automata = dict()
self.newEntrada = ""
self._reporte = Report()
def _incio(self,texto):
self.newEntrada = texto
self.entrada = texto + '$'
self.cacterActual = ''
posicion = 0
while posicion < len(self.entrada):
self.cacterActual = self.entrada[posicion]
#q0 -> q1 por que es simbolo :V
#print(f"Pos{posicion} letra:{self.cacterActual}")
if self.cacterActual == '/' and self.entrada[posicion + 1] == '*':
self.add_token(Tipo.comenPor,'/*',"gray")
sizeLexema = self.get_size_lexemaComentario_mul(posicion)
self.q11(posicion+2,posicion+sizeLexema)
posicion = posicion + sizeLexema
if self.cacterActual == "{":
self.add_token(Tipo.llAbre,"{","")
elif self.cacterActual == "}":
self.add_token(Tipo.llCier,"}","")
elif self.cacterActual == "=":
self.add_token(Tipo.igual,"=","anaranjado")
elif self.cacterActual == '(':
self.add_token(Tipo.paAbre,"(","")
elif self.cacterActual == ")":
self.add_token(Tipo.paCierr,')',"")
elif self.cacterActual == ":":
self.add_token(Tipo.dpuntos,":","")
elif self.cacterActual == ";":
self.add_token(Tipo.pcoma,";","")
elif self.cacterActual == "+":
self.add_token(Tipo.mas, "+","anaranjado")
elif self.cacterActual == "-":
self.add_token(Tipo.menos, "-","anaranjado")
#elif self.cacterActual == "/":
#self.add_token(Tipo.division,"/","white")
elif self.cacterActual == ">":
self.add_token(Tipo.mayor,">","anaranjado")
elif self.cacterActual == "<":
self.add_token(Tipo.menor,"<","anaranjado")
elif self.cacterActual == '"':
self.add_token(Tipo.comiAbre,'"',"yellow")
elif self.cacterActual == '.':
self.add_token(Tipo.punto,'.',"")
elif self.cacterActual == ',':
self.add_token(Tipo.coma,',',"")
elif self.cacterActual == "'":
self.add_token(Tipo.comiSimple,'\'',"yellow")
elif self.cacterActual == '&' and self.entrada[posicion + 1] == '&':
self.add_token(Tipo.conjuncion,"&&" ,"anaranjado")
elif self.cacterActual == '!':
self.add_token(Tipo.negacion,'!' ,"anaranjado")
elif self.cacterActual == '|' and self.entrada[posicion + 1 ] == '|':
self.add_token(Tipo.negacion,'||' ,"anaranjado")
elif self.cacterActual == '*':
self.add_token(Tipo.por,'*',"")
if self.entrada[posicion - 1] == '"' or self.entrada[posicion - 1] == "'" or self.cacterActual == "'" or self.cacterActual == '"' :
#--------------->Graphviz ----------------------------------
if (self.cont_ComentarioAS < 2):
transicion = f"{self.entrada[posicion -1]},q10"
self.add_trancisiones("q0",transicion)
transicion = f"{self.cacterActual},q5"
self.add_trancisiones("q10",transicion)
#--------------------------------------------------
sizeLexema = self.get_size_lexemaEspecial(posicion)
self.q5(posicion,posicion+sizeLexema)
posicion = posicion + sizeLexema
if (self.entrada[posicion] == "\n"):
self.linea += 1
# q0 -> q1 Si es numero
elif self.cacterActual.isnumeric():
sizeLexema = self.get_size_lexema(posicion)
self.q2(posicion,posicion +sizeLexema)
posicion = posicion + sizeLexema
elif self.entrada[posicion - 1] == '/' and self.cacterActual == '/':
#--------------->Graphviz ----------------------------------
if (self.cont_Comentario < 2):
transicion = f"{self.entrada[posicion -1]},q8"
self.add_trancisiones("q0",transicion)
transicion = f"{self.cacterActual},q6"
self.add_trancisiones("q8",transicion)
#--------------------------------------------------
sizeLexema = self.get_size_lexemaComentario_un(posicion)
self.q6(posicion+1,posicion+sizeLexema)
posicion = posicion + sizeLexema
elif self.entrada[posicion - 1] == '/' and self.cacterActual == '*':
sizeLexema = self.get_size_lexemaComentario_mul(posicion)
self.q11(posicion+1,posicion+sizeLexema)
posicion = posicion + sizeLexema
elif self.cacterActual.isalpha():
#--------------->Graphviz ----------------------------------
if (self.contador < 2):
transicion = f"{self.cacterActual},q7"
self.add_trancisiones("q0",transicion)
#--------------------------------------------------
sizeLexema = self.get_size_lexema(posicion)
self.analizador_id_reservada(posicion,posicion + sizeLexema);
posicion = posicion + sizeLexema
elif self.cacterActual == "\n":
self.linea += 1
#print(f" 1 if Salto de linea en :{self.linea}")
else:
if self.cacterActual == "$" and posicion == len(self.entrada) -1:
print("analicis terminado ..")
else:
if self.cacterActual != " " and self.cacterActual != "\n" and self.cacterActual != "\t" and self.cacterActual != "\r":
if (self.cacterActual != '/'):
if(self.cacterActual.isspace() == False and self.is_empty(self.cacterActual) == False):
if(self.cacterActual == '&' and self.entrada[posicion - 1] == '&'):
pass
elif(self.cacterActual == '|' and self.entrada[posicion - 1] == '|'):
pass
else:
#self.pos_error[self.linea] = self.insert_error(posicion,self.cacterActual)
self.add_error(posicion,self.linea,self.columan,self.cacterActual)
#print(posicion)
posicion +=1
#self.imprimir()
return self.lista_error;
#-----> Estado3 (q2) -------------------
def q2(self,actual,fin):
c = ''
while actual < fin:
c = self.entrada[actual]
if c.isnumeric():
self.lexema += c
if(actual + 1 == fin):
self.add_token(Tipo.valor,self.lexema,"blue")
else:
#self.pos_error[self.linea] = self.insert_error(actual,c)
self.add_error(actual,self.linea,self.columan,c)
actual +=1
#-----> Estado3 (q3) -------------------
def q3(self,actual,fin):
c = ''
while actual < fin:
c = self.entrada[actual]
if c.isalpha():
self.lexema += c
if(actual +1 == fin):
self.add_token(Tipo.valor,self.lexema,"blue")
else:
#self.pos_error[self.linea] = self.insert_error(actual,c)
self.add_error(actual,self.linea,self.columan,c)
def analizador_id_reservada(self,actual, fin):
self.lexema = self.get_lexema(actual,fin).lower()
# q0 -> q3
if(self.lexema == "var"):
self.add_token(Tipo._var,"var","red")
return
elif(self.lexema == "for"):
self.add_token(Tipo._for,"for","red")
return
elif(self.lexema == "if"):
self.add_token(Tipo._if,"if","red")
return
elif(self.lexema == "class"):
self.add_token(Tipo._class,"class","red")
return
elif(self.lexema == "else"):
self.add_token(Tipo._else,"else","red")
return
elif(self.lexema == "break"):
self.add_token(Tipo._break,"break","red")
return
elif(self.lexema == "await"):
self.add_token(Tipo._await,"await","red")
return
elif(self.lexema == "case"):
self.add_token(Tipo._case,"case","red")
return
elif(self.lexema == "catch"):
self.add_token(Tipo._catch,"catch","red")
return
elif self.lexema == "const":
self.add_token(Tipo._const,"const","red")
return
elif self.lexema == "continue":
self.add_token(Tipo._const,"continue","red")
return
elif self.lexema == "debugger":
self.add_token(Tipo._debugger,"debugger","red")
return
elif self.lexema == "default":
self.add_token(Tipo._default,"default","red")
return
elif self.lexema == "delete":
self.add_token(Tipo._delete,"delete","red")
return
elif self.lexema == "do":
self.add_token(Tipo._do,"do","red")
return
elif self.lexema == "export":
self.add_token(Tipo._export,"export","red")
return
elif self.lexema == "extends":
self.add_token(Tipo._extends,"extends","red")
return
elif self.lexema == "finally":
self.add_token(Tipo._finally,"finally","red")
return
elif self.lexema == "function":
self.add_token(Tipo._function,"function","red")
return
elif self.lexema == "if":
self.add_token(Tipo._if,"if","red")
return
elif self.lexema == "import":
self.add_token(Tipo._import,"import","red")
return
elif self.lexema == "in":
self.add_token(Tipo._in,"in","red")
return
elif self.lexema == "instanceof":
self.add_token(Tipo._instanceof,"instanceof","red")
return
elif self.lexema == "new":
self.add_token(Tipo._new,"new","red")
return
elif self.lexema == "return":
self.add_token(Tipo._return,"return","red")
return
elif self.lexema == "super":
self.add_token(Tipo._super,"super","red")
return
elif self.lexema == "switch":
self.add_token(Tipo._switch,"switch","red")
return
elif self.lexema == "this":
self.add_token(Tipo._this,"this","red")
return
elif self.lexema == "throw":
self.add_token(Tipo._throw,"this","red")
return
elif self.lexema == "try":
self.add_token(Tipo._try,"try","red")
return
elif self.lexema == "typeof":
self.add_token(Tipo._typeof,"typeof","red")
return
elif self.lexema == "void":
self.add_token(Tipo._void,"void","red")
return
elif self.lexema == "while":
self.add_token(Tipo._while,"while","red")
return
elif self.lexema == "with":
self.add_token(Tipo._with,"with","red")
return
elif self.lexema == "yield":
self.add_token(Tipo._yield,"yield","red")
return
elif self.lexema == "let":
self.add_token(Tipo._let,"let","red")
return
self.lexema = ""
c = ''
while actual < fin:
c = self.entrada[actual]
if c.isalpha():
#--------------->Graphviz ----------------------------------
if (self.contador < 2):
transicion = f"{self.entrada[actual + 1]},q4"
self.add_trancisiones("q7",transicion)
#--------------------------------------------------
self.q4(actual,fin)
break
else:
#self.pos_error[self.linea] = self.insert_error(actual,c)
self.add_error(actual,self.linea,self.columan,c)
actual +=1
def q4(self,actual,fin):
c = ''
while actual < fin:
c = self.entrada[actual]
if c.isalpha():
self.lexema += c
#--------------->Graphviz ----------------------------------
if (self.contador < 2):
transicion = f"{c},q4"
self.add_trancisiones("q4",transicion)
#--------------------------------------------------
if (actual + 1 == fin):
self.add_token(Tipo._id,self.lexema,"green")
self.contador += 1
elif c.isnumeric():
self.lexema += c
#--------------->Graphviz ----------------------------------
if (self.contador < 2):
transicion = f"{c},q4"
self.add_trancisiones("q4",transicion)
#--------------------------------------------------
if (actual + 1 == fin):
self.add_token(Tipo._id,self.lexema,"green")
self.contador += 1
elif c == "_":
self.lexema +=c
#--------------->Graphviz ----------------------------------
if (self.contador < 2):
transicion = f"{c},q4"
self.add_trancisiones("q4",transicion)
#--------------------------------------------------
if(actual + 1 == fin):
self.add_token(Tipo._id,self.lexema,"green")
self.contador += 1
else:
#self.pos_error[self.linea] = self.insert_error(actual,c)
#print(f"Error lexico :C :{c} in line:{self.linea}")
self.add_error(actual,self.linea,self.columan,c)
actual += 1
def q5(self,actual,fin):
c = ''
fin = fin - 1
while actual < fin:
c = self.entrada[actual]
self.lexema += c
#--------------->Graphviz ----------------------------------
if (self.cont_ComentarioAS < 2):
transicion = f"{c},q5"
self.add_trancisiones("q5",transicion)
#--------------------------------------------------
if(actual + 1 == fin):
self.add_token(Tipo.valor,self.lexema,"yellow")
self.cont_ComentarioAS += 1
actual +=1
def q6(self,actual,fin):
c = ''
while actual < fin:
c = self.entrada[actual]
self.lexema += c
#--------------->Graphviz ----------------------------------
if (self.cont_Comentario < 2):
transicion = f"{c},q6"
self.add_trancisiones("q6",transicion)
#--------------------------------------------------
if(actual + 1 == fin):
self.add_token(Tipo.comentario,self.lexema,"gray")
self.cont_Comentario += 1
actual +=1
def q11(self,actual,fin):
c = ''
while actual < fin:
c = self.entrada[actual]
self.lexema += c
if(actual + 1 == fin):
self.add_token(Tipo.comentario,self.lexema,"gray")
actual +=1
def get_lexema(self,actual,fin):
return (self.entrada[actual:fin])
def add_token(self,tipo,valor,color):
new = Token(tipo,valor,color)
self.lista_token.append(new)
self.cacterActual = ""
self.estado = 0
self.lexema = ""
def imprimir(self):
for valor in self.lista_token:
print(f"Tipo:{valor.getTipoToken()}, Valor:{valor.getValorToken()}")
print("--------------")
def get_size_lexema(self, posInicial):
longitud = 0
for i in range(posInicial,len(self.entrada) -1 ):
#if self.entrada[i] == "(" or self.entrada[i] == ")" or self.entrada[i] == " " or self.entrada[i] == "{" or self.entrada[i] == "}" or self.entrada[i] == "," or self.entrada[i] == ";" or self.entrada[i] == ":" or self.entrada[i] == "\n" or self.entrada[i] == "\t" or self.entrada[i] == "\r" or self.entrada[i] == "=" or self.entrada[i] == '"' or self.entrada[i] == "//" or self.entrada[i] == "/*" or self.entrada[i] == "*/":
if self.entrada[i] == '/' or self.entrada[i] == "," or self.entrada[i] == "(" or self.entrada[i] == ")" or self.entrada[i] == " " or self.entrada[i] == "{" or self.entrada[i] == "}" or self.entrada[i] == "," or self.entrada[i] == ";" or self.entrada[i] == ":" or self.entrada[i] == "\n" or self.entrada[i] == "\t" or self.entrada[i] == "\r" or self.entrada[i] == "=" or self.entrada[i] == "//" or self.entrada[i] == "/*" or self.entrada[i] == "*/" or self.entrada[i] == '.':
if self.entrada[i] == "\n":
self.linea +=1
self.columan = 1
#print(f" size_lexema if Salto de linea en :{self.linea}")
break
longitud +=1
return longitud
# devuelve la longitul del lexima si esta en "sdf dfad"
def get_size_lexemaEspecial(self,inicial):
longitud = 0
for i in range(inicial,len(self.entrada) -1 ):
if self.entrada[i] == "\n":
self.linea +=1
#print(f" size_lexema_Especial if Salto de linea en :{self.linea}")
if self.entrada[i] == '"' or self.entrada[i] == "'":
break
longitud +=1
return longitud+1
# devuelve la longitul del lexema si esta en un --> comentario uniliniea
def get_size_lexemaComentario_un(self,inicial):
longitud = 0
for i in range(inicial,len(self.entrada) -1 ):
if self.entrada[i] == "\n":
self.linea += 1
#print(f" size_lexema_COmentarioUni if Salto de linea en :{self.linea}")
break
longitud +=1
return longitud
# devuelve la longitul del lexema si esta en un --> comentario multilinea
def get_size_lexemaComentario_mul(self,inicial):
longitud = 0
for i in range(inicial,len(self.entrada) -1 ):
if self.entrada[i] == "\n":
self.linea +=1
#print(f" size_lexema_COmentarioMulti if Salto de linea en :{self.linea}")
if self.entrada[i] == '*' and self.entrada[i + 1] == '/':
break
longitud +=1
return longitud
def insert_error(self,poscion,letra):
listaError = self.getListError(self.linea)
if listaError == None:
listaError = list()
listaError.append(letra)
else:
listaError.append(letra)
return listaError;
def getListError(self,clave):
for key,value in self.pos_error.items():
if clave == key:
return value
return None
def getListTokens(self):
listaClonada = []
listaClonada = self.lista_token;
return listaClonada;
def is_empty(self,data_structure):
if data_structure:
#print("No está vacía")
return False
else:
#print("Está vacía")
return True
#limpia las variables globales para otra ejecucion
def clear_data(self):
self.cacterActual = ""
self.estado = 0
self.lexema = ""
self.entrada = ""
self.linea = 1
self.columan = 1
self.lista_token = list()
self.lista_error = list()
self.pos_error = {}
# ----> Metodos de agregar estados y transiciones al diccionario para graphviz
def add_trancisiones(self,clave,transicion):
lista_Trancision = self.get_listInDiccionario(clave)
if lista_Trancision == None:
lista_Trancision = list()
lista_Trancision.append(transicion)
else:
lista_Trancision.append(transicion)
self.recorrido_automata[clave] = lista_Trancision
def get_listInDiccionario(self,clave):
for key,value in self.recorrido_automata.items():
if key == clave:
return value
return None
def add_error(self,posicion,linea,columna,caracter):
newError = Error_Lexico(posicion,linea,columna,caracter)
self.lista_error.append(newError)
def get_pathComentario(self):
ruta = ''
for valor in self.lista_token:
if Tipo.comentario == valor.getTipoToken():
tokenValor = valor.getValorToken()
if(tokenValor.find("PATHW")) != -1:
if(tokenValor.find("c:") != -1):
if(tokenValor.find("*/") != -1):
ruta = tokenValor[tokenValor.find('c:'):tokenValor.find('*/')].strip()
else:
ruta = tokenValor[tokenValor.find('c:'):len(tokenValor)].strip()
break
elif(tokenValor.find("C:") != -1):
if(tokenValor.find("*/") != -1):
ruta = tokenValor[tokenValor.find('C:'):tokenValor.find('*/')].strip()
else:
ruta = tokenValor[tokenValor.find('C:'):len(tokenValor)].strip()
break
return ruta
def enviarReporte(self,ruta):
self._reporte.writeReporte(ruta,self.newEntrada,self.lista_error,'js')
self._reporte.generate_ReportGraphiv(self.recorrido_automata)
self.newEntrada = ''
class Sintactico():
listado_tokens = list()
pila = list()
pop_pila = ''
entrada = ''
lista_Token = list()
estado = ''
cadena = ''
ireport = Report()
def __init__(self):
self.listado_tokens = list()
self.pila = list()
self.pop_pila = ''
self.entrada = ''
self.lista_Token = list()
self.estado = ''
self.cadena = ''
self.ireport = Report()
def q0(self,texto):
print(texto)
self.cadena = texto
self.entrada = f"{texto}$"
self.caracterActual = ''
self.pila.append('#')
x = 0
self.q1(x)
self.reset_analicis()
def q1(self,actual):
x = actual
while x < len(self.entrada):
self.caracterActual = self.entrada[x]
if self.caracterActual == '(':
self.pila.append(self.caracterActual)
elif self.caracterActual == ')':
bandera = self.get_pilaPop()
if bandera != None:
self.q3(x+1)
else:
print("Cadena invalida :(")
break
elif self.caracterActual.isalpha():
pass
elif self.caracterActual.isnumeric():
pass
elif self.caracterActual == '*'or self.caracterActual == '/'or self.caracterActual == '+'or self.caracterActual == '-':
pass
elif self.caracterActual == '$' and x == len(self.entrada) -1:
bandera = self.get_pilaPop()
if bandera != None:
if self.pop_pila == '#':
print('Cadena valida (:')
self.estado = 'Cadena valida (:'
else:
print("Cadena invalida :(")
self.estado = 'Cadena invalida ):'
else:
print("Cadena invalida :(")
self.estado = 'Cadena invalida ):'
break
x += 1
def q3(self,actual):
while actual < len(self.entrada):
self.caracterActual = self.entrada[actual]
if self.caracterActual == ')':
bandera = self.get_pilaPop()
if bandera == None:
print("Cadena invalida :(")
self.estado = 'Cadena invalida ):'
break
elif self.caracterActual == '(':
self.pila.append(self.caracterActual)
self.q1(actual + 1)
break
elif self.caracterActual == '*'or self.caracterActual == '/'or self.caracterActual == '+'or self.caracterActual == '-':
pass
elif self.caracterActual == '$' and actual == len(self.entrada) -1:
bandera = self.get_pilaPop()
if bandera != None:
if self.pop_pila == '#':
print('Cadena Valida (:')
self.estado = 'Cadena Valida (:'
else:
print('Cadena Invalida :c')
self.estado = 'Cadena invalida ):'
else:
print('Cadena Invalida :c')
self.estado = 'Cadena invalida ):'
break
actual += 1
def q4(self):
pass
def get_pilaPop(self):
size = len(self.pila)
print(size)
if size != 0:
self.pop_pila = self.pila.pop()
return self.pop_pila
else:
return None
def get_estado(self):
return self.estado,self.cadena
def reset_analicis(self):
self.caracterActual = ''
self.pop_pila = ''
self.pila = list()
def getRuta(self):
filename = ''
path_SINT = ''
filename = filedialog.asksaveasfilename(initialdir = "/",title = "Select CSV file",filetypes = (("HTML files","*.html"),("all files","*.*")))
if filename != '':
path_SINT = f"{filename}.html"
else:
print("No se selecciono ninguna ruta")
return path_SINT
def generateReport(self):
path_SINT = self.getRuta()
estado,cadena = self.get_estado()
self.ireport.reporte_sintactico(path_SINT,estado,cadena)
class Anality_HTML():
lista_Tokens = list()
lista_error = list()
linea = 1
columna = 1
lexema = ""
_reporte = Report()
newEntrada = ""
def __init__(self):
self.lista_Tokens = list()
self.lista_error = list()
self.linea = 1
self.columna = 1
self.lexema = ""
self._reporte = Report()
self.newEntrada = ""
def read_caracter(self, texto):
self.newEntrada = texto
self.entrada = texto + '$'
self.cActual = ''
x = 0
#print("inicio a leer")
while x < len(self.entrada):
self.cActual = self.entrada[x]
print(self.cActual)
if self.cActual == '<' and self.entrada[
x + 1] == '!' and self.entrada[x + 2] == '-':
if self.entrada[x + 3] == '-':
size_lexama = self.get_size_lexemaComentario(x)
self.q4(x, x + size_lexama + 3)
x = x + size_lexama
elif self.cActual == '<' and self.entrada[x + 1] == '!':
size_lexema = self.get_size_lexema(x)
self.q1(x, x + size_lexema)
x = x + size_lexema
elif self.cActual == '<':
size_lexema = self.get_size_lexema(x)
self.q1(x, x + size_lexema)
x = x + size_lexema
elif self.cActual.isalpha() or self.cActual.isnumeric():
size_lexema = self.get_size_lexemaValor(x)
self.q3(x, x + size_lexema)
print(f"antes de la suma:{x}")
x = x + (size_lexema - 1)
elif self.cActual == "\n" or self.cActual == " " or self.cActual == "\t" or self.cActual == "\t":
if self.cActual == "\n":
self.linea += 1
self.columna = 1
print("Salto de linea principal")
x += 1
self.columna += 1
continue
else:
if self.cActual == "$" and x == len(self.entrada) - 1:
print("Analicis Terminado")
else:
pass
x += 1
self.columna += 1
#self.imprimir_token()
return self.lista_error
def q1(self, actual, fin):
c = ''
while actual < fin:
c = self.entrada[actual]
if c.isnumeric():
self.lexema += c
if (actual + 1 == fin):
self.add_token(TipoHTML.ID, self.lexema, "")
elif c == '!':
self.lexema += c
elif c.isalpha():
self.lexema += c
if (actual + 1 == fin):
self.add_token(TipoHTML.ID, self.lexema, "")
elif c == '/':
self.lexema += c
if (actual + 1 == fin):
self.add_token(TipoHTML.ID, self.lexema, "")
elif c == '=':
self.lexema += c
if (actual + 1 == fin):
self.add_token(TipoHTML.ID, self.lexema, "")
elif c == '\n' or c == ' ' or c == "\t":
self.lexema += c
if (actual + 1 == fin):
self.add_token(TipoHTML.ID, self.lexema, "")
elif c == '"' or c == "'":
self.lexema += c
if (actual + 1 == fin):
self.add_token(TipoHTML.ID, self.lexema, "")
else:
self.q2(actual + 1, fin)
break
else:
print(actual)
self.add_error(actual, self.linea, self.columna, c)
if (actual + 1 == fin):
self.add_token(TipoHTML.ID, self.lexema, "")
actual += 1
self.columna += 1
def q2(self, actual, fin):
while actual < fin:
c = self.entrada[actual]
if c == '"' or c == "'":
self.lexema += c
if (actual + 1 == fin):
self.add_token(TipoHTML.ID, self.lexema, "")
else:
self.q1(actual + 1, fin)
break
else:
self.lexema += c
actual += 1
self.columna += 1
def q3(self, actual, fin):
while actual < fin:
c = self.entrada[actual]
self.lexema += c
if (actual + 1 == fin):
self.add_token(TipoHTML.VALOR, self.lexema, '')
actual += 1
def q4(self, actual, fin):
while actual < fin:
c = self.entrada[actual]
self.lexema += c
if (actual + 1 == fin):
self.add_token(TipoHTML.COMENTARIO, self.lexema, 'gray')
actual += 1
def get_lexema(self, actual, fin):
poscicion = self.entrada[actual:fin].find(" ")
if (poscicion == -1):
return (self.entrada[actual:fin], '', actual)
else:
return (self.entrada[actual:poscicion],
self.entrada[poscicion + 1:fin], poscicion + 1)
def get_pathComentario(self):
print("Analizando Comentario")
ruta = ''
for valor in self.lista_Tokens:
if TipoHTML.COMENTARIO == valor.getTipoToken():
tokenValor = valor.getValorToken()
posicion = tokenValor.find("PATHW")
if posicion != -1:
if (tokenValor.find("c:") != -1):
ruta = tokenValor[tokenValor.find('c:'):tokenValor.
find('-->')].strip()
break
elif (tokenValor.find("C:") != -1):
ruta = tokenValor[tokenValor.find('C:'):tokenValor.
find('-->')].strip()
break
#print(ruta)
return ruta
def add_token(self, tipo, valor, color):
nuevo = TokenHTML(tipo, valor, color)
self.lista_Tokens.append(nuevo)
self.cActual = ''
self.lexema = ""
def add_error(self, posicion, linea, columna, caracter):
if (caracter == '<' or caracter == '>'):
pass
else:
newError = Error_Lexico(posicion, linea, columna, caracter)
self.lista_error.append(newError)
def imprimir_token(self):
for valor in self.lista_Tokens:
print(
f"Tipo: {valor.getTipoToken()}; Valor: {valor.getValorToken()}"
)
print("--------------------------------------------------------")
def get_size_lexema(self, incio):
longitud = 0
for j in range(incio, len(self.entrada) - 1):
if self.entrada[j] == "\n":
self.linea += 1
self.columna = 1
print(f"Salto de linea comentrio {self.linea} ")
if self.entrada[j] == '>':
break
longitud += 1
return longitud
def get_size_lexemaComentario(self, incio):
longitud = 0
for j in range(incio, len(self.entrada) - 1):
if self.entrada[j] == "\n":
self.linea += 1
self.columna = 1
print(f"Salto de linea comentrio {self.linea} ")
if self.entrada[j] == '-' and self.entrada[
j + 1] == '-' and self.entrada[j + 2] == '>':
break
longitud += 1
return longitud
def get_size_lexemaValor(self, inicio):
longitud = 0
for j in range(inicio, len(self.entrada) - 1):
if self.entrada[j] == "\n":
self.linea += 1
self.columna = 1
print(f"Salto de linea comentrio {self.linea} ")
if self.entrada[j] == '<':
break
longitud += 1
return longitud
def enviarReporte(self, ruta):
#self.reporte.writeReporte(ruta,self.newEntrada,self.lista_error)
print("Enviar Reporte")
self._reporte.writeReporte(ruta, self.newEntrada, self.lista_error,
'html')
def limpiarCaracter(self):
self.cActual = ''
self.lexema = ""
self.lista_Tokens = list()
self.lista_error = list()
self.linea = 1
self.columna = 1
self.entrada = ''
print('se limpio el carcater')