IncludeCPP 3.8.4__tar.gz → 3.8.6__tar.gz

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

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

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

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

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.8.4 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
+> Version 3.8.6 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
 
 ---
 
@@ -1891,6 +1891,122 @@ define process(open *Params) {
 }
 ```
 
+### Class Constructors with `constr` Keyword
+
+The `constr` keyword defines explicit constructors inside classes. Multiple constructors can be defined and will be executed in order.
+
+```cssl
+// Class with constructor parameters in declaration
+class Vehicle (string brand, int year) {
+    string make;
+    int modelYear;
+
+    // Constructor using constr keyword
+    constr Initialize() {
+        // brand and year are available from class parameters
+        this->make = brand;
+        this->modelYear = year;
+    }
+
+    // Additional constructor - executed after Initialize
+    constr SetupDefaults() {
+        printl("Vehicle created: " + this->make);
+    }
+}
+
+Vehicle v = new Vehicle("Toyota", 2024);
+```
+
+### Constructor Inheritance with `super()`
+
+Use `super()` to call parent class constructors and methods:
+
+```cssl
+class Animal {
+    string name;
+
+    void Animal(string n) {
+        this->name = n;
+    }
+
+    void speak() {
+        printl("Generic sound");
+    }
+}
+
+class Dog : extends Animal {
+    string breed;
+
+    constr DogInit(string n, string b) {
+        super(n);  // Call parent constructor with name
+        this->breed = b;
+    }
+
+    void speak() {
+        super::speak();  // Call parent's speak method
+        printl("Woof! I'm " + this->name);
+    }
+}
+
+Dog d = new Dog("Buddy", "Labrador");
+d.speak();
+// Output:
+// Generic sound
+// Woof! I'm Buddy
+```
+
+### Constructor Extends with Arguments
+
+Pass arguments to parent constructors in class declaration:
+
+```cssl
+class Parent {
+    int value;
+
+    void Parent(int v) {
+        this->value = v;
+    }
+}
+
+// Pass arguments to parent constructor using extends (arg1, arg2)
+class Child : extends Parent ("defaultValue") {
+    constr ChildInit() {
+        // Parent constructor already called with "defaultValue"
+        printl("Child value: " + this->value);
+    }
+}
+```
+
+### Method-Level Extends & Overwrites
+
+Functions and methods can extend or overwrite specific methods in parent classes using `::` syntax:
+
+```cssl
+class Base {
+    constr Init() {
+        printl("Base init");
+    }
+
+    void process() {
+        printl("Base processing");
+    }
+}
+
+class Derived : extends Base {
+    // Extend specific parent constructor
+    constr DerivedInit() :: extends Base::Init {
+        // Base::Init local vars are available here
+        printl("Derived init");
+    }
+
+    // Or define a method that extends parent method
+    define customProcess :: extends Base::process() {
+        // Has access to Base::process local variables
+        printl("Extended processing");
+    }
+}
+```
+
 ---
 
 ## Map Container

{includecpp-3.8.4 → includecpp-3.8.6}/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', 'extends', 'overwrites', 'new', 'this',
+    'service-init', 'service-run', 'service-include', 'struct', 'define', 'main', 'class', 'constr', 'extends', 'overwrites', 'new', 'this', 'super',
     # Control flow
     'if', 'else', 'elif', 'while', 'for', 'foreach', 'in', 'range',
     'switch', 'case', 'default', 'break', 'continue', 'return',
@@ -1383,12 +1383,20 @@ class CSSLParser:
 
         class_name = self._advance().value
 
+        # Check for class-level constructor parameters: class MyClass (int x, string y) { ... }
+        class_params = []
+        if self._match(TokenType.PAREN_START):
+            class_params = self._parse_parameter_list()
+            self._expect(TokenType.PAREN_END)
+
         # Check for inheritance and overwrites:
         # class Child : extends Parent { ... }
         # class Child : extends $PythonObject { ... }
         # class Child : extends Parent : overwrites Parent { ... }
+        # class Child : extends Parent (param1, param2) { ... }  <- constructor args for parent
         extends_class = None
         extends_is_python = False
+        extends_args = []
         overwrites_class = None
         overwrites_is_python = False
 
@@ -1403,6 +1411,13 @@ class CSSLParser:
                         extends_is_python = True
                     else:
                         raise CSSLSyntaxError("Expected parent class name after 'extends'")
+                    # Check for constructor arguments: extends Parent (arg1, arg2)
+                    if self._match(TokenType.PAREN_START):
+                        while not self._check(TokenType.PAREN_END):
+                            arg = self._parse_expression()
+                            extends_args.append(arg)
+                            self._match(TokenType.COMMA)
+                        self._expect(TokenType.PAREN_END)
                 elif self._match_keyword('overwrites'):
                     if self._check(TokenType.IDENTIFIER):
                         overwrites_class = self._advance().value
@@ -1423,8 +1438,10 @@ class CSSLParser:
         node = ASTNode('class', value={
             'name': class_name,
             'non_null': non_null,
+            'class_params': class_params,
             'extends': extends_class,
             'extends_is_python': extends_is_python,
+            'extends_args': extends_args,
             'overwrites': overwrites_class,
             'overwrites_is_python': overwrites_is_python
         }, children=[])
@@ -1456,12 +1473,172 @@ class CSSLParser:
                 method = self._parse_define()
                 node.children.append(method)
 
+            # Check for constr keyword (constructor declaration)
+            # Syntax: constr ConstructorName() { ... }
+            # or: constr ConstructorName() : extends Parent::ConstructorName { ... }
+            elif self._match_keyword('constr'):
+                constructor = self._parse_constructor(class_name)
+                node.children.append(constructor)
+
             else:
                 self._advance()
 
         self._expect(TokenType.BLOCK_END)
         return node
 
+    def _parse_constructor(self, class_name: str) -> ASTNode:
+        """Parse constructor declaration inside a class.
+
+        Syntax:
+            constr ConstructorName() { ... }
+            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().
+        """
+        # Get constructor name
+        if not self._check(TokenType.IDENTIFIER):
+            raise CSSLSyntaxError("Expected constructor name after 'constr'")
+        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
+        overwrites_target = None
+        overwrites_class_ref = None
+        overwrites_method_ref = None
+
+        # Parse parameters
+        params = []
+        if self._match(TokenType.PAREN_START):
+            params = self._parse_parameter_list()
+            self._expect(TokenType.PAREN_END)
+
+        # Check for method-level extends/overwrites with :: or :
+        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
+            while True:
+                if self._match_keyword('extends'):
+                    # Parse Parent::method or just method
+                    extends_target = self._parse_qualified_method_ref()
+                    if '::' in extends_target:
+                        parts = extends_target.split('::')
+                        extends_class_ref = parts[0]
+                        extends_method_ref = parts[1]
+                    else:
+                        extends_method_ref = extends_target
+                elif self._match_keyword('overwrites'):
+                    # Parse Parent::method or just method
+                    overwrites_target = self._parse_qualified_method_ref()
+                    if '::' in overwrites_target:
+                        parts = overwrites_target.split('::')
+                        overwrites_class_ref = parts[0]
+                        overwrites_method_ref = parts[1]
+                    else:
+                        overwrites_method_ref = overwrites_target
+                else:
+                    break
+                # Check for another :: or : for chaining
+                if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
+                    break
+
+        # Parse constructor body
+        self._expect(TokenType.BLOCK_START)
+        body = []
+        while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+            stmt = self._parse_statement()
+            if stmt:
+                body.append(stmt)
+        self._expect(TokenType.BLOCK_END)
+
+        return ASTNode('constructor', value={
+            'name': constr_name,
+            'class_name': class_name,
+            'params': params,
+            'is_constructor': True,
+            'extends_target': extends_target,
+            'extends_class': extends_class_ref,
+            'extends_method': extends_method_ref,
+            'overwrites_target': overwrites_target,
+            'overwrites_class': overwrites_class_ref,
+            'overwrites_method': overwrites_method_ref
+        }, children=body)
+
+    def _parse_qualified_method_ref(self) -> str:
+        """Parse a qualified method reference like 'ParentClass::methodName' or just 'methodName'.
+
+        Returns the qualified name as a string (e.g., 'Parent::init' or just 'init').
+        """
+        # Check for $PythonObject
+        if self._check(TokenType.SHARED_REF):
+            class_ref = self._advance().value  # Gets the name without $
+            class_ref = f'${class_ref}'
+        elif self._check(TokenType.IDENTIFIER):
+            class_ref = self._advance().value
+        else:
+            raise CSSLSyntaxError("Expected class or method name in extends/overwrites")
+
+        # Check for :: to get method part
+        if self._match(TokenType.DOUBLE_COLON):
+            if self._check(TokenType.IDENTIFIER):
+                method_ref = self._advance().value
+                return f'{class_ref}::{method_ref}'
+            else:
+                raise CSSLSyntaxError("Expected method name after '::'")
+
+        # 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.
 
@@ -1470,6 +1647,7 @@ class CSSLParser:
             define *MyFunc(args) { }  // Non-null: must never return None
             define MyFunc : extends OtherFunc() { }  // Inherit local vars
             define MyFunc : overwrites OtherFunc() { }  // Replace OtherFunc
+            define MyFunc :: extends Parent::Method :: overwrites Parent::Method() { }  // Method-level inheritance
         """
         # Check for * prefix (non-null function - must return non-null)
         non_null = False
@@ -1479,40 +1657,79 @@ class CSSLParser:
         name = self._advance().value
 
         # Check for extends/overwrites: define func : extends/overwrites target() { }
+        # Also supports method-level :: syntax: define func :: extends Parent::method
         extends_func = None
         overwrites_func = None
         extends_is_python = False
         overwrites_is_python = False
+        extends_class_ref = None
+        extends_method_ref = None
+        overwrites_class_ref = None
+        overwrites_method_ref = None
 
-        if self._match(TokenType.COLON):
-            # Parse extends and/or overwrites
+        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
+            # Parse extends and/or overwrites (supports :: method-level syntax)
             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
+                    # Check for qualified reference: Parent::method
+                    if self._check(TokenType.SHARED_REF):
                         extends_is_python = True
+                        extends_func = self._advance().value
+                        # Check for ::method
+                        if self._match(TokenType.DOUBLE_COLON):
+                            extends_class_ref = f'${extends_func}'
+                            if self._check(TokenType.IDENTIFIER):
+                                extends_method_ref = self._advance().value
+                            else:
+                                raise CSSLSyntaxError("Expected method name after '::'")
+                    elif self._check(TokenType.IDENTIFIER):
+                        first_part = self._advance().value
+                        # Check for ::method (qualified reference)
+                        if self._match(TokenType.DOUBLE_COLON):
+                            extends_class_ref = first_part
+                            if self._check(TokenType.IDENTIFIER):
+                                extends_method_ref = self._advance().value
+                            else:
+                                raise CSSLSyntaxError("Expected method name after '::'")
+                        else:
+                            extends_func = first_part
                     else:
                         raise CSSLSyntaxError("Expected function name after 'extends'")
-                    # Skip optional () after function name
+                    # Skip optional () after function/method 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
+                    # Check for qualified reference: Parent::method
+                    if self._check(TokenType.SHARED_REF):
                         overwrites_is_python = True
+                        overwrites_func = self._advance().value
+                        # Check for ::method
+                        if self._match(TokenType.DOUBLE_COLON):
+                            overwrites_class_ref = f'${overwrites_func}'
+                            if self._check(TokenType.IDENTIFIER):
+                                overwrites_method_ref = self._advance().value
+                            else:
+                                raise CSSLSyntaxError("Expected method name after '::'")
+                    elif self._check(TokenType.IDENTIFIER):
+                        first_part = self._advance().value
+                        # Check for ::method (qualified reference)
+                        if self._match(TokenType.DOUBLE_COLON):
+                            overwrites_class_ref = first_part
+                            if self._check(TokenType.IDENTIFIER):
+                                overwrites_method_ref = self._advance().value
+                            else:
+                                raise CSSLSyntaxError("Expected method name after '::'")
+                        else:
+                            overwrites_func = first_part
                     else:
                         raise CSSLSyntaxError("Expected function name after 'overwrites'")
-                    # Skip optional () after function name
+                    # Skip optional () after function/method 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):
+                # Check for another :: or : for chaining extends/overwrites
+                if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
                     break
 
         params = []
@@ -1559,7 +1776,12 @@ class CSSLParser:
             'extends': extends_func,
             'extends_is_python': extends_is_python,
             'overwrites': overwrites_func,
-            'overwrites_is_python': overwrites_is_python
+            'overwrites_is_python': overwrites_is_python,
+            # Method-level inheritance (Parent::method syntax)
+            'extends_class': extends_class_ref,
+            'extends_method': extends_method_ref,
+            'overwrites_class': overwrites_class_ref,
+            'overwrites_method': overwrites_method_ref
         }, children=[])
         self._expect(TokenType.BLOCK_START)
 
@@ -1606,6 +1828,11 @@ class CSSLParser:
         elif self._check(TokenType.SUPER_FUNC):
             # 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 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
               self._check(TokenType.GLOBAL_REF) or self._check(TokenType.SELF_REF) or
@@ -1616,6 +1843,43 @@ class CSSLParser:
             self._advance()
             return None
 
+    def _parse_super_call(self) -> ASTNode:
+        """Parse 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
+
+        Used inside constructors (constr) and methods to call parent implementations.
+        """
+        # Consume 'super' keyword
+        self._advance()
+
+        # Check for ::method syntax
+        target_method = None
+        if self._match(TokenType.DOUBLE_COLON):
+            if not self._check(TokenType.IDENTIFIER):
+                raise CSSLSyntaxError("Expected method name after 'super::'")
+            target_method = self._advance().value
+
+        # Parse arguments
+        args = []
+        self._expect(TokenType.PAREN_START)
+        while not self._check(TokenType.PAREN_END):
+            arg = self._parse_expression()
+            args.append(arg)
+            if not self._match(TokenType.COMMA):
+                break
+        self._expect(TokenType.PAREN_END)
+        self._match(TokenType.SEMICOLON)
+
+        return ASTNode('super_call', value={
+            'method': target_method,  # None for constructor, method name for specific method
+            'args': args
+        })
+
     def _parse_if(self) -> ASTNode:
         """Parse if statement with support for else if AND elif syntax."""
         self._expect(TokenType.PAREN_START)

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

@@ -755,11 +755,20 @@ class CSSLRuntime:
 
         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')
 
@@ -789,6 +798,10 @@ class CSSLRuntime:
             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)
@@ -1497,6 +1510,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:
@@ -3082,6 +3171,8 @@ class CSSLRuntime:
         """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', [])]
@@ -3109,12 +3200,130 @@ 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 _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.
+        """
+        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')
+
+        # 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
+
+        # Execute constructor body
+        prev_scope = self.scope
+        self.scope = new_scope
+
+        try:
+            for stmt in constr_node.children:
+                self._execute(stmt)
+        finally:
+            self.scope = prev_scope
+            self._current_instance = prev_instance
+
     def _eval_this_access(self, node: ASTNode) -> Any:
         """Evaluate 'this->member' access.
 

{includecpp-3.8.4 → includecpp-3.8.6}/includecpp/vscode/cssl/package.json

@@ -2,7 +2,7 @@
     "name": "cssl",
     "displayName": "CSSL Language",
     "description": "Professional syntax highlighting, snippets, and language support for CSSL scripts (.cssl, .cssl-pl, .cssl-mod)",
-    "version": "1.4.0",
+    "version": "1.6.0",
     "publisher": "IncludeCPP",
     "icon": "images/cssl.png",
     "engines": {

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

@@ -8,6 +8,9 @@
         { "include": "#strings" },
         { "include": "#numbers" },
         { "include": "#class-definition" },
+        { "include": "#function-definitions" },
+        { "include": "#constructor-definition" },
+        { "include": "#super-call" },
         { "include": "#sql-types" },
         { "include": "#keywords" },
         { "include": "#types" },
@@ -35,13 +38,13 @@
         "non-null-declarations": {
             "patterns": [
                 {
-                    "comment": "Non-null class: class *ClassName - light pink",
+                    "comment": "Non-null class: class *ClassName - turquoise",
                     "name": "meta.class.non-null.cssl",
                     "match": "\\b(class)\\s+(\\*)([a-zA-Z_][a-zA-Z0-9_]*)",
                     "captures": {
                         "1": { "name": "storage.type.class.cssl" },
                         "2": { "name": "keyword.operator.non-null.cssl" },
-                        "3": { "name": "entity.name.class.non-null.cssl" }
+                        "3": { "name": "support.class.non-null.cssl" }
                     }
                 },
                 {
@@ -164,15 +167,48 @@
         },
         "class-definition": {
             "patterns": [
+                {
+                    "comment": "Class with extends AND overwrites: class X : extends Y : overwrites Z { }",
+                    "name": "meta.class.extends-overwrites.cssl",
+                    "begin": "\\b(class)\\s+(\\*?)([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(extends)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(overwrites)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(\\(\\))?\\s*\\{",
+                    "beginCaptures": {
+                        "1": { "name": "storage.type.class.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "support.class.cssl" },
+                        "4": { "name": "storage.modifier.extends.cssl" },
+                        "5": { "name": "support.class.inherited.cssl" },
+                        "6": { "name": "storage.modifier.overwrites.cssl" },
+                        "7": { "name": "support.class.overwritten.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" }
+                    ]
+                },
                 {
                     "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*\\{",
+                    "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" }
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "support.class.cssl" },
+                        "4": { "name": "storage.modifier.extends.cssl" },
+                        "5": { "name": "support.class.inherited.cssl" }
                     },
                     "end": "\\}",
                     "patterns": [
@@ -198,7 +234,7 @@
                     "begin": "\\b(class)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\{",
                     "beginCaptures": {
                         "1": { "name": "storage.type.class.cssl" },
-                        "2": { "name": "entity.name.class.cssl" }
+                        "2": { "name": "support.class.cssl" }
                     },
                     "end": "\\}",
                     "patterns": [
@@ -223,6 +259,28 @@
         },
         "constructor-definition": {
             "patterns": [
+                {
+                    "comment": "New-style constructor with constr keyword and extends: constr Name() :: extends Parent::Name { }",
+                    "name": "meta.constructor.constr.extends.cssl",
+                    "match": "\\b(constr)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\([^)]*\\)\\s*(::)?\\s*(extends)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(::[a-zA-Z_][a-zA-Z0-9_]*)?",
+                    "captures": {
+                        "1": { "name": "storage.type.constructor.cssl" },
+                        "2": { "name": "entity.name.function.constructor.cssl" },
+                        "3": { "name": "punctuation.accessor.double-colon.cssl" },
+                        "4": { "name": "storage.modifier.extends.cssl" },
+                        "5": { "name": "entity.other.inherited-class.cssl" },
+                        "6": { "name": "entity.name.function.inherited.cssl" }
+                    }
+                },
+                {
+                    "comment": "New-style constructor with constr keyword: constr ConstructorName() { }",
+                    "name": "meta.constructor.constr.cssl",
+                    "match": "\\b(constr)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(",
+                    "captures": {
+                        "1": { "name": "storage.type.constructor.cssl" },
+                        "2": { "name": "entity.name.function.constructor.cssl" }
+                    }
+                },
                 {
                     "comment": "Constructor: ClassName { ... } or void ClassName(...)",
                     "name": "meta.constructor.cssl",
@@ -234,6 +292,28 @@
                 }
             ]
         },
+        "super-call": {
+            "patterns": [
+                {
+                    "comment": "super::method() - call parent method",
+                    "name": "meta.super-call.method.cssl",
+                    "match": "\\b(super)(::)([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(",
+                    "captures": {
+                        "1": { "name": "keyword.other.super.cssl" },
+                        "2": { "name": "punctuation.accessor.double-colon.cssl" },
+                        "3": { "name": "entity.name.function.parent.cssl" }
+                    }
+                },
+                {
+                    "comment": "super() - call parent constructor",
+                    "name": "meta.super-call.constructor.cssl",
+                    "match": "\\b(super)\\s*\\(",
+                    "captures": {
+                        "1": { "name": "keyword.other.super.cssl" }
+                    }
+                }
+            ]
+        },
         "class-method-definition": {
             "patterns": [
                 {
@@ -296,6 +376,15 @@
                     "name": "storage.modifier.extends.cssl",
                     "match": "\\b(extends|overwrites)\\b"
                 },
+                {
+                    "comment": "new ClassName() - class instantiation with turquoise class name",
+                    "name": "meta.new-expression.cssl",
+                    "match": "\\b(new)\\s+([A-Z][a-zA-Z0-9_]*)\\s*\\(",
+                    "captures": {
+                        "1": { "name": "keyword.operator.new.cssl" },
+                        "2": { "name": "support.class.cssl" }
+                    }
+                },
                 {
                     "name": "keyword.operator.new.cssl",
                     "match": "\\bnew\\b"
@@ -306,7 +395,11 @@
                 },
                 {
                     "name": "storage.type.function.cssl",
-                    "match": "\\b(define|void|shuffled)\\b"
+                    "match": "\\b(define|void|shuffled|constr)\\b"
+                },
+                {
+                    "name": "keyword.other.super.cssl",
+                    "match": "\\bsuper\\b"
                 },
                 {
                     "name": "keyword.other.cssl",
@@ -409,7 +502,7 @@
                 },
                 {
                     "name": "support.function.namespace.python.cssl",
-                    "match": "\\bpython::(pythonize|wrap|export)\\b"
+                    "match": "\\bpython::(pythonize|wrap|export|csslize|import)\\b"
                 },
                 {
                     "name": "support.function.namespace.filter.cssl",
@@ -548,6 +641,48 @@
                 }
             ]
         },
+        "function-definitions": {
+            "patterns": [
+                {
+                    "comment": "Function with extends AND overwrites: define func : extends X : overwrites Y() { }",
+                    "name": "meta.function.extends-overwrites.cssl",
+                    "match": "\\b(define)\\s+(\\*?)([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(extends)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(\\(\\))?\\s*:\\s*(overwrites)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(\\(\\))?",
+                    "captures": {
+                        "1": { "name": "storage.type.function.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "entity.name.function.cssl" },
+                        "4": { "name": "storage.modifier.extends.cssl" },
+                        "5": { "name": "entity.other.inherited-function.cssl" },
+                        "7": { "name": "storage.modifier.overwrites.cssl" },
+                        "8": { "name": "entity.other.overwritten-function.cssl" }
+                    }
+                },
+                {
+                    "comment": "Function with extends: define func : extends otherFunc() { }",
+                    "name": "meta.function.extends.cssl",
+                    "match": "\\b(define)\\s+(\\*?)([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(extends)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(\\(\\))?",
+                    "captures": {
+                        "1": { "name": "storage.type.function.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "entity.name.function.cssl" },
+                        "4": { "name": "storage.modifier.extends.cssl" },
+                        "5": { "name": "entity.other.inherited-function.cssl" }
+                    }
+                },
+                {
+                    "comment": "Function with overwrites: define func : overwrites target() { }",
+                    "name": "meta.function.overwrites.cssl",
+                    "match": "\\b(define)\\s+(\\*?)([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(overwrites)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(\\(\\))?",
+                    "captures": {
+                        "1": { "name": "storage.type.function.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "entity.name.function.cssl" },
+                        "4": { "name": "storage.modifier.overwrites.cssl" },
+                        "5": { "name": "entity.other.overwritten-function.cssl" }
+                    }
+                }
+            ]
+        },
         "function-calls": {
             "patterns": [
                 {

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

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