IncludeCPP 4.2.2__py3-none-any.whl → 4.5.2__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -15,7 +15,7 @@ from .cssl_modules import get_module_registry, get_standard_module
 from .cssl_types import (
     Parameter, DataStruct, Shuffled, Iterator, Combo,
     Stack, Vector, Array, DataSpace, OpenQuote, List, Dictionary, Map,
-    CSSLClass, CSSLInstance
+    CSSLClass, CSSLInstance, ByteArrayed
 )
 
 
@@ -199,6 +199,13 @@ class CSSLReturn(Exception):
         super().__init__()
 
 
+class CSSLThrow(Exception):
+    """Throw statement - v4.5.1: User-thrown exceptions that propagate to catch blocks"""
+    def __init__(self, message: Any = None):
+        self.message = message
+        super().__init__(str(message) if message else "")
+
+
 @dataclass
 class Scope:
     """Variable scope"""
@@ -532,6 +539,10 @@ class CSSLRuntime:
                 self._exec_struct(child)
             elif child.type == 'class':
                 self._exec_class(child)
+            elif child.type == 'enum':
+                self._exec_enum(child)
+            elif child.type == 'bytearrayed':
+                self._exec_bytearrayed(child)
             elif child.type == 'function':
                 self._exec_function(child)
             elif child.type == 'global_assignment':
@@ -813,6 +824,123 @@ class CSSLRuntime:
 
         return struct_data
 
