Mini Programming Language Project

Introduction and Motivation

Building your own programming language — even a tiny one — is the ultimate compiler design exercise. It ties together every concept from this course: lexical analysis, parsing, semantic analysis, symbol tables, type checking, and code execution. When you finish this project, you will truly understand how programming languages work from the inside out.

Our mini language will be a simple procedural language supporting integer and float types, variables, arithmetic and logical operations, control flow (if-else, while loops), functions with parameters and return values, and basic input/output. Think of it as a stripped-down C with just enough features to write interesting programs like factorial, fibonacci, or sorting algorithms.

Language Design Decisions

Before writing any code, you need to design your language. Every choice has consequences for the complexity of your compiler:

Key design decisions include: Will types be static or dynamic? (We choose static — checked at compile time.) Will variables need explicit declaration? (Yes — helps catch typos.) Will functions support recursion? (Yes — essential for teaching.) These choices shape every phase of our compiler.

Implementation Architecture

The implementation follows the classic compiler pipeline, with interpretation instead of machine code generation:

Phase 1: The Lexer

The lexer recognizes these token categories:

The key challenge is distinguishing keywords from identifiers. The lexer first reads an alphabetic sequence, then checks if it matches any keyword. If not, it is an identifier:

Phase 2: The Parser and AST

The parser builds an Abstract Syntax Tree where each node represents a language construct. Here is the AST node structure:

The parser uses recursive descent. Here is how it handles if-statements:

Phase 3: Semantic Analysis

The semantic analyzer traverses the AST and performs critical checks using a symbol table:

The symbol table supports nested scopes using a stack of hash tables:

Phase 4: The Interpreter

The interpreter walks the AST and executes each node. It maintains a runtime environment with variable values and a call stack for function invocations:

Tracing Through Execution

Let us trace factorial(3):

Testing Strategy

Create a systematic test suite covering each language feature:

Extension Ideas

Once the basic interpreter works, consider these enhancements:

• Arrays: int arr[10]; arr[0] = 5; — requires array type in symbol table and bounds checking
• String type: String literals, concatenation, and length operations
• For loops: for (int i = 0; i < 10; i++) syntactic sugar
• Code generation: Instead of interpreting, generate x86 assembly or LLVM IR
• Standard library: Built-in functions like sqrt(), abs(), strlen()
• Error recovery: Continue after the first error to report multiple issues

Key Takeaways

Building a mini language teaches you that a programming language is not magic — it is a carefully designed system with a lexer, parser, semantic analyzer, and execution engine working together. Every feature you use daily in languages like Python or Java was deliberately designed, implemented, and tested by someone who understood these same compiler principles. This project gives you that same understanding, making you a better programmer regardless of which language you use.