Fix build errors: resolve VM pointer/struct mismatch and duplicate case in vm.c; perform general cleanup

ProgrammerKR · ProgrammerKR · commit ab3337849df0 · 2026-03-19T11:14:31.000+05:30
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.15)
-project(ProXPL VERSION 1.2.0 LANGUAGES C CXX)
+project(ProXPL VERSION 1.3.0 LANGUAGES C CXX)
 
 # Enable C and C++
 enable_language(C CXX)
@@ -9,11 +9,25 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if (MSVC)
-  add_compile_options(/W4 /wd4244 /wd4245 /wd4267 /wd4100)
+  add_compile_options(/W4 /wd4244 /wd4245 /wd4267 /wd4100 /wd4200)
+  add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE)
 else()
   add_compile_options(-Wall -Wextra -Wno-sign-compare -Wno-unused-variable -Wno-unused-parameter)
 endif()
 
+# --- Build Configuration ---
+option(PROX_STATIC_BUILD "Build as a single static executable" ON)
+
+if(PROX_STATIC_BUILD)
+    add_definitions(-DPROX_STATIC)
+    if(MSVC)
+        # Set dynamic/static CRT for the whole project before targets are added
+        set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+        # Also add flags for older CMake versions or explicit control
+        add_compile_options($<$<CONFIG:Release>:/MT> $<$<CONFIG:Debug>:/MTd>)
+    endif()
+endif()
+
 # --- LLVM Configuration ---
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules")
 
@@ -183,9 +197,6 @@ list(REMOVE_ITEM LIB_SOURCES
     "${CMAKE_CURRENT_SOURCE_DIR}/src/instr_handlers_template.c"
 )
 
-# --- Build Configuration ---
-option(PROX_STATIC_BUILD "Build as a single static executable" ON)
-
 # Define the core library that all tools link against
 add_library(prox_core STATIC ${LIB_SOURCES})
 target_include_directories(prox_core PUBLIC include src)
@@ -201,14 +212,6 @@ if (LIBFFI_FOUND)
     target_link_libraries(prox_core PUBLIC ${LIBFFI_LIBRARIES})
 endif()
 
-if(PROX_STATIC_BUILD)
-    add_definitions(-DPROX_STATIC)
-    if(MSVC)
-        set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-        add_compile_options($<$<CONFIG:Release>:/MT> $<$<CONFIG:Debug>:/MTd>)
-    endif()
-endif()
-
 # Main executable
 add_executable(proxpl src/main.c)
 target_link_libraries(proxpl PRIVATE prox_core)
