IncludeCPP 3.5.2__tar.gz → 3.5.7__tar.gz

{includecpp-3.5.2 → includecpp-3.5.7}/IncludeCPP.egg-info/PKG-INFO

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

{includecpp-3.5.2 → includecpp-3.5.7}/PKG-INFO

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

{includecpp-3.5.2 → includecpp-3.5.7}/includecpp/__init__.py

@@ -2,7 +2,7 @@ from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
 
-__version__ = "3.5.2"
+__version__ = "3.5.7"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

{includecpp-3.5.2 → includecpp-3.5.7}/includecpp/core/cssl/cssl_builtins.py

@@ -913,6 +913,29 @@ class CSSLBuiltins:
         else:
             raise SystemExit(code)
 
+    def builtin_original(self, func_name: str, *args) -> Any:
+        """Call the original version of a replaced function.
+
+        Usage:
+            exit <<== { printl("custom exit"); }
+            original("exit");  // Calls the ORIGINAL exit, not the replacement
+
+            // In an injection that was defined BEFORE replacement:
+            old_exit <<== { original("exit"); }  // Calls original exit
+        """
+        if self.runtime and hasattr(self.runtime, '_original_functions'):
+            original_func = self.runtime._original_functions.get(func_name)
+            if original_func is not None:
+                if callable(original_func):
+                    return original_func(*args)
+                elif isinstance(original_func, type(lambda: None).__class__.__bases__[0]):  # Check if bound method
+                    return original_func(*args)
+        # Fallback: try to call builtin directly
+        builtin_method = getattr(self, f'builtin_{func_name}', None)
+        if builtin_method:
+            return builtin_method(*args)
+        raise CSSLBuiltinError(f"No original function '{func_name}' found")
+
     def builtin_env(self, name: str, default: str = None) -> Optional[str]:
         return os.environ.get(name, default)
 

{includecpp-3.5.2 → includecpp-3.5.7}/includecpp/core/cssl/cssl_parser.py

@@ -100,6 +100,7 @@ class TokenType(Enum):
     GLOBAL_REF = auto()  # r@<name> global variable declaration
     SELF_REF = auto()    # s@<name> self-reference to global struct
     SHARED_REF = auto()  # $<name> shared object reference
+    CAPTURED_REF = auto()  # %<name> captured reference (for infusion)
     PACKAGE = auto()
     PACKAGE_INCLUDES = auto()
     AS = auto()
@@ -242,6 +243,9 @@ class CSSLLexer:
             elif char == '$':
                 # $<name> shared object reference
                 self._read_shared_ref()
+            elif char == '%':
+                # %<name> captured reference (for infusion)
+                self._read_captured_ref()
             elif char == '&':
                 # & for references
                 if self._peek(1) == '&':
@@ -494,6 +498,20 @@ class CSSLLexer:
             self.error("Expected identifier after '$'")
         self._add_token(TokenType.SHARED_REF, value)
 
+    def _read_captured_ref(self):
+        """Read %<name> captured reference (captures value at definition time for infusions)"""
+        self._advance()  # skip '%'
+
+        # Read the identifier (captured reference name)
+        name_start = self.pos
+        while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] == '_'):
+            self._advance()
+
+        value = self.source[name_start:self.pos]
+        if not value:
+            self.error("Expected identifier after '%'")
+        self._add_token(TokenType.CAPTURED_REF, value)
+
     def _read_less_than(self):
         # Check for <<== (code infusion left)
         if self._peek(1) == '<' and self._peek(2) == '=' and self._peek(3) == '=':
@@ -1294,7 +1312,9 @@ class CSSLParser:
         elif self._looks_like_function_declaration():
             # Nested typed function (e.g., void Level2() { ... })
             return self._parse_typed_function()
-        elif self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT):
+        elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
+              self._check(TokenType.CAPTURED_REF) or self._check(TokenType.SHARED_REF) or
+              self._check(TokenType.GLOBAL_REF) or self._check(TokenType.SELF_REF)):
             return self._parse_expression_statement()
         else:
             self._advance()
@@ -2058,6 +2078,31 @@ class CSSLParser:
                     break
             return node
 
