IncludeCPP 3.8.0__py3-none-any.whl → 3.8.9__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -715,17 +715,60 @@ class CSSLRuntime:
 
         Parses class members and methods, creating a CSSLClass object
         that can be instantiated with 'new'.
+        Supports inheritance via 'extends' keyword and method overwriting via 'overwrites'.
         """
         class_info = node.value
         class_name = class_info.get('name')
+        extends_class_name = class_info.get('extends')
+        extends_is_python = class_info.get('extends_is_python', False)
+        overwrites_class_name = class_info.get('overwrites')
+        overwrites_is_python = class_info.get('overwrites_is_python', False)
+
+        # Resolve parent class if extends is specified
+        parent_class = None
+        if extends_class_name:
+            if extends_is_python:
+                # extends $PythonObject - look up in shared objects
+                from ..cssl_bridge import _live_objects, SharedObjectProxy
+                if extends_class_name in _live_objects:
+                    parent_class = _live_objects[extends_class_name]
+                    # Unwrap SharedObjectProxy if needed
+                    if isinstance(parent_class, SharedObjectProxy):
+                        parent_class = parent_class._obj
+                else:
+                    # Also check scope with $ prefix
+                    parent_class = self.global_scope.get(f'${extends_class_name}')
+            else:
+                # Try to resolve from scope (could be CSSL class or variable holding Python object)
+                parent_class = self.scope.get(extends_class_name)
+                if parent_class is None:
+                    parent_class = self.global_scope.get(extends_class_name)
+
+            if parent_class is None:
+                raise ValueError(f"Cannot extend unknown class '{extends_class_name}'")
+
+            # Auto-wrap Python objects for inheritance
+            from .cssl_builtins import CSSLizedPythonObject
+            if not isinstance(parent_class, (CSSLClass, CSSLizedPythonObject)):
+                # Wrap raw Python object
+                parent_class = CSSLizedPythonObject(parent_class, self)
 
         members = {}  # Member variable defaults/types
         methods = {}  # Method AST nodes
-        constructor = None
+        constructors = []  # List of constructors (multiple allowed with constr keyword)
+        constructor = None  # Primary constructor (backward compatibility)
+
+        # Get class parameters and extends args
+        class_params = class_info.get('class_params', [])
+        extends_args = class_info.get('extends_args', [])
 
         for child in node.children:
-            if child.type == 'function':
-                # This is a method
+            if child.type == 'constructor':
+                # New-style constructor from 'constr' keyword
+                constructors.append(child)
+
+            elif child.type == 'function':
+                # This is a method or old-style constructor
                 func_info = child.value
                 method_name = func_info.get('name')
 
@@ -752,32 +795,170 @@ class CSSLRuntime:
             name=class_name,
             members=members,
             methods=methods,
-            constructor=constructor
+            constructor=constructor,
+            parent=parent_class
         )
+        # Store additional constructor info
+        class_def.constructors = constructors  # Multiple constructors from 'constr' keyword
+        class_def.class_params = class_params  # Class-level constructor parameters
+        class_def.extends_args = extends_args  # Arguments to pass to parent constructor
 
         # Register class in scope
         self.scope.set(class_name, class_def)
         self.global_scope.set(class_name, class_def)
 
+        # Handle class overwrites - replace methods in target class
+        if overwrites_class_name:
+            self._apply_class_overwrites(
+                class_def, overwrites_class_name, overwrites_is_python
+            )
+
         return class_def
 
+    def _apply_class_overwrites(self, new_class: CSSLClass, target_name: str, is_python: bool):
+        """Apply method overwrites from new_class to target class/object.
+
+        When a class has 'overwrites' specified, all methods defined in new_class
+        will replace the corresponding methods in the target.
+        """
+        from .cssl_builtins import CSSLizedPythonObject
+
+        # Resolve target
+        target = None
+        if is_python:
+            from ..cssl_bridge import _live_objects
+            if target_name in _live_objects:
+                target = _live_objects[target_name]
+        else:
+            target = self.scope.get(target_name)
+            if target is None:
+                target = self.global_scope.get(target_name)
+
+        if target is None:
+            return  # Target not found, silently skip
+
+        # Get methods to overwrite
+        methods_to_overwrite = new_class.methods
+
+        if is_python and hasattr(target, '__class__'):
+            # Python object - overwrite methods on the object/class
+            for method_name, method_node in methods_to_overwrite.items():
+                # Create a Python-callable wrapper for the CSSL method
+                wrapper = self._create_method_wrapper(method_node, target)
+                # Set on the object
+                try:
+                    setattr(target, method_name, wrapper)
+                except AttributeError:
+                    # Try setting on class instead
+                    try:
+                        setattr(target.__class__, method_name, wrapper)
+                    except:
+                        pass
+        elif isinstance(target, CSSLClass):
+            # CSSL class - directly replace methods
+            for method_name, method_node in methods_to_overwrite.items():
+                target.methods[method_name] = method_node
+        elif isinstance(target, CSSLizedPythonObject):
+            # CSSLized Python object - get underlying object and overwrite
+            py_obj = target.get_python_obj()
+            for method_name, method_node in methods_to_overwrite.items():
+                wrapper = self._create_method_wrapper(method_node, py_obj)
+                try:
+                    setattr(py_obj, method_name, wrapper)
+                except AttributeError:
+                    try:
+                        setattr(py_obj.__class__, method_name, wrapper)
+                    except:
+                        pass
+
+    def _create_method_wrapper(self, method_node: ASTNode, instance: Any):
+        """Create a Python-callable wrapper for a CSSL method that works with an instance."""
+        def wrapper(*args, **kwargs):
+            # Set up instance context for this->
+            old_instance = self._current_instance
+            # Create a fake CSSLInstance-like wrapper if needed
+            self._current_instance = instance
+            try:
+                return self._call_function(method_node, list(args), kwargs)
+            finally:
+                self._current_instance = old_instance
+        return wrapper
+
     def _exec_function(self, node: ASTNode) -> Any:
-        """Execute function definition - just registers it"""
+        """Execute function definition - registers it and handles extends/overwrites.
+
+        Syntax:
+            define func() { ... }
+            define func : extends otherFunc() { ... }  - Inherit local vars
+            define func : overwrites otherFunc() { ... }  - Replace otherFunc
+        """
         func_info = node.value
         func_name = func_info.get('name')
+        extends_func = func_info.get('extends')
+        extends_is_python = func_info.get('extends_is_python', False)
+        overwrites_func = func_info.get('overwrites')
+        overwrites_is_python = func_info.get('overwrites_is_python', False)
+
+        # Store function extends info for runtime use
+        if extends_func:
+            node.value['_extends_resolved'] = self._resolve_function_target(
+                extends_func, extends_is_python
+            )
+
+        # Handle overwrites - replace the target function
+        if overwrites_func:
+            target = self._resolve_function_target(overwrites_func, overwrites_is_python)
+            if target is not None:
+                # Store original for reference
+                node.value['_overwrites_original'] = target
+                # Replace the target function with this one
+                if overwrites_is_python:
+                    from ..cssl_bridge import _live_objects
+                    if overwrites_func in _live_objects:
+                        # Create a wrapper that calls the CSSL function
+                        _live_objects[overwrites_func] = self._create_python_wrapper(node)
+                else:
+                    # Replace in CSSL scope
+                    self.scope.set(overwrites_func, node)
+                    self.global_scope.set(overwrites_func, node)
+
+        # Register the function
         self.scope.set(func_name, node)
         return None
 
+    def _resolve_function_target(self, name: str, is_python: bool) -> Any:
+        """Resolve a function target for extends/overwrites."""
+        if is_python:
+            from ..cssl_bridge import _live_objects
+            if name in _live_objects:
+                return _live_objects[name]
+            return self.global_scope.get(f'${name}')
+        else:
+            target = self.scope.get(name)
+            if target is None:
+                target = self.global_scope.get(name)
+            return target
+
+    def _create_python_wrapper(self, func_node: ASTNode):
+        """Create a Python-callable wrapper for a CSSL function."""
+        def wrapper(*args, **kwargs):
+            return self._call_function(func_node, list(args), kwargs)
+        return wrapper
+
     def _exec_typed_declaration(self, node: ASTNode) -> Any:
         """Execute typed variable declaration: type<T> varName = value;
 
         Creates appropriate type instances for stack, vector, datastruct, etc.
