feat: Add core VM implementation, LLVM backend, benchmarking infrastructure, and project license.

Author: ProgrammerKR

LICENSE

@@ -126,4 +126,4 @@ term sustainability of the ProX ecosystem.
 
 ────────────────────────────────────────────────────────
 END OF PROX PROFESSIONAL LICENSE (PPL)
-────────────────────────────────────────────────────────
+────────────────────────────────────────────────────────

benchmarks/run_benchmarks.py

@@ -12,18 +12,43 @@ def run_benchmark(executable, benchmark_file):
 
     cmd = [executable, benchmark_file]
     start = time.time()
-    try:
-        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-        end = time.time()
-        return end - start, result.stdout
-    except subprocess.CalledProcessError as e:
-        print(f"Error running {benchmark_file}: {e}")
-        print(f"Stdout: {e.stdout}")
-        print(f"Stderr: {e.stderr}")
-        return None, None
-    except Exception as e:
-        print(f"Execution failed: {e}")
-        return None, None
+    
+    # Use a temporary file for stdout/stderr to avoid MemoryError on huge output
+    import tempfile
+    
+    with tempfile.TemporaryFile() as out_tmp:
+        try:
+            # We don't use check=True so we can capture output even on failure
+            proc = subprocess.run(cmd, stdout=out_tmp, stderr=subprocess.STDOUT, timeout=60, text=False) # raw bytes
+            
+            end = time.time()
+            duration = end - start
+            
+            # Read output back (limit size)
+            out_tmp.seek(0)
+            # Read first 4KB and last 4KB if large? Or just read all and catch error?
+            # Let's read first 100KB which should be enough for any reasonable benchmark
+            # If it's huge, we truncate.
+            output_bytes = out_tmp.read(100 * 1024) 
+            if out_tmp.read(1): # check if there is more
+                 output_bytes += b"\n... [Output Truncated] ...\n"
+                 
+            output = output_bytes.decode('utf-8', errors='replace')
+            
+            if proc.returncode != 0:
+                print(f"Error running {benchmark_file}: Return Code {proc.returncode}")
+                # Print output snippet
+                print(f"Output:\n{output[-1000:]}") # Last 1000 chars
+                return None, None
+                
+            return duration, output
+
+        except subprocess.TimeoutExpired:
+            print(f"Benchmark {benchmark_file} timed out.")
+            return None, None
+        except Exception as e:
+             print(f"Execution failed: {e}")
+             return None, None
 
 def main():
     parser = argparse.ArgumentParser(description="Run ProXPL benchmarks.")

include/vm.h

@@ -12,7 +12,7 @@
 #include "table.h" 
 #include "importer.h"
 
-#define FRAMES_MAX 256
+#define FRAMES_MAX 1024
 #define STACK_MAX (FRAMES_MAX * 256)
 
 // CallFrame is now defined in common.h

src/compiler/backend_llvm.cpp

@@ -466,7 +466,7 @@ class LLVMEmitter {
         // Implement prox_rt_resume wrapper
         llvm::BasicBlock* Entry = llvm::BasicBlock::Create(*Context, "entry", FResume);
         llvm::IRBuilder<> ResBuilder(Entry);
-        llvm::Function* FCoroResume = llvm::Intrinsic::getOrInsertDeclaration(ModuleOb.get(), llvm::Intrinsic::coro_resume);
+        llvm::Function* FCoroResume = llvm::Intrinsic::getDeclaration(ModuleOb.get(), llvm::Intrinsic::coro_resume);
         // Note: getDeclaration is deprecated but for some LLVM versions getOrInsertDeclaration is for non-intrinsics?
         // Actually, for intrinsics, getDeclaration is still standard in many versions.
         // But the warning says use getOrInsertDeclaration? 

src/runtime/vm.c

@@ -74,6 +74,15 @@ void runtimeError(VM* pvm, const char* format, ...) {
 }
 
 void push(VM* pvm, Value value) {
+  if (pvm->stackTop >= pvm->stack + STACK_MAX) {
+      // Emergency stack reset or hard abort to prevent segfault
+      // Since we can't easily return error code from push, we set a flag or just abort.
+      // Ideally, push checks should be done before calling logic. 
+      // check frame overflow handles recursion. 
+      // check value stack overflow:
+      fprintf(stderr, "Fatal Runtime Error: Value stack overflow.\n");
+      exit(1); 
+  }
   *pvm->stackTop = value;
   pvm->stackTop++;
 }
@@ -449,7 +458,7 @@ static InterpretResult run(VM *vm) {
               runtimeError(vm, "Expected %d arguments but got %d.", closure->function->arity, argCount);
               return INTERPRET_RUNTIME_ERROR;
           }
-          if (vm->frameCount == 64) { // MAX_FRAMES
+          if (vm->frameCount == FRAMES_MAX) { // FRAMES_MAX
               runtimeError(vm, "Stack overflow.");
               return INTERPRET_RUNTIME_ERROR;
           }