def __init__(self, txt=None):
# self.lexico = MockLexico()
self.lexico = Lexico()
print("#####INICIO LEXICO########")
if not txt:
self.lexico.le_arquivo()
else:
self.lexico.txt_arquivo = txt
self.lexico.inicia_lexico()
print("#####INICIO SINTATICO########")
self.txt_arquivo = ""
self.expressao_temp = ""
self.pilha_expressao = []
self.LISTA_OPERADORES = {}
self.ERROS = {
"is_identificador": "'!#!' não é um identificador.",
"is_programa": "'!#!' não é um início de programa válido.",
"is_ponto_virgula": "Deveria ser um ';' ao invés de '!#!'.",
"is_ponto_final":
"O pragrama deveria terminar com '.' ao invés de '!#!'.",
"is_dois_pontos": "Deveria ser ':' ao invés de '!#!'.",
"analisa_tipo": "'!#!' não é um tipo válido.",
"is_procedimento": "'!#!' não é um procedimento.",
"is_procedimento_ou_funcao":
"'!#!' não é um procedimento ou uma função.",
"is_funcao": "'!#!' deveria ser um início de função.",
"is_fim": "'!#!' deveria ser um fim de função ou procedimento.",
"is_inicio": "'!#!' Sintaxe inválida.",
"is_se": "'!#!' deveria ser um se.",
"is_entao": "'!#!' deveria ser um entao.",
"is_var": "'!#!' deveria ser uma variável.",
"is_tipo": "'!#!' deveria ser um tipo.",
}
print("#####INICIO SEMÂNTICO########")
self.semantico = Semantico()
def main():
tokens = Lexico("entrada")
tokens = tokens.analisar()
lista = tokens.getList()
#for elemento in lista:
# print(elemento.cadeia)
sintatico = Sintatico(tokens)
sintatico.analisar()
print("Inicio de tradução")
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() # ABRE O ARQUIVO PASSADO POR PARAMETRO.
self.tokenAtual = self.lex.getToken(
) # A FUNÇÃO "getToken" PEGA UM TOKEN DO LEXICO
# PARA MINHA VARIAVEL CHAMADA "tokenAtual".
self.A()
def enviarPagina():
if request.method == "POST":
codigo = request.form['codigo']
tokens = Lexico(codigo).tokens
return render_template("tokens.html", tokens=tokens)
else:
return render_template("inicio_lexico.html")
def analizador():
if request.method == "POST":
codigo = request.form['codigo']
lexico = Lexico(codigo)
analizador = Analizador(Analizador.leerTablaTAS("tablaTAS.csv"),
lexico)
analizador.analizar()
return render_template("analizador.html", estados=analizador.estados)
else:
return render_template("inicio_analizador.html")
cad = cad.lstrip()
cad = cad.rstrip()
aux = ""
flag = 0
er = ""
try:
indice = "".join(cad).rindex(' ')
for i in range(indice + 1, len(cad)):
aux += cad[i]
er = cad[0:indice].replace(' ', '')
tk = int(aux)
lexic = Lexico(er)
numCrear2 = 0
conteoDeEdos2 = 0
conjunto2 = conjuntoAFN(None)
result = E(conjunto2, tk)
except:
print(
"Error, una de las expresiones del txt que ingresaste es errónea\n"
)
time.sleep(1)
result = False
if result == False:
break
else:
class Sintatico:
def __init__(self, txt=None):
# self.lexico = MockLexico()
self.lexico = Lexico()
print("#####INICIO LEXICO########")
if not txt:
self.lexico.le_arquivo()
else:
self.lexico.txt_arquivo = txt
self.lexico.inicia_lexico()
print("#####INICIO SINTATICO########")
self.txt_arquivo = ""
self.expressao_temp = ""
self.pilha_expressao = []
self.LISTA_OPERADORES = {}
self.ERROS = {
"is_identificador": "'!#!' não é um identificador.",
"is_programa": "'!#!' não é um início de programa válido.",
"is_ponto_virgula": "Deveria ser um ';' ao invés de '!#!'.",
"is_ponto_final":
"O pragrama deveria terminar com '.' ao invés de '!#!'.",
"is_dois_pontos": "Deveria ser ':' ao invés de '!#!'.",
"analisa_tipo": "'!#!' não é um tipo válido.",
"is_procedimento": "'!#!' não é um procedimento.",
"is_procedimento_ou_funcao":
"'!#!' não é um procedimento ou uma função.",
"is_funcao": "'!#!' deveria ser um início de função.",
"is_fim": "'!#!' deveria ser um fim de função ou procedimento.",
"is_inicio": "'!#!' Sintaxe inválida.",
"is_se": "'!#!' deveria ser um se.",
"is_entao": "'!#!' deveria ser um entao.",
"is_var": "'!#!' deveria ser uma variável.",
"is_tipo": "'!#!' deveria ser um tipo.",
}
print("#####INICIO SEMÂNTICO########")
self.semantico = Semantico()
def mostra_erro(self, nome_metodo, token):
raise Exception(
'Erro de sintáxe: ' +
self.ERROS[nome_metodo].replace('!#!', token['token']) +
" Linha: " + str(token['linha'] + 1))
def analisa_programa(self):
self.semantico.rotulo = 1
token = self.lexico.pop_token()
if is_programa(token):
token = self.lexico.pop_token()
if is_identificador(token):
self.semantico.insere_tabela(token["token"],
token["lexema"],
'programa',
posicao_mem=0)
token = self.lexico.pop_token()
if is_ponto_virgula(token, 'analisa_programa'):
self.semantico.gera(comando='START')
self.analisa_bloco()
dalloc = self.semantico.pilha_alloc.pop()
self.semantico.gera(comando='DALLOC',
attr1=dalloc[0],
attr2=dalloc[1])
token = self.lexico.pop_token()
if is_ponto_final(token):
self.semantico.gera(comando='HLT')
return True
else:
self.mostra_erro('is_ponto_final', token)
else:
self.mostra_erro('is_ponto_virgula', token)
else:
self.mostra_erro('is_identificador', token)
else:
self.mostra_erro('is_programa', token)
def analisa_bloco(self):
print('--analisa_bloco')
self.analisa_etapa_declaracao_vars()
self.analisa_etapa_declaracao_sub_rotinas()
self.analisa_comandos()
def analisa_etapa_declaracao_vars(self):
print("--analisa_etapa_declaracao_vars")
token = self.lexico.pop_token()
if is_var(token):
while self.analisa_declaracao_vars():
token = self.lexico.pop_token()
if not is_ponto_virgula(token,
'analisa_etapa_decalracao_vars'):
self.mostra_erro('is_ponto_virgula', token)
self.semantico.gera(comando='ALLOC',
attr1=self.semantico.i_pilha,
attr2=self.semantico.qtd_var_local)
self.semantico.pilha_alloc.append(
(self.semantico.i_pilha, self.semantico.qtd_var_local))
self.semantico.i_pilha = self.semantico.qtd_var_local
self.semantico.qtd_var_local = 0
token = self.lexico.pop_token()
#TODO:rever
if token["lexema"] == 'sprocedimento' or token[
"lexema"] == 'sfuncao' or token["lexema"] == 'sinicio':
self.lexico.insert_token(token)
break
self.lexico.insert_token(token)
return True
# self.lexico.insert_token(token)
else:
self.mostra_erro('is_var', token)
def analisa_variavel(self):
print("--analisa_variavel")
token = self.lexico.pop_token()
if is_identificador(token):
return True
else:
self.mostra_erro('is_identificador', token)
def analisa_declaracao_vars(self):
print("--analisa_declaracao_vars")
token = self.lexico.pop_token()
while is_identificador(token):
if not self.semantico.pesquisa_duplic_var_tabela(token):
self.semantico.insere_tabela(token["token"],
token['lexema'],
'variavel',
nivel=self.semantico.nivel,
i=self.semantico.qtd_var)
self.semantico.qtd_var_local += 1
self.semantico.qtd_var += 1
else:
self.semantico.mostra_erro('duplic_var', token)
token = self.lexico.pop_token()
if not is_virgula(token):
if is_dois_pontos(token):
tipo = self.analisa_tipo()
if tipo:
self.semantico.coloca_tipo(tipo)
return True
else:
self.mostra_erro('analisa_tipo', token)
else:
self.mostra_erro('is_dois_pontos', token)
token = self.lexico.pop_token()
self.mostra_erro('is_identificador', token)
def analisa_tipo(self):
print('--analisa_tipo')
token = self.lexico.pop_token()
if is_inteiro(token) or is_booleano(token):
# self.semantico.coloca_tipo_tabela(token['lexema'])
return token['token']
else:
self.mostra_erro('is_tipo', token)
def analisa_etapa_declaracao_sub_rotinas(self):
print('--analisa_etapa_declaracao_sub_rotinas')
auxrot = None
flag = False
token = self.lexico.pop_token()
if is_procedimento(token) or is_funcao(token):
auxrot = self.semantico.rotulo
self.semantico.gera(comando='JMP',
attr1="L" + str(self.semantico.rotulo))
self.semantico.rotulo += 1
flag = True
while is_procedimento(token) or is_funcao(token):
# token = self.lexico.pop_token()
if is_procedimento(token):
print("entrei")
self.analisa_declaracao_procedimento(token)
# token = self.lexico.pop_token()
# if not is_ponto_virgula(token, 'dec_sub_rotinas'):
# self.mostra_erro('is_ponto_virgula', token)
elif is_funcao(token):
self.analisa_declaracao_funcao(token)
token = self.lexico.pop_token()
if not is_ponto_virgula(token, 'dec_sub_rotinas'):
self.mostra_erro('is_ponto_virgula', token)
else:
token = self.lexico.pop_token()
if is_inicio(token):
self.lexico.insert_token(token)
if flag:
self.semantico.gera(rotulo=auxrot, comando='NULL')
def analisa_declaracao_procedimento(self, token):
print("--analisa_declaracao_procedimento")
if is_procedimento(token):
token = self.lexico.pop_token()
# self.semantico.nivel = 'L'
if is_identificador(token):
if not self.semantico.pesquisa_declproc_tabela(token):
self.semantico.insere_tabela(token["token"],
token['lexema'],
'procedimento',
nivel=self.semantico.nivel,
rotulo=self.semantico.rotulo)
self.semantico.gera(rotulo=self.semantico.rotulo,
comando='NULL')
self.semantico.rotulo += 1
token = self.lexico.pop_token()
if is_ponto_virgula(token, 'ana_dec_proc'):
self.analisa_bloco()
dalloc = self.semantico.pilha_alloc.pop()
self.semantico.gera(comando='DALLOC',
attr1=dalloc[0],
attr2=dalloc[1])
self.semantico.gera(comando='RETURN')
return True
else:
self.mostra_erro('is_ponto_virgula', token)
else:
self.semantico.mostra_erro('decl_proc', token)
else:
self.mostra_erro('is_identificador', token)
else:
self.semantico.volta_nivel()
self.mostra_erro('is_identificador', token)
def analisa_declaracao_funcao(self, token=None):
print('--analisa_declaracao_funcao')
if is_funcao(token):
token = self.lexico.pop_token()
# self.semantico.nivel = 'L'
if is_identificador(token):
if self.semantico.pesquisa_declfunc_tabela(
token['lexema'], self.semantico.nivel):
self.semantico.insere_tabela(token["token"],
token['lexema'], 'funcao',
self.semantico.nivel,
self.semantico.rotulo)
self.semantico.gera(comando='NULL',
attr1=self.semantico.nivel)
self.semantico.nivel += 1
token = self.lexico.pop_token()
if is_dois_pontos(token):
token = self.lexico.pop_token()
if is_inteiro(token) or is_booleano(token):
if is_inteiro(token):
self.semantico.tabela[0][
'tipo_lexema'] = 'função inteiro'
self.semantico.tabela[0][
'tipo_especifico'] = 'inteiro'
else:
self.semantico.tabela[0][
'tipo_lexema'] = 'função boolean'
self.semantico.tabela[0][
'tipo_especifico'] = 'boolean'
token = self.lexico.pop_token()
if is_ponto_virgula(token, 'ana_dec_func'):
self.analisa_bloco()
return True
else:
self.mostra_erro('func_erro_tipo', token)
else:
self.mostra_erro('is_dois_pontos', token)
else:
self.semantico.mostra_erro('decl_func', token)
else:
self.mostra_erro('is_identificador', token)
#semantico: desempilha ou volta nself.nivelivel
else:
self.mostra_erro('is_funcao', token)
def analisa_comandos(self):
print('--analisa_comandos')
token = self.lexico.pop_token()
if is_inicio(token):
self.analisa_comando()
token = self.lexico.pop_token()
while not is_fim(token):
# if is_ponto_final(token):
# dalloc = self.semantico.pilha_alloc.pop()
# self.semantico.gera(comando='DALLOC', attr1=dalloc[0], attr2=dalloc[1])
# self.semantico.gera(comando='RETURN')
# break
if is_ponto_virgula(token, 'ana_com'):
token = self.lexico.get_token()
if not is_fim(token):
self.analisa_comando()
token = self.lexico.pop_token()
else:
self.mostra_erro('is_ponto_virgula', token)
else:
self.mostra_erro('is_inicio', token)
def analisa_comando(self):
print('--analisa_comando')
token = self.lexico.get_token()
if is_identificador(token):
var_ind = self.semantico.get_indice_var(token['token'])
# if var_ind:
# token = self.lexico.pop_token()
tipo = self.semantico.retorna_tipo_especifico(token['token'])
_, posicao_mem, _ = self.semantico.pesquisa_tabela(
token['token'], self.semantico.nivel)
token = self.lexico.pop_token()
self.analisa_atribuicao_chprocedimento(tipo, posicao_mem, token)
elif is_se(token):
self.analisa_comando_condicional()
elif is_enquanto(token):
self.analisa_comando_enquanto()
elif is_leia(token):
self.semantico.gera(comando='RD')
self.analisa_comando_leitura()
elif is_escreva(token):
self.analisa_comando_escrita()
else:
self.analisa_comandos()
def analisa_atribuicao_chprocedimento(self, tipo, posicao_mem,
token_anterior):
print('--analisa_atribuicao_chprocedimento')
token = self.lexico.pop_token()
if is_atribuicao(token):
self.analisa_comando_atribuicao(tipo, posicao_mem)
else:
self.lexico.insert_token(token)
if not token['token'] == ";":
self.lexico.insert_token(token_anterior)
self.analisa_chamada_procedimento()
def analisa_comando_atribuicao(self, tipo, posicao_mem, token=None):
print('--analisa_comando_atribuicao')
token = self.lexico.get_token()
tipo_retorno = self.semantico.retorna_tipo_especifico(token['token'])
if tipo_retorno:
_, tipo_retorno = self.analisa_expressao()
if tipo != tipo_retorno:
self.semantico.mostra_erro('inc_tipo', token)
else:
self.semantico.gera(comando="STR", attr1=posicao_mem)
# elif token['token'].isdigit():
# return
else:
self.semantico.mostra_erro('inc_ident', token)
def analisa_chamada_procedimento(self):
token = self.lexico.get_token()
# if is_identificador(token):
exists, nivel, rotulo = self.semantico.get_nivel_rotulo_procedimento(
token['token'])
if exists:
self.semantico.gera(comando='CALL', attr1='L' + str(rotulo))
self.lexico.pop_token()
return True
def analisa_comando_condicional(self):
print('--analisa_comando_condicional')
executando_se = True
token = self.lexico.pop_token()
if is_se(token):
self.analisa_expressao()
token = self.lexico.pop_token()
if is_entao(token):
self.semantico.gera(comando='JMPF',
attr1='L' + str(self.semantico.rotulo))
self.semantico.rotulo += 1
self.analisa_comando()
self.semantico.gera(comando='JMP',
attr1='L' + str(self.semantico.rotulo))
self.semantico.gera(rotulo=self.semantico.rotulo - 1,
comando='NULL')
self.semantico.rotulo += 1
token = self.lexico.get_token()
if is_senao(token):
self.lexico.pop_token()
self.analisa_comando()
self.semantico.gera(rotulo=self.semantico.rotulo - 1,
comando='NULL')
return True
else:
self.mostra_erro('is_entao', token)
else:
self.mostra_erro('is_se', token)
def analisa_comando_enquanto(self):
auxrot1 = None
auxrot2 = None
token = self.lexico.pop_token()
if is_enquanto(token):
auxrot1 = self.semantico.rotulo
self.semantico.gera(rotulo=self.semantico.rotulo, comando='NULL')
self.semantico.rotulo += 1
self.analisa_expressao()
token = self.lexico.pop_token()
if is_faca(token):
auxrot2 = self.semantico.rotulo
self.semantico.gera(comando='JMPF',
attr1='L' + str(self.semantico.rotulo))
self.semantico.rotulo += 1
self.analisa_comando()
self.semantico.gera(comando='JMP', attr1='L' + str(auxrot1))
self.semantico.gera(rotulo=auxrot2, comando='NULL')
return True
else:
self.mostra_erro('is_faca', token)
else:
self.mostra_erro('is_enquanto', token)
def analisa_comando_leitura(self):
print('--analisa_comando_leitura')
token = self.lexico.pop_token()
if is_leia(token):
token = self.lexico.pop_token()
if is_abre_parenteses(token):
token = self.lexico.pop_token()
if is_identificador(token):
if self.semantico.pesquisa_declvar_tabela(token):
i = self.semantico.get_indice_var(token['token'])
self.semantico.gera(comando='STR', attr1=i)
token = self.lexico.pop_token()
if is_fecha_parenteses(token):
return True
else:
self.mostra_erro('is_fecha_parenteses', token)
else:
self.semantico.mostra_erro('decl_var', token)
else:
self.mostra_erro('is_identificador', token)
else:
self.mostra_erro('is_abre_parenteses', token)
else:
self.mostra_erro('is_leia', token)
def analisa_comando_escrita(self):
print('--analisa_comando_escrita')
token = self.lexico.pop_token()
if is_escreva(token):
token = self.lexico.pop_token()
if is_abre_parenteses(token):
token = self.lexico.pop_token()
if is_identificador(token):
if self.semantico.pesquisa_declvar_tabela(token):
i = self.semantico.get_indice_var(token['token'])
self.semantico.gera(comando='LDV', attr1=i)
self.semantico.gera(comando='PRN')
token = self.lexico.pop_token()
if is_fecha_parenteses(token):
return True
else:
self.mostra_erro('is_fecha_parenteses', token)
else:
self.semantico.mostra_erro('decl_var', token)
else:
self.mostra_erro('is_identificador', token)
else:
self.mostra_erro('is_abre_parenteses', token)
else:
self.mostra_erro('is_escreva', token)
def analisa_expressao(self):
print('--analisa_expressao')
self.expressao_temp = ""
_, return_tipo = self.analisa_expressao_simples()
token = self.lexico.get_token()
if return_tipo == "inteiro":
if is_operador(['>', '>=', '==', '<', '<=', '!='], token):
self.semantico.empilha_operador({
'lexema': token['token'],
'prioridade': 3,
'tipo': 'comparadores'
})
token = self.lexico.pop_token()
_, return_tipo = self.analisa_expressao_simples()
if return_tipo == "inteiro":
self.semantico.desempilha_operador()
return True, 'booleano'
else:
raise self.semantico.mostra_erro('not_boolean', token)
if token['lexema'] != 'sfecha_parenteses':
self.semantico.desempilha_operador()
return True, return_tipo
def analisa_funcao(self):
print('--analisa_funcao')
token = self.lexico.pop_token()
if is_identificador(token):
self.semantico.gera(comando='CALL',
attr1=self.semantico.nivel +
str(self.semantico.rotulo))
return self.semantico.retorna_tipo_especifico(token['token'])
else:
self.mostra_erro('is_identificador', token)
def analisa_expressao_simples(self):
print('--analisa_expressao_simples')
token = self.lexico.get_token()
self.semantico.aux_tipos = []
if is_operador(['+', '-'], token):
token = self.lexico.pop_token()
self.semantico.aux_tipos.append('inteiro')
self.semantico.aux_tipos.append(self.analisa_termo())
token = self.lexico.get_token()
while is_operador(['+', '-', 'ou'], token):
if is_operador(['+', '-'], token):
self.semantico.empilha_operador({
'lexema': token['token'],
'tipo': 'maisMenos',
'prioridade': 0
})
self.semantico.aux_tipos.append('inteiro')
else:
self.semantico.empilha_operador({
'lexema': token['token'],
'tipo': 'ou',
'prioridade': 2
})
self.semantico.aux_tipos.append('booleano')
token = self.lexico.pop_token()
self.semantico.aux_tipos.append(self.analisa_termo())
token = self.lexico.get_token()
return True, self.semantico.aux_tipos[0]
def analisa_termo(self):
print('--analisa_termo')
# flag = False
print('primeiro fator')
# self.semantico.aux_tipos = []
self.semantico.aux_tipos.append(self.analisa_fator())
token = self.lexico.get_token()
while is_operador(['*', 'div', 'e'], token):
if is_operador(['*', 'div'], token):
self.semantico.aux_tipos.append('inteiro')
self.semantico.empilha_operador({
'lexema': token['token'],
'tipo': 'multDiv',
'prioridade': 5
})
else:
self.semantico.aux_tipos.append('booleano')
self.semantico.empilha_operador({
'lexema': token['token'],
'tipo': 'e',
'prioridade': 2
})
self.semantico.verifica_compatibilidade_tipos(token['linha'])
token = self.lexico.pop_token()
print('segundo fator')
self.semantico.aux_tipos.append(self.analisa_fator())
token = self.lexico.get_token()
self.semantico.verifica_compatibilidade_tipos(token['linha'])
return self.semantico.aux_tipos[0]
def analisa_fator(self):
print('--analisa_fator')
token = self.lexico.get_token()
self.expressao_temp += " " + token["token"]
if is_identificador(token):
flag, mem, i = self.semantico.pesquisa_tabela(
token['token'], self.semantico.nivel)
if not flag:
raise self.semantico.mostra_erro('inc_ident', token)
if self.semantico.tabela[i]['tipo_especifico'] == "inteiro":
if self.semantico.tabela[i]['tipo_lexema'] == "variavel":
self.semantico.gera(comando="LDV", attr1=int(mem))
self.lexico.pop_token()
return "inteiro"
else:
return self.analisa_funcao()
else:
if self.semantico.tabela[i]['tipo_lexema'] == "variavel":
self.semantico.gera(comando="LDV", attr1=int(i))
self.lexico.pop_token()
return "booleano"
else:
return self.analisa_funcao()
else:
if is_numero(token):
self.semantico.gera(comando='LDC', attr1=int(token['token']))
self.lexico.pop_token()
return 'inteiro'
else:
if is_nao(token):
self.semantico.empilha_operador({
'lexema': 'nao',
'tipo': 'unarios',
'prioridade': 6
})
self.lexico.pop_token()
return self.analisa_fator()
else:
if is_abre_parenteses(token):
self.semantico.empilha_operador({
'lexema': '(',
'tipo': 'parenteses',
'prioridade': 0
})
self.lexico.pop_token()
_, retorno_expressao = self.analisa_expressao()
token = self.lexico.pop_token()
if is_fecha_parenteses(token):
self.semantico.desempilha_operador()
# token = self.lexico.pop_token()
else:
self.semantico.mostra_erro('fecha_parenteses',
token)
return retorno_expressao
else:
if is_verdadeiro(token):
self.semantico.gera(comando="LDC", attr1=1)
self.lexico.pop_token()
return True, 'booleano'
elif is_falso(token):
self.semantico.gera(comando="LDC", attr1=0)
self.lexico.pop_token()
return True, 'booleano'
else:
self.semantico.mostra_erro('fator_desconhecido',
token)
def __init__(self, top=None):
'''This class configures and populates the toplevel window.
top is the toplevel containing window.'''
_bgcolor = '#d9d9d9' # X11 color: 'gray85'
_fgcolor = '#000000' # X11 color: 'black'
_compcolor = '#d9d9d9' # X11 color: 'gray85'
_ana1color = '#d9d9d9' # X11 color: 'gray85'
_ana2color = '#ececec' # Closest X11 color: 'gray92'
self.lexico = Lexico()
top.geometry("1562x965+310+8")
top.minsize(148, 1)
top.maxsize(4804, 1325)
top.resizable(1, 1)
top.title("Lexico Simulador")
top.configure(background="#d9d9d9")
self.Frame1 = tk.Frame(top)
self.Frame1.place(relx=0.007,
rely=0.01,
relheight=0.058,
relwidth=0.984)
self.Frame1.configure(relief='groove')
self.Frame1.configure(borderwidth="2")
self.Frame1.configure(relief="groove")
self.Frame1.configure(background="#d9d9d9")
self.Frame1.configure(cursor="fleur")
self.title_lexico = tk.Label(self.Frame1)
self.title_lexico.place(relx=0.423, rely=0.179, height=30, width=150)
self.title_lexico.configure(background="#d9d9d9")
self.title_lexico.configure(disabledforeground="#a3a3a3")
self.title_lexico.configure(foreground="#000000")
self.title_lexico.configure(text='''Lexico''')
self.title_lexico.configure(fg="navy blue")
self.title_lexico.configure(font="Helvetica 16 bold")
self.Frame2 = tk.Frame(top)
self.Frame2.place(relx=0.006,
rely=0.073,
relheight=0.821,
relwidth=0.677)
self.Frame2.configure(relief='groove')
self.Frame2.configure(borderwidth="2")
self.Frame2.configure(relief="groove")
self.Frame2.configure(background="#d9d9d9")
self.title_programa = tk.Label(self.Frame2)
self.title_programa.place(relx=0.407, rely=0.013, height=26, width=150)
self.title_programa.configure(background="#d9d9d9")
self.title_programa.configure(disabledforeground="#a3a3a3")
self.title_programa.configure(foreground="#000000")
self.title_programa.configure(text='''Programa''')
self.title_programa.configure(fg="navy blue")
self.title_programa.configure(font="Helvetica 16 bold")
self.Listbox_programa = tk.Listbox(self.Frame2)
self.Listbox_programa.place(relx=0.011,
rely=0.064,
relheight=0.926,
relwidth=0.974)
self.Listbox_programa.configure(background="white")
self.Listbox_programa.configure(disabledforeground="#a3a3a3")
self.Listbox_programa.configure(font="TkFixedFont")
self.Listbox_programa.configure(foreground="#000000")
self.Frame3 = tk.Frame(top)
self.Frame3.place(relx=0.685,
rely=0.073,
relheight=0.818,
relwidth=0.304)
self.Frame3.configure(relief='groove')
self.Frame3.configure(borderwidth="2")
self.Frame3.configure(relief="groove")
self.Frame3.configure(background="#d9d9d9")
self.title_lexema = tk.Label(self.Frame3)
self.title_lexema.place(relx=0.163, rely=0.013, height=26, width=153)
self.title_lexema.configure(background="#d9d9d9")
self.title_lexema.configure(disabledforeground="#a3a3a3")
self.title_lexema.configure(foreground="#000000")
self.title_lexema.configure(text='''Lexema''')
self.title_lexema.configure(fg="navy blue")
self.title_lexema.configure(font="Helvetica 16 bold")
self.title_simbolo = tk.Label(self.Frame3)
self.title_simbolo.place(relx=0.470, rely=0.013, height=26, width=197)
self.title_simbolo.configure(background="#d9d9d9")
self.title_simbolo.configure(disabledforeground="#a3a3a3")
self.title_simbolo.configure(foreground="#000000")
self.title_simbolo.configure(text='''Simbolo''')
self.title_simbolo.configure(fg="navy blue")
self.title_simbolo.configure(font="Helvetica 16 bold")
self.Listbox_lexema = tk.Listbox(self.Frame3)
self.Listbox_lexema.place(relx=0.147,
rely=0.063,
relheight=0.925,
relwidth=0.358)
self.Listbox_lexema.configure(background="white")
self.Listbox_lexema.configure(disabledforeground="#a3a3a3")
self.Listbox_lexema.configure(font="TkFixedFont")
self.Listbox_lexema.configure(foreground="#000000")
self.Listbox_lexema.bind("<MouseWheel>", self.OnMouseWheel)
self.Listbox_simbolo = tk.Listbox(self.Frame3)
self.Listbox_simbolo.place(relx=0.505,
rely=0.063,
relheight=0.924,
relwidth=0.358)
self.Listbox_simbolo.configure(background="white")
self.Listbox_simbolo.configure(disabledforeground="#a3a3a3")
self.Listbox_simbolo.configure(font="TkFixedFont")
self.Listbox_simbolo.configure(foreground="#000000")
self.Listbox_simbolo.bind("<MouseWheel>", self.OnMouseWheel)
self.Button_carregar = tk.Button(top)
self.Button_carregar.place(relx=0.09, rely=0.912, height=53, width=216)
self.Button_carregar.configure(activebackground="#ececec")
self.Button_carregar.configure(activeforeground="#000000")
self.Button_carregar.configure(background="#d9d9d9")
self.Button_carregar.configure(disabledforeground="#a3a3a3")
self.Button_carregar.configure(foreground="#000000")
self.Button_carregar.configure(highlightbackground="#d9d9d9")
self.Button_carregar.configure(highlightcolor="black")
self.Button_carregar.configure(pady="0")
self.Button_carregar.configure(text='''CARREGAR''')
self.Button_carregar.configure(fg="black")
self.Button_carregar.configure(font="Arial 12")
self.Button_carregar.configure(command=self.le_arquivo)
self.Button_run = tk.Button(top)
self.Button_run.place(relx=0.237, rely=0.912, height=53, width=216)
self.Button_run.configure(activebackground="#ececec")
self.Button_run.configure(activeforeground="#000000")
self.Button_run.configure(background="#d9d9d9")
self.Button_run.configure(disabledforeground="#a3a3a3")
self.Button_run.configure(foreground="#000000")
self.Button_run.configure(highlightbackground="#d9d9d9")
self.Button_run.configure(highlightcolor="black")
self.Button_run.configure(pady="0")
self.Button_run.configure(text='''RUN''')
self.Button_run.configure(fg="black")
self.Button_run.configure(font="Arial 12")
self.Button_run.configure(command=self.inicia_lexico)
def ejercicio1():
tablaLR = {(0,Lexico._tiposInt['IDENTIFICADOR']): 2,
(0,3): 1,
(1,Lexico._tiposInt['$']): -1,
(2,Lexico._tiposInt['OPSUMA']): 3,
(3,Lexico._tiposInt['IDENTIFICADOR']): 4,
(4,Lexico._tiposInt['$']): -2}
#Preparar la pila
pila = Pila()
fila = 0
columna = 0
accion = 0
aceptacion = 0
#Establecer la cadena de entrada
lexico = Lexico("a+b")
#Adecuar la pila
pila.push(Lexico._tiposInt['$'])
pila.push(0);
#solicitar el simbolo al Lexico "a"
lexico.sigSimbolo()
#verificar si el simbolo en pila.top() tiene un desplazamiento o transicion con
#respecto a lexico.tipo conforme a la tablaLR
fila = pila.top()
columna = lexico.tipo
accion = tablaLR.get((fila,columna), 0)
#sabemos que la accion va a ser d2, o sea accion = 2, numero positivo,
#indica transicion o desplazamiento, entonces apilamos estos valores.
pila.push(lexico.tipo)
pila.push(accion)
#Mostrar el progreso del algoritmo
print()
pila.muestra()
print()
#pedimos el siguiente simbolo "+"
lexico.sigSimbolo()
#verificar accion
fila = pila.top()
columna = lexico.tipo
accion = tablaLR.get((fila,columna), 0)
#sabemos que nos dara el desplazamiento 3; accion = 3, entonces apilamos
pila.push(lexico.tipo)
pila.push(accion)
print()
pila.muestra()
print()
#pedimos el siguiente simbolo "b"
lexico.sigSimbolo()
#verificar accion
fila = pila.top()
columna = lexico.tipo
accion = tablaLR.get((fila,columna), 0)
#sabemos que nos dara el desplazamiento 4; accion = 4, entonces apilamos
pila.push(lexico.tipo)
pila.push(accion)
print()
pila.muestra()
print()
#pedimos el siguiente simbolo "$" (llegamos al final de la entrada)
lexico.sigSimbolo()
#verificar accion
fila = pila.top()
columna = lexico.tipo
accion = tablaLR.get((fila,columna), 0)
#sabemos que nos dara la transicion -2; accion = -2, entonces -desapilamos-
#Desapilaremos el doble del tamaño de la regla, la regla es E-> <id>+<id>
#la longitud seria 3, nosotros desapilaremos 6 elementos.
pila.pop()
pila.pop()
pila.pop()
pila.pop()
pila.pop()
pila.pop()
print()
pila.muestra()
print()
#continuamos sin pedir el siguiente simbolo, debido a que la ultima accion fue
#una reduccion, verificamos que accion sigue
fila = pila.top() #seria 0
columna = 3 #nos quedamos en la columna 3, donde esta la regla en la matriz
accion = tablaLR.get((fila,columna), 0)
print()
pila.muestra()
print()
#la accion resulta ser una transicion, entonces apilamos
pila.push(3)#la representacion de la regla E en la matriz
pila.push(accion)
print()
pila.muestra()
print()
#Como lo anterior fue una transicion, continuamos sin solicitar nuevo simbolo
fila = pila.top()
print("fila:",fila)
columna = lexico.tipo
print("columna:",columna)
accion = tablaLR.get((fila,columna),0)
print("accion: ",accion)
print()
pila.muestra()
print()
#la accion resulta ser -1, es decir, aceptacion.abs
aceptacion = accion == -1
if aceptacion:
print("Aceptado")
def ejemplo3():
print()
tablaLR = {(0,Lexico._tiposInt['IDENTIFICADOR']): 2,
(0,2): 1,
(1,Lexico._tiposInt['$']): -1,
(2,Lexico._tiposInt['$']): -2}
#Preparar la pila
pila = Pila()
fila = 0
columna = 0
accion = 0
aceptacion = 0
lexico = Lexico("a")
pila.push(Lexico._tiposInt['$'])
pila.push(0);
lexico.sigSimbolo()
#para saber que accion realizar
fila = pila.top()
columna = lexico.tipo
accion = tablaLR.get((fila,columna), 0)
#mostrar lo que esta sucediendo
print ("pila: ", end = " ")
pila.muestra()
print ()
print ("lex.tipo: ", lexico.tipo)
print ("accion: ", accion)
pila.push (lexico.tipo)
pila.push (accion)
print (lexico.sigSimbolo())
print (lexico.tipo)
fila = pila.top()
print("fila:", fila, "pilaTop:", pila.top())
columna = lexico.tipo
print("columna:", columna, "l.tipo:", lexico.tipo)
accion = tablaLR.get((fila,columna), 0)
print("Futari:",tablaLR.get((fila,columna), 0))
pila.muestra()
print()
print ("entrada: ", lexico.simbolo)
print ("accion: ", accion)
pila.pop()
pila.pop()
fila = pila.top()
columna = 2
accion = tablaLR.get((fila,columna), 0)
#transicion
pila.push(2)
pila.push(accion)
pila.muestra()
print()
print("entrada: ", lexico.simbolo)
print("accion: ", accion)
fila = pila.top()
columna = lexico.tipo
accion = tablaLR.get((fila,columna), 0)
pila.muestra()
print()
print("entrada: ", lexico.simbolo)
print("accion: ", accion)
print()
aceptacion = accion == -1;
if aceptacion:
print("aceptacion")
def ejemplo2():
lexico = Lexico("+-+")
while not lexico.terminado():
lexico.sigSimbolo()
print (lexico.simbolo)
class Sintatico:
# TABELA DOS FOLLOWS DE CADA FUNÇÃO:
FOLLOW_A = [tt.FIMARQ]
FOLLOW_PROG = [tt.FIMARQ[0]]
FOLLOW_DECLS = [tt.OPABREC[0], tt.FIMARQ[0]]
FOLLOW_LIST_DECLS = [tt.OPABREC[0], tt.OPPV[0], tt.FIMARQ[0]]
FOLLOW_D = [tt.OPABREC[0], tt.FIMARQ[0]]
FOLLOW_DECL_TIPO = [tt.OPABREC[0], tt.IDENT[0], tt.FIMARQ[0]]
FOLLOW_LIST_ID = [tt.DPONTOS[0], tt.OPFECHAP[0], tt.FIMARQ[0]]
FOLLOW_E = [tt.DPONTOS[0], tt.OPFECHAP[0], tt.FIMARQ[0]]
FOLLOW_TIPO = [tt.OPPV[0], tt.FIMARQ[0]]
FOLLOW_C_COMP = [
tt.WHILE[0], tt.WRITE[0], tt.OPFECHAC[0], tt.IDENT[0], tt.READ[0],
tt.SE[0], tt.SENAO[0], tt.FIMARQ[0]
]
FOLLOW_LISTA_COMANDOS = [tt.OPFECHAC[0], tt.FIMARQ[0]]
FOLLOW_G = [tt.OPFECHAC, tt.FIMARQ[0]]
FOLLOW_COMANDOS = [
tt.FIMARQ[0], tt.WHILE[0], tt.WRITE[0], tt.OPFECHAP[0], tt.IDENT[0],
tt.READ[0], tt.SE[0]
]
FOLLOW_IF = [
tt.FIMARQ[0], tt.WHILE[0], tt.WRITE[0], tt.OPFECHAP[0], tt.IDENT[0],
tt.READ[0], tt.SE[0]
]
FOLLOW_H = [
tt.FIMARQ[0], tt.WHILE[0], tt.WRITE[0], tt.OPFECHAP[0], tt.IDENT[0],
tt.READ[0], tt.SE[0]
]
FOLLOW_WHILE = [
tt.FIMARQ[0], tt.WHILE[0], tt.WRITE[0], tt.OPFECHAP[0], tt.IDENT[0],
tt.READ[0], tt.SE[0]
]
FOLLOW_READ = [
tt.FIMARQ[0], tt.WHILE[0], tt.WRITE[0], tt.OPFECHAP[0], tt.IDENT[0],
tt.READ[0], tt.SE[0]
]
FOLLOW_ATRIB = [
tt.FIMARQ[0], tt.WHILE[0], tt.WRITE[0], tt.OPFECHAP[0], tt.IDENT[0],
tt.READ[0], tt.SE[0]
]
FOLLOW_WRITE = [
tt.FIMARQ[0], tt.WHILE[0], tt.WRITE[0], tt.OPFECHAP[0], tt.IDENT[0],
tt.READ[0], tt.SE[0]
]
FOLLOW_ELEM_W = [tt.FIMARQ[0], tt.OPFECHAP[0], tt.OPVIRG[0]]
FOLLOW_P = [tt.FIMARQ[0], tt.OPFECHAP[0], tt.OPVIRG[0], tt.OPPV[0]]
FOLLOW_R = [tt.FIMARQ[0], tt.OPFECHAP[0], tt.OPVIRG[0], tt.OPPV[0]]
FOLLOW_S = [tt.FIMARQ[0], tt.OPFECHAP[0], tt.OPVIRG[0], tt.OPPV[0]]
FOLLOW_FAT = [tt.FIMARQ[0], tt.OPMAIS[0], tt.OPMULT[0]]
# CONSTRUTOR DA CLASSE SINTATICO.
def __init__(self, nomeArquivo):
self.lex = None # LEXICO COMEÇA VAZIO.
self.tokenAtual = None # COMEÇA COM O TOKEN ESCOLHIDO VAZIO.
self.compiladoSucesso = [
True, 0
] # COMEÇA COM O RESULTADO DA COMPILAÇÃO REALIZADA COM SUCESSO.
self.vetTabela = [] # COMEÇA COM O VETOR VAZIO NA TABELA DE SIMBOLOS.
self.nomeArquivo = nomeArquivo # RECEBE O NOME DO ARQUIVO POR MEIO DE PARAMETRO.
# FUNÇÃO PARA ABRIR O ARQUIVO E COMECAR A COMPILAÇÃO.
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() # ABRE O ARQUIVO PASSADO POR PARAMETRO.
self.tokenAtual = self.lex.getToken(
) # A FUNÇÃO "getToken" PEGA UM TOKEN DO LEXICO
# PARA MINHA VARIAVEL CHAMADA "tokenAtual".
self.A()
# FUNÇÃO QUE REALIZA O PROCESSO FINAL DA COMPILAÇÃO.
def finalArquivo(self, nome):
param = sys.argv
if self.compiladoSucesso == [
True, 0
]: # SE A TUPLA DA VARIAVEL "compiladoSucesso" FOR "True, 0".
# MOSTRA QUE COMPILAÇÃO FOI COM SUCESSO E QUE NÃO MOSTROU NENHUMA VEZ A MENSAGEM DO RESULTADO DE COMPILAÇÃO.
print('Compilado com Sucesso !.')
if param[
1] == '-t': # CASO TENHA PEDIDO PARA MOSTRAR A TABELA DE SIMBOLOS.
self.printTabela(
nome) # A FUNÇÃO DA PRINT DA TABELA NO TERMINAL.
self.compiladoSucesso = [True]
elif self.compiladoSucesso == [
False, 0
]: # SE A TUPLA DA VARIAVEL "compiladoSucesso" FOR "Falsa, 0"
# MOSTRA QUE COMPILAÇÃO FOI COM FALHA E QUE NÃO MOSTROU NENHUMA VEZ A MENSAGEM DO RESULTADO DE COMPILAÇÃO.
print('Falha na Compilacao !.')
if param[
1] == '-t': # CASO TENHA PEDIDO PARA MOSTRAR A TABELA DE SIMBOLOS.
self.printTabela(
nome) # A FUNÇÃO DA PRINT DA TABELA NO TERMINAL.
self.compiladoSucesso = [False]
quit(0) # DA UM QUIT NO CODIGO, DESEMPILANDO.
# FUNÇÃO QUE FAZ A COMPARAÇÃO DO TOKEN ATUAL PELO ESPERADA.
def atualIgual(self, token):
(classe, desc, id) = token # PEGA O TOKEN ATUAL E COLOCA NUMA TUPLA.
return self.tokenAtual.classe == classe # COMPARA A VARIAVEL CLASSE DA TUPLA COM A CLASSE QUE É ESPERADA PELA LINGUAGEM.
# FUNÇÃO QUE CONSOME O TOKEN ATUAL E PEGA O PROXIMO TOKEN, CASO CONTRARIO ENTRA NO MODO PANICO.
def consome(self, token):
if self.atualIgual(
token
): # SE O TOKEN PEGADO FOR O ESPERADO ENTÃO PEGA O PROXIMO TOKEN.
if self.tokenAtual.classe == tt.IDENT[0]:
self.vetTabela.append(
self.tokenAtual.lexema
) # ADICIONA O "id" NO VETOR DA TABELA DE SIMBOLOS.
self.tokenAtual = self.lex.getToken()
else: # CASO CONTRARIO ELE INFORMA NO TERMINAL UMA MENSAGEM DE ERRO E ATIVA O MODO PANICO.
self.mensagemERRO(token)
self.modoPanico()
# FUNÇÃO QUE MOSTRA OS ERROS NO TERMINAL.
def mensagemERRO(self, token):
(classe, desc, id) = token # PEGA O TOKEN ATUAL E COLOCA NUMA TUPLA.
self.compiladoSucesso = [
False, 0
] # NA VARIAVEL "compiladoSucesso" COLOCA "False" INFORMANDO QUE A COMPILAÇÃO FALHOU.
print('ERRO DE SINTAXE [linha %d]: era esperado "%s" mas veio "%s"' %
(self.tokenAtual.linha, desc,
self.tokenAtual.lexema)) # DA UM PRINT DE ERRO NO TEMINAL.
# FUNÇÃO QUE ENTRA NO FOLLOW
def modoPanico(self):
self.tokenAtual = self.lex.getToken() # PEGA O PROXIMO TOKEN.
raise Exception("") # ENTRA NO EXCEPTION DA FUNÇÃO QUE ESTAVA.
# A PRIMEIRA FUNÇÃO DA GRAMATICA.
def A(self):
self.PROG() # FUNÇÃO QUE COMEÇA A CONSUMIR OS TOKENS DO TXT.
self.lex.fechaArquivo() # FECHA O ARQUIVO QUE ESTAVA SENDO LIDO.
self.finalArquivo(self.nomeArquivo)
# FUNÇÃO QUE VERIFICA SE O INICIO DO CODIGO ESTA CORRETO PARA DEPOIS ENTRAR NA DECLARAÇAO DE VARIAVEIS E DEPOIS NO CORPO DO CODIGO.
def PROG(self):
try:
self.consome(tt.PROGRAMA) # CONSOME O TOKEN "programa".
self.consome(tt.IDENT) # CONSOME O TOKEN "id".
self.consome(tt.OPPV) # CONSOME O TOKEN ";".
self.DECLS()
self.C_COMP()
except:
self.get_FOLLOW_PROG()
# FUNÇAO QUE PEGA O FOLLOW DE PROG.
def get_FOLLOW_PROG(self):
if self.tokenAtual.classe in self.FOLLOW_PROG: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPPV[
0]: # VERIFICA E CONSOME O TOKEN ";" E CONTINUA A GRAMATICA.
self.consome(tt.OPPV)
self.DECLS()
self.C_COMP()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_PROG()
# FUNÇÃO QUE INICIA A DECLARAÇÃO DE VARIAVEIS.
def DECLS(self):
try:
if self.atualIgual(
tt.VARIAVEL
): # VERIFICA SE O TOKEN É "variavel" CASO SEJA CONSOME O TOKEN
self.consome(tt.VARIAVEL)
self.LIST_DECLS()
else:
pass
except:
self.get_FOLLOW_DECLS()
# FUNÇÃO QUE PEGA O FOLLOW DE DECLS
def get_FOLLOW_DECLS(self):
if self.tokenAtual.classe in self.FOLLOW_DECLS: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPABREC[
0]: # VERIFICA SE TOKEN É "{" E CONTINUA A GRAMATICA.
self.C_COMP()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_DECLS()
# VAI COMEÇAR A PEGAR OS ID E SEUS TIPOS
def LIST_DECLS(self):
try:
self.DECL_TIPO()
self.D()
except:
self.get_FOLLOW_LIST_DECLS()
# FUNÇÃO QUE PEGA O FOLLOW DE LIST_DECLS
def get_FOLLOW_LIST_DECLS(self):
if self.tokenAtual.classe in self.FOLLOW_LIST_DECLS: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPABREC[
0]: # VERIFICA SE TOKEN É "{" E CONTINUA A GRAMATICA.
self.C_COMP()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_LIST_DECLS()
# FUNÇÃO QUE VERIFICA SE O TOKEN E ID
def D(self):
try:
if self.atualIgual(
tt.IDENT): # VERIFICA SE EXISTE MAIS UM ID COMO VARIAVEL
self.LIST_DECLS()
else: # CASO CONTRARIO ACABOU AS DECLARAÇÕES DE VARIAVEIS
pass
except:
self.get_FOLLOW_D()
# FUNÇÃO QUE PEGA O FOLLOW DE D
def get_FOLLOW_D(self):
if self.tokenAtual.classe in self.FOLLOW_D: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPABREC[
0]: # VERIFICA SE TOKEN É "{" E CONTINUA A GRAMATICA.
self.C_COMP()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_D()
# FUNÇÃO QUE MONTA A FORMA CERTA DA LINGUAGEM
def DECL_TIPO(self):
try:
self.LIST_ID() # PEGA A ID DA VARIAVEL.
self.consome(tt.DPONTOS) # CONSOME O TOKEN ":".
self.TIPO() # PEGA O TIPO DA ID ACIMA.
self.consome(tt.OPPV) # CONSOME O TOKEN ";".
except:
self.get_FOLLOW_DECL_TIPO()
# FUNÇÃO QUE PEGA O FOLLOW DE DECL_TIPO
def get_FOLLOW_DECL_TIPO(self):
if self.tokenAtual.classe in self.FOLLOW_DECL_TIPO: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPABREC[
0]: # VERIFICA SE TOKEN É "{" E CONTINUA A GRAMATICA.
self.C_COMP()
elif self.tokenAtual.classe == tt.IDENT[
0]: # VERIFICA SE TOKEN É DA CLASSE "id" E CONTINUA A GRAMATICA.
self.DECL_TIPO()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_DECL_TIPO()
# FUNÇÃO QUE CONSOME E COLOCA NA TABELA O ID.
def LIST_ID(self):
try:
self.consome(tt.IDENT) # CONSOME O TOKEN "id".
self.E(
) # FUNÇÃO PARA VERIFICAR SE EXISTE "," PARA COLOCAR OUTRO "id" COM O MESMO TIPO.
except:
self.get_FOLLOW_LIST_ID()
# FUNÇÃO QUE PEGA O FOLLOW DE LIST_ID
def get_FOLLOW_LIST_ID(self):
if self.tokenAtual.classe in self.FOLLOW_LIST_ID: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.DPONTOS[
0]: # VERIFICA SE TOKEN É ":" E CONTINUA A GRAMATICA.
return
elif self.tokenAtual.classe == tt.OPFECHAP[
0]: # VERIFICA SE TOKEN É DA CLASSE ")" E CONSOME O TOKEN.
self.consome(tt.OPFECHAP)
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_LIST_ID()
# FUNÇÃO QUE VERIFICA SE POSSUI "," DEPOIS DO ID.
def E(self):
if self.atualIgual(
tt.OPVIRG): # VERIFICA SE O TOKEN É "," E CONSOME O TOKEN.
self.consome(tt.OPVIRG)
self.LIST_ID()
# FUNÇÃO QUE VERIFICA, CONSOME E COLOCA NA TABELA O TIPO DO ID.
def TIPO(self):
try: # VERIFICA QUAL É O TIPO DO "id" E ADICIONA NA TABELA RELACIONANDO AO "id" E CONSOME O TOKEN.
if self.atualIgual(tt.INTEIRO):
self.vetTabela.append(
[self.tokenAtual.classe, self.tokenAtual.linha])
self.consome(tt.INTEIRO)
elif self.atualIgual(tt.REAL):
self.vetTabela.append(
[self.tokenAtual.classe, self.tokenAtual.linha])
self.consome(tt.REAL)
elif self.atualIgual(tt.LOGICO):
self.vetTabela.append(
[self.tokenAtual.classe, self.tokenAtual.linha])
self.consome(tt.LOGICO)
elif self.atualIgual(tt.CARACTER):
self.vetTabela.append(
[self.tokenAtual.classe, self.tokenAtual.linha])
self.consome(tt.CARACTER)
else: # CASO NÃO SEJA NENHUM, LISTA TODAS AS POSSIBILIDADES PARA COMPILAR COM SUCESSO NO TERMINAL.
self.mensagemERRO(tt.INTEIRO)
self.mensagemERRO(tt.REAL)
self.mensagemERRO(tt.LOGICO)
self.mensagemERRO(tt.CARACTER)
# E ENTRA NO MODOPANICO PARA ENTRAR NO EXCEPTION.
self.modoPanico()
except:
self.get_FOLLOW_TIPO()
# FUNÇÃO QUE PEGA O FOLLOW DE TIPO
def get_FOLLOW_TIPO(self):
if self.tokenAtual.classe in self.FOLLOW_LIST_ID: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPPV[0]:
self.consome(tt.OPPV)
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_TIPO()
# FUNÇÃO QUE INICIA O CORPO DO CODIGO DEPOIS DAS VARIAVEIS.
def C_COMP(self):
try:
self.consome(tt.OPABREC) # CONSOME O TOKEN "{".
self.LISTA_COMANDOS(
) # FUNÇÃO QUE INICIA O CORPO DO CODIGO DEPOIS DE DECLARAR AS VARIAVEIS.
self.consome(tt.OPFECHAC) # CONSOME O TOKEN "}".
except:
self.get_FOLLOW_C_COMP()
# FUNÇÃO QUE PEGA O FOLLOW DE C_COMP
def get_FOLLOW_C_COMP(self):
if self.tokenAtual.classe in self.FOLLOW_C_COMP: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.WHILE[
0]: # VERIFICA SE TOKEN É "while" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.WRITE[
0]: # VERIFICA SE TOKEN É "write" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.IDENT[
0]: # VERIFICA SE TOKEN É DA CLASSE "id" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.READ[
0]: # VERIFICA SE TOKEN É "read" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.SE[
0]: # VERIFICA SE TOKEN É "if" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_C_COMP()
def LISTA_COMANDOS(self):
self.COMANDOS()
self.G()
# FUNÇÃO QUE DECIDE O QUE VAI FAZER DE ACORDO COM TOKEN.
def G(self):
# CONFERE SE O TOKEN CORRESPONDE A ALGUM DOS TOKENS ESPERADOS.
if self.atualIgual(tt.SE):
self.LISTA_COMANDOS()
elif self.atualIgual(tt.WHILE):
self.LISTA_COMANDOS()
elif self.atualIgual(tt.READ):
self.LISTA_COMANDOS()
elif self.atualIgual(tt.WRITE):
self.LISTA_COMANDOS()
elif self.atualIgual(tt.IDENT):
self.LISTA_COMANDOS()
else:
pass
# FUNÇÃO QUE DECIDE O QUE VAI FAZER DE ACORDO COM TOKEN.
def COMANDOS(self):
try: # CONFERE SE O TOKEN CORRESPONDE A ALGUM DOS TOKENS ESPERADOS, E CONTINUA A GRAMATICA.
if self.atualIgual(tt.SE):
self.IF()
elif self.atualIgual(tt.WHILE):
self.WHILE()
elif self.atualIgual(tt.READ):
self.READ()
elif self.atualIgual(tt.WRITE):
self.WRITE()
elif self.atualIgual(tt.IDENT):
self.ATRIB()
else:
# CASO NÃO SEJA NENHUM, LISTA TODAS AS POSSIBILIDADES PARA COMPILAR COM SUCESSO NO TERMINAL.
self.mensagemERRO(tt.SE)
self.mensagemERRO(tt.WHILE)
self.mensagemERRO(tt.READ)
self.mensagemERRO(tt.WRITE)
self.mensagemERRO(tt.IDENT)
# E ENTRA NO MODOPANICO PARA ENTRAR NO EXCEPTION.
self.modoPanico()
except:
self.get_FOLLOW_COMANDOS()
# FUNÇÃO QUE PEGA O FOLLOW DE COMANDOS
def get_FOLLOW_COMANDOS(self):
if self.tokenAtual.classe in self.FOLLOW_COMANDOS: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.WHILE[
0]: # VERIFICA SE TOKEN É "while" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.WRITE[
0]: # VERIFICA SE TOKEN É "write" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.IDENT[
0]: # VERIFICA SE TOKEN É "id" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.READ[
0]: # VERIFICA SE TOKEN É "read" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.SE[
0]: # VERIFICA SE TOKEN É "if" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_COMANDOS()
# FUNÇÃO PARA REALIZAR UM IF CASO O TOKEN FOR UM SE
def IF(self):
try:
self.consome(tt.SE) # CONSOME O TOKEN "if".
self.consome(tt.OPABREP) # CONSOME O TOKEN "(".
self.EXPR()
self.consome(tt.OPFECHAP) # CONSOME O TOKEN ")".
self.C_COMP()
self.H()
except:
self.get_FOLLOW_IF()
# FUNÇÃO QUE PEGA O FOLLOW DE SE
def get_FOLLOW_IF(self):
if self.tokenAtual.classe in self.FOLLOW_IF: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.WHILE[
0]: # VERIFICA SE TOKEN É "while" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.WRITE[
0]: # VERIFICA SE TOKEN É "write" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.IDENT[
0]: # VERIFICA SE TOKEN É "id" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.READ[
0]: # VERIFICA SE TOKEN É "read" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.SE[
0]: # VERIFICA SE TOKEN É "if" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_IF()
# FUNÇÃO PARA REALIZAR UM ELSE CASO O TOKEN FOR UM SENAO.
def H(self):
try:
if self.atualIgual(tt.SENAO): # VERIFICA E CONSOME O TOKEN "else".
self.consome(tt.SENAO)
self.C_COMP()
else:
pass
except:
self.get_FOLLOW_H()
# FUNÇÃO QUE PEGA O FOLLOW DE H
def get_FOLLOW_H(self):
if self.tokenAtual.classe in self.FOLLOW_H: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.WHILE[
0]: # VERIFICA SE TOKEN É "while" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.WRITE[
0]: # VERIFICA SE TOKEN É "write" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.IDENT[
0]: # VERIFICA SE TOKEN É "id" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.READ[
0]: # VERIFICA SE TOKEN É "read" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.SE[
0]: # VERIFICA SE TOKEN É "if" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_H()
# FUNÇÃO PARA REALIZAR UM WHILE CASO O TOKEN FOR UM ENQUANTO.
def WHILE(self):
try:
self.consome(tt.WHILE) # CONSOME O TOKEN "while".
self.consome(tt.OPABREP) # CONSOME O TOKEN "(".
self.EXPR()
self.consome(tt.OPFECHAP) # CONSOME O TOKEN ")".
self.C_COMP()
except:
self.get_FOLLOW_WHILE()
# FUNÇÃO QUE PEGA O FOLLOW DE WHILE
def get_FOLLOW_WHILE(self):
if self.tokenAtual.classe in self.FOLLOW_WHILE: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.WHILE[
0]: # VERIFICA SE TOKEN É "while" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.WRITE[
0]: # VERIFICA SE TOKEN É "write" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.IDENT[
0]: # VERIFICA SE TOKEN É "id" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.READ[
0]: # VERIFICA SE TOKEN É "read" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.SE[
0]: # VERIFICA SE TOKEN É "if" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_WHILE()
# FUNÇÃO PARA REALIZAR UM READ CASO O TOKEN FOR UM LEIA
def READ(self):
try:
self.consome(tt.READ) # CONSOME O TOKEN "read".
self.consome(tt.OPABREP) # CONSOME O TOKEN "(".
self.LIST_ID()
self.consome(tt.OPFECHAP) # CONSOME O TOKEN ")".
self.consome(tt.OPPV) # CONSOME O TOKEN ";".
except:
self.get_FOLLOW_READ()
# FUNÇÃO QUE PEGA O FOLLOW DE READ
def get_FOLLOW_READ(self):
if self.tokenAtual.classe in self.FOLLOW_READ: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.WHILE[
0]: # VERIFICA SE TOKEN É "while" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.WRITE[
0]: # VERIFICA SE TOKEN É "write" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.IDENT[
0]: # VERIFICA SE TOKEN É "id" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.READ[
0]: # VERIFICA SE TOKEN É "read" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.SE[
0]: # VERIFICA SE TOKEN É "if" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_READ()
# FUNÇÃO QUE PEGA UMA ATRIBUIÇÃO NO CODIGO.
def ATRIB(self):
try:
self.consome(tt.IDENT) # CONSOME O TOKEN "id".
self.consome(tt.ATRIB) # CONSOME O TOKEN ":=".
self.EXPR()
self.consome(tt.OPPV) # CONSOME O TOKEN ";".
except:
self.get_FOLLOW_ATRIB()
# FUNÇÃO QUE PEGA O FOLLOW DE ATRIB
def get_FOLLOW_ATRIB(self):
if self.tokenAtual.classe in self.FOLLOW_ATRIB: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.WHILE[
0]: # VERIFICA SE TOKEN É "while" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.WRITE[
0]: # VERIFICA SE TOKEN É "write" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.IDENT[
0]: # VERIFICA SE TOKEN É "id" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.READ[
0]: # VERIFICA SE TOKEN É "read" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.SE[
0]: # VERIFICA SE TOKEN É "if" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_ATRIB()
# FUNÇÃO PARA REALIZAR UM WRITE CASO O TOKEN FOR UM ESCREVA.
def WRITE(self):
try:
self.consome(tt.WRITE) # CONSOME O TOKEN "write".
self.consome(tt.OPABREP) # CONSOME O TOKEN "(".
self.LIST_W()
self.consome(tt.OPFECHAP) # CONSOME O TOKEN ")".
self.consome(tt.OPPV) # CONSOME O TOKEN ";".
except:
self.get_FOLLOW_WRITE()
# FUNÇÃO QUE PEGA O FOLLOW DE WRITE
def get_FOLLOW_WRITE(self):
if self.tokenAtual.classe in self.FOLLOW_WRITE: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.WHILE[
0]: # VERIFICA SE TOKEN É "while" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.WRITE[
0]: # VERIFICA SE TOKEN É "write" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.IDENT[
0]: # VERIFICA SE TOKEN É "id" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.READ[
0]: # VERIFICA SE TOKEN É "read" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.SE[
0]: # VERIFICA SE TOKEN É "if" E CONTINUA A GRAMATICA.
self.LISTA_COMANDOS()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_WRITE()
# FUNÇÃO QUE OLHA O QUE TEM DENTRO DE UM WRITE.
def LIST_W(self):
self.ELEM_W()
self.L()
def L(self):
if self.atualIgual(
tt.OPVIRG
): # VERIFICA SE PEGOU O TOKEN "else" E CONSOME O TOKEN.
self.consome(tt.OPVIRG)
self.LIST_W()
else:
pass
# FUNÇÃO QUE OLHA SE O WRITE POSSUI UMA CADEIA DE CARACTER OU UMA EXPPRESSÃO.
def ELEM_W(self):
try:
if self.atualIgual(
tt.CADCARACTER
): # VERIFICA SE PEGOU O TOKEN "cadeia de caracter" E CONSOME O TOKEN.
self.consome(tt.CADCARACTER)
else:
self.EXPR(
) # CASO NAO SEJA UMA CADEIA DE CARACTER ELE ENTRA NA FUNÇÃO DE EXPRESSOES.
except:
self.get_FOLLOW_ELEM_W()
# FUNÇÃO QUE PEGA O FOLLOW DE ELEM_W
def get_FOLLOW_ELEM_W(self):
if self.tokenAtual.classe in self.FOLLOW_ELEM_W: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPFECHAP[
0]: # VERIFICA SE TOKEN É ")" E CONTINUA A GRAMATICA.
self.consome(tt.OPFECHAP)
elif self.tokenAtual.classe == tt.OPPV[
0]: # VERIFICA SE TOKEN É ";" E CONTINUA A GRAMATICA.
self.consome(tt.OPPV)
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_ELEM_W()
# FUNÇÃO QUE LE A EXPRESSAO DO CODIGO.
def EXPR(self):
self.SIMPLES()
self.P()
# FUNÇÃO QUE VERIFICA E CONSOME SIMBOLOS MATEMATICOS.
def P(self):
try:
if self.atualIgual(tt.OPIGUAL):
self.consome(tt.OPIGUAL)
self.SIMPLES()
elif self.atualIgual(tt.OPMENOR):
self.consome(tt.OPMENOR)
self.SIMPLES()
elif self.atualIgual(tt.OPMAIOR):
self.consome(tt.OPMAIOR)
self.SIMPLES()
elif self.atualIgual(tt.OPMENORI):
self.consome(tt.OPMENORI)
self.SIMPLES()
elif self.atualIgual(tt.OPMAIORI):
self.consome(tt.OPMAIORI)
self.SIMPLES()
elif self.atualIgual(tt.OPDIF):
self.consome(tt.OPDIF)
self.SIMPLES()
else:
pass
except:
self.get_FOLLOW_P()
# FUNÇÃO QUE PEGA O FOLLOW DE P
def get_FOLLOW_P(self):
if self.tokenAtual.classe in self.FOLLOW_P: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPFECHAP[
0]: # VERIFICA SE TOKEN É ")" E CONTINUA A GRAMATICA.
self.FAT()
elif self.tokenAtual.classe == tt.OPPV[
0]: # VERIFICA SE TOKEN É ";" E CONTINUA A GRAMATICA.
self.consome(tt.OPPV)
elif self.tokenAtual.classe == tt.OPVIRG[
0]: # VERIFICA SE TOKEN É "," E CONTINUA A GRAMATICA.
self.consome(tt.OPPV)
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_P()
def SIMPLES(self):
self.TERMO()
self.R()
# FUNÇÃO QUE CONSOME OS TOKENS IGUALDADE E DESIGUALDADE ENTRE CONSTANTES E ID.
def R(self):
try:
if self.atualIgual(tt.OPMAIS):
self.consome(tt.OPMAIS)
self.SIMPLES()
elif self.atualIgual(tt.OPMENOS):
self.consome(tt.OPMENOS)
self.SIMPLES()
else:
pass
except:
self.get_FOLLOW_R()
# FUNÇÃO QUE PEGA O FOLLOW DE R
def get_FOLLOW_R(self):
if self.tokenAtual.classe in self.FOLLOW_R: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPFECHAP[
0]: # VERIFICA SE TOKEN É ")" E CONTINUA A GRAMATICA.
self.FAT()
elif self.tokenAtual.classe == tt.OPPV[
0]: # VERIFICA SE TOKEN É ";" E CONTINUA A GRAMATICA.
self.consome(tt.OPPV)
elif self.tokenAtual.classe == tt.OPVIRG[
0]: # VERIFICA SE TOKEN É "," E CONTINUA A GRAMATICA.
self.consome(tt.OPPV)
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_R()
def TERMO(self):
self.FAT()
self.S()
# FUNÇÃO QUE CONSOME OS TOKENS MATEMATICOS ENTRE CONSTANTES E ID.
def S(self):
try:
if self.atualIgual(tt.OPMULT):
self.consome(tt.OPMULT)
self.SIMPLES()
elif self.atualIgual(tt.OPDIV):
self.consome(tt.OPDIV)
self.SIMPLES()
else:
pass
except:
self.get_FOLLOW_S()
# FUNÇÃO QUE PEGA O FOLLOW DE S
def get_FOLLOW_S(self):
if self.tokenAtual.classe in self.FOLLOW_S: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPFECHAP[
0]: # VERIFICA SE TOKEN É ")" E CONTINUA A GRAMATICA.
self.FAT()
elif self.tokenAtual.classe == tt.OPPV[
0]: # VERIFICA SE TOKEN É ";" E CONTINUA A GRAMATICA.
self.consome(tt.OPPV)
elif self.tokenAtual.classe == tt.OPVIRG[
0]: # VERIFICA SE TOKEN É "," E CONTINUA A GRAMATICA.
self.consome(tt.OPPV)
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_S()
# FUNÇÃO QUE CONSOME DEPOIS DE UMA ATRIBUIÇÃO.
def FAT(self):
try:
if self.atualIgual(tt.CONST):
self.consome(tt.CONST)
elif self.atualIgual(tt.OPABREP):
self.consome(tt.OPABREP)
self.EXPR()
self.consome(tt.OPFECHAP)
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()
elif self.atualIgual(tt.IDENT):
self.consome(tt.IDENT)
else:
# CASO NÃO SEJA NENHUM, LISTA TODAS AS POSSIBILIDADES PARA COMPILAR COM SUCESSO NO TERMINAL.
self.mensagemERRO(tt.CONST)
self.mensagemERRO(tt.OPABREP)
self.mensagemERRO(tt.VERDADEIRO)
self.mensagemERRO(tt.FALSO)
self.mensagemERRO(tt.OPNEG)
self.mensagemERRO(tt.IDENT)
# E ENTRA NO MODOPANICO PARA ENTRAR NO EXCEPTION.
self.modoPanico()
except:
self.get_FOLLOW_FAT()
# FUNÇÃO QUE PEGA O FOLLOW DE FAT
def get_FOLLOW_FAT(self):
if self.tokenAtual.classe in self.FOLLOW_FAT: # CONFERE SE O TOKEN E UM DOS FOLLOWS DA FUNÇÃO.
if self.tokenAtual.classe == tt.OPMAIS[
0]: # VERIFICA SE TOKEN É "+" E CONTINUA A GRAMATICA.
self.R()
elif self.tokenAtual.classe == tt.OPMULT[
0]: # VERIFICA SE TOKEN É "*" E CONTINUA A GRAMATICA.
self.S()
elif self.tokenAtual.classe == tt.FIMARQ[0]:
return
else: # CASO CONTRARIO PEGA OUTRO TOKEN E CHAMA A FUNÇÃO FOLLOWS DENOVO.
self.tokenAtual = self.lex.getToken()
self.get_FOLLOW_FAT()
# FUNÇÃO QUE DA PRINT DA TABELA NO TERMINAL.
def printTabela(self, nome):
controle = 0
tipo = ''
linha = ''
aux = []
escrita = []
for i in range(len(self.vetTabela) - 1, -1, -1):
if type(self.vetTabela[i]) is list:
controle = 1
tipo = self.vetTabela[i][0]
linha = self.vetTabela[i][1]
if controle == 1 and type(self.vetTabela[i]) is str:
aux.append([self.vetTabela[i], tipo, linha])
aux.pop()
for i in aux:
escrita.append("Variável '%s' do tipo '%s' na linha %d" %
(i[0], i[1], i[2]) + "\n")
arq = open('Tabela_Simbolos_' + nome, 'w')
arq.writelines(escrita)
arq.close()
from Lexico import Lexico
from Sintatico import Sintatico
entrada = "entrada.txt"
print("entrada.txt\n")
lex = Lexico(entrada)
lex.lexanalise()
print("analise lexica feita\n")
sint = Sintatico()
sint.programa()
sint.output.close()
print("analise sintatica pronta!\n")
from Lexico import Lexico
codigo = open("prueba.txt", 'r')
codigo = codigo.read()
Tokens = Lexico(codigo)
for i, j in Tokens.tokens:
print(i, j)
for i in Tokens.tablaDeSimbolos:
print(i)
print(Tokens.verSiguienteSimbolo())
print(Tokens.sacarSimbolo())
print(Tokens.verSiguienteSimbolo())
def main(): analisador = Lexico() analisador.run() return analisador