+
+        The * prefix indicates a non-nullable variable (can never be None/null).
+        Example: vector<dynamic> *MyVector - can never contain None values.
         """
         decl = node.value
         type_name = decl.get('type')
         element_type = decl.get('element_type', 'dynamic')
         var_name = decl.get('name')
         value_node = decl.get('value')
+        non_null = decl.get('non_null', False)
 
         # Create the appropriate type instance
         if type_name == 'stack':
@@ -825,11 +1006,32 @@ class CSSLRuntime:
             # For container types, the value might be initialization data
             init_value = self._evaluate(value_node)
             if isinstance(init_value, (list, tuple)):
+                # For non-null containers, filter out None values
+                if non_null:
+                    init_value = [v for v in init_value if v is not None]
                 instance.extend(init_value)
             elif init_value is not None:
                 if hasattr(instance, 'append'):
                     instance.append(init_value)
 
+        # Non-null enforcement: container types get wrapped to filter None on operations
+        if non_null:
+            # Mark the instance as non-null for runtime checks
+            if hasattr(instance, '_non_null'):
+                instance._non_null = True
+            # Track non-null variables for assignment enforcement
+            if not hasattr(self, '_non_null_vars'):
+                self._non_null_vars = set()
+            self._non_null_vars.add(var_name)
+
+            # Ensure initial value is not None for non-null variables
+            if instance is None:
+                raise CSSLRuntimeError(
+                    f"Non-null variable '*{var_name}' cannot be initialized to None",
+                    node.line,
+                    hint="Use a default value or remove the * prefix"
+                )
+
         # Check for global modifier
         modifiers = decl.get('modifiers', [])
         is_global = 'global' in modifiers
@@ -1006,6 +1208,9 @@ class CSSLRuntime:
             func_node: The function AST node
             args: List of positional arguments
             kwargs: Dict of named arguments (param_name -> value)
+
+        Supports:
+            define func : extends otherFunc() { ... } - Inherit local vars from otherFunc
         """
         func_info = func_node.value
         params = func_info.get('params', [])
