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

includecpp/__init__.py

@@ -2,7 +2,7 @@ from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
 
-__version__ = "4.0.1"
+__version__ = "4.0.2"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

includecpp/core/cssl/cssl_runtime.py

@@ -278,6 +278,26 @@ class CSSLRuntime:
         self._setup_modules()
         self._setup_builtins()
 
+    def output(self, text: str, level: str = 'normal') -> None:
+        """Output text, using callback if available, otherwise print."""
+        if self._output_callback:
+            self._output_callback(text, level)
+        else:
+            print(text, end='')
+        self.output_buffer.append(text)
+
+    def debug(self, text: str) -> None:
+        """Debug output."""
+        self.output(f"[DEBUG] {text}\n", 'debug')
+
+    def error(self, text: str) -> None:
+        """Error output."""
+        self.output(f"[ERROR] {text}\n", 'error')
+
+    def warn(self, text: str) -> None:
+        """Warning output."""
+        self.output(f"[WARN] {text}\n", 'warning')
+
     def _setup_modules(self):
         """Setup module references for @KernelClient, @VSRAM, etc."""
         if self.service_engine:
@@ -1310,29 +1330,38 @@ class CSSLRuntime:
     def _exec_instance_declaration(self, node: ASTNode) -> Any:
         """Execute instance declaration: instance<"name"> varName;
 
-        Gets or creates a shared instance by name.
+        Gets or creates a universal shared instance by name.
+        Universal instances are accessible from CSSL, Python, and C++.
+
+        Usage:
+            instance<"myContainer"> container;  // Creates or gets instance
+            container.member = "value";         // Set member
+            container +<<== { void func() {} }  // Inject methods
         """
-        from ..cssl_bridge import _live_objects, SharedObjectProxy
+        from .cssl_types import UniversalInstance
+
         decl = node.value
         instance_name = decl.get('instance_name')
         var_name = decl.get('name')
         value_node = decl.get('value')
 
-        # Get existing shared instance
-        instance = None
-        if instance_name in _live_objects:
-            instance = SharedObjectProxy(instance_name, _live_objects[instance_name])
-        elif self.global_scope.has(f'${instance_name}'):
-            instance = self.global_scope.get(f'${instance_name}')
+        # Get existing or create new universal instance
+        instance = UniversalInstance.get_or_create(instance_name)
 
-        # If value is provided, use that and register as shared
+        # If value is provided, set it as initial content
         if value_node:
-            instance = self._evaluate(value_node)
-            # Register in global scope for future access
-            self.global_scope.set(f'${instance_name}', instance)
+            initial_value = self._evaluate(value_node)
+            # If it's a dict, set all keys as members
+            if isinstance(initial_value, dict):
+                for key, val in initial_value.items():
+                    instance.set_member(key, val)
+            else:
+                instance.set_member('value', initial_value)
 
-        # Store in scope
+        # Store in scope and global scope for access
         self.scope.set(var_name, instance)
+        self.global_scope.set(f'${instance_name}', instance)
+
         return instance
 
     def _exec_super_func(self, node: ASTNode) -> Any:
@@ -2736,8 +2765,13 @@ class CSSLRuntime:
         - add: func +<<== { code } - ADDS code to function (both execute)
         - remove: func -<<== { code } - REMOVES matching code from function
 
