INÍCIO
Livros do Prof.
Introdução aos Compiladores
Bem-vindo à primeira aula da disciplina de Compiladores, onde iniciaremos nossa jornada para compreender como as linguagens de programação são traduzidas para código executável.
🛠️ Laboratório Prático – GCC & Python (com PLY)
Exercício 1 – Compilar e Executar com GCC Arquivo: hello.c
#include <stdio.h>
int main() {
    printf("Olá, Compiladores!\n");
    return 0;
}
Tarefa:
  • Compilar com: gcc hello.c -o hello
  • Executar com: ./hello
Exercício 2 – Corrigir erro de sintaxe Arquivo: erro.c
#include <stdio.h>
int main() {
    int a = 10
    printf("Valor: %d", a);
    return 0;
}
Tarefa:
  • Tente compilar e veja o erro
  • Identifique qual etapa do compilador detectou o erro
Exercício 3 – Python interpretado Arquivo: interpretador.py
print("Olá, mundo da interpretação!")
Tarefa:
  • Executar com: python interpretador.py
  • Comparar com a execução via gcc
Exercício 4 – Tokenização com PLY Arquivo: tokenizador.py
import ply.lex as lex

tokens = ('NUM', 'PLUS',)

t_PLUS = r'\+'
t_NUM = r'\d+'

t_ignore = ' \t'

def t_newline(t):
    r'\n+'
    t.lexer.lineno += len(t.value)

def t_error(t):
    print("Caractere ilegal: ", t.value[0])
    t.lexer.skip(1)

lexer = lex.lex()
lexer.input("23 + 45")

for tok in lexer:
    print(tok)
Tarefa:
  • Executar e analisar os tokens gerados
  • Alterar a entrada e observar o comportamento
Exercício 5 – Automatizando com Python
import subprocess
subprocess.run(["gcc", "hello.c", "-o", "hello"])
subprocess.run(["./hello"])
Tarefa:
  • Crie o script e execute
  • Discuta: qual a vantagem de automatizar o processo?
🔧 EXERCÍCIOS PRÁTICOS – COMPILADORES (PARTE 2)
🟢 Nível Iniciante (1–7)
  1. Compilação simples com GCC
  • Crie um programa em C que exibe seu nome completo na tela. Compile e execute com gcc.
  1. Erro de sintaxe proposital
  • Remova o ; após um printf() e veja o que o compilador reporta. Qual etapa detectou?
  1. Exibir tipos básicos
  • Crie um programa que imprima o tamanho (em bytes) de int, float, char e double.
  1. Usar scanf com printf
  • Faça um programa que leia um número inteiro e exiba seu dobro.
  1. Comparar tempo de execução
  • Escreva dois programas: um em C e um em Python que somam 1 até 100.000. Compare os tempos.
  1. Listar tokens manualmente
  • Dado o trecho int x = 10 + 5;, identifique os tokens léxicos. (Feito no caderno ou verbal).
  1. Criar um interpretador em Python básico
  • Faça um script que leia uma string de soma ("2+3") e exiba o resultado com eval().
🟡 Nível Intermediário (8–14)
8. Analisador léxico com PLY
  • Implemente um analisador que reconhece números inteiros, + e -.
9.Reconhecimento de identificadores e operadores
  • Com PLY, modifique o exemplo anterior para reconhecer variáveis como x, y1.
10.Crie e quebre seu próprio código
  • Escreva um programa em C e depois insira 3 tipos diferentes de erros: léxico, sintático e semântico.
11.Mini compilador Python-C
  • Faça um script Python que gere um código .c simples e o compile com gcc.
12.Mensagens de erro intencionais
  • Troque o nome de uma função (prinft ao invés de printf) e observe o erro.
13.Simular otimizador manual
  • Escreva dois trechos de código em C: um com repetições redundantes, outro otimizado. Compare.
