IncludeCPP 3.5.0__py3-none-any.whl → 3.7.1__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -14,7 +14,8 @@ from .cssl_builtins import CSSLBuiltins
 from .cssl_modules import get_module_registry, get_standard_module
 from .cssl_types import (
     Parameter, DataStruct, Shuffled, Iterator, Combo,
-    Stack, Vector, Array, DataSpace, OpenQuote
+    Stack, Vector, Array, DataSpace, OpenQuote, List, Dictionary, Map,
+    CSSLClass, CSSLInstance
 )
 
 
@@ -139,9 +140,13 @@ class CSSLRuntime:
         self.services: Dict[str, ServiceDefinition] = {}
         self._modules: Dict[str, Any] = {}
         self._global_structs: Dict[str, Any] = {}  # Global structs for s@<name> references
-        self._function_injections: Dict[str, List[ASTNode]] = {}  # NEW: Permanent function injections
+        self._function_injections: Dict[str, List[tuple]] = {}  # List of (code_block, captured_values_dict)
         self._function_replaced: Dict[str, bool] = {}  # NEW: Track replaced functions (<<==)
+        self._original_functions: Dict[str, Any] = {}  # Store originals before replacement
+        self._injection_captures: Dict[str, Dict[str, Any]] = {}  # Captured %vars per injection
+        self._current_captured_values: Dict[str, Any] = {}  # Current captured values during injection execution
         self._promoted_globals: Dict[str, Any] = {}  # NEW: Variables promoted via global()
+        self._current_instance: Optional[CSSLInstance] = None  # Current class instance for this-> access
         self._running = False
         self._exit_code = 0
         self._output_callback = output_callback  # Callback for console output (text, level)
@@ -374,10 +379,17 @@ class CSSLRuntime:
         - top-level statements (assignments, function calls, control flow)
         """
         result = None
+        self._running = True  # Start running
 
         for child in node.children:
+            # Check if exit() was called
+            if not self._running:
+                break
+
             if child.type == 'struct':
                 self._exec_struct(child)
+            elif child.type == 'class':
+                self._exec_class(child)
             elif child.type == 'function':
                 self._exec_function(child)
             elif child.type == 'global_assignment':
@@ -386,6 +398,9 @@ class CSSLRuntime:
             elif child.type == 'typed_declaration':
                 # Handle typed variable declaration: type<T> varName = value;
                 result = self._exec_typed_declaration(child)
+            elif child.type == 'instance_declaration':
+                # Handle instance declaration: instance<"name"> varName;
+                result = self._exec_instance_declaration(child)
             elif child.type in ('assignment', 'expression', 'inject', 'receive', 'flow',
                                'if', 'while', 'for', 'c_for', 'foreach', 'switch', 'try'):
                 result = self._execute_node(child)
@@ -398,13 +413,14 @@ class CSSLRuntime:
                 except CSSLRuntimeError:
                     pass  # Ignore unknown nodes in program mode
 
-        # Look for and execute main() if defined
-        main_func = self.scope.get('main')
-        if main_func and isinstance(main_func, ASTNode) and main_func.type == 'function':
-            try:
-                result = self._call_function(main_func, [])
-            except CSSLReturn as ret:
-                result = ret.value
+        # Look for and execute main() if defined (only if still running)
+        if self._running:
+            main_func = self.scope.get('main')
+            if main_func and isinstance(main_func, ASTNode) and main_func.type == 'function':
+                try:
+                    result = self._call_function(main_func, [])
+                except CSSLReturn as ret:
+                    result = ret.value
 
         return result
 
@@ -652,6 +668,57 @@ class CSSLRuntime:
 
         return struct_data
 
+    def _exec_class(self, node: ASTNode) -> CSSLClass:
+        """Execute class definition - registers class in scope.
+
+        Parses class members and methods, creating a CSSLClass object
+        that can be instantiated with 'new'.
+        """
+        class_info = node.value
+        class_name = class_info.get('name')
+
+        members = {}  # Member variable defaults/types
+        methods = {}  # Method AST nodes
+        constructor = None
+
+        for child in node.children:
+            if child.type == 'function':
+                # This is a method
+                func_info = child.value
+                method_name = func_info.get('name')
+
+                if func_info.get('is_constructor') or method_name == class_name or method_name == '__init__':
+                    constructor = child
+                else:
+                    methods[method_name] = child
+
+            elif child.type == 'typed_declaration':
+                # This is a member variable
+                decl = child.value
+                member_name = decl.get('name')
+                member_type = decl.get('type')
+                member_value = decl.get('value')
+
+                # Store member info with type and optional default
+                members[member_name] = {
+                    'type': member_type,
+                    'default': self._evaluate(member_value) if member_value else None
+                }
+
+        # Create class definition object
+        class_def = CSSLClass(
+            name=class_name,
+            members=members,
+            methods=methods,
+            constructor=constructor
+        )
+
+        # Register class in scope
+        self.scope.set(class_name, class_def)
+        self.global_scope.set(class_name, class_def)
+
+        return class_def
+
     def _exec_function(self, node: ASTNode) -> Any:
         """Execute function definition - just registers it"""
         func_info = node.value
@@ -701,6 +768,12 @@ class CSSLRuntime:
             instance = {} if value_node is None else self._evaluate(value_node)
         elif type_name == 'array':
             instance = Array(element_type)
+        elif type_name == 'list':
+            instance = List(element_type)
+        elif type_name in ('dictionary', 'dict'):
+            instance = Dictionary(element_type)
+        elif type_name == 'map':
+            instance = Map(element_type)
         else:
             # Default: evaluate the value or set to None
             instance = self._evaluate(value_node) if value_node else None
@@ -719,6 +792,34 @@ class CSSLRuntime:
         self.scope.set(var_name, instance)
         return instance
 
+    def _exec_instance_declaration(self, node: ASTNode) -> Any:
+        """Execute instance declaration: instance<"name"> varName;
+
+        Gets or creates a shared instance by name.
+        """
+        from ..cssl_bridge import _live_objects, SharedObjectProxy
+        decl = node.value
+        instance_name = decl.get('instance_name')
+        var_name = decl.get('name')
+        value_node = decl.get('value')
+
+        # Get existing shared instance
+        instance = None
+        if instance_name in _live_objects:
+            instance = SharedObjectProxy(instance_name, _live_objects[instance_name])
+        elif self.global_scope.has(f'${instance_name}'):
+            instance = self.global_scope.get(f'${instance_name}')
+
+        # If value is provided, use that and register as shared
+        if value_node:
+            instance = self._evaluate(value_node)
+            # Register in global scope for future access
+            self.global_scope.set(f'${instance_name}', instance)
+
+        # Store in scope
+        self.scope.set(var_name, instance)
+        return instance
+
     def _exec_global_assignment(self, node: ASTNode) -> Any:
         """Execute global variable assignment: global Name = value
 