+    def _exec_enum(self, node: ASTNode) -> Dict[str, Any]:
+        """Execute enum declaration - registers enum values in scope.
+
+        Creates a dictionary-like enum object accessible via EnumName::VALUE syntax.
+
+        Example:
+            enum Colors { RED, GREEN, BLUE }
+            Colors::RED  // returns 0
+            Colors::GREEN  // returns 1
+
+        v4.3.2: Support for embedded enum modification:
+            embedded __NewEnum &OldEnum { ... }       // Replace OldEnum
+            embedded __NewEnum &OldEnum ++ { ... }    // Add to OldEnum
+            embedded __NewEnum &OldEnum -- { ... }    // Remove from OldEnum
+        """
+        enum_info = node.value
+        enum_name = enum_info.get('name')
+        members = enum_info.get('members', [])
+        is_embedded = enum_info.get('is_embedded', False)
+        replace_target = enum_info.get('replace_target')
+        mode = enum_info.get('mode', 'replace')
+
+        # Create enum object as a dict-like object with members
+        new_values = {}
+        for member in members:
+            member_name = member['name']
+            member_value = member['value']
+            # Evaluate if value is an ASTNode
+            if isinstance(member_value, ASTNode):
+                member_value = self._evaluate(member_value)
+            new_values[member_name] = member_value
+
+        # v4.3.2: Handle embedded modification
+        if is_embedded and replace_target:
+            target_name = replace_target.lstrip('@') if replace_target.startswith('@') else replace_target
+
+            if mode == 'add':
+                # Get existing enum and add new values
+                existing = self.scope.get(target_name) or self.global_scope.get(target_name) or {}
+                if isinstance(existing, dict):
+                    # For add mode, auto-increment from highest existing int value
+                    max_val = -1
+                    for v in existing.values():
+                        if isinstance(v, int) and v > max_val:
+                            max_val = v
+                    # Update new values that don't have explicit values
+                    for name, val in new_values.items():
+                        if isinstance(val, int) and val <= max_val:
+                            max_val += 1
+                            new_values[name] = max_val
+                    enum_obj = {**existing, **new_values}
+                else:
+                    enum_obj = new_values
+            elif mode == 'remove':
+                # Get existing enum and remove specified keys
+                existing = self.scope.get(target_name) or self.global_scope.get(target_name) or {}
+                if isinstance(existing, dict):
+                    enum_obj = {k: v for k, v in existing.items() if k not in new_values}
+                else:
+                    enum_obj = {}
+            else:
+                # Replace mode - just use new values
+                enum_obj = new_values
+
+            self.scope.set(target_name, enum_obj)
+            self.global_scope.set(target_name, enum_obj)
+            if replace_target.startswith('@'):
+                self._promoted_globals[target_name] = enum_obj
+        else:
+            # Regular enum - just register it
+            enum_obj = new_values
+            self.scope.set(enum_name, enum_obj)
+            self.global_scope.set(enum_name, enum_obj)
+
+        return enum_obj
+
+    def _exec_bytearrayed(self, node: ASTNode) -> 'ByteArrayed':
+        """Execute bytearrayed declaration - function-to-byte mapping with pattern matching.
+
+        Creates a ByteArrayed object that:
+        - Maps function references to byte positions (0x0, 0x1, etc.)
+        - Executes functions "invisibly" when called to get return values
+        - Matches case patterns based on return values
+        - Supports indexing: MyBytes["0x0"] or MyBytes[0]
+
+        Example:
+            bytearrayed MyBytes {
+                &func1;           // 0x0
+                &func2;           // 0x1
+                case {0, 1} {     // func1=0, func2=1
+                    printl("Match!");
+                }
+            }
+            MyBytes();            // Execute pattern matching
+            x = MyBytes["0x0"];   // Get value at position 0
+        """
+        info = node.value
+        name = info.get('name')
+        func_refs = info.get('func_refs', [])
+        cases = info.get('cases', [])
+        default_block = info.get('default')
+
+        # Create ByteArrayed object
+        bytearrayed_obj = ByteArrayed(
+            name=name,
+            func_refs=func_refs,
+            cases=cases,
+            default_block=default_block,
+            runtime=self
+        )
+
+        # Register in scope
+        self.scope.set(name, bytearrayed_obj)
+        self.global_scope.set(name, bytearrayed_obj)
+
+        return bytearrayed_obj
+
     def _exec_class(self, node: ASTNode) -> CSSLClass:
         """Execute class definition - registers class in scope.
 
@@ -942,6 +1070,22 @@ class CSSLRuntime:
             self.global_scope.set(class_name, class_def)
             self._promoted_globals[class_name] = class_def
 
+        # v4.2.5: Handle &target replacement for classes
+        # embedded class MyClass &$Target { } - immediate replacement
+        # class MyClass &$Target { } - deferred until instantiation
+        append_ref_class = class_info.get('append_ref_class')
+        is_embedded = class_info.get('is_embedded', False)
+        if append_ref_class and is_embedded:
+            append_ref_member = class_info.get('append_ref_member')
+            self._overwrite_class_target(append_ref_class, append_ref_member, class_def)
+            class_def._target_applied = True
+        elif append_ref_class:
+            # Store reference info for deferred replacement
+            class_def._pending_target = {
+                'append_ref_class': append_ref_class,
+                'append_ref_member': class_info.get('append_ref_member')
+            }
+
         # Handle class overwrites - replace methods in target class
         if overwrites_class_name:
             self._apply_class_overwrites(
@@ -1164,13 +1308,18 @@ class CSSLRuntime:
         # Handle &Class::method syntax
         # Without ++ = full replacement
         # With ++ = append (run original first, then new code)
-        if append_ref_class:
+        # v4.2.5: Only do immediate replacement if is_embedded=True
+        #         For regular 'define', replacement is deferred until function is called
+        is_embedded = func_info.get('is_embedded', False)
+        if append_ref_class and is_embedded:
             if append_mode:
                 # Append mode: wrap original to run original + new
                 self._append_to_target(append_ref_class, append_ref_member, node)
             else:
                 # Full replacement
                 self._overwrite_target(append_ref_class, append_ref_member, node)
+            # Mark as already applied so we don't apply again on call
+            node.value['_target_applied'] = True
 
         # Handle overwrites keyword - replace the target function
         if overwrites_func:
@@ -1215,6 +1364,34 @@ class CSSLRuntime:
             return self._call_function(func_node, list(args), kwargs)
         return wrapper
 
+    def _create_python_method_wrapper(self, func_node: ASTNode, python_obj):
+        """Create a Python-callable wrapper that passes python_obj as 'this'.
+
+        v4.3.0: Used when replacing Python object methods with CSSL functions.
+        The wrapper ensures 'this->' in CSSL refers to the Python object.
+        """
+        runtime = self
+        _captured_obj = python_obj
+
+        def wrapper(*args, **kwargs):
+            # Save current instance context
+            old_instance = runtime._current_instance
+            old_this = runtime.scope.get('this')
+            try:
+                # Set Python object as current instance for this-> access
+                runtime._current_instance = _captured_obj
+                runtime.scope.set('this', _captured_obj)
+                return runtime._call_function(func_node, list(args), kwargs)
+            finally:
+                # Restore previous context
+                runtime._current_instance = old_instance
+                if old_this is not None:
+                    runtime.scope.set('this', old_this)
+                elif 'this' in runtime.scope.variables:
+                    del runtime.scope.variables['this']
+
+        return wrapper
+
     def _overwrite_target(self, ref_class: str, ref_member: str, replacement_node: ASTNode):
         """Overwrite a class method or function with the replacement.
 
@@ -1222,9 +1399,50 @@ class CSSLRuntime:
         - &ClassName::method - Overwrite method in CSSL class
         - &$PyObject.method - Overwrite method in Python shared object
         - &functionName - Overwrite standalone function
