Mini Compiler

Mini Compiler Building a mini compiler is a foundational project for understanding how programming languages work. It bridges the gap between human-readable source code and machine-executable instructions. By creating a scaled-down compiler, developers gain deep insights into software architecture, parsing techniques, and resource management. ⚙️ The Architecture of a Mini Compiler

A standard compiler operates in distinct phases. A mini compiler simplifies these stages but retains the core pipeline: Frontend, Optimization, and Backend.

+————-+ +————+ +——————-+ +—————–+ | Source Code | —> | Lexer | —> | Parser | —> | Code Generator | +————-+ | (Tokens) | | (Abstract Syntax) | | (Target Code) | +————+ +——————-+ +—————–+ 1. Lexical Analysis (The Lexer)

The lexer reads the raw source code character by character. It groups these characters into meaningful pieces called tokens. Input: x = 5 + 10 Output: [IDENTIFIER(“x”), ASSIGN, INT(5), PLUS, INT(10)] 2. Syntax Analysis (The Parser)

The parser takes the stream of tokens and checks them against the grammatical rules of the language. It organizes the tokens into a hierarchical tree structure known as an Abstract Syntax Tree (AST). This tree represents the logical structure of the code. 3. Code Generation

The backend of the mini compiler traverses the AST and translates it into the target language. For a mini compiler, the target language is often a simplified assembly language, virtual machine bytecode, or even another high-level language like C. 🛠️ Implementing a Mini Compiler in Python

Below is a highly simplified implementation of a mini compiler. This project accepts simple arithmetic expressions like 5 + 3 or 10 - 2 and generates basic assembly-like instructions.

import re # Token types TOKEN_INT = “INT” TOKEN_PLUS = “PLUS” TOKEN_MINUS = “MINUS” class Lexer: def init(self, text): self.text = text self.pos = 0 def get_next_token(self): # Skip whitespace while self.pos < len(self.text) and self.text[self.pos].isspace(): self.pos += 1 if self.pos >= len(self.text): return None current_char = self.text[self.pos] if current_char.isdigit(): match = re.match(r’\d+‘, self.text[self.pos:]) value = match.group([]) self.pos += len(value) return (TOKEN_INT, int(value)) if current_char == ‘+’: self.pos += 1 return (TOKEN_PLUS, ‘+’) if current_char == ‘-’: self.pos += 1 return (TOKEN_MINUS, ‘-’) raise ValueError(f”Invalid character: {current_char}“) class Parser: def init(self, lexer): self.lexer = lexer self.current_token = self.lexer.get_next_token() def eat(self, token_type): if self.current_token and self.current_token[0] == token_type: self.current_token = self.lexer.get_next_token() else: raise SyntaxError(“Invalid syntax”) def parse(self): # Parse simple: INT OP INT left = self.current_token self.eat(TOKEN_INT) op = self.current_token if op[0] == TOKEN_PLUS: self.eat(TOKEN_PLUS) elif op[0] == TOKEN_MINUS: self.eat(TOKEN_MINUS) else: raise SyntaxError(“Expected operator”) right = self.current_token self.eat(TOKEN_INT) return (op[0], left[1], right[1]) class CodeGenerator: def generate(self, ast): op, left, right = ast instructions = [ f”LOAD R1, {left}“, f”LOAD R2, {right}” ] if op == TOKEN_PLUS: instructions.append(“ADD R1, R2”) elif op == TOKEN_MINUS: instructions.append(“SUB R1, R2”) instructions.append(“STORE R1, RESULT”) return instructions # Execution source_code = “42 - 7” lexer = Lexer(source_code) parser = Parser(lexer) ast = parser.parse() compiler = CodeGenerator() print(“\n”.join(compiler.generate(ast))) Use code with caution. Output Target Code: LOAD R1, 42 LOAD R2, 7 SUB R1, R2 STORE R1, RESULT Use code with caution. 🚀 Why Build a Mini Compiler?

Demystifies Magic: Software development feels less like magic once you understand how text turns into logic.

Optimized Coding: Knowing how compilers read code helps you write cleaner, more performant software.

Domain-Specific Languages (DSLs): Engineering teams often require custom mini-languages for data processing, configuration, or automation. Building a mini compiler provides the exact skillset needed to design a DSL.

To expand this mini compiler project, consider adding features like variable assignments, looping mechanisms, or a symbol table to track variables. Tell me:

What programming language do you plan to use for your compiler?

What features (variables, loops, functions) do you want it to support?