compilador_lpd.py

import tkinter as tk
from tkinter import filedialog, scrolledtext, ttk, messagebox
import os

class Token:
    """
    Representa um token identificado pelo analisador léxico.
    
    Atributos:
        lexema: A sequência de caracteres que forma o token
        simbolo: A classificação do token (sidentificador, snumero, etc.)
        linha: Número da linha onde o token foi encontrado no código fonte
    """
    def __init__(self, lexema, simbolo, linha):
        self.lexema = lexema
        self.simbolo = simbolo
        self.linha = linha
    
    def __repr__(self):
        return f"Token(Linha: {self.linha}, Lexema: '{self.lexema}', Simbolo: '{self.simbolo}')"

class Simbolo:
    """
    Representa um símbolo na tabela de símbolos (variável, função, procedimento).
    
    Atributos:
        lexema: Nome do identificador
        nivel: Nível de escopo (0=global, 1=função, etc.)
        tipo: Tipo do símbolo (variável inteiro, funcao, procedimento, etc.)
        rotulo: Rótulo de memória para funções/procedimentos
        memoria: Posição de memória para variáveis
    """
    def __init__(self, lexema, nivel, tipo="indefinido", rotulo=None, memoria=None):
        self.lexema = lexema
        self.tipo = tipo
        self.nivel = nivel
        self.rotulo = rotulo
        self.memoria = memoria
    
    def __repr__(self):
        return f"Lexema: {self.lexema:<15} | Tipo: {self.tipo:<20} | Nível: {self.nivel} | Mem: {self.memoria}"

class TabelaDeSimbolos:
    """
    Gerencia a tabela de símbolos do compilador, armazenando informações sobre
    variáveis, funções e procedimentos declarados.
    """
    def __init__(self):
        self.pilha_simbolos = []  # Lista de símbolos organizados por ordem de declaração
    
    def insere(self, simbolo):
        """Insere um novo símbolo na tabela."""
        self.pilha_simbolos.append(simbolo)
    
    def consulta_duplicado_no_escopo(self, lexema_busca, nivel_busca):
        """
        Verifica se já existe um símbolo com o mesmo nome no mesmo nível de escopo.
        Usado para detectar declarações duplicadas.
        """
        for simbolo in self.pilha_simbolos:
            if simbolo.lexema == lexema_busca and simbolo.nivel == nivel_busca:
                return True
        return False
    
    def desempilha_nivel(self, nivel):
        """
        Remove todos os símbolos de um determinado nível de escopo.
        Chamado ao sair de um bloco (função, procedimento, etc.).
        """
        self.pilha_simbolos = [s for s in self.pilha_simbolos if s.nivel < nivel]
        
    def define_tipo_para_variaveis(self, lista_de_lexemas, tipo_novo):
        """
        Define o tipo para uma lista de variáveis declaradas.
        Percorre a lista de trás para frente para pegar a declaração mais recente (funcionamento de uma pilha).
        """
        for lexema in lista_de_lexemas:
            for simbolo in reversed(self.pilha_simbolos):
                if simbolo.lexema == lexema and simbolo.tipo == "indefinido":
                    simbolo.tipo = f"variável {tipo_novo}"
                    break
    
    def get_tabela_completa(self):
        """Retorna a lista completa de símbolos."""
        return self.pilha_simbolos
    
    def consulta_simbolo(self, lexema_busca):
        """
        Busca um símbolo na tabela pelo nome (lexema).
        Busca do escopo mais interno para o mais externo (pilha).
        Retorna None se não encontrar.
        """
        for simbolo in reversed(self.pilha_simbolos):
            if simbolo.lexema == lexema_busca:
                return simbolo
        return None

