Harden GC memory safety, optimize bytecode dispatch, and update build scripts

Add RAII root guards, thread safe spawn cloning, zero copy string refs, and CMake and install fixes

Author: Shrey-N

CMakeLists.txt

@@ -18,6 +18,16 @@ else()
     add_compile_options(-Wall -Wextra -Wno-unused-parameter -Wno-unused-variable)
 endif()
 
+option(SHL_ENABLE_ASAN "Enable AddressSanitizer" OFF)
+if(SHL_ENABLE_ASAN)
+    if(MSVC)
+        add_compile_options(/fsanitize=address)
+    else()
+        add_compile_options(-fsanitize=address,undefined)
+        add_link_options(-fsanitize=address,undefined)
+    endif()
+endif()
+
 include(FetchContent)
 
 # ------------------------------------------------------------------------------
@@ -176,30 +186,40 @@ set(SOURCES
 # ------------------------------------------------------------------------------
 # 3. Executable and Library Targets
 # ------------------------------------------------------------------------------
-add_executable(shell_lite_exec ${SOURCES})
+add_library(shell_lite_core OBJECT ${SOURCES})
+set_target_properties(shell_lite_core PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
-target_include_directories(shell_lite_exec PRIVATE 
+target_include_directories(shell_lite_core PUBLIC 
     shell_lite
     ${sqlite3_SOURCE_DIR}
     ${imgui_SOURCE_DIR}
     ${imgui_SOURCE_DIR}/backends
 )
+target_link_libraries(shell_lite_core PUBLIC libcurl clip SDL2-static httplib zip SQLite3)
+if(WIN32)
+    target_link_libraries(shell_lite_core PUBLIC ws2_32 user32 gdi32)
+endif()
 
+add_executable(shell_lite_exec $<TARGET_OBJECTS:shell_lite_core>)
+target_include_directories(shell_lite_exec PRIVATE 
+    shell_lite
+    ${sqlite3_SOURCE_DIR}
+    ${imgui_SOURCE_DIR}
+    ${imgui_SOURCE_DIR}/backends
+)
 target_link_libraries(shell_lite_exec PRIVATE libcurl clip SDL2-static httplib zip SQLite3)
 
 if(WIN32)
     target_link_libraries(shell_lite_exec PRIVATE ws2_32 user32 gdi32)
 endif()
 
-add_library(shell_lite_lib SHARED ${SOURCES})
-
+add_library(shell_lite_lib SHARED $<TARGET_OBJECTS:shell_lite_core>)
 target_include_directories(shell_lite_lib PRIVATE 
     shell_lite
     ${sqlite3_SOURCE_DIR}
     ${imgui_SOURCE_DIR}
     ${imgui_SOURCE_DIR}/backends
 )
-
 target_link_libraries(shell_lite_lib PRIVATE libcurl clip SDL2-static httplib zip SQLite3)
 
 if(WIN32)

install.ps1

@@ -1,26 +1,56 @@
 $InstallDir = "$env:LOCALAPPDATA\ShellLite"
 $ExePath = Join-Path $PSScriptRoot "shlcpp.exe"
 if (-not (Test-Path $ExePath)) {
-    Write-Error "shlcpp.exe not found in current directory. Please run this after building."
-    exit
+    if (Test-Path (Join-Path $PSScriptRoot "build_cpp\Release\shell_lite_exec.exe")) {
+        $ExePath = Join-Path $PSScriptRoot "build_cpp\Release\shell_lite_exec.exe"
+    } elseif (Test-Path (Join-Path $PSScriptRoot "build_cpp\Release\shlcpp.exe")) {
+        $ExePath = Join-Path $PSScriptRoot "build_cpp\Release\shlcpp.exe"
+    } else {
+        Write-Error "shlcpp.exe not found. Please place or build shlcpp.exe first."
+        exit 1
+    }
 }
 Write-Host "Installing ShellLite to $InstallDir..."
 if (-not (Test-Path $InstallDir)) {
-    New-Item -ItemType Directory -Path $InstallDir
+    New-Item -ItemType Directory -Path $InstallDir | Out-Null
 }
-Copy-Item $ExePath -Destination $InstallDir -Force
+Copy-Item $ExePath -Destination (Join-Path $InstallDir "shlcpp.exe") -Force
 Write-Host "ShellLite binary copied."
+
+$DllPath = Join-Path $PSScriptRoot "shell_lite_lib.dll"
+if (-not (Test-Path $DllPath) -and (Test-Path (Join-Path $PSScriptRoot "build_cpp\Release\shell_lite_lib.dll"))) {
+    $DllPath = Join-Path $PSScriptRoot "build_cpp\Release\shell_lite_lib.dll"
+}
+if (Test-Path $DllPath) {
+    Copy-Item $DllPath -Destination $InstallDir -Force
+    Write-Host "ShellLite shared library copied."
+}
+
 $StdLibPath = Join-Path $PSScriptRoot "shell_lite\stdlib"
 if (Test-Path $StdLibPath) {
+    $DestStdLib = Join-Path $InstallDir "stdlib"
+    if (Test-Path $DestStdLib) {
+        Remove-Item $DestStdLib -Recurse -Force
+    }
     Copy-Item -Path $StdLibPath -Destination $InstallDir -Recurse -Force
     Write-Host "ShellLite standard library copied."
 }
 $UserPath = [Environment]::GetEnvironmentVariable("Path", "User")
-if ($UserPath -notlike "*$InstallDir*") {
+$PathEntries = if ($UserPath) { ($UserPath -split ';') | Where-Object { $_ } } else { @() }
+if ($PathEntries -notcontains $InstallDir) {
     Write-Host "Adding $InstallDir to User PATH..."
-    [Environment]::SetEnvironmentVariable("Path", $UserPath + ";" + $InstallDir, "User")
+    $NewPath = if ($UserPath) { "$UserPath;$InstallDir" } else { $InstallDir }
+    [Environment]::SetEnvironmentVariable("Path", $NewPath, "User")
     Write-Host "PATH updated. Please restart your terminal."
 } else {
     Write-Host "ShellLite is already in your PATH."
 }
+
+$UserPathext = [Environment]::GetEnvironmentVariable("PATHEXT", "User")
+$PathextEntries = if ($UserPathext) { ($UserPathext -split ';') | Where-Object { $_ } } else { @() }
+if ($PathextEntries -notcontains ".SHL") {
+    $NewPathext = if ($UserPathext) { "$UserPathext;.SHL" } else { ".SHL" }
+    [Environment]::SetEnvironmentVariable("PATHEXT", $NewPathext, "User")
+}
+
 Write-Host "`nInstallation complete! You can now run 'shlcpp' from any terminal." -ForegroundColor Green

shell_lite/arena.hpp

@@ -12,7 +12,7 @@ namespace shell_lite {
 
 class Arena {
 public:
-    static constexpr size_t DEFAULT_ARENA_CHUNK_SIZE = 1024 * 1024; // 1MB default chunk size
+    static constexpr size_t DEFAULT_ARENA_CHUNK_SIZE = 64 * 1024;
 
     explicit Arena(size_t chunk_size = DEFAULT_ARENA_CHUNK_SIZE) : chunk_size_(chunk_size) {
         alloc_chunk();
@@ -80,6 +80,7 @@ class Arena {
         chunks_.push_back(chunk);
         current_ptr_ = chunk;
         end_ptr_ = chunk + cap;
+        chunk_size_ = (std::min)(chunk_size_ * 2, static_cast<size_t>(1024 * 1024));
     }
 
     size_t remaining_capacity() const {

shell_lite/compiler.cpp

@@ -28,6 +28,15 @@ struct CompilerState {
     function->name = name;
     function->source_file = source_file;
     locals.push_back({"", 0});
+    if (vm && function) {
+      vm->arena().push_temp_root(function);
+    }
+  }
+
+  ~CompilerState() {
+    if (vm && function) {
+      vm->arena().remove_temp_root(function);
+    }
   }
 };
 
@@ -433,10 +442,11 @@ class ProperCompiler : public Visitor {
     func->upvalue_count = (int)state->upvalues.size();
     std::vector<Upvalue> uvs = state->upvalues;
     state = old;
+    uint16_t const_idx = make_constant(Value(func));
     delete sub;
 
     emit_byte(OP_CLOSURE);
-    emit_short(make_constant(Value(func)));
+    emit_short(const_idx);
     for (auto &uv : uvs) {
       emit_byte(uv.is_local ? 1 : 0);
       emit_short(uv.index);
@@ -1035,9 +1045,10 @@ class ProperCompiler : public Visitor {
     func->upvalue_count = (int)state->upvalues.size();
     std::vector<Upvalue> uvs = state->upvalues;
     state = old;
+    uint16_t const_idx = make_constant(Value(func));
     delete sub;
     emit_byte(OP_CLOSURE);
-    emit_short(make_constant(Value(func)));
+    emit_short(const_idx);
     for (auto &uv : uvs) {
       emit_byte(uv.is_local ? 1 : 0);
       emit_short(uv.index);
@@ -1243,10 +1254,11 @@ class ProperCompiler : public Visitor {
       func->upvalue_count = (int)state->upvalues.size();
       std::vector<Upvalue> uvs = state->upvalues;
       state = old;
+      uint16_t const_idx = make_constant(Value(func));
       delete sub;
 
       emit_byte(OP_CLOSURE);
-      emit_short(make_constant(Value(func)));
+      emit_short(const_idx);
       for (auto &uv : uvs) {
         emit_byte(uv.is_local ? 1 : 0);
         emit_short(uv.index);

shell_lite/gc.cpp

@@ -106,6 +106,23 @@ void GCArena::transfer_to(GCArena& target) {
     strings_.clear();
 }
 
+void GCArena::push_temp_root(GCObject* obj) {
+    if (!obj) return;
+    std::lock_guard<std::recursive_mutex> lock(gc_mutex_);
+    temp_roots_.push_back(obj);
+}
+
+void GCArena::remove_temp_root(GCObject* obj) {
+    if (!obj) return;
+    std::lock_guard<std::recursive_mutex> lock(gc_mutex_);
+    for (auto it = temp_roots_.rbegin(); it != temp_roots_.rend(); ++it) {
+        if (*it == obj) {
+            temp_roots_.erase((it + 1).base());
+            return;
+        }
+    }
+}
+
 static size_t get_object_live_bytes(GCObject* obj) {
     if (!obj) return 0;
     size_t sz = get_object_size(obj);
@@ -163,6 +180,12 @@ void GCArena::collect_internal() {
         vm_->mark_roots();
     }
 
+    for (GCObject* root : temp_roots_) {
+        if (root) {
+            Value(root).mark();
+        }
+    }
+
     GCObject* prev = nullptr;
     GCObject* curr = first_object_;
     size_t new_object_count = 0;

shell_lite/gc.hpp

@@ -73,16 +73,57 @@ class GCArena {
     void collect();
     void transfer_to(GCArena& target);
 
+    void push_temp_root(GCObject* obj);
+    void remove_temp_root(GCObject* obj);
+
 private:
     void collect_internal();
 
     GCObject* first_object_ = nullptr;
     std::unordered_map<std::string, ObjString*> strings_;
+    std::vector<GCObject*> temp_roots_;
     VM* vm_;
 
     size_t bytes_allocated_;
     size_t next_gc_;
     std::recursive_mutex gc_mutex_;
 };
 
+class GCRootGuard {
+public:
+    explicit GCRootGuard(GCArena& arena, GCObject* obj = nullptr)
+        : arena_(&arena), obj_(obj) {
+        if (arena_ && obj_) arena_->push_temp_root(obj_);
+    }
+    ~GCRootGuard() {
+        if (arena_ && obj_) arena_->remove_temp_root(obj_);
+    }
+    void reset(GCObject* new_obj) {
+        if (arena_ && obj_) arena_->remove_temp_root(obj_);
+        obj_ = new_obj;
+        if (arena_ && obj_) arena_->push_temp_root(obj_);
+    }
+    GCObject* get() const { return obj_; }
+
+    GCRootGuard(const GCRootGuard&) = delete;
+    GCRootGuard& operator=(const GCRootGuard&) = delete;
+    GCRootGuard(GCRootGuard&& o) noexcept : arena_(o.arena_), obj_(o.obj_) {
+        o.arena_ = nullptr;
+        o.obj_ = nullptr;
+    }
+    GCRootGuard& operator=(GCRootGuard&& o) noexcept {
+        if (this != &o) {
+            if (arena_ && obj_) arena_->remove_temp_root(obj_);
+            arena_ = o.arena_;
+            obj_ = o.obj_;
+            o.arena_ = nullptr;
+            o.obj_ = nullptr;
+        }
+        return *this;
+    }
+private:
+    GCArena* arena_;
+    GCObject* obj_;
+};
+
 }

shell_lite/modules/module_db.cpp

@@ -139,8 +139,10 @@ void register_stdlib_db(VM* vm) {
         }
 
         auto result_list = vm->arena().allocate<ObjList>();
+        GCRootGuard res_guard(vm->arena(), result_list);
         while (sqlite3_step(stmt) == SQLITE_ROW) {
             auto row_dict = vm->arena().allocate<ObjDict>();
+            result_list->elements.push_back(Value(row_dict));
             int cols = sqlite3_column_count(stmt);
             for (int i = 0; i < cols; ++i) {
                 std::string col_name = sqlite3_column_name(stmt, i);
@@ -153,7 +155,6 @@ void register_stdlib_db(VM* vm) {
                 }
                 else row_dict->elements[col_name] = Value();
             }
-            result_list->elements.push_back(Value(row_dict));
         }
         sqlite3_finalize(stmt);
         return Value(result_list);
@@ -254,6 +255,7 @@ void register_stdlib_db(VM* vm) {
         }
         sqlite3_stmt* stmt = nullptr;
         auto result_list = vm->arena().allocate<ObjList>();
+        GCRootGuard res_guard(vm->arena(), result_list);
         if (sqlite3_prepare_v2(conn, q.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
             int idx = 1;
             for (auto& val : where_info.second) {
@@ -265,6 +267,7 @@ void register_stdlib_db(VM* vm) {
 
             while (sqlite3_step(stmt) == SQLITE_ROW) {
                 auto row_dict = vm->arena().allocate<ObjDict>();
+                result_list->elements.push_back(Value(row_dict));
                 int cols = sqlite3_column_count(stmt);
                 for (int i = 0; i < cols; ++i) {
                     std::string col_name = sqlite3_column_name(stmt, i);
@@ -277,7 +280,6 @@ void register_stdlib_db(VM* vm) {
                     }
                     else row_dict->elements[col_name] = Value();
                 }
-                result_list->elements.push_back(Value(row_dict));
             }
             sqlite3_finalize(stmt);
         } else {

shell_lite/modules/module_web.cpp

@@ -43,23 +43,27 @@ static bool match_route_pattern(const std::string& pattern, const std::string& a
 static Value build_request_dict(VM* vm, const httplib::Request& req,
                                 const std::unordered_map<std::string, std::string>& params) {
     auto* d = vm->arena().allocate<ObjDict>();
+    GCRootGuard guard_d(vm->arena(), d);
     d->elements["method"] = Value(vm->arena().allocate_string(req.method));
     d->elements["path"] = Value(vm->arena().allocate_string(req.path));
     d->elements["body"] = Value(vm->arena().allocate_string(req.body));
 
     auto* p_dict = vm->arena().allocate<ObjDict>();
+    GCRootGuard guard_p(vm->arena(), p_dict);
     for (const auto& pair : params) {
         p_dict->elements[pair.first] = Value(vm->arena().allocate_string(pair.second));
     }
     d->elements["params"] = Value(p_dict);
 
     auto* q_dict = vm->arena().allocate<ObjDict>();
+    GCRootGuard guard_q(vm->arena(), q_dict);
     for (const auto& pair : req.params) {
         q_dict->elements[pair.first] = Value(vm->arena().allocate_string(pair.second));
     }
     d->elements["query"] = Value(q_dict);
 
     auto* h_dict = vm->arena().allocate<ObjDict>();
+    GCRootGuard guard_h(vm->arena(), h_dict);
     for (const auto& pair : req.headers) {
         h_dict->elements[pair.first] = Value(vm->arena().allocate_string(pair.second));
     }

shell_lite/objects.hpp

@@ -131,6 +131,7 @@ struct ObjIterator : public GCObject {
       : GCObject(ObjType::ITERATOR), iterable(iter), index(0) {
     if (iterable.is_dict()) {
       auto* dict = static_cast<ObjDict*>(iterable.get_obj());
+      dict_keys.reserve(dict->elements.size());
       for (const auto& pair : dict->elements) {
         dict_keys.push_back(pair.first);
       }