maquina_virtual_lpd.py

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

class MVD:
    """
    Máquina Virtual Didática (MVD) - Interpretador LPD.
    
    Executa instruções assembly geradas pelo compilador LPD.
    """
    
    def __init__(self, gui_input_func, gui_output_func, gui_update_callback):
        """
        Inicializa a máquina virtual.
        
        Args:
            gui_input_func: Função para solicitar entrada do usuário (RD)
            gui_output_func: Função para exibir saída (PRN)
            gui_update_callback: Função para atualizar displays de debug
        """
        self.gui_input_func = gui_input_func
        self.gui_output_func = gui_output_func
        self.gui_update_callback = gui_update_callback
        self.reset()

    def reset(self):
        """
        Reinicia o estado da máquina virtual.
        Limpa programa, memória, pilha e registradores.
        """
        self.P = []  # Memória de programa (lista de instruções)
        self.M = [0] * 2000  # Memória de dados (pilha) (obs: tamanho fixo de 2000. valor definido pelo nosso grupo)
        self.i = 0  # Ponteiro de instrução (Program Counter)
        self.s = -1  # Ponteiro de pilha (Stack Pointer)
        self.labels = {}  # Mapeamento de rótulos para endereços
        self.running = False  # Estado de execução
        self.call_stack = []  # Pilha de chamadas (endereços de retorno)
        self.frames = []  # Frames de ativação (ponteiros de pilha)

    def load_program_from_file(self, file_path):
        """
        Carrega programa assembly de arquivo .obj.
        
        Formato de linha: [rótulo] instrução [param1] [param2]
        Parsing com espaçamento variável (split() ao invés de posições fixas).
        Registra rótulos após adicionar instrução à memória de programa.
        
        Args:
            file_path: Caminho do arquivo .obj
            
        Retorna:
            bool: True se carregou com sucesso, False caso contrário
        """
        self.reset()
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                program_lines = f.readlines()
            
            for line in program_lines:
                parts = line.split()
                
                if not parts:
                    continue
                
                # Variáveis para armazenar componentes da linha
                rotulo = None
                instrucao = None
                p1 = None
                p2 = None
                
                # Verifica se primeira parte é rótulo (número)
                if parts[0].isdigit():
                    rotulo = parts[0]
                    parts = parts[1:]  # Remove rótulo da lista
                
                # Obtém instrução (primeiro elemento restante)
                if len(parts) >= 1:
                    instrucao = parts[0]
                
                # Obtém primeiro parâmetro
                if len(parts) >= 2:
                    p1 = parts[1]
                
                # Obtém segundo parâmetro
                if len(parts) >= 3:
                    p2 = parts[2]
                
                # Adiciona instrução à memória de programa
                if instrucao:
                    self.P.append((instrucao, p1, p2))
                    
                    # Registra rótulo APÓS adicionar instrução (aponta para último comando)
                    if rotulo:
                        self.labels[rotulo] = len(self.P) - 1
                
            return True 
        
        except Exception as e:
            messagebox.showerror("Erro de Carga", f"Falha ao carregar o arquivo .obj: {e}")
            return False

    def _get_param_value(self, param, is_label=False):
        """
        Converte parâmetro para valor inteiro.
        
        Args:
            param: Parâmetro a ser convertido (string ou None)
            is_label: Se True, trata como rótulo de salto (JMP, JMPF, CALL)
                     Se False, trata como valor literal de memória
        
        Retorna:
            int: Valor convertido (endereço de rótulo ou valor literal)
        """
        if param is None:
            return 0
        if is_label and param in self.labels:
            return self.labels[param]
        try:
            return int(param)
        except ValueError:
            raise SyntaxError(f"Parâmetro inválido: {param}")
            
    def step(self):
        """
        Executa um único passo (uma instrução) do programa.
        
        Atualiza displays de debug após execução.
        Avança ponteiro de instrução se a instrução não modificou i.
        
        Retorna:
            bool: True se pode continuar executando, False se terminou ou erro
        """
        if not self.running:
            self.running = True
            
        if self.i >= len(self.P):
            self.running = False
            return False
            
        try:
            instr, p1, p2 = self.P[self.i]
            i_anterior = self.i  # Guarda posição antes da execução
            
            self.execute_instruction(instr, p1, p2)
            
            # Se instrução não alterou i (JMP, JMPF, CALL, RETURN), avança
            if self.i == i_anterior:
                self.i += 1
                
        except Exception as e:
            self.gui_output_func(f"--- ERRO DE EXECUÇÃO (linha {self.i}) ---\n{e}")
            self.running = False
            return False
        
        # Atualiza displays de debug
        if self.gui_update_callback:
            self.gui_update_callback()
            
        if not self.running:
            return False
            
        return True

    def execute_instruction(self, instr, p1, p2):
        """
        Executa uma instrução individual da MVD.
        
        Conjunto de instruções:
        - Controle: START, HLT, NULL, JMP, JMPF, CALL, RETURN
        - Memória: ALLOC, DALLOC, LDC, LDV, STR
        - Aritméticas: ADD, SUB, MULT, DIVI, INV
        - Lógicas: AND, OR, NEG
        - Comparação: CME, CMA, CEQ, CDIF, CMEQ, CMAQ
        - I/O: RD, PRN
        
        Args:
            instr: Nome da instrução
            p1: Primeiro parâmetro
            p2: Segundo parâmetro
        """
        # Funções auxiliares para manipulação de pilha
        def push(val):
            """Empilha valor (converte para string)"""
            self.s += 1
            if self.s >= len(self.M):
                raise IndexError("Stack overflow")
            self.M[self.s] = str(val)

        def pop():
            """Desempilha valor (converte para int)"""
            if self.s < 0:
                raise IndexError("Stack underflow")
            v = int(self.M[self.s])
            self.s -= 1
            return v
            
        def param_val(x):
            """Obtém valor de parâmetro (não é rótulo)"""
            return self._get_param_value(x)
        
        # Execução das instruções
        if instr == "START":
            # Inicializa pilha
            self.s = -1

        elif instr == "HLT":
            # Para execução
            self.gui_output_func("\nExecução terminada (HLT).")
            self.running = False

        elif instr == "ALLOC":
            # Aloca espaço na pilha, copiando valores da memória
            m = param_val(p1)  # Endereço base na memória
            n = param_val(p2)  # Quantidade de posições a serem alocadas
            for i in range(n):
                self.s += 1
                if self.s >= len(self.M):
                    raise IndexError("Stack overflow")
                self.M[self.s] = self.M[m + i]
        
        elif instr == "DALLOC":
            # Desaloca espaço, copiando valores de volta para memória
            m = param_val(p1)  # Endereço base na memória
            n = param_val(p2)  # Quantidade de posições a serem desalocadas
            for i in range(n - 1, -1, -1):
                if self.s < 0:
                    raise IndexError("Stack underflow")
                self.M[m + i] = self.M[self.s]
                self.s -= 1

        elif instr == "LDC":
            # Carrega constante na pilha
            push(param_val(p1))

        elif instr == "LDV":
            # Carrega valor da memória para pilha
            n = param_val(p1)
            push(self.M[n])
            
        elif instr == "STR":
            # Armazena topo da pilha na memória
            n = param_val(p1)
            val = pop()
            self.M[n] = str(val)
            
        # Operações aritméticas
        elif instr == "ADD":
            b = pop()
            a = pop()
            push(a + b)
            
        elif instr == "SUB":
            b = pop()
            a = pop()
            push(a - b)
            
        elif instr == "MULT":
            b = pop()
            a = pop()
            push(a * b)
            
        elif instr == "DIVI":
            b = pop()
            a = pop()
            if b == 0:
                raise ValueError("Divisão por zero.")
            push(int(a / b))
            
        elif instr == "INV":
            # Inverte sinal (negação aritmética)
            v = pop()
            push(-v)
            
        # Operações lógicas
        elif instr == "AND":
            b = pop()
            a = pop()
            push(1 if (a == 1 and b == 1) else 0)
            
        elif instr == "OR":
            b = pop()
            a = pop()
            push(1 if (a == 1 or b == 1) else 0)
            
        elif instr == "NEG":
            # Negação lógica (NOT)
            v = pop()
            push(1 - v)
            
        # Operações de comparação
        elif instr in ("CME","CMA","CEQ","CDIF","CMEQ","CMAQ"):
            b = pop()
            a = pop()
            if instr == "CME":
                push(1 if a < b else 0)
            elif instr == "CMA":
                push(1 if a > b else 0)
            elif instr == "CEQ":
                push(1 if a == b else 0)
            elif instr == "CDIF":
                push(1 if a != b else 0)
            elif instr == "CMEQ":
                push(1 if a <= b else 0)
            elif instr == "CMAQ":
                push(1 if a >= b else 0)
                
        # Instruções de controle de fluxo
        elif instr == "JMP":
            # Salto incondicional
            self.i = self._get_param_value(p1, is_label=True)
            
        elif instr == "JMPF":
            # Salto condicional (se falso)
            target = self._get_param_value(p1, is_label=True)
            cond = pop()
            if cond == 0:
                self.i = target
                
        elif instr == "NULL":
            # Instrução vazia (marca rótulos)
            pass
            
        elif instr == "CALL":
            # Chama subrotina
            target = self._get_param_value(p1, is_label=True)
            ret = self.i + 1  # Endereço de retorno
            push(ret)
            self.call_stack.append(ret)
            self.frames.append(self.s)
            self.i = target
            
        elif instr == "RETURN":
            # Retorna de subrotina
            if self.s < 0:
                raise RuntimeError("RETURN com pilha vazia.")
            ret = pop()  # Endereço de retorno
            if self.frames:
                self.frames.pop()
            if self.call_stack and self.call_stack[-1] == ret:
                self.call_stack.pop()
            self.i = ret
            
        # Instruções de I/O
        elif instr == "RD":
            # Lê entrada do usuário
            valor = self.gui_input_func()
            if valor is None:
                self.running = False
                raise Exception("Execução cancelada.")
            push(valor)
            
        elif instr == "PRN":
            # Imprime valor
            val = pop()
            self.gui_output_func(val)
            
        else:
            raise SyntaxError(f"Instrução desconhecida: {instr}")

        # Atualiza displays após execução
        if self.gui_update_callback:
            try:
                self.gui_update_callback()
            except Exception:
                pass