@@ -762,11 +863,18 @@ class CSSLRuntime:
         # Fallback: execute normally
         return self._execute_node(inner)
 
-    def _call_function(self, func_node: ASTNode, args: List[Any]) -> Any:
-        """Call a function node with arguments"""
+    def _call_function(self, func_node: ASTNode, args: List[Any], kwargs: Dict[str, Any] = None) -> Any:
+        """Call a function node with arguments (positional and named)
+
+        Args:
+            func_node: The function AST node
+            args: List of positional arguments
+            kwargs: Dict of named arguments (param_name -> value)
+        """
         func_info = func_node.value
         params = func_info.get('params', [])
         modifiers = func_info.get('modifiers', [])
+        kwargs = kwargs or {}
 
         # Check for undefined modifier - suppress errors if present
         is_undefined = 'undefined' in modifiers
@@ -774,11 +882,16 @@ class CSSLRuntime:
         # Create new scope
         new_scope = Scope(parent=self.scope)
 
-        # Bind parameters - handle both string and dict formats
+        # Bind parameters - handle both positional and named arguments
         for i, param in enumerate(params):
             # Extract param name from dict format: {'name': 'a', 'type': 'int'}
             param_name = param['name'] if isinstance(param, dict) else param
-            if i < len(args):
+
+            if param_name in kwargs:
+                # Named argument takes priority
+                new_scope.set(param_name, kwargs[param_name])
+            elif i < len(args):
+                # Positional argument
                 new_scope.set(param_name, args[i])
             else:
                 new_scope.set(param_name, None)
@@ -789,6 +902,9 @@ class CSSLRuntime:
 
         try:
             for child in func_node.children:
+                # Check if exit() was called
+                if not self._running:
+                    break
                 self._execute_node(child)
         except CSSLReturn as ret:
             return ret.value
