Add files via upload

Geracaodecodigo.py

 '''
     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 :
+def intemerdiario(token,args):
+    if (args.lgc):
+        print ("Gerando código intermediário")
+    L=0
+    C=0
+    pilha=[]
+    i=0
+    texto=[]
+    while i < len(token) :
         if 'inteiro' in token[i][0]:
+            if (args.lgc):
+                print ("Inteiro identificado:")
             texto.extend(variaveis(token,i))
         elif 'leia' in token[i][0]:
+            if (args.lgc):
+                print ("leia identificado:")
             texto.append('LEIA '+token[i+2][1])
         elif 'escreva' in token[i][0]:
+            if (args.lgc):
+                print ("escreva identificado:")
             texto.append('ESCREVA '+ token[i+2][1])
         elif 'recebe' in token[i][0]:
+            if (args.lgc):
+                print ("Atribuição identificada:")
             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
+            if (args.lgc):
+                print ("função enquanto identificado:")
+            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} ')
+            pilha.append(f'_L{L+1}')
+            L+=2
         elif 'se' == token[i][0]:
-            texto.append(f'_C{C}: if {token[i+2][1]}' + (' >' if '<' in token[i+3][1] else ' <')+f' {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
+            if (args.lgc):
+                print ("\'se\' identificado:")
+            texto.append(f'_C{C}: if {token[i+2][1]}' + (' =>' if '<' in token[i+3][1] else ' <=')+f' {token[i+4][1]} goto _C{C+1}')
+            pilha.append(f'_C{C + 1}')
+            C += 2
+        elif 'senao' == token[i][0]:
+            if (args.lgc):
+                print ("\'senao\' identificado:")
+            pilha.append(f'{int(texto[-1].split("_C")[1].split(":")[0])-1}')
         elif '}' in token[i][1]:
-            return i
+            if 'L' in pilha[-1]:
+                p= pilha.pop()
+                texto.append(f'goto _L{int(p.split("_L")[1])-1}')
+                texto.append(f'{p}:')
+            elif 'C' in pilha[-1]:
+                p = pilha.pop()
+                texto.append(f'goto EXIT_C{int(p.split("_C")[1]) - 1}')
+                texto.append(f'{p}:')
+                if 'senao' not in  token[i+1][0]:
+                    texto.append (f'EXIT_C{int(p.split("_C")[1])-1}:')
+            elif pilha[-1]:
+                texto.append(f'EXIT_C{pilha.pop()}:')
+        #print (pilha)
         i=i+1
 
     with open('intermediario.s','w') as f:
+        if (args.lgc):
+            print ("Escrevendo no arquivo:")
         f.write('\n'.join(texto))
 def simpleexpre(exp,var,texto):
     '''
     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
+    DIV dest,src1,src2	dest = src1/src2
     '''
     t=1
     exp=exp[0].split()
         l+=1
     return var
 def gerarcodigo(token,args):
-    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)
     '''
-    intemerdiario(token, args, 0, len(token), 0, 0, texto)
-    gerar()
-def gerar():
+    intemerdiario(token, args)
+    gerar(args)
+def gerar(args):
+    nome = args.filename.split('.')[0]
     texto=[]
+    if (args.lgc):
+        print ("Gerando código final")
     with open('intermediario.s','r') as f:
-        texto=f.readlines()
+        texto=f.read().splitlines()
     i=0
     final=[]
     db=[]
     msg=-1