@@ -1018,6 +1223,34 @@ class CSSLRuntime:
         # Create new scope
         new_scope = Scope(parent=self.scope)
 
+        # Handle function extends - inherit local vars from extended function
+        extends_resolved = func_info.get('_extends_resolved')
+        if extends_resolved:
+            if callable(extends_resolved):
+                # Python function - call it first to populate any state
+                try:
+                    extends_resolved(*args, **kwargs)
+                except:
+                    pass
+            elif hasattr(extends_resolved, 'value'):
+                # CSSL function - execute it in a temporary scope to get local vars
+                old_scope = self.scope
+                temp_scope = Scope(parent=self.scope)
+                self.scope = temp_scope
+                try:
+                    # Execute extended function body to populate local vars
+                    for child in extends_resolved.children:
+                        if not self._running:
+                            break
+                        self._execute_node(child)
+                    # Copy all local vars to new scope
+                    for name, value in temp_scope._vars.items():
+                        new_scope.set(name, value)
+                except:
+                    pass
+                finally:
+                    self.scope = old_scope
+
         # Bind parameters - handle both positional and named arguments
         for i, param in enumerate(params):
             # Extract param name and type from dict format: {'name': 'a', 'type': 'int'}
@@ -1029,10 +1262,20 @@ class CSSLRuntime:
                 param_type = ''
 
             # Check if this is an 'open' parameter - receives all args as a list