14.Compilar em C e chamar via Python
  • Escreva soma.c com int soma(int a, int b). Compile como soma.so e chame com ctypes no Python.
🔴 Nível Avançado (15–20)
15.Criar um analisador sintático com PLY
  • Crie um parser para expressões matemáticas do tipo 3 + 4 * (2 - 1).
16.Criação de código intermediário textual
  • Dado um código em C, crie manualmente sua representação intermediária (quadruplas ou triplas).
17.Comparar GCC com Clang
  • Compile o mesmo código com gcc e clang (se disponível). Verifique diferenças no binário.
18.Mensurar tempo de compilação com time
  • Use o comando time gcc prog.c para medir performance de códigos simples e grandes.
19.Código mal formatado
  • Apresente um código C mal indentado e peça para os grupos ajustarem e explicarem seu funcionamento.
20.Simular fases do compilador
  • Dado um trecho x = y + 2 * z; Exercício: a) identificar tokens b) montar a árvore sintática c) gerar código intermediário (pseudocódigo)
⚙️ Recursos sugeridos
  • gcc, time, nano ou VS Code
  • Python 3 + ply (pip install ply)
  • ctypes para ligação Python/C
  • Google Colab (para simulações com Python)
O que é um Compilador?
Um compilador é um programa especial que traduz código escrito em uma linguagem de programação (código-fonte) para outra linguagem, geralmente de mais baixo nível como código de máquina ou assembly.
Este processo de tradução permite que o computador execute as instruções especificadas pelo programador, transformando comandos legíveis por humanos em instruções que podem ser executadas diretamente pelo hardware.
Por que estudar Compiladores?
Fundamento da Computação
O estudo de compiladores conecta teoria e prática da computação, consolidando conhecimentos de algoritmos, linguagens formais e arquitetura de computadores.
Habilidades Transferíveis
Técnicas aprendidas na construção de compiladores são aplicáveis em processamento de linguagem natural, análise de dados e desenvolvimento de linguagens específicas de domínio.
Melhor Programador
Compreender como compiladores funcionam torna você mais consciente sobre a eficiência do código e os processos que ocorrem por trás das linguagens de programação.
Exemplos do Mundo Real
Compiladores
  • GCC (GNU Compiler Collection) - C, C++
  • Rustc - Compilador da linguagem Rust
  • MSVC - Microsoft Visual C++
Interpretadores
  • CPython - Interpretador oficial do Python
  • Node.js - JavaScript fora do navegador
  • Ruby Interpreter
Híbridos
  • Javac + JVM - Java
  • .NET Framework - C#
  • JIT (Just-In-Time) em navegadores
Compiladores no Ciclo de Desenvolvimento
Os compiladores são componentes essenciais no ciclo de desenvolvimento de software, atuando como ponte entre o código escrito pelo programador e o programa executável. Eles garantem que as instruções lógicas elaboradas sejam convertidas corretamente para operações que o computador pode executar.
Um erro de compilação impede que o programa seja executado, fornecendo feedback imediato ao desenvolvedor sobre problemas no código-fonte, enquanto erros em tempo de execução só aparecem quando o programa já está em uso.
Definição de Compilação
Compilação é o processo de tradução de um programa escrito em uma linguagem de programação (código-fonte) para uma representação equivalente em outra linguagem, geralmente de mais baixo nível.
Este processo transforma código legível por humanos em instruções que podem ser diretamente executadas por um computador, realizando várias análises e otimizações para garantir que o programa resultante seja correto e eficiente.
A compilação é essencialmente uma transformação de linguagem que preserva o significado (semântica) do programa original, mas altera sua forma (sintaxe).
Do Código-fonte ao Executável
O processo de compilação transforma seu código-fonte em um arquivo executável através de diversas etapas. Primeiro, o código é analisado (análise léxica, sintática e semântica), depois otimizado e finalmente transformado em código de máquina específico para a plataforma-alvo.
Este fluxo garante que as instruções escritas em uma linguagem de alto nível, como C ou Java, sejam corretamente convertidas em instruções binárias que o processador consegue executar.
Etapas da Compilação: Visão Geral
Front-end
Análise léxica, sintática e semântica do código-fonte, criando uma representação intermediária.
Middle-end
Otimização independente de máquina, trabalhando sobre a representação intermediária.
Back-end
Geração de código específico para a arquitetura alvo e otimizações dependentes de máquina.
Esta divisão em etapas permite que compiladores modernos sejam modulares, facilitando a adaptação para diferentes linguagens de origem e plataformas de destino.
Exemplo Básico: Código em C sendo compilado
#include 

