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

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'

includecpp/core/cssl_bridge.py

@@ -266,8 +266,8 @@ class CSSLFunctionModule:
 
         from .cssl import CSSLRuntime, parse_cssl_program, ASTNode
 
-        # Create a dedicated runtime for this module
-        self._runtime = CSSLRuntime()
+        # Create a dedicated runtime for this module, preserving output_callback
+        self._runtime = CSSLRuntime(output_callback=self._cssl._output_callback)
 
         # If we have a payload, load it first (defines functions/globals for main)
         if self._payload_code:
@@ -330,7 +330,12 @@ class CSSLFunctionModule:
                 self._runtime.global_scope.set('parameter', Parameter(list(args)))
                 self._runtime.global_scope.set('args', list(args))
                 self._runtime.global_scope.set('argc', len(args))
-                return self._runtime._call_function(func_node, list(args))
+                # Enable running flag for function execution
+                self._runtime._running = True
+                try:
+                    return self._runtime._call_function(func_node, list(args))
+                finally:
+                    self._runtime._running = False
 
             return wrapper
 
@@ -603,7 +608,8 @@ class CsslLang:
         self,
         main_script: Union[str, 'CSSLScript'],
         payload_script: Union[str, 'CSSLScript', None] = None,
-        name: str = None
+        name: str = None,
+        bind: str = None
     ) -> 'CSSLFunctionModule':
         """
         Create a CSSL module with accessible functions.
@@ -612,13 +618,22 @@ class CsslLang:
         Optionally registers the module for payload() access in other scripts.
 
         Args:
-            main_script: Main CSSL code (string or CSSLScript)
+            main_script: Main CSSL code, file path, or CSSLScript
             payload_script: Optional payload code (string or CSSLScript)
             name: Optional name to register for payload(name) access
+            bind: Optional payload name to auto-prepend (from makepayload)
 
         Returns:
             CSSLFunctionModule - module with callable function attributes
 
+        Usage (simplified - with file path and bind):
+            # First register the payload
+            cssl.makepayload("api", "lib/api/einkaufsmanager.cssl-pl")
+
+            # Then create module from file, binding to payload
+            mod = cssl.makemodule("writer", "lib/writer.cssl", bind="api")
+            mod.SaySomething("Hello!")  # Functions are now accessible
+
         Usage (v3.8.0 - with CSSLScript objects):
             main = cssl.script("cssl", '''
                 printl("Main");
@@ -644,6 +659,28 @@ class CsslLang:
             ''')
             module.greet("World")  # Returns "Hello, World!"
         """
+        # Handle simplified API: makemodule(name, path, bind=...)
+        # Check if main_script looks like a short identifier and payload_script looks like a path
+        if (isinstance(main_script, str) and isinstance(payload_script, str) and
+            not '\n' in main_script and not ';' in main_script and not '{' in main_script):
+            # main_script is likely a name, payload_script is likely a path
+            module_name = main_script
+            path = payload_script
+
+            # Check if it's actually a file path
+            path_obj = Path(path)
+            if path_obj.exists():
+                main_code = path_obj.read_text(encoding='utf-8')
+
+                # If bind is specified, prepend that payload's code
+                payload_code = None
+                if bind:
+                    runtime = self._get_runtime()
+                    if hasattr(runtime, '_inline_payloads') and bind in runtime._inline_payloads:
+                        payload_code = runtime._inline_payloads[bind]
+
+                return CSSLFunctionModule(self, main_code, payload_code, module_name)
+
         # Extract code from CSSLScript objects if provided
         if isinstance(main_script, CSSLScript):
             main_code = main_script.code
@@ -657,6 +694,12 @@ class CsslLang:
             else:
                 payload_code = payload_script
 
+        # If bind is specified and no payload_script, use the bound payload
+        if bind and payload_code is None:
+            runtime = self._get_runtime()
+            if hasattr(runtime, '_inline_payloads') and bind in runtime._inline_payloads:
+                payload_code = runtime._inline_payloads[bind]
+
         return CSSLFunctionModule(self, main_code, payload_code, name)
 
     def load(self, path: str, name: str) -> None:
