IncludeCPP 4.0.3__py3-none-any.whl → 4.1.0__py3-none-any.whl

includecpp/core/cssl/cssl_parser.py

@@ -113,6 +113,8 @@ class TokenType(Enum):
     # Append operator for constructor/function extension
     PLUS_PLUS = auto()     # ++ for constructor/function append (keeps old + adds new)
     MINUS_MINUS = auto()   # -- for potential future use
+    # Multi-language support (v4.1.0)
+    LANG_INSTANCE_REF = auto()  # cpp$InstanceName, py$Object - cross-language instance access
 
 
 KEYWORDS = {
@@ -155,6 +157,8 @@ KEYWORDS = {
     'static',       # Static method/function
     # CSSL Include Keywords
     'include', 'get',
+    # Multi-language support (v4.1.0)
+    'supports', 'libinclude',
 }
 
 # Function modifiers that can appear in any order before function name
@@ -182,6 +186,12 @@ INJECTION_HELPERS = {
     'string', 'integer', 'json', 'array', 'vector', 'combo', 'dynamic', 'sql'
 }
 
+# Language identifiers for multi-language support (v4.1.0)
+# Used in lang$instance patterns like cpp$MyClass, py$Object
+LANGUAGE_IDS = {
+    'cpp', 'py', 'python', 'java', 'csharp', 'js', 'javascript'
+}
+
 
 @dataclass
 class Token:
@@ -457,6 +467,25 @@ class CSSLLexer:
             self._advance()
         value = self.source[start:self.pos]
 
+        # Check for language$instance pattern (v4.1.0)
+        # e.g., cpp$MyClass, py$Object, java$Service
+        if value.lower() in LANGUAGE_IDS and self.pos < len(self.source) and self.source[self.pos] == '$':
+            lang_id = value
+            self._advance()  # skip '$'
+            # Read instance name
+            instance_start = self.pos
+            while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] == '_'):
+                self._advance()
+            instance_name = self.source[instance_start:self.pos]
+            if instance_name:
+                self._add_token(TokenType.LANG_INSTANCE_REF, {'lang': lang_id, 'instance': instance_name})
+                return
+            # If no instance name, revert and treat as normal identifier
+            self.pos = start
+            while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] == '_'):
+                self._advance()
+            value = self.source[start:self.pos]
+
         if value in ('True', 'true'):
             self._add_token(TokenType.BOOLEAN, True)
         elif value in ('False', 'false'):
@@ -1350,13 +1379,7 @@ class CSSLParser:
                     # Wrap in global_assignment to mark as global variable (same as 'global' keyword)
                     global_stmt = ASTNode('global_assignment', value=stmt)
                     root.children.append(global_stmt)
-            # Handle statements - keywords like 'instance', 'list', 'map' can be variable names
-            elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
-                  self._check(TokenType.SELF_REF) or self._check(TokenType.SHARED_REF) or
-                  self._check(TokenType.KEYWORD)):
-                stmt = self._parse_expression_statement()
-                if stmt:
-                    root.children.append(stmt)
+            # Control flow keywords must be checked BEFORE generic KEYWORD handling
             elif self._match_keyword('if'):
                 root.children.append(self._parse_if())
             elif self._match_keyword('while'):
@@ -1365,6 +1388,13 @@ class CSSLParser:
                 root.children.append(self._parse_for())
             elif self._match_keyword('foreach'):
                 root.children.append(self._parse_foreach())
+            # Handle statements - keywords like 'instance', 'list', 'map' can be variable names
+            elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
+                  self._check(TokenType.SELF_REF) or self._check(TokenType.SHARED_REF) or
+                  self._check(TokenType.KEYWORD)):
+                stmt = self._parse_expression_statement()
+                if stmt:
+                    root.children.append(stmt)
             # Skip comments and newlines
             elif self._check(TokenType.COMMENT) or self._check(TokenType.NEWLINE):
                 self._advance()
@@ -1627,15 +1657,22 @@ class CSSLParser:
         # class Child : extends Parent (param1, param2) { ... }  <- constructor args for parent
         extends_class = None
         extends_is_python = False
+        extends_lang_ref = None  # v4.1.0: Cross-language inheritance (cpp$ClassName)
         extends_args = []
         overwrites_class = None
         overwrites_is_python = False
+        supports_language = None  # v4.1.0: Multi-language syntax support
 
         if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
             # Parse extends and/or overwrites (can be chained with : or ::)
             while True:
                 if self._match_keyword('extends'):