class AnalisadorLexical:
    """
    Realiza a análise léxica do código fonte, identificando e classificando tokens.
    
    O analisador processa o código caractere por caractere, reconhecendo:
    - Palavras reservadas (programa, inicio, fim, etc.)
    - Identificadores (nomes de variáveis, funções)
    - Números
    - Operadores (aritméticos, relacionais, lógicos)
    - Símbolos de pontuação
    - Comentários (entre chaves {})
    """
    def __init__(self, codigo_fonte):
        # Dicionário de palavras reservadas da linguagem
        self.palavras_reservadas = {
            "programa":"sprograma","inicio":"sinicio","fim":"sfim","procedimento":"sprocedimento",
            "funcao":"sfuncao","se":"sse","entao":"sentao","senao":"ssenao","enquanto":"senquanto",
            "faca":"sfaca","escreva":"sescreva","leia":"sleia","var":"svar","inteiro":"sinteiro",
            "booleano":"sbooleano","verdadeiro":"sverdadeiro","falso":"sfalso","div":"sdiv",
            "e":"se","ou":"sou","nao":"snao"
        }
        # Símbolos de pontuação reconhecidos
        self.simbolos_pontuacao = {
            ".":"sponto",";":"sponto_virgula",",":"svirgula",
            "(":"sabre_parenteses",")":"sfecha_parenteses"
        }
        # Operadores aritméticos
        self.simbolos_aritmeticos = { "+":"smais", "-":"smenos", "*":"smult" }
        
        self.codigo_fonte = codigo_fonte  # Código fonte a ser analisado
        self.ponteiro = 0  # Posição atual no código fonte
        self.linha_atual = 1  # Linha atual (para mensagens de erro)

    def _proximo_caractere(self):
        """
        Avança para o próximo caractere no código fonte.
        Incrementa o contador de linhas quando encontra quebra de linha.
        """
        if self.ponteiro < len(self.codigo_fonte):
            char = self.codigo_fonte[self.ponteiro]
            self.ponteiro += 1
            if char == '\n':
                self.linha_atual += 1
            return char
        return None

    def _olhar_a_frente(self):
        """
        Retorna o próximo caractere sem avançar o ponteiro (lookahead).
        Usado para decisões que precisam ver o próximo caractere.
        """
        if self.ponteiro < len(self.codigo_fonte):
            return self.codigo_fonte[self.ponteiro]
        return None

    def trata_identificador_e_palavra_reservada(self, char):
        """
        Processa identificadores e palavras reservadas.
        Continua lendo enquanto encontrar letras, dígitos ou underscore.
        Verifica se é palavra reservada; caso contrário, classifica como identificador.
        """
        ident = char
        while self._olhar_a_frente() and (self._olhar_a_frente().isalnum() or self._olhar_a_frente() == '_'):
            ident += self._proximo_caractere()
        return Token(ident, self.palavras_reservadas.get(ident, "sidentificador"), self.linha_atual)

    def trata_digito(self, char):
        """
        Processa números inteiros.
        Continua lendo enquanto encontrar dígitos.
        """
        num = char
        while self._olhar_a_frente() and self._olhar_a_frente().isdigit():
            num += self._proximo_caractere()
        return Token(num, "snumero", self.linha_atual)

    def trata_atribuicao(self, char):
        """
        Trata o operador de atribuição (:=) ou dois-pontos (:).
        Se encontrar ':=' retorna token de atribuição, senão retorna dois-pontos.
        """
        if self._olhar_a_frente() == '=':
            return Token(char + self._proximo_caractere(), "satribuicao", self.linha_atual)
        else:
            return Token(char, "sdoispontos", self.linha_atual)

    def trata_operador_aritmetico(self, char):
        """Processa operadores aritméticos: +, -, *"""
        return Token(char, self.simbolos_aritmeticos.get(char), self.linha_atual)

    def trata_operador_relacional(self, char):
        """
        Processa operadores relacionais: >, >=, <, <=, =, !=
        Alguns operadores são compostos (>=, <=, !=), então usa lookahead.
        """
        lexema = char
        if char == '>':
            if self._olhar_a_frente() == '=':
                lexema += self._proximo_caractere()
                return Token(lexema, "smaiorig", self.linha_atual)
            return Token(lexema, "smaior", self.linha_atual)
        elif char == '<':
            if self._olhar_a_frente() == '=':
                lexema += self._proximo_caractere()
                return Token(lexema, "smenorig", self.linha_atual)
            return Token(lexema, "smenor", self.linha_atual)
        elif char == '!':
            if self._olhar_a_frente() == '=':
                lexema += self._proximo_caractere()
                return Token(lexema, "sdif", self.linha_atual)
            raise SyntaxError(f"Erro Léxico (linha {self.linha_atual}): Caractere '!' inesperado.")
        elif char == '=':
            return Token(lexema, "sig", self.linha_atual)
        return None

    def trata_pontuacao(self, char):
        """Processa símbolos de pontuação: . ; , ( )"""
        return Token(char, self.simbolos_pontuacao.get(char), self.linha_atual)

    def pega_token(self):
        """
        Retorna o próximo token do código fonte.
        
        - Ignora espaços em branco
        - Trata comentários entre chaves {}
        - Identifica o tipo de token e delega para função específica
        - Retorna None quando chega ao fim do código
        """
        char = self._proximo_caractere()
        # Ignora espaços em branco
        while char is not None and char.isspace():
            char = self._proximo_caractere()
        
        if char is None:
            return None

        # Trata comentários entre chaves {}
        if char == '{':
            linha_comentario = self.linha_atual
            char = self._proximo_caractere()
            while char != '}' and char is not None:
                char = self._proximo_caractere()
            if char is None:
                raise SyntaxError(f"Erro Léxico (linha {linha_comentario}): Comentário não foi fechado.")
            return self.pega_token()

        # Identifica tipo do token e delega processamento
        if char.isalpha():
            return self.trata_identificador_e_palavra_reservada(char)
        if char.isdigit():
            return self.trata_digito(char)
        if char == ':':
            return self.trata_atribuicao(char)
        if char in "+-*":
            return self.trata_operador_aritmetico(char)
        if char in "><!=":
            return self.trata_operador_relacional(char)
        if char in ".;,()":
            return self.trata_pontuacao(char)

        raise SyntaxError(f"Erro Léxico (linha {self.linha_atual}): Caractere '{char}' desconhecido.")

