Refactor UI import to std.ui and fix CI build failure (create_empty_module and shadowing warnings)

Author: ProgrammerKR

src/runtime/vm_helpers.c

@@ -16,19 +16,19 @@
 #include "../include/compiler.h"
 
 
-void closeUpvalues(VM *vm, Value *last) {
-  while (vm->openUpvalues != NULL &&
-         vm->openUpvalues->location >= last) {
-    ObjUpvalue *upvalue = vm->openUpvalues;
+void closeUpvalues(VM *pVM, Value *last) {
+  while (pVM->openUpvalues != NULL &&
+         pVM->openUpvalues->location >= last) {
+    ObjUpvalue *upvalue = pVM->openUpvalues;
     upvalue->closed = *upvalue->location;
     upvalue->location = &upvalue->closed;
-    vm->openUpvalues = upvalue->next;
+    pVM->openUpvalues = upvalue->next;
   }
 }
 
-ObjUpvalue *captureUpvalue(Value *local, VM *vm) {
+ObjUpvalue *captureUpvalue(Value *local, VM *pVM) {
   ObjUpvalue *prevUpvalue = NULL;
-  ObjUpvalue *upvalue = vm->openUpvalues;
+  ObjUpvalue *upvalue = pVM->openUpvalues;
   while (upvalue != NULL && upvalue->location > local) {
     prevUpvalue = upvalue;
     upvalue = upvalue->next;
@@ -42,120 +42,120 @@ ObjUpvalue *captureUpvalue(Value *local, VM *vm) {
   createdUpvalue->next = upvalue;
 
   if (prevUpvalue == NULL) {
-    vm->openUpvalues = createdUpvalue;
+    pVM->openUpvalues = createdUpvalue;
   } else {
     prevUpvalue->next = createdUpvalue;
   }
 
   return createdUpvalue;
 }
 
-void defineMethod(ObjString *name, VM *vm) {
-  Value method = peek(vm, 0);
-  ObjClass *klass = AS_CLASS(peek(vm, 1));
+void defineMethod(ObjString *name, VM *pVM) {
+  Value method = peek(pVM, 0);
+  ObjClass *klass = AS_CLASS(peek(pVM, 1));
   if (IS_CLOSURE(method)) {
       AS_CLOSURE(method)->function->ownerClass = klass;
   }
   tableSet(&klass->methods, name, method);
-  pop(vm);
+  pop(pVM);
 }
 
-bool bindMethod(struct ObjClass *klass, ObjString *name, VM *vm) {
+bool bindMethod(struct ObjClass *klass, ObjString *name, VM *pVM) {
   Value method;
   if (!tableGet(&klass->methods, name, &method)) {
-    runtimeError(vm, "Undefined property '%s'.", name->chars);
+    runtimeError(pVM, "Undefined property '%s'.", name->chars);
     return false;
   }
 
-  ObjBoundMethod *bound = newBoundMethod(peek(vm, 0), AS_CLOSURE(method));
-  pop(vm);
-  push(vm, OBJ_VAL(bound));
+  ObjBoundMethod *bound = newBoundMethod(peek(pVM, 0), AS_CLOSURE(method));
+  pop(pVM);
+  push(pVM, OBJ_VAL(bound));
   return true;
 }
 
-bool call(ObjClosure *closure, int argCount, VM *vm) {
+bool call(ObjClosure *closure, int argCount, VM *pVM) {
   if (argCount != closure->function->arity) {
-    runtimeError(vm, "Expected %d arguments but got %d.",
+    runtimeError(pVM, "Expected %d arguments but got %d.",
                  closure->function->arity, argCount);
     return false;
   }
 
-  if (vm->frameCount == FRAMES_MAX) {
-    runtimeError(vm, "Stack overflow.");
+  if (pVM->frameCount == FRAMES_MAX) {
+    runtimeError(pVM, "Stack overflow.");
     return false;
   }
 
-  CallFrame *frame = &vm->frames[vm->frameCount++];
+  CallFrame *frame = &pVM->frames[pVM->frameCount++];
   frame->closure = closure;
   frame->ip = closure->function->chunk.code;
-  frame->slots = vm->stackTop - argCount - 1;
+  frame->slots = pVM->stackTop - argCount - 1;
   return true;
 }
 
-bool callValue(Value callee, int argCount, VM *vm) {
+bool callValue(Value callee, int argCount, VM *pVM) {
   if (IS_OBJ(callee)) {
     switch (OBJ_TYPE(callee)) {
     case OBJ_BOUND_METHOD: {
       ObjBoundMethod *bound = AS_BOUND_METHOD(callee);
-      vm->stackTop[-argCount - 1] = bound->receiver;
-      return call(bound->method, argCount, vm);
+      pVM->stackTop[-argCount - 1] = bound->receiver;
+      return call(bound->method, argCount, pVM);
     }
     case OBJ_CLASS: {
       ObjClass *klass = AS_CLASS(callee);
-      vm->stackTop[-argCount - 1] = OBJ_VAL(newInstance(klass));
+      pVM->stackTop[-argCount - 1] = OBJ_VAL(newInstance(klass));
       Value initializer;
-      if (tableGet(&klass->methods, vm->initString, &initializer)) {
-        return call(AS_CLOSURE(initializer), argCount, vm);
+      if (tableGet(&klass->methods, pVM->initString, &initializer)) {
+        return call(AS_CLOSURE(initializer), argCount, pVM);
       } else if (argCount != 0) {
-        runtimeError(vm, "Expected 0 arguments but got %d.", argCount);
+        runtimeError(pVM, "Expected 0 arguments but got %d.", argCount);
         return false;
       }
       return true;
     }
     case OBJ_CLOSURE:
-      return call(AS_CLOSURE(callee), argCount, vm);
+      return call(AS_CLOSURE(callee), argCount, pVM);
     case OBJ_NATIVE: {
       NativeFn native = AS_NATIVE(callee);
-      Value result = native(argCount, vm->stackTop - argCount);
-      vm->stackTop -= argCount + 1;
-      push(vm, result);
+      Value result = native(argCount, pVM->stackTop - argCount);
+      pVM->stackTop -= argCount + 1;
+      push(pVM, result);
       return true;
     }
     default:
       break; // Non-callable object type
     }
   }
-  runtimeError(vm, "Can only call functions and classes.");
+  runtimeError(pVM, "Can only call functions and classes.");
   return false;
 }
 
 bool invokeFromClass(struct ObjClass *klass, ObjString *name,
-                            int argCount, VM *vm) {
+                            int argCount, VM *pVM) {
   Value method;
   if (!tableGet(&klass->methods, name, &method)) {
-    runtimeError(vm, "Undefined property '%s'.", name->chars);
+    runtimeError(pVM, "Undefined property '%s'.", name->chars);
     return false;
   }
-  return call(AS_CLOSURE(method), argCount, vm);
+  return call(AS_CLOSURE(method), argCount, pVM);
 }
 
-bool invoke(ObjString *name, int argCount, VM *vm) {
-  Value receiver = peek(vm, argCount);
+bool invoke(ObjString *name, int argCount, VM *pVM) {
+  Value receiver = peek(pVM, argCount);
 
   if (!IS_INSTANCE(receiver)) {
-    runtimeError(vm, "Only instances have methods.");
+    runtimeError(pVM, "Only instances have methods.");
     return false;
   }
 
   struct ObjInstance *instance = AS_INSTANCE(receiver);
 
   Value value;
   if (tableGet(&instance->fields, name, &value)) {
-    vm->stackTop[-argCount - 1] = value;
-    return callValue(value, argCount, vm);
+    pVM->stackTop[-argCount - 1] = value;
+    return callValue(value, argCount, pVM);
   }
 
-  return invokeFromClass(instance->klass, name, argCount, vm);
+  return invokeFromClass(instance->klass, name, argCount, pVM);
 }
 
 void appendToList(ObjList* list, Value value) {

src/stdlib/convert_native.c

@@ -158,14 +158,14 @@ static Value native_char_at(int argCount, Value* args) {
 // len(value) moved to stdlib_core.c
 
 // Register all conversion functions with the VM
-void register_convert_natives(VM* vm) {
-    defineNative(vm, "to_int", native_to_int);
-    defineNative(vm, "to_float", native_to_float);
-    defineNative(vm, "to_string", native_to_string);
-    defineNative(vm, "to_bool", native_to_bool);
-    defineNative(vm, "to_hex", native_to_hex);
-    defineNative(vm, "to_bin", native_to_bin);
-    defineNative(vm, "char_at", native_char_at);
-    // defineNative(vm, "len", native_len); // Moved to stdlib_core.c
+void register_convert_natives(VM* pVM) {
+    defineNative(pVM, "to_int", native_to_int);
+    defineNative(pVM, "to_float", native_to_float);
+    defineNative(pVM, "to_string", native_to_string);
+    defineNative(pVM, "to_bool", native_to_bool);
+    defineNative(pVM, "to_hex", native_to_hex);
+    defineNative(pVM, "to_bin", native_to_bin);
+    defineNative(pVM, "char_at", native_char_at);
+    // defineNative(pVM, "len", native_len); // Moved to stdlib_core.c
 }
 

src/stdlib/io_native.c

@@ -149,8 +149,8 @@ ObjModule* create_std_io_module() {
 }
 
 // Register I/O functions as globals (for convenience)
-void register_io_globals(VM* vm) {
-    defineNative(vm, "print", native_print_raw);
-    defineNative(vm, "println", native_println);
-    defineNative(vm, "input", native_input);
+void register_io_globals(VM* pVM) {
+    defineNative(pVM, "print", native_print_raw);
+    defineNative(pVM, "println", native_println);
+    defineNative(pVM, "input", native_input);
 }

src/stdlib/math_native.c

@@ -384,28 +384,28 @@ ObjModule* create_std_math_module() {
 }
 
 // Register math functions as globals (for benchmarks/ease of use)
-void register_math_globals(VM* vm) {
-    defineNative(vm, "abs", native_abs);
-    defineNative(vm, "ceil", native_ceil);
-    defineNative(vm, "floor", native_floor);
-    defineNative(vm, "round", native_round);
-    defineNative(vm, "max", native_max);
-    defineNative(vm, "min", native_min);
-    defineNative(vm, "pow", native_pow);
-    defineNative(vm, "sqrt", native_sqrt);
-    defineNative(vm, "sin", native_sin);
-    defineNative(vm, "cos", native_cos);
-    defineNative(vm, "tan", native_tan);
-    defineNative(vm, "asin", native_asin);
-    defineNative(vm, "acos", native_acos);
-    defineNative(vm, "atan", native_atan);
-    defineNative(vm, "log", native_log);
-    defineNative(vm, "exp", native_exp);
-    defineNative(vm, "random", native_random);
-    defineNative(vm, "randint", native_randint);
-    defineNative(vm, "seed", native_seed);
-    defineNative(vm, "sigmoid", native_sigmoid);
-    defineNative(vm, "relu", native_relu);
-    defineNative(vm, "tanh", native_tanh);
-    defineNative(vm, "transpose", native_transpose);
+void register_math_globals(VM* pVM) {
+    defineNative(pVM, "abs", native_abs);
+    defineNative(pVM, "ceil", native_ceil);
+    defineNative(pVM, "floor", native_floor);
+    defineNative(pVM, "round", native_round);
+    defineNative(pVM, "max", native_max);
+    defineNative(pVM, "min", native_min);
+    defineNative(pVM, "pow", native_pow);
+    defineNative(pVM, "sqrt", native_sqrt);
+    defineNative(pVM, "sin", native_sin);
+    defineNative(pVM, "cos", native_cos);
+    defineNative(pVM, "tan", native_tan);
+    defineNative(pVM, "asin", native_asin);
+    defineNative(pVM, "acos", native_acos);
+    defineNative(pVM, "atan", native_atan);
+    defineNative(pVM, "log", native_log);
+    defineNative(pVM, "exp", native_exp);
+    defineNative(pVM, "random", native_random);
+    defineNative(pVM, "randint", native_randint);
+    defineNative(pVM, "seed", native_seed);
+    defineNative(pVM, "sigmoid", native_sigmoid);
+    defineNative(pVM, "relu", native_relu);
+    defineNative(pVM, "tanh", native_tanh);
+    defineNative(pVM, "transpose", native_transpose);
 }