Ferramentas e Infraestrutura
Video da aula estara disponivel em breve
O Pipeline GCC
O GCC (GNU Compiler Collection) e um dos compiladores mais usados. O que parece ser uma unica invocacao (gcc main.c -o main) na verdade executa um pipeline de ferramentas:
Diagrama
main.c --[cpp]--> main.i --[cc1]--> main.s --[as]--> main.o --[ld]--> main
fonte preprocessor expandido compiler assembly assembler objeto linker executavel
Fase Ferramenta Entrada Saida Funcao
Preprocessar cpp .c .i Expande #include, #define
Compilar cc1 .i .s Gera assembly
Montar as .s .o Gera codigo de maquina
Linkar ld .o + libs executavel Resolve simbolos, combina
Bash
# Ver cada etapa individualmente
gcc -E main.c -o main.i # so preprocessar
gcc -S main.c -o main.s # preprocessar + compilar (gera assembly)
gcc -c main.c -o main.o # preprocessar + compilar + montar (gera objeto)
gcc main.c -o main # tudo: preprocessar + compilar + montar + linkar
# Ver o que o GCC faz internamente
gcc -v main.c -o main # mostra cada comando executadoLLVM: Arquitetura Modular
O LLVM e um framework de compilacao modular que se tornou o padrao da industria. Sua arquitetura encarna perfeitamente a separacao front-end / IR / back-end:
Diagrama
Front-ends: Core: Back-ends:
+--------+ +---------+
| Clang |--\ +----------+ /--->| x86_64 |
| (C/C++) | \ | | / +---------+
+--------+ }--------->| LLVM IR |------{ +---------+
+--------+ / | Passes | \--->| ARM |
| rustc |--/ | Optimize | +---------+
+--------+ / +----------+ /--->+---------+
+--------+-/ / | WebAsm |
| swiftc | +---------+
+--------+
LLVM IR e um assembly virtual tipado, em formato SSA
Bash
# Gerar LLVM IR a partir de C
clang -S -emit-llvm hello.c -o hello.ll
# Ver o IR gerado (formato legivel)
cat hello.ll
# Otimizar o IR
opt -O2 hello.ll -o hello_opt.ll
# Gerar assembly nativo a partir do IR
llc hello_opt.ll -o hello.sParser Generators
Em vez de escrever lexers e parsers manualmente, podemos usar geradores que produzem codigo a partir de especificacoes formais:
Diagrama
Ferramenta Entrada Saida Linguagem
---------- ------- ----- ---------
lex / flex regras regex scanner C C
yacc / bison gramatica BNF parser C C
ANTLR gramatica EBNF parser Java/Python/C++/JS
PLY decorators Python lexer+parser Python
Lark gramatica EBNF parser Python
Tree-sitter gramatica JS parser incremental C (com bindings)O Modulo ast do Python
Python oferece ferramentas built-in para trabalhar com compilacao. O modulo ast permite parsear codigo Python e inspecionar a arvore sintatica:
Python
import ast
# Parsear codigo Python em uma AST
codigo = """
def calcular(taxa, bonus):
resultado = taxa * 100 + bonus
return resultado
"""
tree = ast.parse(codigo)
# Mostrar a AST
print(ast.dump(tree, indent=2))
# Module(
# body=[
# FunctionDef(
# name='calcular',
# args=arguments(args=[arg(arg='taxa'), arg(arg='bonus')]),
# body=[
# Assign(
# targets=[Name(id='resultado')],
# value=BinOp(
# left=BinOp(left=Name(id='taxa'), op=Mult(), right=Constant(value=100)),
# op=Add(),
# right=Name(id='bonus')
# )
# ),
# Return(value=Name(id='resultado'))
# ]
# )
# ]
# )
# O modulo tokenize mostra os tokens (fase lexica)
import tokenize
import io
tokens = tokenize.generate_tokens(io.StringIO(codigo).readline)
for tok in tokens:
print(f"{tokenize.tok_name[tok.type]:10} {tok.string!r}")
Na pratica
O modulo
ast do Python e extremamente util para analise estatica de codigo, transformacao de codigo, e metaprogramacao. Ferramentas como black (formatador), mypy (type checker), e pylint (linter) usam a AST do Python internamente.
No harness.os
O pipeline de ferramentas MCP do harness.os e analogo ao pipeline de compilacao. Cada tool call passa por fases equivalentes:
Diagrama
Pipeline MCP Tool Call no harness.os:
Requisicao JSON --> Validacao --> Roteamento --> Execucao --> Resposta JSON
(entrada) (lexica+ (sintatica: (semantica: (codigo gerado)
sintatica: qual tool? consulta DB,
JSON valido? params ok?) logica)
schema ok?)
Paralelo com GCC:
.c --> preprocessor --> compiler --> assembler --> linker --> executavel
JSON --> parse --> validate --> route --> execute --> response
Python
# Usando ast para analisar um arquivo do harness.os
import ast
# Suponha que queremos analisar quais funcoes
# do harness.os fazem queries ao banco de dados
class DBQueryFinder(ast.NodeVisitor):
def __init__(self):
self.queries = []
def visit_Call(self, node):
# Procura chamadas a execute() ou fetch()
if isinstance(node.func, ast.Attribute):
if node.func.attr in ('execute', 'fetch', 'fetchone'):
self.queries.append({
'line': node.lineno,
'method': node.func.attr,
})
self.generic_visit(node)
# Uso:
# with open('harness_server.py') as f:
# tree = ast.parse(f.read())
# finder = DBQueryFinder()
# finder.visit(tree)
# print(f"Encontradas {len(finder.queries)} queries")Resumo
- GCC executa um pipeline de ferramentas: preprocessor, compiler, assembler, linker
- LLVM usa uma arquitetura modular com IR comum (LLVM IR em formato SSA)
- Parser generators (yacc, ANTLR, PLY) geram lexers e parsers a partir de especificacoes
- Python oferece os modulos
astetokenizepara introspecao de codigo - O pipeline MCP do harness.os segue o mesmo padrao de processamento em fases
Exercicio
Use o modulo ast do Python para analisar um arquivo Python do harness.os (ou qualquer arquivo Python). Escreva um script que:
- Parseia o arquivo em uma AST
- Lista todas as funcoes definidas (nome, numero de parametros, linha)
- Identifica todas as chamadas a funcoes externas
- Gera um relatorio resumido
Verifique seu entendimento
Qual das seguintes ferramentas gera um parser a partir de uma especificacao de gramatica?