+        Also supports instance injection:
+        - instance +<<== { void method() { ... } } - ADDS methods to UniversalInstance
+
         Also supports expression form: func <<== %exit() (wraps in action_block)
         """
+        from .cssl_types import UniversalInstance
+
         target = node.value.get('target')
         code_block = node.value.get('code')
         source_expr = node.value.get('source')  # For expression form: func <<== expr
@@ -2749,6 +2783,17 @@ class CSSLRuntime:
             expr_node = ASTNode('expression', value=source_expr)
             code_block = ASTNode('action_block', children=[expr_node])
 
+        # Check if target is a UniversalInstance
+        target_value = None
+        if isinstance(target, ASTNode) and target.type == 'identifier':
+            target_value = self.scope.get(target.value)
+            if target_value is None:
+                target_value = self.global_scope.get(target.value)
+
+        # Handle UniversalInstance injection
+        if isinstance(target_value, UniversalInstance):
+            return self._inject_into_instance(target_value, code_block, mode)
+
         # Get function name from target
         func_name = None
         if isinstance(target, ASTNode):
@@ -2796,6 +2841,60 @@ class CSSLRuntime:
 
         return None
 
+    def _inject_into_instance(self, instance: Any, code_block: Any, mode: str) -> Any:
+        """Inject code/methods into a UniversalInstance.
+
+        Usage:
+            instance<"myContainer"> container;
+            container +<<== {
+                void sayHello() { printl("Hello!"); }
+                int value = 42;
+            }
+        """
+        from .cssl_types import UniversalInstance
+
+        if not isinstance(instance, UniversalInstance):
+            return None
+
+        if code_block is None:
+            return None
+
+        # Store the raw injection
+        instance.add_injection(code_block)
+
+        # Parse the code block for function definitions and variable declarations
+        if isinstance(code_block, ASTNode):
+            children = code_block.children if hasattr(code_block, 'children') else []
+
+            for child in children:
+                if isinstance(child, ASTNode):
+                    if child.type == 'function':
+                        # Extract function name and store the AST node
+                        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)
+                    elif child.type == 'var_declaration':
+                        # Extract variable and value
+                        var_info = child.value
+                        if isinstance(var_info, dict):
+                            var_name = var_info.get('name')
+                            value_node = var_info.get('value')
+                            if var_name:
+                                value = self._evaluate(value_node) if value_node else None
+                                instance.set_member(var_name, value)
+                    elif child.type == 'typed_var_declaration':
+                        # Typed variable declaration
+                        var_info = child.value
+                        if isinstance(var_info, dict):
+                            var_name = var_info.get('name')
+                            value_node = var_info.get('value')
+                            if var_name:
+                                value = self._evaluate(value_node) if value_node else None
+                                instance.set_member(var_name, value)
+
+        return instance
+
     def _exec_infuse_right(self, node: ASTNode) -> Any:
         """Execute right-side code infusion (==>>)"""
         source = node.value.get('source')
@@ -3516,7 +3615,33 @@ class CSSLRuntime:
         if isinstance(callee, ASTNode) and callee.type == 'function':
             return self._call_function(callee, args, kwargs)
 
-        callee_name = callee_node.value if isinstance(callee_node, ASTNode) and hasattr(callee_node, 'value') else str(callee_node)
+        # Extract callee name for error messages
+        if isinstance(callee_node, ASTNode) and hasattr(callee_node, 'value'):
+            val = callee_node.value
+            if isinstance(val, str):
+                callee_name = val
+            elif isinstance(val, dict):
+                # For member access nodes like obj.method, get the member name
+                if 'member' in val:
+                    obj_node = val.get('object')
+                    member = val.get('member')
+                    obj_name = obj_node.value if isinstance(obj_node, ASTNode) else str(obj_node)
+                    callee_name = f"{obj_name}.{member}"
+                # For call nodes, try to get the callee name
+                elif 'callee' in val:
+                    callee_val = val.get('callee')
+                    if isinstance(callee_val, ASTNode):
+                        callee_name = callee_val.value if isinstance(callee_val.value, str) else str(callee_val.value)
+                    else:
+                        callee_name = str(callee_val)
+                elif 'name' in val:
+                    callee_name = str(val.get('name'))
+                else:
+                    callee_name = str(val)
+            else:
+                callee_name = str(val)
+        else:
+            callee_name = str(callee_node)
 
         # Build detailed error with suggestions
         available_funcs = _get_available_functions(self.scope, self.global_scope, self.builtins)
@@ -4112,6 +4237,48 @@ class CSSLRuntime:
                 hint
             )
 
+        # === UNIVERSAL INSTANCE METHODS ===
+        from .cssl_types import UniversalInstance
+        if isinstance(obj, UniversalInstance):
+            # Check for member variable
+            if obj.has_member(member):
+                return obj.get_member(member)
+            # Check for method
+            if obj.has_method(member):
+                method_node = obj.get_method(member)
+                # Create a callable that executes the method in context
+                def instance_method_caller(*args, **kwargs):
+                    # Set 'this' to refer to the instance
+                    old_this = self.scope.get('this')
+                    self.scope.set('this', obj)
+                    try:
+                        return self._call_function(method_node, list(args))
+                    finally:
+                        if old_this is not None:
+                            self.scope.set('this', old_this)
+                        else:
+                            self.scope.remove('this') if hasattr(self.scope, 'remove') else None
+                return instance_method_caller
+            # Build helpful error with available members
+            instance_name = obj.name
+            available_members = list(obj.get_all_members().keys())
+            available_methods = list(obj.get_all_methods().keys())
+            all_available = available_members + available_methods
+            similar = _find_similar_names(member, all_available)
+
+            if similar:
+                hint = f"Did you mean: {', '.join(similar)}?"
+            elif all_available:
+                hint = f"Available: {', '.join(all_available[:5])}"
+            else:
+                hint = f"Instance '{instance_name}' has no accessible members."
+
+            raise self._format_error(
+                node.line,
+                f"Instance '{instance_name}' has no member or method '{member}'",
+                hint
+            )
+
         # === STRING METHODS ===
         if isinstance(obj, str):
             string_methods = self._get_string_method(obj, member)
@@ -4350,6 +4517,12 @@ class CSSLRuntime:
             obj.set_member(member, value)
             return
 
+        # Check for UniversalInstance - use set_member method
+        from .cssl_types import UniversalInstance
+        if isinstance(obj, UniversalInstance):
+            obj.set_member(member, value)
+            return
+
         # Check for SharedObjectProxy - directly access underlying object
         # This is more robust than relying on the proxy's __setattr__
         if hasattr(obj, '_direct_object') and hasattr(obj, '_name'):

includecpp/core/cssl/cssl_types.py

@@ -1624,10 +1624,152 @@ class CSSLInstance:
         return f"<{self._class.name} instance at 0x{id(self):x}>"
 
 
+class UniversalInstance:
+    """Universal shared container accessible from CSSL, Python, and C++.
+
+    Created via instance<"name"> syntax in CSSL or getInstance("name") in Python.
+    Supports dynamic member/method injection via +<<== operator.
+
+    Example CSSL:
+        instance<"myContainer"> container;
+        container +<<== { void sayHello() { printl("Hello!"); } }
+        container.sayHello();
+
+    Example Python:
+        container = cssl.getInstance("myContainer")
+        container.sayHello()
+    """
+
+    # Global registry for all universal instances
+    _registry: Dict[str, 'UniversalInstance'] = {}
+
+    def __init__(self, name: str):
+        self._name = name
+        self._members: Dict[str, Any] = {}
+        self._methods: Dict[str, Any] = {}  # Method name -> AST node or callable
+        self._injections: List[Any] = []  # Code blocks injected via +<<==
+        # Register globally
+        UniversalInstance._registry[name] = self
+
+    @classmethod
+    def get_or_create(cls, name: str) -> 'UniversalInstance':
+        """Get existing instance or create new one."""
+        if name in cls._registry:
+            return cls._registry[name]
+        return cls(name)
+
+    @classmethod
+    def get(cls, name: str) -> Optional['UniversalInstance']:
+        """Get existing instance by name, returns None if not found."""
+        return cls._registry.get(name)
+
+    @classmethod
+    def exists(cls, name: str) -> bool:
+        """Check if instance exists."""
+        return name in cls._registry
+
+    @classmethod
+    def delete(cls, name: str) -> bool:
+        """Delete instance from registry."""
+        if name in cls._registry:
+            del cls._registry[name]
+            return True
+        return False
+
+    @classmethod
+    def clear_all(cls) -> int:
+        """Clear all instances. Returns count of cleared instances."""
+        count = len(cls._registry)
+        cls._registry.clear()
+        return count
+
+    @classmethod
+    def list_all(cls) -> List[str]:
+        """List all instance names."""
+        return list(cls._registry.keys())
+
+    @property
+    def name(self) -> str:
+        """Get instance name."""
+        return self._name
+
+    def set_member(self, name: str, value: Any) -> None:
+        """Set a member value."""
+        self._members[name] = value
+
+    def get_member(self, name: str) -> Any:
+        """Get a member value."""
+        if name in self._members:
+            return self._members[name]
+        raise AttributeError(f"Instance '{self._name}' has no member '{name}'")
+
+    def has_member(self, name: str) -> bool:
+        """Check if member exists."""
+        return name in self._members
+
+    def set_method(self, name: str, method: Any) -> None:
+        """Set a method (AST node or callable)."""
+        self._methods[name] = method
+
+    def get_method(self, name: str) -> Any:
+        """Get a method by name."""
+        if name in self._methods:
+            return self._methods[name]
+        raise AttributeError(f"Instance '{self._name}' has no method '{name}'")
+
+    def has_method(self, name: str) -> bool:
+        """Check if method exists."""
+        return name in self._methods
+
+    def add_injection(self, code_block: Any) -> None:
+        """Add a code injection (from +<<== operator)."""
+        self._injections.append(code_block)
+
+    def get_injections(self) -> List[Any]:
+        """Get all injected code blocks."""
+        return self._injections
+
+    def get_all_members(self) -> Dict[str, Any]:
+        """Get all members."""
+        return dict(self._members)
+
+    def get_all_methods(self) -> Dict[str, Any]:
+        """Get all methods."""
+        return dict(self._methods)
+
+    def __getattr__(self, name: str) -> Any:
+        """Allow direct attribute access for members and methods."""
+        if name.startswith('_'):
+            raise AttributeError(name)
+        if name in object.__getattribute__(self, '_members'):
+            return object.__getattribute__(self, '_members')[name]
+        if name in object.__getattribute__(self, '_methods'):
+            return object.__getattribute__(self, '_methods')[name]
+        raise AttributeError(f"Instance '{object.__getattribute__(self, '_name')}' has no attribute '{name}'")
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Allow direct attribute setting for members."""
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+        else:
+            if hasattr(self, '_members'):
+                self._members[name] = value
+            else:
+                object.__setattr__(self, name, value)
+
+    def __repr__(self):
+        members = len(self._members)
+        methods = len(self._methods)
+        return f"<UniversalInstance '{self._name}' ({members} members, {methods} methods)>"
+
+    def __str__(self):
+        return f"<UniversalInstance '{self._name}'>"
+
+
 __all__ = [
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
     'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array', 'List', 'Dictionary', 'Map',
-    'CSSLClass', 'CSSLInstance',
+    'CSSLClass', 'CSSLInstance', 'UniversalInstance',
     'create_datastruct', 'create_shuffled', 'create_iterator',
     'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter',
     'create_stack', 'create_vector', 'create_array', 'create_list', 'create_dictionary', 'create_map'