Translates a ``Program`` AST into TrueType hinting assembly. Usage:: gen = CodeGenerator() result = gen.compile(program_ast)

Root AST node — a sequence of top-level declarations.

Tokenize TTDoom DSL source code. Usage:: lexer = Lexer(source_code) tokens = lexer.tokenize() # list[Token]

Recursive-descent parser for the TTDoom DSL. Usage:: parser = Parser(source_code) program = parser.parse() # returns ast_nodes

Raised when code generation encounters an unrecoverable error.

Assigns storage indices and function IDs. Args: start_storage: First available storage slot index. start_func_id: First available

A single lexical token.

Function definition with typed parameters and optional return type. ``func add(a: int, b: int) -> int:``

Binary operation. Supported operators: ``+ - * / % == != < > <= >= and or``

Standalone expression (typically a function call).

Raised when the allocator detects an invalid operation.

Function or intrinsic call. Intrinsics: ``get_axis``, ``set_point_y``, ``fixmul``, ``fixdiv``.

Integer constant (decimal or hex).

Raised when the parser encounters a syntax error.

Indexed array read: ``map_data[y * MAP_SIZE + x]``.

Simple variable assignment: ``player_x = player_x + dx``.

Raised when the lexer encounters an invalid character or token.

Unary operation: negation ``-`` or logical ``not``.

Indexed array write: ``map_data[idx] = value``.

Contiguous storage-slot array. ``array sin_table[256]``

Compile-time constant (always inlined). ``const SCALE = 16384``

Conditional with optional else branch. The else branch may itself contain a single ``IfStmt`` for chaining.

Return statement with optional expression.

Global or local variable declaration. ``var player_x: int = 512``

Reference to a named variable or constant.

While-loop.

Verify arithmetic operators compile correctly.

Compile a program with arrays and while loops.

Compile ``arr[i]`` read and verify index + base + RS.

Compile ``arr[i] = v`` and verify correct WS sequence.

Verify that assembly can be disassembled and still makes sense.

Verify that generated assembly consists of valid TT instructions.

Compile ``x = x + 1`` and verify RS/ADD/WS sequence.

Test the build_font function directly.

Verify the FDEF/ENDF wrapping and function ID assignment.

Verify the build script produces a valid font file.

Test the compiler CLI (python -m compiler).

Verify all comparison operators compile to correct TT instructions.

Verify a more complex program compiles without errors.

Compile ``const C = 100`` and verify it is inlined in expressions.

Verify to_fixed / from_fixed round-trip correctly.

Verify specific DSL features used in the raycaster.

Verify that doom.doom compiles to valid TT assembly.

Verify that doom.doom parses without errors.

Stress-test with boundary and adversarial inputs.

Compile a small program, inject into a font, verify valid bytecode.

End-to-end tests verifying the complete build pipeline.

Verify that code generation raises useful errors.

Verify that compilation errors are handled gracefully.

Verify the trivial ABS/NEG wrappers.

Verify fixdiv produces correct results via simulation.

Verify fixmul produces correct results via simulation.

Inject stdlib assembly into a real .ttf and verify it compiles.

Verify font can be saved and reloaded (round-trip).

Verify the built font has the correct tables and structure.

Verify the structural properties of compiled fonts.

Verify the font program (fpgm) content.

Compile function calls and verify push args + CALL.

Compile function definitions and verify FDEF with param storage.

Verify stack-effect metadata is consistent.

Compile a program with function definitions and calls.

Compile a game-like program with variables, arrays, functions, if/while.

Compile get_axis(N) and verify GETVARIATION assembly.

Verify glyph program generation.

Compile a program with if/else.

Compile if/else and verify IF/EIF assembly.

Every generated instruction should be a valid TT mnemonic.

Verify that local variables in different functions do not conflict.

Verify and/or/not compile to correct TT instructions.

Verify the map data loading.

Verify sin/cos table generation and integration.

Compile a minimal ``var x: int = 42`` program.

Compile ``a + b * c`` and verify correct order.

Verify the pre-program (prep) content.

Verify prep program always starts with SVTCA[0].

Verify PUSHB/PUSHW selection based on value range.

Compile return and verify expr is left on stack.