IncludeCPP 4.9.4__tar.gz → 4.9.5__tar.gz

{includecpp-4.9.4 → includecpp-4.9.5}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 4.9.4
+Version: 4.9.5
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-4.9.4 → includecpp-4.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 4.9.4
+Version: 4.9.5
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-4.9.4 → includecpp-4.9.5}/includecpp/CHANGELOG.md

@@ -1,6 +1,49 @@
 # IncludeCPP Changelog
 
-## v4.9.4 (2026-01-27)
+## v4.9.5 (2026-01-27)
+
+### Variable Modifiers
+
+#### `local`, `static`, `freezed` Keywords
+- **`local`**: Forbids global reference access (`@var` returns null), allows snapshots (`%var`)
+  ```cssl
+  local int privateCounter = 0;
+  @privateCounter;  // Returns null (cannot access via @)
+  snapshot(privateCounter);
+  %privateCounter;  // Works normally
+  ```
+
+- **`static`**: Allows global reference access (`@var`), forbids snapshots (`%var` returns null)
+  ```cssl
+  static int cachedValue = 42;
+  @cachedValue;     // Works normally
+  %cachedValue;     // Returns null (cannot snapshot)
+  ```
+
+- **`local static`**: Forbids both `@` and `%` access
+  ```cssl
+  local static int internalOnly = 100;
+  @internalOnly;    // Returns null
+  %internalOnly;    // Returns null
+  ```
+
+- **`freezed`**: Creates immutable variables (reassignment returns null)
+  ```cssl
+  freezed string constant = "immutable";
+  constant = "new value";  // Returns null (no change made)
+  ```
+
+### Function Modifier Fixes
+
+#### `undefined` and `super` Error Handling
+- **Per-statement error handling**: `undefined` and `super` modifiers now catch errors on each statement and continue execution
+  ```cssl
+  undefined define SafeFunc() {
+      d = ?nonexistent;  // Error swallowed, continues
+      x = 2;             // Executes
+      return x;          // Returns 2
+  }
+  ```
 
 ### Generator Enhancements
 

{includecpp-4.9.4 → includecpp-4.9.5}/includecpp/__init__.py

@@ -5,7 +5,7 @@ import os
 import sys
 from pathlib import Path
 
-__version__ = "4.9.4"
+__version__ = "4.9.5"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

{includecpp-4.9.4 → includecpp-4.9.5}/includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 4.9.3 | A modern scripting language with C++-style syntax featuring async/await, generators, CodeInfusion, BruteInjection, Snapshots, Python/C++ Interop, Multi-Language Support, and 330+ built-in functions.
+> Version 4.9.5 | A modern scripting language with C++-style syntax featuring async/await, generators, CodeInfusion, BruteInjection, Snapshots, Variable Modifiers (local/static/freezed), Python/C++ Interop, Multi-Language Support, and 330+ built-in functions.
 
 ---
 
