IncludeCPP 3.8.3__tar.gz → 3.8.4__tar.gz

{includecpp-3.8.3 → includecpp-3.8.4}/IncludeCPP.egg-info/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.8.3
+Version: 3.8.4
 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.3 → includecpp-3.8.4}/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.3"
+__version__ = "3.8.4"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

{includecpp-3.8.3 → includecpp-3.8.4}/includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.7.6 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
+> Version 3.8.4 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
 
 ---
 
@@ -1696,6 +1696,201 @@ string result = b.add("Hello ").add("World!").build();
 printl(result);  // prints: "Hello World!"
 ```
 
+### Class Inheritance (extends)
+
+CSSL supports class inheritance using the `: extends` syntax:
+
+```cssl
+// Base class
+class Animal {
+    string name;
+
+    void Animal(string n) {
+        this->name = n;
+    }
+
+    void speak() {
+        printl("Some sound");
+    }
+}
+
+// Derived class - inherits all members and methods from Animal
+class Dog : extends Animal {
+    void Dog(string n) {
+        this->name = n;
+    }
+
+    // Override parent method
+    void speak() {
+        printl("Woof! I'm " + this->name);
+    }
+
+    // New method only in Dog
+    void fetch() {
+        printl(this->name + " fetches the ball!");
+    }
+}
+
+Dog d = new Dog("Buddy");
+d.speak();    // "Woof! I'm Buddy"
+d.fetch();    // "Buddy fetches the ball!"
+```
+
+### Extending Python Objects
+
+You can extend Python classes/objects directly:
+
+```cssl
+// Extend a Python object using $
+class ExtendedGame : extends $GameEngine {
+    void newFeature() {
+        printl("New CSSL feature!");
+    }
+
+    // Override a Python method
+    void showUsername() {
+        printl("Custom username display: " + this->username);
+    }
+}
+```
+
+In Python:
+```python
+class GameEngine:
+    def __init__(self):
+        self.username = "Player1"
+    def showUsername(self):
+        print(f"Username: {self.username}")
+
+cssl = CSSL.CsslLang()
+cssl.share('GameEngine', GameEngine())
+cssl.run('''
+    class MyGame : extends $GameEngine {
+        void customMethod() {
+            printl("Extended from Python!");
+        }
+    }
+''')
+```
+
+### Class Overwrites
+
+Use `: overwrites` to replace methods in an existing class/object:
+
+```cssl
+// Overwrite methods in a Python object
+class MyOverrides : extends $GameEngine : overwrites $GameEngine {
+    // This method will REPLACE the original showUsername() in $GameEngine
+    void showUsername() {
+        printl("OVERWRITTEN: " + this->username);
+    }
+}
+```
+
+When you use `: overwrites TargetClass`, all methods defined in your class will replace the corresponding methods in the target. This works with:
+- Other CSSL classes
+- Python objects via `$ObjectName`
+- Shared objects
+
+### python::csslize() - Import Python Objects
+
+Convert Python objects to CSSL-compatible wrappers:
+
+```cssl
+// Import a Python object
+py_obj <== python::csslize($MyPythonInstance);
+
+// Now use it like a CSSL object
+py_obj.someMethod();
+printl(py_obj.someProperty);
+
+// Or use it as a base class
+class Extended : extends py_obj {
+    void newMethod() { ... }
+}
+```
+
+In Python:
+```python
+class MyPythonClass:
+    def __init__(self, name):
+        self.name = name
+    def greet(self):
+        return f"Hello, {self.name}!"
+
+cssl = CSSL.CsslLang()
+cssl.share('MyPython', MyPythonClass("World"))
+result = cssl.run('''
+    py_obj <== python::csslize($MyPython);
+    printl(py_obj.greet());  // "Hello, World!"
+''')
+```
+
+### Function Extends & Overwrites
+
+Functions can also extend or overwrite other functions:
+
+```cssl
+// Base function
+define baseFunction() {
+    string greeting = "Hello";
+    int count = 42;
+    printl(greeting);
+}
+
+// Extend: inherit local variables from baseFunction
+define extendedFunc : extends baseFunction() {
+    // 'greeting' and 'count' are available here!
+    printl(greeting + " World! Count: " + count);
+}
+
+// Overwrite: replace the original function
+define myReplacement : overwrites baseFunction() {
+    printl("This replaces baseFunction entirely!");
+}
+
+// After defining myReplacement, calling baseFunction()
+// will now execute myReplacement instead
+baseFunction();  // prints: "This replaces baseFunction entirely!"
+```
+
+Overwriting Python functions:
+```cssl
+// Replace a shared Python function
+define myVersion : overwrites $pythonFunc() {
+    printl("CSSL implementation replaces Python!");
+}
+```
+
+### Non-Null Declarations
+
+Use `*` prefix to declare non-nullable items:
+
+```cssl
+// Non-null variable - can never be None
+vector<dynamic> *myList;  // Always initialized, never null
+
+// Non-null function - must never return None
+define *alwaysReturns() {
+    return "Always a value";  // Error if returns null
+}
+
+// Non-null class - all methods return non-null
+class *MyClass {
+    string getValue() {
+        return "Value";  // All methods must return non-null
+    }
+}
+
+// Non-null open parameter - filters out None values
+define process(open *Params) {
+    // Params will never contain None values
+    foreach item in Params {
+        printl(item);  // Guaranteed non-null
+    }
+}
+```
+
 ---
 
 ## Map Container

{includecpp-3.8.3 → includecpp-3.8.4}/includecpp/core/cssl/cssl_builtins.py

@@ -209,6 +209,8 @@ class CSSLBuiltins:
         self._functions['python::pythonize'] = self.builtin_python_pythonize
         self._functions['python::wrap'] = self.builtin_python_pythonize  # Alias
         self._functions['python::export'] = self.builtin_python_pythonize  # Alias
+        self._functions['python::csslize'] = self.builtin_python_csslize
+        self._functions['python::import'] = self.builtin_python_csslize  # Alias
 
         # Regex functions
         self._functions['match'] = self.builtin_match
@@ -2524,6 +2526,137 @@ class CSSLBuiltins:
 
         return PythonizedCSSLInstance(cssl_instance, self.runtime)
 
+    def builtin_python_csslize(self, python_obj: Any) -> Any:
+        """Convert a Python object (class instance or function) to a CSSL-compatible wrapper.
+
+        Syntax:
+            cssl_obj <== python::csslize($python_instance);
+            cssl_func <== python::csslize($python_function);
+
+        Example:
+            # In Python:
+            class MyPythonClass:
+                def __init__(self, name):
+                    self.name = name
+                def greet(self):
+                    return f"Hello, {self.name}!"
+
+            cssl = CSSL.CsslLang()
+            cssl.set_variable('MyPython', MyPythonClass("World"))
+            result = cssl.run('''
+                py_obj <== python::csslize($MyPython);
+                printl(py_obj.greet());  // "Hello, World!"
+            ''')
+
+        For class inheritance:
+            py_class <== python::csslize($MyPythonClass);
+            class MyExtended : extends py_class {
+                void newMethod() { ... }
+            }
+
+        Args:
+            python_obj: A Python object (class instance, function, or class)
+
+        Returns:
+            CSSLizedPythonObject - A CSSL-compatible wrapper
+        """
+        if python_obj is None:
+            return None
+
+        # Already csslized
+        if isinstance(python_obj, CSSLizedPythonObject):
+            return python_obj
+
+        # Wrap the Python object
+        return CSSLizedPythonObject(python_obj, self.runtime)
+
+
+class CSSLizedPythonObject:
+    """CSSL wrapper for Python objects (classes, instances, functions).
+
+    Allows Python objects to be used within CSSL code, including as base classes.
+    """
+
+    def __init__(self, python_obj: Any, runtime: Any = None):
+        self._python_obj = python_obj
+        self._runtime = runtime
+        self._is_class = isinstance(python_obj, type)
+        self._is_callable = callable(python_obj) and not self._is_class
+
+    def __repr__(self):
+        if self._is_class:
+            return f"<CSSLizedPythonClass: {self._python_obj.__name__}>"
+        elif self._is_callable:
+            return f"<CSSLizedPythonFunction: {getattr(self._python_obj, '__name__', 'anonymous')}>"
+        else:
+            return f"<CSSLizedPythonInstance: {type(self._python_obj).__name__}>"
+
+    def __call__(self, *args, **kwargs):
+        """Call the wrapped object (for functions or class instantiation)."""
+        return self._python_obj(*args, **kwargs)
+
+    def __getattr__(self, name: str) -> Any:
+        """Get attribute from wrapped Python object."""
+        if name.startswith('_'):
+            raise AttributeError(f"Cannot access private attribute '{name}'")
+
+        obj = object.__getattribute__(self, '_python_obj')
+
+        if hasattr(obj, name):
+            attr = getattr(obj, name)
+            # If it's a method, wrap it for CSSL calling
+            if callable(attr):
+                return CSSLizedPythonMethod(attr, self._runtime)
+            return attr
+
+        raise AttributeError(f"Python object has no attribute '{name}'")
+
+    def __setattr__(self, name: str, value: Any):
+        """Set attribute on wrapped Python object."""
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._python_obj, name, value)
+
+    def has_member(self, name: str) -> bool:
+        """Check if the Python object has a member."""
+        return hasattr(self._python_obj, name)
+
+    def get_member(self, name: str) -> Any:
+        """Get a member from the Python object."""
+        return getattr(self._python_obj, name, None)
+
+    def set_member(self, name: str, value: Any):
+        """Set a member on the Python object."""
+        setattr(self._python_obj, name, value)
+
+    def get_method(self, name: str):
+        """Get a method from the Python object."""
+        if hasattr(self._python_obj, name):
+            method = getattr(self._python_obj, name)
+            if callable(method):
+                return CSSLizedPythonMethod(method, self._runtime)
+        return None
+
+    def get_python_obj(self):
+        """Get the underlying Python object (for inheritance)."""
+        return self._python_obj
+
+
+class CSSLizedPythonMethod:
+    """Wrapper for Python methods to be called from CSSL."""
+
+    def __init__(self, method: Any, runtime: Any = None):
+        self._method = method
+        self._runtime = runtime
+
+    def __call__(self, *args, **kwargs):
+        """Call the Python method."""
+        return self._method(*args, **kwargs)
+
+    def __repr__(self):
+        return f"<CSSLizedPythonMethod: {getattr(self._method, '__name__', 'anonymous')}>"
+
 
 class PythonizedCSSLInstance:
     """Python wrapper for CSSL class instances.

{includecpp-3.8.3 → includecpp-3.8.4}/includecpp/core/cssl/cssl_parser.py

@@ -114,7 +114,7 @@ class TokenType(Enum):
 
 KEYWORDS = {
     # Service structure
-    'service-init', 'service-run', 'service-include', 'struct', 'define', 'main', 'class', 'new', 'this',
+    'service-init', 'service-run', 'service-include', 'struct', 'define', 'main', 'class', 'extends', 'overwrites', 'new', 'this',
     # Control flow
     'if', 'else', 'elif', 'while', 'for', 'foreach', 'in', 'range',
     'switch', 'case', 'default', 'break', 'continue', 'return',
@@ -1045,7 +1045,7 @@ class CSSLParser:
 
         # Check for * prefix (non-nullable indicator)
         non_null = False
-        if self._match(TokenType.ASTERISK):
+        if self._match(TokenType.MULTIPLY):
             non_null = True
 
         # Get variable name
@@ -1378,12 +1378,56 @@ class CSSLParser:
         """
         # Check for * prefix (non-null class - all methods return non-null)
         non_null = False
-        if self._match(TokenType.ASTERISK):
+        if self._match(TokenType.MULTIPLY):
             non_null = True
 
         class_name = self._advance().value
 
-        node = ASTNode('class', value={'name': class_name, 'non_null': non_null}, children=[])
+        # Check for inheritance and overwrites:
+        # class Child : extends Parent { ... }
+        # class Child : extends $PythonObject { ... }
+        # class Child : extends Parent : overwrites Parent { ... }
+        extends_class = None
+        extends_is_python = False
+        overwrites_class = None
+        overwrites_is_python = False
+
+        if self._match(TokenType.COLON):
+            # Parse extends and/or overwrites (can be chained)
+            while True:
+                if self._match_keyword('extends'):
+                    if self._check(TokenType.IDENTIFIER):
+                        extends_class = self._advance().value
+                    elif self._check(TokenType.SHARED_REF):
+                        extends_class = self._advance().value
+                        extends_is_python = True
+                    else:
+                        raise CSSLSyntaxError("Expected parent class name after 'extends'")
+                elif self._match_keyword('overwrites'):
+                    if self._check(TokenType.IDENTIFIER):
+                        overwrites_class = self._advance().value
+                    elif self._check(TokenType.SHARED_REF):
+                        overwrites_class = self._advance().value
+                        overwrites_is_python = True
+                    else:
+                        raise CSSLSyntaxError("Expected class name after 'overwrites'")
+                    # Skip optional () after class name
+                    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):
+                    break
+
+        node = ASTNode('class', value={
+            'name': class_name,
+            'non_null': non_null,
+            'extends': extends_class,
+            'extends_is_python': extends_is_python,
+            'overwrites': overwrites_class,
+            'overwrites_is_python': overwrites_is_python
+        }, children=[])
         self._expect(TokenType.BLOCK_START)
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
@@ -1424,13 +1468,53 @@ class CSSLParser:
         Syntax:
             define MyFunc(args) { }
             define *MyFunc(args) { }  // Non-null: must never return None
+            define MyFunc : extends OtherFunc() { }  // Inherit local vars
+            define MyFunc : overwrites OtherFunc() { }  // Replace OtherFunc
         """
         # Check for * prefix (non-null function - must return non-null)
         non_null = False
-        if self._match(TokenType.ASTERISK):
+        if self._match(TokenType.MULTIPLY):
             non_null = True
 
         name = self._advance().value
+
+        # Check for extends/overwrites: define func : extends/overwrites target() { }
+        extends_func = None
+        overwrites_func = None
+        extends_is_python = False
+        overwrites_is_python = False
+
+        if self._match(TokenType.COLON):
+            # Parse extends and/or overwrites
+            while True:
+                if self._match_keyword('extends'):
+                    if self._check(TokenType.IDENTIFIER):
+                        extends_func = self._advance().value
+                    elif self._check(TokenType.SHARED_REF):
+                        extends_func = self._advance().value
+                        extends_is_python = True
+                    else:
+                        raise CSSLSyntaxError("Expected function name after 'extends'")
+                    # Skip optional () after function name
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                elif self._match_keyword('overwrites'):
+                    if self._check(TokenType.IDENTIFIER):
+                        overwrites_func = self._advance().value
+                    elif self._check(TokenType.SHARED_REF):
+                        overwrites_func = self._advance().value
+                        overwrites_is_python = True
+                    else:
+                        raise CSSLSyntaxError("Expected function name after 'overwrites'")
+                    # Skip optional () after function name
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                else:
+                    break
+                # Check for another : for chaining extends/overwrites
+                if not self._match(TokenType.COLON):
+                    break
+
         params = []
 
         if self._match(TokenType.PAREN_START):
@@ -1446,7 +1530,7 @@ class CSSLParser:
                 if self._match(TokenType.AMPERSAND):
                     param_info['ref'] = True
                 # Handle * prefix for non-null parameters
-                if self._match(TokenType.ASTERISK):
+                if self._match(TokenType.MULTIPLY):
                     param_info['non_null'] = True
                 # Get parameter name
                 if self._check(TokenType.IDENTIFIER):
@@ -1468,7 +1552,15 @@ class CSSLParser:
                     break
             self._expect(TokenType.PAREN_END)
 
-        node = ASTNode('function', value={'name': name, 'params': params, 'non_null': non_null}, children=[])
+        node = ASTNode('function', value={
+            'name': name,
+            'params': params,
+            'non_null': non_null,
+            'extends': extends_func,
+            'extends_is_python': extends_is_python,
+            'overwrites': overwrites_func,
+            'overwrites_is_python': overwrites_is_python
+        }, children=[])
         self._expect(TokenType.BLOCK_START)
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():

{includecpp-3.8.3 → includecpp-3.8.4}/includecpp/core/cssl/cssl_runtime.py

@@ -715,9 +715,43 @@ 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
@@ -752,22 +786,152 @@ class CSSLRuntime:
             name=class_name,
             members=members,
             methods=methods,
-            constructor=constructor
+            constructor=constructor,
+            parent=parent_class
         )
 
         # 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;
 
@@ -1031,6 +1195,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', [])
@@ -1043,6 +1210,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(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'}
@@ -2957,6 +3152,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(
@@ -3038,6 +3237,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}'")
 

{includecpp-3.8.3 → includecpp-3.8.4}/includecpp/core/cssl/cssl_types.py

@@ -1448,17 +1448,62 @@ class CSSLClass:
 
     Stores class name, member variables, methods, and constructor.
     Used by the runtime to instantiate CSSLInstance objects.
+    Supports inheritance via the 'parent' attribute.
     """
 
     def __init__(self, name: str, members: Dict[str, Any] = None,
-                 methods: Dict[str, Any] = None, constructor: Any = None):
+                 methods: Dict[str, Any] = None, constructor: Any = None,
+                 parent: Any = None):
         self.name = name
         self.members = members or {}  # Default member values/types
         self.methods = methods or {}  # Method AST nodes
         self.constructor = constructor  # Constructor AST node
+        self.parent = parent  # Parent class (CSSLClass or CSSLizedPythonObject)
+
+    def get_all_members(self) -> Dict[str, Any]:
+        """Get all members including inherited ones."""
+        all_members = {}
+        # First add parent members (can be overridden)
+        if self.parent:
+            if hasattr(self.parent, 'get_all_members'):
+                all_members.update(self.parent.get_all_members())
+            elif hasattr(self.parent, 'members'):
+                all_members.update(self.parent.members)
+            elif hasattr(self.parent, '_python_obj'):
+                # CSSLizedPythonObject - get attributes from Python object
+                py_obj = self.parent._python_obj
+                if hasattr(py_obj, '__dict__'):
+                    for key, val in py_obj.__dict__.items():
+                        if not key.startswith('_'):
+                            all_members[key] = {'type': 'dynamic', 'default': val}
+        # Then add own members (override parent)
+        all_members.update(self.members)
+        return all_members
+
+    def get_all_methods(self) -> Dict[str, Any]:
+        """Get all methods including inherited ones."""
+        all_methods = {}
+        # First add parent methods (can be overridden)
+        if self.parent:
+            if hasattr(self.parent, 'get_all_methods'):
+                all_methods.update(self.parent.get_all_methods())
+            elif hasattr(self.parent, 'methods'):
+                all_methods.update(self.parent.methods)
+            elif hasattr(self.parent, '_python_obj'):
+                # CSSLizedPythonObject - get methods from Python object
+                py_obj = self.parent._python_obj
+                for name in dir(py_obj):
+                    if not name.startswith('_'):
+                        attr = getattr(py_obj, name, None)
+                        if callable(attr):
+                            all_methods[name] = ('python_method', attr)
+        # Then add own methods (override parent)
+        all_methods.update(self.methods)
+        return all_methods
 
     def __repr__(self):
-        return f"<CSSLClass '{self.name}' with {len(self.methods)} methods>"
+        parent_info = f" extends {self.parent.name}" if self.parent and hasattr(self.parent, 'name') else ""
+        return f"<CSSLClass '{self.name}'{parent_info} with {len(self.methods)} methods>"
 
 
 class CSSLInstance:
@@ -1471,8 +1516,9 @@ class CSSLInstance:
     def __init__(self, class_def: CSSLClass):
         self._class = class_def
         self._members: Dict[str, Any] = {}
-        # Initialize members with defaults from class definition
-        for name, default in class_def.members.items():
+        # Initialize members with defaults from class definition (including inherited)
+        all_members = class_def.get_all_members() if hasattr(class_def, 'get_all_members') else class_def.members
+        for name, default in all_members.items():
             if isinstance(default, dict):
                 # Type declaration with optional default
                 member_type = default.get('type')
@@ -1541,14 +1587,17 @@ class CSSLInstance:
         return name in self._members
 
     def get_method(self, name: str) -> Any:
-        """Get method AST node by name"""
-        if name in self._class.methods:
-            return self._class.methods[name]
+        """Get method AST node by name (including inherited methods)"""
+        # Use get_all_methods to include inherited methods
+        all_methods = self._class.get_all_methods() if hasattr(self._class, 'get_all_methods') else self._class.methods
+        if name in all_methods:
+            return all_methods[name]
         raise AttributeError(f"'{self._class.name}' has no method '{name}'")
 
     def has_method(self, name: str) -> bool:
-        """Check if method exists"""
-        return name in self._class.methods
+        """Check if method exists (including inherited methods)"""
+        all_methods = self._class.get_all_methods() if hasattr(self._class, 'get_all_methods') else self._class.methods
+        return name in all_methods
 
     def __getattr__(self, name: str) -> Any:
         """Allow direct attribute access for members"""

{includecpp-3.8.3 → includecpp-3.8.4}/includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json

@@ -164,6 +164,35 @@
         },
         "class-definition": {
             "patterns": [
+                {
+                    "comment": "Class with inheritance: class Child : extends Parent { }",
+                    "name": "meta.class.extends.cssl",
+                    "begin": "\\b(class)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(extends)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)\\s*\\{",
+                    "beginCaptures": {
+                        "1": { "name": "storage.type.class.cssl" },
+                        "2": { "name": "entity.name.class.cssl" },
+                        "3": { "name": "storage.modifier.extends.cssl" },
+                        "4": { "name": "entity.other.inherited-class.cssl" }
+                    },
+                    "end": "\\}",
+                    "patterns": [
+                        { "include": "#comments" },
+                        { "include": "#constructor-definition" },
+                        { "include": "#class-method-definition" },
+                        { "include": "#class-member-declaration" },
+                        { "include": "#types" },
+                        { "include": "#this-access" },
+                        { "include": "#captured-references" },
+                        { "include": "#global-references" },
+                        { "include": "#shared-references" },
+                        { "include": "#strings" },
+                        { "include": "#numbers" },
+                        { "include": "#keywords" },
+                        { "include": "#function-calls" },
+                        { "include": "#builtins" },
+                        { "include": "#operators" }
+                    ]
+                },
                 {
                     "name": "meta.class.cssl",
                     "begin": "\\b(class)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\{",
@@ -263,6 +292,10 @@
                     "name": "storage.type.class.cssl",
                     "match": "\\b(class|struct|structure|enum|interface)\\b"
                 },
+                {
+                    "name": "storage.modifier.extends.cssl",
+                    "match": "\\b(extends|overwrites)\\b"
+                },
                 {
                     "name": "keyword.operator.new.cssl",
                     "match": "\\bnew\\b"

{includecpp-3.8.3 → includecpp-3.8.4}/pyproject.toml

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