+
+        v4.2.6: In namespace mode (_payload_namespace_mode), track replacements
+        instead of applying globally. The namespace handler will scope them.
+
+        v4.5.1: Respects 'private' modifier - private functions/methods cannot be overwritten.
         """
         from ..cssl_bridge import _live_objects, SharedObjectProxy
 
+        # v4.5.1: Check if target has 'private' modifier - prevent overwrite
+        if not ref_class.startswith('$'):
+            target_func = self.scope.get(ref_class) or self.global_scope.get(ref_class)
+            if target_func is not None:
+                # Check for function with private modifier
+                if hasattr(target_func, 'value') and isinstance(target_func.value, dict):
+                    modifiers = target_func.value.get('modifiers', [])
+                    if 'private' in modifiers:
+                        raise CSSLRuntimeError(
+                            f"Cannot overwrite private function '{ref_class}' - "
+                            f"private functions are protected from embedded replacements"
+                        )
+                # Check for class with private method
+                if ref_member and isinstance(target_func, CSSLClass):
+                    method = target_func.methods.get(ref_member) if hasattr(target_func, 'methods') else None
+                    if method and hasattr(method, 'value') and isinstance(method.value, dict):
+                        modifiers = method.value.get('modifiers', [])
+                        if 'private' in modifiers:
+                            raise CSSLRuntimeError(
+                                f"Cannot overwrite private method '{ref_class}::{ref_member}' - "
+                                f"private methods are protected from embedded replacements"
+                            )
+
+        # v4.2.6: Check for namespace mode
+        namespace_mode = getattr(self, '_payload_namespace_mode', None)
+        if namespace_mode and ref_member is None and not ref_class.startswith('$'):
+            # Standalone function replacement in namespace mode
+            # Track it for the namespace handler
+            if not hasattr(self, '_namespace_replacements'):
+                self._namespace_replacements = {}
+            self._namespace_replacements[ref_class] = replacement_node
+            # Still register the function normally (namespace handler will move it)
+            self.scope.set(ref_class, replacement_node)
+            self.global_scope.set(ref_class, replacement_node)
+            return
+
         # Handle Python shared objects
         if ref_class.startswith('$'):
             var_name = ref_class[1:]
@@ -1241,7 +1459,8 @@ class CSSLRuntime:
 
             # Overwrite Python object method
             if ref_member and hasattr(ref_obj, ref_member):
-                wrapper = self._create_python_wrapper(replacement_node)
+                # v4.3.0: Create wrapper that passes Python object as 'this' context
+                wrapper = self._create_python_method_wrapper(replacement_node, ref_obj)
                 try:
                     setattr(ref_obj, ref_member, wrapper)
                 except (AttributeError, TypeError):
@@ -1250,12 +1469,49 @@ class CSSLRuntime:
 
         # Handle CSSL class method overwrite
         target_class = self.scope.get(ref_class) or self.global_scope.get(ref_class)
-        if target_class is None:
-            # Maybe it's a standalone function reference (no ::member)
-            if ref_member is None:
-                # &functionName - overwrite the function
+
+        # v4.2.3: Handle standalone function reference (&functionName) including builtins
+        if ref_member is None:
+            # Check if this is a builtin function
+            is_builtin = hasattr(self, 'builtins') and self.builtins.has_function(ref_class)
+
+            # Check if target_class is NOT a CSSLClass (it's either a function/builtin or None)
+            is_cssl_class = isinstance(target_class, CSSLClass)
+            # v4.2.5: Also check if target is a CSSL function (ASTNode with type 'function')
+            is_cssl_function = (hasattr(target_class, 'type') and target_class.type == 'function')
+
+            if is_builtin or (target_class is None) or (not is_cssl_class and callable(target_class)) or is_cssl_function:
+                # v4.2.3: CRITICAL - Store original BEFORE overwriting for %name captures
+                # This ensures %exit() refers to the ORIGINAL exit, not the replacement
+                if ref_class not in self._original_functions:
+                    if is_builtin:
+                        # Store the original builtin from _functions dict
+                        # (handles aliases like printl -> builtin_println)
+                        original_builtin = self.builtins._functions.get(ref_class)
+                        if original_builtin is not None:
+                            self._original_functions[ref_class] = original_builtin
+                    elif is_cssl_function:
+                        # v4.2.5: Store original CSSL function (ASTNode)
+                        self._original_functions[ref_class] = target_class
+                    elif target_class is not None and callable(target_class):
+                        # Store the original function/callable
+                        self._original_functions[ref_class] = target_class
+
+                # &functionName - overwrite the function/builtin
                 self.scope.set(ref_class, replacement_node)
                 self.global_scope.set(ref_class, replacement_node)
+
+                # Also overwrite in builtins dict if it's a builtin
+                if is_builtin:
+                    # Create wrapper that calls CSSL function instead of builtin
+                    def make_wrapper(node, runtime):
+                        def wrapper(*args, **kwargs):
+                            return runtime._call_function(node, list(args), kwargs)
+                        return wrapper
+                    self.builtins._functions[ref_class] = make_wrapper(replacement_node, self)
+                return
+
+        if target_class is None:
             return
 
         if isinstance(target_class, CSSLClass) and ref_member:
@@ -1277,9 +1533,34 @@ class CSSLRuntime:
         - &ClassName::method ++ - Append to method in CSSL class
         - &$PyObject.method ++ - Append to method in Python shared object
         - &functionName ++ - Append to standalone function
+
+        v4.5.1: Respects 'private' modifier - private functions/methods cannot be appended to.
         """
         from ..cssl_bridge import _live_objects, SharedObjectProxy
 
