prepared for release and placed most debug prints under cfg macro

Author: sinisterMage

wpp-cli/src/main.rs

@@ -662,6 +662,7 @@ fn run_with_codegen(_source: &str, optimize: bool) {
 
     // 🧩 Step 4: Collect exports across cached modules
     let mut resolver = ExportResolver::new();
+    #[cfg(debug_assertions)]
     println!("📦 [debug] WMS cache keys: {:?}", wms.get_cache().keys());
     resolver.collect_exports(&wms);
 

wpp-v2/src/lib.rs

@@ -22,7 +22,7 @@ use libc::{malloc, printf};
 use crate::codegen::Codegen;
 use crate::lexer::Lexer;
 use crate::parser::Parser;
-use crate::runtime::thread::{wpp_mutex_lock, wpp_mutex_new, wpp_mutex_unlock, wpp_thread_join, wpp_thread_join_all, wpp_thread_poll, wpp_thread_spawn_gc};
+use crate::runtime::thread::{wpp_mutex_lock, wpp_mutex_new, wpp_mutex_unlock, wpp_thread_join, wpp_thread_join_all, wpp_thread_poll, wpp_thread_spawn_gc, wpp_thread_state_get, wpp_thread_state_new, wpp_thread_state_set};
 use runtime::*;
 
 /// Link to static runtime (optional)
@@ -47,34 +47,112 @@ fn declare_runtime_externals<'ctx>(context: &'ctx Context, module: &Module<'ctx>
     let i64_type = context.i64_type();
     let i8_ptr = context.i8_type().ptr_type(inkwell::AddressSpace::from(0));
 
-    // === Declare all known externals ===
+    // === Declare all runtime externals ===
     let externals = [
+        // --- Print subsystem ---
         ("wpp_print_value_basic", void_type.fn_type(&[i8_ptr.into(), i32_type.into()], false)),
         ("wpp_print_array", void_type.fn_type(&[i8_ptr.into()], false)),
         ("wpp_print_object", void_type.fn_type(&[i8_ptr.into()], false)),
+
+        // --- String subsystem ---
+        ("wpp_str_concat", i8_ptr.fn_type(&[i8_ptr.into(), i8_ptr.into()], false)),
+
+        // --- HTTP subsystem ---
+        ("wpp_http_get", i32_type.fn_type(&[i8_ptr.into()], false)),
+        ("wpp_http_post", i32_type.fn_type(&[i8_ptr.into(), i8_ptr.into()], false)),
+        ("wpp_http_put", i32_type.fn_type(&[i8_ptr.into(), i8_ptr.into()], false)),
+        ("wpp_http_patch", i32_type.fn_type(&[i8_ptr.into(), i8_ptr.into()], false)),
+        ("wpp_http_delete", i32_type.fn_type(&[i8_ptr.into()], false)),
+        ("wpp_http_status", i32_type.fn_type(&[i32_type.into()], false)),
+        ("wpp_http_body", i8_ptr.fn_type(&[i32_type.into()], false)),
+        ("wpp_http_headers", i8_ptr.fn_type(&[i32_type.into()], false)),
+        ("wpp_http_free_all", void_type.fn_type(&[], false)),
+        ("wpp_register_endpoint", void_type.fn_type(&[i8_ptr.into(), i8_ptr.into()], false)),
+        ("wpp_start_server", void_type.fn_type(&[i32_type.into()], false)),
+
+        // --- Threading subsystem ---
         ("wpp_thread_spawn_gc", i8_ptr.fn_type(&[i8_ptr.into()], false)),
         ("wpp_thread_join", void_type.fn_type(&[i8_ptr.into()], false)),
         ("wpp_thread_poll", i32_type.fn_type(&[i8_ptr.into()], false)),
-        ("wpp_thread_join_all", void_type.fn_type(&[], false)), // 🧩 critical
+        ("wpp_thread_state_new", i8_ptr.fn_type(&[i32_type.into()], false)),
+        ("wpp_thread_state_get", i8_ptr.fn_type(&[i8_ptr.into()], false)),
+        ("wpp_thread_state_set", void_type.fn_type(&[i8_ptr.into(), i32_type.into()], false)),
+        ("wpp_thread_join_all", void_type.fn_type(&[], false)),
+
+        // --- Mutex subsystem ---
         ("wpp_mutex_new", i8_ptr.fn_type(&[i32_type.into()], false)),
         ("wpp_mutex_lock", void_type.fn_type(&[i8_ptr.into(), i32_type.into()], false)),
         ("wpp_mutex_unlock", void_type.fn_type(&[i8_ptr.into()], false)),
+
+        // --- Runtime ---
+        ("wpp_runtime_wait", void_type.fn_type(&[], false)),
+
+        // --- libc ---
         ("printf", i32_type.fn_type(&[i8_ptr.into()], true)),
         ("malloc", i8_ptr.fn_type(&[i64_type.into()], false)),
     ];
 
     for (name, ty) in externals {
         if module.get_function(name).is_none() {
             module.add_function(name, ty, None);
-            println!("🔧 Declared external runtime function: {name}");
         }
     }
 }