@@ -824,9 +940,11 @@ class CSSLRuntime:
 
     def _exec_while(self, node: ASTNode) -> Any:
         """Execute while loop"""
-        while self._evaluate(node.value.get('condition')):
+        while self._running and self._evaluate(node.value.get('condition')):
             try:
                 for child in node.children:
+                    if not self._running:
+                        break
                     self._execute_node(child)
             except CSSLBreak:
                 break
@@ -846,9 +964,13 @@ class CSSLRuntime:
         step = int(self._evaluate(step_node)) if step_node else 1
 
         for i in range(start, end, step):
+            if not self._running:
+                break
             self.scope.set(var_name, i)
             try:
                 for child in node.children:
+                    if not self._running:
+                        break
                     self._execute_node(child)
             except CSSLBreak:
                 break
@@ -879,7 +1001,7 @@ class CSSLRuntime:
             var_name = None
 
         # Main loop
-        while True:
+        while self._running:
             # Check condition
             if condition:
                 cond_result = self._evaluate(condition)
@@ -890,6 +1012,8 @@ class CSSLRuntime:
             # Execute body
             try:
                 for child in node.children:
+                    if not self._running:
+                        break
                     self._execute_node(child)
             except CSSLBreak:
                 break
@@ -933,9 +1057,13 @@ class CSSLRuntime:
             return None
 
         for item in iterable:
+            if not self._running:
+                break
             self.scope.set(var_name, item)
             try:
                 for child in node.children:
+                    if not self._running:
+                        break
                     self._execute_node(child)
             except CSSLBreak:
                 break
@@ -1109,6 +1237,76 @@ class CSSLRuntime:
                             result = result if len(result) == filter_val else None
                         elif isinstance(result, list):
                             result = [item for item in result if isinstance(item, str) and len(item) == filter_val]
+                    elif helper == 'cut':
+                        # Cut string - returns the part BEFORE the index/substring
+                        # x = <==[string::cut=2] "20:200-1"  -->  x = "20"
+                        # x = <==[string::cut="1.0"] "1.0.0"  -->  x = "" (before "1.0")
+                        if isinstance(result, str):
+                            if isinstance(filter_val, str):
+                                # Cut at substring position
+                                idx = result.find(filter_val)
+                                result = result[:idx] if idx >= 0 else result
+                            else:
+                                # Cut at integer index
+                                idx = int(filter_val)
+                                result = result[:idx] if 0 <= idx <= len(result) else result
+                        elif isinstance(result, list):
+                            def cut_item(item):
+                                if not isinstance(item, str):
+                                    return item
+                                if isinstance(filter_val, str):
+                                    idx = item.find(filter_val)
+                                    return item[:idx] if idx >= 0 else item
+                                return item[:int(filter_val)]
+                            result = [cut_item(item) for item in result]
+                    elif helper == 'cutAfter':
+                        # Get the part AFTER the index/substring
+                        # x = <==[string::cutAfter=2] "20:200-1"  -->  x = ":200-1"
+                        # x = <==[string::cutAfter="1.0"] "1.0.0"  -->  x = ".0" (after "1.0")
+                        if isinstance(result, str):
+                            if isinstance(filter_val, str):
+                                # Cut after substring
+                                idx = result.find(filter_val)
+                                result = result[idx + len(filter_val):] if idx >= 0 else result
+                            else:
+                                # Cut after integer index
+                                idx = int(filter_val)
+                                result = result[idx:] if 0 <= idx <= len(result) else result
+                        elif isinstance(result, list):
+                            def cut_after_item(item):
+                                if not isinstance(item, str):
+                                    return item
+                                if isinstance(filter_val, str):
+                                    idx = item.find(filter_val)
+                                    return item[idx + len(filter_val):] if idx >= 0 else item
+                                return item[int(filter_val):]
+                            result = [cut_after_item(item) for item in result]
+                    elif helper == 'slice':
+                        # Slice string with start:end format (e.g., "2:5")
+                        if isinstance(result, str) and isinstance(filter_val, str) and ':' in filter_val:
+                            parts = filter_val.split(':')
+                            start = int(parts[0]) if parts[0] else 0
+                            end = int(parts[1]) if parts[1] else len(result)
+                            result = result[start:end]
+                    elif helper == 'split':
+                        # Split string by delimiter
+                        if isinstance(result, str):
+                            result = result.split(str(filter_val))
+                    elif helper == 'replace':
+                        # Replace in string (format: "old:new")
+                        if isinstance(result, str) and isinstance(filter_val, str) and ':' in filter_val:
+                            parts = filter_val.split(':', 1)
+                            if len(parts) == 2:
+                                result = result.replace(parts[0], parts[1])
+                    elif helper == 'upper':
+                        if isinstance(result, str):
+                            result = result.upper()
+                    elif helper == 'lower':
+                        if isinstance(result, str):
+                            result = result.lower()
+                    elif helper == 'trim':
+                        if isinstance(result, str):
+                            result = result.strip()
 
                 # === INTEGER HELPERS ===
                 elif filter_type == 'integer':
