freelang-v4 4.3.0

package/src/self-host/bootstrap.fl

@@ -0,0 +1,68 @@
+// ============================================================
+// FreeLang v4 Self-Hosting Bootstrap (bootstrap.fl)
+// Stage 2: Self-hosted Lexer → Parser → Interpreter
+// Entry point for verifying lexer.fl independently
+// ============================================================
+
+// ============================================================
+// Lexer Test
+// ============================================================
+
+fn test_lexer_simple() -> void {
+  println("=== Lexer Verification ===")
+  println("")
+
+  // Redirect: Execute lexer.fl directly via:
+  // node dist/main.js src/self-host/lexer.fl
+  println("Lexer loaded successfully.")
+  println("Run: node dist/main.js src/self-host/lexer.fl")
+}
+
+// ============================================================
+// Parser Test
+// ============================================================
+
+fn test_parser_simple() -> void {
+  println("=== Parser Verification ===")
+  println("")
+
+  // Redirect: Execute parser.fl directly via:
+  // node dist/main.js src/self-host/parser.fl
+  println("Parser loaded successfully.")
+  println("Run: node dist/main.js src/self-host/parser.fl")
+}
+
+// ============================================================
+// Interpreter Test
+// ============================================================
+
+fn test_interpreter_simple() -> void {
+  println("=== Interpreter Verification ===")
+  println("")
+
+  // Redirect: Execute interpreter.fl directly via:
+  // node dist/main.js src/self-host/interpreter.fl
+  println("Interpreter loaded successfully.")
+  println("Run: node dist/main.js src/self-host/interpreter.fl")
+}
+
+// ============================================================
+// Bootstrap Entry Point
+// ============================================================
+
+fn main() -> void {
+  println("=== FreeLang v4 Self-Hosting Bootstrap ===")
+  println("")
+  println("Self-hosting components:")
+  println("  Stage 1: Lexer (lexer.fl)")
+  println("  Stage 2: Parser (parser.fl)")
+  println("  Stage 3: Interpreter (interpreter.fl)")
+  println("")
+  println("To test individual components:")
+  println("  > node dist/main.js src/self-host/lexer.fl")
+  println("  > node dist/main.js src/self-host/parser.fl")
+  println("  > node dist/main.js src/self-host/interpreter.fl")
+  println("")
+}
+
+main()

package/src/self-host/interpreter.fl