+fn register_all_runtime_symbols() {
+    unsafe {
+        // --- Print subsystem ---
+        add_symbol("wpp_print_value_basic", wpp_print_value_basic as usize);
+        add_symbol("wpp_print_array", wpp_print_array as usize);
+        add_symbol("wpp_print_object", wpp_print_object as usize);
+
+        // --- String subsystem ---
+        add_symbol("wpp_str_concat", wpp_str_concat as usize);
+
+        // --- HTTP subsystem ---
+        add_symbol("wpp_http_get", wpp_http_get as usize);
+        add_symbol("wpp_http_post", wpp_http_post as usize);
+        add_symbol("wpp_http_put", wpp_http_put as usize);
+        add_symbol("wpp_http_patch", wpp_http_patch as usize);
+        add_symbol("wpp_http_delete", wpp_http_delete as usize);
+        add_symbol("wpp_http_status", wpp_http_status as usize);
+        add_symbol("wpp_http_body", wpp_http_body as usize);
+        add_symbol("wpp_http_headers", wpp_http_headers as usize);
+        add_symbol("wpp_http_free_all", wpp_http_free_all as usize);
+        add_symbol("wpp_register_endpoint", wpp_register_endpoint as usize);
+        add_symbol("wpp_start_server", wpp_start_server as usize);
+
+        // --- Threading subsystem ---
+        add_symbol("wpp_thread_spawn_gc", wpp_thread_spawn_gc as usize);
+        add_symbol("wpp_thread_join", wpp_thread_join as usize);
+        add_symbol("wpp_thread_poll", wpp_thread_poll as usize);
+        add_symbol("wpp_thread_state_new", wpp_thread_state_new as usize);
+        add_symbol("wpp_thread_state_get", wpp_thread_state_get as usize);
+        add_symbol("wpp_thread_state_set", wpp_thread_state_set as usize);
+        add_symbol("wpp_thread_join_all", wpp_thread_join_all as usize);
+
+        // --- Mutex subsystem ---
+        add_symbol("wpp_mutex_new", wpp_mutex_new as usize);
+        add_symbol("wpp_mutex_lock", wpp_mutex_lock as usize);
+        add_symbol("wpp_mutex_unlock", wpp_mutex_unlock as usize);
+
+        // --- Runtime ---
+        add_symbol("wpp_runtime_wait", wpp_runtime_wait as usize);
+
+        // --- libc ---
+        unsafe extern "C" {
+            fn printf(fmt: *const std::os::raw::c_char, ...) -> i32;
+            fn malloc(size: usize) -> *mut std::ffi::c_void;
+        }
+        add_symbol("printf", printf as usize);
+        add_symbol("malloc", malloc as usize);
+    }
+}
 
 fn register_runtime_symbols<'ctx>(engine: &ExecutionEngine<'ctx>, module: &Module<'ctx>) {
     let map_fn = |name: &str, ptr: usize| {
         if let Some(func) = module.get_function(name) {
             engine.add_global_mapping(&func, ptr);
+            #[cfg(debug_assertions)]
             println!("🔗 Bound {name}");
         } else {
             eprintln!("⚠️ Function {name} not found in module");
@@ -163,6 +241,7 @@ pub fn run_file(codegen: &mut Codegen, optimize: bool) -> Result<(), String> {
                             // 🧹 Remove duplicate globals
                             for global_name in ["_wpp_exc_flag", "_wpp_exc_i32", "_wpp_exc_str"] {
                                 if let Some(global) = main_mod.get_global(global_name) {
+                                    #[cfg(debug_assertions)]
                                     println!(
                                         "🔧 [wms] Neutralized duplicate global '{}' in reloaded main module",
                                         global_name
@@ -201,6 +280,7 @@ pub fn run_file(codegen: &mut Codegen, optimize: bool) -> Result<(), String> {
             }
 
             if let Some(ref ir_text) = dep.llvm_ir {
+                #[cfg(debug_assertions)]
                 println!("🔗 [link] Importing compiled submodule: {}", name);
                 let mem_buf = MemoryBuffer::create_from_memory_range_copy(ir_text.as_bytes(), name);
 
@@ -223,27 +303,27 @@ pub fn run_file(codegen: &mut Codegen, optimize: bool) -> Result<(), String> {
             }
         }
     }
+    #[cfg(debug_assertions)]
     println!("🪶 [debug1] Finished merging and linking modules — about to declare externals");
     declare_runtime_externals(context, module);
+    #[cfg(debug_assertions)]
     println!("🪶 [debug2] Declared externals successfully — creating JIT engine next");
-    unsafe {
-    add_symbol("wpp_print_value_basic", wpp_print_value_basic as usize);
-    add_symbol("wpp_thread_join_all", wpp_thread_join_all as usize);
-    add_symbol("printf", printf as usize);
-    add_symbol("malloc", malloc as usize);
-}
+    register_all_runtime_symbols();
 
 
     // === Create JIT engine ===
     let engine = module
         .create_jit_execution_engine(OptimizationLevel::None)
         .map_err(|e| format!("JIT init failed: {e:?}"))?;
+    #[cfg(debug_assertions)]
 println!("🪶 [debug3] JIT engine created successfully");
     for func in module.get_functions() {
     if let Ok(name) = func.get_name().to_str() {
         if let Ok(addr) = engine.get_function_address(name) {
+            #[cfg(debug_assertions)]
             println!("🔎 {name} -> 0x{addr:x}");
         } else {
+            #[cfg(debug_assertions)]
             println!("❌ {name} -> <missing>");
         }
     }
@@ -255,6 +335,7 @@ println!("🪶 [debug3] JIT engine created successfully");
 
     // === Register runtime bindings ===
     register_runtime_symbols(&engine, module);
+    #[cfg(debug_assertions)]
     println!("🪶 [debug4] Runtime symbols bound successfully");
 
     // === Link cross-module imports (from WMS) ===
@@ -264,9 +345,11 @@ println!("🪶 [debug3] JIT engine created successfully");
         let wms = wms_arc.lock().unwrap();
         let mut resolver = resolver_arc.lock().unwrap();
         resolver.link_imports_runtime(&engine, module, &wms);
+        #[cfg(debug_assertions)]
         println!("🪶 [debug5] Finished linking runtime imports across modules");
 
     }
+    #[cfg(debug_assertions)]
     println!("🪶 [debug6] Searching for entrypoint (bootstrap_main / main / main_async)");
     // === Find and run entrypoint ===
     let entry_name = if module.get_function("bootstrap_main").is_some() {
@@ -279,10 +362,13 @@ println!("🪶 [debug3] JIT engine created successfully");
         eprintln!("❌ No valid entrypoint found (expected main, main_async, or bootstrap_main)");
         return Err("❌ No entrypoint function found in final linked module".into());
     };
+    #[cfg(debug_assertions)]
     println!("🪶 [debug7] Entrypoint resolved to {entry_name}");
+    #[cfg(debug_assertions)]
     println!("🔍 [jit] Listing all LLVM functions before execution:");
     for func in module.get_functions() {
         if let Ok(name) = func.get_name().to_str() {
+            #[cfg(debug_assertions)]
             println!("  - {}", name);
         }
     }
@@ -297,9 +383,13 @@ println!("🪶 [debug3] JIT engine created successfully");
     // === Debug entrypoint signature ===
     println!("🚀 Launching entrypoint: {entry_name}");
     if let Some(func) = module.get_function(entry_name) {
+        #[cfg(debug_assertions)]
         println!("🔍 LLVM signature for entrypoint:");
+        #[cfg(debug_assertions)]
         println!("{}", func.print_to_string().to_string());
+        #[cfg(debug_assertions)]
         println!("=== FULL IR DUMP ===");
+        #[cfg(debug_assertions)]
 println!("{}", module.print_to_string().to_string());
     }
 
@@ -310,6 +400,7 @@ println!("{}", module.print_to_string().to_string());
             Err(_) => println!("❌ Missing runtime binding for {name}"),
         }
     }
+    #[cfg(debug_assertions)]
     println!("🧠 [jit] About to execute entrypoint `{entry_name}`");
     // === Run the entrypoint ===
 
@@ -322,6 +413,7 @@ println!("{}", module.print_to_string().to_string());
         println!("✅ [jit] Returned cleanly from `{entry_name}` with result = {result}");
         println!("🏁 Finished running {entry_name}, result = {result}");
     }
+    #[cfg(debug_assertions)]
     println!("🪶 [debug10] run_file() completed successfully without panic");
     Ok(())
 }

wpp-v2/src/module_system.rs

@@ -88,6 +88,7 @@ impl ModuleSystem {
                 let mut cache = self.cache.lock().unwrap();
                 if !cache.contains_key(module) {
                     drop(cache); // unlock before recursive call
+                    #[cfg(debug_assertions)]
                     println!("🔗 [wms] Auto-loading dependency '{}'", module);
                     if let Err(e) = self.load_module(module) {
                         eprintln!("⚠️ [wms] Failed to load dependency '{}': {}", module, e);
@@ -117,7 +118,7 @@ if name != "main" {
                 use inkwell::values::AsValueRef;
                 LLVMSetInitializer(global.as_value_ref(), std::ptr::null_mut());
             }
-
+            #[cfg(debug_assertions)]
             println!("🔧 [wms] Neutralized duplicate global '{}' in module '{}'", gname, name);
         }
     }