How romainpc/decacompiler works
Project type and purpose
• This is a compiler for the Deca language (“Compilateur du langage deca”), implemented in Java, built with Maven.
• It reads .deca source files, performs lexing, parsing, AST construction, contextual (semantic) analysis, and emits either IMA assembly (.ass) or Java bytecode (via Jasmin, producing .j files).
File structure
• Build & tooling
• pom.xml → Maven build, dependencies (ANTLR, Log4j, Jasmin).
• env_settup.sh, wsl_config.sh → environment scripts.
• src/main/bin/decac → CLI launcher shell script.
• lib/jasmin.jar → external library for bytecode emission.
• Grammar & front‐end
• src/main/antlr4/.../DecaLexer.g4, DecaParser.g4 → ANTLR4 grammar.
• Generates AbstractDecaLexer, AbstractDecaParser, error listeners, exceptions in fr.ensimag.deca.syntax.
• AST & tree
• src/main/java/fr/ensimag/deca/tree → AST node classes (expressions, statements, declarations).
• Contextual analysis
• src/main/java/fr/ensimag/deca/context → symbol table, type definitions, contextual error checking.
• Code generation
• src/main/java/fr/ensimag/deca/codegen → register, memory, label managers, v-tables, dispatching to backends.
• src/main/java/fr/ensimag/ima/pseudocode → IR for IMA instructions.
• src/main/java/fr/ensimag/ima/pseudocode/instructions → concrete IMA ops.
• src/main/java/fr/ensimag/ima/pseudocode/jasmin & instructions/jasmin → Jasmin instruction emitter.
• Resources & tests
• src/main/resources/include/Math.decah → built-in library.
• src/test → lexing, syntax, context, codegen, and end-to-end scripts.
README for additional insights
• Confirms two backends: .ass (IMA) and Java bytecode (-j flag).
• Debug levels via log4j.properties.
• Test automation via Maven (mvn test, mvn verify, Jacoco).
a. Main components
• CLI / Driver (shell script + DecacMain)
• Build System (Maven)
• Front-end
• ANTLR Lexer → tokens
• ANTLR Parser → parse tree
• AST Builder (inferred by parser actions)
• Semantic (Contextual) Analyzer (symbol table, type checking)
• Intermediate Representation (AST + Pseudocode IR)
• Backends
• IMA Assembly Generator (.ass)
• Jasmin Bytecode Generator (.j) + external jasmin.jar
• Output / Execution
• IMA Simulator (external)
• JVM (executes generated .class via Jasmin)
b. Relationships & data flow
1. User invokes decac <file>.deca
2. CLI loads config, sets logging
3. Front-end: ANTLR Lexer → Parser → AST
4. Contextual analysis: AST + Environment → type-checked AST
5. Codegen dispatch: type-checked AST →
– IMA IR → .ass file
– Jasmin IR → .j file → jasmin.jar → .class bytecode
6. Output written to disk
c. Architectural patterns
• Pipeline of compiler phases (Front-end → Semantic → Backend)
• Modular backends (strategy pattern: pick IMA or Jasmin)
• Separation of concerns: grammar, AST, context, codegen, resources, CLI
d. Key technologies
• Java 16, Maven
• ANTLR4 (lexer/parser)
• Log4j (debug levels)
• Jasmin (Java bytecode assembler)
• Shell scripts for CLI & tests
Elements
• Clear labels on each component/module (use the actual package names).
• Green rectangles for compiler phases
• Blue parallelograms for input/output files
• Notes or annotations indicating configuration files (log4j.properties, pom.xml), command flags, and debug levels.
Details
• essential packages (fr.ensimag.deca.syntax, .context, .tree, .codegen, .ima.pseudocode).
• two output formats clearly.
• Don’t just group everything under “compiler”—show each pass separately.
• build & launch steps (Maven → CLI script → Java classes).