-            if param_type == 'open' or param_name == 'Params':
+            # The parser sets param['open'] = True for 'open' keyword
+            is_open_param = (isinstance(param, dict) and param.get('open', False)) or param_name == 'Params'
+            if is_open_param:
                 # 'open Params' receives all arguments as a list
-                new_scope.set(param_name, list(args))
-                new_scope.set('Params', list(args))  # Also set 'Params' for OpenFind
+                # Check for non_null flag: open *Params filters out None values
+                is_non_null = isinstance(param, dict) and param.get('non_null', False)
+                args_list = list(args)
+                if is_non_null:
+                    args_list = [a for a in args_list if a is not None]
+                    # Also filter kwargs
+                    kwargs = {k: v for k, v in kwargs.items() if v is not None}
+                new_scope.set(param_name, args_list)
+                new_scope.set('Params', args_list)  # Also set 'Params' for OpenFind
+                new_scope.set('_OpenKwargs', kwargs)  # Store kwargs for OpenFind<type, "name">
             elif param_name in kwargs:
                 # Named argument takes priority
                 new_scope.set(param_name, kwargs[param_name])
@@ -1047,6 +1290,17 @@ 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:
@@ -1267,6 +1521,82 @@ class CSSLRuntime:
         """Execute continue statement"""
         raise CSSLContinue()
 
+    def _exec_constructor(self, node: ASTNode) -> Any:
+        """Execute constructor node - only called when encountered directly.
+
+        Normally constructors are executed through _call_constructor in _eval_new.
+        This handles cases where a constructor node is executed in other contexts.
+        """
+        # Constructor nodes should be handled during class instantiation
+        # If we reach here, it's in a context where the constructor is stored but not executed
+        return None
+
+    def _exec_super_call(self, node: ASTNode) -> Any:
+        """Execute super() call to invoke parent constructor or method.
+
+        Syntax:
+            super()              - Call parent constructor with no args
+            super(arg1, arg2)    - Call parent constructor with args
+            super::method()      - Call specific parent method
+            super::method(args)  - Call specific parent method with args
+        """
+        if self._current_instance is None:
+            raise CSSLRuntimeError(
+                "super() called outside of class context",
+                node.line if hasattr(node, 'line') else 0,
+                hint="super() can only be used inside class constructors and methods"
+            )
+
+        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(
+                "super() called but class has no parent",
+                node.line if hasattr(node, 'line') else 0,
+                hint="super() requires the class to extend another class"
+            )
+
+        method_name = node.value.get('method')
+        args = [self._evaluate(arg) for arg in node.value.get('args', [])]
+
+        from .cssl_builtins import CSSLizedPythonObject
+
+        if method_name:
+            # super::method() - call specific parent method
+            if isinstance(parent, CSSLClass):
+                method = parent.methods.get(method_name)
+                if method:
+                    return self._call_method(instance, method, args, {})
+                else:
+                    raise CSSLRuntimeError(
+                        f"Parent class has no method '{method_name}'",
+                        node.line if hasattr(node, 'line') else 0
+                    )
+            elif isinstance(parent, CSSLizedPythonObject):
+                py_obj = parent.get_python_obj()
+                if hasattr(py_obj, method_name):
+                    method = getattr(py_obj, method_name)
+                    return method(*args)
+                else:
+                    raise CSSLRuntimeError(
+                        f"Parent Python object has no method '{method_name}'",
+                        node.line if hasattr(node, 'line') else 0
+                    )
+            elif hasattr(parent, method_name):
+                method = getattr(parent, method_name)
+                return method(*args)
+        else:
+            # super() - call parent constructor
+            self._call_parent_constructor(instance, args)
+            instance._parent_constructor_called = True
+
+        return None
+
     def _exec_try(self, node: ASTNode) -> Any:
         """Execute try/catch block"""
         try:
@@ -2308,6 +2638,9 @@ class CSSLRuntime:
 
         if node.type == 'literal':
             value = node.value
+            # Handle dict-format literals from parser: {'type': 'int', 'value': 0}
+            if isinstance(value, dict) and 'value' in value:
+                value = value['value']
             # String interpolation - replace {var} or <var> with scope values
             if isinstance(value, str):
                 has_fstring = '{' in value and '}' in value
