feat: Implement core object model, compiler stages (lexer, parser, AST, bytecode), VM, GC, and FFI.

Author: ProgrammerKR

CMakeLists.txt

@@ -14,9 +14,36 @@ else()
   add_compile_options(-Wall -Wextra)
 endif()
 
+# --- LLVM Configuration ---
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules")
+
 # --- LLVM Configuration ---
 find_package(LLVM CONFIG)
 
+# --- LibFFI Configuration ---
+# specialized find_package might be needed if not in standard path, but let's try standard first
+find_package(PkgConfig QUIET)
+if(PKG_CONFIG_FOUND)
+    pkg_check_modules(LIBFFI libffi)
+endif()
+
+# Fallback or manual find if pkg-config fails or on simple windows setups
+if(NOT LIBFFI_FOUND)
+    find_path(LIBFFI_INCLUDE_DIRS ffi.h)
+    find_library(LIBFFI_LIBRARIES NAMES ffi libffi)
+    if(LIBFFI_INCLUDE_DIRS AND LIBFFI_LIBRARIES)
+        set(LIBFFI_FOUND TRUE)
+    endif()
+endif()
+
+if(LIBFFI_FOUND)
+    message(STATUS "Found LibFFI: ${LIBFFI_LIBRARIES}")
+    include_directories(${LIBFFI_INCLUDE_DIRS})
+    add_definitions(-DUSE_LIBFFI)
+else()
+    message(WARNING "LibFFI not found. FFI features will be disabled.")
+endif()
+
 if (LLVM_FOUND)
     message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
     include_directories(SYSTEM ${LLVM_INCLUDE_DIRS})
@@ -76,6 +103,9 @@ else()
     if (LLVM_FOUND)
         target_link_libraries(proxpl_lib PRIVATE ${llvm_libs})
     endif()
+    if (LIBFFI_FOUND)
+        target_link_libraries(proxpl_lib PRIVATE ${LIBFFI_LIBRARIES})
+    endif()
     add_executable(proxpl src/main.c)
     target_link_libraries(proxpl PRIVATE proxpl_lib)
 endif()
@@ -86,6 +116,10 @@ if (LLVM_FOUND)
     target_link_libraries(proxpl PRIVATE ${llvm_libs})
 endif()
 
+if (LIBFFI_FOUND)
+    target_link_libraries(proxpl PRIVATE ${LIBFFI_LIBRARIES})
+endif()
+
 if(UNIX)
     if(APPLE)
         target_link_libraries(proxpl PRIVATE pthread dl z)

include/ast.h

@@ -44,7 +44,7 @@ typedef enum {
   STMT_EXPRESSION, STMT_VAR_DECL, STMT_FUNC_DECL, STMT_CLASS_DECL, STMT_INTERFACE_DECL,
   STMT_USE_DECL, STMT_IF, STMT_WHILE, STMT_FOR, STMT_RETURN,
   STMT_BLOCK, STMT_BREAK, STMT_CONTINUE, STMT_SWITCH,
-  STMT_TRY_CATCH, STMT_PRINT
+  STMT_TRY_CATCH, STMT_PRINT, STMT_EXTERN_DECL
 } StmtType;
 
 // --- List Structures ---
@@ -137,6 +137,7 @@ typedef struct { int dummy; } ContinueStmt;
 typedef struct { Expr *value; SwitchCaseList *cases; StmtList *default_case; } SwitchStmt;
 typedef struct { StmtList *try_block; char *catch_var; StmtList *catch_block; StmtList *finally_block; } TryCatchStmt;
 typedef struct { Expr *expression; } PrintStmt;
+typedef struct { char *libraryPath; char *symbolName; char *name; StringList *params; } ExternDeclStmt;
 
 struct Stmt {
   StmtType type;
@@ -148,6 +149,7 @@ struct Stmt {
     WhileStmt while_stmt; ForStmt for_stmt; ReturnStmt return_stmt;
     BlockStmt block; BreakStmt break_stmt; ContinueStmt continue_stmt;
     SwitchStmt switch_stmt; TryCatchStmt try_catch; PrintStmt print;
+    ExternDeclStmt extern_decl;
   } as;
 };
 
@@ -185,6 +187,7 @@ Stmt *createContinueStmt(int line, int column);
 Stmt *createSwitchStmt(Expr *value, SwitchCaseList *cases, StmtList *def, int line, int column);
 Stmt *createTryCatchStmt(StmtList *try_blk, const char *catch_var, StmtList *catch_blk, StmtList *finally_blk, int line, int column);
 Stmt *createPrintStmt(Expr *expression, int line, int column);
+Stmt *createExternDeclStmt(const char *libPath, const char *symName, const char *name, StringList *params, int line, int column);
 
 ExprList *createExprList();
 void appendExpr(ExprList *list, Expr *expr);