@@ -1220,8 +1418,21 @@ class CSSLRuntime:
                 self.register_function_injection(func_name, source_node)
                 return None
 
-        # Evaluate source
-        source = self._evaluate(source_node)
+        # Check if source is an action_block with %<name> captures
+        # If so, capture values NOW and evaluate the block with those captures
+        if isinstance(source_node, ASTNode) and source_node.type == 'action_block':
+            # Scan for %<name> captured references and capture their current values
+            captured_values = self._scan_and_capture_refs(source_node)
+            old_captured = self._current_captured_values.copy()
+            self._current_captured_values = captured_values
+            try:
+                # Execute the action block and get the last expression's value
+                source = self._evaluate_action_block(source_node)
+            finally:
+                self._current_captured_values = old_captured
+        else:
+            # Evaluate source normally
+            source = self._evaluate(source_node)
 
         # Apply filter if present
         if filter_info:
@@ -1348,6 +1559,12 @@ class CSSLRuntime:
             name = target.value
             _live_objects[name] = final_value
             self.global_scope.set(f'${name}', SharedObjectProxy(name, final_value))
+        elif target.type == 'instance_ref':
+            # value ==> instance<"name"> - create/update shared object
+            from ..cssl_bridge import _live_objects, SharedObjectProxy
+            name = target.value
+            _live_objects[name] = final_value
+            self.global_scope.set(f'${name}', SharedObjectProxy(name, final_value))
         elif target.type == 'member_access':
             self._set_member(target, final_value)
 
