From 343a533feaeb2784bb5720dd2d63b8ed6b9b4b51 Mon Sep 17 00:00:00 2001
From: theMackabu <theMackabu@gmail.com>
Date: Sun, 7 Dec 2025 15:18:02 -0800
Subject: [PATCH] for-of and -e

---
 meson.build      |   2 +-
 src/ant.c        | 134 ++++++++++++++++++++++++++++++++++++++-
 src/main.c       |  32 ++++++++--
 src/repl.c       |   2 +
 tests/for_of.cjs | 161 +++++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 325 insertions(+), 6 deletions(-)
 create mode 100644 tests/for_of.cjs

diff --git a/meson.build b/meson.build
index 7ba45eb..e4186c0 100644
--- a/meson.build
+++ b/meson.build
@@ -74,7 +74,7 @@ endif
 build_date = run_command('date', '+%Y-%m-%d', check: true).stdout().strip()
 
 version_conf = configuration_data()
-version_conf.set('ANT_VERSION', '0.0.7.22')
+version_conf.set('ANT_VERSION', '0.0.7.23')
 version_conf.set('ANT_GIT_HASH', git_hash)
 version_conf.set('ANT_BUILD_DATE', build_date)
 
diff --git a/src/ant.c b/src/ant.c
index 21386fb..434f0cd 100644
--- a/src/ant.c
+++ b/src/ant.c
@@ -234,7 +234,7 @@ enum {
   TOK_LPAREN, TOK_RPAREN, TOK_LBRACE, TOK_RBRACE, TOK_LBRACKET, TOK_RBRACKET,
   TOK_ASYNC = 50, TOK_AWAIT, TOK_BREAK, TOK_CASE, TOK_CATCH, TOK_CLASS, TOK_CONST, TOK_CONTINUE,
   TOK_DEFAULT, TOK_DELETE, TOK_DO, TOK_ELSE, TOK_EXPORT, TOK_FINALLY, TOK_FOR, TOK_FROM, TOK_FUNC,
-  TOK_IF, TOK_IMPORT, TOK_IN, TOK_INSTANCEOF, TOK_LET, TOK_NEW, TOK_RETURN, TOK_SWITCH,
+  TOK_IF, TOK_IMPORT, TOK_IN, TOK_INSTANCEOF, TOK_LET, TOK_NEW, TOK_OF, TOK_RETURN, TOK_SWITCH,
   TOK_THIS, TOK_THROW, TOK_TRY, TOK_VAR, TOK_VOID, TOK_WHILE, TOK_WITH,
   TOK_YIELD, TOK_UNDEF, TOK_NULL, TOK_TRUE, TOK_FALSE, TOK_AS, TOK_STATIC,
   TOK_DOT = 100, TOK_CALL, TOK_BRACKET, TOK_POSTINC, TOK_POSTDEC, TOK_NOT, TOK_TILDA,
@@ -1695,6 +1695,7 @@ static uint8_t parsekeyword(const char *buf, size_t len) {
     case 'i': if (streq("if", 2, buf, len)) return TOK_IF; if (streq("import", 6, buf, len)) return TOK_IMPORT; if (streq("in", 2, buf, len)) return TOK_IN; if (streq("instanceof", 10, buf, len)) return TOK_INSTANCEOF; break;
     case 'l': if (streq("let", 3, buf, len)) return TOK_LET; break;
     case 'n': if (streq("new", 3, buf, len)) return TOK_NEW; if (streq("null", 4, buf, len)) return TOK_NULL; break;
+    case 'o': if (streq("of", 2, buf, len)) return TOK_OF; break;
     case 'r': if (streq("return", 6, buf, len)) return TOK_RETURN; break;
     case 's': if (streq("switch", 6, buf, len)) return TOK_SWITCH; if (streq("static", 6, buf, len)) return TOK_STATIC; break;
     case 't': if (streq("try", 3, buf, len)) return TOK_TRY; if (streq("this", 4, buf, len)) return TOK_THIS; if (streq("throw", 5, buf, len)) return TOK_THROW; if (streq("true", 4, buf, len)) return TOK_TRUE; if (streq("typeof", 6, buf, len)) return TOK_TYPEOF; break;
@@ -4520,6 +4521,7 @@ static jsval_t js_for(struct js *js) {
   if (!expect(js, TOK_LPAREN, &res)) goto done;
   
   bool is_for_in = false;
+  bool is_for_of = false;
   jsoff_t var_name_off = 0, var_name_len = 0;
   bool is_const_var = false;
   
@@ -4539,6 +4541,9 @@ static jsval_t js_for(struct js *js) {
       if (next(js) == TOK_IN) {
         is_for_in = true;
         js->consumed = 1;
+      } else if (next(js) == TOK_OF) {
+        is_for_of = true;
+        js->consumed = 1;
       } else {
         js->pos = var_name_off;
         js->consumed = 1;
@@ -4557,6 +4562,9 @@ static jsval_t js_for(struct js *js) {
     if (next(js) == TOK_IN) {
       is_for_in = true;
       js->consumed = 1;
+    } else if (next(js) == TOK_OF) {
+      is_for_of = true;
+      js->consumed = 1;
     } else {
       js->pos = var_name_off;
       js->consumed = 1;
@@ -4636,6 +4644,130 @@ static jsval_t js_for(struct js *js) {
     goto done;
   }
   
+  if (is_for_of) {
+    jsval_t iter_expr = js_expr(js);
+    if (is_err2(&iter_expr, &res)) goto done;
+    if (!expect(js, TOK_RPAREN, &res)) goto done;
+    
+    jsoff_t body_start = js->pos;
+    js->flags |= F_NOEXEC;
+    v = js_block_or_stmt(js);
+    if (is_err2(&v, &res)) goto done;
+    jsoff_t body_end = js->pos;
+    
+    if (exe) {
+      jsval_t iterable = resolveprop(js, iter_expr);
+      uint8_t itype = vtype(iterable);
+      
+      if (itype == T_ARR) {
+        jsoff_t next_prop = loadoff(js, (jsoff_t) vdata(iterable)) & ~(3U | CONSTMASK);
+        jsoff_t length = 0;
+        jsoff_t scan = next_prop;
+        
+        while (scan < js->brk && scan != 0) {
+          jsoff_t koff = loadoff(js, scan + (jsoff_t) sizeof(scan));
+          jsoff_t klen = offtolen(loadoff(js, koff));
+          const char *key = (char *) &js->mem[koff + sizeof(koff)];
+          
+          if (streq(key, klen, "length", 6)) {
+            jsval_t val = loadval(js, scan + (jsoff_t) (sizeof(scan) + sizeof(koff)));
+            if (vtype(val) == T_NUM) length = (jsoff_t) tod(val);
+            break;
+          }
+          scan = loadoff(js, scan) & ~(3U | CONSTMASK);
+        }
+        
+        for (jsoff_t i = 0; i < length; i++) {
+          char idx[16];
+          snprintf(idx, sizeof(idx), "%u", (unsigned) i);
+          jsoff_t idxlen = (jsoff_t) strlen(idx);
+          jsoff_t prop = next_prop;
+          jsval_t val = js_mkundef();
+          
+          while (prop < js->brk && prop != 0) {
+            jsoff_t koff = loadoff(js, prop + (jsoff_t) sizeof(prop));
+            jsoff_t klen = offtolen(loadoff(js, koff));
+            const char *key = (char *) &js->mem[koff + sizeof(koff)];
+            if (streq(key, klen, idx, idxlen)) {
+              val = loadval(js, prop + (jsoff_t) (sizeof(prop) + sizeof(koff)));
+              break;
+            }
+            prop = loadoff(js, prop) & ~(3U | CONSTMASK);
+          }
+          
+          const char *var_name = &js->code[var_name_off];
+          jsoff_t existing = lkp(js, js->scope, var_name, var_name_len);
+          if (existing > 0) {
+            saveval(js, existing + sizeof(jsoff_t) * 2, val);
+          } else {
+            jsval_t x = mkprop(js, js->scope, js_mkstr(js, var_name, var_name_len), val, is_const_var);
+            if (is_err(x)) {
+              res = x;
+              goto done;
+            }
+          }
+          
+          js->pos = body_start;
+          js->consumed = 1;
+          js->flags = (flags & ~F_NOEXEC) | F_LOOP;
+          v = js_block_or_stmt(js);
+          if (is_err(v)) {
+            res = v;
+            goto done;
+          }
+          
+          if (js->flags & F_BREAK) break;
+          if (js->flags & F_RETURN) {
+            res = v;
+            goto done;
+          }
+        }
+      } else if (itype == T_STR) {
+        jsoff_t slen, soff = vstr(js, iterable, &slen);
+        const char *str = (char *) &js->mem[soff];
+        
+        for (jsoff_t i = 0; i < slen; i++) {
+          jsval_t char_str = js_mkstr(js, &str[i], 1);
+          
+          const char *var_name = &js->code[var_name_off];
+          jsoff_t existing = lkp(js, js->scope, var_name, var_name_len);
+          if (existing > 0) {
+            saveval(js, existing + sizeof(jsoff_t) * 2, char_str);
+          } else {
+            jsval_t x = mkprop(js, js->scope, js_mkstr(js, var_name, var_name_len), char_str, is_const_var);
+            if (is_err(x)) {
+              res = x;
+              goto done;
+            }
+          }
+          
+          js->pos = body_start;
+          js->consumed = 1;
+          js->flags = (flags & ~F_NOEXEC) | F_LOOP;
+          v = js_block_or_stmt(js);
+          if (is_err(v)) {
+            res = v;
+            goto done;
+          }
+          
+          if (js->flags & F_BREAK) break;
+          if (js->flags & F_RETURN) {
+            res = v;
+            goto done;
+          }
+        }
+      } else {
+        res = js_mkerr(js, "for-of requires iterable");
+        goto done;
+      }
+    }
+    
+    js->pos = body_end;
+    js->tok = TOK_SEMICOLON;
+    js->consumed = 0;
+    goto done;
+  }
+  
   if (!expect(js, TOK_SEMICOLON, &res)) goto done;
   js->flags |= F_NOEXEC;
   pos1 = js->pos;
diff --git a/src/main.c b/src/main.c
index 2d21472..0b6895f 100644
--- a/src/main.c
+++ b/src/main.c
@@ -25,6 +25,27 @@
 
 int js_result = EXIT_SUCCESS;
 
+static void eval_code(struct js *js, struct arg_str *eval, struct arg_lit *print) {
+  const char *script = eval->sval[0];
+  size_t len = strlen(script);
+  
+  js_set_filename(js, "<eval>");
+  js_mkscope(js);
+  js_protect_init_memory(js);
+  
+  jsval_t result = js_eval(js, script, len);
+  
+  if (js_type(result) == JS_ERR) {
+    fprintf(stderr, "%s\n", js_str(js, result));
+    js_result = EXIT_FAILURE;
+  } else if (print->count > 0) {
+    const char *str = js_str(js, result);
+    if (str && strcmp(str, "undefined") != 0) printf("%s\n", str);
+  }
+  
+  js_run_event_loop(js);
+}
+
 static int execute_module(struct js *js, const char *filename) {
   char *filename_copy = strdup(filename);
   char *dir = dirname(filename_copy);
@@ -76,13 +97,15 @@ int main(int argc, char *argv[]) {
   struct arg_lit *help = arg_lit0("h", "help", "display this help and exit");
   struct arg_lit *version = arg_lit0("v", "version", "display version information and exit");
   struct arg_lit *debug = arg_litn("d", "debug", 0, 10, "dump VM state (can be repeated for more detail)");
+  struct arg_str *eval = arg_str0("e", "eval", "<script>", "evaluate script");
+  struct arg_lit *print = arg_lit0("p", "print", "evaluate script and print result");
   struct arg_int *gct = arg_int0(NULL, "gct", "<threshold>", "set garbage collection threshold");
   struct arg_int *initial_mem = arg_int0(NULL, "initial-mem", "<size>", "initial memory size in MB (default: 4)");
   struct arg_int *max_mem = arg_int0(NULL, "max-mem", "<size>", "maximum memory size in MB (default: 512)");
   struct arg_file *file = arg_file0(NULL, NULL, "<module.js>", "JavaScript module file to execute");
   struct arg_end *end = arg_end(20);
   
-  void *argtable[] = {help, version, debug, gct, initial_mem, max_mem, file, end};
+  void *argtable[] = {help, version, debug, eval, print, gct, initial_mem, max_mem, file, end};
   int nerrors = arg_parse(argc, argv, argtable);
   
   if (help->count > 0) {
@@ -108,8 +131,8 @@ int main(int argc, char *argv[]) {
     return EXIT_FAILURE;
   }
   
-  bool repl_mode = (file->count == 0);
-  const char *module_file = repl_mode ? NULL : file->filename[0];
+  bool repl_mode = (file->count == 0 && eval->count == 0);
+  const char *module_file = repl_mode ? NULL : (file->count > 0 ? file->filename[0] : NULL);
   dump = debug->count;
   
   size_t initial_size = 4 * 1024 * 1024;
@@ -144,7 +167,8 @@ int main(int argc, char *argv[]) {
   ant_register_library("ant:path", path_library);
   ant_register_library("ant:ffi", ffi_library);
 
-  if (repl_mode) ant_repl_run(); else {
+  if (eval->count > 0) eval_code(js, eval, print);
+  else if (repl_mode) ant_repl_run(); else {
     js_result = execute_module(js, module_file);
     js_run_event_loop(js);
   }
diff --git a/src/repl.c b/src/repl.c
index fd341cb..b650447 100644
--- a/src/repl.c
+++ b/src/repl.c
@@ -191,6 +191,8 @@ static char* read_line_with_history(history_t *hist, struct js *js) {
 
 void ant_repl_run() {
   struct js *js = rt->js;
+  
+  js_mkscope(js);
   js_protect_init_memory(js);
   
   printf("Welcome to Ant JavaScript v%s\n", ANT_VERSION);
diff --git a/tests/for_of.cjs b/tests/for_of.cjs
new file mode 100644
index 0000000..b55f392
--- /dev/null
+++ b/tests/for_of.cjs
@@ -0,0 +1,161 @@
+// Test for-of loop functionality
+
+console.log("=== For-Of Loop Tests ===\n");
+
+// Test 1: Basic for-of with array
+console.log("Test 1: Basic for-of with array");
+const fruits = ["apple", "banana", "cherry"];
+let collected = [];
+for (const fruit of fruits) {
+  collected.push(fruit);
+}
+console.log("  Collected:", collected);
+
+// Test 2: for-of with Object.keys()
+console.log("\nTest 2: for-of with Object.keys()");
+const person = { name: "Alice", age: 30, city: "NYC" };
+let keys = [];
+for (const key of Object.keys(person)) {
+  keys.push(key);
+}
+console.log("  Keys:", keys);
+
+// Test 3: for-of with Object.keys() accessing values
+console.log("\nTest 3: for-of accessing object values");
+const scores = { math: 95, english: 88, science: 92 };
+let total = 0;
+for (const key of Object.keys(scores)) {
+  console.log("  " + key + ":", scores[key]);
+  total = total + scores[key];
+}
+console.log("  Total:", total);
+
+// Test 4: for-of with let (mutable variable)
+console.log("\nTest 4: for-of with let");
+const numbers = [1, 2, 3, 4, 5];
+let sum = 0;
+for (let num of numbers) {
+  num = num * 2;
+  sum = sum + num;
+}
+console.log("  Sum of doubled:", sum);
+
+// Test 5: for-of with string iteration
+console.log("\nTest 5: for-of with string");
+const str = "hello";
+let chars = [];
+for (const char of str) {
+  chars.push(char);
+}
+console.log("  Characters:", chars);
+
+// Test 6: Nested for-of loops
+console.log("\nTest 6: Nested for-of loops");
+const matrix = [[1, 2], [3, 4], [5, 6]];
+let flatSum = 0;
+for (const row of matrix) {
+  for (const val of row) {
+    flatSum = flatSum + val;
+  }
+}
+console.log("  Matrix sum:", flatSum);
+
+// Test 7: for-of with break
+console.log("\nTest 7: for-of with break");
+const items = [10, 20, 30, 40, 50];
+let breakSum = 0;
+for (const item of items) {
+  if (item > 25) {
+    console.log("  Breaking at:", item);
+    break;
+  }
+  breakSum = breakSum + item;
+}
+console.log("  Sum before break:", breakSum);
+
+// Test 8: for-of with continue
+console.log("\nTest 8: for-of with continue");
+const mixed = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let evenSum = 0;
+for (const n of mixed) {
+  if (n % 2 === 1) {
+    continue;
+  }
+  evenSum = evenSum + n;
+}
+console.log("  Sum of evens:", evenSum);
+
+// Test 9: for-of in function with return
+console.log("\nTest 9: for-of with return");
+function findValue(arr, target) {
+  for (const val of arr) {
+    if (val === target) {
+      return true;
+    }
+  }
+  return false;
+}
+console.log("  Contains 30:", findValue([10, 20, 30, 40], 30));
+console.log("  Contains 99:", findValue([10, 20, 30, 40], 99));
+
+// Test 10: for-of with empty array
+console.log("\nTest 10: for-of with empty array");
+const empty = [];
+let emptyCount = 0;
+for (const x of empty) {
+  emptyCount = emptyCount + 1;
+}
+console.log("  Iterations on empty:", emptyCount);
+
+// Test 11: for-of building new array
+console.log("\nTest 11: for-of building new array");
+const source = [1, 2, 3, 4, 5];
+const squared = [];
+for (const n of source) {
+  squared.push(n * n);
+}
+console.log("  Squared:", squared);
+
+// Test 12: for-of with complex objects in array
+console.log("\nTest 12: for-of with objects in array");
+const users = [
+  { id: 1, name: "Alice" },
+  { id: 2, name: "Bob" },
+  { id: 3, name: "Charlie" }
+];
+let names = [];
+for (const user of users) {
+  names.push(user.name);
+}
+console.log("  Names:", names);
+
+// Test 13: for-of with Object.keys() building result object
+console.log("\nTest 13: for-of building result object");
+const original = { a: 1, b: 2, c: 3 };
+const doubled = {};
+for (const key of Object.keys(original)) {
+  doubled[key] = original[key] * 2;
+}
+console.log("  Doubled object:", doubled);
+
+// Test 14: for-of scope isolation
+console.log("\nTest 14: for-of scope isolation");
+const vals = [100, 200, 300];
+const results = [];
+for (const v of vals) {
+  const computed = v / 10;
+  results.push(computed);
+}
+console.log("  Results:", results);
+
+// Test 15: Chained for-of operations
+console.log("\nTest 15: Chained for-of");
+const data = { x: 10, y: 20, z: 30 };
+const dataKeys = Object.keys(data);
+let product = 1;
+for (const k of dataKeys) {
+  product = product * data[k];
+}
+console.log("  Product of values:", product);
+
+console.log("\n=== All for-of tests completed ===");
-- 
2.51.2