include/bytecode.h

@@ -64,6 +64,7 @@ typedef enum {
   OP_END_TRY,
   OP_INTERFACE,
   OP_IMPLEMENT,
+  OP_MAKE_FOREIGN,
   OP_HALT = 0xFF
 } OpCode;
 

include/ffi_bridge.h

@@ -0,0 +1,23 @@
+#ifndef PROX_FFI_BRIDGE_H
+#define PROX_FFI_BRIDGE_H
+
+#include "value.h"
+#include "object.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Call a foreign function interface object
+Value callForeign(ObjForeign* foreign, int argCount, Value* args);
+
+// Load a dynamic library and find a symbol
+// Returns successful ObjForeign* or NULL if failed
+// If libraryPath is NULL, looks in current process (e.g. libc/msvcrt)
+ObjForeign* loadForeign(ObjString* libraryPath, ObjString* symbolName);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PROX_FFI_BRIDGE_H

include/object.h

@@ -57,6 +57,9 @@
 #define IS_INTERFACE(value) isObjType(value, OBJ_INTERFACE)
 #define AS_INTERFACE(value) ((ObjInterface *)AS_OBJ(value))
 
+#define IS_FOREIGN(value) isObjType(value, OBJ_FOREIGN)
+#define AS_FOREIGN(value) ((ObjForeign *)AS_OBJ(value))
+
 typedef enum {
   OBJ_STRING,
   OBJ_FUNCTION,
@@ -69,6 +72,7 @@ typedef enum {
   OBJ_BOUND_METHOD,
   OBJ_LIST,
   OBJ_DICTIONARY,
+  OBJ_FOREIGN,
 
   OBJ_TASK,
   OBJ_INTERFACE
@@ -167,6 +171,13 @@ struct ObjDictionary {
   Table items;
 };
 
+typedef struct ObjForeign {
+  Obj obj;
+  ObjString* name;
+  void* library; // dlopen/LoadLibrary handle
+  void* function; // dlsym/GetProcAddress pointer
+} ObjForeign;
+
 typedef struct ObjTask ObjTask;
 
 typedef void (*ResumeFn)(void*);
@@ -198,6 +209,7 @@ struct ObjInstance *newInstance(struct ObjClass *klass);
 struct ObjBoundMethod *newBoundMethod(Value receiver, ObjClosure *method);
 struct ObjList *newList();
 struct ObjDictionary *newDictionary();
+ObjForeign *newForeign(ObjString* name, void* library, void* function);
 struct ObjTask *newTask(void* hdl, ResumeFn resume);
 void printObject(Value value);
 

include/scanner.h

@@ -106,6 +106,7 @@ typedef enum {
   TOKEN_IS,
   TOKEN_TYPEOF,
   TOKEN_EXTENDS,
+  TOKEN_EXTERN,
   TOKEN_IMPLEMENTS,
   TOKEN_INTERFACE,
   TOKEN_ENUM,

src/compiler/bytecode_gen.c

@@ -481,6 +481,33 @@ static void genStmt(BytecodeGen* gen, Stmt* stmt) {
             writeChunk(gen->chunk, OP_RETURN, stmt->line);
             break;
         }
+        case STMT_EXTERN_DECL: {
+            // Push library path
+            Value libVal = OBJ_VAL(copyString(stmt->as.extern_decl.libraryPath, strlen(stmt->as.extern_decl.libraryPath)));
+            int libConst = addConstant(gen->chunk, libVal);
+            writeChunk(gen->chunk, OP_CONSTANT, stmt->line);
+            writeChunk(gen->chunk, (uint8_t)libConst, stmt->line);
+            
+            // Push symbol name
+            Value symVal = OBJ_VAL(copyString(stmt->as.extern_decl.symbolName, strlen(stmt->as.extern_decl.symbolName)));
+            int symConst = addConstant(gen->chunk, symVal);
+            writeChunk(gen->chunk, OP_CONSTANT, stmt->line);
+            writeChunk(gen->chunk, (uint8_t)symConst, stmt->line);
+            
+            // Make Foreign Object
+            writeChunk(gen->chunk, OP_MAKE_FOREIGN, stmt->line);
+            
+            // Define Global
+             if (gen->compiler->scopeDepth > 0) {
+                addLocal(gen, stmt->as.extern_decl.name);
+            } else {
+                Value nameVal = OBJ_VAL(copyString(stmt->as.extern_decl.name, strlen(stmt->as.extern_decl.name)));
+                int nameConst = addConstant(gen->chunk, nameVal);
+                writeChunk(gen->chunk, OP_DEFINE_GLOBAL, stmt->line);
+                writeChunk(gen->chunk, (uint8_t)nameConst, stmt->line);
+            }
+            break;
+        }
         case STMT_IF: {
             genExpr(gen, stmt->as.if_stmt.condition);
             writeChunk(gen->chunk, OP_JUMP_IF_FALSE, stmt->line);

src/compiler/lexer/scanner.c

@@ -242,7 +242,13 @@ static PxTokenType identifierType(Scanner *scanner) {
           case 'p':
             return checkKeyword(scanner, 3, 3, "ort", TOKEN_EXPORT);
           case 't':
-            return checkKeyword(scanner, 3, 4, "ends", TOKEN_EXTENDS);
+            if (scanner->current - scanner->start > 3) {
+                 switch(scanner->start[3]) {
+                     case 'e': return checkKeyword(scanner, 4, 2, "rn", TOKEN_EXTERN);
+                     case 'n': return checkKeyword(scanner, 4, 3, "nds", TOKEN_EXTENDS);
+                 }
+            }
+            break;
           }
         }
         break;

src/compiler/parser/ast.c

@@ -492,6 +492,18 @@ Stmt *createPrintStmt(Expr *expression, int line, int column) {
   return stmt;
 }
 
+Stmt *createExternDeclStmt(const char *libPath, const char *symName, const char *name, StringList *params, int line, int column) {
+  Stmt *stmt = ALLOCATE(Stmt, 1);
+  stmt->type = STMT_EXTERN_DECL;
+  stmt->line = line;
+  stmt->column = column;
+  stmt->as.extern_decl.libraryPath = strdup(libPath);
+  stmt->as.extern_decl.symbolName = strdup(symName);
+  stmt->as.extern_decl.name = strdup(name);
+  stmt->as.extern_decl.params = params;
+  return stmt;
+}
+
 // --- Free Functions ---
 
 void freeExpr(Expr *expr) {
@@ -640,6 +652,12 @@ void freeStmt(Stmt *stmt) {
   case STMT_PRINT:
     freeExpr(stmt->as.print.expression);
     break;
+  case STMT_EXTERN_DECL:
+    free(stmt->as.extern_decl.libraryPath);
+    free(stmt->as.extern_decl.symbolName);
+    free(stmt->as.extern_decl.name);
+    freeStringList(stmt->as.extern_decl.params);
+    break;
   }
 
   FREE(Stmt, stmt);

src/compiler/parser/parser.c

@@ -205,6 +205,8 @@ StmtList *parse(Parser *parser) {
 
 // === Declarations ===
 
+static Stmt *externDecl(Parser *p);
+
 static Stmt *declaration(Parser *p) {
   if (match(p, 1, TOKEN_ASYNC)) {
       if (match(p, 1, TOKEN_FUNC))
@@ -217,6 +219,8 @@ static Stmt *declaration(Parser *p) {
     return funcDecl(p, "function", false, ACCESS_PUBLIC, false, false);
   if (match(p, 1, TOKEN_CLASS))
     return classDecl(p);
+  if (match(p, 1, TOKEN_EXTERN))
+    return externDecl(p);
   if (match(p, 1, TOKEN_INTERFACE))
     return interfaceDecl(p);
   if (match(p, 1, TOKEN_USE))
@@ -398,6 +402,39 @@ static Stmt *useDecl(Parser *p) {
   return createUseDeclStmt(modules, previous(p).line, 0);
 }
 
+static Stmt *externDecl(Parser *p) {
+    Token libToken = consume(p, TOKEN_STRING, "Expect library path string.");
+    char *libPath = tokenToString(libToken);
+    
+    Token symToken = consume(p, TOKEN_STRING, "Expect symbol name string.");
+    char *symName = tokenToString(symToken);
+    
+    consume(p, TOKEN_FUNC, "Expect 'func' after extern strings.");
+    Token nameToken = consume(p, TOKEN_IDENTIFIER, "Expect function name.");
+    char *name = tokenToString(nameToken);
+    
+    consume(p, TOKEN_LEFT_PAREN, "Expect '(' after name.");
+    
+    StringList *params = createStringList();
+    if (!check(p, TOKEN_RIGHT_PAREN)) {
+        do {
+            Token param = consume(p, TOKEN_IDENTIFIER, "Expect parameter name.");
+            char *paramName = tokenToString(param);
+            appendString(params, paramName);
+            free(paramName);
+        } while (match(p, 1, TOKEN_COMMA));
+    }
+    
+    consume(p, TOKEN_RIGHT_PAREN, "Expect ')' after parameters.");
+    consume(p, TOKEN_SEMICOLON, "Expect ';' after extern declaration.");
+    
+    Stmt *stmt = createExternDeclStmt(libPath, symName, name, params, libToken.line, 0);
+    free(libPath);
+    free(symName);
+    free(name);
+    return stmt;
+}
+
 // === Statements ===
 
 static Stmt *statement(Parser *p) {