class AnalisadorSintatico:
    """
    Realiza a análise sintática e semântica do código fonte.
    
    Implementa um analisador descendente recursivo baseado na gramática da linguagem LPD.
    Também realiza:
    - Análise semântica (verificação de tipos, declarações, escopos)
    - Geração de código para a máquina virtual
    - Conversão de expressões para notação pós-fixa
    """
    def __init__(self, analisador_lexico):
        self.lexico = analisador_lexico  # Analisador léxico para obter tokens
        self.token_atual = None  # Token sendo processado atualmente
        self.tabela_de_simbolos = TabelaDeSimbolos()  # Tabela de símbolos para análise semântica
        self.nivel_atual = 0  # Nível de escopo atual (0=global, 1=função, etc.)

        # --- ESTRUTURAS PARA GERAÇÃO DE CÓDIGO ---
        self.codigo_gerado = []  # Lista com as linhas de código assembly gerado
        self.rotulo_count = 1  # Contador para gerar rótulos únicos
        self.memoria_count = 1  # Contador de posições de memória (começa em 1, pois 0 é reservado para retorno de função)

        # Estruturas para conversão de expressões infixa -> posfixa
        self.postfix_output = []  # Saída em notação pós-fixa
        self.operator_stack = []  # Pilha de operadores

        # Tabela de precedência de operadores (maior número = maior precedência)
        self.precedencia = {
            'smais_unario': 9, 'smenos_unario': 9,
            'smult': 8, 'sdiv': 8,
            'smais': 7, 'smenos': 7,
            'smaior': 6, 'smaiorig': 6, 'sig': 6, 'smenor': 6, 'smenorig': 6, 'sdif': 6,
            'snao': 5,
            'se': 4,
            'sou': 3,
        }

    def _gera_codigo(self, rotulo, instrucao, p1, p2):
        """
        Gera uma linha de código assembly para a máquina virtual.
        
        Args:
            rotulo: Rótulo da linha (para saltos/chamadas) ou string vazia
            instrucao: Nome da instrução (LDC, ADD, JMP, etc.)
            p1: Primeiro parâmetro (ou None)
            p2: Segundo parâmetro (ou None)
        """
        p1_str = str(p1) if p1 is not None else ""
        p2_str = str(p2) if p2 is not None else ""
        linha = f"{rotulo:<5} {instrucao:<10} {p1_str:<5} {p2_str:<5}\n"
        self.codigo_gerado.append(linha)

    def _novo_rotulo(self):
        """
        Gera um novo rótulo único para uso em saltos e chamadas.
        Incrementa o contador de rótulos.
        """
        rotulo = str(self.rotulo_count)
        self.rotulo_count += 1
        return rotulo

    def _gera_codigo_posfix(self, expressao_posfixa):
        """
        Gera código assembly a partir de uma expressão em notação pós-fixa.
        
        Percorre a lista de tokens pós-fixa e gera instruções correspondentes:
        - Operandos (números, variáveis): LDC/LDV
        - Operadores: ADD, SUB, MULT, DIVI, etc.
        - Funções: CALL + LDV
        """
        for token in expressao_posfixa:
            if token.simbolo == 'sidentificador':
                simbolo = self.tabela_de_simbolos.consulta_simbolo(token.lexema)
                
                if simbolo.tipo.startswith("variável_retorno"):
                    for s in reversed(self.tabela_de_simbolos.pilha_simbolos):
                        if s.lexema == token.lexema and s.tipo.startswith("funcao"):
                            simbolo = s
                            break
                
                if simbolo.tipo.startswith("funcao"):
                    self._gera_codigo("", "CALL", simbolo.rotulo, "")
                    self._gera_codigo("", "LDV", "0", "") 
                else: 
                    self._gera_codigo("", "LDV", simbolo.memoria, "")
            
            elif token.simbolo == 'snumero': self._gera_codigo("", "LDC", token.lexema, "")
            elif token.simbolo == 'sverdadeiro': self._gera_codigo("", "LDC", "1", "")
            elif token.simbolo == 'sfalso': self._gera_codigo("", "LDC", "0", "")
            elif token.simbolo == 'smais_unario': pass
            elif token.simbolo == 'smenos_unario': self._gera_codigo("", "INV", "", "")
            elif token.simbolo == 'snao': self._gera_codigo("", "NEG", "", "")
            elif token.simbolo == 'smais': self._gera_codigo("", "ADD", "", "")
            elif token.simbolo == 'smenos': self._gera_codigo("", "SUB", "", "")
            elif token.simbolo == 'smult': self._gera_codigo("", "MULT", "", "")
            elif token.simbolo == 'sdiv': self._gera_codigo("", "DIVI", "", "")
            elif token.simbolo == 'se': self._gera_codigo("", "AND", "", "")
            elif token.simbolo == 'sou': self._gera_codigo("", "OR", "", "")
            elif token.simbolo == 'smaior': self._gera_codigo("", "CMA", "", "")
            elif token.simbolo == 'smaiorig': self._gera_codigo("", "CMAQ", "", "")
            elif token.simbolo == 'smenor': self._gera_codigo("", "CME", "", "")
            elif token.simbolo == 'smenorig': self._gera_codigo("", "CMEQ", "", "")
            elif token.simbolo == 'sig': self._gera_codigo("", "CEQ", "", "")
            elif token.simbolo == 'sdif': self._gera_codigo("", "CDIF", "", "")

    def _proximo_token(self):
        """Avança para o próximo token do código fonte."""
        self.token_atual = self.lexico.pega_token()

    def _consome(self, simbolo_esperado):
        """
        Consome (verifica e avança) um token esperado.
        
        Se o token atual não for o esperado, lança erro sintático.
        Args:
            simbolo_esperado: O símbolo do token esperado (ex: 'sprograma', 'sidentificador')
        """
        if self.token_atual and self.token_atual.simbolo == simbolo_esperado:
            self._proximo_token()
        else:
            linha = self.token_atual.linha if self.token_atual else "fim"
            esperado = simbolo_esperado[1:] if simbolo_esperado.startswith('s') else simbolo_esperado
            encontrado = self.token_atual.lexema if self.token_atual else "fim de arquivo"
            raise SyntaxError(f"Erro Sintático (linha {linha}): Esperado '{esperado}', mas encontrado '{encontrado}'.")

    def analisar(self):
        """
        Inicia a análise sintática e semântica do programa.
        Retorna a lista de linhas de código assembly gerado.
        """
        self._proximo_token()
        self._analisa_programa()
        return self.codigo_gerado

    # --- MÉTODOS DE ANÁLISE SINTÁTICA E SEMÂNTICA ---

    def _analisa_programa(self):
        """
        Analisa a estrutura principal do programa.
        Gramática: programa <identificador> ; <bloco> .
        
        Gera código de inicialização e finalização do programa.
        """
        self._gera_codigo("", "START", "", "")
        self._gera_codigo("", "ALLOC", "0", "1")  # Aloca retorno de função (M[0])
        
        self._consome('sprograma')
        
        # Verificação semântica: programa não pode ter nome duplicado
        if self.tabela_de_simbolos.consulta_duplicado_no_escopo(self.token_atual.lexema, self.nivel_atual):
            raise SyntaxError(f"Erro Semântico (linha {self.token_atual.linha}): Nome de programa '{self.token_atual.lexema}' já usado.")
        self.tabela_de_simbolos.insere(Simbolo(self.token_atual.lexema, self.nivel_atual, "programa"))
        
        self._consome('sidentificador')
        self._consome('sponto_virgula')

        self._analisa_bloco()
        
        self._consome('sponto')
        self._gera_codigo("", "DALLOC", "0", "1")  # Libera retorno
        self._gera_codigo("", "HLT", "", "")
        
        # Verifica se há código após o fim do programa
        if self.token_atual is not None:
            raise SyntaxError(f"Erro Sintático (linha {self.token_atual.linha}): Código extra após o fim.")

    def _analisa_bloco(self):
        """
        Analisa um bloco de código (variáveis, sub-rotinas, comandos).
        Gramática: [var <declaração de variáveis>] [<declaração de sub-rotinas>] <comandos>
        
        Gerencia alocação e liberação de memória para variáveis locais.
        Gera salto sobre declarações de sub-rotinas.
        """
        memoria_antes = self.memoria_count  # Guarda posição de memória antes de alocar variáveis
        
        # 1. Declarações de variáveis
        if self.token_atual and self.token_atual.simbolo == 'svar':
            self._analisa_et_variaveis()
        
        # Gera ALLOC para variáveis locais
        vars_alocadas = self.memoria_count - memoria_antes
        if vars_alocadas > 0:
            self._gera_codigo("", "ALLOC", memoria_antes, vars_alocadas)
        
        # 2. Declarações de sub-rotinas (procedimentos/funções)
        if self.token_atual.simbolo in ['sprocedimento', 'sfuncao']:
            rotulo_inicio_comandos = self._novo_rotulo()
            self._gera_codigo("", "JMP", rotulo_inicio_comandos, "")  # Pula sobre sub-rotinas
            
            self._analisa_et_subrotinas()
            
            self._gera_codigo(rotulo_inicio_comandos, "NULL", "", "")  # Marca início dos comandos
        
        # 3. Comandos
        self._analisa_comandos()
        
        # Gera DALLOC para liberar variáveis locais
        if vars_alocadas > 0:
            self._gera_codigo("", "DALLOC", memoria_antes, vars_alocadas)

    def _analisa_et_variaveis(self):
        """
        Analisa a seção de declaração de variáveis.
        Gramática: var <variáveis> ; [<variáveis> ;]...
        """
        self._consome('svar')
        while self.token_atual and self.token_atual.simbolo == 'sidentificador':
            self._analisa_variaveis()
            self._consome('sponto_virgula')

    def _analisa_variaveis(self):
        """
        Analisa uma declaração de variáveis.
        Gramática: <identificador> [, <identificador>]... : <tipo>
        
        Insere variáveis na tabela de símbolos e aloca memória para cada uma.
        """
        lexemas_para_tipar = []  # Lista de variáveis para definir tipo depois
        
        while self.token_atual and self.token_atual.simbolo == 'sidentificador':
            # Verificação semântica: variável duplicada no mesmo escopo
            if self.tabela_de_simbolos.consulta_duplicado_no_escopo(self.token_atual.lexema, self.nivel_atual):
                raise SyntaxError(f"Erro Semântico (linha {self.token_atual.linha}): Variável '{self.token_atual.lexema}' já declarada.")
            
            lexemas_para_tipar.append(self.token_atual.lexema)
            # Insere símbolo com endereço de memória
            self.tabela_de_simbolos.insere(Simbolo(self.token_atual.lexema, self.nivel_atual, memoria=self.memoria_count))
            self.memoria_count += 1
            
            self._consome('sidentificador')
            if self.token_atual and self.token_atual.simbolo == 'svirgula':
                self._consome('svirgula')
        
        self._consome('sdoispontos')
        self._analisa_tipo(lexemas_para_tipar)

    def _analisa_tipo(self, lexemas_para_tipar):
        """
        Analisa e define o tipo para uma lista de variáveis.
        Gramática: inteiro | booleano
        """
        if self.token_atual and self.token_atual.simbolo in ['sinteiro', 'sbooleano']:
            self.tabela_de_simbolos.define_tipo_para_variaveis(lexemas_para_tipar, self.token_atual.lexema)
            self._proximo_token()
        else:
            raise SyntaxError(f"Erro Sintático (linha {self.token_atual.linha}): Tipo inválido.")

    def _analisa_et_subrotinas(self):
        """
        Analisa declarações de sub-rotinas (procedimentos e funções).
        Gramática: (<declaração de procedimento> | <declaração de função>) ; [...]
        """
        while self.token_atual and self.token_atual.simbolo in ['sprocedimento', 'sfuncao']:
            if self.token_atual.simbolo == 'sprocedimento':
                self._analisa_declaracao_procedimento()
            elif self.token_atual.simbolo == 'sfuncao':
                self._analisa_declaracao_funcao()
            self._consome('sponto_virgula')

    def _analisa_declaracao_procedimento(self):
        """
        Analisa declaração de procedimento.
        Gramática: procedimento <identificador> ; <bloco>
        
        Cria novo escopo, gera código com rótulo, e finaliza com RETURN.
        """
        self._consome('sprocedimento')
        nome_proc = self.token_atual.lexema
        
        # Verificação semântica: procedimento duplicado no mesmo escopo
        if self.tabela_de_simbolos.consulta_duplicado_no_escopo(nome_proc, self.nivel_atual):
            raise SyntaxError(f"Erro Semântico (linha {self.token_atual.linha}): Procedimento '{nome_proc}' já declarado.")
        
        rotulo_proc = self._novo_rotulo()
        self.tabela_de_simbolos.insere(Simbolo(nome_proc, self.nivel_atual, "procedimento", rotulo=rotulo_proc))
        
        self._consome('sidentificador')
        self._consome('sponto_virgula')
        
        # Entra em novo escopo
        self.nivel_atual += 1
        self._gera_codigo(rotulo_proc, "NULL", "", "")  # Marca início do procedimento
        self._analisa_bloco()
        self._gera_codigo("", "RETURN", "", "")  # Retorna ao chamador
        self.tabela_de_simbolos.desempilha_nivel(self.nivel_atual)  # Remove símbolos locais
        self.nivel_atual -= 1

    def _analisa_declaracao_funcao(self):
        """
        Analisa declaração de função.
        Gramática: funcao <identificador> : <tipo> ; <bloco>
        
        Funções retornam valor armazenado em M[0].
        Cria variável de retorno com mesmo nome da função no escopo interno.
        """
        self._consome('sfuncao')
        nome_funcao = self.token_atual.lexema
        
        # Verificação semântica: função duplicada no mesmo escopo
        if self.tabela_de_simbolos.consulta_duplicado_no_escopo(nome_funcao, self.nivel_atual):
            raise SyntaxError(f"Erro Semântico (linha {self.token_atual.linha}): Função '{nome_funcao}' já declarada.")
        
        rotulo_func = self._novo_rotulo()
        self._consome('sidentificador')
        self._consome('sdoispontos')

        # Verifica e obtém tipo de retorno
        if self.token_atual.simbolo not in ['sinteiro', 'sbooleano']:
            raise SyntaxError(f"Erro Sintático: Tipo inválido identificado na linha {self.token_atual.linha}.")
        tipo_retorno = self.token_atual.lexema
        self._proximo_token()
        self._consome('sponto_virgula')

        self.tabela_de_simbolos.insere(Simbolo(nome_funcao, self.nivel_atual, f"funcao {tipo_retorno}", rotulo=rotulo_func))
        
        # Entra em novo escopo
        self.nivel_atual += 1
        self._gera_codigo(rotulo_func, "NULL", "", "")
        
        # Insere variável de retorno (mesmo nome da função) em M[0]
        self.tabela_de_simbolos.insere(Simbolo(nome_funcao, self.nivel_atual, f"variável_retorno {tipo_retorno}", memoria=0))
        
        self._analisa_bloco()
        self._gera_codigo("", "RETURN", "", "")
        
        self.tabela_de_simbolos.desempilha_nivel(self.nivel_atual)
        self.nivel_atual -= 1

    def _analisa_comandos(self):
        """
        Analisa bloco de comandos.
        Gramática: inicio <comando simples> [; <comando simples>]... fim
        """
        self._consome('sinicio')
        self._analisa_comando_simples()
        while self.token_atual and self.token_atual.simbolo == 'sponto_virgula':
            self._consome('sponto_virgula')
            if self.token_atual and self.token_atual.simbolo != 'sfim':
                self._analisa_comando_simples()
        self._consome('sfim')

    def _analisa_comando_simples(self):
        """
        Analisa um comando simples e delega para função específica.
        Comandos: atribuição, chamada, se, enquanto, leia, escreva, bloco
        """
        if self.token_atual:
            if self.token_atual.simbolo == 'sidentificador':
                self._analisa_atribuicao_ou_chamada_proc()
            elif self.token_atual.simbolo == 'sse':
                self._analisa_se()
            elif self.token_atual.simbolo == 'senquanto':
                self._analisa_enquanto()
            elif self.token_atual.simbolo == 'sleia':
                self._analisa_leia()
            elif self.token_atual.simbolo == 'sescreva':
                self._analisa_escreva()
            elif self.token_atual.simbolo == 'sinicio':
                self._analisa_comandos()
            else:
                raise SyntaxError(f"Erro Sintático: Comando inválido na linha {self.token_atual.linha}.")

    def _analisa_atribuicao_ou_chamada_proc(self):
        """
        Analisa atribuição ou chamada de procedimento.
        Ambos começam com identificador, decide pelo próximo token.
        
        Gramática: 
        - Atribuição: <identificador> := <expressão>
        - Chamada: <identificador>
        """
        lexema = self.token_atual.lexema
        line = self.token_atual.linha
        
        # Verificação semântica: identificador foi declarado?
        simbolo = self.tabela_de_simbolos.consulta_simbolo(lexema)
        if not simbolo:
            raise SyntaxError(f"Erro Semântico (linha {line}): Identificador '{lexema}' não declarado.")
        
        self._consome('sidentificador')

        if self.token_atual and self.token_atual.simbolo == 'satribuicao':
            # Atribuição: verifica se é variável e compatibilidade de tipos
            if not (simbolo.tipo.startswith("variável") or simbolo.tipo.startswith("variável_retorno")):
                 raise SyntaxError(f"Erro Semântico (linha {line}): '{lexema}' não é variável.")
            
            self._consome('satribuicao')
            
            # Análise da expressão em notação posfixa
            tipo_expr = self._analisa_expressao_e_gera_posfix()
            self._gera_codigo_posfix(self.postfix_output)  # Gera código da expressão
            self._gera_codigo("", "STR", simbolo.memoria, "")  # Armazena resultado em M[memoria]

            # Verificação semântica: compatibilidade de tipos
            tipo_var = 'inteiro' if 'inteiro' in simbolo.tipo else 'booleano'
            if tipo_var != tipo_expr:
                raise SyntaxError(f"Erro Semântico (linha {line}): Tipos incompatíveis na atribuição.")
        else:
            # Chamada de procedimento: verifica tipo
            if simbolo.tipo != "procedimento":
                raise SyntaxError(f"Erro Semântico (linha {line}): '{lexema}' não é procedimento.")
            self._gera_codigo("", "CALL", simbolo.rotulo, "")  # Chama procedimento

    def _analisa_se(self):
        """
        Analisa comando condicional SE.
        Gramática: se <expressão> entao <comando simples> [senao <comando simples>]
        
        Geração de código:
        - JMP condicional para 'senao' ou fim
        - Estrutura com rótulos para controle de fluxo
        """
        self._consome('sse')
        tipo = self._analisa_expressao_e_gera_posfix()
        
        # Verificação semântica: condição deve ser booleana
        if tipo != "booleano":
            raise SyntaxError(f"Erro Semântico: Condição do 'se' não é booleana na linha {self.token_atual.linha}.")
        
        self._gera_codigo_posfix(self.postfix_output)
        rotulo_falso = self._novo_rotulo()  # Rótulo para parte falsa ou fim
        self._gera_codigo("", "JMPF", rotulo_falso, "")  # Pula se falso
        
        self._consome('sentao')
        self._analisa_comando_simples()  # Parte verdadeira
        
        if self.token_atual and self.token_atual.simbolo == 'ssenao':
            rotulo_fim_se = self._novo_rotulo()  # Rótulo para fim do SE
            self._gera_codigo("", "JMP", rotulo_fim_se, "")  # Pula parte senao
            self._gera_codigo(rotulo_falso, "NULL", "", "")  # Marca início do senao
            self._consome('ssenao')
            self._analisa_comando_simples()  # Parte falsa
            self._gera_codigo(rotulo_fim_se, "NULL", "", "")  # Marca fim
        else:
            self._gera_codigo(rotulo_falso, "NULL", "", "")  # Marca fim (sem senao)

    def _analisa_enquanto(self):
        """
        Analisa comando de repetição ENQUANTO.
        Gramática: enquanto <expressão> faca <comando simples>
        
        Geração de código:
        - Rótulo no início para retorno (loop)
        - JMPF para sair quando condição falsa
        - JMP volta ao início
        """
        self._consome('senquanto')
        rotulo_inicio = self._novo_rotulo()  # Rótulo para início do loop
        rotulo_falso = self._novo_rotulo()   # Rótulo para saída do loop
        
        self._gera_codigo(rotulo_inicio, "NULL", "", "")  # Marca início
        tipo = self._analisa_expressao_e_gera_posfix()
        
        # Verificação semântica: condição deve ser booleana
        if tipo != "booleano":
            raise SyntaxError(f"Erro Semântico: Condição do 'enquanto' não é booleana na linha {self.token_atual.linha}.")

        self._gera_codigo_posfix(self.postfix_output)
        self._gera_codigo("", "JMPF", rotulo_falso, "")  # Sai se falso
        self._consome('sfaca')
        self._analisa_comando_simples()  # Corpo do loop
        self._gera_codigo("", "JMP", rotulo_inicio, "")  # Volta ao início
        self._gera_codigo(rotulo_falso, "NULL", "", "")  # Marca saída

    def _analisa_leia(self):
        """
        Analisa comando LEIA.
        Gramática: leia ( <identificador> )
        
        Lê entrada do usuário e armazena em variável inteira.
        """
        self._consome('sleia')
        self._consome('sabre_parenteses')
        simbolo = self.tabela_de_simbolos.consulta_simbolo(self.token_atual.lexema)
        
        # Verificação semântica: deve ser variável inteira
        if not simbolo or "inteiro" not in simbolo.tipo or "variável" not in simbolo.tipo:
            raise SyntaxError(f"Erro Semântico: 'leia' requer variável inteira na linha {self.token_atual.linha}.")
        
        self._gera_codigo("", "RD", "", "")  # Lê valor (topo da pilha)
        self._gera_codigo("", "STR", simbolo.memoria, "")  # Armazena em M[memoria]
        self._consome('sidentificador')
        self._consome('sfecha_parenteses')

    def _analisa_escreva(self):
        """
        Analisa comando ESCREVA.
        Gramática: escreva ( <identificador> )
        
        Imprime valor de variável ou retorno de função.
        """
        self._consome('sescreva')
        self._consome('sabre_parenteses')
        simbolo = self.tabela_de_simbolos.consulta_simbolo(self.token_atual.lexema)
        
        # Verificação semântica: declarado e não é procedimento
        if not simbolo or simbolo.tipo == "procedimento":
             raise SyntaxError(f"Erro Semântico: 'escreva' inválido na linha {self.token_atual.linha}.")
        
        if simbolo.tipo.startswith("funcao"):
             self._gera_codigo("", "CALL", simbolo.rotulo, "")  # Chama função
             self._gera_codigo("", "LDV", "0", "")  # Carrega retorno M[0]
        else:
             self._gera_codigo("", "LDV", simbolo.memoria, "")  # Carrega variável
        self._gera_codigo("", "PRN", "", "")  # Imprime topo da pilha
        self._consome('sidentificador')
        self._consome('sfecha_parenteses')

    def _analisa_expressao_e_gera_posfix(self):
        """
        Analisa expressão e converte para notação posfixa.
        
        Retorna tipo da expressão ('inteiro' ou 'booleano').
        Trata operadores unários (+, -, nao) e binários.
        Usa self.postfix_output (lista de tokens em posfix) e self.operator_stack (pilha de operadores).
        
        Retorna:
            str: Tipo da expressão resultante
        """
        self.postfix_output = []  # Lista de tokens em notação posfixa
        self.operator_stack = []  # Pilha de operadores

        # Tokens que terminam uma expressão no contexto atual
        fim_expressao = ['sponto_virgula', 'sfim', 'sentao', 'sfaca']

        # Flag para detectar operadores unários: True no início ou após operador/abre parênteses
        pode_ser_unario = True

        while self.token_atual and self.token_atual.simbolo not in fim_expressao:
            token = self.token_atual

            # Operandos (identificadores, números, valores booleanos)
            if token.simbolo in ['sidentificador', 'snumero', 'sverdadeiro', 'sfalso']:
                self.postfix_output.append(token)
                self._proximo_token()
                pode_ser_unario = False
                continue

            # Abre parênteses
            if token.simbolo == 'sabre_parenteses':
                self.operator_stack.append(token)
                self._proximo_token()
                pode_ser_unario = True
                continue

            # Fecha parênteses: desempilha até encontrar '('
            if token.simbolo == 'sfecha_parenteses':
                while self.operator_stack and self.operator_stack[-1].simbolo != 'sabre_parenteses':
                    self.postfix_output.append(self.operator_stack.pop())
                if not self.operator_stack:
                    raise SyntaxError(f"Erro Sintático (linha {token.linha}): Parênteses desbalanceados.")
                self.operator_stack.pop()  # Remove '('
                self._proximo_token()
                pode_ser_unario = False
                continue

            # Operador unário 'nao' (NOT lógico)
            if token.simbolo == 'snao':
                # 'nao' é unário associativo à direita, empilha diretamente
                op_token = Token(token.lexema, 'snao', token.linha)
                # Não desempilha 'snao' anterior para permitir encadeamento (associatividade à direita)
                self.operator_stack.append(op_token)
                self._proximo_token()
                pode_ser_unario = True
                continue

            # Operadores +/- (podem ser unários ou binários)
            if token.simbolo in ['smais', 'smenos']:
                if pode_ser_unario:
                    # Trata como operador unário
                    simbolo_unario = token.simbolo + "_unario"
                    op_token = Token(token.lexema, simbolo_unario, token.linha)
                    # Unários empilham direto (associatividade à direita)
                    self.operator_stack.append(op_token)
                    self._proximo_token()
                    pode_ser_unario = True
                    continue
                else:
                    # Trata como operador binário
                    op_token = token
                    # Desempilha operadores de maior/igual precedência
                    while (self.operator_stack and
                           self.operator_stack[-1].simbolo in self.precedencia and
                           self.precedencia[self.operator_stack[-1].simbolo] >= self.precedencia.get(op_token.simbolo, 0)):
                        self.postfix_output.append(self.operator_stack.pop())
                    self.operator_stack.append(op_token)
                    self._proximo_token()
                    pode_ser_unario = True
                    continue

            # Outros operadores binários (*, div, relacionais, e, ou)
            if token.simbolo in self.precedencia:
                op_token = token
                # Desempilha operadores de maior/igual precedência
                while (self.operator_stack and
                       self.operator_stack[-1].simbolo in self.precedencia and
                       self.precedencia[self.operator_stack[-1].simbolo] >= self.precedencia.get(op_token.simbolo, 0)):
                    self.postfix_output.append(self.operator_stack.pop())
                self.operator_stack.append(op_token)
                self._proximo_token()
                pode_ser_unario = True
                continue

            # Se chegou aqui, token não é parte da expressão - sai do loop
            break

        # Desempilha o que restar na pilha
        while self.operator_stack:
            op = self.operator_stack.pop()
            if op.simbolo == 'sabre_parenteses':
                raise SyntaxError(f"Erro Sintático (linha {op.linha}): Parênteses desbalanceados.")
            self.postfix_output.append(op)

        # Validação semântica: verifica tipos na expressão pós-fixa
        return self._analisa_semantica_posfix(self.postfix_output)

    def _analisa_semantica_posfix(self, posfix):
        """
        Valida tipos dos operandos e operadores na expressão posfixa.
        
        Usa pilha de tipos para verificar compatibilidade semântica.
        Regras:
        - Operações aritméticas (+,-,*,div): inteiro
        - Operações lógicas (e,ou,nao): booleano
        - Comparações (=,!=,<,>,<=,>=): tipos iguais, retorna booleano
        
        Args:
            posfix: Lista de tokens em notação posfixa
            
        Retorna:
            str: Tipo da expressão ('inteiro' ou 'booleano')
        """
        if not posfix:
            return "vazio"
        
        stack = []  # Pilha de tipos
        
        for token in posfix:
            # Operandos: empilha tipo correspondente
            if token.simbolo in ['snumero', 'sverdadeiro', 'sfalso', 'sidentificador']:
                if token.simbolo == 'snumero':
                    stack.append('inteiro')
                elif token.simbolo in ['sverdadeiro', 'sfalso']:
                    stack.append('booleano')
                elif token.simbolo == 'sidentificador':
                    sym = self.tabela_de_simbolos.consulta_simbolo(token.lexema)
                    stack.append('inteiro' if 'inteiro' in sym.tipo else 'booleano')
            
            # Operadores unários: valida tipo no topo da pilha
            elif token.simbolo in ['smais_unario', 'smenos_unario', 'snao']:
                if not stack:
                    raise SyntaxError(f"Erro Semântico: Expressão inválida na linha {token.linha}.")
                tipo = stack.pop()
                
                if token.simbolo == 'snao' and tipo != 'booleano':
                    raise SyntaxError(f"Erro Semântico: 'nao' exige booleano na linha {token.linha}.")
                if token.simbolo != 'snao' and tipo != 'inteiro':
                    raise SyntaxError(f"Erro Semântico: Operador unário exige inteiro na linha {token.linha}.")
                stack.append(tipo)
            
            # Operadores binários: valida dois operandos
            else:
                if len(stack) < 2:
                    raise SyntaxError(f"Erro Semântico: Faltam operandos na linha {token.linha}.")
                t2, t1 = stack.pop(), stack.pop()
                
                # Operações aritméticas: ambos devem ser inteiros
                if token.simbolo in ['smais', 'smenos', 'smult', 'sdiv']:
                    if t1 != 'inteiro' or t2 != 'inteiro':
                        raise SyntaxError(f"Erro Semântico: Operação aritmética exige inteiros na linha {token.linha}.")
                    stack.append('inteiro')
                
                # Operações lógicas: ambos devem ser booleanos
                elif token.simbolo in ['se', 'sou']:
                    if t1 != 'booleano' or t2 != 'booleano':
                        raise SyntaxError(f"Erro Semântico: Operação lógica exige booleanos na linha {token.linha}.")
                    stack.append('booleano')
                
                # Comparações: tipos devem ser iguais, retorna booleano
                else:
                    if t1 != t2:
                        raise SyntaxError(f"Erro Semântico: Tipos incompatíveis na comparação na linha {token.linha}.")
                    stack.append('booleano')
        
        if not stack:
            return "vazio"
        return stack[0]


