Refactor proxpl_api.c for file handling and stubbing

Updated proxpl_api.c to include file reading capabilities and modified function implementations to handle source code strings instead of raw chunks. Stubbed out features for writing and reading chunks from files.

Author: ProgrammerKR

src/proxpl_api.c

@@ -1,38 +1,83 @@
-/* proxpl_api.c - public API wrappers for stable ABI
- * Exposes a minimal C-style API that callers can use to embed runtime.
- */
+/* proxpl_api.c - public API wrappers for stable ABI */
 
-#include "proxpl_api.h"
-#include "vm.h"
-#include "chunk.h"
+#include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+
+#include "../include/proxpl_api.h"
+#include "../include/vm.h"
+#include "../include/chunk.h"
+#include "../include/common.h"
+
+// Helper to read a file into a string
+static char* readFile(const char* path) {
+    FILE* file = fopen(path, "rb");
+    if (file == NULL) {
+        fprintf(stderr, "Could not open file \"%s\".\n", path);
+        return NULL;
+    }
+
+    fseek(file, 0L, SEEK_END);
+    size_t fileSize = ftell(file);
+    rewind(file);
+
+    char* buffer = (char*)malloc(fileSize + 1);
+    if (buffer == NULL) {
+        fprintf(stderr, "Not enough memory to read \"%s\".\n", path);
+        fclose(file);
+        return NULL;
+    }
+
+    size_t bytesRead = fread(buffer, sizeof(char), fileSize, file);
+    if (bytesRead < fileSize) {
+        fprintf(stderr, "Could not read file \"%s\".\n", path);
+        free(buffer);
+        fclose(file);
+        return NULL;
+    }
+
+    buffer[bytesRead] = '\0';
+    fclose(file);
+    return buffer;
+}
 
 void proxpl_vm_init(VM *vm) {
-    initVM(vm);
+    // Standard CLOX uses a global VM instance, so we ignore the pointer for now
+    // or assume 'vm' points to the global one.
+    initVM(); 
 }
 
 void proxpl_vm_free(VM *vm) {
-    freeVM(vm);
+    freeVM();
 }
 
 InterpretResult proxpl_interpret_chunk(VM *vm, const Chunk *chunk) {
-    // interpret expects a mutable chunk; cast away const as the API currently
-    return interpret(vm, (Chunk *)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) {
-    // Helper: read chunk and interpret
-    Chunk c;
-    if (read_chunk_from_file(path, &c) != 0) return INTERPRET_COMPILE_ERROR;
-    InterpretResult r = interpret(vm, &c);
-    chunk_free(&c);
-    return r;
+    char* source = readFile(path);
+    if (source == NULL) return INTERPRET_COMPILE_ERROR;
+
+    // Pass the source string to interpret
+    InterpretResult result = interpret(source);
+    
+    free(source);
+    return result;
 }
 
+// These functions are STUBBED because bytecode.c was deleted.
+// You must re-implement binary serialization later if you need it.
 int proxpl_write_chunk_to_file(const char *path, const Chunk *chunk) {
-    return write_chunk_to_file(path, chunk);
+    fprintf(stderr, "Feature 'write_chunk_to_file' is temporarily disabled.\n");
+    return -1;
 }
 
 int proxpl_read_chunk_from_file(const char *path, Chunk *out) {
-    return read_chunk_from_file(path, out);
+    fprintf(stderr, "Feature 'read_chunk_from_file' is temporarily disabled.\n");
+    return -1;
 }
+