Learn Compilers Using CrabPascal

Bilingual post · Post bilíngue
Jump to: English · Português

English {#english}

Series — Part 2: Previous: Audit Deep Dive: IDE, CI, and Docs (054-audit-ide-ci-docs). Course doc: resources/curso-compiladores-crabpascal. Technical depth: architecture/technical/tecnico-detalhado.

Textbooks teach compilers with toy languages — CALC, MiniJava, IMP. Useful, but abstract. CrabPascal is a real compiler: lexer, parser, semantic analyzer, dual backends, RTL shims, and a sprint history you can read in git. The Mintlify course resources/curso-compiladores-crabpascal turns that codebase into a one-hour guided tour. This post explains why that matters and how to use it.

Why learn compilers through a real project?

Compiler courses often stop at code generation for a language with ten constructs. Production compilers add:

Error recovery and diagnostic spans
Namespace resolution and unit loading
Object layout, VMT, and properties
Two execution modes (interpret vs native C)
A runtime with 65+ builtins

CrabPascal exposes all of this in Rust, with Pascal fixtures you already understand if you know Delphi. You are not learning a compiler — you are learning how Delphi-like semantics get implemented.

Course structure (six modules)

The course in Mintlify walks six chapters:

Introduction — Why translation is fascinating; compilers as protectors and optimizers
Anatomy — Frontend (lexer, parser, semantic) vs backend (codegen, linker)
Lifecycle — Source to executable; where CrabPascal's dual-mode fits
CrabPascal case study — Concrete file map and pipeline phases
Real-world compilers — GCC, LLVM, Rustc comparisons
Next steps — How to contribute after the tour

Each section links theory to files you can open today.

Map theory to repository paths

Concept	CrabPascal location
Lexical analysis	`src/lexer/`
Parsing / AST	`src/parser/`, `src/ast/`
Semantic analysis	`src/semantic/`
Interpretation	`src/complete_runtime.rs`
C code generation	`src/codegen/`
Preprocessor	`src/preprocessor/`
Unit graph	`src/unit_resolver.rs`
Delphi RTL surface	`rtl/sys/*.pas`

Read architecture/technical/tecnico-detalhado alongside the course for VMT, heap layout, and builtin dispatch tables.

Hands-on exercises (self-paced)

After each module, try one small task:

After lexer module — Add a token trace to a failing fixture:

crab-pascal check tests/fixtures/your_file.pas

After parser module — Read a parser_hardening.rs test; find the AST node it asserts.

After semantic module — Introduce an undefined variable; confirm Sprint 1 span format in output.

After backend module — Compare run vs build-exe on a string fixture; note honest failures post-v2.21.0.

After runtime module — Trace a property read in complete_runtime.rs starting from a three-line class.

These exercises mirror what sprint contributors do — not exams, but navigation practice.

Who is this course for?

Delphi developers curious why their code behaves differently in CrabPascal
Rust developers wanting a large, readable compiler codebase
CS students past the dragon book who need a maintained case study
Contributors preparing for RTL, parser, or codegen sprints

Intermediate level assumed: you should read Pascal and basic Rust syntax.

Connection to the audit series

Posts 050–054 documented technical debt honestly. The course does not hide gaps — it shows where in the pipeline each feature lives so you can fix TD-IDs with context. Learning and contributing converge.

Takeaway

Compiler education does not require starting from zero. CrabPascal offers a bilingual, open, sprint-documented laboratory. Work through the course, then claim one backlog item — parser fixture, RTL shim, or parity test. That is how compiler engineers are made in 2026.

Next: Mapping the Delphi Bible to CrabPascal (056-delphi-bible-analysis).

Português {#portugus}

Aprenda compiladores com CrabPascal

Série — Parte 2: Anterior: Auditoria: IDE, CI e documentação (054-audit-ide-ci-docs). Curso: resources/curso-compiladores-crabpascal. Profundidade técnica: architecture/technical/tecnico-detalhado.

Livros ensinam compiladores com linguagens de brinquedo — CALC, MiniJava, IMP. Útil, mas abstrato. CrabPascal é um compilador real: lexer, parser, analisador semântico, dual backends, shims RTL e histórico de sprints legível no git. O curso Mintlify em resources/curso-compiladores-crabpascal transforma esse codebase em tour guiado de uma hora. Este post explica por que importa e como usar.

Por que aprender compiladores via projeto real?

Cursos de compiladores often param em codegen para linguagem com dez construtos. Compiladores de produção adicionam:

Recuperação de erro e spans de diagnóstico
Resolução de namespaces e carregamento de units
Layout de objetos, VMT e properties
Dois modos de execução (interpretar vs C nativo)
Runtime com 65+ builtins

CrabPascal expõe tudo isso em Rust, com fixtures Pascal que você já entende se conhece Delphi. Você não aprende um compilador — aprende como semântica Delphi-like é implementada.

Estrutura do curso (seis módulos)

O curso no Mintlify percorre seis capítulos:

Introdução — Por que tradução fascina; compiladores como protetores e otimizadores
Anatomia — Frontend (lexer, parser, semântica) vs backend (codegen, linker)
Ciclo de vida — Fonte ao executável; onde dual-mode do CrabPascal encaixa
Estudo de caso CrabPascal — Mapa concreto de arquivos e fases do pipeline
Compiladores reais — Comparações GCC, LLVM, Rustc
Próximos passos — Como contribuir após o tour

Cada seção liga teoria a arquivos que você pode abrir hoje.

Mapeie teoria para paths do repositório

Conceito	Local no CrabPascal
Análise léxica	`src/lexer/`
Parsing / AST	`src/parser/`, `src/ast/`
Análise semântica	`src/semantic/`
Interpretação	`src/complete_runtime.rs`
Codegen C	`src/codegen/`
Preprocessor	`src/preprocessor/`
Grafo de units	`src/unit_resolver.rs`
Surface RTL Delphi	`rtl/sys/*.pas`

Leia architecture/technical/tecnico-detalhado junto com o curso para VMT, layout de heap e tabelas de dispatch de builtins.

Exercícios práticos (auto-ritmo)

Após cada módulo, tente uma tarefa pequena:

Após módulo lexer — Adicione trace de token a fixture que falha:

crab-pascal check tests/fixtures/seu_arquivo.pas

Após módulo parser — Leia teste em parser_hardening.rs; ache o nó AST que ele asserta.

Após módulo semântica — Introduza variável indefinida; confirme formato de span Sprint 1 na saída.

Após módulo backend — Compare run vs build-exe em fixture de string; note falhas honestas pós-v2.21.0.

Após módulo runtime — Trace leitura de property em complete_runtime.rs partindo de classe de três linhas.

Esses exercícios espelham o que contribuidores de sprint fazem — não provas, mas prática de navegação.

Para quem é o curso?

Desenvolvedores Delphi curiosos por que código se comporta diferente no CrabPascal
Desenvolvedores Rust querendo codebase de compilador grande e legível
Estudantes de CC pós-dragon book que precisam de case study mantido
Contribuidores se preparando para sprints RTL, parser ou codegen

Nível intermediário assumido: leia Pascal e sintaxe Rust básica.

Conexão com série de auditoria

Posts 050–054 documentaram débito técnico honestamente. O curso não esconde gaps — mostra onde no pipeline cada feature vive para você corrigir TD-IDs com contexto. Aprender e contribuir convergem.

Ordem de leitura sugerida

getting-started/quickstart — rode hello world
resources/curso-compiladores-crabpascal — curso completo
architecture/technical/arquitetura-design — decisões de design
009-compiler-pipeline-five-phases (blog Parte 1) — visão do pipeline
Escolha um sprint review alinhado ao seu interesse (generics, exceptions, strings)

Conclusão

Educação em compiladores não exige começar do zero. CrabPascal oferece laboratório bilíngue, aberto e documentado por sprint. Faça o curso, depois claim um item do backlog — fixture de parser, shim RTL ou teste de paridade. Assim se formam engenheiros de compiladores em 2026.

Próximo: Mapeando a Bíblia Delphi no CrabPascal (056-delphi-bible-analysis).

Published on dev.to/@crabpascal · Código em CrabPascal

推荐订阅源

DEV Community

English {#english}