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

includecpp/core/cssl/cssl_runtime.py

@@ -883,6 +883,18 @@ class CSSLRuntime:
         class_params = class_info.get('class_params', [])
         extends_args = class_info.get('extends_args', [])
 
+        # v4.2.0: Handle 'supports' language transformation for raw_body
+        supports_language = class_info.get('supports_language')
+        raw_body = class_info.get('raw_body')
+
+        if raw_body and supports_language:
+            # Transform raw body from target language to CSSL and parse
+            transformed_children = self._transform_and_parse_class_body(
+                raw_body, supports_language, class_name
+            )
+            # Add transformed children to node's children
+            node.children = transformed_children
+
         for child in node.children:
             if child.type == 'constructor':
                 # New-style constructor from 'constr' keyword
@@ -1007,6 +1019,119 @@ class CSSLRuntime:
                 self._current_instance = old_instance
         return wrapper
 
+    def _transform_and_parse_class_body(self, raw_body: str, language: str, class_name: str) -> list:
+        """Transform source code from another language to CSSL and parse as class body.
+
+        v4.2.0: Used for 'supports <lang>' in class definitions.
+
+        Args:
+            raw_body: Raw source code in the target language
+            language: Language identifier (py, python, cpp, c++, js, javascript, etc.)
+            class_name: Name of the class (for constructor recognition)
+
+        Returns:
+            List of parsed AST nodes representing methods, constructors, and members
+        """
+        import textwrap
+        from .cssl_languages import get_language
+        from .cssl_parser import parse_cssl_program, ASTNode
+
+        # Normalize language ID
+        lang_id = language.lstrip('@').lower()
+
+        # Get language support and transformer
+        lang_support = get_language(lang_id)
+        if lang_support is None:
+            raise CSSLRuntimeError(f"Unknown language '{lang_id}' in 'supports' clause")
+
+        # Dedent the raw body to normalize indentation
+        # This fixes the issue where code inside CSSL {} has relative indentation
+        dedented_body = textwrap.dedent(raw_body)
+
+        # Transform the raw body to CSSL syntax
+        transformer = lang_support.get_transformer()
+        transformed_source = transformer.transform_source(dedented_body)
+
+        # Wrap in a dummy class for parsing
+        wrapper_source = f"class _TempClass {{\n{transformed_source}\n}}"
+
+        try:
+            ast = parse_cssl_program(wrapper_source)
+        except Exception as e:
+            raise CSSLRuntimeError(
+                f"Failed to parse transformed '{lang_id}' code: {e}\n"
+                f"Dedented:\n{dedented_body}\n"
+                f"Transformed:\n{transformed_source}"
+            )
+
+        # Extract children from the parsed temp class
+        children = []
+        for top_level in ast.children:
+            if top_level.type == 'class':
+                for child in top_level.children:
+                    # Mark constructor if method name matches class_name or is __init__
+                    if child.type == 'function':
+                        func_info = child.value
+                        method_name = func_info.get('name')
+                        if method_name == class_name or method_name == '__init__':
+                            child.value['is_constructor'] = True
+                    children.append(child)
+                break
+
+        return children
+
+    def _transform_and_parse_function_body(self, raw_body: str, language: str) -> list:
+        """Transform source code from another language to CSSL and parse as function body.
+
+        v4.2.0: Used for 'supports <lang>' in function definitions.
+
+        Args:
+            raw_body: Raw source code in the target language
+            language: Language identifier (py, python, cpp, c++, js, javascript, etc.)
+
+        Returns:
+            List of parsed AST nodes representing statements in the function body
+        """
+        import textwrap
+        from .cssl_languages import get_language
+        from .cssl_parser import parse_cssl_program
+
+        # Normalize language ID
+        lang_id = language.lstrip('@').lower()
+
+        # Get language support and transformer
+        lang_support = get_language(lang_id)
+        if lang_support is None:
+            raise CSSLRuntimeError(f"Unknown language '{lang_id}' in 'supports' clause")
+
+        # Dedent the raw body to normalize indentation
+        dedented_body = textwrap.dedent(raw_body)
+
+        # Transform the raw body to CSSL syntax
+        transformer = lang_support.get_transformer()
+        transformed_source = transformer.transform_source(dedented_body)
+
+        # Wrap in a dummy function for parsing
+        wrapper_source = f"define _TempFunc() {{\n{transformed_source}\n}}"
+
+        try:
+            ast = parse_cssl_program(wrapper_source)
+        except Exception as e:
+            raise CSSLRuntimeError(
+                f"Failed to parse transformed '{lang_id}' code: {e}\n"
+                f"Dedented:\n{dedented_body}\n"
+                f"Transformed:\n{transformed_source}"
+            )
+
+        # Extract children from the parsed temp function
+        children = []
+        for top_level in ast.children:
+            if top_level.type == 'function':
+                children = top_level.children
+                break
+
+        return children
+
     def _exec_function(self, node: ASTNode) -> Any:
         """Execute function definition - registers it and handles extends/overwrites.
 
@@ -1172,16 +1297,22 @@ class CSSLRuntime:
             if ref_member and hasattr(ref_obj, ref_member):
                 original_method = getattr(ref_obj, ref_member)
                 runtime = self
+                # Store the original method before wrapping
+                _saved_original = original_method
                 def appended_wrapper(*args, **kwargs):
-                    # Run original first
+                    # Run original first (use saved reference to avoid recursion)
                     result = None
-                    if callable(original_method):
+                    if callable(_saved_original):
                         try:
-                            result = original_method(*args, **kwargs)
+                            result = _saved_original(*args, **kwargs)
                         except:
                             pass
-                    # Then run appended code
-                    return runtime._call_function(append_node, list(args), kwargs)
+                    # Then run appended code - disable append_mode to prevent recursion
+                    append_node.value['append_mode'] = False
+                    try:
+                        return runtime._call_function(append_node, list(args), kwargs)
+                    finally:
+                        append_node.value['append_mode'] = True
                 try:
                     setattr(ref_obj, ref_member, appended_wrapper)
                 except (AttributeError, TypeError):
@@ -1546,13 +1677,15 @@ class CSSLRuntime:
 
         # Bind parameters - handle both positional and named arguments
         for i, param in enumerate(params):
-            # Extract param name and type from dict format: {'name': 'a', 'type': 'int'}
+            # Extract param name, type, and default from dict format: {'name': 'a', 'type': 'int', 'default': ...}
             if isinstance(param, dict):
                 param_name = param['name']
                 param_type = param.get('type', '')
+                param_default = param.get('default')  # v4.2.0: Default value AST node
             else:
                 param_name = param
                 param_type = ''
+                param_default = None
 
             # Check if this is an 'open' parameter - receives all args as a list
             # The parser sets param['open'] = True for 'open' keyword
@@ -1575,6 +1708,10 @@ class CSSLRuntime:
             elif i < len(args):
                 # Positional argument
                 new_scope.set(param_name, args[i])
+            elif param_default is not None:
+                # v4.2.0: Use default value if no argument provided
+                default_value = self._evaluate(param_default)
+                new_scope.set(param_name, default_value)
             else:
                 new_scope.set(param_name, None)
 
@@ -1594,11 +1731,24 @@ class CSSLRuntime:
                     args, kwargs, {}, is_constructor=False
                 )
 
-            for child in func_node.children:
-                # Check if exit() was called
-                if not self._running:
-                    break
-                self._execute_node(child)
+            # v4.2.0: Handle raw_body with supports_language (multi-language support)
+            raw_body = func_info.get('raw_body')
+            supports_language = func_info.get('supports_language')
+
+            if raw_body and supports_language:
+                # Transform and parse the raw body from the target language
+                body_children = self._transform_and_parse_function_body(raw_body, supports_language)
+                for child in body_children:
+                    if not self._running:
+                        break
+                    self._execute_node(child)
+            else:
+                # Normal CSSL function body
+                for child in func_node.children:
+                    # Check if exit() was called
+                    if not self._running:
+                        break
+                    self._execute_node(child)
         except CSSLReturn as ret:
             return_value = ret.value
 
@@ -1981,6 +2131,71 @@ class CSSLRuntime:
 
         return None
 
+    def _exec_supports_block(self, node: ASTNode) -> Any:
+        """Execute standalone supports block for multi-language syntax.
+
+        v4.2.0: Allows 'supports' to be used anywhere, not just in class/function.
+
+        Syntax:
+            supports py {
+                for i in range(10):
+                    print(i)
+            }
+
+            supports cpp {
+                int x = 42;
+                std::cout << x << std::endl;
+            }
+        """
+        block_info = node.value
+        language = block_info.get('language')
+        raw_source = block_info.get('raw_source')
+
+        # If we have raw_source, transform and execute
+        if raw_source and language:
+            import textwrap
+            from .cssl_languages import get_language
+            from .cssl_parser import parse_cssl_program
+
+            # Normalize language ID
+            lang_id = language.lstrip('@').lower()
+
+            # Get language support and transformer
+            lang_support = get_language(lang_id)
+            if lang_support is None:
+                raise CSSLRuntimeError(f"Unknown language '{lang_id}' in 'supports' block")
+
+            # Dedent the raw source to normalize indentation
+            dedented_source = textwrap.dedent(raw_source)
+
+            # Transform the raw source to CSSL
+            transformer = lang_support.get_transformer()
+            transformed_source = transformer.transform_source(dedented_source)
+
+            # Parse the transformed CSSL
+            try:
+                ast = parse_cssl_program(transformed_source)
+            except Exception as e:
+                raise CSSLRuntimeError(
+                    f"Failed to parse transformed '{lang_id}' code in supports block: {e}\n"
+                    f"Dedented:\n{dedented_source}\n"
+                    f"Transformed:\n{transformed_source}"
+                )
+
+            # Execute the transformed AST
+            result = None
+            for child in ast.children:
+                result = self._execute_node(child)
+
+            return result
+
+        # Fallback: execute already-parsed children (CSSL syntax)
+        result = None
+        for child in node.children:
+            result = self._execute_node(child)
+
+        return result
+
     def _exec_createcmd_inject(self, node: ASTNode) -> Any:
         """Execute createcmd injection: createcmd('cmd') <== { action }"""
         command_call = node.value.get('command_call')
@@ -2549,24 +2764,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 +3124,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
@@ -2981,7 +3232,13 @@ class CSSLRuntime:
                 if self._current_instance is None:
                     raise CSSLRuntimeError("'this' used outside of class method context")
                 member = target.value.get('member')
-                self._current_instance.set_member(member, value)
+                instance = self._current_instance
+                # Check if instance is a CSSL instance or a plain Python object
+                if hasattr(instance, 'set_member'):
+                    instance.set_member(member, value)
+                else:
+                    # Plain Python object - use setattr
+                    setattr(instance, member, value)
         elif isinstance(target, str):
             self.scope.set(target, value)
 
@@ -3214,6 +3471,83 @@ class CSSLRuntime:
             # Return None if instance doesn't exist (can be created via ==>)
             return None
 
+        # v4.1.0/v4.1.1: Cross-language instance reference: cpp$ClassName, py$Object
+        # Enhanced bidirectional access with real runtime bridges
+        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:
+                # v4.1.1: 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
+
+                # v4.1.1: For C++, also try to get class from loaded modules directly
+                if hasattr(lang_support, '_get_bridge'):
+                    bridge = lang_support._get_bridge()
+                    if bridge is not None:
+                        # Try to get from bridge's instances
+                        bridge_instance = bridge.get_instance(instance_name)
+                        if bridge_instance is not None:
+                            return bridge_instance
+
+                        # For C++: Try to access class from IncludeCPP modules
+                        if hasattr(bridge, '_modules'):
+                            for mod in bridge._modules.values():
+                                if hasattr(mod, instance_name):
+                                    cls_or_instance = getattr(mod, instance_name)
+                                    # Cache it for future access
+                                    lang_support._instances[instance_name] = cls_or_instance
+                                    return cls_or_instance
+
+                # Check _instances dict directly as fallback
+                if hasattr(lang_support, '_instances'):
+                    if instance_name in lang_support._instances:
+                        return lang_support._instances[instance_name]
+
+            # Build helpful error message based on language
+            if lang_id in ('cpp', 'c++'):
+                hint = (f"For C++ access:\n"
+                       f"  1. Build your module with 'includecpp build'\n"
+                       f"  2. Use cpp.share(\"{instance_name}\", instance) to register\n"
+                       f"  3. Or access a class directly: obj = new cpp${instance_name}()")
+            elif lang_id in ('java',):
+                hint = (f"For Java access:\n"
+                       f"  1. Install JPype: pip install jpype1\n"
+                       f"  2. Add classpath: java.add_classpath(\"path/to/jar\")\n"
+                       f"  3. Load class: MyClass = java.load_class(\"com.example.{instance_name}\")\n"
+                       f"  4. Share instance: java.share(\"{instance_name}\", instance)")
+            elif lang_id in ('js', 'javascript'):
+                hint = (f"For JavaScript access:\n"
+                       f"  1. Make sure Node.js is installed\n"
+                       f"  2. Define in JS: js.eval(\"function {instance_name}() {{...}}\")\n"
+                       f"  3. Share result: js.share(\"{instance_name}\", result)")
+            else:
+                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 +3621,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 +3914,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 +4193,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",
@@ -4080,24 +4506,40 @@ class CSSLRuntime:
         # Direct this->member access
         instance = self._current_instance
 
-        # Check if it's a member variable
-        if instance.has_member(member):
-            return instance.get_member(member)
+        # Check if instance is a CSSL instance or a plain Python object
+        is_cssl_instance = hasattr(instance, 'has_member') and hasattr(instance, 'has_method')
 
-        # Check if it's a method
-        if instance.has_method(member):
-            # Return a callable that will invoke the method with instance context
-            method_node = instance.get_method(member)
-            # Check if this is an inherited Python method
-            if isinstance(method_node, tuple) and method_node[0] == 'python_method':
-                python_method = method_node[1]
-                return lambda *args, **kwargs: python_method(*args, **kwargs)
-            return lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
+        if is_cssl_instance:
+            # CSSL instance - use CSSL methods
+            if instance.has_member(member):
+                return instance.get_member(member)
+
+            # Check if it's a method
+            if instance.has_method(member):
+                # Return a callable that will invoke the method with instance context
+                method_node = instance.get_method(member)
+                # Check if this is an inherited Python method
+                if isinstance(method_node, tuple) and method_node[0] == 'python_method':
+                    python_method = method_node[1]
+                    return lambda *args, **kwargs: python_method(*args, **kwargs)
+                return lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
+        else:
+            # Plain Python object - use standard attribute access
+            if hasattr(instance, member):
+                return getattr(instance, member)
+            # Also check __dict__ for dynamic attributes
+            if hasattr(instance, '__dict__') and member in instance.__dict__:
+                return instance.__dict__[member]
 
         # Build helpful error with available members
-        class_name = instance._class.name
-        available_members = list(instance._members.keys()) if hasattr(instance, '_members') else []
-        available_methods = list(instance._methods.keys()) if hasattr(instance, '_methods') else []
+        if is_cssl_instance:
+            class_name = instance._class.name
+            available_members = list(instance._members.keys()) if hasattr(instance, '_members') else []
+            available_methods = list(instance._methods.keys()) if hasattr(instance, '_methods') else []
+        else:
+            class_name = type(instance).__name__
+            available_members = [k for k in dir(instance) if not k.startswith('_')]
+            available_methods = []
         all_available = available_members + available_methods
         similar = _find_similar_names(member, all_available)