class MaquinaVirtualGUI:
    """
    Interface gráfica para a Máquina Virtual Didática (MVD).
    
    Fornece visualização do código assembly, estado da pilha, registradores,
    controles de execução (passo a passo ou contínua) e saída do programa.
    """
    
    def __init__(self):
        """
        Inicializa a interface gráfica da máquina virtual.
        Cria janela principal, MVD, e componentes de visualização/controle.
        """
        # Janela principal
        self.janela = tk.Tk()
        self.janela.title("Máquina Virtual Didática (MVD)")
        self.janela.geometry("1000x600")

        # Instância da máquina virtual
        self.mvd = MVD(self.pedir_input, self.imprimir_saida, self.atualizar_displays_debug)
        
        # Frame principal
        self.frame_principal = ttk.Frame(self.janela, padding=10)
        self.frame_principal.pack(fill=tk.BOTH, expand=True)

        # Frame esquerdo (controles e saída)
        self.frame_esquerda = ttk.Frame(self.frame_principal, width=400)
        self.frame_esquerda.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 5))

        # Botões de controle
        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 .obj", command=self.carregar_obj)
        self.btn_carregar.pack(side=tk.LEFT, padx=5)
        
        self.btn_executar = ttk.Button(self.frame_botoes, text="Executar", command=self.executar_programa, state="disabled")
        self.btn_executar.pack(side=tk.LEFT, padx=5)
        
        self.btn_step = ttk.Button(self.frame_botoes, text="Step (Passo)", command=self.executar_step, state="disabled")
        self.btn_step.pack(side=tk.LEFT, padx=5)
        
        # Área de saída do programa
        self.frame_saida = ttk.LabelFrame(self.frame_esquerda, text="Saída da Execução (PRN)", padding=5)
        self.frame_saida.pack(fill=tk.BOTH, expand=True, pady=5)
        
        self.texto_saida = scrolledtext.ScrolledText(self.frame_saida, height=15, font=("Courier New", 10), wrap="word")
        self.texto_saida.pack(fill=tk.BOTH, expand=True)

        # Frame direito (visualização de debug)
        self.frame_direita = ttk.Frame(self.frame_principal, width=600)
        self.frame_direita.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=(5, 0))
        
        # Notebook com abas de debug
        self.notebook_debug = ttk.Notebook(self.frame_direita)
        self.notebook_debug.pack(fill=tk.BOTH, expand=True)
        
        # Aba: Código Assembly
        self.tab_codigo = ttk.Frame(self.notebook_debug)
        self.notebook_debug.add(self.tab_codigo, text="Código Assembly (Memória P)")
        self.texto_codigo = scrolledtext.ScrolledText(self.tab_codigo, font=("Courier New", 10), wrap="none")
        self.texto_codigo.pack(fill=tk.BOTH, expand=True)
        self.texto_codigo.tag_config("highlight", background="yellow")  # Destaca instrução atual

        # Aba: Memória e Pilha
        self.tab_memoria = ttk.Frame(self.notebook_debug)
        self.notebook_debug.add(self.tab_memoria, text="Pilha de Memória (M)")
        self.texto_memoria = scrolledtext.ScrolledText(self.tab_memoria, font=("Courier New", 10), wrap="none")
        self.texto_memoria.pack(fill=tk.BOTH, expand=True)

    def carregar_obj(self):
        """
        Abre diálogo para carregar arquivo .obj e inicializa a MVD.
        Habilita botões de execução após carregar com sucesso.
        """
        arquivo = filedialog.askopenfilename(
            title="Selecionar arquivo .obj",
            filetypes=[("Arquivos Objeto", "*.obj"), ("Todos os arquivos", "*.*")]
        )
        if arquivo:
            if self.mvd.load_program_from_file(arquivo):
                self.texto_saida.delete('1.0', tk.END)
                self.texto_saida.insert('1.0', f"Arquivo '{os.path.basename(arquivo)}' carregado.\nPronto para executar.")
                self.btn_executar.config(state="normal")
                self.btn_step.config(state="normal")
                self.atualizar_displays_debug()
            else:
                self.btn_executar.config(state="disabled")
                self.btn_step.config(state="disabled")

    def executar_programa(self):
        """
        Executa o programa completo de forma contínua.
        Desabilita botões durante execução e reabilita ao final.
        """
        self.texto_saida.delete('1.0', tk.END)
        self.btn_executar.config(state="disabled")
        self.btn_step.config(state="disabled")
        self.btn_carregar.config(state="disabled")
        
        self.mvd.running = True
        self.executar_loop()

    def executar_loop(self):
        """
        Loop de execução contínua (chamado recursivamente via after).
        Executa um passo por iteração para manter GUI responsiva.
        """
        if self.mvd.running:
            if self.mvd.step():
                self.janela.after(1, self.executar_loop)  # Continua execução
            else:
                # Terminou execução
                self.btn_executar.config(state="normal")
                self.btn_step.config(state="normal")
                self.btn_carregar.config(state="normal")
                self.atualizar_displays_debug()
    
    def executar_step(self):
        """
        Executa um único passo (uma instrução).
        Permite depuração passo a passo do programa.
        """
        self.btn_executar.config(state="disabled")
        
        # Limpa saída se for primeiro passo
        if not self.mvd.running and self.mvd.i < len(self.mvd.P):
             self.texto_saida.delete('1.0', tk.END)
        
        if not self.mvd.step():
            # Terminou execução ou erro
            self.btn_executar.config(state="normal")
            self.btn_step.config(state="disabled")
        
    def atualizar_displays_debug(self):
        """
        Atualiza visualização de código e memória.
        Destaca instrução atual e topo da pilha.
        """
        # Atualiza visualização do código assembly
        self.texto_codigo.config(state="normal")
        self.texto_codigo.delete('1.0', tk.END)
        self.texto_codigo.tag_remove("highlight", "1.0", "end")
        
        for i, (instr, p1, p2) in enumerate(self.mvd.P):
            # Procura rótulo correspondente ao endereço
            rotulo = ""
            for label_name, address in self.mvd.labels.items():
                if address == i:
                    rotulo = label_name
                    
            linha = f"{rotulo:<5} {instr:<10} {p1 or '':<5} {p2 or '':<5}\n"
            self.texto_codigo.insert(tk.END, linha)
            
            # Destaca instrução atual
            if i == self.mvd.i:
                self.texto_codigo.tag_add("highlight", f"{i+1}.0", f"{i+1}.end")
                self.texto_codigo.see(f"{i+1}.0")  # Rola para mostrar instrução atual
        
        self.texto_codigo.config(state="disabled")

        # Atualiza visualização da memória e pilha
        self.texto_memoria.config(state="normal")
        self.texto_memoria.delete('1.0', tk.END)
        
        # Exibe registradores e estado
        self.texto_memoria.insert(tk.END, f"Ponteiro de Instrução - PC (i): {self.mvd.i}\n")
        self.texto_memoria.insert(tk.END, f"Ponteiro de Pilha - SP (s): {self.mvd.s}\n")
        self.texto_memoria.insert(tk.END, f"Endereço de Retorno (call stack): {self.mvd.call_stack}\n")
        self.texto_memoria.insert(tk.END, f"Frames: {self.mvd.frames}\n")
        self.texto_memoria.insert(tk.END, "--- Pilha de Memória (M) ---\n")

        # Exibe memória até topo da pilha + margem
        limite_display = max(20, self.mvd.s + 5)
        for i in range(limite_display):
            linha = f"M[{i}]: {self.mvd.M[i]}\n"
            self.texto_memoria.insert(tk.END, linha)

            # Destaca topo da pilha
            if i == self.mvd.s:
                 self.texto_memoria.tag_add("highlight", f"{i+6}.0", f"{i+6}.end")

        self.texto_memoria.tag_config("highlight", background="yellow")
        self.texto_memoria.config(state="disabled")

    def imprimir_saida(self, mensagem):
        """
        Exibe mensagem na área de saída do programa.
        
        Args:
            mensagem: Texto a ser exibido
        """
        self.texto_saida.insert(tk.END, f"{str(mensagem)}\n")
        self.janela.update_idletasks()

    def pedir_input(self):
        """
        Solicita entrada do usuário via diálogo.
        
        Retorna:
            int: Valor inteiro digitado pelo usuário (ou None se cancelado)
        """
        valor = simpledialog.askinteger("Entrada (RD)", "Digite um valor inteiro:", parent=self.janela)
        return valor

    def iniciar(self):
        """
        Inicia a interface gráfica e entra no loop principal.
        Atualiza displays iniciais antes de mostrar janela.
        """
        self.atualizar_displays_debug()
        self.janela.mainloop()

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