@@ -2783,19 +3116,20 @@ class CSSLRuntime:
         )
 
     def _eval_typed_call(self, node: ASTNode) -> Any:
-        """Evaluate typed function call like OpenFind<string>(0)"""
+        """Evaluate typed function call like OpenFind<string>(0) or OpenFind<dynamic, "name">"""
         name = node.value.get('name')
         type_param = node.value.get('type_param', 'dynamic')
+        param_name = node.value.get('param_name')  # For OpenFind<type, "name">
         args = [self._evaluate(a) for a in node.value.get('args', [])]
 
-        # Handle OpenFind<type>(index)
+        # Handle OpenFind<type>(index) or OpenFind<type, "name">
         if name == 'OpenFind':
             # OpenFind searches for a value of the specified type
             # from the open parameters in scope
             open_params = self.scope.get('Params') or []
-            index = args[0] if args else 0
+            open_kwargs = self.scope.get('_OpenKwargs') or {}
 
-            # Search for value of matching type at or near the index
+            # Type mapping for type checking
             type_map = {
                 'string': str, 'str': str,
                 'int': int, 'integer': int,
@@ -2803,10 +3137,23 @@ class CSSLRuntime:
                 'bool': bool, 'boolean': bool,
                 'list': list, 'array': list,
                 'dict': dict, 'json': dict,
+                'dynamic': None,  # Accept any type
             }
-
             target_type = type_map.get(type_param.lower())
 
+            # If param_name is specified, search by name in kwargs
+            # OpenFind<dynamic, "tasks"> -> searches for MyFunc(tasks="value")
+            if param_name:
+                if param_name in open_kwargs:
+                    value = open_kwargs[param_name]
+                    # Type check if not dynamic
+                    if target_type is None or isinstance(value, target_type):
+                        return value
+                return None
+
+            # Otherwise, search by index in positional args
+            index = args[0] if args else 0
+
             if isinstance(open_params, (list, tuple)):
                 # Find first matching type starting from index
                 for i in range(index, len(open_params)):
@@ -2827,14 +3174,16 @@ class CSSLRuntime:
         raise CSSLRuntimeError(
             f"Unknown typed function: {name}<{type_param}>",
             node.line,
-            context=f"Available typed functions: OpenFind<type>",
-            hint="Typed functions use format: FunctionName<Type>(args)"
+            context=f"Available typed functions: OpenFind<type>, OpenFind<type, \"name\">",
+            hint="Use OpenFind<type>(index) for positional or OpenFind<type, \"name\"> for named params"
         )
 
     def _eval_new(self, node: ASTNode) -> CSSLInstance:
         """Evaluate 'new ClassName(args)' expression.
 
         Creates a new instance of a CSSL class and calls its constructor.
+        Supports multiple constructors (constr keyword), class parameters,
+        and automatic parent constructor calling.
         """
         class_name = node.value.get('class')
         args = [self._evaluate(arg) for arg in node.value.get('args', [])]
@@ -2862,12 +3211,242 @@ class CSSLRuntime:
         # Create new instance
         instance = CSSLInstance(class_def)
 
-        # Call constructor if defined
+        # Store parent class reference for super() calls
+        instance._parent_class = class_def.parent
+        instance._parent_constructor_called = False
+
+        # Get class params and extends args
+        class_params = getattr(class_def, 'class_params', [])
+        extends_args = getattr(class_def, 'extends_args', [])
+        constructors = getattr(class_def, 'constructors', [])
+
+        # Bind class_params to instance scope (they receive values from constructor args)
+        # These are the implicit constructor parameters defined in class declaration
+        param_values = {}
+        for i, param in enumerate(class_params):
+            param_name = param.get('name') if isinstance(param, dict) else param
+            if i < len(args):
+                param_values[param_name] = args[i]
+            else:
+                param_values[param_name] = None
+
+        # Call parent constructor with extends_args if parent exists and args specified
+        if class_def.parent and extends_args:
+            evaluated_extends_args = [self._evaluate(arg) for arg in extends_args]
+            self._call_parent_constructor(instance, evaluated_extends_args)
+            instance._parent_constructor_called = True
+
+        # Execute all constructors defined with 'constr' keyword (in order)
+        for constr in constructors:
+            self._call_constructor(instance, constr, args, kwargs, param_values)
+
+        # Call primary constructor (old-style) if defined
         if class_def.constructor:
             self._call_method(instance, class_def.constructor, args, kwargs)
 
         return instance
 