-    final.append('format ELF64 executable 3')
-    final.append('segment readable executable')
-    final.append('entry main')
+    if (args.lgc):
+        print ("Gerando cabeçalho")
+    final.append(';flat assembler  version 1.73.02')
+    final.append(f';fasm {nome}.asm')
+    final.append(f';ld -lc -e main -dynamic-linker /lib/ld-linux.so.2  {nome}.o -o {nome} -m elf_i386')
+    final.append(';OS: Ubuntu 18.04.1 LTS x86_64 ')
+    final.append(';Kernel: 4.15.0-42-generic ')
+    final.append(';CPU: Intel i5-2520M (4) @ 3.200GHz\n')
+    final.append(f'format ELF')
+    final.append('public main as \'main\' ')
+    final.append('extrn \'exit\'as exit')
+    final.append('extrn \'printf\' as printf')
+    final.append('extrn \'scanf\'as scanf\n')
+
+    final.append('section \'.text\' executable')
+
     final.append('main:')
 
     while i < len(texto):
-        if 'ESCREVA' in texto[i]:
+        if (args.lgc):
+            print ("Gerando o comando escreva")
+        if 'INTEIRO' in texto[i].split()[0]:
+            db.append(f'{texto[i].split()[1]} dd 0')
+        if 'ESCREVA' in texto[i].split('"')[0]:
+            final.append(';Impressão na tela')
             if '"' in texto[i]:
                 msg += 1
-                size = texto[i].strip('ESCREVA')
-                size = size.strip('\n').replace('"','')
-                final.append(f'lea rdi, [msg{msg}]')
-                final.append(f'mov rax, {len(size)}')
-                final.append(f'mov rdx, rax')
-                final.append(f'mov rsi, rdi')
-                final.append(f'mov rdi, 1')
-                final.append(f'mov rax, 1')
-                final.append(f'syscall')
-                db.extend([f'msg{msg} db \'{size.strip()}\', 10,0'])
+                text = texto[i].split('ESCREVA')[1]
+                text= text.strip()
+                text= "".join(text)
+                text = text.replace('\"', '')
+                if (args.lgc):
+                    print ("Gerando comandos para o escrever uma mensagem")
+                final.append(f'push msg{msg}')
+                final.append(f'call printf')
+                final.append(f'add esp, 4\n')
+
+                txt=text.replace('\\n', '\',10,0,\'')
+                db.append(f'msg{msg} db \'{txt}\', 0,0')
             else:
