Add files via upload

Geracaodecodigo.py

@@ -0,0 +1,80 @@
+'''
+    intermediario(token, argumentos, posicao inicial que deseja converter para assembler, posição final, valor inicial das Labels dos loops, texto final)
+'''
+def intemerdiario(token,args, inicio, fim, loop,condicional, texto):
+    L=loop
+    C=condicional
+    i=inicio
+    while i < fim :
+        if 'inteiro' in token[i][0]:
+            texto.extend(variaveis(token,i))
+        elif 'leia' in token[i][0]:
+            texto.append('LEIA '+token[i+2][1])
+        elif 'escreva' in token[i][0]:
+            texto.append('ESCREVA '+ token[i+2][1])
+        elif 'recebe' in token[i][0]:
+            exp=[]
+            from infixtoposfix import infixToPostfix
+            exp.append(infixToPostfix(expressao(token, i)))
+            simpleexpre(exp,token[i-1][1],texto)
+        elif 'enquanto' in token[i][0]:
+            texto.append(f'_L{L}: if {token[i+2][1]}'+ (' >' if '<' in token[i+3][1] else ' <')+f' {token[i+4][1]} goto _L{L+1} ')
+            i=intemerdiario(token, args, i+6, fim, L+1, C, texto)
+            texto.append(f'_L{L+1}:')
+            L=L+i
+            C=L
+        elif 'se' == token[i][0]:
+            texto.append(f'_C{C} if {token[i+2][1]} {token[i+3][1]} {token[i+4][1]} goto _C{C+1}')
+            i=intemerdiario(token, args, i+6, fim, L, C+1, texto)
+            texto.append(f'_C{L+1}:')
+            C = C + i
+            L = C
+        elif '}' in token[i][1]:
+            return i
+        i=i+1
+
+    with open('intermediario.s','w') as f:
+        f.write('\n'.join(texto))
+    #print (texto)
+def simpleexpre(exp,var,texto):
+    '''
+    ADD dest,src1,src2	dest = src1 + src2
+    SUB dest,src1,src2	dest = src1 - src2
+    ADDI dest,src1,I	dest = src1 + I
+    MUL dest,src1,src2	dest = src1 × src2
+    DIV[U] dest,src1,src2	dest = src1/src2
+    '''
+    t=1
+    exp=exp[0].split()
+    values=[]
+    operador=['+','-','*','/']
+    for i in range(len(exp)):
+        if exp[i] in operador:
+            a = values.pop()
+            b = values.pop()
+            if i == len(exp)-1:
+                texto.append(f'{var} := {b} {a} {exp[i]}')
+            else:
+                texto.append(f'T{t} := {b} {a} {exp[i]}')
+                values.append(f'T{t}')
+                t+=1
+        else:
+            values.append(exp[i])
+    if len(values) > 0:
+        texto.append(f'{var} := {values[0]}')
+
+def expressao(token, i):
+    l=i+1
+    var=[]
+    while not('fim_linha' in token[l][0]):
+        var.append(token[l][1])
+        l+=1
+    return ' '.join(var)
+def variaveis(token,i):
+    l=i+1
+    var=[]
+    while not('fim_linha' in token[l][0]):
+        if not('virgula' in token[l][0]):
+            var.append('INTEIRO '+token[l][1])
+        l+=1
+    return var

beuty.py