-                    if self._check(TokenType.IDENTIFIER):
+                    # v4.1.0: Check for cross-language inheritance: extends cpp$ClassName
+                    if self._check(TokenType.LANG_INSTANCE_REF):
+                        ref = self._advance().value
+                        extends_lang_ref = ref  # {'lang': 'cpp', 'instance': 'ClassName'}
+                        extends_class = ref['instance']
+                    elif self._check(TokenType.IDENTIFIER):
                         extends_class = self._advance().value
                     elif self._check(TokenType.SHARED_REF):
                         extends_class = self._advance().value
@@ -1660,8 +1697,20 @@ class CSSLParser:
                     # Skip optional () after class name
                     if self._match(TokenType.PAREN_START):
                         self._expect(TokenType.PAREN_END)
+                # v4.1.0: Parse 'supports' keyword for multi-language syntax
+                elif self._match_keyword('supports'):
+                    if self._check(TokenType.AT):
+                        self._advance()  # consume @
+                        if self._check(TokenType.IDENTIFIER):
+                            supports_language = '@' + self._advance().value
+                        else:
+                            raise CSSLSyntaxError("Expected language identifier after '@' in 'supports'")
+                    elif self._check(TokenType.IDENTIFIER):
+                        supports_language = self._advance().value
+                    else:
+                        raise CSSLSyntaxError("Expected language identifier after 'supports'")
                 else:
-                    raise CSSLSyntaxError("Expected 'extends' or 'overwrites' after ':' or '::' in class declaration")
+                    raise CSSLSyntaxError("Expected 'extends', 'overwrites', or 'supports' after ':' or '::' in class declaration")
                 # Check for another : or :: for chaining
                 if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
                     break
@@ -1673,9 +1722,11 @@ class CSSLParser:
             'class_params': class_params,
             'extends': extends_class,
             'extends_is_python': extends_is_python,
+            'extends_lang_ref': extends_lang_ref,  # v4.1.0
             'extends_args': extends_args,
             'overwrites': overwrites_class,
-            'overwrites_is_python': overwrites_is_python
+            'overwrites_is_python': overwrites_is_python,
+            'supports_language': supports_language  # v4.1.0
         }, children=[])
         self._expect(TokenType.BLOCK_START)
 
@@ -1945,6 +1996,7 @@ class CSSLParser:
         extends_method_ref = None
         overwrites_class_ref = None
         overwrites_method_ref = None
+        supports_language = None  # v4.1.0: Multi-language syntax support
 
         if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
             # Parse extends and/or overwrites (supports :: method-level syntax)
@@ -2005,6 +2057,18 @@ class CSSLParser:
                     # Skip optional () after function/method name
                     if self._match(TokenType.PAREN_START):
                         self._expect(TokenType.PAREN_END)
+                # v4.1.0: Parse 'supports' keyword for multi-language syntax
+                elif self._match_keyword('supports'):
+                    if self._check(TokenType.AT):
+                        self._advance()  # consume @
+                        if self._check(TokenType.IDENTIFIER):
+                            supports_language = '@' + self._advance().value
+                        else:
+                            raise CSSLSyntaxError("Expected language identifier after '@' in 'supports'")
+                    elif self._check(TokenType.IDENTIFIER):
+                        supports_language = self._advance().value
+                    else:
+                        raise CSSLSyntaxError("Expected language identifier after 'supports'")
                 else:
                     break
                 # Check for another :: or : for chaining extends/overwrites
@@ -2092,7 +2156,9 @@ class CSSLParser:
             # New append mode fields
             'append_mode': append_mode,
             'append_ref_class': append_ref_class,
-            'append_ref_member': append_ref_member
+            'append_ref_member': append_ref_member,
+            # v4.1.0: Multi-language support
+            'supports_language': supports_language
         }, children=[])
         self._expect(TokenType.BLOCK_START)
 