+        # v4.5.1: Check if target has 'private' modifier - prevent append
+        if not ref_class.startswith('$'):
+            target_func = self.scope.get(ref_class) or self.global_scope.get(ref_class)
+            if target_func is not None:
+                # Check for function with private modifier
+                if hasattr(target_func, 'value') and isinstance(target_func.value, dict):
+                    modifiers = target_func.value.get('modifiers', [])
+                    if 'private' in modifiers:
+                        raise CSSLRuntimeError(
+                            f"Cannot append to private function '{ref_class}' - "
+                            f"private functions are protected from embedded modifications"
+                        )
+                # Check for class with private method
+                if ref_member and isinstance(target_func, CSSLClass):
+                    method = target_func.methods.get(ref_member) if hasattr(target_func, 'methods') else None
+                    if method and hasattr(method, 'value') and isinstance(method.value, dict):
+                        modifiers = method.value.get('modifiers', [])
+                        if 'private' in modifiers:
+                            raise CSSLRuntimeError(
+                                f"Cannot append to private method '{ref_class}::{ref_member}' - "
+                                f"private methods are protected from embedded modifications"
+                            )
+
         # Handle Python shared objects
         if ref_class.startswith('$'):
             var_name = ref_class[1:]
@@ -1357,6 +1638,58 @@ class CSSLRuntime:
                         target_class.members[i] = append_node
                         break
 