-                print ()
+                if (args.lgc):
+                    print ("Gerando comandos para o escrever uma variavel")
+                expre = texto[i].split()
+                final.append(f'push {"["+expre[1]+"]" if expre[1].isidentifier() else expre[1] }')
+                final.append(f'push formatacao')
+                final.append(f'call printf')
+                final.append(f'add esp, 4\n')
+        if 'LEIA' in texto[i].split()[0]:
+            if (args.lgc):
+                print ("Gerando o comando leia")
+            final.append(';Ler do Teclado')
+            final.append(f'push {texto[i].split()[1]}')
+            final.append(f'push formatacao')
+            final.append(f'call scanf')
+            final.append(f'add esp, 8\n')
+        if 'if' in texto[i]:
+            '''
+            je - jump if op1 = op2 (op1 is "equal to" op2)
+            ja - jump if op1 > op2 (op1 is "above" op2)
+            jb - jump if op1 < op2 (op1 is "below" op2)
+            jae - jump if op1 >= op2 (op1 is "above or equal to" op2)
+            jbe - jump if op1 <= op2 (op1 is "below or equal to" op2) 
+            '''
+            if (args.lgc):
+                print ("Comando condicional/repetição identificado")
+                print ("Gerando os comandos condicões/repetição")
+            expre=texto[i].split()
+            final.append(';Label')
+            final.append(f'{expre[0]}')
+            #final.append(f'xor eax,eax')
+            final.append(f'xor ebx, ebx')
+            final.append(f'mov eax, {"["+expre[2]+"]" if expre[2].isidentifier() else expre[2] }')
+            final.append(f'mov ebx, {"["+expre[4]+"]" if expre[4].isidentifier() else expre[4] }')
+            final.append(f'cmp eax, ebx')
+            final.append(f'j{"ae" if ">=" is expre[3] else "be"} {expre[6]}')
+        if 'goto' in texto[i].split()[0]:
+            final.append(f'jmp {texto[i].split()[1]}')
+        if len(texto[i].split())<2:
+            final.append(f'{texto[i]}')
+        if len(texto[i].split())>2:
+            if (args.lgc):
+                print ("Comando de atribuição identificado")
+                print ("Gerando...")
+            if ':=' in texto[i].split()[1]:
+                expre = texto[i].split()
+                if len(expre)==3:
+                    if (args.lgc):
+                        print ("Comando de atribuição para com um valor")
+                        print ("Gerando...")
+                    final.append(f';Atribuição')
+                    final.append(f'mov eax,[{expre[0]}]')
+                    final.append(f'mov eax, {"["+expre[2]+"]" if expre[2].isidentifier() else expre[2] }')
+                    final.append(f'mov [{expre[0]}],eax')
+                    final.append(f'xor eax,eax\n')
+                elif '+' is expre[4]:
+                    if (args.lgc):
+                        print ("Comando de soma")
+                        print ("Gerando...")
+                    final.append(f';Adicção')
+                    final.append(f'mov eax, {"["+expre[2]+"]" if expre[2].isidentifier() else expre[2] }')
+                    final.append(f'mov edx, {"["+expre[3]+"]" if expre[3].isidentifier() else expre[3] }')
+                    final.append(f'add eax, edx')
+                    final.append(f'mov {"["+expre[0]+"]"}, eax')
+                    final.append(f'xor eax,eax\n')
+                elif '-' is expre[4]:
+                    if (args.lgc):
+                        print ("Comando de subtração")
+                        print ("Gerando...")
+                    final.append(f';Subtração')
+                    final.append(f'mov eax, {"["+expre[2]+"]" if expre[2].isidentifier() else expre[2] }')
+                    final.append(f'mov edx, {"["+expre[3]+"]" if expre[3].isidentifier() else expre[3] }')
+                    final.append(f'sub eax, edx')
+                    final.append(f'mov {"["+expre[0]+"]"}, eax')
+                    final.append(f'xor eax,eax\n')
+                elif '*' is expre[4]:
+                    if (args.lgc):
+                        print ("Comando de multiplicação")
+                        print ("Gerando...")
+                    final.append(f';Multiplicação')
+                    final.append(f'mov eax, {"[" + expre[2] + "]" if expre[2].isidentifier() else expre[2] }')
+                    final.append(f'mov edx, {"[" + expre[3] + "]" if expre[3].isidentifier() else expre[3] }')
+                    final.append(f'imul eax, edx')
+                    final.append(f'mov {"[" + expre[0] + "]"}, eax')
+                    final.append(f'xor eax,eax\n')
+                elif '/' is expre[4]:
+                    if (args.lgc):
+                        print ("Comando de divisão")
+                        print ("Gerando...")
+                    final.append(f';Divisao')
+                    final.append(f'xor edx, edx')
+                    final.append(f'mov ebx, {"[" + expre[2] + "]" if expre[2].isidentifier() else expre[2] }')
+                    final.append(f'mov eax, {"[" + expre[2] + "]" if expre[2].isidentifier() else expre[2] }')
+                    final.append(f'div ebx')
+                    final.append(f'mov {"[" + expre[0] + "]"}, eax')
+                    final.append(f'xor eax,eax\n')
+
         i+=1
-    final.append('xor rdi,rdi')
-    final.append('mov rax, 60')
-    final.append('syscall')
-    if(msg>-1):
-        final.append('segment readable writable')
+    final.append('sair:')
+    final.append('push 0')
+    final.append('call exit\n')
+
+    if(len(db)>0):
+        final.append('section \'.data\' writeable')
+        final.append('formatacao db \'%d\' , 0')
         final.extend(db)
