def __init__(self, arquivo_fonte):
self.lexico = Lexico(arquivo_fonte)
self.producoes = {
'2': ['P', ['inicio', 'V', 'A']],
'3': ['V', ['varinicio', 'LV']],
'4': ['LV', ['D', 'LV']],
'5': ['LV', ['varfim', ';']],
'6': ['D', ['id', 'TIPO', ';']],
'7': ['TIPO', ['int']],
'8': ['TIPO', ['real']],
'9': ['TIPO', ['lit']],
'10': ['A', ['ES', 'A']],
'11': ['ES', ['leia', 'id', ';']],
'12': ['ES', ['escreva', 'ARG', ';']],
'13': ['ARG', ['literal']],
'14': ['ARG', ['num']],
'15': ['ARG', ['id']],
'16': ['A', ['CMD', 'A']],
'17': ['CMD', ['id', 'rcb', 'LD', ';']],
'18': ['LD', ['OPRD', 'opm', 'OPRD']],
'19': ['LD', ['OPRD']],
'20': ['OPRD', ['id']],
'21': ['OPRD', ['num']],
'22': ['A', ['COND', 'A']],
'23': ['COND', ['CABEÇALHO', 'CORPO']],
'24': ['CABEÇALHO', ['se', '(', 'EXP_R', ')', 'entao']],
'25': ['EXP_R', ['OPRD', 'opr', 'OPRD']],
'26': ['CORPO', ['ES', 'CORPO']],
'27': ['CORPO', ['CMD', 'CORPO']],
'28': ['CORPO', ['COND', 'CORPO']],
'29': ['CORPO', ['fimse']],
'30': ['A', ['fim']]
}
try:
with open('tabela_shift_reduce.csv', newline='') as csvfile:
self.tabela_sintatico = list(csv.reader(csvfile,
delimiter=','))
self.tabela_sintatico = np.array(self.tabela_sintatico)
classes_itens = self.tabela_sintatico[0, 1:]
self.classifica_item = dict()
for idx, tipo in enumerate(classes_itens):
if tipo == '$':
self.classifica_item.update({'EOF': idx})
elif tipo == ';':
self.classifica_item.update({'pt_v': idx})
elif tipo == '(':
self.classifica_item.update({'ab_p': idx})
elif tipo == ')':
self.classifica_item.update({'fc_p': idx})
else:
self.classifica_item.update({tipo: idx})
self.tabela_sintatico = self.tabela_sintatico[1:, 1:]
except Exception as e:
raise e
print("Erro ao abrir tabela de shift reduce do módulo Sintático!!")
exit()
def analisis_sintactico():
global token
global mLex
mLex = Lexico('./afd_final.txt', './mas_simple.html')
token = mLex.getToken()[0].lower()
S()
print "La compilación tuvo éxito"
def analisis_sintactico():
global token
global mLex
arch = './simple.html'
mLex = Lexico('./afd_final.txt', arch)
token = mLex.getToken()[0].lower()
S()
print "La compilación de", arch, "tuvo éxito"
def interprete(self, arquivo):
if not self.lex is None:
print('ERRO: Já existe um arquivo sendo processado.')
else:
self.lex = Lexico(arquivo)
self.lex.abre_arquivo()
self.token_atual = self.lex.get_token()
self.A()
self.consome( tt.FIMARQ )
self.lex.fecha_arquivo()
def interprete(self, nomeArquivo):
if not self.lex is None:
print('ERRO: Já existe um arquivo sendo processado.')
else:
self.lex = Lexico(nomeArquivo)
self.lex.abreArquivo()
self.tokenAtual = self.lex.getToken()
self.F()
self.consome(tt.FIMARQ)
self.lex.fechaArquivo()
def interprete(self, nomeArquivo):
if not self.lex is None:
print('ERRO: Ja existe um arquivo sendo processado.')
else:
self.lex = Lexico(nomeArquivo)
self.lex.abreArquivo()
self.tokenAtual = self.lex.getToken()
if self.gerar_tokens:
self.tokens.append(self.tokenAtual)
self.P()
self.lex.fechaArquivo()
def printTokens(linea):
lexico = Lexico(linea)
tokens = ''
while True:
try:
componente = lexico.siguiente()
tokens = tokens + '\n' + str(componente)
if componente.cat == 'eof':
break
except Exception:
print "Error de ejecucion. (Tokens)"
return tokens
def getExpresion(linea):
try:
lexico = Lexico(linea)
sintactico = Sintactico(lexico)
expresion = sintactico.analizaLinea()
return str(expresion)
except Exception:
print "Error en Ejecucion. (Expresiones)"
def main():
arq = open('pascal_programs/program3.pas', 'r')
prog = arq.read()
arq.close()
print('-- Análise Léxica --')
lex = Lexico()
lex.analizar(prog)
listaTokens = lex.analizar(prog)
print('Análise léxica finalizada \n')
""" for i in listaTokens:
print(i.token+"\t\t"+i.cla+"\t\t"+str(i.linha)) """
print('-- Análise Sintática e Semântica --')
sint = Sintatico(listaTokens)
sint.programa()
sint.exibeLista()
def getResultado(linea):
try:
lexico = Lexico(linea)
sintactico = Sintactico(lexico)
expresion = sintactico.analizaLinea()
return expresion.evalua()
except Exception:
print "Error de Ejecucion. (Resultado)"
class Sintatico:
def __init__(self, gerar_tokens: bool):
self.lex = None
self.tokenAtual = None
self.gerar_tokens = gerar_tokens
self.tokens = []
def interprete(self, nomeArquivo):
if not self.lex is None:
print('ERRO: Ja existe um arquivo sendo processado.')
else:
self.lex = Lexico(nomeArquivo)
self.lex.abreArquivo()
self.tokenAtual = self.lex.getToken()
if self.gerar_tokens:
self.tokens.append(self.tokenAtual)
self.P()
self.lex.fechaArquivo()
def atualIgual(self, token):
(const, _) = token
return self.tokenAtual.const == const
def consome(self, token):
if self.atualIgual(token):
self.tokenAtual = self.lex.getToken()
if self.gerar_tokens:
self.tokens.append(self.tokenAtual)
else:
(_, msg) = token
print('ERRO DE SINTAXE [linha %d]: era esperado "%s" mas veio "%s"'
% (self.tokenAtual.linha, msg, self.tokenAtual.lexema))
quit()
def P(self):
self.Z()
self.consome(tt.EOF)
def Z(self):
self.I()
self.S()
def I(self):
self.consome(tt.VAR)
self.D()
def D(self):
self.L()
self.consome(tt.DPONTOS)
self.K()
self.O()
def L(self):
self.consome(tt.ID)
self.X()
def X(self):
if not self.atualIgual(tt.VIRG):
pass
else:
self.consome(tt.VIRG)
self.L()
def K(self):
if self.atualIgual(tt.INTEGER):
self.consome(tt.INTEGER)
elif self.atualIgual(tt.REAL):
self.consome(tt.REAL)
def O(self):
if not self.atualIgual(tt.PVIRG):
pass
else:
self.consome(tt.PVIRG)
self.D()
def S(self):
if self.atualIgual(tt.ID):
self.consome(tt.ID)
self.consome(tt.ATRIB)
self.E()
elif self.atualIgual(tt.IF):
self.consome(tt.IF)
self.E()
self.consome(tt.THEN)
self.S()
def E(self):
self.T()
self.R()
def R(self):
if not self.atualIgual(tt.OPAD):
pass
else:
self.consome(tt.OPAD)
self.T()
self.R()
def T(self):
self.consome(tt.ID)
def __init__(self):
self.lexico = Lexico()
self.error = False
self.errores = open("errores.txt", "w")
class Sintactico(object):
def __init__(self):
self.lexico = Lexico()
self.error = False
self.errores = open("errores.txt", "w")
def trow_error(self):
print("error sintactico")
sys.exit
def print_position_lex_data(self):
try:
print(f"posicion: {self.lexico.posicion} "\
f"caracter: {self.lexico.actualCaracter()} "\
f"caracter sig: {self.lexico.siguienteCaracter()}\n"
)
except:
pass
def L(self):
"""
El inicio de el analisis la palabra inicial
"""
print("llamando a sintactico palabra inicial")
self.print_position_lex_data()
e = self.E()
self.error = self.lexico.coincidir("n")
if not self.error:
self.trow_error()
print(f"valor final de e: {e}")
def E(self):
print("llamando a E")
self.print_position_lex_data()
t = self.T()
e1 = self.E1()
return t + e1
def E1(self):
print("llamando a E1")
self.print_position_lex_data()
caracter_actual = self.lexico.actualCaracter()
if caracter_actual == "+":
self.error = self.lexico.coincidir("+")
if not self.error:
self.trow_error()
t = self.T()
e1 = self.E1()
return t + e1
return 0
def T(self):
print("llamando a T")
self.print_position_lex_data()
f = self.F()
self.T1()
return f
def T1(self):
print("llamando a T1")
self.print_position_lex_data()
caracter_actual = self.lexico.actualCaracter()
if caracter_actual == "*":
self.error = self.lexico.coincidir("*")
if not self.error:
self.trow_error()
self.F()
self.T1()
else:
pass
def F(self):
print("llamando a F")
self.print_position_lex_data()
caracter_actual = self.lexico.actualCaracter()
if self.lexico.esdigito(caracter_actual):
self.error = self.lexico.coincidir(caracter_actual)
if not self.error:
self.trow_error()
return int(caracter_actual)
#!/usr/bin/python3.5
from lexico import Lexico
from sintactico import Sintactico
from simbolo import Simbolo
source = 'code.txt'
f = open(source, 'r')
codigo_fuente = f.read()
print("Codigo fuente: \n\n{}".format(codigo_fuente))
lex = Lexico(codigo_fuente)
sin = Sintactico(lex)
sin.PROGRAMA()
print()
if sin.errors > 0:
print("Se encontraron: {} erorres".format(sin.errors))
else:
print("Compilacion exitosa!")
print(sin.TAC())
#for s in lex.tabla_simbolos:
# print(s)
##while True:
## s = lex.siguiente_componente_lexico()
## print(s)
## if not s:
## break
from sintatico import Sintatico
from lexico import Lexico
from semantico import Semantico
from maqhipo import MaqHipo
from interpretador import Interpretador
import os
import sys
os.system('cls' if os.name == 'nt' else 'clear')
if (len(sys.argv) > 1):
tokens = Lexico(str(sys.argv[1])).lista_de_tokens
else:
tokens = Lexico('Entrada/Ex2.txt').lista_de_tokens
if (Sintatico(tokens).resultado):
if (Semantico(tokens).resultado):
maqHipo = MaqHipo(tokens)
if (maqHipo.resultado):
Interpretador(maqHipo.codigo_inter)
class Sintatico():
def __init__(self, arquivo_fonte):
self.lexico = Lexico(arquivo_fonte)
self.producoes = {
'2': ['P', ['inicio', 'V', 'A']],
'3': ['V', ['varinicio', 'LV']],
'4': ['LV', ['D', 'LV']],
'5': ['LV', ['varfim', ';']],
'6': ['D', ['id', 'TIPO', ';']],
'7': ['TIPO', ['int']],
'8': ['TIPO', ['real']],
'9': ['TIPO', ['lit']],
'10': ['A', ['ES', 'A']],
'11': ['ES', ['leia', 'id', ';']],
'12': ['ES', ['escreva', 'ARG', ';']],
'13': ['ARG', ['literal']],
'14': ['ARG', ['num']],
'15': ['ARG', ['id']],
'16': ['A', ['CMD', 'A']],
'17': ['CMD', ['id', 'rcb', 'LD', ';']],
'18': ['LD', ['OPRD', 'opm', 'OPRD']],
'19': ['LD', ['OPRD']],
'20': ['OPRD', ['id']],
'21': ['OPRD', ['num']],
'22': ['A', ['COND', 'A']],
'23': ['COND', ['CABEÇALHO', 'CORPO']],
'24': ['CABEÇALHO', ['se', '(', 'EXP_R', ')', 'entao']],
'25': ['EXP_R', ['OPRD', 'opr', 'OPRD']],
'26': ['CORPO', ['ES', 'CORPO']],
'27': ['CORPO', ['CMD', 'CORPO']],
'28': ['CORPO', ['COND', 'CORPO']],
'29': ['CORPO', ['fimse']],
'30': ['A', ['fim']]
}
try:
with open('tabela_shift_reduce.csv', newline='') as csvfile:
self.tabela_sintatico = list(csv.reader(csvfile,
delimiter=','))
self.tabela_sintatico = np.array(self.tabela_sintatico)
classes_itens = self.tabela_sintatico[0, 1:]
self.classifica_item = dict()
for idx, tipo in enumerate(classes_itens):
if tipo == '$':
self.classifica_item.update({'EOF': idx})
elif tipo == ';':
self.classifica_item.update({'pt_v': idx})
elif tipo == '(':
self.classifica_item.update({'ab_p': idx})
elif tipo == ')':
self.classifica_item.update({'fc_p': idx})
else:
self.classifica_item.update({tipo: idx})
self.tabela_sintatico = self.tabela_sintatico[1:, 1:]
except Exception as e:
raise e
print("Erro ao abrir tabela de shift reduce do módulo Sintático!!")
exit()
def gera_arvore_sintatica(self):
tupla_token = self.lexico.pega_token()
a = self.classifica_item[tupla_token[0]]
pilha = [0]
derivacoes = []
while 1:
s = pilha.pop()
pilha.append(s)
#print(s, a)
acao = self.tabela_sintatico[s, int(a)]
if acao == '':
#erro
print("Deu ruim!!")
exit()
elif acao[0] == 's':
pilha.append(int(acao[1:]))
tupla_token = self.lexico.pega_token()
a = self.classifica_item[tupla_token[0]]
elif acao[0] == 'r':
p = self.producoes[acao[1:]]
for i in range(len(p[1])):
pilha.pop()
t = pilha.pop()
pilha.append(t)
#print ("estado adicionado pela redução ", t, self.classifica_item[p[0]])
pilha.append(
int(self.tabela_sintatico[t, self.classifica_item[p[0]]]))
derivacoes.append([acao[1:], p])
print("%s %s -> " % (acao[1:], p[0]) + ' '.join(p[1]))
elif acao == 'acc':
return derivacoes
class Sintatico:
def __init__(self):
self.lex = None
self.token_atual = None
self.tabela_simbolo = { 'PROGRAMA': 0, 'VARIAVEIS': 1, 'INTEIRO': 2, 'REAL': 3 , 'LOGICO': 4, 'CARACTER': 5, 'SE': 6,
'SENAO': 7, 'ENQUANTO': 8, 'LEIA': 9, 'ESCREVA': 10, 'FALSO': 11, 'VERDADEIRO': 12 }
self.tabela_follow = {
'PROG': [tt.FIMARQ[0]],
'DECLS': [tt.ABRECH[0]],
'LIST_DECLS': [tt.ABRECH[0]],
'D': [tt.ABRECH[0]],
'DECL_TIPO': [tt.ID[0], tt.ABRECH[0]],
'LIST_ID': [tt.FECHAPAR[0], tt.DPONTOS[0]],
'E': [tt.FECHAPAR[0], tt.DPONTOS[0]],
'TIPO': [tt.PVIRG[0]],
'C_COMP': [tt.FIMARQ[0], tt.ENQUANTO[0], tt.ESCREVA[0], tt.ID[0], tt.LEIA[0], tt.SE[0], tt.SENAO[0], tt.FECHACH[0]],
'LISTA_COMANDOS': [tt.FECHACH[0]],
'G': [tt.FECHACH[0]],
'COMANDOS': [tt.ENQUANTO[0], tt.ESCREVA[0], tt.ID[0], tt.LEIA[0], tt.SE[0], tt.FECHACH[0]],
'IF': [tt.ENQUANTO[0], tt.ESCREVA[0], tt.ID[0], tt.LEIA[0], tt.SE[0], tt.FECHACH[0]],
'H': [tt.ENQUANTO[0], tt.ESCREVA[0], tt.ID[0], tt.LEIA[0], tt.SE[0], tt.FECHACH[0]],
'WHILE': [tt.ENQUANTO[0], tt.ESCREVA[0], tt.ID[0], tt.LEIA[0], tt.SE[0], tt.FECHACH[0]],
'READ': [tt.ENQUANTO[0], tt.ESCREVA[0], tt.ID[0], tt.LEIA[0], tt.SE[0], tt.FECHACH[0]],
'ATRIB': [tt.ENQUANTO[0], tt.ESCREVA[0], tt.ID[0], tt.LEIA[0], tt.SE[0], tt.FECHACH[0]],
'WRITE': [tt.ENQUANTO[0], tt.ESCREVA[0], tt.ID[0], tt.LEIA[0], tt.SE[0], tt.FECHACH[0]],
'LIST_W': [tt.FECHAPAR[0]],
'L': [tt.FECHAPAR[0]],
'ELEM_W': [tt.FECHAPAR[0], tt.VIRG[0]],
'EXPR': [tt.FECHAPAR[0], tt.VIRG[0], tt.PVIRG[0]],
'P': [tt.FECHAPAR[0], tt.VIRG[0], tt.PVIRG[0]],
'SIMPLES': [tt.FECHAPAR[0], tt.VIRG[0], tt.PVIRG[0], tt.OPREL[0]],
'R': [tt.FECHAPAR[0], tt.VIRG[0], tt.PVIRG[0], tt.OPREL[0]],
'TERMO': [tt.FECHAPAR[0], tt.VIRG[0], tt.PVIRG[0], tt.OPAD[0], tt.OPREL[0]],
'S': [tt.FECHAPAR[0], tt.VIRG[0], tt.PVIRG[0], tt.OPAD[0], tt.OPREL[0]],
'FAT': [tt.OPAD[0], tt.OPMUL[0]],
}
def interprete(self, arquivo):
if not self.lex is None:
print('ERRO: Já existe um arquivo sendo processado.')
else:
self.lex = Lexico(arquivo)
self.lex.abre_arquivo()
self.token_atual = self.lex.get_token()
self.A()
self.consome( tt.FIMARQ )
self.lex.fecha_arquivo()
def atual_igual(self, token):
(const, msg) = token
return self.token_atual.const == const
def consome(self, token):
if self.atual_igual( token ):
self.token_atual = self.lex.get_token()
if self.token_atual.const == tt.ID[0] and (self.token_atual.lexema not in self.tabela_simbolo):
self.tabela_simbolo[self.token_atual.lexema] = (self.token_atual.const,
self.token_atual.msg, self.token_atual.linha)
else:
(const, msg) = token
self.erro( msg )
def erro(self, esperado):
print('ERRO DE SINTAXE [linha %d]: era esperado "%s" mas veio "%s"'
% (self.token_atual.linha, esperado, self.token_atual.lexema))
raise
def sincroniza(self, follow):
#print(follow)
follow_list = self.tabela_follow[follow]
while True:
#print(self.token_atual.lexema)
self.token_atual = self.lex.get_token()
if self.token_atual.const in follow_list: # SINCRONIZOU
#print(self.token_atual.lexema)
break
def A(self):
try:
self.PROG()
self.consome( tt.FIMARQ )
except:
quit()
def PROG(self):
try:
self.consome( tt.PROGRAMA )
self.consome( tt.ID )
self.consome( tt.PVIRG )
self.DECLS()
self.C_COMP()
except:
self.sincroniza('PROG')
def DECLS(self):
try:
if self.atual_igual( tt.VARIAVEIS ):
self.consome( tt.VARIAVEIS )
self.LIST_DECLS()
else:
pass
except:
self.sincroniza('DECLS')
def LIST_DECLS(self):
try:
self.DECL_TIPO()
self.D()
except:
self.sincroniza('LIST_DECLS')
def D(self):
try:
if self.atual_igual( tt.ID ):
self.LIST_DECLS()
else:
pass
except:
self.sincroniza('D')
def DECL_TIPO(self):
try:
self.LIST_ID()
self.consome( tt.DPONTOS )
if self.TIPO():
self.erro( 'tipo' )
self.consome( tt.PVIRG )
except:
self.sincroniza('DECL_TIPO')
def LIST_ID(self):
try:
self.consome( tt.ID )
self.E()
except:
self.sincroniza('LIST_ID')
def E(self):
try:
if self.atual_igual( tt.VIRG ):
self.consome( tt.VIRG )
self.LIST_ID()
else:
pass
except:
self.sincroniza('E')
def TIPO(self):
try:
if self.atual_igual( tt.INTEIRO ):
self.consome( tt.INTEIRO )
elif self.atual_igual( tt.REAL ):
self.consome( tt.REAL )
elif self.atual_igual( tt.LOGICO ):
self.consome( tt.LOGICO )
elif self.atual_igual( tt.CARACTER ):
self.consome( tt.CARACTER )
else:
return True
except:
self.sincroniza('TIPO')
def C_COMP(self):
try:
self.consome( tt.ABRECH )
self.LISTA_COMANDOS()
self.consome( tt.FECHACH )
except:
self.sincroniza('C_COMP')
def LISTA_COMANDOS(self):
try:
if self.COMANDOS():
self.erro( 'comando' )
self.G()
except:
self.sincroniza('LISTA_COMANDOS')
def G(self):
try:
if self.atual_igual( tt.SE ) or self.atual_igual( tt.ENQUANTO ) or self.atual_igual( tt.LEIA ) or self.atual_igual( tt.ESCREVA ) or self.atual_igual( tt.ID ):
self.LISTA_COMANDOS()
else:
pass
except:
self.sincroniza('G')
def COMANDOS(self):
try:
if self.atual_igual( tt.SE ):
self.IF()
elif self.atual_igual( tt.ENQUANTO ):
self.WHILE()
elif self.atual_igual( tt.LEIA ):
self.READ()
elif self.atual_igual( tt.ESCREVA ):
self.WRITE()
elif self.atual_igual( tt.ID ):
self.ATRIB()
else:
return True
except:
self.sincroniza('COMANDOS')
def IF(self):
try:
self.consome( tt.SE )
self.consome( tt.ABREPAR )
self.EXPR()
self.consome( tt.FECHAPAR )
self.C_COMP()
self.H()
except:
self.sincroniza('IF')
def H(self):
try:
if self.atual_igual( tt.SENAO ):
self.consome( tt.SENAO )
self.C_COMP()
else:
pass
except:
self.sincroniza('H')
def WHILE(self):
try:
self.consome( tt.ENQUANTO )
self.consome( tt.ABREPAR )
self.EXPR()
self.consome( tt.FECHAPAR )
self.C_COMP()
except:
self.sincroniza('WHILE')
def READ(self):
try:
self.consome( tt.LEIA )
self.consome( tt.ABREPAR )
self.LIST_ID()
self.consome( tt.FECHAPAR )
self.consome( tt.PVIRG )
except:
self.sincroniza('READ')
def ATRIB(self):
try:
self.consome( tt.ID )
self.consome( tt.ATRIB )
self.EXPR()
self.consome( tt.PVIRG )
except:
self.sincroniza('ATRIB')
def WRITE(self):
try:
self.consome( tt.ESCREVA )
self.consome( tt.ABREPAR )
self.LIST_W()
self.consome( tt.FECHAPAR )
self.consome( tt.PVIRG )
except:
self.sincroniza('WRITE')
def LIST_W(self):
try:
if self.ELEM_W():
self.erro( 'expreção ou cadeia' )
self.L()
except:
self.sincroniza('LIST_W')
def L(self):
try:
if self.atual_igual( tt.VIRG ):
self.consome( tt.VIRG )
self.LIST_W()
else:
pass
except:
self.sincroniza('L')
def ELEM_W(self):
try:
if self.atual_igual( tt.ID ) or self.atual_igual( tt.CTE ) or self.atual_igual( tt.ABREPAR ) or self.atual_igual( tt.VERDADEIRO ) or self.atual_igual( tt.FALSO ) or self.atual_igual( tt.OPNEG ):
self.EXPR()
elif self.atual_igual( tt.CADEIA ):
self.consome( tt.CADEIA )
else:
return True
except:
self.sincroniza('ELEM_W')
def EXPR(self):
try:
self.SIMPLES()
self.P()
except:
self.sincroniza('EXPR')
def P(self):
try:
if self.atual_igual( tt.OPREL ):
self.consome( tt.OPREL )
self.SIMPLES()
else:
pass
except:
self.sincroniza('P')
def SIMPLES(self):
try:
self.TERMO()
self.R()
except:
self.sincroniza('SIMPLES')
def R(self):
try:
if self.atual_igual( tt.OPAD ):
self.consome( tt.OPAD )
self.SIMPLES()
else:
pass
except:
self.sincroniza('R')
def TERMO(self):
try:
if self.FAT():
self.erro( 'FAT' )
self.S()
except:
self.sincroniza('TERMO')
def S(self):
try:
if self.atual_igual( tt.OPMUL ):
self.consome( tt.OPMUL )
self.TERMO()
else:
pass
except:
self.sincroniza('S')
def FAT(self):
try:
if self.atual_igual( tt.ID ):
self.consome( tt.ID )
elif self.atual_igual( tt.CTE ):
self.consome( tt.CTE )
elif self.atual_igual( tt.ABREPAR ):
self.consome( tt.ABREPAR )
self.EXPR()
self.consome( tt.FECHAPAR )
elif self.atual_igual( tt.VERDADEIRO ):
self.consome( tt.VERDADEIRO )
elif self.atual_igual( tt.FALSO ):
self.consome( tt.FALSO )
elif self.atual_igual( tt.OPNEG ):
self.consome( tt.OPNEG )
if self.FAT():
self.erro( 'FAT' )
else:
return True
except:
self.sincroniza('FAT')
else:
return complex_actual.Token == TOKENS[token]
else:
return False
codigo = ""
with open('codigo.txt', 'r') as f:
codigo = f.read()
ln = 1
for linea in codigo.split('\n'):
print("{}: {}".format(ln, linea))
ln += 1
lex = Lexico(codigo)
complex_actual = siguiente_componente_lexico()
semantico = Semantico()
if not PROGRAMA():
print("Ln# {}: Se encontraron errores.".format(lex.num_linea))
else:
print("\nCompilacion exitosa!")
semantico.generar_archivo_3ac()
if lex.error.total > 0:
print("Se encontraron: {} errores.".format(lex.error.total))
for e in lex.error.errores:
print(e)
#!/usr/bin/env python
from lexico import Lexico
from pila import Pila
from interRI import InterRI
import sys
if __name__ == '__main__':
archivo = sys.argv[1]
f = file(archivo,"r").readlines()
s = "".join(f)
l = Lexico(s=s)
l.analizar()
t = l.getTokens()
t.reverse()
inter = InterRI(t)
inter.ejecutar()
p = inter.getMainStack()
from lexico import Lexico
from simbolo import CONST_TOKENS
codigo = ""
with open('codigo.txt', 'r') as f:
codigo = f.read()
print(codigo)
lex = Lexico(codigo)
print("\n")
while True:
s = lex.siguiente_componente_lexico()
if s:
print("Lexema: {}".format(s.Lexema).ljust(20), end="")
print("Token: {} ".format(s.Token))
else:
break
print("\n")
if lex.error.total > 0:
print("Se encontraron: {} errores.".format(lex.error.total))
for e in lex.error.errores:
print(e)
if (self.accion == -1):
print('Cadena valida')
elif (self.accion > 0):
self.pila.push(self.accion)
elif (self.accion < 0):
self.pila.pop(reglas[self.accion]['cantidad'])
self.pila.push(matriz[int(
self.pila.top())][reglas[self.accion]['columna']])
self.comparar('$')
else:
print('Invalida')
exit()
cadena = input('Ingresar cadena: ')
lexico = Lexico(cadena)
tokens = list()
while (lexico.termino() == False):
lexico.sigPosicion()
if (lexico.boolToken):
tokens.append(lexico.token)
lexico.boolToken = False
lexico.tipoDato(lexico.state)
tokens.append(lexico.token)
tokens.append('$')
sintactico = Sintactico(len(tokens) - 1)
for token in tokens:
sintactico.comparar(token)
class Sintatico:
def __init__(self):
self.lex = None
self.tokenAtual = None
def interprete(self, nomeArquivo):
if not self.lex is None:
print('ERRO: Já existe um arquivo sendo processado.')
else:
self.lex = Lexico(nomeArquivo)
self.lex.abreArquivo()
self.tokenAtual = self.lex.getToken()
self.F()
self.consome(tt.FIMARQ)
self.lex.fechaArquivo()
def atualIgual(self, token):
(const, msg) = token
return self.tokenAtual.const == const
def consome(self, token):
if self.atualIgual(token):
self.tokenAtual = self.lex.getToken()
else:
(const, msg) = token
print(
'ERRO DE SINTAXE [linha %d]: era esperado "%s" mas veio "%s"' %
(self.tokenAtual.linha, msg, self.tokenAtual.lexema))
quit()
def F(self):
self.C()
self.Rf()
def Rf(self):
if self.atualIgual(tt.FIMARQ):
pass
else:
self.C()
self.Rf()
def C(self):
if self.atualIgual(tt.READ):
self.R()
elif self.atualIgual(tt.PRINT):
self.P()
else:
self.A()
def A(self):
self.consome(tt.IDENT)
self.consome(tt.ATRIB)
self.E()
self.consome(tt.PTOVIRG)
def R(self):
self.consome(tt.READ)
self.consome(tt.OPENPAR)
self.consome(tt.IDENT)
self.consome(tt.CLOSEPAR)
self.consome(tt.PTOVIRG)
def P(self):
self.consome(tt.PRINT)
self.consome(tt.OPENPAR)
self.consome(tt.IDENT)
self.consome(tt.CLOSEPAR)
self.consome(tt.PTOVIRG)
def E(self):
self.M()
self.Rs()
def Rs(self):
if self.atualIgual(tt.ADD):
self.consome(tt.ADD)
self.M()
self.Rs()
else:
pass
def M(self):
self.Op()
self.Rm()
def Rm(self):
if self.atualIgual(tt.MULT):
self.consome(tt.MULT)
self.Op()
self.Rm()
else:
pass
def Op(self):
if self.atualIgual(tt.OPENPAR):
self.consome(tt.OPENPAR)
self.E()
self.consome(tt.CLOSEPAR)
else:
self.consome(tt.NUM)
class Sintatico:
def __init__(self, gerar_tokens: bool):
self.lex = None
self.tokenAtual = None
self.gerar_tokens = gerar_tokens
self.tokens = []
def interprete(self, nomeArquivo):
if not self.lex is None:
print('ERRO: Já existe um arquivo sendo processado.')
else:
self.lex = Lexico(nomeArquivo)
self.lex.abreArquivo()
self.tokenAtual = self.lex.getToken()
if self.gerar_tokens:
self.tokens.append(self.tokenAtual)
self.A()
self.lex.fechaArquivo()
def atualIgual(self, token):
(const, _) = token
return self.tokenAtual.const == const
def consome(self, token):
if self.atualIgual(token):
self.tokenAtual = self.lex.getToken()
if self.gerar_tokens:
self.tokens.append(self.tokenAtual)
else:
(_, msg) = token
print(
'ERRO DE SINTAXE [linha %d]: era esperado "%s" mas veio "%s"' %
(self.tokenAtual.linha, msg, self.tokenAtual.lexema))
quit()
def A(self):
self.PROG()
self.consome(tt.FIMARQ)
def PROG(self):
self.consome(tt.PROGRAMA)
self.consome(tt.ID)
self.consome(tt.PVIRG)
self.DECLS()
self.C_COMP()
def DECLS(self):
if not self.atualIgual(tt.VARIAVEIS):
pass
else:
self.consome(tt.VARIAVEIS)
self.LIST_DECLS()
def LIST_DECLS(self):
self.DECL_TIPO()
self.D()
def D(self):
if not self.atualIgual(tt.ID):
pass
else:
self.LIST_DECLS()
def DECL_TIPO(self):
self.LIST_ID()
self.consome(tt.DPONTOS)
self.TIPO()
self.consome(tt.PVIRG)
def LIST_ID(self):
self.consome(tt.ID)
self.E()
def E(self):
if not self.atualIgual(tt.VIRG):
pass
else:
self.consome(tt.VIRG)
self.LIST_ID()
def TIPO(self):
if self.atualIgual(tt.INTEIRO):
self.consome(tt.INTEIRO)
elif self.atualIgual(tt.REAL):
self.consome(tt.REAL)
elif self.atualIgual(tt.LOGICO):
self.consome(tt.LOGICO)
elif self.atualIgual(tt.CARACTER):
self.consome(tt.CARACTER)
def C_COMP(self):
self.consome(tt.ABRECH)
self.LISTA_COMANDOS()
self.consome(tt.FECHACH)
def LISTA_COMANDOS(self):
self.COMANDOS()
self.G()
def G(self):
if not (self.atualIgual(tt.SE) or self.atualIgual(tt.ENQUANTO)
or self.atualIgual(tt.LEIA) or self.atualIgual(tt.ESCREVA)
or self.atualIgual(tt.ID)):
pass
else:
self.LISTA_COMANDOS()
def COMANDOS(self):
if self.atualIgual(tt.SE):
self.IF()
elif self.atualIgual(tt.ENQUANTO):
self.WHILE()
elif self.atualIgual(tt.LEIA):
self.READ()
elif self.atualIgual(tt.ESCREVA):
self.WRITE()
elif self.atualIgual(tt.ID):
self.ATRIB()
def IF(self):
self.consome(tt.SE)
self.consome(tt.ABREPAR)
self.EXPR()
self.consome(tt.FECHAPAR)
self.C_COMP()
self.H()
def H(self):
if not (self.atualIgual(tt.SENAO)):
pass
else:
self.consome(tt.SENAO)
self.C_COMP()
def WHILE(self):
self.consome(tt.ENQUANTO)
self.consome(tt.ABREPAR)
self.EXPR()
self.consome(tt.FECHAPAR)
self.C_COMP()
def READ(self):
self.consome(tt.LEIA)
self.consome(tt.ABREPAR)
self.LIST_ID()
self.consome(tt.FECHAPAR)
self.consome(tt.PVIRG)
def ATRIB(self):
self.consome(tt.ID)
self.consome(tt.ATRIB)
self.EXPR()
self.consome(tt.PVIRG)
def WRITE(self):
self.consome(tt.ESCREVA)
self.consome(tt.ABREPAR)
self.LIST_W()
self.consome(tt.FECHAPAR)
self.consome(tt.PVIRG)
def LIST_W(self):
self.ELEM_W()
self.L()
def L(self):
if not self.atualIgual(tt.VIRG):
pass
else:
self.consome(tt.VIRG)
self.LIST_W()
def ELEM_W(self):
if not self.atualIgual(tt.CADEIA):
self.EXPR()
else:
self.consome(tt.CADEIA)
def EXPR(self):
self.SIMPLES()
self.P()
def P(self):
if not self.atualIgual(tt.OPREL):
pass
else:
self.consome(tt.OPREL)
self.SIMPLES()
def SIMPLES(self):
self.TERMO()
self.R()
def R(self):
if not self.atualIgual(tt.OPAD):
pass
else:
self.consome(tt.OPAD)
self.SIMPLES()
def TERMO(self):
self.FAT()
self.S()
def S(self):
if not self.atualIgual(tt.OPMUL):
pass
else:
self.consome(tt.OPMUL)
self.TERMO()
def FAT(self):
if self.atualIgual(tt.ID):
self.consome(tt.ID)
elif self.atualIgual(tt.CTE):
self.consome(tt.CTE)
elif self.atualIgual(tt.ABREPAR):
self.consome(tt.ABREPAR)
self.EXPR()
self.consome(tt.FECHAPAR)
elif self.atualIgual(tt.VERDADEIRO):
self.consome(tt.VERDADEIRO)
elif self.atualIgual(tt.FALSO):
self.consome(tt.FALSO)
elif self.atualIgual(tt.OPNEG):
self.consome(tt.OPNEG)
self.FAT()