+    def _overwrite_class_target(self, ref_class: str, ref_member: str, replacement_class: 'CSSLClass'):
+        """Overwrite a target class with the replacement class.
+
+        v4.2.5: Used by 'embedded class' with &target syntax.
+        Handles:
+        - &ClassName - Overwrite CSSL class
+        - &$PyObject - Overwrite Python shared object
+
+        v4.2.6: In namespace mode, track replacements instead of applying globally.
+        """
+        from ..cssl_bridge import _live_objects, SharedObjectProxy
+
+        # v4.2.6: Check for namespace mode
+        namespace_mode = getattr(self, '_payload_namespace_mode', None)
+        if namespace_mode and not ref_class.startswith('$') and not ref_class.startswith('@'):
+            # Class replacement in namespace mode
+            # Track it for the namespace handler
+            if not hasattr(self, '_namespace_replacements'):
+                self._namespace_replacements = {}
+            self._namespace_replacements[ref_class] = replacement_class
+            # Still register the class normally (namespace handler will move it)
+            self.scope.set(ref_class, replacement_class)
+            self.global_scope.set(ref_class, replacement_class)
+            return
+
+        # Handle Python shared objects
+        if ref_class.startswith('$'):
+            var_name = ref_class[1:]
+            # Replace the shared object with the new class
+            _live_objects[var_name] = replacement_class
+            self.scope.set(var_name, replacement_class)
+            self.global_scope.set(var_name, replacement_class)
+            return
+
+        # Handle @ prefix (global reference)
+        if ref_class.startswith('@'):
+            var_name = ref_class[1:]
+            self.global_scope.set(var_name, replacement_class)
+            self._promoted_globals[var_name] = replacement_class
+            return
+
+        # Handle regular class reference
+        target_class = self.scope.get(ref_class)
+        if target_class is None:
+            target_class = self.global_scope.get(ref_class)
+
+        # Replace the class definition
+        self.scope.set(ref_class, replacement_class)
+        self.global_scope.set(ref_class, replacement_class)
+        if ref_class in self._promoted_globals:
+            self._promoted_globals[ref_class] = replacement_class
+
     def _exec_typed_declaration(self, node: ASTNode) -> Any:
         """Execute typed variable declaration: type<T> varName = value;
 
@@ -1638,6 +1971,18 @@ class CSSLRuntime:
         modifiers = func_info.get('modifiers', [])
         kwargs = kwargs or {}
 
+        # v4.2.5: Deferred &target replacement for non-embedded functions
+        # If function has &target and hasn't been applied yet, apply now on first call
+        append_ref_class = func_info.get('append_ref_class')
+        if append_ref_class and not func_info.get('_target_applied', False):
+            append_mode = func_info.get('append_mode', False)
+            append_ref_member = func_info.get('append_ref_member')
+            if append_mode:
+                self._append_to_target(append_ref_class, append_ref_member, func_node)
+            else:
+                self._overwrite_target(append_ref_class, append_ref_member, func_node)
+            func_node.value['_target_applied'] = True
+
         # Check for undefined modifier - suppress errors if present
         is_undefined = 'undefined' in modifiers
 
@@ -2012,6 +2357,141 @@ class CSSLRuntime:
 
         return None
 
+    def _exec_param_switch(self, node: ASTNode) -> Any:
+        """Execute param switch statement for open parameters.
+
+        v4.2.5: Switch on which parameters were provided.
+
+        Syntax:
+            switch(Params) {
+                case name:              // if 'name' param exists
+                case name & age:        // if both exist
+                case name & not age:    // if 'name' exists but 'age' doesn't
+                except name:            // if 'name' does NOT exist
+                default:                // fallback
+                always:                 // always runs after match
+                finally:                // cleanup, always runs
+            }
+        """
+        params_name = node.value.get('params')
+        # v4.3.2: Use the actual variable from switch(Variable), not just _OpenKwargs
+        # This allows switch(Input) where Input is the open parameter
+        if params_name == 'Params':
+            open_kwargs = self.scope.get('_OpenKwargs') or {}
+        else:
+            # Try to get kwargs from the named variable
+            open_kwargs = self.scope.get(params_name)
+            if open_kwargs is None:
+                open_kwargs = self.scope.get('_OpenKwargs') or {}
+            elif not isinstance(open_kwargs, dict):
+                # If it's not a dict, try _OpenKwargs as fallback
+                open_kwargs = self.scope.get('_OpenKwargs') or {}
+
+        matched = False
+        always_node = None
+        finally_node = None
+        default_node = None
+
+        # First pass: find always, finally, default nodes
+        for child in node.children:
+            if child.type == 'param_always':
+                always_node = child
+            elif child.type == 'param_finally':
+                finally_node = child
+            elif child.type == 'param_default':
+                default_node = child
+
+        try:
+            # Execute matching cases
+            for child in node.children:
+                if child.type == 'param_case':
+                    condition = child.value.get('condition')
+                    if self._eval_param_condition(condition, open_kwargs):
+                        matched = True
+                        try:
+                            for stmt in child.children:
+                                self._execute_node(stmt)
+                        except CSSLBreak:
+                            break
+
+            # Execute default if no match
+            if not matched and default_node:
+                try:
+                    for stmt in default_node.children:
+                        self._execute_node(stmt)
+                except CSSLBreak:
+                    pass
+
+            # Execute always block (runs after a match, before finally)
+            if matched and always_node:
+                try:
+                    for stmt in always_node.children:
+                        self._execute_node(stmt)
+                except CSSLBreak:
+                    pass
+
+        finally:
+            # Execute finally block (always runs, even on break/exception)
+            if finally_node:
+                for stmt in finally_node.children:
+                    self._execute_node(stmt)
+
+        return None
+
+    def _eval_param_condition(self, condition: dict, kwargs: dict) -> bool:
+        """Evaluate a param switch condition.
+
+        Condition types:
+            {'type': 'exists', 'param': 'name'}  -> 'name' in kwargs OR variable 'name' is truthy
+            {'type': 'not', 'param': 'name'}     -> 'name' not in kwargs AND variable 'name' is falsy
+            {'type': 'and', 'left': {...}, 'right': {...}} -> left AND right
+            {'type': 'or', 'left': {...}, 'right': {...}}  -> left OR right
+
+        v4.3.2: Added 'or' type for || operator support.
+        v4.3.2: Enhanced to check both kwargs AND scope variables (from OpenFind).
+                This allows positional args found via OpenFind<type>(index) to work
+                with param_switch conditions like 'case text & !error:'.
+        """
+        cond_type = condition.get('type')
+
+        if cond_type == 'exists':
+            param = condition.get('param')
+            # Check kwargs first
+            if param in kwargs:
+                return True
+            # Also check if a variable with this name exists in scope and is truthy
+            # This allows OpenFind results to work with param_switch
+            var_value = self.scope.get(param)
+            if var_value is not None and var_value != '' and var_value != 0 and var_value != False:
+                # Make sure it's not a builtin function
+                if not callable(var_value):
+                    return True
+            return False
+
+        elif cond_type == 'not':
+            param = condition.get('param')
+            # Check kwargs first
+            if param in kwargs:
+                return False
+            # Also check if variable is truthy (then it's "provided")
+            var_value = self.scope.get(param)
+            if var_value is not None and var_value != '' and var_value != 0 and var_value != False:
+                if not callable(var_value):
+                    return False  # Variable has value, so it IS provided
+            return True  # Not in kwargs and variable is null/empty
+
+        elif cond_type == 'and':
+            left = self._eval_param_condition(condition.get('left'), kwargs)
+            right = self._eval_param_condition(condition.get('right'), kwargs)
+            return left and right
+
+        elif cond_type == 'or':
+            left = self._eval_param_condition(condition.get('left'), kwargs)
+            right = self._eval_param_condition(condition.get('right'), kwargs)
+            return left or right
+
+        return False
+
     def _exec_return(self, node: ASTNode) -> Any:
         """Execute return statement.
 
@@ -2037,6 +2517,23 @@ class CSSLRuntime:
         """Execute continue statement"""
         raise CSSLContinue()
 