@@ -368,6 +368,45 @@ snapshot(myVar);
 printl(%myVar);  // Access snapshotted value
 ```
 
+### Variable Modifiers (v4.9.4)
+
+Control how variables can be accessed and modified with special modifiers:
+
+```cssl
+// local - forbids global reference (@), allows snapshot (%)
+local int privateCounter = 0;
+@privateCounter;  // Returns null (cannot access via @)
+snapshot(privateCounter);
+%privateCounter;  // Works normally
+
+// static - allows global reference (@), forbids snapshot (%)
+static int cachedValue = 42;
+@cachedValue;     // Works normally
+snapshot(cachedValue);
+%cachedValue;     // Returns null (cannot snapshot)
+
+// local static - forbids both @ and % access
+local static int internalOnly = 100;
+@internalOnly;    // Returns null
+%internalOnly;    // Returns null
+
+// freezed - creates immutable variable (cannot be reassigned)
+freezed string constant = "immutable";
+constant = "new value";  // Returns null (cannot reassign)
+
+// Combine modifiers
+freezed local int secretConst = 999;  // Immutable and no global access
+```
+
+**Modifier Summary:**
+| Modifier | `@var` (global) | `%var` (snapshot) | Reassignment |
+|----------|-----------------|-------------------|--------------|
+| (none)   | ✓ allowed       | ✓ allowed         | ✓ allowed    |
+| `local`  | ✗ returns null  | ✓ allowed         | ✓ allowed    |
+| `static` | ✓ allowed       | ✗ returns null    | ✓ allowed    |
+| `local static` | ✗ returns null | ✗ returns null | ✓ allowed  |
+| `freezed`| ✓ allowed       | ✓ allowed         | ✗ returns null |
+
 ---
 
 ## Operators

{includecpp-4.9.4 → includecpp-4.9.5}/includecpp/core/cssl/cssl_builtins.py

@@ -243,6 +243,7 @@ class CSSLBuiltins:
 
         # Type checking
         self._functions['typeof'] = self.builtin_typeof
+        self._functions['nameof'] = self.builtin_nameof  # v4.9.4: Get name of function/class/object
         self._functions['memory'] = self.builtin_memory  # v4.8.9: Python repr() for debugging
         self._functions['address'] = self.builtin_address  # v4.9.0: Get address of object
         self._functions['reflect'] = self.builtin_reflect  # v4.9.0: Reflect address to object
@@ -879,6 +880,65 @@ class CSSLBuiltins:
         }
         return type_map.get(type(value), type(value).__name__)
 
+    def builtin_nameof(self, value: Any) -> str:
+        """Get the name of a function, class, or object.
+
+        v4.9.4: Returns the identifier name for reflection/debugging.
+
+        For functions: returns the function name
+        For classes: returns the class name
+        For instances: returns the class name
+        For AST nodes: returns the name from the node value
+        For other objects: returns the type name
+
+        Example:
+            define myFunc() { }
+            printl(nameof(myFunc));  // "myFunc"
+
+            class MyClass { }
+            printl(nameof(MyClass)); // "MyClass"
+
+            MyClass obj = new MyClass();
+            printl(nameof(obj));     // "MyClass"
+        """
+        from .cssl_parser import ASTNode
+        from .cssl_types import CSSLInstance
+
+        # AST function node
+        if isinstance(value, ASTNode):
+            if value.type == 'function':
+                func_info = value.value
+                if isinstance(func_info, dict):
+                    return func_info.get('name', '<anonymous>')
+                return str(func_info) if func_info else '<anonymous>'
+            elif value.type == 'class':
+                class_info = value.value
+                if isinstance(class_info, dict):
+                    return class_info.get('name', '<anonymous>')
+                return str(class_info) if class_info else '<anonymous>'
+            elif value.type == 'identifier':
+                return value.value
+            return value.type
+
+        # CSSL class instance
+        if isinstance(value, CSSLInstance):
+            return value._class.name if hasattr(value, '_class') else type(value).__name__
+
+        # CSSL class definition (stored as dict with 'name' key)
+        if isinstance(value, dict) and 'name' in value:
+            return value['name']
+
+        # Python callable (function)
+        if callable(value):
+            if hasattr(value, '__name__'):
+                return value.__name__
+            if hasattr(value, 'name'):
+                return value.name
+            return type(value).__name__
+
+        # Fallback to type name
+        return type(value).__name__
+
     def builtin_memory(self, value: Any) -> dict:
         """Get memory/introspection info about a value as a dictionary.
 
@@ -1069,7 +1129,8 @@ class CSSLBuiltins:
         Returns:
             The result of the last expression or explicit return
         """
-        if not self._runtime:
+        # v4.9.4: Fix attribute name - use self.runtime not self._runtime
+        if not self.runtime:
             return None
 
         try:
@@ -1083,17 +1144,17 @@ class CSSLBuiltins:
             # Inject context variables into scope if provided
             if context and isinstance(context, dict):
                 for name, value in context.items():
-                    self._runtime.scope.set(name, value)
+                    self.runtime.scope.set(name, value)
 
             # Execute each statement
             result = None
             for node in ast.children:
-                result = self._runtime._execute(node)
+                result = self.runtime._execute_node(node)
                 # Check for early return
-                if self._runtime._return_triggered:
-                    result = self._runtime._return_value
-                    self._runtime._return_triggered = False
-                    self._runtime._return_value = None
+                if self.runtime._return_triggered:
+                    result = self.runtime._return_value
+                    self.runtime._return_triggered = False
+                    self.runtime._return_value = None
                     break
 
             return result
@@ -1503,10 +1564,18 @@ class CSSLBuiltins:
     # ============= Time Functions =============
 
     def builtin_now(self) -> float:
-        return time.time()
+        import sys
+        result = time.time()
+        sys.stderr.write(f"[DEBUG] builtin_now() called, returning {result}\n")
+        sys.stderr.flush()
+        return result
 
     def builtin_timestamp(self) -> int:
-        return int(time.time())
+        import sys
+        result = int(time.time())
+        sys.stderr.write(f"[DEBUG] builtin_timestamp() called, returning {result}\n")
+        sys.stderr.flush()
+        return result
 
     def builtin_sleep(self, seconds: float) -> None:
         time.sleep(seconds)
@@ -4701,6 +4770,8 @@ class CSSLBuiltins:
 
         After snapshotting, access the value with %name syntax.
 
+        v4.9.4: Variables marked as 'static' cannot be snapshotted (returns False, no error)
+
         Example:
             string version = "1.0";
             snapshot(version);
@@ -4739,6 +4810,10 @@ class CSSLBuiltins:
             # Use a generic name based on type and hash
             name = f"_snap_{type(value).__name__}_{id(value)}"
 
+        # v4.9.4: Check if variable is marked as 'static' - cannot be snapshotted
+        if self.runtime and name in self.runtime._var_meta and self.runtime._var_meta[name].get('is_static', False):
+            return False  # static variables cannot be snapshotted
+
         # Deep copy to preserve the state
         try:
             snapped_value = copy.deepcopy(value)