@@ -1360,11 +1577,20 @@ class CSSLRuntime:
         - replace: func <<== { code } - REPLACES function body (original won't execute)
         - add: func +<<== { code } - ADDS code to function (both execute)
         - remove: func -<<== { code } - REMOVES matching code from function
+
+        Also supports expression form: func <<== %exit() (wraps in action_block)
         """
         target = node.value.get('target')
         code_block = node.value.get('code')
+        source_expr = node.value.get('source')  # For expression form: func <<== expr
         mode = node.value.get('mode', 'replace')  # Default is REPLACE for <<==
 
+        # If source expression is provided instead of code block, wrap it
+        if code_block is None and source_expr is not None:
+            # Wrap in expression node so _execute_node can handle it
+            expr_node = ASTNode('expression', value=source_expr)
+            code_block = ASTNode('action_block', children=[expr_node])
+
         # Get function name from target
         func_name = None
         if isinstance(target, ASTNode):
@@ -1375,7 +1601,7 @@ class CSSLRuntime:
                 if isinstance(callee, ASTNode) and callee.type == 'identifier':
                     func_name = callee.value
 
-        if not func_name:
+        if not func_name or code_block is None:
             return None
 
         if mode == 'add':
@@ -1384,16 +1610,31 @@ class CSSLRuntime:
             self._function_replaced[func_name] = False  # Don't replace, just add
         elif mode == 'replace':
             # <<== : Replace function body (only injection executes, original skipped)
-            self._function_injections[func_name] = [code_block]
+            # Save original function BEFORE replacing (for original() access)
+            if func_name not in self._original_functions:
+                # Try to find original in scope or builtins
+                original = self.scope.get(func_name)
+                if original is None:
+                    original = getattr(self.builtins, f'builtin_{func_name}', None)
+                if original is not None:
+                    self._original_functions[func_name] = original
+            # Capture %<name> references at registration time
+            captured_values = self._scan_and_capture_refs(code_block)
+            self._function_injections[func_name] = [(code_block, captured_values)]
             self._function_replaced[func_name] = True  # Mark as replaced
         elif mode == 'remove':
-            # -<<== : Remove matching code from function body
-            # For now, this removes all injections for the function
+            # -<<== or -<<==[n] : Remove matching code from function body
+            remove_index = node.value.get('index')
+
             if func_name in self._function_injections:
-                self._function_injections[func_name] = []
+                if remove_index is not None:
+                    # Indexed removal: -<<==[n] removes only the nth injection
+                    if 0 <= remove_index < len(self._function_injections[func_name]):
+                        self._function_injections[func_name].pop(remove_index)
+                else:
+                    # No index: -<<== removes all injections
+                    self._function_injections[func_name] = []
             self._function_replaced[func_name] = False
-            # Note: Removing from actual function body would require AST manipulation
-            # which is complex - for now we just clear injections
 
         return None
 
@@ -1473,6 +1714,12 @@ class CSSLRuntime:
                 self._set_member(target, value)
             elif target.type == 'index_access':
                 self._set_index(target, value)
+            elif target.type == 'this_access':
+                # this->member = value
+                if self._current_instance is None:
+                    raise CSSLRuntimeError("'this' used outside of class method context")
+                member = target.value.get('member')
+                self._current_instance.set_member(member, value)
         elif isinstance(target, str):
             self.scope.set(target, value)
 
@@ -1546,9 +1793,17 @@ class CSSLRuntime:
             return None
 
         if node.type == 'identifier':
-            value = self.scope.get(node.value)
-            if value is None and self.builtins.has_function(node.value):
-                return self.builtins.get_function(node.value)
+            name = node.value
+            value = self.scope.get(name)
+            # Fallback to global scope
+            if value is None:
+                value = self.global_scope.get(name)
+            # Fallback to promoted globals (from 'global' keyword)
+            if value is None:
+                value = self._promoted_globals.get(name)
+            # Fallback to builtins
+            if value is None and self.builtins.has_function(name):
+                return self.builtins.get_function(name)
             return value
 
         if node.type == 'module_ref':
@@ -1585,6 +1840,55 @@ class CSSLRuntime:
                 return scoped_val
             raise CSSLRuntimeError(f"Shared object '${name}' not found. Use share() to share objects.")
 
+        if node.type == 'captured_ref':
+            # %<name> captured reference - use value captured at infusion registration time
+            name = node.value
+            # 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
+            value = self.scope.get(name)
+            if value is None:
+                value = self.global_scope.get(name)
+            if value is None:
+                # For critical builtins like 'exit', create direct wrapper
+                if name == 'exit':
+                    runtime = self
+                    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
+            raise CSSLRuntimeError(f"Captured reference '%{name}' not found.")
+
+        if node.type == 'instance_ref':
+            # instance<"name"> - get shared instance by name
+            # Works like $name but with explicit syntax
+            from ..cssl_bridge import _live_objects, SharedObjectProxy
+            name = node.value
+            if name in _live_objects:
+                return SharedObjectProxy(name, _live_objects[name])
+            # Check if stored in runtime's scope
+            scoped_val = self.global_scope.get(f'${name}')
+            if scoped_val is not None:
+                return scoped_val
+            # Return None if instance doesn't exist (can be created via ==>)
+            return None
+
+        if node.type == 'new':
+            # Create new instance of a class: new ClassName(args)
+            return self._eval_new(node)
+
+        if node.type == 'this_access':
+            # this->member access
+            return self._eval_this_access(node)
+
         if node.type == 'type_instantiation':
             # Create new instance of a type: stack<string>, vector<int>, etc.
             type_name = node.value.get('type')
@@ -1608,6 +1912,10 @@ class CSSLRuntime:
                 return OpenQuote()
             elif type_name == 'array':
                 return Array(element_type)
+            elif type_name == 'list':
+                return List(element_type)
+            elif type_name in ('dictionary', 'dict'):
+                return Dictionary(element_type)
             else:
                 return None
 
@@ -1647,8 +1955,41 @@ class CSSLRuntime:
                     return {'__ref__': True, 'name': inner.value, 'value': self.get_module(inner.value)}
             return {'__ref__': True, 'value': self._evaluate(inner)}
 
+        # Handle action_block - execute and return last expression value
+        if node.type == 'action_block':
+            return self._evaluate_action_block(node)
+
         return None
 
+    def _evaluate_action_block(self, node: ASTNode) -> Any:
+        """Evaluate an action block and return the last expression's value.
+
+        Used for: v <== { %version; } - captures %version at this moment
+
+        Returns the value of the last expression in the block.
+        If the block contains a captured_ref (%name), that's what gets returned.
+        """
+        last_value = None
+        for child in node.children:
+            if child.type == 'captured_ref':
+                # Direct captured reference - return its value
+                last_value = self._evaluate(child)
+            elif child.type == 'expression':
+                # Expression statement - evaluate and keep value
+                last_value = self._evaluate(child.value if hasattr(child, 'value') else child)
+            elif child.type == 'identifier':
+                # Just an identifier - evaluate it
+                last_value = self._evaluate(child)
+            elif child.type in ('call', 'member_access', 'binary', 'unary'):
+                # Expression types
+                last_value = self._evaluate(child)
+            else:
+                # Execute other statements
+                result = self._execute_node(child)
+                if result is not None:
+                    last_value = result
+        return last_value
+
     def _eval_binary(self, node: ASTNode) -> Any:
         """Evaluate binary operation with auto-casting support"""
         op = node.value.get('op')
@@ -1818,12 +2159,15 @@ class CSSLRuntime:
         return None
 
     def _eval_call(self, node: ASTNode) -> Any:
-        """Evaluate function call"""
+        """Evaluate function call with optional named arguments"""
         callee_node = node.value.get('callee')
-        callee = self._evaluate(callee_node)
         args = [self._evaluate(a) for a in node.value.get('args', [])]
 
-        # Get function name for injection check
+        # Evaluate named arguments (kwargs)
+        kwargs_raw = node.value.get('kwargs', {})
+        kwargs = {k: self._evaluate(v) for k, v in kwargs_raw.items()} if kwargs_raw else {}
+
+        # Get function name for injection check FIRST (before evaluating callee)
         func_name = None
         if isinstance(callee_node, ASTNode):
             if callee_node.type == 'identifier':
@@ -1835,20 +2179,27 @@ class CSSLRuntime:
         has_injections = func_name and func_name in self._function_injections
         is_replaced = func_name and self._function_replaced.get(func_name, False)
 
-        # Execute injected code first (if any)
-        if has_injections:
+        # If function is FULLY REPLACED (<<==), run injection and skip original
+        # This allows creating new functions via infusion: new_func <<== { ... }
+        if is_replaced:
             self._execute_function_injections(func_name)
+            return None  # Injection ran, don't try to find original
 
-        # If function is REPLACED (<<==), skip original body execution
-        if is_replaced:
-            return None  # Injection already ran, don't run original
+        # Now evaluate the callee (only if not replaced)
+        callee = self._evaluate(callee_node)
+
+        # Execute added injections (+<<==) before original
+        if has_injections and not is_replaced:
+            self._execute_function_injections(func_name)
 
         # Execute original function
         if callable(callee):
+            if kwargs:
+                return callee(*args, **kwargs)
             return callee(*args)
 
         if isinstance(callee, ASTNode) and callee.type == 'function':
-            return self._call_function(callee, args)
+            return self._call_function(callee, args, kwargs)
 
         callee_name = callee_node.value if isinstance(callee_node, ASTNode) and hasattr(callee_node, 'value') else str(callee_node)
         raise CSSLRuntimeError(
@@ -1907,6 +2258,140 @@ class CSSLRuntime:
             hint="Typed functions use format: FunctionName<Type>(args)"
         )
 
+    def _eval_new(self, node: ASTNode) -> CSSLInstance:
+        """Evaluate 'new ClassName(args)' expression.
+
+        Creates a new instance of a CSSL class and calls its constructor.
+        """
+        class_name = node.value.get('class')
+        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
+        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:
+            raise CSSLRuntimeError(
+                f"Class '{class_name}' not found",
+                node.line,
+                hint="Make sure the class is defined before instantiation"
+            )
+
+        if not isinstance(class_def, CSSLClass):
+            raise CSSLRuntimeError(
+                f"'{class_name}' is not a class",
+                node.line,
+                hint=f"'{class_name}' is of type {type(class_def).__name__}"
+            )
+
+        # Create new instance
+        instance = CSSLInstance(class_def)
+
+        # Call constructor if defined
+        if class_def.constructor:
+            self._call_method(instance, class_def.constructor, args, kwargs)
+
+        return instance
+
+    def _eval_this_access(self, node: ASTNode) -> Any:
+        """Evaluate 'this->member' access.
+
+        Returns the value of a member from the current class instance.
+        """
+        if self._current_instance is None:
+            raise CSSLRuntimeError(
+                "'this' used outside of class method context",
+                node.line if hasattr(node, 'line') else 0,
+                hint="'this->' can only be used inside class methods"
+            )
+
+        member = node.value.get('member')
+
+        # Check if it's a chained access (this->a->b)
+        if 'object' in node.value:
+            # First evaluate the object part
+            obj = self._evaluate(node.value.get('object'))
+            if obj is None:
+                return None
+            if hasattr(obj, member):
+                return getattr(obj, member)
+            if isinstance(obj, dict):
+                return obj.get(member)
+            return None
+
+        # Direct this->member access
+        instance = self._current_instance
+
+        # Check if it's a member variable
+        if instance.has_member(member):
+            return instance.get_member(member)
+
+        # Check if it's a method
+        if instance.has_method(member):
+            # Return a callable that will invoke the method with instance context
+            method_node = instance.get_method(member)
+            return lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
+
+        raise CSSLRuntimeError(
+            f"'{instance._class.name}' has no member or method '{member}'",
+            node.line if hasattr(node, 'line') else 0
+        )
+
+    def _call_method(self, instance: CSSLInstance, method_node: ASTNode, args: list, kwargs: dict = None) -> Any:
+        """Call a method on an instance with 'this' context.
+
+        Sets up the instance as the current 'this' context and executes the method.
+        """
+        kwargs = kwargs or {}
+        func_info = method_node.value
+        params = func_info.get('params', [])
+        modifiers = func_info.get('modifiers', [])
+
+        # Check for undefined modifier
+        is_undefined = 'undefined' in modifiers
+
+        # Create new scope for method
+        new_scope = Scope(parent=self.scope)
+
+        # Bind parameters
+        for i, param in enumerate(params):
+            param_name = param['name'] if isinstance(param, dict) else param
+
+            if param_name in kwargs:
+                new_scope.set(param_name, kwargs[param_name])
+            elif i < len(args):
+                new_scope.set(param_name, args[i])
+            else:
+                new_scope.set(param_name, None)
+
+        # Save current state
+        old_scope = self.scope
+        old_instance = self._current_instance
+
+        # Set up method context
+        self.scope = new_scope
+        self._current_instance = instance
+
+        try:
+            for child in method_node.children:
+                if not self._running:
+                    break
+                self._execute_node(child)
+        except CSSLReturn as ret:
+            return ret.value
+        except Exception as e:
+            if is_undefined:
+                return None
+            raise
+        finally:
+            # Restore previous state
+            self.scope = old_scope
+            self._current_instance = old_instance
+
+        return None
+
     def _eval_member_access(self, node: ASTNode) -> Any:
         """Evaluate member access"""
         obj = self._evaluate(node.value.get('object'))
@@ -1920,6 +2405,17 @@ class CSSLRuntime:
         if isinstance(obj, Parameter) and member == 'return':
             member = 'return_'
 
+        # === CSSL CLASS INSTANCE METHODS ===
+        if isinstance(obj, CSSLInstance):
+            # Check for member variable
+            if obj.has_member(member):
+                return obj.get_member(member)
+            # Check for method
+            if obj.has_method(member):
+                method_node = obj.get_method(member)
+                return lambda *args, **kwargs: self._call_method(obj, method_node, list(args), kwargs)
+            raise CSSLRuntimeError(f"'{obj._class.name}' has no member or method '{member}'")
+
         # === STRING METHODS ===
         if isinstance(obj, str):
             string_methods = self._get_string_method(obj, member)
@@ -2153,6 +2649,11 @@ class CSSLRuntime:
         if obj is None:
             return
 
+        # Check for CSSLInstance - use set_member method
+        if isinstance(obj, CSSLInstance):
+            obj.set_member(member, value)
+            return
+
         # Check for SharedObjectProxy - directly access underlying object
         # This is more robust than relying on the proxy's __setattr__
         if hasattr(obj, '_direct_object') and hasattr(obj, '_name'):
@@ -2256,22 +2757,107 @@ class CSSLRuntime:
             # Also store in promoted globals for string interpolation
             self._promoted_globals[base_name] = value
 
+    # NEW: Scan for captured_ref nodes and capture their current values
+    def _scan_and_capture_refs(self, node: ASTNode) -> Dict[str, Any]:
+        """Scan AST for %<name> captured references and capture their current values.
+
+        This is called at infusion registration time to capture values.
+        Example: old_exit <<== { %exit(); } captures 'exit' at definition time.
+        """
+        captured = {}
+
+        def scan_node(n):
+            if not isinstance(n, ASTNode):
+                return
+
+            # Found a captured_ref - capture its current value
+            if n.type == 'captured_ref':
+                name = n.value
+                if name not in captured:
+                    # Try to find value - check multiple sources
+                    value = None
+
+                    # 1. Check _original_functions first (for functions that were JUST replaced)
+                    if value is None:
+                        value = self._original_functions.get(name)
+
+                    # 2. Check scope
+                    if value is None:
+                        value = self.scope.get(name)
+
+                    # 3. Check global_scope
+                    if value is None:
+                        value = self.global_scope.get(name)
+
+                    # 4. Check builtins (most common case for exit, print, etc.)
+                    if value is None:
+                        # For critical builtins like 'exit', create a direct wrapper
+                        # that captures the runtime reference to ensure correct behavior
+                        if name == 'exit':
+                            runtime = self  # Capture runtime in closure
+                            value = lambda code=0, rt=runtime: rt.exit(code)
+                        else:
+                            value = getattr(self.builtins, f'builtin_{name}', None)
+
+                    # 5. Check if there's a user-defined function in scope
+                    if value is None:
+                        # Look for function definitions
+                        func_def = self.global_scope.get(f'__func_{name}')
+                        if func_def is not None:
+                            value = func_def
+
+                    # Only capture if we found something
+                    if value is not None:
+                        captured[name] = value
+
+            # Check call node's callee
+            if n.type == 'call':
+                callee = n.value.get('callee')
+                if callee:
+                    scan_node(callee)
+                for arg in n.value.get('args', []):
+                    scan_node(arg)
+
+            # Recurse into children
+            if hasattr(n, 'children') and n.children:
+                for child in n.children:
+                    scan_node(child)
+
+            # Check value dict for nested nodes
+            if hasattr(n, 'value') and isinstance(n.value, dict):
+                for key, val in n.value.items():
+                    if isinstance(val, ASTNode):
+                        scan_node(val)
+                    elif isinstance(val, list):
+                        for item in val:
+                            if isinstance(item, ASTNode):
+                                scan_node(item)
+
+        scan_node(node)
+        return captured
+
     # NEW: Register permanent function injection
     def register_function_injection(self, func_name: str, code_block: ASTNode):
         """Register code to be permanently injected into a function - NEW
 
         Example: exit() <== { println("Cleanup..."); }
         Makes every call to exit() also execute the injected code
+
+        Captures %<name> references at registration time.
         """
+        # Scan for %<name> captured references and capture their current values
+        captured_values = self._scan_and_capture_refs(code_block)
+
         if func_name not in self._function_injections:
             self._function_injections[func_name] = []
-        self._function_injections[func_name].append(code_block)
+        self._function_injections[func_name].append((code_block, captured_values))
 
     # NEW: Execute injected code for a function
     def _execute_function_injections(self, func_name: str):
         """Execute all injected code blocks for a function - NEW
 
         Includes protection against recursive execution to prevent doubled output.
+        Uses captured values for %<name> references.
         """
         # Prevent recursive injection execution (fixes doubled output bug)
         if getattr(self, '_injection_executing', False):
@@ -2279,16 +2865,29 @@ class CSSLRuntime:
 
         if func_name in self._function_injections:
             self._injection_executing = True
+            old_captured = self._current_captured_values.copy()
             try:
-                for code_block in self._function_injections[func_name]:
+                for injection in self._function_injections[func_name]:
+                    # Handle both tuple format (code_block, captured_values) and legacy ASTNode format
+                    if isinstance(injection, tuple):
+                        code_block, captured_values = injection
+                        self._current_captured_values = captured_values
+                    else:
+                        code_block = injection
+                        self._current_captured_values = {}
+
                     if isinstance(code_block, ASTNode):
                         if code_block.type == 'action_block':
                             for child in code_block.children:
+                                # Check if exit() was called
+                                if not self._running:
+                                    break
                                 self._execute_node(child)
                         else:
                             self._execute_node(code_block)
             finally:
                 self._injection_executing = False
+                self._current_captured_values = old_captured
 
     # Output functions for builtins
     def set_output_callback(self, callback: Callable[[str, str], None]):