+    def _exec_throw(self, node: ASTNode) -> Any:
+        """Execute throw statement - v4.5.1
+
+        Throws a CSSLThrow exception that propagates to the nearest catch block.
+
+        Syntax:
+            throw "Error message";
+            throw errorVar;
+            throw;  // re-throw current exception
+        """
+        if node.value is None:
+            # throw; - re-throw current exception (should be in a catch block)
+            raise CSSLThrow("Re-thrown exception")
+
+        message = self._evaluate(node.value)
+        raise CSSLThrow(message)
+
     def _exec_constructor(self, node: ASTNode) -> Any:
         """Execute constructor node - only called when encountered directly.
 
@@ -2114,12 +2611,26 @@ class CSSLRuntime:
         return None
 
     def _exec_try(self, node: ASTNode) -> Any:
-        """Execute try/catch block"""
+        """Execute try/catch/finally block"""
         try:
             for child in node.children:
                 if child.type == 'try-block':
                     for stmt in child.children:
                         self._execute_node(stmt)
+        except CSSLThrow as e:
+            # v4.5.1: Handle user-thrown exceptions from throw statement
+            for child in node.children:
+                if child.type == 'catch-block':
+                    error_var = child.value.get('error_var') if child.value else None
+                    if error_var:
+                        # Store the thrown message in the error variable
+                        self.scope.set(error_var, e.message if e.message else str(e))
+                    for stmt in child.children:
+                        self._execute_node(stmt)
+                    break  # Only execute first matching catch block
+            else:
+                # No catch block found - re-raise for outer try-catch
+                raise
         except CSSLRuntimeError as e:
             for child in node.children:
                 if child.type == 'catch-block':
@@ -2128,6 +2639,27 @@ class CSSLRuntime:
                         self.scope.set(error_var, str(e))
                     for stmt in child.children:
                         self._execute_node(stmt)
+                    break
+            else:
+                raise  # Re-raise if no catch block
+        except Exception as e:
+            # v4.2.6: Also catch Python exceptions
+            for child in node.children:
+                if child.type == 'catch-block':
+                    error_var = child.value.get('error_var') if child.value else None
+                    if error_var:
+                        self.scope.set(error_var, str(e))
+                    for stmt in child.children:
+                        self._execute_node(stmt)
+                    break
+            else:
+                raise  # Re-raise if no catch block
+        finally:
+            # v4.2.6: Execute finally block if present
+            for child in node.children:
+                if child.type == 'finally-block':
+                    for stmt in child.children:
+                        self._execute_node(stmt)
 
         return None
 
@@ -2831,6 +3363,15 @@ class CSSLRuntime:
                 final_value = {**current_value, **source}
             elif isinstance(current_value, str) and isinstance(source, str):
                 final_value = current_value + source
+            # Handle CSSL container types (DataStruct, Vector, Stack, etc.)
+            elif hasattr(current_value, 'append') or hasattr(current_value, 'push') or hasattr(current_value, 'add'):
+                if hasattr(current_value, 'append'):
+                    current_value.append(source)
+                elif hasattr(current_value, 'push'):
+                    current_value.push(source)
+                elif hasattr(current_value, 'add'):
+                    current_value.add(source)
+                final_value = current_value
             elif current_value is None:
                 final_value = [source] if not isinstance(source, list) else source
             else:
@@ -3353,6 +3894,35 @@ class CSSLRuntime:
 
         if node.type == 'identifier':
             name = node.value
+
+            # Handle enum/namespace access: Colors::RED, MyNamespace::func
+            if '::' in name:
+                parts = name.split('::', 1)
+                container_name = parts[0]
+                member_name = parts[1]
+
+                # Look up the container (enum, class, or namespace)
+                container = self.scope.get(container_name)
+                if container is None:
+                    container = self.global_scope.get(container_name)
+                if container is None:
+                    container = self._promoted_globals.get(container_name)
+
+                if container is not None:
+                    # If it's a dict-like object (enum or namespace), get the member
+                    if isinstance(container, dict):
+                        return container.get(member_name)
+                    # If it's an object with the member as an attribute
+                    elif hasattr(container, member_name):
+                        return getattr(container, member_name)
+
+                # v4.3.2: Check if full name exists as builtin function (json::write, string::cut, etc.)
+                if self.builtins.has_function(name):
+                    return self.builtins.get_function(name)
+
+                # Fall through to normal lookup if container not found
+                return None
+
             value = self.scope.get(name)
             # Check if it's a class member in current instance context
             # This allows accessing members without 'this->' inside methods
@@ -3426,14 +3996,22 @@ class CSSLRuntime:
 
         if node.type == 'captured_ref':
             # %<name> captured reference - use value captured at infusion registration time
+            # Priority: The % prefix means "get the ORIGINAL value before any replacement"
             name = node.value
-            # First check captured values from current injection context
+
+            # 1. First check captured values from current injection context
             if name in self._current_captured_values:
                 captured_value = self._current_captured_values[name]
-                # Only use captured value if it's not None
                 if captured_value is not None:
                     return captured_value
-            # Fall back to normal resolution if not captured or capture was None
+
+            # 2. v4.2.3: Check _original_functions FIRST - this is the pre-replacement value
+            #    This ensures %exit() refers to the ORIGINAL exit when using &exit
+            value = self._original_functions.get(name)
+            if value is not None:
+                return value
+
+            # 3. Fall back to scope/builtins if no original was captured
             value = self.scope.get(name)
             if value is None:
                 value = self.global_scope.get(name)
@@ -3444,9 +4022,6 @@ class CSSLRuntime:
                     value = lambda code=0, rt=runtime: rt.exit(code)
                 else:
                     value = getattr(self.builtins, f'builtin_{name}', None)
-            if value is None:
-                # Check original functions (for replaced functions)
-                value = self._original_functions.get(name)
             if value is not None:
                 return value
             # Build helpful error for captured reference
@@ -3782,15 +4357,21 @@ class CSSLRuntime:
 
         if op == '/':
             r = self._to_number(right)
-            return self._to_number(left) / r if r != 0 else 0
+            if r == 0:
+                raise CSSLRuntimeError("Division by zero")
+            return self._to_number(left) / r
 
         if op == '//':
             r = self._to_number(right)
-            return self._to_number(left) // r if r != 0 else 0
+            if r == 0:
+                raise CSSLRuntimeError("Integer division by zero")
+            return self._to_number(left) // r
 
         if op == '%':
             r = self._to_number(right)
-            return self._to_number(left) % r if r != 0 else 0
+            if r == 0:
+                raise CSSLRuntimeError("Modulo by zero")
+            return self._to_number(left) % r
 
         if op == '**':
             return self._to_number(left) ** self._to_number(right)
@@ -4144,30 +4725,44 @@ class CSSLRuntime:
         )
 
     def _eval_new(self, node: ASTNode) -> CSSLInstance:
-        """Evaluate 'new ClassName(args)' or 'new @ClassName(args)' expression.
+        """Evaluate 'new ClassName(args)' or 'new @ClassName(args)' or 'new Namespace::ClassName(args)' expression.
 
         Creates a new instance of a CSSL class and calls its constructor.
         Supports multiple constructors (constr keyword), class parameters,
         and automatic parent constructor calling.
 
         With '@' prefix (new @ClassName), looks only in global scope.
+        With Namespace:: prefix, looks in the namespace dict first.
         """
         class_name = node.value.get('class')
