feat: Implement core runtime with NaN-boxing values, virtual machine, and Python bindings.

ProgrammerKR · ProgrammerKR · commit d19549ecacd4 · 2025-12-18T15:26:51.000+05:30
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -23,21 +23,31 @@ link_directories(${LLVM_LIBRARY_DIRS})
 # Map generic components to specific libs
 llvm_map_components_to_libnames(llvm_libs core support executionengine native ipo)
 
+# --- Project Source ---
+# Export symbols for Windows DLL
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+
 # --- Project Source ---
 include_directories(include)
 
-# Gather sources
-file(GLOB_RECURSE SOURCES 
+# Gather sources (excluding main.c for library)
+file(GLOB_RECURSE LIB_SOURCES 
     "src/*.c"
-    "src/compiler/*.cpp"  # Pickup the new backend
+    "src/compiler/*.cpp"
 )
+list(FILTER LIB_SOURCES EXCLUDE REGEX ".*main\\.c$")
+
+# --- Shared Library ---
+add_library(proxpl_lib SHARED ${LIB_SOURCES})
+target_link_libraries(proxpl_lib PRIVATE ${llvm_libs})
 
 # --- Executable ---
-add_executable(proxpl ${SOURCES})
+add_executable(proxpl src/main.c ${LIB_SOURCES})
 
 # Link LLVM and standard libraries
 target_link_libraries(proxpl PRIVATE ${llvm_libs})
 
 if(UNIX)
     target_link_libraries(proxpl PRIVATE pthread dl z tinfo) 
+    target_link_libraries(proxpl_lib PRIVATE pthread dl z tinfo)
 endif()
diff --git a/include/value.h b/include/value.h
@@ -8,40 +8,58 @@
 #define PROX_VALUE_H
 
 #include "common.h"
+#include <string.h>
 
-// For now, simpler Tagged Union.
-// Phase 2 can introduce Nan-boxing.
+// NaN-Boxing:
+// IEEE 754 doubles have 52 bits of mantissa.
+// specific NaN patterns can encode pointers (48 bits on x64) and tags.
+//
+// Mask: 0xFFFF000000000000 (Top 16 bits are tag/sign/exp)
+//
+// QNaN   : 0x7ff8000000000000
+// SIGN   : 0x8000000000000000 (Sign bit implies object pointer)
+// TAGS   : Lower 3 bits of the high 16 bits can be types.
+
+typedef uint64_t Value;
+
+// Masks
+#define SIGN_BIT ((uint64_t)0x8000000000000000)
+#define QNAN     ((uint64_t)0x7ffc000000000000)
+
+#define TAG_NULL  1 // 01
+#define TAG_FALSE 2 // 10
+#define TAG_TRUE  3 // 11
 
 typedef struct Obj Obj;
-typedef struct ObjString ObjString;
 
-typedef enum { VAL_BOOL, VAL_NULL, VAL_NUMBER, VAL_OBJ } ValueType;
+// Classification Macros
+#define IS_NUMBER(v) (((v) & QNAN) != QNAN)
+#define IS_NULL(v)   ((v) == (QNAN | TAG_NULL))
+#define IS_BOOL(v)   (((v) | 1) == (QNAN | TAG_TRUE))
+#define IS_OBJ(v)    (((v) & (QNAN | SIGN_BIT)) == (QNAN | SIGN_BIT))
 
-typedef struct {
-  ValueType type;
-  union {
-    bool boolean;
-    double number;
-    Obj *obj;
-  } as;
-} Value;
-
-// Macros for checking type
-#define IS_BOOL(value) ((value).type == VAL_BOOL)
-#define IS_NULL(value) ((value).type == VAL_NULL)
-#define IS_NUMBER(value) ((value).type == VAL_NUMBER)
-#define IS_OBJ(value) ((value).type == VAL_OBJ)
-
-// Macros for unwrapping
-#define AS_BOOL(value) ((value).as.boolean)
-#define AS_NUMBER(value) ((value).as.number)
-#define AS_OBJ(value) ((value).as.obj)
-
-// Macros for creating values
-#define BOOL_VAL(value) ((Value){VAL_BOOL, {.boolean = value}})
-#define NULL_VAL ((Value){VAL_NULL, {.number = 0}})
-#define NUMBER_VAL(value) ((Value){VAL_NUMBER, {.number = value}})
-#define OBJ_VAL(object) ((Value){VAL_OBJ, {.obj = (Obj *)object}})
+// Conversion Macros
+#define AS_NUMBER(v) valueToNum(v)
+#define AS_BOOL(v)   ((v) == (QNAN | TAG_TRUE))
+#define AS_OBJ(v)    ((Obj*)(uintptr_t)((v) & ~(SIGN_BIT | QNAN)))
+
+// Value Constructors
+static inline Value numToValue(double num) {
+    Value value;
+    memcpy(&value, &num, sizeof(double));
+    return value;
+}
+
+static inline double valueToNum(Value value) {
+    double num;
+    memcpy(&num, &value, sizeof(Value));
+    return num;
+}
+
+#define NUMBER_VAL(num) (numToValue(num))
+#define NULL_VAL        ((Value)(QNAN | TAG_NULL))
+#define BOOL_VAL(b)     ((b) ? (QNAN | TAG_TRUE) : (QNAN | TAG_FALSE))
+#define OBJ_VAL(obj)    (Value)(SIGN_BIT | QNAN | (uint64_t)(uintptr_t)(obj))
 
 // Value Array (for constants, stack etc.)
 typedef struct {
diff --git a/src/runtime/value.c b/src/runtime/value.c
@@ -36,19 +36,13 @@ void freeValueArray(ValueArray *array) {
 }
 
 void printValue(Value value) {
-  switch (value.type) {
-  case VAL_BOOL:
+  if (IS_BOOL(value)) {
     printf(AS_BOOL(value) ? "true" : "false");
-    break;
-  case VAL_NULL:
+  } else if (IS_NULL(value)) {
     printf("null");
-    break;
-  case VAL_NUMBER:
+  } else if (IS_NUMBER(value)) {
     printf("%g", AS_NUMBER(value));
-    break;
-  case VAL_OBJ:
-    // Placeholder until object system is implemented
+  } else if (IS_OBJ(value)) {
     printf("<obj>");
-    break;
   }
 }
diff --git a/src/runtime/vm.c b/src/runtime/vm.c
@@ -29,32 +29,117 @@ Value pop(VM *vm) {
 }
 
 static InterpretResult run(VM *vm) {
-#define READ_BYTE() (*vm->ip++)
-#define READ_CONSTANT() (vm->chunk->constants.values[READ_BYTE()])
-#define BINARY_OP(valueType, op)                                               \
-  do {                                                                         \
-    if (!IS_NUMBER((*(vm->stackTop - 1))) ||                                   \
-        !IS_NUMBER((*(vm->stackTop - 2)))) {                                   \
-      printf("Operands must be numbers.\n");                                   \
-      return INTERPRET_RUNTIME_ERROR;                                          \
-    }                                                                          \
-    double b = AS_NUMBER(pop(vm));                                             \
-    double a = AS_NUMBER(pop(vm));                                             \
-    push(vm, valueType(a op b));                                               \
-  } while (false)
+  register u8* ip = vm->ip;
+  register Value* sp = vm->stackTop;
 
-  for (;;) {
-#ifdef DEBUG_TRACE_EXECUTION
-    printf("          ");
-    for (Value *slot = vm->stack; slot < vm->stackTop; slot++) {
-      printf("[ ");
-      printValue(*slot);
-      printf(" ]");
-    }
+#ifdef __GNUC__
+  #define READ_BYTE() (*ip++)
+  #define READ_CONSTANT() (vm->chunk->constants.values[READ_BYTE()])
+  #define DISPATCH() goto *dispatch_table[*ip++]
+  
+  static void* dispatch_table[] = {
+      &&DO_OP_CONSTANT, &&DO_OP_TRUE, &&DO_OP_FALSE, &&DO_OP_NULL,
+      &&DO_OP_POP, &&DO_OP_ADD, &&DO_OP_SUBTRACT, &&DO_OP_MULTIPLY, 
+      &&DO_OP_DIVIDE, &&DO_OP_NOT, &&DO_OP_NEGATE, &&DO_OP_PRINT,
+      &&DO_OP_RETURN
+  };
+
+  DISPATCH();
+
+  DO_OP_CONSTANT: {
+      Value constant = READ_CONSTANT();
+      *sp++ = constant;
+      DISPATCH();
+  }
+  DO_OP_TRUE: {
+      *sp++ = BOOL_VAL(true);
+      DISPATCH();
+  }
+  DO_OP_FALSE: {
+      *sp++ = BOOL_VAL(false);
+      DISPATCH();
+  }
+  DO_OP_NULL: {
+      *sp++ = NULL_VAL;
+      DISPATCH();
+  }
+  DO_OP_POP: {
+      sp--;
+      DISPATCH();
+  }
+  DO_OP_ADD: {
+      double b = AS_NUMBER(*(sp - 1));
+      double a = AS_NUMBER(*(sp - 2));
+      sp -= 2;
+      *sp++ = NUMBER_VAL(a + b);
+      DISPATCH();
+  }
+  DO_OP_SUBTRACT: {
+      double b = AS_NUMBER(*(sp - 1));
+      double a = AS_NUMBER(*(sp - 2));
+      sp -= 2;
+      *sp++ = NUMBER_VAL(a - b);
+      DISPATCH();
+  }
+  DO_OP_MULTIPLY: {
+      double b = AS_NUMBER(*(sp - 1));
+      double a = AS_NUMBER(*(sp - 2));
+      sp -= 2;
+      *sp++ = NUMBER_VAL(a * b);
+      DISPATCH();
+  }
+  DO_OP_DIVIDE: {
+      double b = AS_NUMBER(*(sp - 1));
+      double a = AS_NUMBER(*(sp - 2));
+      sp -= 2;
+      *sp++ = NUMBER_VAL(a / b);
+      DISPATCH();
+  }
+  DO_OP_NOT: {
+      Value v = *(sp-1);
+      *(sp-1) = BOOL_VAL(IS_NULL(v) || (IS_BOOL(v) && !AS_BOOL(v)));
+      DISPATCH();
+  }
+  DO_OP_NEGATE: {
+      double a = AS_NUMBER(*(sp-1));
+      *(sp-1) = NUMBER_VAL(-a);
+      DISPATCH();
+  }
+  DO_OP_PRINT: {
+    // printValue expects Value, we need to sync slightly or safe call
+    // printValue doesn't use VM, so it's safe.
+    printValue(*(sp-1));
+    sp--;
     printf("\n");
-    disassembleInstruction(vm->chunk, (int)(vm->ip - vm->chunk->code));
-#endif
+    DISPATCH();
+  }
+  DO_OP_RETURN: {
+      vm->stackTop = sp; 
+      vm->ip = ip;
+      return INTERPRET_OK;
+  }
+  
+#else
+  // Fallback for MSVC / Standard C
+  // We use local variables for speed even in switch
+  vm->ip = ip;
+  vm->stackTop = sp;
+  
+  #define READ_BYTE() (*vm->ip++)
+  #define READ_CONSTANT() (vm->chunk->constants.values[READ_BYTE()])
+  #define BINARY_OP(valueType, op)                                               \
+    do {                                                                         \
+      if (!IS_NUMBER((*(vm->stackTop - 1))) ||                                   \
+          !IS_NUMBER((*(vm->stackTop - 2)))) {                                   \
+        printf("Operands must be numbers.\n");                                   \
+        return INTERPRET_RUNTIME_ERROR;                                          \
+      }                                                                          \
+      double b = AS_NUMBER(pop(vm));                                             \
+      double a = AS_NUMBER(pop(vm));                                             \
+      push(vm, valueType(a op b));                                               \
+    } while (false)
 
+  for (;;) {
     u8 instruction;
     switch (instruction = READ_BYTE()) {
     case OP_CONSTANT: {
@@ -108,10 +193,12 @@ static InterpretResult run(VM *vm) {
     }
     }
   }
+#endif
 
 #undef READ_BYTE
 #undef READ_CONSTANT
 #undef BINARY_OP
+#undef DISPATCH
 }
 
 InterpretResult interpret(VM *vm, Chunk *chunk) {
diff --git a/wrappers/proxpl_wrapper.py b/wrappers/proxpl_wrapper.py