@@ -781,6 +824,45 @@ class CsslLang:
             runtime._inline_payloads = {}
         runtime._inline_payloads[name] = code
 
+    def makepayload(self, name: str, path: str) -> str:
+        """
+        Register a payload from a file path.
+
+        Reads the file and registers it as a payload accessible via payload(name) in CSSL.
+        This is a convenience method that combines reading a file and calling code().
+
+        Usage:
+            from includecpp import CSSL
+            cssl = CSSL.CsslLang()
+
+            # Register a payload from file
+            cssl.makepayload("api", "lib/api/myapi.cssl-pl")
+
+            # Now use in CSSL code
+            cssl.run('''
+                payload("api");  // Load the payload
+                myApiFunction();  // Call functions from it
+            ''')
+
+            # Or use with makemodule for automatic binding
+            mod = cssl.makemodule("writer", "lib/writer.cssl", bind="api")
+            mod.SaySomething("Hello!")
+
+        Args:
+            name: Name to register the payload under (used in payload(name) and bind=name)
+            path: Path to the .cssl-pl or .cssl file
+
+        Returns:
+            The payload code that was registered
+        """
+        path_obj = Path(path)
+        if not path_obj.exists():
+            raise FileNotFoundError(f"Payload file not found: {path}")
+
+        code = path_obj.read_text(encoding='utf-8')
+        self.code(name, code)
+        return code
+
     def share(self, instance: Any, name: str = None) -> str:
         """
         Share a Python object instance with CSSL scripts (LIVE sharing).
@@ -979,6 +1061,73 @@ class CsslLang:
         """
         return self.get_shared(name)
 
+    def getInstance(self, name: str) -> Optional[Any]:
+        """
+        Get a universal instance by name (for Python-side access).
+
+        Universal instances are shared containers accessible from CSSL, Python, and C++.
+        They support dynamic member/method access and are mutable across all contexts.
+
+        Usage:
+            from includecpp import CSSL
+            cssl = CSSL.CsslLang()
+
+            # In CSSL: instance<"myContainer"> container;
+            # Then in Python:
+            container = cssl.getInstance("myContainer")
+            container.member = "value"
+            print(container.member)  # value
+
+        Args:
+            name: Name of the instance (without quotes)
+
+        Returns:
+            The UniversalInstance or None if not found
+        """
+        from .cssl.cssl_types import UniversalInstance
+        return UniversalInstance.get(name)
+
+    def createInstance(self, name: str) -> Any:
+        """
+        Create or get a universal instance by name (for Python-side creation).
+
+        Usage:
+            container = cssl.createInstance("myContainer")
+            container.data = {"key": "value"}
+            # Now accessible in CSSL via instance<"myContainer">
+
+        Args:
+            name: Name for the instance
+
+        Returns:
+            The UniversalInstance (new or existing)
+        """
+        from .cssl.cssl_types import UniversalInstance
+        return UniversalInstance.get_or_create(name)
+
+    def deleteInstance(self, name: str) -> bool:
+        """
+        Delete a universal instance by name.
+
+        Args:
+            name: Name of the instance to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        from .cssl.cssl_types import UniversalInstance
+        return UniversalInstance.delete(name)
+
+    def listInstances(self) -> list:
+        """
+        List all universal instance names.
+
+        Returns:
+            List of instance names
+        """
+        from .cssl.cssl_types import UniversalInstance
+        return UniversalInstance.list_all()
+
 
 # Global shared objects registry (for cross-instance sharing)
 _global_shared_objects: Dict[str, str] = {}
@@ -1303,14 +1452,49 @@ def module(code: str) -> CSSLModule:
     return get_cssl().module(code)
 
 
+def makepayload(name: str, path: str) -> str:
+    """
+    Register a payload from a file path.
+
+    Reads the file and registers it as a payload accessible via payload(name) in CSSL.
+
+    Usage:
+        from includecpp import CSSL
+
+        # Register a payload from file
+        CSSL.makepayload("api", "lib/api/myapi.cssl-pl")
+
+        # Use with makemodule for automatic binding
+        mod = CSSL.makemodule("writer", "lib/writer.cssl", bind="api")
+        mod.SaySomething("Hello!")
+
+    Args:
+        name: Name to register the payload under (used in payload(name) and bind=name)
+        path: Path to the .cssl-pl or .cssl file
+
+    Returns:
+        The payload code that was registered
+    """
+    return get_cssl().makepayload(name, path)
+
+
 def makemodule(
     main_script: Union[str, CSSLScript],
     payload_script: Union[str, CSSLScript, None] = None,
-    name: str = None
+    name: str = None,
+    bind: str = None
 ) -> CSSLFunctionModule:
     """
     Create a CSSL module with accessible functions.
 
