O que você vai aprender
Integrar análise léxica, sintática e geração de RI em um pipeline.
Testar o compilador ponta a ponta com casos de aceitação.
Planejar a arquitetura e a divisão de tarefas do projeto.
Diagnosticar erros em cada fase do pipeline integrado.
Hora de juntar as peças
Estudamos cada fase isoladamente: scanner, parser, semântica, geração de RI. Agora as conectamos em um mini-compilador real, onde a saída de uma fase é a entrada da próxima — do texto-fonte ao código de três endereços.
Esta aula é a síntese prática do curso: ver o pipeline inteiro funcionando consolida tudo o que veio antes e prepara a entrega do projeto da disciplina.
O pipeline completo
Para a entrada x = a + b * 2, o caminho é:
tokens→Parser
árvore→Semântica
tipos→Gerador
TAC
Os dois simuladores da aula mostram as pontas: primeiro a tokenização (léxico), depois a árvore + código intermediário (síntese).
O contrato entre fases
O segredo da integração é que cada fase só precisa conhecer o formato da entrada que recebe e da saída que produz — não os detalhes internos das vizinhas.
A saída de cada fase
Detalhando o que flui entre as fases:
- Scanner → Parser: uma sequência linear de tokens (categoria + lexema).
- Parser → Semântica: a árvore sintática que estrutura os tokens.
- Semântica → Gerador: a árvore anotada com tipos + a tabela de símbolos.
- Gerador → (saída): a sequência de código de três endereços.
Rastreando x = a + b * 2
Veja a transformação da entrada ao longo do pipeline:
| Fase | Resultado para x = a + b * 2 |
|---|---|
| Scanner | id(x) = id(a) + id(b) * num(2) |
| Parser | Atrib( x , Soma( a , Prod( b , 2 ) ) ) |
| Semântica | tipos checados; x, a, b na tabela de símbolos |
| Gerador | t1 = b * 2; t2 = a + t1; x = t2 |
Siga o dado pelo pipeline
Casos de teste de aceitação
Antes de implementar, defina os casos: que entradas o mini-compilador deve aceitar, que TAC deve produzir, e que entradas inválidas deve rejeitar com erro.
Testando ponta a ponta
Testes de aceitação verificam o pipeline inteiro, não fases isoladas. Um bom conjunto cobre:
- Casos válidos: expressões simples e aninhadas, com precedência variada.
- Casos de borda: um único número, parênteses redundantes, expressões longas.
- Casos inválidos: parêntese não fechado (erro sintático), variável não declarada (erro semântico), símbolo estranho (erro léxico).
A linha de produção
Mini-compilador × compilador real
| Mini-compilador (projeto) | Compilador real | |
|---|---|---|
| Linguagem-fonte | Expressões + atribuição | Linguagem completa |
| Fases | Léxica, sintática, semântica, RI | + otimização e geração de código |
| Saída | Código de três endereços | Binário executável |
| Arquitetura | A mesma, em miniatura | A mesma, em escala |
A diferença é de escopo, não de princípio: a arquitetura é idêntica.
Do planejamento à entrega
minilinguagem→Dividir tarefas
por fase→Implementar
+ testar→Integrar
+ demonstrar
Comece pelo contrato entre fases: com as interfaces definidas, cada integrante pode trabalhar em paralelo e a integração no fim é tranquila.
Onde a semântica entra no projeto
Mesmo num mini-compilador de expressões, a semântica tem papel: ela verifica se cada identificador usado foi declarado e se os tipos das operações são compatíveis, consultando a tabela de símbolos (aula 9).
x = ...), a semântica também registra x na tabela e checa o tipo do lado direito contra o de x. É a fase 8/9 em ação dentro do pipeline.Verifique seu entendimento
No pipeline integrado, a saída do scanner alimenta qual fase?
Planejando a divisão de tarefas
Um grupo de quatro pode dividir o mini-compilador assim:
Com as assinaturas das funções acordadas, cada um implementa e testa sua parte isoladamente, montando no fim o pipeline completo.
Armadilhas do projeto integrador
Deixar testes para o fim. Sem casos de aceitação cedo, bugs se acumulam e a depuração explode.
Ignorar entradas inválidas. Um bom compilador rejeita erros com clareza, não só aceita o caso feliz.
Precedência incorreta. A árvore errada propaga TAC errado até o fim do pipeline.
Para um projeto bem-sucedido
Escreva casos de aceitação antes do código: eles guiam a implementação.
Aproveite os simuladores da aula como referência de saída esperada.
Integre cedo e com frequência: junte as fases assim que cada uma tiver um esqueleto funcionando, em vez de só no fim.
Pense antes de revelar
Se o TAC gerado para "a + b * c" sair errado, em qual(is) fase(s) pode estar o defeito?
Revise os termos
Como esta aula reúne o curso
- Aula 3/4 (léxico): o scanner que tokeniza a entrada.
- Aula 5/6/7 (sintaxe): o parser que constrói a árvore.
- Aula 8/9 (semântica): a verificação de tipos e a tabela de símbolos.
- Aula 10 (RI): a geração do código de três endereços — o coração do projeto.
O essencial da aula
Atividade em grupo · Sprint do mini-compilador
Em grupos, planejem e iniciem o projeto integrador.
Roteiro
- Definam o escopo da minilinguagem (ex.: expressões aritméticas com atribuição).
- Dividam tarefas: scanner, parser, gerador de TAC.
- Definam os casos de teste de aceitação (entradas e saídas esperadas).
- Montem um cronograma de implementação até a aula 14.
Mini-quiz · Aula 13
20 questões sobre esta aula. Escolha e veja a explicação na hora.
📌 Resumo — leve isto para a prova
- O pipeline integra scanner, parser, semântica e geração de RI; a saída de cada fase alimenta a próxima.
- Interfaces claras entre fases permitem dividir o trabalho e depurar com facilidade.
- Casos de teste de aceitação (entrada → saída) guiam a implementação e validam o todo.
- O projeto exercita o front-end completo e produz código de três endereços.
- O mini-compilador tem a mesma arquitetura de um compilador real, em escala menor.