@@ -0,0 +1,71 @@
+def beut(tabela1, tabela2):
+    from bs4 import BeautifulSoup
+    with open('tabela.html', 'r') as file:
+        soup = BeautifulSoup(file, "html5lib")
+        soup.prettify()#reorganiza as tags
+
+        tabela_all = soup.find_all('tbody')
+
+        coluna1 = tabela_all[0].find_all('tr')
+        coluna2 = tabela_all[1].find_all('tr')
+
+        valores_return(coluna1, tabela1)
+        valores_return(coluna2, tabela2)
+
+
+def valores_return(colunas, tabela):
+
+    for coluna in colunas:
+        celula = coluna.find_all('td')
+        celula = [ele.text.strip() for ele in celula]
+        tabela.append([ele for ele in celula if ele])
+
+def separar(palavra):
+    numero = []
+    for word in palavra:
+        if word.isdigit():
+            numero += word
+    return (''.join(numero))
+
+def initsintatico(token, args):
+    import os
+    if not(os.path.isfile('dicionario1.dtc')and os.path.isfile('dicionario2.dtc')):
+        save()
+
+    from sintatico import analisadorsintatico
+    dict_tabela1 = load("dicionario1.dtc")
+    dict_tabela2 = load("dicionario2.dtc")
+    analisadorsintatico(dict_tabela1, dict_tabela2, token, args)
+
+def load(filename):
+    import pickle
+    file = open(filename, "rb")
+    return pickle.load(file)
+
+def save():
+    tabela1 = []
+    tabela2 = []
+    beut(tabela1, tabela2)
+    topo = tabela1[0]
+    del tabela1[0]
+    dict_tabela1 = {}
+    dict_tabela2 = {}
+    for linhas in tabela1:
+        i = 0;
+        for linha in linhas:
+            if linha.isdigit() and i <= len(topo):
+                dict_tabela1[(linhas[0], topo[i - 1])] = [int(linha)]
+            i += 1
+    for i in range(len(tabela2)):
+        if (((tabela2[i][1]).split('::= '))[1]).split(" ")[0] != 'î':
+            dict_tabela2[int(separar(tabela2[i][0]))] = ((((tabela2[i][1]).split('::= '))[1]).split())
+        else:
+            dict_tabela2[int(separar(tabela2[i][0]))] = []
+    saveFile(dict_tabela1, "dicionario1.dtc")
+    saveFile(dict_tabela2, "dicionario2.dtc")
+
+def saveFile(dict, filename):
+    import pickle
+    dicionario = open(filename, "wb")
+    pickle.dump(dict, dicionario)
+    dicionario.close()

fatorial.txt

@@ -0,0 +1,18 @@
+programa
+inteiro var1, var2;
+escreva("Escreva um numero: ");
+leia(var1);
+var2 = 1;
+se(1<1){
+    enquanto(var1 > 1){
+        var2 = var1 / var2 * 1 + 2;
+        var1 = var1 - 1;
+     }
+}
+enquanto(2>1){
+    escreva("a");
+}
+escreva("fatorial de: ");
+escreva(var1);
+escreva("\n");
+fimprograma

infixtoposfix.py

@@ -0,0 +1,37 @@
+'''
+Codigo retirado do livro: Problem Solving with Algorithms and Data Structures using Python
+pelo link: http://interactivepython.org/runestone/static/pythonds/BasicDS/InfixPrefixandPostfixExpressions.html
+e modificado por: Nicolas T. Cuerbas
+'''
+
+def infixToPostfix(infixexpr):
+    prec = {}
+    prec["*"] = 3
+    prec["/"] = 3
+    prec["+"] = 2
+    prec["-"] = 2
+    prec[">"] = 2
+    prec["<"] = 2
+    prec["("] = 1
+    opStack = []
+    postfixList = []
+    tokenList = infixexpr.split()
+
+    for token in tokenList:
+        if token.isidentifier() or token.isdigit():
+            postfixList.append(token)
+        elif token == '(':
+            opStack.extend(token)
+        elif token == ')':
+            topToken = opStack.pop()
+            while topToken != '(':
+                postfixList.append(topToken)
+                topToken = opStack.pop()
+        else:
+            while (not len(opStack)==0) and (prec[opStack[-1]] >= prec[token]):
+                  postfixList.append(opStack.pop())
+            opStack.extend(token)
+
+    while not (len(opStack)==0):
+        postfixList.append(opStack.pop())
+    return " ".join(postfixList)

intermediario.s

