Compiler Architecture

​

Overview

• Stack-based concatenative programming model
• Pure and impure function distinction (functions vs actions)
• Linear types and stack-based resource management
• Full optional type inference
• Single-pass compilation
• Pluggable backend system

​

Build Graph

​

Pipeline Stages

1. Source Files - .dry source files and standard library
2. Frontend - Single-pass parser and semantic analyzer
3. Backend - Code generator for target platform
4. IR - Intermediate representation (C code, assembly, etc.)
5. Assembler - Platform assembler/compiler (GCC, NASM, etc.)
6. Objects - Compiled object files from Dryft code and native bindings
7. Linker - Links all objects into final executable
8. Interpreter - Executes the resulting program

​

Frontend Architecture

​

compile()

pub fn compile(backend: &mut Box<dyn Backend>, code: &str) -> CompileState

1. Character-by-character processing - The source code is drained one character at a time (line 45)
2. Token accumulation - Characters are accumulated into words until whitespace is encountered
3. Immediate processing - Each token is processed immediately via handle_token()
4. State tracking - The CompileState struct maintains all compilation state

• Comment handling - #comment# syntax (lines 65-69)
• String literals - "text" syntax (lines 70-79)
• Annotations - (annotation) syntax for metadata (lines 80-86)
• File inclusion - Tracks file stack for include keyword (lines 94-104)
• Line tracking - Maintains line and file information for error reporting (lines 54-62)

​

compile_full()

pub fn compile_full(mut backend: Box<dyn Backend>, code: &str) -> String

​

Token Handling

1. Recognizes token types - Keywords, numbers, variables, function calls, etc.
2. Manages definition contexts - Tracks whether we’re inside a function, loop, etc.
3. Performs type checking - Validates stack types match operation requirements
4. Emits backend code - Calls appropriate backend methods to generate output

​

Definition Stack

• Function - Pure functions (declared with fun:)
• Action - Impure actions (declared with act:)
• Then - Conditional blocks
• Elect - When/elect blocks (switch-like)
• Loop - Infinite loops
• Variable - Variable declarations
• Linkin - External function bindings
• Include - File inclusion
• Module - Module definitions

​

Token Matching

• fun: / :fun - Define functions
• act: / :act - Define actions
• then: / :then - Conditional blocks
• elect: / :elect or when: / :when - Switch-like constructs
• loop: / :loop or cycle: / :cycle - Infinite loops
• var: - Variable declaration

• break - Exit loops
• return - Return from functions
• ; or end - End current block

• Integer regex match (line 473)
• String literals (handled separately)
• true / false - Boolean literals

• $varname - Read variable (line 463)
• varname! - Write variable (line 478)

• Arithmetic: +, -, *, /, mod
• Stack ops: ^ (copy), v (drop), swap
• Comparison: =?, !=?, >?, <?, >=?, =<?
• Logic: not, both?, either?, xor

• linkin - Link external functions (line 329)
• include - Include other files (line 334)
• Method calls - Any previously defined function/action name

​

Compile State

​

Core Fields

• out: Option<String> - Final compiled output
• methods: HashMap<String, Method> - All defined functions and actions
• word: String - Current token being accumulated

​

Stacks

• defnstack - Definition context stack (what kind of block we’re in)
• metastack - Metadata for current definition (e.g., function names)
• bodystack - Code bodies for nested definitions
• varscopes - Variable scopes (nested HashMap stack)
• typestack - Type state for type checking
• voidstack - Input types for functions/actions

​

State Flags

• iscomment / isstring / isannotation - Parser mode flags
• linenumber / tokenumber - Position tracking
• current_file / file_stack - File inclusion tracking

​

Backend Interface

• Code generation: create_function(), create_loop_block(), etc.
• Stack operations: push_integer(), fun_add(), etc.
• Finalization: complete() wraps code with runtime

​

Backend Selection

pub fn select(name: &str) -> Box<dyn Backend> {
    match name {
        "C99" => Box::new(c99::C99Backend {}),
        "x86" => Box::new(x86::Nasm64Backend {}),
        other => panic!("Invalid backend {other}"),
    }
}

​

Type System

​

Value Types

pub enum ValueTypes {
    Number,          // Integer values
    Text,            // String values
    Binary,          // Boolean values
    Method(Vec<ValueTypes>, Vec<ValueTypes>),  // Function types
    Fake,            // Internal use only
}

​

Method Classes

pub enum MethodClass {
    Function,  // Pure functions (fun:)
    Action,    // Impure actions (act:)
}

​

Type Checking

• Each operation declares expected input types via cs.expect_types()
• Operations push their output types via cs.push_type()
• Type mismatches cause compilation errors
• Actions are tracked to ensure they’re not called in pure contexts

​

Error Handling

• cs.token_line and cs.token_file track where each token originates
• cs.throw_error() reports errors with context
• The file stack enables accurate error reporting even in included files

​

Single-Pass Compilation

• Each token is processed immediately as it’s encountered
• No AST is built
• Backend code is generated during parsing
• This keeps the compiler extremely simple but limits certain optimizations

​

Key Design Decisions

​

Stack-Based Concatenation

​

Linear Types

​

Macros

• new_definition! - Start new definition contexts
• add_method! - Finalize method definitions
• add_builtin! - Emit builtin operations
• check_terminator! - Validate block endings

​

Standard Library