int main() {
    printf("Olá, mundo!\n");
    return 0;
}
Para compilar este código C usando o GCC:
$ gcc hello.c -o hello
$ ./hello
Olá, mundo!
O compilador GCC transforma o código-fonte em C em um arquivo executável binário que contém instruções de máquina específicas para o sistema operacional e arquitetura do processador.
Linguagens de Alto e Baixo Nível
Linguagens de Alto Nível
  • Mais próximas da linguagem humana
  • Abstração de detalhes da máquina
  • Foco na solução do problema
  • Exemplos: Python, Java, C#
Linguagens de Baixo Nível
  • Mais próximas do hardware
  • Acesso direto a recursos da máquina
  • Maior controle e eficiência
  • Exemplos: Assembly, Código de máquina
Código de Máquina, Bytecode e Assembly
Código de Máquina
Sequência de bits (0s e 1s) diretamente executável pelo processador. É específico para cada arquitetura de hardware e completamente ilegível para humanos.
Assembly
Representação textual de instruções de máquina usando mnemônicos. É uma forma legível de código de baixo nível, onde cada instrução corresponde diretamente a uma operação do processador.
Bytecode
Código intermediário gerado por compiladores de linguagens como Java. É executado por uma máquina virtual (ex: JVM) em vez de diretamente pelo processador, permitindo portabilidade.
Vantagens e Desvantagens de Compiladores
Vantagens
  • Execução mais rápida do programa final
  • Verificação de erros antes da execução
  • Otimizações avançadas possíveis
  • Proteção do código-fonte (distribuição binária)
Desvantagens
  • Tempo de compilação pode ser longo
  • Necessidade de recompilar após alterações
  • Binários específicos para cada plataforma
  • Ciclo de desenvolvimento mais lento
A escolha entre compilação e interpretação depende do equilíbrio desejado entre desempenho, portabilidade e ciclo de desenvolvimento para cada projeto específico.
Definição de Interpretador
Um interpretador é um programa que executa diretamente instruções escritas em uma linguagem de programação, sem necessidade de compilação prévia para código de máquina.
Ao contrário dos compiladores, interpretadores leem e executam o código linha por linha em tempo real. Isso proporciona maior flexibilidade e facilidade de depuração, embora geralmente resulte em execução mais lenta do que programas compilados.
Comparação: Compilador vs. Interpretador
Exemplos: Python vs C
Python (Interpretado)
# hello.py
print("Olá, mundo!")

# Execução
$ python hello.py
Olá, mundo!
O interpretador Python lê o código linha por linha e o executa imediatamente, sem gerar um arquivo executável separado.
C (Compilado)
// hello.c
#include 
int main() {
    printf("Olá, mundo!\n");
    return 0;
}