@@ -0,0 +1,19 @@
+INTEIRO var1
+INTEIRO var2
+ESCREVA "Escreva um numero: "
+LEIA var1
+var2 := 1
+_C0 if 1 < 1 goto _C1
+_L0: if var1 < 1 goto _L1 
+T1 := var1 var2 /
+T2 := T1 1 *
+var2 := T2 2 +
+var1 := var1 1 -
+_L1:
+_C1:
+_L51: if 2 < 1 goto _L52 
+ESCREVA "a"
+_L52:
+ESCREVA "fatorial de: "
+ESCREVA var1
+ESCREVA "\n"

lexical.py

@@ -0,0 +1,63 @@
+import collections
+import re
+def tokenize(code,args):
+    token = collections.namedtuple('Token', ['tipo', 'lexema', 'linha', 'coluna'])
+    token_especificacao = [
+        ('inicio'       ,r'\{'), #inicio {
+        ('fim'          ,r'\}'), # fim }
+        ('a_parentese'  ,r'\('), #parentese de abertura
+        ('f_parentese'  ,r'\)'), #parentese de fechamento
+        ('leia'         ,r'leia'), #leia
+        ('escreva'      ,r'escreva'), #escreva
+        ('se'           ,r'se'), #se
+        ('senao'        ,r'senao'), #senao
+        ('enquanto'     ,r'enquanto'), #enquanto
+        ('programa'     ,r'programa'), #programa
+        ('fimprograma'  ,r'fimprograma'), #fimprograma
+        ('inteiro'      ,r'inteiro'),     #variavel
+        ('numero'       ,r'[+-]?[0-9]+'),  # inteiro
+        ("fim_linha"    ,r';'), #fim de linha
+        ("virgula"      ,r','), # virgula
+        ('recebe'       ,r'='),           # recebe
+        ('id'           ,r'[A-Za-z]([A-Za-z0-9_])*'),    # Id
+        ('subtracao'    ,r'\-'),            #subtração
+        ('soma'         ,r'\+'),           #soma
+        ('multiplicacao',r'\*'),            #multiplicação
+        ('divisao'      ,r'/'),             #divisão
+        ('WS'           ,r' +'),           # espaço
+        ('menor'        ,r'<'),             #operadore lógico menor
+        ('maior'        ,r'>'),             #operador lógico maior
+        ('frase'        ,r'".*?"'),         #frase
+        ('ERRO'         ,r'.'),            # qualquer caracter não identificado
+        ('Linha'        ,r'\n'),	    #fim de linha
+    ]
+
+    token_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_especificacao)
+    linha = 1
+    linha_inicia = 0
+    for mo in re.finditer(token_regex, code):
+        tipo = mo.lastgroup
+        valor = mo.group(tipo)
+        if (tipo == 'Linha'):
+            linha_inicia = mo.end()
+            linha += 1
+        elif tipo == 'tab':
+            pass
+        elif tipo == 'ERRO':
+
+            from colorama import Fore, Style
+            t=Fore.CYAN+'########################################################'
+            print(t)
+            print(f'{valor!r} não esperado na linha {linha} e coluna {coluna}\a\a')
+            print(t)
+            print(f'Erro lexico')
+            args.lt=False
+            if valor == '"':
+                print(f'" de fechamento não encontrada'+Style.RESET_ALL)
+            else:
+                print(f'caracter desconhecido')
+                print(Style.RESET_ALL)
+            pass
+        coluna = mo.start() - linha_inicia
+        if (tipo != 'ERRO') and (tipo != 'Linha') and (tipo != 'WS'):
+            yield token(tipo, valor, linha, coluna)

main.py

@@ -0,0 +1,18 @@
+def main():
+
+    parser = argparse.ArgumentParser(description='Compilador para uma linguagem do tipo LL(1)')
+    parser.add_argument("-lt", help="Mostra o LOG de Tokens e Lexemas do analisador lexico", action='store_true')
+    parser.add_argument("-ls", help="Mostra o Log das operações do analisador sintatico", action='store_true')
+    parser.add_argument("-lse", help="Mostra o Log das operações do analisador semantico", action='store_true')
+    parser.add_argument("-lgc", help="Mostra o Log da geração de codigo", action='store_true')
+    parser.add_argument("filename", type=str, help="Filename")
+    parser.add_argument('-tudo', help='Show all logs', action='store_true')
+    args=parser.parse_args()
+    opction(args)
+
+#executa a funcao main()
+if __name__ == "__main__":
+    import sys
+    import argparse
+    from selection import opction
+    main()

