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

includecpp/core/cssl/cssl_runtime.py

@@ -14,7 +14,7 @@ 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
 )
 
 
@@ -139,8 +139,11 @@ 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._running = False
         self._exit_code = 0
@@ -374,8 +377,13 @@ 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 == 'function':
@@ -398,13 +406,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
 
@@ -701,6 +710,10 @@ 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)
         else:
             # Default: evaluate the value or set to None
             instance = self._evaluate(value_node) if value_node else None
@@ -762,11 +775,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 +794,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 +814,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 +852,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 +876,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 +913,7 @@ class CSSLRuntime:
             var_name = None
 
         # Main loop
-        while True:
+        while self._running:
             # Check condition
             if condition:
                 cond_result = self._evaluate(condition)
@@ -890,6 +924,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 +969,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 +1149,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 +1330,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:
@@ -1360,11 +1483,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 +1507,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 +1516,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
 
@@ -1546,9 +1693,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 +1740,33 @@ 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 == 'type_instantiation':
             # Create new instance of a type: stack<string>, vector<int>, etc.
             type_name = node.value.get('type')
@@ -1608,6 +1790,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 +1833,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 +2037,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 +2057,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(
@@ -2256,22 +2485,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 +2593,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]):