+    def _call_parent_constructor(self, instance: CSSLInstance, args: list, kwargs: dict = None):
+        """Call the parent class constructor on an instance.
+
+        Used for automatic parent constructor calling and super() calls.
+        """
+        kwargs = kwargs or {}
+        parent = instance._parent_class
+
+        if parent is None:
+            return
+
+        from .cssl_builtins import CSSLizedPythonObject
+
+        if isinstance(parent, CSSLClass):
+            # CSSL parent class
+            if parent.constructor:
+                self._call_method(instance, parent.constructor, args, kwargs)
+            # Also call parent's constr constructors
+            for constr in getattr(parent, 'constructors', []):
+                self._call_constructor(instance, constr, args, kwargs, {})
+        elif isinstance(parent, CSSLizedPythonObject):
+            # Python parent - call __init__ if it's a class
+            py_obj = parent.get_python_obj()
+            if isinstance(py_obj, type):
+                # It's a class - we need to initialize it
+                try:
+                    py_obj.__init__(instance, *args, **kwargs)
+                except TypeError:
+                    pass  # Initialization might not be needed
+        elif isinstance(parent, type):
+            # Raw Python class
+            try:
+                parent.__init__(instance, *args, **kwargs)
+            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
+
+        # Create new scope for constructor
+        new_scope = Scope(parent=self.scope)
+
+        # Bind param_values (from class params) to constructor scope
+        for name, value in param_values.items():
+            new_scope.set(name, value)
+
+        # Bind constructor parameters
+        for i, param in enumerate(constr_params):
+            param_name = param.get('name') if isinstance(param, dict) else param
+            if i < len(args):
+                new_scope.set(param_name, args[i])
+            elif param_name in kwargs:
+                new_scope.set(param_name, kwargs[param_name])
+            else:
+                new_scope.set(param_name, None)
+
+        # If constructor extends another constructor, inherit its local vars
+        if extends_class and extends_method:
+            parent_class = self.scope.get(extends_class) or self.global_scope.get(extends_class)
+            if parent_class and isinstance(parent_class, CSSLClass):
+                for constr in getattr(parent_class, 'constructors', []):
+                    if constr.value.get('name') == extends_method:
+                        # Execute parent constructor first to get local vars
+                        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_node(stmt)
+        finally:
+            self.scope = prev_scope
+            self._current_instance = prev_instance
+
     def _eval_this_access(self, node: ASTNode) -> Any:
         """Evaluate 'this->member' access.
 
@@ -2905,6 +3484,10 @@ class CSSLRuntime:
         if instance.has_method(member):
             # Return a callable that will invoke the method with instance context
             method_node = instance.get_method(member)
+            # Check if this is an inherited Python method
+            if isinstance(method_node, tuple) and method_node[0] == 'python_method':
+                python_method = method_node[1]
+                return lambda *args, **kwargs: python_method(*args, **kwargs)
             return lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
 
         raise CSSLRuntimeError(
@@ -2916,12 +3499,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
 
@@ -2948,6 +3537,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
@@ -2986,6 +3582,10 @@ class CSSLRuntime:
             # Check for method
             if obj.has_method(member):
                 method_node = obj.get_method(member)
+                # Check if this is an inherited Python method
+                if isinstance(method_node, tuple) and method_node[0] == 'python_method':
+                    python_method = method_node[1]
+                    return lambda *args, **kwargs: python_method(*args, **kwargs)
                 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}'")