selection.py

@@ -0,0 +1,48 @@
+def opction(args):
+    token = []
+    if args.tudo:
+        args.lt=True
+        args.ls=True
+        args.lse=True
+        args.lgc=True
+    if args.lt:
+        vlt(args.filename,token,args)
+    else:
+        lt(args.filename,token,args)
+    ls(token,args)
+    lse(token,args)
+    lgc(token,args)
+
+def vlt(filename,token,args):
+    from lexical import tokenize
+    print ('#' * 80)
+    file = open(filename, "r")
+    arquivo = file.read()
+    file.close()
+    print('{:15}'.format('Token'), '{:29}'.format('Lexema'), '{:10}'.format('Linha'), '{:10}'.format('Coluna'))
+    i = 0
+    for tok in tokenize(arquivo,args):
+        token.append(tok)
+        print('{:15}'.format(token[i][0]), '{:20.11}'.format(token[i][1]), '{:10}'.format(token[i][2]),
+              '{:10}'.format(token[i][3]))
+        i += 1
+def lt(filename, token, args):
+    from lexical import tokenize
+    file = open(filename, "r")
+    arquivo = file.read()
+    file.close()
+    for tok in tokenize(arquivo,args):
+        token.append(tok)
+def ls(token,args):
+    from beuty import initsintatico
+    initsintatico(token,args)
+def lse(token,args):
+    from semantico import semantico
+    semantico(token,args)
+def lgc(token,args):
+    from  Geracaodecodigo import intemerdiario
+    texto = []
+    intemerdiario(token,args,0,len(token),0,0, texto)
+    '''
+    intermediario(token, args, posicao inicial que deseja converter para assembler, posição final, valor inicial das Labels dos loops, valor inicial das Labels dos condicionais)
+    '''

semantico.py

@@ -0,0 +1,58 @@
+def semantico(token, args):
+    Avariaveis(token, args)
+def divisao(token, args, lista):
+    linha = []
+    if args.lse:
+        print("Verificando Divisão por Zero.")
+
+def verificando(lista):
+    for exp in lista.values():
+        if 'î' not in exp:
+            try:
+                eval(''.join(exp))
+            except ZeroDivisionError:
+                from colorama import Style
+                Color()
+                print (f' Divisão por Zero {exp} '+ Style.RESET_ALL)
+def trocandoValores(lista,a,key):
+    import re
+    for exp in lista.keys():
+        if exp in a:
+            a=re.sub(r''+exp, (''.join(lista[exp])),''.join(a))
+    lista[key] = ''.join(a)
+
+def Avariaveis(token, args):
+    variaveis = {}
+    if args.lse:
+        print ('#' * 80)
+        print('Carregando Tabela de Variveis.')
+        print("Verificando Variaveis Duplicadas.")
+    for var in token:
+        if 'id' in var and var[2] == 2:
+            if var[1] not in variaveis:
+                variaveis[var[1]] = 'î'
+            else:
+                Color()
+                print(f'\'{var[1]}\' declaração duplicada: ' + reset(var))
+
+    if args.lse:
+        print("Variaveis declaradas: ")
+        for var in variaveis.items():
+            print(var[0])
+        print("Verificando Variaveis não declaradas.")
+
+    for code in token:
+        if 'id' in code:
+            if not (code[1] in variaveis):
+                Color();
+                print(f'Variavel \'{code[1]}\' não declarado: ' + reset(code))
+    divisao(token, args, variaveis)
+
+def Color():
+    from colorama import Fore, Back
+    print(Fore.CYAN + 'Erro semantico:')
+
+
+def reset(linha):
+    from colorama import Style
+    return f'linha{linha[2]} : coluna{linha[3]}' + Style.RESET_ALL

sintatico.py