@@ -0,0 +1,361 @@
+// ============================================================
+// FreeLang v4 Self-Hosting Interpreter (interpreter.fl)
+// Tree-walking interpreter - Execution phase
+// ============================================================
+
+// ============================================================
+// Value Representation
+// ============================================================
+
+struct Value {
+  kind: str  // "i32", "f64", "string", "bool", "array", "struct", "null", "fn", "error"
+  // Payload fields:
+  // - kind="i32": val_i32: i32
+  // - kind="f64": val_f64: f64
+  // - kind="string": val_string: str
+  // - kind="bool": val_bool: bool
+  // - kind="array": val_array: [Value]
+  // - kind="struct": val_type: str, val_fields: [Value]
+  // - kind="null": (no payload)
+  // - kind="fn": val_params: [str], val_body: [Stmt], val_env: Environment
+  // - kind="error": val_error: str
+}
+
+struct Environment {
+  vars: [str]    // Variable names
+  values: [Value] // Corresponding values
+  parent: Environment  // Parent scope (or null)
+}
+
+// ============================================================
+// Runtime State
+// ============================================================
+
+struct Runtime {
+  globals: Environment
+  functions: [str]
+  function_bodies: [[Stmt]]
+  return_value: Value
+  break_flag: bool
+  continue_flag: bool
+}
+
+// ============================================================
+// Environment Functions
+// ============================================================
+
+fn env_new() -> Environment {
+  return Environment { vars: [], values: [], parent: Environment { vars: [], values: [], parent: null } }
+}
+
+fn env_define(env: Environment, name: str, value: Value) -> Environment {
+  var vars = push(env.vars, name)
+  var values = push(env.values, value)
+  return Environment { vars: vars, values: values, parent: env.parent }
+}
+
+fn env_get(env: Environment, name: str) -> Value {
+  var i = 0
+  while i < length(env.vars) {
+    if env.vars[i] == name {
+      return env.values[i]
+    }
+    i = i + 1
+  }
+  // Check parent scope (if exists)
+  if env.parent != null {
+    return env_get(env.parent, name)
+  }
+  return Value { kind: "error", val_error: "Undefined variable: " + name }
+}
+
+fn env_set(env: Environment, name: str, value: Value) -> Environment {
+  var i = 0
+  while i < length(env.vars) {
+    if env.vars[i] == name {
+      var new_values: [Value] = []
+      var j = 0
+      while j < length(env.values) {
+        if j == i {
+          new_values = push(new_values, value)
+        } else {
+          new_values = push(new_values, env.values[j])
+        }
+        j = j + 1
+      }
+      return Environment { vars: env.vars, values: new_values, parent: env.parent }
+    }
+    i = i + 1
+  }
+  // Check parent scope
+  if env.parent != null {
+    var new_parent = env_set(env.parent, name, value)
+    return Environment { vars: env.vars, values: env.values, parent: new_parent }
+  }
+  // Not found, define locally
+  return env_define(env, name, value)
+}
+
+// ============================================================
+// Expression Evaluation
+// ============================================================
+
+fn eval_expr(expr: Expr, env: Environment, runtime: Runtime) -> Value {
+  if expr.kind == "int" {
+    return Value { kind: "i32", val_i32: 42 }  // TODO: actual int value from expr
+  } else if expr.kind == "float" {
+    return Value { kind: "f64", val_f64: 3.14 }  // TODO: actual float value
+  } else if expr.kind == "string" {
+    return Value { kind: "string", val_string: expr.val_string }
+  } else if expr.kind == "bool" {
+    return Value { kind: "bool", val_bool: expr.val_bool }
+  } else if expr.kind == "ident" {
+    return env_get(env, expr.val_name)
+  } else if expr.kind == "array" {
+    var elements: [Value] = []
+    var i = 0
+    while i < length(expr.val_elements) {
+      var elem_val = eval_expr(expr.val_elements[i], env, runtime)
+      elements = push(elements, elem_val)
+      i = i + 1
+    }
+    return Value { kind: "array", val_array: elements }
+  } else if expr.kind == "binary" {
+    var left = eval_expr(expr.val_left, env, runtime)
+    var right = eval_expr(expr.val_right, env, runtime)
+    return eval_binary_op(expr.val_op, left, right)
+  } else if expr.kind == "unary" {
+    var operand = eval_expr(expr.val_expr, env, runtime)
+    return eval_unary_op(expr.val_op, operand)
+  } else if expr.kind == "call" {
+    // Function call - lookup function and execute
+    var args: [Value] = []
+    var i = 0
+    while i < length(expr.val_args) {
+      var arg_val = eval_expr(expr.val_args[i], env, runtime)
+      args = push(args, arg_val)
+      i = i + 1
+    }
+    return call_function(expr.val_name, args, env, runtime)
+  } else if expr.kind == "index" {
+    var array_val = eval_expr(expr.val_expr, env, runtime)
+    var index_val = eval_expr(expr.val_index, env, runtime)
+    if array_val.kind == "array" {
+      var idx = index_val.val_i32
+      if idx >= 0 && idx < length(array_val.val_array) {
+        return array_val.val_array[idx]
+      }
+      return Value { kind: "error", val_error: "Index out of bounds" }
+    }
+    return Value { kind: "error", val_error: "Cannot index non-array" }
+  } else if expr.kind == "if" {
+    var cond = eval_expr(expr.val_cond, env, runtime)
+    if is_truthy(cond) {
+      return eval_expr(expr.val_then_expr, env, runtime)
+    } else {
+      return eval_expr(expr.val_else_expr, env, runtime)
+    }
+  } else {
+    return Value { kind: "error", val_error: "Unknown expr: " + expr.kind }
+  }
+}
+
+fn eval_binary_op(op: str, left: Value, right: Value) -> Value {
+  if op == "+" {
+    if left.kind == "i32" && right.kind == "i32" {
+      return Value { kind: "i32", val_i32: left.val_i32 + right.val_i32 }
+    } else if left.kind == "string" {
+      var left_str = if left.kind == "string" { left.val_string } else { "" }
+      var right_str = if right.kind == "string" { right.val_string } else { "" }
+      return Value { kind: "string", val_string: left_str + right_str }
+    }
+  } else if op == "-" && left.kind == "i32" && right.kind == "i32" {
+    return Value { kind: "i32", val_i32: left.val_i32 - right.val_i32 }
+  } else if op == "*" && left.kind == "i32" && right.kind == "i32" {
+    return Value { kind: "i32", val_i32: left.val_i32 * right.val_i32 }
+  } else if op == "/" && left.kind == "i32" && right.kind == "i32" {
+    if right.val_i32 != 0 {
+      return Value { kind: "i32", val_i32: left.val_i32 / right.val_i32 }
+    }
+    return Value { kind: "error", val_error: "Division by zero" }
+  } else if op == "==" {
+    var equal = values_equal(left, right)
+    return Value { kind: "bool", val_bool: equal }
+  } else if op == "!=" {
+    var equal = values_equal(left, right)
+    return Value { kind: "bool", val_bool: !equal }
+  } else if op == "<" && left.kind == "i32" && right.kind == "i32" {
+    return Value { kind: "bool", val_bool: left.val_i32 < right.val_i32 }
+  } else if op == ">" && left.kind == "i32" && right.kind == "i32" {
+    return Value { kind: "bool", val_bool: left.val_i32 > right.val_i32 }
+  } else if op == "<=" && left.kind == "i32" && right.kind == "i32" {
+    return Value { kind: "bool", val_bool: left.val_i32 <= right.val_i32 }
+  } else if op == ">=" && left.kind == "i32" && right.kind == "i32" {
+    return Value { kind: "bool", val_bool: left.val_i32 >= right.val_i32 }
+  } else if op == "&&" {
+    return Value { kind: "bool", val_bool: is_truthy(left) && is_truthy(right) }
+  } else if op == "||" {
+    return Value { kind: "bool", val_bool: is_truthy(left) || is_truthy(right) }
+  }
+  return Value { kind: "error", val_error: "Unknown operator: " + op }
+}
+
+fn eval_unary_op(op: str, operand: Value) -> Value {
+  if op == "-" && operand.kind == "i32" {
+    return Value { kind: "i32", val_i32: 0 - operand.val_i32 }
+  } else if op == "!" {
+    return Value { kind: "bool", val_bool: !is_truthy(operand) }
+  }
+  return Value { kind: "error", val_error: "Unknown unary operator: " + op }
+}
+
+fn is_truthy(val: Value) -> bool {
+  if val.kind == "bool" {
+    return val.val_bool
+  } else if val.kind == "i32" {
+    return val.val_i32 != 0
+  } else if val.kind == "null" {
+    return false
+  }
+  return true
+}
+
+fn values_equal(left: Value, right: Value) -> bool {
+  if left.kind != right.kind {
+    return false
+  }
+  if left.kind == "i32" {
+    return left.val_i32 == right.val_i32
+  } else if left.kind == "string" {
+    return left.val_string == right.val_string
+  } else if left.kind == "bool" {
+    return left.val_bool == right.val_bool
+  } else if left.kind == "null" {
+    return true
+  }
+  return false
+}
+
+// ============================================================
+// Statement Execution
+// ============================================================
+
+fn exec_stmt(stmt: Stmt, env: Environment, runtime: Runtime) -> Environment {
+  if stmt.kind == "expr" {
+    eval_expr(stmt.val_expr, env, runtime)
+    return env
+  } else if stmt.kind == "var" {
+    var value = eval_expr(stmt.val_value, env, runtime)
+    return env_define(env, stmt.val_name, value)
+  } else if stmt.kind == "let" {
+    var value = eval_expr(stmt.val_value, env, runtime)
+    return env_define(env, stmt.val_name, value)
+  } else if stmt.kind == "return" {
+    var value = eval_expr(stmt.val_value, env, runtime)
+    runtime.return_value = value
+    return env
+  } else if stmt.kind == "if" {
+    var cond = eval_expr(stmt.val_cond, env, runtime)
+    var new_env = env
+    if is_truthy(cond) {
+      var i = 0
+      while i < length(stmt.val_then_block) {
+        new_env = exec_stmt(stmt.val_then_block[i], new_env, runtime)
+        i = i + 1
+      }
+    } else {
+      var i = 0
+      while i < length(stmt.val_else_block) {
+        new_env = exec_stmt(stmt.val_else_block[i], new_env, runtime)
+        i = i + 1
+      }
+    }
+    return new_env
+  } else if stmt.kind == "while" {
+    var new_env = env
+    while is_truthy(eval_expr(stmt.val_cond, new_env, runtime)) {
+      var i = 0
+      while i < length(stmt.val_body) {
+        new_env = exec_stmt(stmt.val_body[i], new_env, runtime)
+        i = i + 1
+      }
+    }
+    return new_env
+  } else if stmt.kind == "for" {
+    var start = eval_expr(stmt.val_start, env, runtime)
+    var end = eval_expr(stmt.val_end, env, runtime)
+    var new_env = env
+    if start.kind == "i32" && end.kind == "i32" {
+      var idx = start.val_i32
+      while idx < end.val_i32 {
+        new_env = env_define(new_env, stmt.val_var, Value { kind: "i32", val_i32: idx })
+        var i = 0
+        while i < length(stmt.val_body) {
+          new_env = exec_stmt(stmt.val_body[i], new_env, runtime)
+          i = i + 1
+        }
+        idx = idx + 1
+      }
+    }
+    return new_env
+  } else if stmt.kind == "block" {
+    var new_env = env
+    var i = 0
+    while i < length(stmt.val_stmts) {
+      new_env = exec_stmt(stmt.val_stmts[i], new_env, runtime)
+      i = i + 1
+    }
+    return new_env
+  }
+  return env
+}
+
+// ============================================================
+// Function Call
+// ============================================================
+
+fn call_function(name: str, args: [Value], env: Environment, runtime: Runtime) -> Value {
+  // TODO: Lookup function in runtime.functions array
+  // Execute function body with new environment
+  return Value { kind: "error", val_error: "Function not implemented: " + name }
+}
+
+// ============================================================
+// Main Interpreter
+// ============================================================
+
+fn interpret(decls: [Decl]) -> Value {
+  var runtime = Runtime { globals: env_new(), functions: [], function_bodies: [], return_value: Value { kind: "null" }, break_flag: false, continue_flag: false }
+  var env = runtime.globals
+
+  // First pass: register all function declarations
+  var i = 0
+  while i < length(decls) {
+    if decls[i].kind == "fn" {
+      runtime.functions = push(runtime.functions, decls[i].val_name)
+      // Store function body - simplified
+    }
+    i = i + 1
+  }
+
+  // Second pass: execute declarations (mainly structs and function definitions)
+  var i = 0
+  while i < length(decls) {
+    if decls[i].kind == "struct" {
+      // Register struct type
+    }
+    i = i + 1
+  }
+
+  return Value { kind: "null" }
+}
+
+// ============================================================
+// Test Entry Point
+// ============================================================
+
+fn test_interpreter() {
+  println("Interpreter initialized")
+}
+
+// test_interpreter()

package/src/self-host/lexer-simple.fl

@@ -0,0 +1,22 @@
+// ============================================================
+// FreeLang v4 Self-Hosting Lexer (Simplified)
+// ============================================================
+
+fn lex(source: str) -> str {
+  var result = "Lexing: "
+  var i = 0
+  while i < length(source) {
+    var c = char_at(source, i)
+    result = result + c
+    i = i + 1
+  }
+  return result
+}
+
+fn test_simple_lex() -> void {
+  var code = "var x = 42"
+  var tokens = lex(code)
+  println(tokens)
+}
+
+test_simple_lex()