IncludeCPP 3.8.5__tar.gz → 3.9.0__tar.gz

{includecpp-3.8.5 → includecpp-3.9.0}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.8.5
+Version: 3.9.0
 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.8.5 → includecpp-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.8.5
+Version: 3.9.0
 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.8.5 → includecpp-3.9.0}/includecpp/__init__.py

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

{includecpp-3.8.5 → includecpp-3.9.0}/includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.8.5 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
+> Version 3.8.9 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
 
 ---
 
@@ -2007,6 +2007,101 @@ class Derived : extends Base {
 }
 ```
 
+### Append Mode with `++` Operator
+
+The `++` append operator allows you to extend constructors and functions by keeping the original code and adding new code. This is useful for extending behavior without completely replacing it.
+
+#### Basic Function Append
+
+```cssl
+// Original function
+define BaseFunc() {
+    printl("Base functionality");
+}
+
+// Append to BaseFunc - keeps original + adds new
+define ExtendedFunc() &BaseFunc ++ {
+    printl("Extended functionality");
+}
+
+ExtendedFunc();
+// Output:
+// Base functionality
+// Extended functionality
+```
+
+#### Constructor Append with Class Reference
+
+```cssl
+class MyClass {
+    constr MyClassConstructor() {
+        printl("MyClass constructor");
+        this->value = 10;
+    }
+}
+
+class BetterClass :: extends MyClass {
+    // Append to specific parent constructor
+    constr BetterConstructor() &MyClass::MyClassConstructor ++ {
+        printl("BetterClass - added code");
+        this->extra = 20;
+    }
+}
+
+$instance = new BetterClass();
+// Output:
+// MyClass constructor
+// BetterClass - added code
+printl($instance.value);  // 10
+printl($instance.extra);  // 20
+```
+
+#### Method Append
+
+```cssl
+class Parent {
+    define greet() {
+        printl("Hello from Parent");
+    }
+}
+
+class Child :: extends Parent {
+    // Append to parent method
+    define betterGreet() &Parent::greet ++ {
+        printl("And also from Child!");
+    }
+}
+
+$child = new Child();
+$child.betterGreet();
+// Output:
+// Hello from Parent
+// And also from Child!
+```
+
+#### Dynamic Instance Reference
+
+You can also reference methods from instances using `&$instanceVar::member`:
+
+```cssl
+global $myInstance = new SomeClass();
+
+class Extended {
+    define extendedMethod() &$myInstance::originalMethod ++ {
+        printl("Added to instance method");
+    }
+}
+```
+
+#### Append Mode Syntax Summary
+
+| Syntax | Description |
+|--------|-------------|
+| `&FunctionName ++` | Append to a function |
+| `&ClassName::member ++` | Append to a class member (constructor/method) |
+| `&$instanceVar::member ++` | Append to an instance member |
+| `&ClassName::constructors ++` | Append to all constructors of a class |
+
 ---
 
 ## Map Container
@@ -2375,6 +2470,7 @@ print(result)  # ["Missing colon after def"]
 | `-<==` | BruteInjection | Move data |
 | `==>` | BruteInjection | Replace data |
 | `==>-` | BruteInjection | Remove matching items |
+| `++` | AppendMode | Append to parent (with `&ref`) |
 
 ### Special Syntax
 
@@ -2386,6 +2482,9 @@ print(result)  # ["Missing colon after def"]
 | `$name` | Access shared Python object |
 | `s@name` | Self-reference to struct |
 | `r@name` | Global variable declaration |
+| `&ClassName::member` | Reference class member for append mode |
+| `&$instance::member` | Reference instance member for append mode |
+| `&FunctionName ++` | Append to function (keeps old + adds new) |
 
 ---
 

{includecpp-3.8.5 → includecpp-3.9.0}/includecpp/core/cssl/cssl_parser.py

@@ -110,6 +110,9 @@ class TokenType(Enum):
     EOF = auto()
     # Super-functions for .cssl-pl payload files (v3.8.0)
     SUPER_FUNC = auto()    # #$run(), #$exec(), #$printl() - pre-execution hooks
+    # Append operator for constructor/function extension
+    PLUS_PLUS = auto()     # ++ for constructor/function append (keeps old + adds new)
+    MINUS_MINUS = auto()   # -- for potential future use
 
 
 KEYWORDS = {
@@ -307,8 +310,13 @@ class CSSLLexer:
                 self._add_token(TokenType.DOT, '.')
                 self._advance()
             elif char == '+':
+                # Check for ++ (append operator for constructor/function extension)
+                if self._peek(1) == '+':
+                    self._add_token(TokenType.PLUS_PLUS, '++')
+                    self._advance()
+                    self._advance()
                 # Check for BruteForce Injection: +<== or +<<==
-                if self._peek(1) == '<' and self._peek(2) == '<' and self._peek(3) == '=' and self._peek(4) == '=':
+                elif self._peek(1) == '<' and self._peek(2) == '<' and self._peek(3) == '=' and self._peek(4) == '=':
                     self._add_token(TokenType.INFUSE_PLUS_LEFT, '+<<==')
                     for _ in range(5): self._advance()
                 elif self._peek(1) == '<' and self._peek(2) == '=' and self._peek(3) == '=':
@@ -849,6 +857,18 @@ class CSSLParser:
                     self._advance()
                 generic_type = ''.join(generic_parts)
 
+        # Check for * prefix (non-null function) or *[type] (type exclusion)
+        non_null = False
+        exclude_type = None
+        if self._match(TokenType.MULTIPLY):
+            # Check for type exclusion filter: *[string], *[int], etc.
+            if self._check(TokenType.BRACKET_START):
+                self._advance()  # consume [
+                exclude_type = self._advance().value  # get type name
+                self._expect(TokenType.BRACKET_END)
+            else:
+                non_null = True
+
         # Get function name
         name = self._advance().value
 
@@ -949,7 +969,9 @@ class CSSLParser:
             'params': params,
             'return_type': return_type,
             'generic_type': generic_type,
-            'modifiers': modifiers
+            'modifiers': modifiers,
+            'non_null': non_null,
+            'exclude_type': exclude_type  # *[type] - must NOT return this type
         }, children=[])
 
         self._expect(TokenType.BLOCK_START)
@@ -1400,8 +1422,8 @@ class CSSLParser:
         overwrites_class = None
         overwrites_is_python = False
 
-        if self._match(TokenType.COLON):
-            # Parse extends and/or overwrites (can be chained)
+        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
+            # Parse extends and/or overwrites (can be chained with : or ::)
             while True:
                 if self._match_keyword('extends'):
                     if self._check(TokenType.IDENTIFIER):
@@ -1430,9 +1452,9 @@ class CSSLParser:
                     if self._match(TokenType.PAREN_START):
                         self._expect(TokenType.PAREN_END)
                 else:
-                    raise CSSLSyntaxError("Expected 'extends' or 'overwrites' after ':' in class declaration")
-                # Check for another : for chaining
-                if not self._match(TokenType.COLON):
+                    raise CSSLSyntaxError("Expected 'extends' or 'overwrites' after ':' or '::' in class declaration")
+                # Check for another : or :: for chaining
+                if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
                     break
 
         node = ASTNode('class', value={
@@ -1491,11 +1513,13 @@ class CSSLParser:
 
         Syntax:
             constr ConstructorName() { ... }
+            constr ConstructorName() ++ { ... }  // Append: keeps parent constructor + adds new code
+            constr ConstructorName() &ParentClass::constructors ++ { ... }  // Append specific parent constructor
             constr ConstructorName() : extends ParentClass::ConstructorName { ... }
             constr ConstructorName() : extends ParentClass::ConstructorName : overwrites ParentClass::ConstructorName { ... }
 
-        Multiple constructors are allowed and executed in order.
-        Constructors can access parent constructor via super().
+        The ++ operator means: execute parent's version first, then execute this code (append mode).
+        The &ClassName::member syntax references a specific member from the overwritten class.
         """
         # Get constructor name
         if not self._check(TokenType.IDENTIFIER):
@@ -1503,7 +1527,6 @@ class CSSLParser:
         constr_name = self._advance().value
 
         # Parse method-level extends/overwrites with :: syntax
-        # constr Name() :: extends Parent::Name :: overwrites Parent::Name { ... }
         extends_target = None
         extends_class_ref = None
         extends_method_ref = None
@@ -1511,12 +1534,39 @@ class CSSLParser:
         overwrites_class_ref = None
         overwrites_method_ref = None
 
+        # New: Append mode and reference tracking
+        append_mode = False  # ++ operator: keep parent code + add new
+        append_ref_class = None  # &ClassName part
+        append_ref_member = None  # ::member part (constructors, functionName, etc.)
+
         # Parse parameters
         params = []
         if self._match(TokenType.PAREN_START):
             params = self._parse_parameter_list()
             self._expect(TokenType.PAREN_END)
 
+        # Check for &ClassName::member reference (for targeting specific parent member)
+        # Syntax: constr Name() &ParentClass::constructors ++ { ... }
+        if self._match(TokenType.AMPERSAND):
+            # Parse the class reference
+            if self._check(TokenType.IDENTIFIER):
+                append_ref_class = self._advance().value
+            elif self._check(TokenType.SHARED_REF):
+                append_ref_class = f'${self._advance().value}'
+            else:
+                raise CSSLSyntaxError("Expected class name after '&' in constructor reference")
+
+            # Check for ::member
+            if self._match(TokenType.DOUBLE_COLON):
+                if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
+                    append_ref_member = self._advance().value
+                else:
+                    raise CSSLSyntaxError("Expected member name after '::' in constructor reference")
+
+        # Check for ++ append operator
+        if self._match(TokenType.PLUS_PLUS):
+            append_mode = True
+
         # Check for method-level extends/overwrites with :: or :
         if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
             while True:
@@ -1563,7 +1613,11 @@ class CSSLParser:
             'extends_method': extends_method_ref,
             'overwrites_target': overwrites_target,
             'overwrites_class': overwrites_class_ref,
-            'overwrites_method': overwrites_method_ref
+            'overwrites_method': overwrites_method_ref,
+            # New append mode fields
+            'append_mode': append_mode,
+            'append_ref_class': append_ref_class,
+            'append_ref_member': append_ref_member
         }, children=body)
 
     def _parse_qualified_method_ref(self) -> str:
@@ -1591,6 +1645,54 @@ class CSSLParser:
         # Just method name, no class qualifier
         return class_ref
 
+    def _parse_parameter_list(self) -> list:
+        """Parse a list of parameters (without the surrounding parentheses).
+
+        Returns a list of parameter definitions, each can be:
+        - Simple string name: "paramName"
+        - Dict with type info: {'name': 'paramName', 'type': 'string', 'ref': True, ...}
+        """
+        params = []
+        while not self._check(TokenType.PAREN_END) and not self._is_at_end():
+            param_info = {}
+
+            # Handle 'open' keyword for open parameters
+            if self._match_keyword('open'):
+                param_info['open'] = True
+
+            # Handle type annotations (e.g., string, int, dynamic, etc.)
+            if self._check(TokenType.KEYWORD):
+                param_info['type'] = self._advance().value
+
+            # Handle reference operator &
+            if self._match(TokenType.AMPERSAND):
+                param_info['ref'] = True
+
+            # Handle * prefix for non-null parameters
+            if self._match(TokenType.MULTIPLY):
+                param_info['non_null'] = True
+
+            # Get parameter name
+            if self._check(TokenType.IDENTIFIER):
+                param_name = self._advance().value
+                if param_info:
+                    params.append({'name': param_name, **param_info})
+                else:
+                    params.append(param_name)
+                self._match(TokenType.COMMA)
+            elif self._check(TokenType.KEYWORD):
+                # Parameter name could be a keyword like 'Params'
+                param_name = self._advance().value
+                if param_info:
+                    params.append({'name': param_name, **param_info})
+                else:
+                    params.append(param_name)
+                self._match(TokenType.COMMA)
+            else:
+                break
+
+        return params
+
     def _parse_define(self) -> ASTNode:
         """Parse define function declaration.
 
@@ -1602,9 +1704,17 @@ class CSSLParser:
             define MyFunc :: extends Parent::Method :: overwrites Parent::Method() { }  // Method-level inheritance
         """
         # Check for * prefix (non-null function - must return non-null)
+        # Also *[type] for type exclusion (must NOT return that type)
         non_null = False
+        exclude_type = None
         if self._match(TokenType.MULTIPLY):
-            non_null = True
+            # Check for type exclusion filter: *[string], *[int], etc.
+            if self._check(TokenType.BRACKET_START):
+                self._advance()  # consume [
+                exclude_type = self._advance().value  # get type name
+                self._expect(TokenType.BRACKET_END)
+            else:
+                non_null = True
 
         name = self._advance().value
 
@@ -1721,10 +1831,37 @@ class CSSLParser:
                     break
             self._expect(TokenType.PAREN_END)
 
+        # New: Append mode and reference tracking for functions
+        # Syntax: define XYZ(int zahl) &overwrittenclass::functionyouwanttokeep ++ { ... }
+        append_mode = False
+        append_ref_class = None
+        append_ref_member = None
+
+        # Check for &ClassName::member reference
+        if self._match(TokenType.AMPERSAND):
+            if self._check(TokenType.IDENTIFIER):
+                append_ref_class = self._advance().value
+            elif self._check(TokenType.SHARED_REF):
+                append_ref_class = f'${self._advance().value}'
+            else:
+                raise CSSLSyntaxError("Expected class name after '&' in function reference")
+
+            # Check for ::member
+            if self._match(TokenType.DOUBLE_COLON):
+                if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
+                    append_ref_member = self._advance().value
+                else:
+                    raise CSSLSyntaxError("Expected member name after '::' in function reference")
+
+        # Check for ++ append operator
+        if self._match(TokenType.PLUS_PLUS):
+            append_mode = True
+
         node = ASTNode('function', value={
             'name': name,
             'params': params,
             'non_null': non_null,
+            'exclude_type': exclude_type,  # *[type] - must NOT return this type
             'extends': extends_func,
             'extends_is_python': extends_is_python,
             'overwrites': overwrites_func,
@@ -1733,7 +1870,11 @@ class CSSLParser:
             'extends_class': extends_class_ref,
             'extends_method': extends_method_ref,
             'overwrites_class': overwrites_class_ref,
-            'overwrites_method': overwrites_method_ref
+            'overwrites_method': overwrites_method_ref,
+            # New append mode fields
+            'append_mode': append_mode,
+            'append_ref_class': append_ref_class,
+            'append_ref_member': append_ref_member
         }, children=[])
         self._expect(TokenType.BLOCK_START)
 
@@ -1781,8 +1922,9 @@ class CSSLParser:
             # Super-function for .cssl-pl payload files
             return self._parse_super_function()
         elif (self._check(TokenType.KEYWORD) and self._current().value == 'super' and
-              self._peek(1).type == TokenType.PAREN_START):
-            # super() call - calls parent constructor/method
+              (self._peek(1).type == TokenType.PAREN_START or
+               self._peek(1).type == TokenType.DOUBLE_COLON)):
+            # super() or super::method() call - calls parent constructor/method
             return self._parse_super_call()
         elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
               self._check(TokenType.CAPTURED_REF) or self._check(TokenType.SHARED_REF) or
@@ -2593,6 +2735,26 @@ class CSSLParser:
             operand = self._parse_unary()
             return ASTNode('reference', value=operand)
 
+        # Non-null assertion: *$var, *@module, *identifier
+        # Also type exclusion filter: *[type]expr - exclude type from return
+        if self._check(TokenType.MULTIPLY):
+            next_token = self._peek(1)
+
+            # Check for type exclusion filter: *[string], *[int], etc.
+            if next_token and next_token.type == TokenType.BRACKET_START:
+                self._advance()  # consume *
+                self._advance()  # consume [
+                exclude_type = self._advance().value  # get type name
+                self._expect(TokenType.BRACKET_END)
+                operand = self._parse_unary()
+                return ASTNode('type_exclude_assert', value={'exclude_type': exclude_type, 'operand': operand})
+
+            # Non-null assertion when followed by $ (shared ref), @ (global), or identifier
+            if next_token and next_token.type in (TokenType.SHARED_REF, TokenType.AT, TokenType.IDENTIFIER):
+                self._advance()  # consume *
+                operand = self._parse_unary()
+                return ASTNode('non_null_assert', value={'operand': operand})
+
         return self._parse_primary()
 
     def _parse_primary(self) -> ASTNode:

{includecpp-3.8.5 → includecpp-3.9.0}/includecpp/core/cssl/cssl_runtime.py

@@ -1242,7 +1242,7 @@ class CSSLRuntime:
                     for child in extends_resolved.children:
                         if not self._running:
                             break
-                        self._execute(child)
+                        self._execute_node(child)
                     # Copy all local vars to new scope
                     for name, value in temp_scope._vars.items():
                         new_scope.set(name, value)
@@ -1290,13 +1290,43 @@ class CSSLRuntime:
         self.scope = new_scope
 
         try:
+            # Handle append mode (++) - execute referenced function first
+            append_mode = func_info.get('append_mode', False)
+            append_ref_class = func_info.get('append_ref_class')
+            append_ref_member = func_info.get('append_ref_member')
+
+            if append_mode and append_ref_class:
+                self._execute_append_reference(
+                    None, append_ref_class, append_ref_member,
+                    args, kwargs, {}, is_constructor=False
+                )
+
             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
+            return_value = ret.value
+
+            # Check exclude_type: *[type] - must NOT return excluded type
+            exclude_type = func_info.get('exclude_type')
+            if exclude_type:
+                type_map = {
+                    'string': str, 'int': int, 'float': float, 'bool': bool,
+                    'null': type(None), 'none': type(None),
+                    'list': list, 'array': list, 'dict': dict, 'json': dict,
+                }
+                excluded_py_type = type_map.get(exclude_type.lower())
+                # For shuffled returns (tuples), check each element
+                if isinstance(return_value, tuple):
+                    for val in return_value:
+                        if excluded_py_type and isinstance(val, excluded_py_type):
+                            raise CSSLError(f"Type exclusion: function must NOT return '{exclude_type}' values")
+                elif excluded_py_type and isinstance(return_value, excluded_py_type):
+                    raise CSSLError(f"Type exclusion: function must NOT return '{exclude_type}'")
+
+            return return_value
         except Exception as e:
             # If undefined modifier, suppress all errors
             if is_undefined:
@@ -1537,7 +1567,11 @@ class CSSLRuntime:
             )
 
         instance = self._current_instance
+
+        # Try to get parent from instance first, then from class definition
         parent = getattr(instance, '_parent_class', None)
+        if parent is None and hasattr(instance, '_class') and instance._class:
+            parent = getattr(instance._class, 'parent', None)
 
         if parent is None:
             raise CSSLRuntimeError(
@@ -2816,6 +2850,39 @@ class CSSLRuntime:
         if node.type == 'unary':
             return self._eval_unary(node)
 
+        if node.type == 'non_null_assert':
+            # *$var, *@module, *identifier - assert value is not null/None
+            operand = node.value.get('operand')
+            value = self._evaluate(operand)
+            if value is None:
+                raise CSSLError(f"Non-null assertion failed: value is null/None")
+            return value
+
+        if node.type == 'type_exclude_assert':
+            # *[type]expr - assert value is NOT of excluded type
+            exclude_type = node.value.get('exclude_type')
+            operand = node.value.get('operand')
+            value = self._evaluate(operand)
+
+            # Map CSSL types to Python types
+            type_map = {
+                'string': str,
+                'int': int,
+                'float': float,
+                'bool': bool,
+                'null': type(None),
+                'none': type(None),
+                'list': list,
+                'array': list,
+                'dict': dict,
+                'json': dict,
+            }
+
+            excluded_py_type = type_map.get(exclude_type.lower())
+            if excluded_py_type and isinstance(value, excluded_py_type):
+                raise CSSLError(f"Type exclusion assertion failed: value is of excluded type '{exclude_type}'")
+            return value
+
         if node.type == 'call':
             return self._eval_call(node)
 
@@ -3267,17 +3334,122 @@ class CSSLRuntime:
             except TypeError:
                 pass
 
+    def _execute_append_reference(self, instance: CSSLInstance, ref_class: str, ref_member: str,
+                                   args: list, kwargs: dict, param_values: dict, is_constructor: bool = True):
+        """Execute referenced parent constructor/method for append mode (++).
+
+        Resolves the class/instance reference and executes the specified member.
+        Supports:
+        - Static class references: &ClassName::member
+        - Dynamic instance references: &$instanceVar::member
+        - Direct function references: &FunctionName (for define functions)
+
+        Args:
+            instance: Current class instance (can be None for standalone functions)
+            ref_class: Referenced class name, $instanceVar, or function name
+            ref_member: Member name (constructor name, 'constructors', or method name) - can be None
+            args: Arguments to pass
+            kwargs: Keyword arguments to pass
+            param_values: Parameter values from class params
+            is_constructor: True if looking for constructor, False for method
+        """
+        from .cssl_builtins import CSSLizedPythonObject
+
+        # Handle direct function reference: &FunctionName ++ (no ::member part)
+        if ref_member is None and not is_constructor:
+            # ref_class is actually a function name
+            func_name = ref_class
+            if func_name.startswith('$'):
+                func_name = func_name[1:]
+
+            # Look for the function in scope
+            func = self.scope.get(func_name) or self.global_scope.get(func_name)
+            if func is not None:
+                if isinstance(func, ASTNode) and func.type in ('function', 'FUNCTION'):
+                    # Execute the referenced function
+                    if instance:
+                        self._call_method(instance, func, args, kwargs)
+                    else:
+                        self._call_function(func, args, kwargs)
+                elif callable(func):
+                    # It's a callable (Python function or lambda)
+                    func(*args, **kwargs)
+            return
+
+        # Resolve the class/instance reference
+        if ref_class.startswith('$'):
+            # Dynamic instance reference: &$instanceVar::member
+            var_name = ref_class[1:]
+            ref_obj = self.scope.get(var_name) or self.global_scope.get(var_name)
+            if ref_obj is None:
+                return  # Instance not found, skip silently
+
+            if isinstance(ref_obj, CSSLInstance):
+                # Get the class definition from the instance
+                target_class = ref_obj.class_def
+            elif isinstance(ref_obj, CSSLClass):
+                target_class = ref_obj
+            else:
+                return  # Not a valid reference
+        else:
+            # Static class reference: &ClassName::member
+            target_class = self.scope.get(ref_class) or self.global_scope.get(ref_class)
+
+        if target_class is None:
+            return  # Class not found, skip silently
+
+        # Handle different target types
+        if isinstance(target_class, CSSLInstance):
+            # Referenced an instance variable directly
+            target_class = target_class.class_def
+
+        if not isinstance(target_class, CSSLClass):
+            return  # Not a CSSL class
+
+        # Find and execute the referenced member
+        if is_constructor:
+            # Looking for a constructor
+            if ref_member == 'constructors' or ref_member is None:
+                # Execute all constructors from the referenced class
+                for constr in getattr(target_class, 'constructors', []):
+                    self._call_constructor(instance, constr, args, kwargs, param_values)
+            else:
+                # Execute specific constructor by name
+                for constr in getattr(target_class, 'constructors', []):
+                    if constr.value.get('name') == ref_member:
+                        self._call_constructor(instance, constr, args, kwargs, param_values)
+                        break
+        else:
+            # Looking for a method (define function)
+            if ref_member:
+                # Find method in class
+                for member in getattr(target_class, 'members', []):
+                    if member.type in ('function', 'FUNCTION') and member.value.get('name') == ref_member:
+                        self._call_method(instance, member, args, kwargs)
+                        break
+                # Also check in methods dict if available
+                methods = getattr(target_class, 'methods', {})
+                if ref_member in methods:
+                    method_node = methods[ref_member]
+                    self._call_method(instance, method_node, args, kwargs)
+
     def _call_constructor(self, instance: CSSLInstance, constr_node: ASTNode,
                           args: list, kwargs: dict, param_values: dict):
         """Call a constructor defined with 'constr' keyword.
 
         Handles constructor extends/overwrites and sets up the instance scope.
+        Supports append mode (++) for keeping parent code and adding new code.
         """
         constr_info = constr_node.value
         constr_params = constr_info.get('params', [])
         extends_class = constr_info.get('extends_class')
         extends_method = constr_info.get('extends_method')
 
+        # Append mode: ++ operator for keeping parent code + adding new
+        append_mode = constr_info.get('append_mode', False)
+        append_ref_class = constr_info.get('append_ref_class')  # &ClassName or &$instanceVar
+        append_ref_member = constr_info.get('append_ref_member')  # ::constructorName or ::methodName
+
         # Save previous instance context
         prev_instance = self._current_instance
         self._current_instance = instance
@@ -3309,13 +3481,20 @@ class CSSLRuntime:
                         self._call_constructor(instance, constr, args, kwargs, param_values)
                         break
 
+        # Handle append mode (++) - execute referenced parent member first
+        if append_mode and append_ref_class:
+            self._execute_append_reference(
+                instance, append_ref_class, append_ref_member,
+                args, kwargs, param_values, is_constructor=True
+            )
+
         # Execute constructor body
         prev_scope = self.scope
         self.scope = new_scope
 
         try:
             for stmt in constr_node.children:
-                self._execute(stmt)
+                self._execute_node(stmt)
         finally:
             self.scope = prev_scope
             self._current_instance = prev_instance
@@ -3372,12 +3551,18 @@ class CSSLRuntime:
         """Call a method on an instance with 'this' context.
 
         Sets up the instance as the current 'this' context and executes the method.
+        Supports append mode (++) for keeping parent code and adding new code.
         """
         kwargs = kwargs or {}
         func_info = method_node.value
         params = func_info.get('params', [])
         modifiers = func_info.get('modifiers', [])
 
+        # Append mode: ++ operator for keeping parent code + adding new
+        append_mode = func_info.get('append_mode', False)
+        append_ref_class = func_info.get('append_ref_class')  # &ClassName or &$instanceVar
+        append_ref_member = func_info.get('append_ref_member')  # ::methodName
+
         # Check for undefined modifier
         is_undefined = 'undefined' in modifiers
 
@@ -3404,6 +3589,13 @@ class CSSLRuntime:
         self._current_instance = instance
 
         try:
+            # Handle append mode (++) - execute referenced parent method first
+            if append_mode and append_ref_class:
+                self._execute_append_reference(
+                    instance, append_ref_class, append_ref_member,
+                    args, kwargs, {}, is_constructor=False
+                )
+
             for child in method_node.children:
                 if not self._running:
                     break

{includecpp-3.8.5 → includecpp-3.9.0}/includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json

@@ -7,6 +7,8 @@
         { "include": "#comments" },
         { "include": "#strings" },
         { "include": "#numbers" },
+        { "include": "#append-operator" },
+        { "include": "#append-reference" },
         { "include": "#class-definition" },
         { "include": "#function-definitions" },
         { "include": "#constructor-definition" },
@@ -35,6 +37,29 @@
         { "include": "#variables" }
     ],
     "repository": {
+        "append-operator": {
+            "patterns": [
+                {
+                    "comment": "++ append operator for constructor/function extension - orange",
+                    "name": "constant.character.escape.infuse.cssl",
+                    "match": "\\+\\+(?=\\s*\\{)"
+                }
+            ]
+        },
+        "append-reference": {
+            "patterns": [
+                {
+                    "comment": "&ClassName::member or &$var::member - all yellow for append reference",
+                    "name": "entity.name.tag.super.cssl",
+                    "match": "&(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(::)([a-zA-Z_][a-zA-Z0-9_]*)"
+                },
+                {
+                    "comment": "&FunctionName - yellow for direct function reference",
+                    "name": "entity.name.tag.super.cssl",
+                    "match": "&([a-zA-Z_][a-zA-Z0-9_]*)(?=\\s*\\+\\+)"
+                }
+            ]
+        },
         "non-null-declarations": {
             "patterns": [
                 {

{includecpp-3.8.5 → includecpp-3.9.0}/pyproject.toml

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