Convert a Python float to 16.16 fixed-point integer. Args: value: Real number to convert. Returns: Signed 32-bit integer in

Consume a token of type *tt* or raise :class:`ParseError`.

Compile a DSL source string to assembly segments.

Return the first top-level declaration.

Compile a .doom DSL source string into a .ttf font file. Runs the full compilation pipeline: 1. Parse source text into an AST. 2.

Generate fixed-point sin/cos lookup tables. Divides a full circle into *entries* equal steps and computes ``sin(angle) * scale`` and ``cos(an

Generate a PUSH instruction for an integer value. Args: value: The integer to push onto the TT stack. Returns:

Compile an expression, leaving its result on the stack. Args: expr: An AST expression node. Returns: List of

Return the complete list of tokens for the source text.

Compile a ``Program`` AST to assembly. Args: program: The root AST node. Returns: Dict with keys ``'fpgm'``,

Parse the complete source and return a :class:`Program` AST.

If the current token matches any of *types*, consume and return it.

Return the current token without consuming it.

Simulate the fixmul FDEF through TT arithmetic. Mirrors the instruction sequence in ``_fixmul_asm()``: 1. ``MUL[]`` -> ``(a * b) / 64`

Convert a 16.16 fixed-point integer back to a Python float. Args: raw: Integer in 16.16 fixed-point representation. Returns:

Top-level expression: or_expr.

Return just the token types for *source* (excluding EOF).

Create a glyph with *num_bars* vertical rectangular contours. Each bar is a separate closed contour occupying an equal horizontal slice of th

Consume and return the current token.

Allocate a function ID for an FDEF. Args: name: Function name. Returns: Assigned FDEF function ID.

Allocate a single storage slot for a variable. Args: name: Variable name. Returns: Assigned storage slot ind

Return True if the current token has the given type.

Integer division that truncates toward zero (C / TT semantics). Python's ``//`` floors toward negative infinity, but the TrueType VM truncate

Build the complete DOOM ``.ttf`` font. Args: fpgm_asm: Assembly instructions for the font program (function definitions loade

Simulate the fixdiv FDEF through TT arithmetic. Mirrors the instruction sequence in ``_fixdiv_asm()``: 1. ``SWAP`` -

Generate assembly to store *value* at *storage_idx*. Uses ``PUSHB`` for values in [0, 255] and ``PUSHW`` otherwise. The storage index is pus

Allocate storage slots for function parameters. Parameters are stored in storage slots so they can be referenced by name inside the f

Return TT assembly bodies for every standard-library function. Each value is a list of TrueType assembly mnemonics that form the function bod

Emit an FDEF block for a user-defined function.

Check whether a single assembly line is a valid TT instruction.

Create a minimal ``.notdef`` glyph. The ``.notdef`` glyph is a required placeholder in every TrueType font. It is drawn as a simple rectangle

Generate TrueType assembly to load sin/cos tables into storage. Emits a sequence of ``PUSHB``/``PUSHW`` + ``WS[]`` instructions that write ev

Check whether a single assembly line is a valid TT instruction. Recognises: - Bare mnemonics like ``MUL[]``, ``SWAP[]`` - Push instructio

Compile doom.doom into a TrueType font. Args: output_path: Override for the output .ttf path. Defaults to ``doom.ttf`` in th

Build complete ``fpgm`` assembly containing all stdlib FDEFs. Args: func_ids: Optional mapping of function name to its FDEF ID.

Return stack-effect metadata for every stdlib function. This information is consumed by the compiler's stack-depth analyser and register allo

Look up a name in the symbol table. Searches constants, then variables, then arrays. Args: name: The identifier to look

Simulate TrueType ``DIV[]``: ``(n2 * 64) / n1``. The VM pops n1 (top-of-stack), then n2 (below), and pushes the result. Division truncates t

Simulate TrueType ``MUL[]``: ``(a * b) / 64``. The VM pops b (top-of-stack), then a, and pushes the result. Division truncates toward zero.

Parse one or more statements until DEDENT (without consuming it).

Compile a single statement. Args: stmt: An AST statement node. Returns: List of assembly instructions.

Allocate a contiguous range of storage slots for an array. Args: name: Array name. size: Number of elements.

Build a variable TrueType font from compiled assembly segments. Creates a font with a multi-bar glyph whose geometry is controlled by TrueTyp

Return True if world coordinate (*wx*, *wy*) is inside a wall.

Parse a standalone expression (usually a function call).

Consume any NEWLINE tokens at the current position.

Create a variable TrueType font with a MOVE axis driving bar height. The font contains a single glyph 'A' drawn as a vertical rectangle (4 on

Register a compile-time constant. Args: name: Constant name. value: Integer value (inlined at every use site).

Reference: exact ``(a * b) / 65536`` with truncation toward zero.

``mul_expr (('+' | '-') mul_expr)*``

``not_expr ('and' not_expr)*``

``unary_expr (('*' | '/' | '%') unary_expr)*``

``'not' not_expr | comparison``

Parse a DSL source string into an AST.

``'-' unary_expr | atom``

``var IDENT : int ( = expr )?``

Create a proof-of-concept TrueType font with hinting instructions. The font contains a single glyph 'A' drawn as a vertical rectangle (4 on-c

``(expr (',' expr)*)?``

``array IDENT [ INT_LITERAL ]``

Parse IDENT-led statement: assignment, array assignment, or expr.

Parse an atomic expression. ``INT_LITERAL | IDENT '(' args ')' | IDENT '[' expr ']' | IDENT | '(' expr ')'``

``add_expr (comp_op add_expr)?``

Compile an array element read: ``arr[i]``. Assembly: compile index, push base, ADD, RS.

Compile ``arr[i] = expr``. Assembly: compile value, compile index, push base, ADD, SWAP, WS. WS pops index (top) then value (below),

Compile ``target = expr``. Assembly: compile expr, push storage index, SWAP, WS.

Compile a binary operation.

Compile a function or intrinsic call.

Compile get_axis(N) intrinsic. GETVARIATION[] pushes N values onto the stack (one per axis). We need to extract the Nth value.

Compile if/else statement. Assembly: compile condition, IF, body, (ELSE, body)?, EIF.

Compile an intrinsic function call.

Compile a local variable declaration inside a function body. Allocates a new storage slot and optionally initialises it. Local variab

Compile a return statement. If there is a return value, compile the expression so it is left on the stack for the caller. If there i

Compile set_point_y(point_idx, coordinate_funits) intrinsic. Accepts coordinate in font units (0..1000 for a 1000-UPM font) and conve

Compile a unary operation.

Compile a variable or constant reference.

Compile a while loop via recursive FDEF pattern. Each while loop becomes a private FDEF that tests its condition, executes the body i

``const IDENT = INT_LITERAL``

Parse one top-level declaration.

Fixed-point absolute value (thin wrapper around ``ABS[]``). Stack effect: ``..., a -> ..., |a|``

Fixed-point 16.16 divide: ``(a << 16) / b``. Stack effect ~~~~~~~~~~~~ :: input: ..., a, b (b on top) output: ..., (a

Fixed-point 16.16 multiply: ``(a * b) >> 16``. Stack effect ~~~~~~~~~~~~ :: input: ..., a, b (b on top) output: ...,

Fixed-point negation (thin wrapper around ``NEG[]``). Stack effect: ``..., a -> ..., -a``

``func IDENT ( params ) ( -> int )? : NEWLINE INDENT body DEDENT``

Emit glyph assembly that calls game_tick (if defined).

Emit prep assembly for global variable initialisation.

``if expr : NEWLINE INDENT body DEDENT (else ...)?``

Construct a :class:`Token`, converting values where needed.