// Compilação e execução
$ gcc hello.c -o hello
$ ./hello
Olá, mundo!
O compilador C traduz todo o código para um executável binário antes da execução.
Sistemas Híbridos
Sistemas híbridos combinam aspectos de compilação e interpretação para balancear as vantagens de ambos. Java, por exemplo, compila o código-fonte para bytecode, que é então interpretado pela Máquina Virtual Java (JVM).
Este modelo "compile uma vez, execute em qualquer lugar" proporciona portabilidade sem sacrificar completamente o desempenho. Tecnologias como Just-In-Time (JIT) compilation melhoram ainda mais a eficiência, compilando partes críticas do código durante a execução.
Arquitetura Clássica de um Compilador
Análise Léxica
Divide o código em tokens (palavras-chave, identificadores, números, etc.)
Análise Sintática
Verifica se a sequência de tokens segue as regras gramaticais da linguagem
Análise Semântica
Verifica o significado e contexto (tipos, escopo, etc.)
Geração de Código
Traduz para código de máquina ou intermediário
Esta arquitetura em fases permite a modularização do compilador, facilitando sua implementação e manutenção. Cada fase tem responsabilidades bem definidas e produz uma saída que serve de entrada para a fase seguinte.
Fase 1: Análise Léxica
A análise léxica, também chamada de tokenização, é a primeira fase do processo de compilação. Nesta etapa, o compilador:
  • Lê o código-fonte caractere por caractere
  • Agrupa caracteres em tokens significativos
  • Remove comentários e espaços em branco
  • Identifica palavras-chave, identificadores, operadores
  • Gerencia a tabela de símbolos
Os tokens são as unidades fundamentais da linguagem, semelhantes às palavras em um idioma natural.
Exemplo de Análise Léxica
Código-fonte
if (contador > 10) {
    soma = soma + valor;
}
Tokens gerados
Fase 2: Análise Sintática
Na análise sintática (ou parsing), o compilador verifica se a sequência de tokens obtida na fase anterior segue as regras gramaticais da linguagem. Esta fase cria uma representação hierárquica do programa, geralmente na forma de uma árvore sintática.
É nesta etapa que erros como parênteses não fechados, ponto-e-vírgula faltando ou uso incorreto de palavras-chave são detectados. A gramática da linguagem é formalmente definida usando notações como BNF (Backus-Naur Form).
Exemplo de Análise Sintática
Tokens
if ( contador > 10 ) { soma = soma + valor ; }
Gramática simplificada
comando → if ( expressao ) bloco
bloco → { comandos }
comandos → comando | comando comandos
comando → identificador = expressao ;
expressao → termo | termo operador termo
termo → identificador | numero
A árvore sintática representa a estrutura hierárquica do programa, seguindo as regras da gramática. Se os tokens não puderem formar uma árvore válida, o compilador reporta um erro de sintaxe.
Fase 3: Análise Semântica
Verificação de Tipos
Garante que operações sejam aplicadas a tipos compatíveis (ex: não dividir uma string por um número)
Verificação de Escopo
Confirma que variáveis e funções são usadas dentro de seus escopos válidos e verifica declarações duplicadas
Verificação de Coerência
Analisa se o uso de instruções é logicamente coerente (ex: return dentro de funções, break dentro de loops)
Anotação da Árvore
Enriquece a árvore sintática com informações semânticas para uso nas fases seguintes
Fase 4: Otimização
A fase de otimização busca melhorar o código intermediário gerado, tornando o programa final mais eficiente em termos de:
  • Velocidade de execução
  • Consumo de memória
  • Uso de energia (importante para dispositivos móveis)