# --- INTERFACE GRÁFICA (GUI) ---
class CompiladorGUI:
    """
    Interface gráfica para o compilador LPD.
    
    Fornece editor de código com numeração de linhas, área de resultados,
    visualização do código assembly gerado, e botões para carregar e compilar.
    """
    
    def __init__(self):
        """
        Inicializa a interface gráfica do compilador.
        Cria janela principal, editor de código, área de resultados e visualização de assembly.
        """
        # Janela principal
        self.janela = tk.Tk()
        self.janela.title("Compilador LPD")
        self.janela.geometry("1200x700")
        
        # Configuração de estilos
        self.style = ttk.Style()
        self.style.configure('TButton', padding=5)
        self.style.configure('TFrame', padding=5)
        
        # Frame principal e painel dividido
        self.frame_principal = ttk.Frame(self.janela)
        self.frame_principal.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        self.paned_window = ttk.PanedWindow(self.frame_principal, orient=tk.HORIZONTAL)
        self.paned_window.pack(fill=tk.BOTH, expand=True)
        
        # Frame esquerdo (editor e resultados)
        self.frame_esquerda = ttk.Frame(self.paned_window, width=700)
        self.paned_window.add(self.frame_esquerda, weight=2)
        
        # Editor de código fonte com numeração de linhas
        self.frame_entrada = ttk.LabelFrame(self.frame_esquerda, text="Código Fonte", padding=5)
        self.frame_entrada.pack(fill=tk.BOTH, expand=True)
        
        # Widget de números de linha
        self.numeros_linha = tk.Text(self.frame_entrada, width=4, padx=4, takefocus=0, border=0,
                                     background='#f0f0f0', state='disabled', wrap='none')
        self.numeros_linha.pack(side=tk.LEFT, fill=tk.Y)
        
        # Widget de entrada de código
        self.texto_entrada = scrolledtext.ScrolledText(self.frame_entrada, height=10, width=80, wrap='none')
        self.texto_entrada.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # Configuração de scroll sincronizado
        self.scrollbar_vertical = self.texto_entrada.vbar
        self.scrollbar_vertical.config(command=self.on_scroll_vertical)
        self.texto_entrada.config(yscrollcommand=self.on_text_scroll)
        
        # Eventos para atualizar números de linha
        self.texto_entrada.bind('<KeyRelease>', lambda e: self.janela.after(10, self.atualizar_numeros_linha))
        self.texto_entrada.bind('<Button-1>', lambda e: self.janela.after(10, self.atualizar_numeros_linha))
        self.texto_entrada.bind('<<Paste>>', lambda e: self.janela.after(10, self.atualizar_numeros_linha))
        self.texto_entrada.bind('<<Cut>>', lambda e: self.janela.after(10, self.atualizar_numeros_linha))

        # Frame de botões
        self.frame_botoes = ttk.Frame(self.frame_esquerda)
        self.frame_botoes.pack(fill=tk.X, pady=5)
        self.btn_carregar = ttk.Button(self.frame_botoes, text="Carregar Arquivo", command=self.carregar_arquivo)
        self.btn_carregar.pack(side=tk.LEFT, padx=5)
        self.btn_analisar = ttk.Button(self.frame_botoes, text="Analisar", command=self.analisar_codigo)
        self.btn_analisar.pack(side=tk.LEFT, padx=5)
        
        # Área de resultados da análise
        self.frame_saida = ttk.LabelFrame(self.frame_esquerda, text="Resultado da Análise", padding=5)
        self.frame_saida.pack(fill=tk.BOTH, expand=True)
        self.texto_saida = scrolledtext.ScrolledText(self.frame_saida, height=10)
        self.texto_saida.pack(fill=tk.BOTH, expand=True)
        
        # Frame direito (código assembly gerado)
        self.frame_direita = ttk.Frame(self.paned_window, width=500)
        self.paned_window.add(self.frame_direita, weight=1)
        self.frame_codigo = ttk.LabelFrame(self.frame_direita, text="Código Assembly Gerado", padding=5)
        self.frame_codigo.pack(fill=tk.BOTH, expand=True)
        self.texto_codigo_gerado = scrolledtext.ScrolledText(self.frame_codigo, height=10, font=("Courier New", 10))
        self.texto_codigo_gerado.pack(fill=tk.BOTH, expand=True)
        
        # Variáveis de controle
        self.arquivo_atual = None  # Caminho do arquivo carregado
        self.arquivos_carregados = 1  # Contador para nomes de arquivos automáticos

    def on_scroll_vertical(self, *args):
        """
        Sincroniza scroll vertical entre editor e números de linha.
        Chamado quando a scrollbar é movida.
        """
        self.texto_entrada.yview(*args)
        self.numeros_linha.yview(*args)

    def on_text_scroll(self, first, last):
        """
        Atualiza scrollbar e números de linha quando o texto é rolado.
        Chamado por eventos do mouse (roda) ou teclado.
        """
        self.scrollbar_vertical.set(first, last)
        self.numeros_linha.yview_moveto(first)
        self.janela.after(10, self.atualizar_numeros_linha)

    def get_total_linhas(self):
        """
        Retorna o número total de linhas no editor.
        
        Retorna:
            int: Número de linhas (0 se vazio)
        """
        # 'end-1c' ignora o newline automático no final do widget
        linhas = self.texto_entrada.index('end-1c').split('.')[0]
        if linhas == '1' and len(self.texto_entrada.get('1.0', 'end-1c')) == 0:
            return 0  # Retorna 0 se o widget estiver vazio
        return int(linhas)

    def atualizar_numeros_linha(self, event=None):
        """
        Atualiza a exibição dos números de linha no editor.
        Mantém sincronização vertical com o texto.
        """
        total_linhas = self.get_total_linhas()
        
        self.numeros_linha.config(state='normal')
        self.numeros_linha.delete('1.0', 'end')
        
        if total_linhas > 0:
            linhas_texto = "\n".join(str(i) for i in range(1, total_linhas + 1))
            self.numeros_linha.insert('1.0', linhas_texto)
        
        self.numeros_linha.config(state='disabled')
        
        # Alinha a visão vertical dos dois widgets
        self.numeros_linha.yview_moveto(self.texto_entrada.yview()[0])

    def carregar_arquivo(self):
        """
        Abre diálogo para selecionar e carregar arquivo de código fonte.
        Atualiza o editor com o conteúdo do arquivo.
        """
        arquivo = filedialog.askopenfilename(
            title="Selecionar arquivo",
            filetypes=[("Arquivos de texto", "*.txt"), ("Todos os arquivos", "*.*")]
        )
        if arquivo:
            try:
                with open(arquivo, 'r', encoding='utf-8') as f:
                    self.texto_entrada.delete('1.0', tk.END)
                    self.texto_entrada.insert('1.0', f.read())
                self.arquivo_atual = arquivo
                self.janela.after(10, self.atualizar_numeros_linha)
            except Exception as e:
                messagebox.showerror("Erro", f"Erro ao ler o arquivo: {str(e)}")

    def analisar_codigo(self):
        """
        Compila o código fonte no editor.
        Exibe resultado da compilação e código assembly gerado.
        Em caso de sucesso, salva arquivo .obj automaticamente.
        """
        codigo_fonte = self.texto_entrada.get('1.0', tk.END)
        self.texto_saida.delete('1.0', tk.END)
        self.texto_codigo_gerado.delete('1.0', tk.END)

        if not codigo_fonte.strip():
            self.texto_saida.insert('1.0', "Nenhum código fonte para analisar.")
            return

        try:
            # Análise léxica e sintática
            analisador_lexico = AnalisadorLexical(codigo_fonte)
            analisador_sintatico = AnalisadorSintatico(analisador_lexico)
            
            codigo_gerado = analisador_sintatico.analisar()
            
            self.texto_saida.insert('1.0', "Programa compilado com sucesso!")
            self.exibir_codigo_gerado(codigo_gerado)
            self.salvar_resultado()
            
        except SyntaxError as e:
            self.texto_saida.insert('1.0', f"--- ERRO NA COMPILAÇÃO ---\n{e}")

    def exibir_codigo_gerado(self, codigo_gerado_lista):
        """
        Exibe o código assembly gerado na área correspondente.
        
        Args:
            codigo_gerado_lista: Lista de strings com linhas de assembly
        """
        if codigo_gerado_lista:
            codigo_formatado = "".join(codigo_gerado_lista)
            self.texto_codigo_gerado.insert('1.0', codigo_formatado)
        else:
            self.texto_codigo_gerado.insert('1.0', "Nenhum código foi gerado.\n")

    def salvar_resultado(self):
        """
        Salva o código assembly gerado em arquivo .obj.
        Nome baseado no arquivo fonte carregado ou gerado automaticamente.
        """
        conteudo_codigo = self.texto_codigo_gerado.get('1.0', tk.END)
        
        if not conteudo_codigo.strip():
            messagebox.showwarning("Aviso", "Não há nada para salvar.")
            return
        
        if self.arquivo_atual:
            # Usa nome base do arquivo carregado
            nome_base = os.path.splitext(self.arquivo_atual)[0]
            arquivo_saida = nome_base + ".obj"
        else:
            # Gera nome automático
            arquivo_saida = "programa" + str(self.arquivos_carregados) + ".obj"
            self.arquivos_carregados += 1
            
        try:
            with open(arquivo_saida, 'w', encoding='utf-8') as f:
                f.write(conteudo_codigo)
        except Exception as e:
            messagebox.showerror("Erro", f"Erro ao salvar o arquivo: {str(e)}")

    def iniciar(self):
        """Inicia o loop principal da interface gráfica."""
        self.janela.mainloop()

if __name__ == "__main__":
    app = CompiladorGUI()
    app.iniciar()