@@ -2352,42 +2418,40 @@ class CSSLParser:
 
         Supports: i = i + 1, i++, ++i, i += 1, i -= 1
         """
-        # Check for prefix increment/decrement: ++i or --i
-        if self._check(TokenType.PLUS) or self._check(TokenType.MINUS):
-            op_token = self._advance()
-            # Check for double operator (++ or --)
-            if self._check(op_token.type):
-                self._advance()
-                var_name = self._advance().value
-                op = 'increment' if op_token.type == TokenType.PLUS else 'decrement'
-                return ASTNode('c_for_update', value={'var': var_name, 'op': op})
+        # Check for prefix increment/decrement: ++i or --i (as single PLUS_PLUS/MINUS_MINUS token)
+        if self._check(TokenType.PLUS_PLUS):
+            self._advance()
+            var_name = self._advance().value
+            return ASTNode('c_for_update', value={'var': var_name, 'op': 'increment'})
+        elif self._check(TokenType.MINUS_MINUS):
+            self._advance()
+            var_name = self._advance().value
+            return ASTNode('c_for_update', value={'var': var_name, 'op': 'decrement'})
 
         # Regular variable assignment or postfix
         var_name = self._advance().value
 
-        # Check for postfix increment/decrement: i++ or i--
-        if self._check(TokenType.PLUS):
+        # Check for postfix increment/decrement: i++ or i-- (as single PLUS_PLUS/MINUS_MINUS token)
+        if self._check(TokenType.PLUS_PLUS):
+            self._advance()
+            return ASTNode('c_for_update', value={'var': var_name, 'op': 'increment'})
+        elif self._check(TokenType.MINUS_MINUS):
+            self._advance()
+            return ASTNode('c_for_update', value={'var': var_name, 'op': 'decrement'})
+        # i += value
+        elif self._check(TokenType.PLUS):
             self._advance()
-            if self._check(TokenType.PLUS):
+            if self._check(TokenType.EQUALS):
                 self._advance()
-                return ASTNode('c_for_update', value={'var': var_name, 'op': 'increment'})
-            else:
-                # i += value
-                if self._check(TokenType.EQUALS):
-                    self._advance()
-                    value = self._parse_expression()
-                    return ASTNode('c_for_update', value={'var': var_name, 'op': 'add', 'value': value})
+                value = self._parse_expression()
+                return ASTNode('c_for_update', value={'var': var_name, 'op': 'add', 'value': value})
+        # i -= value
         elif self._check(TokenType.MINUS):
             self._advance()
-            if self._check(TokenType.MINUS):
+            if self._check(TokenType.EQUALS):
                 self._advance()
-                return ASTNode('c_for_update', value={'var': var_name, 'op': 'decrement'})
-            else:
-                # i -= value
-                if self._check(TokenType.EQUALS):
-                    self._advance()
-                    value = self._parse_expression()
-                    return ASTNode('c_for_update', value={'var': var_name, 'op': 'subtract', 'value': value})
+                value = self._parse_expression()
+                return ASTNode('c_for_update', value={'var': var_name, 'op': 'subtract', 'value': value})
 
         # Regular assignment: i = expression
         if self._check(TokenType.EQUALS):
@@ -2948,6 +3012,14 @@ class CSSLParser:
         if self._match(TokenType.MINUS):
             operand = self._parse_unary()
             return ASTNode('unary', value={'op': '-', 'operand': operand})
+        # Prefix increment: ++i
+        if self._match(TokenType.PLUS_PLUS):
+            operand = self._parse_unary()
+            return ASTNode('increment', value={'op': 'prefix', 'operand': operand})
+        # Prefix decrement: --i
+        if self._match(TokenType.MINUS_MINUS):
+            operand = self._parse_unary()
+            return ASTNode('decrement', value={'op': 'prefix', 'operand': operand})
         if self._match(TokenType.AMPERSAND):
             # Reference operator: &variable or &@module
             operand = self._parse_unary()
@@ -3148,6 +3220,28 @@ class CSSLParser:
                     break
             return node
 
+        # v4.1.0: Cross-language instance reference: cpp$ClassName, py$Object
+        if self._check(TokenType.LANG_INSTANCE_REF):
+            token = self._advance()
+            ref = token.value  # {'lang': 'cpp', 'instance': 'ClassName'}
+            node = ASTNode('lang_instance_ref', value=ref, line=token.line, column=token.column)
+            # Check for member access, calls, indexing
+            while True:
+                if self._match(TokenType.PAREN_START):
+                    args, kwargs = self._parse_call_arguments()
+                    self._expect(TokenType.PAREN_END)
+                    node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
+                elif self._match(TokenType.DOT):
+                    member = self._advance().value
+                    node = ASTNode('member_access', value={'object': node, 'member': member})
+                elif self._match(TokenType.BRACKET_START):
+                    index = self._parse_expression()
+                    self._expect(TokenType.BRACKET_END)
+                    node = ASTNode('index_access', value={'object': node, 'index': index})
+                else:
+                    break
+            return node
+
         if self._check(TokenType.NUMBER):
             return ASTNode('literal', value=self._advance().value)
 
@@ -3398,6 +3492,12 @@ class CSSLParser:
                 index = self._parse_expression()
                 self._expect(TokenType.BRACKET_END)
                 node = ASTNode('index_access', value={'object': node, 'index': index})
+            # Postfix increment: i++
+            elif self._match(TokenType.PLUS_PLUS):
+                node = ASTNode('increment', value={'op': 'postfix', 'operand': node})
+            # Postfix decrement: i--
+            elif self._match(TokenType.MINUS_MINUS):
+                node = ASTNode('decrement', value={'op': 'postfix', 'operand': node})
             else:
                 break
 

includecpp/core/cssl/cssl_runtime.py

@@ -2549,24 +2549,60 @@ class CSSLRuntime:
         if filter_info:
             source = self._apply_injection_filter(source, filter_info)
 
-        # Get current target value for add/move modes
+        # Get current target value for add/move/replace modes (needed for UniversalInstance handling)
         current_value = None
-        if mode in ('add', 'move'):
-            try:
-                current_value = self._evaluate(target)
-            except Exception:
-                # Target might not exist yet, that's okay for add mode
-                current_value = None
+        try:
+            current_value = self._evaluate(target)
+        except Exception:
+            # Target might not exist yet, that's okay for add mode
+            current_value = None
 
         # Determine final value based on mode
         if mode == 'replace':
-            final_value = source
+            from .cssl_types import CSSLInstance, UniversalInstance, CSSLClass
+            # Special handling for UniversalInstance targets - inject instead of replace
+            if isinstance(current_value, UniversalInstance):
+                if isinstance(source, CSSLClass):
+                    current_value.set_member(source.name, source)
+                    final_value = current_value
+                elif isinstance(source, ASTNode) and source.type == 'function':
+                    func_info = source.value
+                    func_name = func_info.get('name') if isinstance(func_info, dict) else None
+                    if func_name:
+                        current_value.set_method(func_name, source, self)
+                    final_value = current_value
+                elif isinstance(source, CSSLInstance):
+                    current_value.set_member(source._class.name, source)
+                    final_value = current_value
+                else:
+                    # For other types, store as member with source type name
+                    final_value = source
+            else:
+                final_value = source
         elif mode == 'add':
             # Copy & add - preserve target and add source
-            from .cssl_types import CSSLInstance
+            from .cssl_types import CSSLInstance, UniversalInstance, CSSLClass
 
+            # Special handling for UniversalInstance + CSSLClass
+            if isinstance(current_value, UniversalInstance) and isinstance(source, CSSLClass):
+                # Inject class definition into universal instance
+                current_value.set_member(source.name, source)
+                final_value = current_value
+            # Special handling for UniversalInstance + Function (AST node)
+            elif isinstance(current_value, UniversalInstance) and isinstance(source, ASTNode) and source.type == 'function':
+                # Inject function as a method into universal instance
+                func_info = source.value
+                func_name = func_info.get('name') if isinstance(func_info, dict) else None
+                if func_name:
+                    current_value.set_method(func_name, source, self)
+                final_value = current_value
+            # Special handling for UniversalInstance + CSSLInstance
+            elif isinstance(current_value, UniversalInstance) and isinstance(source, CSSLInstance):
+                class_name = source._class.name
+                current_value.set_member(class_name, source)
+                final_value = current_value
             # Special handling for CSSLInstance - merge classes
-            if isinstance(current_value, CSSLInstance) and isinstance(source, CSSLInstance):
+            elif isinstance(current_value, CSSLInstance) and isinstance(source, CSSLInstance):
                 # Add the new class instance as a member with class name as key
                 class_name = source._class.name
                 current_value._members[class_name] = source
@@ -2873,7 +2909,7 @@ class CSSLRuntime:
                         func_info = child.value
                         func_name = func_info.get('name') if isinstance(func_info, dict) else None
                         if func_name:
-                            instance.set_method(func_name, child)
+                            instance.set_method(func_name, child, self)
                     elif child.type == 'var_declaration':
                         # Extract variable and value
                         var_info = child.value
@@ -3214,6 +3250,45 @@ class CSSLRuntime:
             # Return None if instance doesn't exist (can be created via ==>)
             return None
 
+        # v4.1.0: Cross-language instance reference: cpp$ClassName, py$Object
+        if node.type == 'lang_instance_ref':
+            ref = node.value  # {'lang': 'cpp', 'instance': 'ClassName'}
+            lang_id = ref['lang']
+            instance_name = ref['instance']
+
+            # First, try to get the language support object from scope
+            lang_support = self.scope.get(lang_id)
+            if lang_support is None:
+                lang_support = self.global_scope.get(lang_id)
+
+            # If not found in scope, try to get from modules
+            if lang_support is None:
+                lang_support = self._modules.get(lang_id)
+
+            # If still not found, try getting default language support
+            if lang_support is None:
+                from .cssl_languages import get_language
+                lang_support = get_language(lang_id)
+
+            if lang_support is not None:
+                # Check if it's a LanguageSupport object with get_instance method
+                if hasattr(lang_support, 'get_instance'):
+                    instance = lang_support.get_instance(instance_name)
+                    if instance is not None:
+                        return instance
+                # Check _instances dict directly
+                if hasattr(lang_support, '_instances'):
+                    if instance_name in lang_support._instances:
+                        return lang_support._instances[instance_name]
+
+            # Build helpful error message
+            hint = f"Use '{lang_id}.share(\"{instance_name}\", instance)' to register the instance first."
+            raise self._format_error(
+                node.line if hasattr(node, 'line') else 0,
+                f"Cross-language instance '{lang_id}${instance_name}' not found",
+                hint
+            )
+
         if node.type == 'new':
             # Create new instance of a class: new ClassName(args)
             return self._eval_new(node)
@@ -3287,6 +3362,14 @@ class CSSLRuntime:
         if node.type == 'unary':
             return self._eval_unary(node)
 
+        # Increment: ++i or i++
+        if node.type == 'increment':
+            return self._eval_increment(node)
+
+        # Decrement: --i or i--
+        if node.type == 'decrement':
+            return self._eval_decrement(node)
+
         if node.type == 'non_null_assert':
             # *$var, *@module, *identifier - assert value is not null/None
             operand = node.value.get('operand')
@@ -3572,6 +3655,74 @@ class CSSLRuntime:
 
         return None
 
+    def _eval_increment(self, node: ASTNode) -> Any:
+        """Evaluate increment operation (++i or i++)"""
+        op_type = node.value.get('op')  # 'prefix' or 'postfix'
+        operand = node.value.get('operand')
+
+        # Get variable name
+        var_name = None
+        if isinstance(operand, ASTNode):
+            if operand.type == 'identifier':
+                var_name = operand.value
+            elif operand.type == 'shared_ref':
+                # Handle $var++
+                var_name = operand.value
+                current = self.shared_vars.get(var_name, 0)
+                if op_type == 'prefix':
+                    self.shared_vars[var_name] = current + 1
+                    return current + 1
+                else:  # postfix
+                    self.shared_vars[var_name] = current + 1
+                    return current
+
+        if var_name:
+            current = self.scope.get(var_name, 0)
+            if op_type == 'prefix':
+                # ++i: increment then return
+                self.scope.set(var_name, current + 1)
+                return current + 1
+            else:
+                # i++: return then increment
+                self.scope.set(var_name, current + 1)
+                return current
+
+        return None
+
+    def _eval_decrement(self, node: ASTNode) -> Any:
+        """Evaluate decrement operation (--i or i--)"""
+        op_type = node.value.get('op')  # 'prefix' or 'postfix'
+        operand = node.value.get('operand')
+
+        # Get variable name
+        var_name = None
+        if isinstance(operand, ASTNode):
+            if operand.type == 'identifier':
+                var_name = operand.value
+            elif operand.type == 'shared_ref':
+                # Handle $var--
+                var_name = operand.value
+                current = self.shared_vars.get(var_name, 0)
+                if op_type == 'prefix':
+                    self.shared_vars[var_name] = current - 1
+                    return current - 1
+                else:  # postfix
+                    self.shared_vars[var_name] = current - 1
+                    return current
+
+        if var_name:
+            current = self.scope.get(var_name, 0)
+            if op_type == 'prefix':
+                # --i: decrement then return
+                self.scope.set(var_name, current - 1)
+                return current - 1
+            else:
+                # i--: return then decrement
+                self.scope.set(var_name, current - 1)
+                return current
+
+        return None
+
     def _eval_call(self, node: ASTNode) -> Any:
         """Evaluate function call with optional named arguments"""
         callee_node = node.value.get('callee')
@@ -3783,6 +3934,22 @@ class CSSLRuntime:
                 hint
             )
 
+        # If we got a variable that holds a class reference, use that class
+        if not isinstance(class_def, CSSLClass):
+            # Check if it's a variable holding a class (dynamic class instantiation)
+            if hasattr(class_def, '__class__') and isinstance(class_def, CSSLClass):
+                pass  # Already a CSSLClass, continue
+            elif isinstance(class_def, dict) and 'class_def' in class_def:
+                # Injected class reference from +<== operator
+                class_def = class_def['class_def']
+            else:
+                # Not a class - show error
+                raise CSSLRuntimeError(
+                    f"'{class_name}' is not a class",
+                    node.line,
+                    hint=f"'{class_name}' is of type {type(class_def).__name__}"
+                )
+
         if not isinstance(class_def, CSSLClass):
             raise CSSLRuntimeError(
                 f"'{class_name}' is not a class",