Execution Model of M7 Script

Overview

M7 Script executes code through an interpreter, following a structured multi-stage process. Each stage is responsible for transforming the source code into an executable format while enforcing syntax, optimization, and runtime integrity.

1. Tokenization (Lexical Analysis)

  • The tokenizer scans raw source code and converts it into tokens.
  • Tokens represent meaningful elements like keywords, identifiers, literals, and operators.
  • Whitespace and comments are discarded during this phase.

Example:

var x = 10 + 5;

Tokenized output:

[VAR] [IDENTIFIER:x] [ASSIGN] [NUMBER:10] [PLUS] [NUMBER:5] [SEMICOLON]

2. Parsing (Concrete Syntax Tree - CST)

  • Converts tokens into a structured Concrete Syntax Tree (CST).
  • The CST retains all code details, including formatting and syntactic elements.
  • This phase does not modify or optimize the code, only structures it.

Example CST (Simplified Representation):

ASSIGNMENT
├── VAR_DECL (x)
└── EXPRESSION
    ├── NUMBER (10)
    ├── OPERATOR (+)
    └── NUMBER (5)

3. Normalization (AST Transformation & Optimizations)

  • The Concrete Syntax Tree (CST) is transformed into an Abstract Syntax Tree (AST).
  • Unnecessary syntax details are removed, leaving only meaningful operations.
  • Optimizations are applied, such as:
    • Constant Folding → 10 + 5 becomes 15
    • Dead Code Elimination → Unreachable code is removed.

Example AST (After Optimization):

ASSIGNMENT
├── IDENTIFIER (x)
└── LITERAL (15)

4. Semantic Analysis (Planned Feature)

  • Currently, semantic analysis is performed at runtime.
  • A dedicated static analysis phase is planned after the language is fully operational and stable.
  • Once implemented, this phase will:
    • Ensure type consistency and scope validation before execution.
    • Detect undefined variables, incorrect argument counts, and invalid operations before runtime.

Example of Future Static Error Detection:

print(unknownVar); // ERROR: `unknownVar` is not defined

5. Execution (Interpreter Runtime Processing)

  • The AST is traversed and executed step by step.
  • Each node in the tree performs its associated operation.
  • Variables, functions, and control structures are executed dynamically.

Execution Flow Example:

var x = 5;
print(x + 10);

Execution Steps:

  1. Declare x and assign 5
  2. Evaluate x + 10 (result = 15)
  3. Call print() with 15 as an argument
  4. Output: 15

6. Saving and Resuming Execution Stages

  • Any stage of the process can be saved and used to resume execution from that point.
  • This allows pre-parsing, AST caching, or loading an optimized representation for later execution.

Example:

  • Parse to AST, save AST, and execute later:
// Phase 1: Parse and save AST
var ast = compileToAST("print(5 + 5);");
saveToFile("program.ast", ast);

// Phase 2: Load AST and execute without re-parsing
var loadedAST = loadFromFile("program.ast");
interpretAST(loadedAST);

7. Planned Features for Execution Enhancements

Just-In-Time (JIT) Compilation (Planned Feature)

  • Instead of interpreting every time, frequently used code can be compiled at runtime for faster execution.

Bytecode Generation (Planned Feature)

  • Instead of executing the AST directly, M7 may introduce an intermediate bytecode representation to improve performance.

Multithreading Support (Planned Feature)

  • Future implementations may allow concurrent execution via lightweight threads or coroutines.

This document provides an in-depth look at the execution model of M7 Script, detailing the various stages from tokenization to execution and outlining planned enhancements for future versions.