diff --git a/README.md b/README.md index ba98cf8..3b958fa 100644 --- a/README.md +++ b/README.md @@ -1,728 +1,514 @@ -# 🚀 Mini-Compilador Python# 🚀 Mini Compilador em Python +# 🚀 Mini Compilador em Python +Compilador didático implementado **conforme metodologia ensinada em aula**, para uma mini-linguagem C-like, cobrindo todas as fases clássicas de compilação: +- Análise léxica +- Análise sintática +- Análise semântica +- Geração de código intermediário (TAC / Quádruplas) +- Otimizações +- Geração de código assembly MIPS-like -Compilador didático implementado **conforme metodologia ensinada em aula**.Bem-vindo ao repositório do **Mini Compilador em Python**, um projeto acadêmico completo desenvolvido para a disciplina de Compiladores. +Projeto acadêmico para a disciplina de **Compiladores**. +--- +## 👥 Equipe -## 👥 EquipeEste projeto implementa um **compilador completo** para uma mini-linguagem C-like, cobrindo todas as fases: **análise léxica, sintática, semântica, geração de código intermediário, otimizações e geração de assembly**. - -- Lucas Farias - -- José Lucas ## 📚 Sobre o Projeto - -- Ester Araiz - -- Henrique NoronhaCompilador educacional que transforma código fonte em assembly MIPS-like, passando por todas as etapas clássicas de compilação com arquitetura modular e bem documentada. - - - ----### ✨ Características - - - -## 📁 Estrutura do Projeto (ORGANIZADA)- ✅ **Pipeline completo** de compilação - -- ✅ **Separação clara** de fases (léxico → sintático → semântico → IR → otimização → assembly) - -```- ✅ **Otimizações** (constant folding, dead code elimination, peephole) - -compilador-python/- ✅ **Análise semântica** robusta com detecção de erros - -│- ✅ **Suporte a funções** e chamadas aninhadas - -├── 🎯 compiler/ # PIPELINE PRINCIPAL (LL(1), CSE, Quádruplas)- ✅ **Código intermediário** (Three-Address Code - TAC) - -│ ├── lexer.py # Análise léxica (tokens)- ✅ **Geração de assembly** MIPS-like - -│ ├── parser_ll1.py # ✅ Parser LL(1) Top-Down (Recursive Descent)- ✅ **Totalmente testável** (cada módulo independente) - -│ ├── ast.py # Árvore Sintática Abstrata - -│ ├── analyzer.py # Análise semântica### 👥 Equipe - -│ ├── symbol_table.py # Tabela de símbolos - -│ ├── ir.py # Código intermediário (TAC + Quádruplas)- Lucas Farias - -│ ├── ir_generator.py # Gerador de IR- José Lucas - -│ ├── optimizer.py # ✅ Otimizações (CSE, CF, DCE, CP, AS)- Ester Araiz - -│ ├── peephole.py # Otimização Peephole- Henrique Noronha - -│ ├── codegen.py # Coordenador de geração de código - -│ ├── assembly.py # Gerador de Assembly MIPS-like## 📁 Estrutura do Repositório - -│ ├── main.py # Pipeline integrado - -│ └── __init__.py### 🆕 Nova Estrutura Modular (`/compiler`) - -│ - -├── 🚀 run.py # INTERFACE PRINCIPAL (use este!)``` - -│compilador-python/ - -├── 📝 tests/ # Arquivos de teste (.txt)├── README.md # Este arquivo - -│ ├── simples.txt # Expressão simples├── requirements.txt # Dependências - -│ ├── teste_cse.txt # Teste CSE├── test_compiler.py # Suite completa de testes - -│ ├── exemplo_professor.txt # Exemplo do professor│ - -│ └── ...├── compiler/ # ⭐ COMPILADOR MODULAR (NOVO) - -││ ├── README.md # Documentação detalhada - -├── 🎮 demos/ # Demonstrações e testes│ ├── __init__.py # Pacote Python - -│ ├── demo_completo.py│ ├── main.py # 🎯 Pipeline unificado - -│ ├── test_compiler.py│ ├── lexer.py # Etapa 2-3: Análise léxica - -│ └── teste_expressoes.py│ ├── parser.py # Etapa 4: Análise sintática - -││ ├── ast.py # Construção da AST - -├── 📚 docs_projeto/ # Documentação completa│ ├── analyzer.py # Etapa 5: Análise semântica - -│ ├── GUIA_RAPIDO.md│ ├── symbol_table.py # Tabela de símbolos - -│ ├── COMANDOS.md│ ├── ir.py # Definição de IR (TAC) +- Lucas Farias +- José Lucas +- Ester Araiz +- Henrique Noronha +- **Laura Barbosa** -│ └── README_OLD.md│ ├── ir_generator.py # Etapa 6: Geração de IR +--- -││ ├── optimizer.py # Framework de otimização +## 📚 Sobre o Projeto -└── 📦 old/ # Implementação anterior (referência)│ ├── peephole.py # Otimizações peephole +Este é um **compilador educacional** que transforma código fonte em **assembly MIPS-like**, passando por todas as etapas de compilação com uma arquitetura modular e bem documentada. -```│ ├── codegen.py # Coordenador de geração +Principais objetivos: -│ └── assembly.py # Etapa 7: Geração de assembly +- Servir como material de estudo para disciplinas de Compiladores +- Ilustrar um pipeline completo, de código-fonte até assembly +- Mostrar otimizações clássicas em código intermediário (TAC) ----│ +--- -├── src/ # Implementação original (legado) +## ✨ Características + +- ✅ **Pipeline completo** de compilação +- ✅ **Separação clara** de fases (léxico → sintático → semântico → IR → otimização → assembly) +- ✅ **Análise semântica robusta** com detecção de erros +- ✅ **Suporte a funções** e chamadas aninhadas +- ✅ **Código intermediário** (Three-Address Code - TAC + quádruplas) +- ✅ **Otimizações**: + - Constant folding + - Dead code elimination + - Copy propagation + - Common Subexpression Elimination (CSE) + - Peephole + - Simplificações algébricas +- ✅ **Geração de assembly** MIPS-like +- ✅ **Módulos independentes e testáveis** -## 🚀 Como Usar│ ├── lexer.py +--- +## 📁 Estrutura do Repositório + +```text +compilador-python/ +├── run.py # Interface principal (use este!) +├── README.md # Este arquivo +├── requirements.txt # Dependências +├── test_compiler.py # Suite de testes integrada + +├── compiler/ # ⭐ NOVO COMPILADOR MODULAR +│ ├── README.md # Documentação detalhada do módulo +│ ├── __init__.py +│ ├── main.py # 🎯 Pipeline unificado +│ ├── lexer.py # Análise léxica +│ ├── parser_ll1.py # Parser LL(1) (recursive descent) +│ ├── ast.py # Árvore Sintática Abstrata (AST) +│ ├── analyzer.py # Análise semântica +│ ├── symbol_table.py # Tabela de símbolos +│ ├── ir.py # Definição de IR (TAC, quádruplas) +│ ├── ir_generator.py # Geração de IR +│ ├── optimizer.py # Otimizações (CSE, CF, DCE, CP, AS) +│ ├── peephole.py # Otimizações peephole +│ ├── codegen.py # Coordena geração de código +│ └── assembly.py # Geração de assembly MIPS-like + +├── src/ # Implementação original (legado) +│ ├── lexer.py │ ├── parser.py - -### 📦 Instalação│ ├── codegen.py - +│ ├── codegen.py │ ├── symbol_table.py +│ ├── runtime.py +│ ├── interpreter.py +│ └── compiler_etapa7.py -```bash│ ├── runtime.py - -pip install -r requirements.txt│ ├── interpreter.py - -```│ └── compiler_etapa7.py - -│ - -### 💻 Modo 1: Linha de Comando├── tests/ # Arquivos de teste - +├── tests/ # Arquivos de teste +│ ├── simples.txt │ ├── hello_world.txt - -```bash│ ├── code.txt - -# Compilar expressão direta│ ├── test_functions.txt - -python run.py -e "5 + 3 * 2"│ └── test_nested_calls.txt - -│ - -# Compilar arquivo└── docs/ # Documentação - -python run.py -f tests/simples.txt ├── GUIA_DE_ESTUDOS.md # Guia completo de estudos - +│ ├── code.txt +│ ├── teste_cse.txt +│ ├── exemplo_professor.txt +│ ├── test_functions.txt +│ └── test_nested_calls.txt + +├── demos/ # Demonstrações +│ ├── demo_completo.py +│ └── teste_expressoes.py + +├── docs_projeto/ # Documentação do projeto +│ ├── GUIA_RAPIDO.md +│ ├── COMANDOS.md +│ └── README_OLD.md + +└── docs/ # Documentação teórica + ├── GUIA_DE_ESTUDOS.md ├── ETAPA7_AMBIENTES_EXECUCAO.md + └── RESUMO_ETAPA7.md +```` -# Modo verbose (mostra TODAS as fases) └── RESUMO_ETAPA7.md +--- -python run.py -f tests/exemplo_professor.txt``` +## 🚀 Como Usar +### 📦 Instalação +```bash +# 1. Clone o repositório +git clone https://github.com/Kl4uz/compilador-python.git +cd compilador-python -# Modo resumido## 🚀 Início Rápido +# 2. Instale as dependências +pip install -r requirements.txt +``` -python run.py -f tests/simples.txt --quiet +> Requer **Python 3.8+** -### Instalação +--- -# Salvar assembly +### 💻 Modo 1: Linha de Comando (run.py) -python run.py -f tests/code.txt -o output.asm```bash +#### Compilar expressão direta -```# 1. Clone o repositório +```bash +python run.py -e "5 + 3 * 2" +``` -git clone https://github.com/Kl4uz/compilador-python.git +#### Compilar arquivo -### 🎮 Modo 2: Interativo (REPL)cd compilador-python +```bash +python run.py -f tests/simples.txt +``` +#### Modo verbose (mostra TODAS as fases) +```bash +python run.py -f tests/exemplo_professor.txt --verbose +``` -```bash# 2. Instale as dependências +#### Modo quiet (saída resumida) -python run.pypip install -r requirements.txt +```bash +python run.py -f tests/simples.txt --quiet +``` -`````` +#### Salvar assembly em arquivo +```bash +python run.py -f tests/code.txt -o output.asm +``` +--- -Depois digite expressões:### Uso Básico +### 🎮 Modo 2: Interativo (REPL) +```bash +python run.py ``` ->>> 5 + 3 * 2#### Via Python (Recomendado) +Depois, digite expressões / comandos: +```text +>>> 5 + 3 * 2 >>> int x = a + b * 2; +>>> sair +``` ->>> sair```python - -```from compiler import compile - +--- +### 🐍 Modo 3: Via Python (API) -### 📄 Modo 3: Arquivo Texto Simples# Seu código +```python +from compiler import compile codigo = """ - -Crie um arquivo `.txt` com apenas uma linha:int soma(int a, int b) { - +int soma(int a, int b) { return a + b; +} -**tests/meu_teste.txt:**} - -``` - -int x = a + b * 2;int main() { - -``` int resultado = soma(5, 3); - +int main() { + int resultado = soma(5, 3); print(resultado); + return 0; +} +""" -Compile: return 0; - -```bash} - -python run.py -f tests/meu_teste.txt""" - -``` - -# Compilar - ----result = compile(codigo, optimize=True, verbose=True) - - - -## 📊 Pipeline de Compilaçãoif result['success']: +result = compile(codigo, optimize=True, verbose=True) +if result["success"]: print("✓ Compilação bem-sucedida!") - -**Conforme metodologia do professor:** for linha in result['assembly']: - + for linha in result["assembly"]: print(linha) +else: + print("✗ Erros:", result["errors"]) +``` -| Fase | Entrada | Saída | Arquivo |else: - -|------|---------|-------|---------| print("✗ Erros:", result['errors']) - -| **1. Léxico** | Código fonte | Tokens | `lexer.py` |``` - -| **2. Sintático LL(1)** | Tokens | Parse Tree | `parser_ll1.py` ✅ | - -| **3. AST** | Parse Tree | AST | `ast.py` |#### Via Linha de Comando - -| **4. Semântica** | AST | Tabela Símbolos | `analyzer.py` | - -| **5. IR** | AST | TAC + Quádruplas | `ir_generator.py` ✅ |```bash - -| **6. Otimizações** | IR | IR Otimizado | `optimizer.py` ✅ |# Compilar arquivo - -| **7. Assembly** | IR | MIPS-like | `assembly.py` |python compiler/main.py tests/hello_world.txt --verbose - - - ----# Salvar assembly - -python compiler/main.py tests/code.txt -o output.asm - -## ✅ Implementado Conforme Professor - -# Sem otimizações - -### ✅ Parser LL(1) Top-Downpython compiler/main.py tests/code.txt --no-optimize - -- **Recursive Descent** manual``` - -- **Lookahead de 1 token** - -- Cada não-terminal = função recursiva### Testes - -- Arquivo: `compiler/parser_ll1.py` - -```bash - -### ✅ Eliminação de Subexpressões Comuns (CSE)# Rodar suite completa de testes +--- -```pythonpython test_compiler.py +## 📊 Pipeline de Compilação -# Antes: +**Conforme metodologia do professor:** -t1 = a + b# Testar módulo individual +| Fase | Entrada | Saída | Arquivo | +| ------------------ | ------------ | ------------------ | ----------------------------- | +| 1. Léxico | Código fonte | Tokens | `lexer.py` | +| 2. Sintático LL(1) | Tokens | Parse Tree | `parser_ll1.py` | +| 3. AST | Parse Tree | AST | `ast.py` | +| 4. Semântica | AST | Tabela de Símbolos | `analyzer.py` | +| 5. IR (TAC) | AST | TAC + Quádruplas | `ir_generator.py` | +| 6. Otimizações | IR | IR Otimizado | `optimizer.py`, `peephole.py` | +| 7. Assembly | IR | MIPS-like | `assembly.py` | -t2 = a + b # redundante!python compiler/lexer.py +--- -python compiler/parser.py +## ✅ Funcionalidades por Etapa -# Depois (CSE):python compiler/optimizer.py +### 🔹 Análise Léxica (Etapas 2–3) -t1 = a + b``` +* Reconhecimento de tokens (palavras-chave, operadores, identificadores, números) +* Tratamento de espaços em branco e comentários +* Detecção de erros léxicos -t2 = t1 # reutiliza! +### 🔹 Análise Sintática (Etapa 4) -```## 📦 Dependências +* Parser baseado em gramática BNF +* Precedência de operadores +* Suporte a declarações de função +* Expressões aritméticas +* Detecção de erros sintáticos +### 🔹 Análise Semântica (Etapa 5) +* Verificação de tipos +* Verificação de escopo (variáveis, funções) +* Detecção de variáveis não declaradas +* Verificação de parâmetros e número de argumentos +* Árvore anotada com tipos e escopos -### ✅ Formato Quádruplas- **Python 3.8+**: Linguagem principal +### 🔹 Código Intermediário (IR / TAC) -```- **PLY (Python Lex-Yacc) 3.11**: Análise léxica e sintática +* Formato de **Three-Address Code (TAC)** +* Representação em **quádruplas**: + `(operação, arg1, arg2, resultado)` -(operação, arg1, arg2, resultado)- **pytest**: Testes (opcional) +Exemplo: +```text (*, b, 2, t0) +(+, a, t0, t1) +(assign, t1, -, x) +``` -(+, a, t0, t1)```bash - -(assign, t1, -, x)pip install ply - -`````` - - - -### ✅ Todas as Otimizações## 🔄 Pipeline de Compilação - -1. **CSE** - Eliminação de Subexpressões Comuns - -2. **Constant Folding** - Avalia em tempo de compilação``` - -3. **Algebraic Simplification** - x*1→x, x+0→x, x*0→0 Código Fonte (.txt) - -4. **Peephole** - x*2→x<<1 ↓ - -5. **Copy Propagation** - Propaga cópias [1] LEXER (lexer.py) - -6. **Dead Code Elimination** - Remove código morto → Tokenização - - ↓ - ---- [2] PARSER (parser.py) - - → Parse Tree (BNF) - -## 📖 Exemplo Completo ↓ - - [3] AST Builder (ast.py) - -### Entrada: → Abstract Syntax Tree - -```c ↓ - -int x = a + b * 2; [4] ANALYZER (analyzer.py) - -``` → Análise Semântica - - → Symbol Table - -### Saída (Verbose): ↓ - - [5] IR GENERATOR (ir_generator.py) - -``` → Three-Address Code (TAC) - -✅ COMPILAÇÃO BEM-SUCEDIDA! ↓ - - [6] OPTIMIZER (optimizer.py + peephole.py) - -━━━ TOKENS ━━━ → Constant Folding - -28 tokens: INT, ID, EQUALS, ID, PLUS, ID, TIMES, NUMBER, SEMICOLON... → Dead Code Elimination - - → Copy Propagation - -━━━ TABELA DE SÍMBOLOS ━━━ → Peephole Optimization - -main: function (params=0) ↓ - - a: int [7] ASSEMBLY GENERATOR (assembly.py) - - b: int → Código MIPS-like - - x: int ↓ - - Assembly (.asm) - -━━━ CÓDIGO INTERMEDIÁRIO (TAC) ━━━``` - -0: begin_func main - -1: a = 7## ✅ Etapas Implementadas - -2: b = 8 - -3: t0 = b * 2| Etapa | Descrição | Status | Módulo | - -4: t1 = a + t0|-------|-----------|--------|--------| - -5: x = t1| **2** | Alfabeto e definição de tokens | ✅ Completo | `lexer.py` | - -6: return 0| **3** | Análise léxica (tokenização) | ✅ Completo | `lexer.py` | - -7: end_func main| **4** | Análise sintática (parser BNF) | ✅ Completo | `parser.py` | - -| **5** | Análise semântica | ✅ Completo | `analyzer.py` | - -━━━ QUÁDRUPLAS ━━━| **6** | Geração de código intermediário (TAC) | ✅ Completo | `ir_generator.py` | - -0: (begin_func, main, -, -)| **7** | Ambientes de execução + Assembly | ✅ Completo | `assembly.py` | - -1: (assign, 7, -, a)| **Extra** | Otimizações | ✅ Completo | `optimizer.py`, `peephole.py` | - -2: (assign, 8, -, b) - -3: (*, b, 2, t0)## 🎯 Funcionalidades - -4: (+, a, t0, t1) - -5: (assign, t1, -, x)### Análise Léxica (Etapa 2-3) - -6: (return, 0, -, -)- ✅ Reconhecimento de tokens (palavras-chave, operadores, identificadores, números) - -7: (end_func, main, -, -)- ✅ Tratamento de espaços em branco e comentários - -- ✅ Detecção de erros léxicos - -━━━ ASSEMBLY (MIPS-like) ━━━ - -main:### Análise Sintática (Etapa 4) - - addi $sp, $sp, -4- ✅ Parser baseado em gramática BNF - - sw $fp, 0($sp)- ✅ Precedência de operadores - - move $fp, $sp- ✅ Suporte a declarações de função - - li $t0, 8- ✅ Expressões aritméticas - - sw $t0, b- ✅ Detecção de erros sintáticos - - li $t1, 7 - - sw $t1, a### Análise Semântica (Etapa 5) - - mul $t2, $t0, 2- ✅ Verificação de tipos - - add $t3, $t1, $t2- ✅ Verificação de escopo (variáveis e funções) - - move $t4, $t3- ✅ Detecção de variáveis não declaradas - - sw $t4, x- ✅ Verificação de parâmetros de função - - move $v0, 0- ✅ Validação de número de argumentos - - lw $fp, 0($sp) - - addi $sp, $sp, 4### Geração de Código (Etapa 6-7) - - jr $ra- ✅ Código intermediário (Three-Address Code) - -```- ✅ Otimizações: - - - Constant folding (5+3 → 8) - ---- - Dead code elimination - - - Copy propagation - -## 🧪 Testes Rápidos - Peephole (x+0 → x, x*1 → x) - - - Simplificação algébrica (x-x → 0) +### 🔹 Otimizações -```bash- ✅ Geração de assembly MIPS-like +1. **CSE** – Eliminação de Subexpressões Comuns +2. **Constant Folding** – Avaliação em tempo de compilação +3. **Algebraic Simplification** – `x*1 → x`, `x+0 → x`, `x*0 → 0` +4. **Peephole** – Micro-otimizações locais (`x*2 → x<<1`, etc.) +5. **Copy Propagation** – Propaga cópias simples +6. **Dead Code Elimination** – Remove código morto -# Teste básico- ✅ Alocação de registradores +### 🔹 Geração de Assembly (Etapas 6–7) -python run.py -f tests/simples.txt- ✅ Gerenciamento de pilha (stack frames) +* Geração de código **MIPS-like** +* Instruções do tipo LOAD/MUL/ADD/STORE +* Alocação de registradores +* Gerenciamento de stack frame (pilha) +* Suporte a funções, chamadas aninhadas e recursivas +--- +## 🧪 Testes Rápidos -# Teste CSE (vê otimização acontecendo!)### Ambientes de Execução (Etapa 7) +```bash +# Teste básico +python run.py -f tests/simples.txt -python run.py -f tests/teste_cse.txt- ✅ Activation Records completos +# Teste de CSE e otimizações +python run.py -f tests/teste_cse.txt -- ✅ Runtime Stack para chamadas de função +# Exemplo do professor +python run.py -f tests/exemplo_professor.txt -# Exemplo do professor- ✅ Tabela de símbolos com escopos aninhados +# Testes com expressões complexas +python demos/teste_expressoes.py -python run.py -f tests/exemplo_professor.txt- ✅ Suporte a chamadas recursivas e aninhadas +# Rodar suite completa de testes +python test_compiler.py +``` -- ✅ Links dinâmicos e estáticos +--- -# Teste com expressões complexas +## 📖 Exemplo Completo -python demos/teste_expressoes.py## 📖 Documentação +### Entrada +```c +int x = a + b * 2; ``` -- **`compiler/README.md`**: Documentação detalhada da arquitetura modular - ----- **`docs/GUIA_DE_ESTUDOS.md`**: Guia completo de estudos (500+ linhas) +### TAC (Three-Address Code) -- **`docs/ETAPA7_AMBIENTES_EXECUCAO.md`**: Documentação da Etapa 7 - -## 📚 Documentação Adicional- **Cada módulo**: Possui docstrings e exemplos de teste +```text +t0 = b * 2 +t1 = a + t0 +x = t1 +``` +### Quádruplas +```text +(*, b, 2, t0) +(+, a, t0, t1) +(assign, t1, -, x) +``` -Veja `docs_projeto/` para:--- +### Assembly MIPS-like (trecho ilustrativo) -- **GUIA_RAPIDO.md** - Referência rápida +```asm +main: + addi $sp, $sp, -4 + sw $fp, 0($sp) + move $fp, $sp -- **COMANDOS.md** - Lista de comandos úteis## Licenca + li $t0, 8 + sw $t0, b + li $t1, 7 + sw $t1, a -- **README_OLD.md** - Documentação anterior completa + mul $t2, $t0, 2 + add $t3, $t1, $t2 + move $t4, $t3 + sw $t4, x -Este projeto esta licenciado sob a MIT license. + move $v0, 0 + lw $fp, 0($sp) + addi $sp, $sp, 4 + jr $ra +``` --- -## Gramatica - Forma BNF - -## 🎯 Metodologia Aplicada +## 📐 Gramática – Forma BNF (Simplificada) ```bnf + ::= -### Análise Léxica - -- Expressões Regulares (ER) ::= - -- PLY gera AFD automaticamente - - ::= | - -### Análise Sintática - -- **LL(1) Top-Down** ✅ ::= + ::= + | -- **Recursive Descent** ✅ | + ::= + | + | + | -- **1 token de lookahead** ✅ | +::= "=" ";" - | + ::= "if" "(" ")" "{" "}" + | "if" "(" ")" "{" "}" "else" "{" "}" -### Código Intermediário + ::= "while" "(" ")" "{" "}" -- **Three-Address Code (TAC)** ✅ ::= "=" ";" + ::= "print" "(" ")" ";" -- **Quádruplas** ✅ - - ::= "if" "(" ")" "{" "}" - -### Otimizações | "if" "(" ")" "{" "}" "else" "{" "}" - -- **CSE** (Common Subexpression Elimination) ✅ - -- **Constant Folding** ✅ ::= "while" "(" ")" "{" "}" - -- **Dead Code Elimination** ✅ - -- **Copy Propagation** ✅ ::= "print" "(" ")" ";" - -- **Algebraic Simplification** ✅ - - ::= | "+" | "-" - -### Assembly - -- **MIPS-like** ::= | "*" | "/" - -- **LOAD/MUL/ADD/STORE** ✅ - - ::= | | "(" ")" - ---- - - ::= { | } - -## 📝 Licença + ::= + | "+" + | "-" - ::= { } + ::= + | "*" + | "/" -MIT License + ::= + | + | "(" ")" - ::= "a" | "b" | ... | "z" | "A" | "B" | ... | "Z" - ---- - - ::= "0" | "1" | ... | "9" - -**📚 Projeto Acadêmico - Disciplina de Compiladores** + ::= { | } + ::= { } + ::= "a" | ... | "z" | "A" | ... | "Z" + ::= "0" | ... | "9" ``` -*Implementado conforme metodologia ensinada em aula.* - -# Autômato Finito Determinístico - Compilador Linguagem Mínima - -## Tokens da Linguagem - -- **Palavras-chave**: PRINT, IF, ELSE, WHILE, RETURN, INT -- **Operadores**: = (atribuição), + (soma) -- **Delimitadores**: ; (ponto e vírgula), ( ) (parênteses) -- **Literais**: números inteiros -- **Identificadores**: variáveis e funções - -## Alfabeto de Entrada - -- **dígito**: 0-9 -- **letra**: a-z, A-Z -- **_**: underscore -- **=**: igual -- **+**: mais -- **;**: ponto e vírgula -- **(**: parêntese esquerdo -- **)**: parêntese direito -- **espaço**: espaço, tab, quebra de linha -- **outro**: qualquer outro caractere - --- -## Tabela de Transições do AFD +## 🔠 Autômato Finito Determinístico (AFD) – Léxico -| Estado | dígito | letra | _ | = | + | ; | ( | ) | espaço | outro | -|--------|--------|-------|---|---|---|---|---|---|---------|-------| -| **q0** | q_num | q_id | q_id | q_equals | q_plus | q_scolon | q_lparen | q_rparen | q0 | qE | -| **q_num** | q_num | qE | qE | q0 | q0 | q0 | q0 | q0 | q0 | qE | -| **q_id** | q_id | q_id | q_id | q0 | q0 | q0 | q0 | q0 | q0 | qE | -| **q_equals** | qE | qE | qE | qE | qE | qE | qE | qE | q0 | qE | -| **q4** | qE | qE | qE | qE | qE | qE | qE | qE | q0 | qE | -| **q_scolon** | qE | qE | qE | qE | qE | qE | qE | qE | q0 | qE | -| **q_lparen** | qE | qE | qE | qE | qE | qE | qE | qE | q0 | qE | -| **q_rparen** | qE | qE | qE | qE | qE | qE | qE | qE | q0 | qE | -| **qE** | qE | qE | qE | qE | qE | qE | qE | qE | qE | qE | +### Tokens da Linguagem ---- +* **Palavras-chave**: `PRINT`, `IF`, `ELSE`, `WHILE`, `RETURN`, `INT` +* **Operadores**: `=` (atribuição), `+` (soma) +* **Delimitadores**: `;`, `(`, `)` +* **Literais**: números inteiros +* **Identificadores**: variáveis e funções -## Descrição dos Estados +### Alfabeto de Entrada -### Estados Principais +* `dígito`: `0–9` +* `letra`: `a–z`, `A–Z` +* `_`: underscore +* `=`, `+`, `;`, `(`, `)` +* `espaço`: espaço, tab, quebra de linha +* `outro`: qualquer outro caractere -- **q0**: Estado inicial (aguardando próximo token) -- **q1**: Reconhecendo número inteiro -- **q2**: Reconhecendo identificador/palavra-chave -- **q3**: Token de atribuição (=) -- **q4**: Token de soma (+) -- **q5**: Token ponto e vírgula (;) -- **q6**: Token parêntese esquerdo (() -- **q7**: Token parêntese direito ()) -- **qE**: Estado de erro +### Tabela de Transições (Resumo) -### Estados Finais e Tokens Gerados +| Estado | dígito | letra | _ | = | + | ; | ( | ) | espaço | outro | +| --------- | ------ | ----- | ---- | -------- | ------ | -------- | -------- | -------- | ------ | ----- | +| **q0** | q_num | q_id | q_id | q_equals | q_plus | q_scolon | q_lparen | q_rparen | q0 | qE | +| **q_num** | q_num | qE | qE | q0 | q0 | q0 | q0 | q0 | q0 | qE | +| **q_id** | q_id | q_id | q_id | q0 | q0 | q0 | q0 | q0 | q0 | qE | +| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | -| Estado Final | Token Gerado | Descrição | -|-------------|-------------|-----------| -| **q1** | TOKEN_NUMBER | Número inteiro | -| **q2** | TOKEN_ID ou TOKEN_KEYWORD | Identificador ou palavra-chave* | -| **q3** | TOKEN_ASSIGN | Operador de atribuição | -| **q4** | TOKEN_PLUS | Operador de soma | -| **q5** | TOKEN_SEMICOLON | Ponto e vírgula | -| **q6** | TOKEN_LPAREN | Parêntese esquerdo | -| **q7** | TOKEN_RPAREN | Parêntese direito | +### Estados Finais (Tokens) -*Para o estado q2, é necessária verificação adicional para determinar se é palavra-chave. +| Estado Final | Token | Descrição | +| ------------ | ------------------ | ------------------------------ | +| q_num | TOKEN_NUMBER | Número inteiro | +| q_id | TOKEN_ID / KEYWORD | Identificador ou palavra-chave | +| q_equals | TOKEN_ASSIGN | `=` | +| q_plus | TOKEN_PLUS | `+` | +| q_scolon | TOKEN_SEMICOLON | `;` | +| q_lparen | TOKEN_LPAREN | `(` | +| q_rparen | TOKEN_RPAREN | `)` | --- -## Associações semânticas -A etapa de tradução dirigida por sintaxe, as ações semânticas implementadas nas regras do -parser não apenas constroem a AST, mas também podem ser estendidas para incluir -informações de tipos e escopos, tornando a árvore anotada e apta para análises semânticas -posteriores. Isso facilita a verificação de tipos, o controle de variáveis e a detecção de -possíveis erros semânticos, além de preparar a AST para a geração de código. +## 🌳 AST – Árvore Sintática Abstrata & Associações Semânticas -## Arvore Sintatica Abstrata -Para a implementação precisamos associar ações semânticas às regras da gramática definidas -no parser e gerar uma Árvore de Sintaxe Abstrata (AST) anotada com informações de tipos e -escopos. Abaixo, apresento um artefato com a implementação atualizada do parser, incluindo -ações semânticas para construir a AST anotada. -Para o exemplo de código a seguir: - -```Python +Exemplo de código: +```c x = 5 + 3; - print(x * 2); ``` -Teremos a AST gerada: +AST anotada (forma textual): -```cmd +```text program {'scope': 'global'} assign (x) {'type': 'int', 'scope': 'global'} - + {'type': 'int'} - num (5) {'type': 'int'} - num (3) {'type': 'int'} print {'type': 'int', 'scope': 'global'} - * {'type': 'int'} - id (x) {'type': 'int', 'scope': 'global'} - num (2) {'type': 'int'} ``` -Formando (simplificadamente) a AST: +As ações semânticas no parser: +* Constroem a AST +* Anotam nós com **tipo** e **escopo** +* Preparam para a geração de IR e para verificações semânticas posteriores -## Transformar AST em código Intermediário +--- -Para a geração de código intermediário utilizamos a AST denotada anteriormente em 5.2, -mas somente para instruções que contém três operadores por enquanto. Dito isto, optamos -por gerar um TAC, que é um Three-Access-Code, que processa no máximo três operadores -por vez. Por Exemplo: +## 🔁 AST → Código Intermediário (TAC) -``` Python +Para o mesmo exemplo: +```c x = 5 + 3; - print(x * 2); ``` -Gera: +Geramos o TAC: -``` +```text t1 = 5 + 3 - -x = t1 - +x = t1 t2 = x * 2 - print t2 ``` -Concluindo. No arquivo codegen.py são carregados os tokens e o parser gerado em parser.py, +Essas temporárias (`t1`, `t2`, …) são geradas no módulo `codegen.py` a partir da AST e do IR. + +--- + +## 📚 Documentação Adicional + +Consulte a pasta `docs_projeto/` e `docs/` para: + +* `GUIA_RAPIDO.md` – Referência rápida +* `COMANDOS.md` – Lista de comandos úteis +* `README_OLD.md` – Documentação anterior completa +* `GUIA_DE_ESTUDOS.md` – Guia completo de estudos +* `ETAPA7_AMBIENTES_EXECUCAO.md` – Ambientes de execução (Etapa 7) +* `RESUMO_ETAPA7.md` – Resumo teórico da etapa final + +--- + +## 📝 Licença -onde é construído as variáveis temporárias chamadas t1, t2 e t3 após construir a AST, +Este projeto está licenciado sob a **MIT License**. -montando claramente as operações realizadas. +> Projeto acadêmico da disciplina de Compiladores, implementado conforme metodologia ensinada em aula.