@@ -0,0 +1,66 @@
+def analisadorsintatico(dict1, dict2, programa, args):
+    pilha = ["<INICIO>"]#inicializa a pilha com o Não terminal inicial
+    if args.ls : #Se verdadeiro mostra a mensagem a seguir
+        print ('#'*80)
+        print("Foi adcionado a pilha: " + pilha[-1])
+        #dicionario para cada token e sua representação no código
+    token={"a_parentese":"(" ,"f_parentese":")", "virgula":",","inicio":"{", "fim":"}",	"fim_linha":";","id":"id","numero":"numero", "frase":"frase", 	"programa":"programa" ,"fimprograma":"fimprograma", "inteiro":"declaração", "leia":"leia" ,"escreva":"escreva", "se":"se",
+       "senao":"senao","enquanto":"enquanto", "menor":"<",	"maior":">", "recebe":"=", "soma":"+" ,"subtracao":"-","multiplicacao":"*", "divisao": '//'}
+    i=0#inicializa a posição
+    while i <= (len(programa)-1):
+        if pilha[-1] == programa[i][0]:#verifica se o topo da pilha é igual ao token na fila do programa
+            if args.ls:#Se verdadeiro mostra a mensagem a seguir
+                print("Foi despilhado: " + pilha[-1])
+            pilha.pop()
+            i += 1
+        else:
+            if (pilha[-1], programa[i][0]) in dict1:#verifica se existe <Não terminal> junto com inicio da fila forma uma chave
+                if dict2[dict1[pilha[-1], programa[i][0]][0]]:#Faz mesma verificação da existencia de chave e imprime na tela se args.ls for verdadeiro para o usuario
+                    if args.ls:
+                        print("Foi despilhado: " + pilha[-1])
+                        print("Foi empilhado: ")
+                        a = dict2[dict1[pilha[-1], programa[i][0]][0]]
+                        a.reverse()
+                        print(f"Expressão {dict1[pilha[-1], programa[i][0]][0]}:", a)#Retorna o numero da expressão que foi adcionado na pilha e expressão na ordem que foi empilhada
+                        a.reverse()
+
+                exp = dict2[dict1[pilha[-1], programa[i][0]][0]]#recebe a expressão que vai ser empilhada
+                if not exp:
+                    if args.ls: #Se verdadeiro mostra a mensagem a seguir
+                        print("Foi tirado da pilha: "+pilha[-1])
+                    pilha.pop() #desempilha o topo da pilha
+                else:
+                    pilha.pop()#desempilha o topo da pilha
+                    exp.reverse()#inverte a expresão antes de colocar na pilha
+                    pilha.extend(exp)#empilha na pilha
+                    exp.reverse()#inverte novamente
+            else:#Caso não encontre a chave
+                a = []
+                if '<' in pilha[-1]:
+                    dict = []
+                    '''
+                    cria uma extenção do dicionario, primeirente apresenta todos os itens e os filtra se o topo da pilha
+                    estiver nas chaves do dicionario 1 e os adciona
+                    '''
+                    dict.extend([ele[1] for ele in dict1 if pilha[-1] in ele])#
+                    #Adciona apenas os elementos filtrados
+                    a.extend([token[ele] for ele in dict if ele])
+                else:
+                    # se top não for um não terminal ele apenas adciona o topo da pilha
+                    a.extend(token[pilha[-1]])
+                from colorama import Fore, Style
+                t = Fore.CYAN +"Erro Sintatico ".upper()#imprimi bunitinho
+                print(t)
+                print(f"\'{programa[i][1]}\' inesperado linha {programa[i][2]}, coluna {programa[i][3]}")#
+                space = " "*int(programa[i][3])
+                texto = []
+                with open(args.filename, 'r') as f:
+                    for i in range(programa[i][2]):
+                        texto = f.readline()
+                print(texto+space+'^')
+                print(f"Era esperado: {' '.join(a)}"+Style.RESET_ALL)
+                args.ls = False
+                break
+    if args.ls:#Se for True imprime a mensagem
+        args.ls=True
+        print("Sintatico terminado com Sucesso")