diff --git a/src/compiler/ir_opt.c b/src/compiler/ir_opt.c
@@ -205,7 +205,7 @@ void constantFold(IRFunction* func) {
             } else if (instr->opcode == IR_OP_ADD || instr->opcode == IR_OP_SUB || 
                        instr->opcode == IR_OP_MUL || instr->opcode == IR_OP_DIV) {
                 
-                Value left, right;
+                Value left = NIL_VAL, right = NIL_VAL;
                 bool c1 = false, c2 = false;
 
                 if (instr->operands[0].type == OPERAND_CONST) {
@@ -225,7 +225,7 @@ void constantFold(IRFunction* func) {
                 }
 
                 if (c1 && c2) {
-                    Value v_result;
+                    Value v_result = NIL_VAL;
                     bool folded = false;
                     if (IS_NUMBER(left) && IS_NUMBER(right)) {
                         double l = AS_NUMBER(left);
diff --git a/src/compiler/type_checker.c b/src/compiler/type_checker.c
@@ -377,7 +377,7 @@ static TypeInfo checkExpr(TypeChecker* checker, Expr* expr) {
 
         case EXPR_INDEX: {
             // Array/Matrix indexing returns tainted values (IFC)
-            TypeInfo target = checkExpr(checker, expr->as.index.target);
+            checkExpr(checker, expr->as.index.target);
             TypeInfo index = checkExpr(checker, expr->as.index.index);
             
             // Index should be numeric
diff --git a/src/proxpl_api.c b/src/proxpl_api.c
@@ -49,30 +49,30 @@ static char* readFile(const char* path) {
     return buffer;
 }
 
-void proxpl_vm_init(VM *vm) {
+void proxpl_vm_init(VM *pvm) {
     // Standard CLOX uses a global VM instance, so we ignore the pointer for now
     // or assume 'vm' points to the global one.
-    initVM(vm); 
+    initVM(pvm); 
 }
 
-void proxpl_vm_free(VM *vm) {
-    freeVM(vm);
+void proxpl_vm_free(VM *pvm) {
+    freeVM(pvm);
 }
 
-InterpretResult proxpl_interpret_chunk(VM *vm, const Chunk *chunk) {
-    (void)vm; (void)chunk;
+InterpretResult proxpl_interpret_chunk(VM *pvm, const Chunk *chunk) {
+    (void)pvm; (void)chunk;
     // ERROR: The standard VM interprets Source Code strings, not raw Chunks.
     // To support this, you would need to expose the internal run() function.
     fprintf(stderr, "API Error: interpreting raw chunks is not supported in this version.\n");
     return INTERPRET_RUNTIME_ERROR;
 }
 
-InterpretResult proxpl_interpret_file(VM *vm, const char *path) {
+InterpretResult proxpl_interpret_file(VM *pvm, const char *path) {
     char* source = readFile(path);
     if (source == NULL) return INTERPRET_COMPILE_ERROR;
 
     // Pass the source string to interpret
-    InterpretResult result = interpret(vm, source);
+    InterpretResult result = interpret(pvm, source);
     
     free(source);
     return result;
diff --git a/src/runtime/gc.c b/src/runtime/gc.c
@@ -77,12 +77,12 @@ static void reset_nursery() {
 // Access the global VM instance
 extern VM vm;
 
-void initGC(VM* vm) {
-    vm->grayCount = 0;
-    vm->grayCapacity = 0;
-    vm->grayStack = NULL;
-    vm->bytesAllocated = 0;
-    vm->nextGC = 1024 * 1024;
+void initGC(VM* pvm) {
+    pvm->grayCount = 0;
+    pvm->grayCapacity = 0;
+    pvm->grayStack = NULL;
+    pvm->bytesAllocated = 0;
+    pvm->nextGC = 1024 * 1024;
     
     initNursery();
 }
diff --git a/src/runtime/vm.c b/src/runtime/vm.c
@@ -72,14 +72,14 @@ void runtimeError(VM* pvm, const char* format, ...) {
   reportRuntimeError(pvm->source, line, message);
 
   for (int i = pvm->frameCount - 1; i >= 0; i--) {
-    CallFrame* frame = &pvm->frames[i];
-    ObjFunction* function = frame->closure->function;
-    size_t instruction = frame->ip - function->chunk.code - 1;
-    fprintf(stderr, "  [line %d] in ", function->chunk.lines[instruction]);
-    if (function->name == NULL) {
+    CallFrame* f = &pvm->frames[i];
+    ObjFunction* fn = f->closure->function;
+    size_t inst = f->ip - fn->chunk.code - 1;
+    fprintf(stderr, "  [line %d] in ", fn->chunk.lines[inst]);
+    if (fn->name == NULL) {
       fprintf(stderr, "script\n");
     } else {
-      fprintf(stderr, "%s()\n", function->name->chars);
+      fprintf(stderr, "%s()\n", fn->name->chars);
     }
   }
 
@@ -113,9 +113,9 @@ bool isFalsey(Value value) {
   return IS_NULL(value) || (IS_BOOL(value) && !AS_BOOL(value));
 }
 
-static bool performTensorArithmetic(VM* vm, char op) {
-    Value bVal = peek(vm, 0);
-    Value aVal = peek(vm, 1);
+static bool performTensorArithmetic(VM* pvm, char op) {
+    Value bVal = peek(pvm, 0);
+    Value aVal = peek(pvm, 1);
     
     // Case 1: Tensor op Tensor
     if (IS_TENSOR(aVal) && IS_TENSOR(bVal)) {
@@ -124,23 +124,23 @@ static bool performTensorArithmetic(VM* vm, char op) {
         
         // Element-wise arithmetic requires matching size
         if (a->size != b->size) {
-            runtimeError(vm, "Tensor size mismatch: %d vs %d.", a->size, b->size);
+            runtimeError(pvm, "Tensor size mismatch: %d vs %d.", a->size, b->size);
             return true;
         }
         
         if (a->dimCount != b->dimCount) {
-             runtimeError(vm, "Tensor rank mismatch.");
+             runtimeError(pvm, "Tensor rank mismatch.");
              return true;
         }
         for (int i=0; i<a->dimCount; i++) {
              if (a->dims[i] != b->dims[i]) {
-                 runtimeError(vm, "Tensor dimension mismatch at axis %d: %d vs %d.", i, a->dims[i], b->dims[i]);
+                 runtimeError(pvm, "Tensor dimension mismatch at axis %d: %d vs %d.", i, a->dims[i], b->dims[i]);
                  return true;
              }
         }
         
         ObjTensor* res = newTensor(a->dimCount, a->dims, NULL);
-        push(vm, OBJ_VAL(res)); 
+        push(pvm, OBJ_VAL(res)); 
         
         for (int i = 0; i < a->size; i++) {
             double vA = a->data[i];
@@ -153,10 +153,10 @@ static bool performTensorArithmetic(VM* vm, char op) {
             }
         }
         
-        Value resVal = pop(vm);
-        pop(vm); // b
-        pop(vm); // a
-        push(vm, resVal);
+        Value resVal = pop(pvm);
+        pop(pvm); // b
+        pop(pvm); // a
+        push(pvm, resVal);
         return true;
     }
     
@@ -166,7 +166,7 @@ static bool performTensorArithmetic(VM* vm, char op) {
         double b = AS_NUMBER(bVal);
         
         ObjTensor* res = newTensor(a->dimCount, a->dims, NULL);
-        push(vm, OBJ_VAL(res));
+        push(pvm, OBJ_VAL(res));
         
         for (int i = 0; i < a->size; i++) {
             double vA = a->data[i];
@@ -177,8 +177,8 @@ static bool performTensorArithmetic(VM* vm, char op) {
                 case '/': res->data[i] = vA / b; break;
             }
         }
-        Value resVal = pop(vm);
-        pop(vm); pop(vm); push(vm, resVal);
+        Value resVal = pop(pvm);
+        pop(pvm); pop(pvm); push(pvm, resVal);
         return true;
     }
     
@@ -188,7 +188,7 @@ static bool performTensorArithmetic(VM* vm, char op) {
         ObjTensor* b = AS_TENSOR(bVal);
         
         ObjTensor* res = newTensor(b->dimCount, b->dims, NULL);
-        push(vm, OBJ_VAL(res));
+        push(pvm, OBJ_VAL(res));
         
         for (int i = 0; i < b->size; i++) {
             double vB = b->data[i];
@@ -199,8 +199,8 @@ static bool performTensorArithmetic(VM* vm, char op) {
                 case '/': res->data[i] = a / vB; break;
             }
         }
-        Value resVal = pop(vm);
-        pop(vm); pop(vm); push(vm, resVal);
+        Value resVal = pop(pvm);
+        pop(pvm); pop(pvm); push(pvm, resVal);
         return true;
     }
 
@@ -1730,7 +1730,7 @@ static InterpretResult run(VM* vm) {
         ObjTensor *tensor = newTensor(dimCount, dims, NULL);
         if (elementCount == 0 && totalSize > 0) {
              memset(tensor->data, 0, totalSize * sizeof(double));
-        } else if (elementCount == totalSize) {
+        } else if (elementCount == (uint32_t)totalSize) {
             // Pop elements (reverse order as they were pushed in order, stack top is last)
             for (int i = totalSize - 1; i >= 0; i--) {
                 Value val = pop(vm);
diff --git a/src/stdlib/stdlib_core.c b/src/stdlib/stdlib_core.c
diff --git a/src/vm/vm_core_opt.c b/src/vm/vm_core_opt.c
diff --git a/src/vm/vm_dispatch.c b/src/vm/vm_dispatch.c
