Ejemplo n.º 1
0
    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()
Ejemplo n.º 2
0
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"
Ejemplo n.º 3
0
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()
Ejemplo n.º 5
0
    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()
Ejemplo n.º 6
0
    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()
Ejemplo n.º 7
0
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
Ejemplo n.º 8
0
def getExpresion(linea):
    try:
        lexico = Lexico(linea)
        sintactico = Sintactico(lexico)
        expresion = sintactico.analizaLinea()

        return str(expresion)
    except Exception:
        print "Error en Ejecucion. (Expresiones)"
Ejemplo n.º 9
0
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()
Ejemplo n.º 10
0
def getResultado(linea):
    try:
        lexico = Lexico(linea)
        sintactico = Sintactico(lexico)
        expresion = sintactico.analizaLinea()

        return expresion.evalua()
    except Exception:
        print "Error de Ejecucion. (Resultado)"
Ejemplo n.º 11
0
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)
Ejemplo n.º 14
0
#!/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
Ejemplo n.º 15
0
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)
Ejemplo n.º 16
0
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')   
Ejemplo n.º 18
0
        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)
Ejemplo n.º 19
0
#!/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()
Ejemplo n.º 20
0
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)
Ejemplo n.º 21
0
            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)
Ejemplo n.º 22
0
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)
Ejemplo n.º 23
0
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()