-    with open('final.fasm','w') as f:
-        f.write('\n'.join(final))
+
+    with open(nome+'.asm','w') as f:
+        f.write('\n'.join(final))
+    import os
+    if args.lgc:
+        print (f"Compilando arquivo fonte: {args.filename}")
+    os.system(f'fasm {nome}.asm')
+    os.system(f'ld -lc -e main -dynamic-linker /lib/ld-linux.so.2  {nome}.o -o {nome} -m elf_i386')
+    if args.lgc:
+        print (f"Arquivo executavel pronto: {nome}")
+        print ("pronto")

beuty.py

             numero += word
     return (''.join(numero))
 
-def initsintatico(token, args):
+def initsintatico(token, args,erro):
     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)
+    analisadorsintatico(dict_tabela1, dict_tabela2, token, args,erro)
 
 def load(filename):
     import pickle

lexical.py

 import collections
 import re
-def tokenize(code,args):
+def tokenize(code,args,erro):
     token = collections.namedtuple('Token', ['tipo', 'lexema', 'linha', 'coluna'])
     token_especificacao = [
         ('inicio'       ,r'\{'), #inicio {
         ('f_parentese'  ,r'\)'), #parentese de fechamento
         ('leia'         ,r'leia'), #leia
         ('escreva'      ,r'escreva'), #escreva
+        ('senao', r'senao'),  # senao
         ('se'           ,r'se'), #se
-        ('senao'        ,r'senao'), #senao
         ('enquanto'     ,r'enquanto'), #enquanto
         ('programa'     ,r'programa'), #programa
         ('fimprograma'  ,r'fimprograma'), #fimprograma
         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
+            erro.append('########################################################')
+            erro.append(f'Erro lexico')
+            erro.append(f'{valor!r} não esperado na linha {linha} e coluna {coluna}')
             if valor == '"':
-                print(f'" de fechamento não encontrada'+Style.RESET_ALL)
+                erro.append(f'" de fechamento não encontrada')
             else:
-                print(f'caracter desconhecido')
-                print(Style.RESET_ALL)
+                erro.append(f'caracter desconhecido')
             pass
+
         coluna = mo.start() - linha_inicia
         if (tipo != 'ERRO') and (tipo != 'Linha') and (tipo != 'WS'):
-            yield token(tipo, valor, linha, coluna)
+            yield token(tipo, valor, linha, coluna)

selection.py

 def opction(args):
     token = []
+    erro = []
     if args.tudo:
         args.lt=True
         args.ls=True
         args.lse=True
         args.lgc=True
     if args.lt:
-        vlt(args.filename,token,args)
+        vlt(args.filename,token,args,erro)
     else:
-        lt(args.filename,token,args)
-    ls(token,args)
-    lse(token,args)
-    lgc(token,args)
+        lt(args.filename,token,args,erro)
+    ls(token,args,erro)
+    lse(token,args,erro)
+    if len(erro)>0:
+        for e in erro:
+            print(e)
+        if (args.lgc):
+            print ("Não foi possivel iniciar a geração de código por causa de erro no código fonte.")
+    else:
+        lgc(token, args)
 
-def vlt(filename,token,args):
+def vlt(filename,token,args, erro):
     from lexical import tokenize
     print ('#' * 80)
     file = open(filename, "r")
     file.close()
     print('{:15}'.format('Token'), '{:29}'.format('Lexema'), '{:10}'.format('Linha'), '{:10}'.format('Coluna'))
     i = 0
-    for tok in tokenize(arquivo,args):
+    for tok in tokenize(arquivo,args, erro):
         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):
+def lt(filename, token, args, erro):
     from lexical import tokenize
     file = open(filename, "r")
     arquivo = file.read()
     file.close()
-    for tok in tokenize(arquivo,args):
+    for tok in tokenize(arquivo,args,erro):
         token.append(tok)
-def ls(token,args):
+def ls(token,args,erro):
     from beuty import initsintatico