+        namespace = node.value.get('namespace')  # v4.2.6: Namespace::ClassName support
         is_global_ref = node.value.get('is_global_ref', False)
         args = [self._evaluate(arg) for arg in node.value.get('args', [])]
         kwargs = {k: self._evaluate(v) for k, v in node.value.get('kwargs', {}).items()}
 
-        # Get class definition from scope
-        if is_global_ref:
-            # With @ prefix, only look in global scope
-            class_def = self._promoted_globals.get(class_name)
-            if class_def is None:
-                class_def = self.global_scope.get(class_name)
-        else:
-            # Normal lookup: local scope first, then global
-            class_def = self.scope.get(class_name)
-            if class_def is None:
-                class_def = self.global_scope.get(class_name)
+        class_def = None
+
+        # v4.2.6: Handle Namespace::ClassName lookup
+        if namespace:
+            # Look up namespace dict first
+            ns_dict = self.scope.get(namespace)
+            if ns_dict is None:
+                ns_dict = self.global_scope.get(namespace)
+            if isinstance(ns_dict, dict) and class_name in ns_dict:
+                class_def = ns_dict[class_name]
+
+        # Get class definition from scope (if not found in namespace)
+        if class_def is None:
+            if is_global_ref:
+                # With @ prefix, only look in global scope
+                class_def = self._promoted_globals.get(class_name)
+                if class_def is None:
+                    class_def = self.global_scope.get(class_name)
+            else:
+                # Normal lookup: local scope first, then global
+                class_def = self.scope.get(class_name)
+                if class_def is None:
+                    class_def = self.global_scope.get(class_name)
 
         if class_def is None:
             # Build detailed error with suggestions
@@ -4216,6 +4811,18 @@ class CSSLRuntime:
                 hint=f"'{class_name}' is of type {type(class_def).__name__}"
             )
 
+        # v4.2.5: Deferred &target replacement for non-embedded classes
+        # Apply on first instantiation if pending
+        if hasattr(class_def, '_pending_target') and class_def._pending_target:
+            pending = class_def._pending_target
+            self._overwrite_class_target(
+                pending['append_ref_class'],
+                pending.get('append_ref_member'),
+                class_def
+            )
+            class_def._target_applied = True
+            class_def._pending_target = None  # Clear pending
+
         # Create new instance
         instance = CSSLInstance(class_def)
 
@@ -4646,6 +5253,33 @@ class CSSLRuntime:
         if isinstance(obj, Parameter) and member == 'return':
             member = 'return_'
 
+        # === ServiceDefinition (from include()) ===
+        if isinstance(obj, ServiceDefinition):
+            # Check functions dict first
+            if member in obj.functions:
+                func_node = obj.functions[member]
+                return lambda *args, **kwargs: self._call_function(func_node, list(args), kwargs)
+            # Check structs dict
+            if member in obj.structs:
+                return obj.structs[member]
+            # Check regular attributes
+            if hasattr(obj, member):
+                return getattr(obj, member)
+            # Build helpful error
+            available = list(obj.functions.keys()) + list(obj.structs.keys())
+            similar = _find_similar_names(member, available)
+            if similar:
+                hint = f"Did you mean: {', '.join(similar)}?"
+            elif available:
+                hint = f"Available: {', '.join(available[:10])}"
+            else:
+                hint = "No functions or structs defined in this module."
+            raise self._format_error(
+                node.line if hasattr(node, 'line') else 0,
+                f"Module has no function or struct '{member}'",
+                hint
+            )
+
         # === CSSL CLASS INSTANCE METHODS ===
         if isinstance(obj, CSSLInstance):
             # Check for member variable