+        if self._check(TokenType.CAPTURED_REF):
+            # %<name> captured reference (captures value at infusion registration time)
+            token = self._advance()
+            node = ASTNode('captured_ref', value=token.value, line=token.line, column=token.column)
+            # Check for member access, calls, indexing
+            while True:
+                if self._match(TokenType.PAREN_START):
+                    args = []
+                    while not self._check(TokenType.PAREN_END):
+                        args.append(self._parse_expression())
+                        if not self._check(TokenType.PAREN_END):
+                            self._expect(TokenType.COMMA)
+                    self._expect(TokenType.PAREN_END)
+                    node = ASTNode('call', value={'callee': node, 'args': args})
+                elif self._match(TokenType.DOT):
+                    member = self._advance().value
+                    node = ASTNode('member_access', value={'object': node, 'member': member})
+                elif self._match(TokenType.BRACKET_START):
+                    index = self._parse_expression()
+                    self._expect(TokenType.BRACKET_END)
+                    node = ASTNode('index_access', value={'object': node, 'index': index})
+                else:
+                    break
+            return node
+
         if self._check(TokenType.NUMBER):
             return ASTNode('literal', value=self._advance().value)
 
@@ -2082,7 +2127,13 @@ class CSSLParser:
             return expr
 
         if self._match(TokenType.BLOCK_START):
-            return self._parse_object()
+            # Distinguish between object literal { key = value } and action block { expr; }
+            # Object literal: starts with IDENTIFIER = or STRING =
+            # Action block: starts with expression (captured_ref, call, literal, etc.)
+            if self._is_object_literal():
+                return self._parse_object()
+            else:
+                return self._parse_action_block_expression()
 
         if self._match(TokenType.BRACKET_START):
             return self._parse_array()
@@ -2191,6 +2242,61 @@ class CSSLParser:
 
         return node
 
+    def _is_object_literal(self) -> bool:
+        """Check if current position is an object literal { key = value } vs action block { expr; }
+
+        Object literal: { name = value; } or { "key" = value; }
+        Action block: { %version; } or { "1.0.0" } or { call(); }
+        """
+        # Empty block is action block
+        if self._check(TokenType.BLOCK_END):
+            return False
+
+        # Save position for lookahead
+        saved_pos = self._current
+
+        # Check if it looks like key = value pattern
+        is_object = False
+        if self._check(TokenType.IDENTIFIER) or self._check(TokenType.STRING):
+            self._advance()  # skip key
+            if self._check(TokenType.EQUALS):
+                # Looks like object literal: { key = ...
+                is_object = True
+
+        # Restore position
+        self._current = saved_pos
+        return is_object
+
+    def _parse_action_block_expression(self) -> ASTNode:
+        """Parse an action block expression: { expr; expr2; } returns last value
+
+        Used for: v <== { %version; } or v <== { "1.0.0" }
+        """
+        children = []
+
+        while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+            # Parse statement or expression
+            if (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
+                self._check(TokenType.CAPTURED_REF) or self._check(TokenType.SHARED_REF) or
+                self._check(TokenType.GLOBAL_REF) or self._check(TokenType.SELF_REF) or
+                self._check(TokenType.STRING) or self._check(TokenType.NUMBER) or
+                self._check(TokenType.BOOLEAN) or self._check(TokenType.NULL) or
+                self._check(TokenType.PAREN_START)):
+                # Parse as expression and wrap in expression node for _execute_node
+                expr = self._parse_expression()
+                self._match(TokenType.SEMICOLON)
+                children.append(ASTNode('expression', value=expr))
+            elif self._check(TokenType.KEYWORD):
+                # Parse as statement
+                stmt = self._parse_statement()
+                if stmt:
+                    children.append(stmt)
+            else:
+                self._advance()
+
+        self._expect(TokenType.BLOCK_END)
+        return ASTNode('action_block', children=children)
+
     def _parse_object(self) -> ASTNode:
         properties = {}
 

{includecpp-3.5.2 → includecpp-3.5.7}/includecpp/core/cssl/cssl_runtime.py

@@ -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
@@ -799,6 +802,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
@@ -1284,8 +1290,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:
@@ -1424,11 +1443,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):
@@ -1439,7 +1467,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':
@@ -1448,7 +1476,17 @@ 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':
             # -<<== or -<<==[n] : Remove matching code from function body
@@ -1654,6 +1692,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')
@@ -1720,8 +1785,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')
@@ -1893,10 +1991,9 @@ class CSSLRuntime:
     def _eval_call(self, node: ASTNode) -> Any:
         """Evaluate function call"""
         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
+        # Get function name for injection check FIRST (before evaluating callee)
         func_name = None
         if isinstance(callee_node, ASTNode):
             if callee_node.type == 'identifier':
@@ -1908,13 +2005,18 @@ 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):
@@ -2329,22 +2431,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):
@@ -2352,16 +2539,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]):

{includecpp-3.5.2 → includecpp-3.5.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "IncludeCPP"
-version = "3.5.2"
+version = "3.5.7"
 description = "Professional C++ Python bindings with type-generic templates, pystubs and native threading"
 readme = "README.md"
 requires-python = ">=3.9"