+    Usage (simplified - with file path and bind):
+        # First register the payload
+        CSSL.makepayload("api", "lib/api/einkaufsmanager.cssl-pl")
+
+        # Then create module from file, binding to payload
+        mod = CSSL.makemodule("writer", "lib/writer.cssl", bind="api")
+        mod.SaySomething("Hello!")
+
     Usage (v3.8.0 - with CSSLScript):
         main = CSSL.script("cssl", '''printl("Main");''')
         payload = CSSL.script("cssl-pl", '''void helper() {}''')
@@ -1323,14 +1507,15 @@ def makemodule(
         math_mod.add(2, 3)  # Returns 5
 
     Args:
-        main_script: Main CSSL code (string or CSSLScript)
+        main_script: Main CSSL code, file path, or CSSLScript
         payload_script: Optional payload code (string or CSSLScript)
         name: Optional name to register for payload(name) access
+        bind: Optional payload name to auto-prepend (from makepayload)
 
     Returns:
         CSSLFunctionModule - module with callable function attributes
     """
-    return get_cssl().makemodule(main_script, payload_script, name)
+    return get_cssl().makemodule(main_script, payload_script, name, bind)
 
 
 # Export all
@@ -1360,6 +1545,7 @@ __all__ = [
     'get_output',
     'clear_output',
     'module',
+    'makepayload',
     'makemodule',
     'share',
     'unshare',

includecpp/core/cssl_bridge.pyi

@@ -412,7 +412,37 @@ class CsslLang:
         """
         ...
 
-    def makemodule(self, code_or_script: Union[str, CSSLScript], *more: Any) -> CSSLFunctionModule:
+    def makepayload(self, name: str, path: str) -> str:
+        """
+        Register a payload from a file path.
+
+        Reads the file and registers it as a payload accessible via payload(name) in CSSL.
+        This is a convenience method for loading payload files.
+
+        Args:
+            name: Name to register the payload under (used in payload(name) and bind=name)
+            path: Path to the .cssl-pl or .cssl file
+
+        Returns:
+            The payload code that was registered
+
+        Usage:
+            # Register a payload from file
+            cssl.makepayload("api", "lib/api/myapi.cssl-pl")
+
+            # Use with makemodule for automatic binding
+            mod = cssl.makemodule("writer", "lib/writer.cssl", bind="api")
+            mod.SaySomething("Hello!")
+        """
+        ...
+
+    def makemodule(
+        self,
+        main_script: Union[str, CSSLScript],
+        payload_script: Union[str, CSSLScript, None] = ...,
+        name: str = ...,
+        bind: str = ...
+    ) -> CSSLFunctionModule:
         """
         Create a CSSL module with accessible functions as methods.
 
@@ -420,14 +450,23 @@ class CsslLang:
         Functions defined in the code become callable Python methods.
 
         Args:
-            code_or_script: CSSL code string or CSSLScript object
-            *more: Additional scripts or module name
+            main_script: CSSL code string, file path, or CSSLScript object
+            payload_script: Optional payload code (string or CSSLScript)
+            name: Optional name to register for payload(name) access
+            bind: Optional payload name to auto-prepend (from makepayload)
 
         Returns:
             CSSLFunctionModule with callable function attributes
 
-        Usage:
-            # From code string
+        Usage (simplified - with file path and bind):
+            # First register the payload
+            cssl.makepayload("api", "lib/api/einkaufsmanager.cssl-pl")
+
+            # Then create module from file, binding to payload
+            mod = cssl.makemodule("writer", "lib/writer.cssl", bind="api")
+            mod.SaySomething("Hello!")  # Functions are now accessible
+
+        Usage (from code string):
             math = cssl.makemodule('''
                 int add(int a, int b) { return a + b; }
                 int sub(int a, int b) { return a - b; }
@@ -435,7 +474,7 @@ class CsslLang:
             print(math.add(10, 5))  # 15
             print(math.sub(10, 5))  # 5
 
-            # From script objects (for .cssl-mod creation)
+        Usage (from script objects):
             main = cssl.script("cssl", "...")
             helpers = cssl.script("cssl-pl", "...")
             mod = cssl.makemodule(main, helpers, "mymodule")
@@ -541,6 +580,66 @@ class CsslLang:
         """
         ...
 
+    def getInstance(self, name: str) -> Optional[Any]:
+        """
+        Get a universal instance by name (for Python-side access).
+
+        Universal instances are shared containers accessible from CSSL, Python, and C++.
+        They support dynamic member/method access and are mutable across all contexts.
+
+        Args:
+            name: Name of the instance (without quotes)
+
+        Returns:
+            The UniversalInstance or None if not found
+
+        Usage:
+            # In CSSL: instance<"myContainer"> container;
+            # Then in Python:
+            container = cssl.getInstance("myContainer")
+            container.member = "value"
+            print(container.member)  # value
+        """
+        ...
+
+    def createInstance(self, name: str) -> Any:
+        """
+        Create or get a universal instance by name (for Python-side creation).
+
+        Args:
+            name: Name for the instance
+
+        Returns:
+            The UniversalInstance (new or existing)
+
+        Usage:
+            container = cssl.createInstance("myContainer")
+            container.data = {"key": "value"}
+            # Now accessible in CSSL via instance<"myContainer">
+        """
+        ...
+
+    def deleteInstance(self, name: str) -> bool:
+        """
+        Delete a universal instance by name.
+
+        Args:
+            name: Name of the instance to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        ...
+
+    def listInstances(self) -> List[str]:
+        """
+        List all universal instance names.
+
+        Returns:
+            List of instance names
+        """
+        ...
+
     def set_global(self, name: str, value: Any) -> None:
         """
         Set a global variable in the CSSL runtime.
@@ -733,20 +832,59 @@ def module(code: str) -> CSSLModule:
     ...
 
 
-def makemodule(code_or_script: Union[str, CSSLScript], *more: Any) -> CSSLFunctionModule:
+def makepayload(name: str, path: str) -> str:
+    """
+    Register a payload from a file path.
+
+    Reads the file and registers it as a payload accessible via payload(name) in CSSL.
+
+    Args:
+        name: Name to register the payload under (used in payload(name) and bind=name)
+        path: Path to the .cssl-pl or .cssl file
+
+    Returns:
+        The payload code that was registered
+
+    Usage:
+        from includecpp import CSSL
+
+        # Register a payload from file
+        CSSL.makepayload("api", "lib/api/myapi.cssl-pl")
+
+        # Use with makemodule for automatic binding
+        mod = CSSL.makemodule("writer", "lib/writer.cssl", bind="api")
+        mod.SaySomething("Hello!")
+    """
+    ...
+
+
+def makemodule(
+    main_script: Union[str, CSSLScript],
+    payload_script: Union[str, CSSLScript, None] = ...,
+    name: str = ...,
+    bind: str = ...
+) -> CSSLFunctionModule:
     """
     Create a CSSL module with accessible functions.
 
     Args:
-        code_or_script: CSSL code string or CSSLScript object
-        *more: Additional scripts or module name
+        main_script: CSSL code string, file path, or CSSLScript object
+        payload_script: Optional payload code (string or CSSLScript)
+        name: Optional name to register for payload(name) access
+        bind: Optional payload name to auto-prepend (from makepayload)
 
     Returns:
         CSSLFunctionModule with callable function attributes
 
-    Usage:
+    Usage (simplified):
         from includecpp import CSSL
 
+        # Register payload and create module
+        CSSL.makepayload("api", "lib/api/myapi.cssl-pl")
+        mod = CSSL.makemodule("writer", "lib/writer.cssl", bind="api")
+        mod.SaySomething("Hello!")
+
+    Usage (code string):
         math = CSSL.makemodule('''
             int add(int a, int b) { return a + b; }
         ''')

includecpp/vscode/cssl/package.json

@@ -2,7 +2,7 @@
     "name": "cssl",
     "displayName": "CSSL Language",
     "description": "Professional syntax highlighting, snippets, and language support for CSSL scripts (.cssl, .cssl-pl, .cssl-mod)",
-    "version": "1.6.0",
+    "version": "1.7.1",
     "publisher": "IncludeCPP",
     "icon": "images/cssl.png",
     "engines": {
@@ -151,6 +151,48 @@
                     "description": "Show output panel when running CSSL files"
                 }
             }
+        },
+        "configurationDefaults": {
+            "editor.tokenColorCustomizations": {
+                "textMateRules": [
+                    {
+                        "scope": "storage.modifier.cssl",
+                        "settings": {
+                            "fontStyle": "italic"
+                        }
+                    },
+                    {
+                        "scope": "storage.modifier.extends.cssl",
+                        "settings": {
+                            "fontStyle": "italic"
+                        }
+                    },
+                    {
+                        "scope": "storage.modifier.overwrites.cssl",
+                        "settings": {
+                            "fontStyle": "italic"
+                        }
+                    },
+                    {
+                        "scope": "support.type.cssl",
+                        "settings": {
+                            "foreground": "#C586C0"
+                        }
+                    },
+                    {
+                        "scope": "variable.other.declaration.cssl",
+                        "settings": {
+                            "foreground": "#9CDCFE"
+                        }
+                    },
+                    {
+                        "scope": "variable.parameter.cssl",
+                        "settings": {
+                            "foreground": "#9CDCFE"
+                        }
+                    }
+                ]
+            }
         }
     }
 }

includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json

@@ -15,6 +15,7 @@
         { "include": "#super-call" },
         { "include": "#sql-types" },
         { "include": "#keywords" },
+        { "include": "#typed-declarations" },
         { "include": "#types" },
         { "include": "#function-modifiers" },
         { "include": "#injection-operators" },
@@ -211,17 +212,21 @@
                         { "include": "#constructor-definition" },
                         { "include": "#class-method-definition" },
                         { "include": "#class-member-declaration" },
+                        { "include": "#typed-declarations" },
                         { "include": "#types" },
+                        { "include": "#function-modifiers" },
                         { "include": "#this-access" },
                         { "include": "#captured-references" },
                         { "include": "#global-references" },
                         { "include": "#shared-references" },
+                        { "include": "#instance-references" },
                         { "include": "#strings" },
                         { "include": "#numbers" },
                         { "include": "#keywords" },
                         { "include": "#function-calls" },
                         { "include": "#builtins" },
-                        { "include": "#operators" }
+                        { "include": "#operators" },
+                        { "include": "#constants" }
                     ]
                 },
                 {
@@ -241,17 +246,21 @@
                         { "include": "#constructor-definition" },
                         { "include": "#class-method-definition" },
                         { "include": "#class-member-declaration" },
+                        { "include": "#typed-declarations" },
                         { "include": "#types" },
+                        { "include": "#function-modifiers" },
                         { "include": "#this-access" },
                         { "include": "#captured-references" },
                         { "include": "#global-references" },
                         { "include": "#shared-references" },
+                        { "include": "#instance-references" },
                         { "include": "#strings" },
                         { "include": "#numbers" },
                         { "include": "#keywords" },
                         { "include": "#function-calls" },
                         { "include": "#builtins" },
-                        { "include": "#operators" }
+                        { "include": "#operators" },
+                        { "include": "#constants" }
                     ]
                 },
                 {
@@ -267,17 +276,21 @@
                         { "include": "#constructor-definition" },
                         { "include": "#class-method-definition" },
                         { "include": "#class-member-declaration" },
+                        { "include": "#typed-declarations" },
                         { "include": "#types" },
+                        { "include": "#function-modifiers" },
                         { "include": "#this-access" },
                         { "include": "#captured-references" },
                         { "include": "#global-references" },
                         { "include": "#shared-references" },
+                        { "include": "#instance-references" },
                         { "include": "#strings" },
                         { "include": "#numbers" },
                         { "include": "#keywords" },
                         { "include": "#function-calls" },
                         { "include": "#builtins" },
-                        { "include": "#operators" }
+                        { "include": "#operators" },
+                        { "include": "#constants" }
                     ]
                 }
             ]
@@ -354,11 +367,42 @@
         "class-member-declaration": {
             "patterns": [
                 {
+                    "comment": "Generic type member: datastruct<dynamic> Container;",
+                    "name": "meta.member.generic.cssl",
+                    "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type member: string ApiID;",
                     "name": "meta.member.cssl",
-                    "match": "\\b(int|string|float|bool|dynamic|auto)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
+                    "match": "\\b(int|string|float|bool|dynamic|auto|void|json|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
                     "captures": {
-                        "1": { "name": "storage.type.cssl" },
-                        "2": { "name": "variable.other.member.cssl" }
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Container type member without generic: list items;",
+                    "name": "meta.member.container.cssl",
+                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type member with assignment: string ApiID = value;",
+                    "name": "meta.member.assigned.cssl",
+                    "match": "\\b(int|string|float|bool|dynamic|auto|void|json|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*=",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
                     }
                 }
             ]
@@ -440,10 +484,65 @@
                 }
             ]
         },
+        "typed-declarations": {
+            "patterns": [
+                {
+                    "comment": "Generic type declaration: datastruct<dynamic> Container; or vector<int> items;",
+                    "name": "meta.declaration.typed.generic.cssl",
+                    "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type declaration: string ID; or int count;",
+                    "name": "meta.declaration.typed.primitive.cssl",
+                    "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[;=])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Container type declaration without generic: list items;",
+                    "name": "meta.declaration.typed.container.cssl",
+                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[;=])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Generic type in function parameter: func(datastruct<dynamic> param)",
+                    "name": "meta.parameter.typed.generic.cssl",
+                    "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[,)])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.parameter.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type in function parameter: func(string name)",
+                    "name": "meta.parameter.typed.primitive.cssl",
+                    "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[,)])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.parameter.cssl" }
+                    }
+                }
+            ]
+        },
         "types": {
             "patterns": [
                 {
-                    "name": "storage.type.primitive.cssl",
+                    "name": "support.type.cssl",
                     "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\b"
                 },
                 {
@@ -451,18 +550,18 @@
                     "name": "meta.generic.cssl",
                     "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)",
                     "captures": {
-                        "1": { "name": "storage.type.container.cssl" },
+                        "1": { "name": "support.type.cssl" },
                         "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
-                        "3": { "name": "storage.type.parameter.cssl" },
+                        "3": { "name": "support.type.cssl" },
                         "4": { "name": "punctuation.definition.typeparameters.end.cssl" }
                     }
                 },
                 {
-                    "name": "storage.type.container.cssl",
+                    "name": "support.type.cssl",
                     "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance|tuple|set|queue)\\b"
                 },
                 {
-                    "name": "storage.type.combo-open.cssl",
+                    "name": "support.type.cssl",
                     "match": "\\bcombo\\s*<\\s*open\\s*&"
                 }
             ]
@@ -471,7 +570,7 @@
             "patterns": [
                 {
                     "name": "storage.modifier.cssl",
-                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased|protected|limited)\\b"
+                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased|protected|limited|const|static|final|abstract|readonly)\\b"
                 }
             ]
         },
@@ -619,24 +718,48 @@
         "instance-references": {
             "patterns": [
                 {
-                    "comment": "instance<\"name\"> - shared instance reference with string",
+                    "comment": "instance<\"name\"> varName - shared instance declaration with variable",
+                    "name": "meta.instance.declaration.cssl",
+                    "match": "(\\binstance)(<)(\"[^\"]+\")(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "string.quoted.double.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "instance<Type> varName - shared instance declaration with type and variable",
+                    "name": "meta.instance.declaration.cssl",
+                    "match": "(\\binstance)(<)([a-zA-Z_][a-zA-Z0-9_]*)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "instance<\"name\"> - shared instance reference without variable",
                     "name": "meta.instance.cssl",
                     "match": "(\\binstance)(<)(\"[^\"]+\")(>)",
                     "captures": {
-                        "1": { "name": "storage.type.instance.cssl" },
+                        "1": { "name": "support.type.cssl" },
                         "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
                         "3": { "name": "string.quoted.double.cssl" },
                         "4": { "name": "punctuation.definition.typeparameters.end.cssl" }
                     }
                 },
                 {
-                    "comment": "instance<Type> - shared instance reference with type",
+                    "comment": "instance<Type> - shared instance reference without variable",
                     "name": "meta.instance.cssl",
                     "match": "(\\binstance)(<)([a-zA-Z_][a-zA-Z0-9_]*)(>)",
                     "captures": {
-                        "1": { "name": "storage.type.instance.cssl" },
+                        "1": { "name": "support.type.cssl" },
                         "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
-                        "3": { "name": "entity.name.type.cssl" },
+                        "3": { "name": "support.type.cssl" },
                         "4": { "name": "punctuation.definition.typeparameters.end.cssl" }
                     }
                 }

{includecpp-4.0.2.dist-info → includecpp-4.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 4.0.2
+Version: 4.0.3
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-4.0.2.dist-info → includecpp-4.0.3.dist-info}/RECORD

@@ -11,8 +11,8 @@ includecpp/core/build_manager.py,sha256=uLuYsuiC6OsOGaU5wAJfl4M3IbdnIDgogfMd8VsV
 includecpp/core/cpp_api.py,sha256=8y_B1L18rhSBZln654xPPzqO2PdvAlLpJrfEjzl7Wnc,14039
 includecpp/core/cpp_api.pyi,sha256=IEiaKqaPItnn6rjL7aK32D3o9FYmRYCgCZbqiQNUwdc,3496
 includecpp/core/cppy_converter.py,sha256=b7yqu-aoa0wShNY0GvQT67TnNhYya4GyYmG7oDdqDV4,156686
-includecpp/core/cssl_bridge.py,sha256=AyYD-vFkxRtWy1LZv6OP_XJtPRWIPTf2YVHOiajmSY8,43016
-includecpp/core/cssl_bridge.pyi,sha256=fukpnvyRQEl8bn7KsKXYYOLUNydPscWGgq5O6pr9KKQ,24358
+includecpp/core/cssl_bridge.py,sha256=xYfIRagegO8irdWl97dfanRB1qLU80p9lQ2wxkttGQ4,49963
+includecpp/core/cssl_bridge.pyi,sha256=nreh2gtK94I6VFrzTWcYVUHN97wcYQF0dY_-HySi7yQ,28787
 includecpp/core/error_catalog.py,sha256=VS3N-P0yEbiHimsDPtcaYfrUb7mXQ-7pqw18PtSngaU,33869
 includecpp/core/error_formatter.py,sha256=7-MzRIT8cM4uODxy0IZ9pu7pqR4Pq2I8Si0QQZHjmVc,39239
 includecpp/core/exceptions.py,sha256=szeF4qdzi_q8hBBZi7mJxkliyQ0crplkLYe0ymlBGtk,2459
@@ -27,9 +27,9 @@ includecpp/core/cssl/cssl_builtins.pyi,sha256=-yr9JbxHKFv9Vc1iufChcqCQvNQLL3-Ow_
 includecpp/core/cssl/cssl_events.py,sha256=nupIcXW_Vjdud7zCU6hdwkQRQ0MujlPM7Tk2u7eDAiY,21013
 includecpp/core/cssl/cssl_modules.py,sha256=cUg0-zdymMnWWTsA_BUrW5dx4R04dHpKcUhm-Wfiwwo,103006
 includecpp/core/cssl/cssl_parser.py,sha256=4GHFcGa6jv7sgQxP0wWqCci8eS4E8Ie2t-qfJ2Ux9BU,154072
-includecpp/core/cssl/cssl_runtime.py,sha256=eSmR1eq9by5VXjsYZp3x8ksJj4PaUR46iqsby2Y0bAI,209792
+includecpp/core/cssl/cssl_runtime.py,sha256=7R3lGdw-2G9_0H5jf3D8Cn_2inLHyw2771XFopMz51s,217360
 includecpp/core/cssl/cssl_syntax.py,sha256=bgo3NFehoPTQa5dqwNd_CstkVGVCNYAXbGYUcu5BEN0,16982
-includecpp/core/cssl/cssl_types.py,sha256=7jbrtZf3xmVQJA_mnL9iYrmdjhjuc4--mxxNigi7fsk,53425
+includecpp/core/cssl/cssl_types.py,sha256=e3yJfM7VqaeuU92jtmvpxfwURWXGmIJlEC41baZryvw,58452
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
 includecpp/generator/parser.cpp,sha256=hbhHdtFH65rzp6prnARN9pNFF_ssr0NseVVcxq0fJh4,76833
 includecpp/generator/parser.h,sha256=EDm0b-pEesIIIQQ2PvH5h2qwlqJU9BH8SiMV7MWbsTo,11073
@@ -40,14 +40,14 @@ includecpp/vscode/__init__.py,sha256=yLKw-_7MTX1Rx3jLk5JjharJQfFXbwtZVE7YqHpM7yg
 includecpp/vscode/cssl/__init__.py,sha256=rQJAx5X05v-mAwqX1Qb-rbZO219iR73MziFNRUCNUIo,31
 includecpp/vscode/cssl/extension.js,sha256=FZaKfOpzo2jXtubVCZmnhDZd4eUVHltm5VW_fgNnSkE,4327
 includecpp/vscode/cssl/language-configuration.json,sha256=61Q00cKI9may5L8YpxMmvfo6PAc-abdJqApfR85DWuw,904
-includecpp/vscode/cssl/package.json,sha256=5MCJts7zYIgF8EdWcBnn98deIMyZamlGXvt1acO0Q1U,4853
+includecpp/vscode/cssl/package.json,sha256=u5iHl79-GfeJiQ7vPe8DP5hXlOpGP41d1A54bn4Yy6M,6391
 includecpp/vscode/cssl/images/cssl.png,sha256=BxAGsnfS0ZzzCvqV6Zb1OAJAZpDUoXlR86MsvUGlSZw,510
 includecpp/vscode/cssl/images/cssl_pl.png,sha256=z4WMk7g6YCTbUUbSFk343BO6yi_OmNEVYkRenWGydwM,799
 includecpp/vscode/cssl/snippets/cssl.snippets.json,sha256=uV3nHJyQ5f7Pr3FzfbQT2VZOEY3AlGs4wrmqe884jm4,37372
-includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=FZw1_VDz1ll4ZBZeGqo-935CK5RuF2kD75rNp5tVdC0,35068
-includecpp-4.0.2.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-4.0.2.dist-info/METADATA,sha256=gVavbx1QXP6Z1UfYdGQT3fl5wSvqW89iSLyo6-fBiZA,22542
-includecpp-4.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-4.0.2.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-4.0.2.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-4.0.2.dist-info/RECORD,,
+includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=nYy7aRWREcgCu9Jbx5QmtQHfD4WRlk-HkPhqzKVtoIA,42806
+includecpp-4.0.3.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-4.0.3.dist-info/METADATA,sha256=HrQsoVYGdTmArZ8MsnftKkBoY7a25f9Zv3AiyFpuHn8,22542
+includecpp-4.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-4.0.3.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-4.0.3.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-4.0.3.dist-info/RECORD,,