@@ -4939,12 +5573,19 @@ class CSSLRuntime:
         index = self._evaluate(node.value.get('index'))
 
         if obj is None:
-            return None
+            raise CSSLRuntimeError(f"Cannot index into None/null value")
 
         try:
             return obj[index]
-        except (IndexError, KeyError, TypeError):
-            return None
+        except IndexError:
+            # v4.2.6: Throw error instead of returning None
+            length = len(obj) if hasattr(obj, '__len__') else 'unknown'
+            raise CSSLRuntimeError(f"Index {index} out of bounds (length: {length})")
+        except KeyError:
+            # v4.2.6: Throw error for missing dict keys
+            raise CSSLRuntimeError(f"Key '{index}' not found in dictionary")
+        except TypeError as e:
+            raise CSSLRuntimeError(f"Cannot index: {e}")
 
     def _set_member(self, node: ASTNode, value: Any):
         """Set member value"""
@@ -5238,10 +5879,17 @@ class CSSLRuntime:
 
     def _emit_output(self, text: str, level: str = 'normal'):
         """Emit output through callback or print"""
+        import sys
         if self._output_callback:
             self._output_callback(text, level)
         else:
-            print(text, end='')
+            # Handle encoding issues on Windows console
+            try:
+                print(text, end='')
+            except UnicodeEncodeError:
+                # Fallback: encode with errors='replace' for unsupported chars
+                encoded = text.encode(sys.stdout.encoding or 'utf-8', errors='replace')
+                print(encoded.decode(sys.stdout.encoding or 'utf-8', errors='replace'), end='')
 
     def output(self, text: str):
         """Output text"""
@@ -5369,14 +6017,79 @@ class CSSLServiceRunner:
         return list(self.running_services.keys())
 
 
-# Convenience function
-def run_cssl(source: str, service_engine=None) -> Any:
-    """Run CSSL source code"""
+# C++ interpreter cache
+_cpp_interpreter = None
+
+
+def _get_cpp_interpreter():
+    """Get or create C++ interpreter instance."""
+    global _cpp_interpreter
+    if _cpp_interpreter is not None:
+        return _cpp_interpreter
+
+    try:
+        from . import _CPP_AVAILABLE, _cpp_module
+        if _CPP_AVAILABLE and _cpp_module and hasattr(_cpp_module, 'Interpreter'):
+            _cpp_interpreter = _cpp_module.Interpreter()
+            return _cpp_interpreter
+    except Exception:
+        pass
+    return None
+
+
+def run_cssl(source: str, service_engine=None, force_python: bool = False) -> Any:
+    """Run CSSL source code.
+
+    Uses C++ interpreter for maximum performance when available.
+    Falls back to Python interpreter for unsupported features.
+
+    Args:
+        source: CSSL source code
+        service_engine: Optional service engine for external integrations
+        force_python: Force Python interpreter (for debugging)
+
+    Returns:
+        Execution result
+    """
+    # Try C++ interpreter first (10-20x faster)
+    if not force_python:
+        cpp_interp = _get_cpp_interpreter()
+        if cpp_interp:
+            try:
+                return cpp_interp.run_string(source)
+            except Exception as e:
+                # C++ doesn't support this feature, fall back to Python
+                error_msg = str(e).lower()
+                # Only fall back for unsupported features, not syntax errors
+                if 'unsupported' in error_msg or 'not implemented' in error_msg:
+                    pass  # Fall through to Python
+                else:
+                    # Re-raise actual errors
+                    raise CSSLRuntimeError(str(e))
+
+    # Python fallback (full feature support)
     runtime = CSSLRuntime(service_engine)
     return runtime.execute(source)
 
 
-def run_cssl_file(filepath: str, service_engine=None) -> Any:
-    """Run a CSSL file"""
+def run_cssl_file(filepath: str, service_engine=None, force_python: bool = False) -> Any:
+    """Run a CSSL file.
+
+    Uses C++ interpreter for maximum performance when available.
+    """
+    # Try C++ interpreter first
+    if not force_python:
+        cpp_interp = _get_cpp_interpreter()
+        if cpp_interp:
+            try:
+                return cpp_interp.run(filepath)
+            except Exception as e:
+                error_msg = str(e).lower()
+                if 'unsupported' in error_msg or 'not implemented' in error_msg:
+                    pass  # Fall through to Python
+                else:
+                    raise CSSLRuntimeError(str(e))
+
+    # Python fallback
     runtime = CSSLRuntime(service_engine)
     return runtime.execute_file(filepath)