IncludeCPP 3.8.3__py3-none-any.whl → 3.8.5__py3-none-any.whl

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', 'constr', 'extends', 'overwrites', 'new', 'this', 'super',
     # 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,73 @@ 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 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
+
+        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'")
+                    # 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
+                    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,
+            '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=[])
         self._expect(TokenType.BLOCK_START)
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
@@ -1412,25 +1473,217 @@ 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_define(self) -> ASTNode:
         """Parse define function declaration.
 
         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
+            define MyFunc :: extends Parent::Method :: overwrites Parent::Method() { }  // Method-level inheritance
         """
         # 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() { }
+        # 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.DOUBLE_COLON) or self._match(TokenType.COLON):
+            # Parse extends and/or overwrites (supports :: method-level syntax)
+            while True:
+                if self._match_keyword('extends'):
+                    # 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/method name
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                elif self._match_keyword('overwrites'):
+                    # 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/method name
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                else:
+                    break
+                # Check for another :: or : for chaining extends/overwrites
+                if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
+                    break
+
         params = []
 
         if self._match(TokenType.PAREN_START):
@@ -1446,7 +1699,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 +1721,20 @@ 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,
+            # 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)
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
@@ -1514,6 +1780,10 @@ 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):
+            # super() 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
@@ -1524,6 +1794,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)