As otimizações podem ocorrer em diferentes níveis, desde simples eliminação de código morto até transformações complexas como loop unrolling, inlining de funções e vetorização.
Fase 5: Geração de Código
A fase de geração de código transforma a representação intermediária otimizada em código específico para a máquina alvo. Esta é a última etapa do processo de compilação e produz o código executável final.
Seleção de Instruções
Escolha das instruções de máquina mais eficientes para implementar as operações do programa.
Alocação de Registradores
Decisão sobre quais variáveis serão mantidas em registradores (acesso rápido) vs. memória.
Geração de Código Objeto
Produção do código de máquina ou assembly que será executado no processador alvo.
Código Intermediário
O código intermediário (IR - Intermediate Representation) é uma forma de representação que facilita a tradução entre linguagens de alto nível e código de máquina. Ele serve como um "idioma universal" dentro do compilador.
Formatos comuns de IR incluem o Three-Address Code (TAC), Static Single Assignment (SSA) e, em compiladores modernos como LLVM, representações específicas como LLVM IR. O uso de IR permite que as otimizações sejam aplicadas de forma independente da linguagem fonte e da máquina alvo.
Fluxo Completo da Compilação
O processo completo de compilação envolve múltiplas fases interconectadas, começando com o código-fonte e terminando com um programa executável. Cada fase tem uma função específica e produz artefatos que são consumidos pela fase seguinte.
Embora apresentado de forma linear, compiladores modernos podem realizar algumas dessas etapas de forma paralela ou iterativa, especialmente durante a otimização, para produzir código mais eficiente.
Ferramentas da Disciplina
Python 3
Linguagem de programação que utilizaremos para implementar nosso compilador. Escolhida por sua sintaxe clara e facilidade de aprendizado.
Visual Studio Code
Editor de código com suporte a extensões para Python, destaque de sintaxe e depuração integrada.
PLY (Python Lex-Yacc)
Biblioteca que implementa as ferramentas lex e yacc em Python, facilitando a criação de analisadores léxicos e sintáticos.
Instalação do Ambiente
Passo 1: Python 3
Baixe e instale o Python 3 do site oficial: python.org
Verifique a instalação com o comando:
python --version
Passo 2: VS Code
Baixe e instale o Visual Studio Code: code.visualstudio.com
Instale a extensão Python da Microsoft
Passo 3: PLY
Instale a biblioteca PLY via pip:
pip install ply
Verifique a instalação:
python -c "import ply; print(ply.__version__)"
Demonstração Prática: Analisador Léxico Básico
# analisador_lexico.py
import ply.lex as lex

# Lista de tokens
tokens = (
   'NUMERO',
   'MAIS',
   'MENOS',
   'VEZES',
   'DIVIDE',
   'LPAREN',
   'RPAREN',
)

# Regras de expressão regular para tokens simples
t_MAIS    = r'\+'
t_MENOS   = r'-'
t_VEZES   = r'\*'
t_DIVIDE  = r'/'
t_LPAREN  = r'\('
t_RPAREN  = r'\)'

# Regra para números
def t_NUMERO(t):
    r'\d+'
    t.value = int(t.value)    
    return t

# Ignorar espaços e tabs
t_ignore  = ' \t'

# Tratamento de erros
def t_error(t):
    print(f"Caractere ilegal '{t.value[0]}'")
    t.lexer.skip(1)

# Construir o analisador léxico
lexer = lex.lex()
Testando o analisador
# Testar com uma entrada
data = '3 + 4 * (10 - 5)'
lexer.input(data)

# Tokenizar
for tok in lexer:
    print(tok)
Saída esperada
LexToken(NUMERO,3,1,0)
LexToken(MAIS,'+',1,2)
LexToken(NUMERO,4,1,4)
LexToken(VEZES,'*',1,6)
LexToken(LPAREN,'(',1,8)
LexToken(NUMERO,10,1,9)
LexToken(MENOS,'-',1,12)
LexToken(NUMERO,5,1,14)
LexToken(RPAREN,')',1,15)
Resumo da Aula
Fundamentos
Compreendemos o que são compiladores e sua importância no desenvolvimento de software, diferenciando-os de interpretadores.
Estrutura
Estudamos as principais fases de um compilador: análise léxica, sintática, semântica, otimização e geração de código.
Ambiente
Configuramos as ferramentas necessárias para a disciplina: Python, VS Code e PLY.
Prática
Implementamos um analisador léxico simples como primeiro passo na construção de um compilador.
Atividade Sugerida
Instale o ambiente em seu computador, reproduza o exemplo do analisador léxico e modifique-o para reconhecer novos tokens como operadores de comparação (>, <, ==) e palavras-chave (if, else, while).