CodeX - Interpreted, Object-Oriented Programming Language

October 5, 2024

• Interpreted Language: CodeX is interpreted, meaning code is executed line by line, allowing for a simpler debugging process and flexible runtime behavior.
• Object-Oriented: The language includes object-oriented principles, supporting classes, objects, and inheritance to manage complex data structures and relationships.
• Statically Typed: CodeX enforces static typing, ensuring type-checking at compile-time, reducing runtime errors and improving code reliability.
• Custom Syntax & Parser: Developed a custom syntax and parsing mechanism to give CodeX its unique structure and flow control.
• Memory Management: Implemented basic memory management techniques to understand how a language manages variable lifetimes and resource allocation.

• Node.js: Built the language using Node.js for its simplicity in handling file operations and its high performance for developing the language’s interpreter.
• JavaScript: Utilized JavaScript for developing the core interpreter logic, from tokenizing to parsing and executing the language code.

• Converts raw source code into tokens.
• Uses a regular expression-based tokenizer to break down keywords, identifiers, operators, literals, and symbols.
• Example Tokenization:

  let x = 10;
  

  Converts to tokens:

  [ {type: 'KEYWORD', value: 'let'}, {type: 'IDENTIFIER', value: 'x'},
    {type: 'OPERATOR', value: '='}, {type: 'NUMBER', value: '10'}, {type: 'SEMICOLON', value: ';'} ]
  

• The parser converts tokens into an Abstract Syntax Tree (AST).
• AST structures the logic of the code, enabling execution.
• Example:

  class Animal {
      func speak() {
          print("Hello");
      }
  }
  

  Gets parsed into an AST structure like:

  {
      type: "ClassDeclaration",
      name: "Animal",
      body: [
          {
              type: "FunctionDeclaration",
              name: "speak",
              body: [{ type: "PrintStatement", value: "Hello" }]
          }
      ]
  }
  

• Since CodeX is statically-typed, type checking occurs before execution.
• Example:

  let x: int = "hello";  // Throws a TypeError
  

• The interpreter traverses the AST, executing nodes dynamically.
• CodeX uses an execution stack, tracking variables and function calls.

• Everything is an object (variables, classes, functions, etc.).
• Supports inheritance, encapsulation, and polymorphism.
• Classes and methods are first-class citizens.

class Person {
    let name: string;

    func init(name: string) {
        this.name = name;
    }

    func greet() {
        print("Hello, my name is " + this.name);
    }
}
let p = new Person("Advay");
p.greet();  // Output: Hello, my name is Advay

• Uses reference counting to deallocate memory.
• Automatically cleans up objects no longer in use.
• Prevents circular references with weak references.

func createPerson() {
    let temp = new Person("John");
}
// 'temp' object is automatically garbage collected when function exits.

• Users write .codex files and execute them via codex filename.codex.
• Has a built-in Read-Eval-Print Loop (REPL) for interactive execution.
• Provides standard library functions for I/O, math, and collections.

$ codex
CodeX REPL v1.0
>> let x: int = 5;
>> print(x * 2);
10

• Compile-time Errors (Syntax, Type, Scope errors)
• Runtime Errors (Null references, Undefined variables, Division by zero)
• Custom Exception Handling
• But Custom Exceptions cannot be created

try {
    let y: int = 10 / 0;
} catch (e) {
    print("Error: Division by zero!");
}

• Github