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"
Ejemplo n.º 4
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.º 5
0
def getResultado(linea):
    try:
        lexico = Lexico(linea)
        sintactico = Sintactico(lexico)
        expresion = sintactico.analizaLinea()

        return expresion.evalua()
    except Exception:
        print "Error de Ejecucion. (Resultado)"
    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.º 7
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.º 8
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.º 9
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.º 10
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.º 11
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)
 def __init__(self):
     self.lexico = Lexico()
     self.error = False
     self.errores = open("errores.txt", "w")
Ejemplo n.º 13
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.º 14
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.º 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)