Lox Interpreter

A complete implementation of the Lox programming language interpreter in Kotlin, following the principles from "Crafting Interpreters".

Features

Lexical Analysis: Full tokenization with keyword and identifier distinction
Parsing: Recursive descent parser building an abstract syntax tree
Variables: Dynamic typing with var declarations and lexical scoping
Functions: First-class functions with named (fun) and anonymous (fn) syntax, closures, and proper tail behavior
Classes: Object-oriented programming with inheritance, instance fields, and methods
Static Methods: Class-level methods accessible directly on the class
Native Functions: Built-in functions for I/O and timing (clock, println, scan, input)
Control Flow: if/else statements and while loops
Operators: All standard arithmetic, comparison, logical, and assignment operators
Scope Resolution: Static analysis pass that pre-computes variable binding distances for efficient runtime lookup
Error Handling: Proper runtime error reporting with token information

Language Syntax Basics

Variables and assignment:

var x = 10;
x = 20;

Functions:

fun greet(name) {
  println("Hello, " + name);
}

greet("Alice");

Anonymous functions:

var add = fn(a, b) { a + b };
println(add(3, 4));

Classes and inheritance:

class Animal {
  init(name) {
    this.name = name;
  }
  
  speak() {
    println(this.name + " makes a sound");
  }
}

class Dog > Animal {
  speak() {
    println(this.name + " barks");
  }
}

var dog = Dog("Buddy");
dog.speak();

Building and Running

Compile the Kotlin code and run the interpreter:

kotlinc -include-runtime -d lox.jar src/*.kt
java -jar lox.jar script.lox

Or use the REPL for interactive mode.

Implementation Highlights

Visitor Pattern: AST traversal for both parsing and interpretation
Environment Chains: Linked scopes for variable storage and lookup
Resolver: Two-pass compilation approach (resolve then execute) for scope analysis
LoxCallable: Interface for both user-defined and native functions
Exception-based Control Flow: RuntimeReturn for return statements, RuntimeError for errors

Project Structure

src/main/kotlin/com/aymanetech/
├── Lox.kt                      # Main entry point and REPL
│
├── lexer/                      # Lexical analysis
│   ├── Scanner.kt
│   ├── Token.kt
│   └── TokenType.kt
│
├── parser/                     # Syntax analysis
│   └── Parser.kt
│
├── ast/                        # Abstract Syntax Tree
│   ├── Expr.kt
│   └── Stmt.kt
│
├── resolver/                   # Semantic analysis
│   └── Resolver.kt
│
├── interpreter/                # Runtime execution
│   ├── Interpreter.kt
│   ├── Environment.kt
│   └── NativeFunctions.kt
│
└── runtime/                    # Runtime types and errors
    ├── LoxCallable.kt
    ├── LoxClass.kt
    ├── LoxFunction.kt
    ├── LoxInstance.kt
    └── errors/
        ├── ErrorHandler.kt
        ├── DiagnosticReporter.kt
        ├── RuntimeError.kt
        └── RuntimeReturn.kt

References

This implementation closely follows the Lox language design and interpreter architecture from "Crafting Interpreters" by Robert Nystrom, adapted to Kotlin's modern language features.

FilesExpand file tree

README.md

Latest commit

History