-    initsintatico(token,args)
-def lse(token,args):
+    initsintatico(token,args,erro)
+def lse(token,args,erro):
     from semantico import semantico
-    semantico(token,args)
+    semantico(token,args,erro)
 def lgc(token,args):
     from  Geracaodecodigo import gerarcodigo
     gerarcodigo(token,args)

semantico.py

-def semantico(token, args):
-    Avariaveis(token, args)
-def divisao(token, args, lista):
+def semantico(token, args, erro):
+    Avariaveis(token, args,erro)
+def divisao(token, args, lista,erro):
     linha = []
+    i=0
     if args.lse:
         print("Verificando Divisão por Zero.")
-
-def verificando(lista):
-    for exp in lista.values():
-        if 'î' not in exp:
+    while (i < len(token)):
+        if 'recebe' in token[i][0]:
+            j=i+1
+            variavel = token[i-1][1]
             try:
-                eval(''.join(exp))
-            except ZeroDivisionError:
-                from colorama import Style
-                Color()
-                print (f' Divisão por Zero {exp} '+ Style.RESET_ALL)
+                while not 'fim_linha' in token[j][0]:
+                    if (str(token[j][1][0])).isdigit():
+                        linha.append(str(token[j][1][0]))
+                    else:
+                        linha.append(token[j][1])
+                    j+=1
+            except IndexError:
+                break
+            if verificando(variavel, linha, lista, erro):
+                erro.append(f'linha:{token[i][2]}')
+            linha.clear()
+        i+=1
+
+def verificando(variavel, linha, lista,erro):
+    i=0
+    antigo=''.join(linha)
+    while i<len(linha):
+        if linha[i].isidentifier:
+            if linha[i] in lista:
+                linha[i]=lista[linha[i]]
+            else:
+                pass
+        i+=1
+    try:
+        expre=''.join(linha)
+        eval(expre)
+    except ZeroDivisionError:
+        erro.append('########################################################')
+        erro.append('Erro semantico:')
+        erro.append(f'Divisão por Zero {antigo}')
+        return 1
+    lista[variavel]=str(eval(''.join(linha)))
+    return 0
+
 def trocandoValores(lista,a,key):
     import re
     for exp in lista.keys():
             a=re.sub(r''+exp, (''.join(lista[exp])),''.join(a))
     lista[key] = ''.join(a)
 
-def Avariaveis(token, args):
+def Avariaveis(token, args,erro):
     variaveis = {}
     if args.lse:
         print ('#' * 80)
     for var in token:
         if 'id' in var and var[2] == 2:
             if var[1] not in variaveis:
-                variaveis[var[1]] = 'î'
+                variaveis[var[1]] = '0'
             else:
-                Color()
-                print(f'\'{var[1]}\' declaração duplicada: ' + reset(var))
+                erro.append('########################################################')
+                erro.append('Erro semantico:')
+                erro.append(f'\'{var[1]}\' declaração duplicada: ')
 
     if args.lse:
         print("Variaveis 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
+                erro.append('########################################################')
+                erro.append('Erro semantico:')
+                erro.append(f'Variavel \'{code[1]}\' não declarado: linha{code[2]} : coluna{code[3]}')
+    divisao(token, args, variaveis, erro)

sintatico.py

-def analisadorsintatico(dict1, dict2, programa, args):
+def analisadorsintatico(dict1, dict2, programa, args,erro):
     pilha = ["<INICIO>"]#inicializa a pilha com o Não terminal inicial
     if args.ls : #Se verdadeiro mostra a mensagem a seguir
         print ('#'*80)
                 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)
+                erro.append('########################################################')
+                erro.append('Erro sintático')
+                erro.append(f"\'{programa[i-1][1]}\' inesperado linha {programa[i-1][2]}, coluna {programa[i-1][3]}")#
+                erro.append(f"Era esperado: {' '.join(a)}")
                 args.ls = False
                 break
     if args.ls:#Se for True imprime a mensagem