IncludeCPP 3.4.8__py3-none-any.whl → 3.4.10__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__ = "3.4.8"
+__version__ = "3.4.10"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

includecpp/__init__.pyi

@@ -11,6 +11,9 @@ try:
 except ImportError:
     pass  # Generated during rebuild
 
+# CSSL module - CSO Service Script Language
+from .core import cssl_bridge as CSSL
+
 __version__: str
 
 # Dynamic module access via: from includecpp import <module_name>
@@ -121,4 +124,4 @@ class CppApi:
         """List all available modules."""
         ...
 
-__all__: List[str]
+__all__: List[str]  # Includes: CppApi, CSSL, __version__

includecpp/cli/commands.py

@@ -7455,9 +7455,8 @@ def cssl_exec(path, code):
     try:
         result = cssl_lang.exec(source)
 
-        # Print output buffer
-        for line in cssl_lang.get_output():
-            click.echo(line)
+        # Output is already printed to stdout during execution via runtime.output()
+        # No need to print buffer again - this was causing double output
 
         if result is not None:
             click.echo(f"Result: {result}")

includecpp/core/cssl/__init__.py

@@ -19,9 +19,10 @@ from .cssl_parser import (
 from .cssl_runtime import CSSLRuntime, CSSLRuntimeError, CSSLServiceRunner, run_cssl, run_cssl_file
 from .cssl_types import (
     DataStruct, Shuffled, Iterator, Combo, DataSpace, OpenQuote,
-    OpenFind, Parameter,
+    OpenFind, Parameter, Stack, Vector,
     create_datastruct, create_shuffled, create_iterator,
-    create_combo, create_dataspace, create_openquote, create_parameter
+    create_combo, create_dataspace, create_openquote, create_parameter,
+    create_stack, create_vector
 )
 
 __all__ = [
@@ -34,7 +35,8 @@ __all__ = [
     'run_cssl', 'run_cssl_file',
     # Data Types
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
-    'OpenFind', 'Parameter',
+    'OpenFind', 'Parameter', 'Stack', 'Vector',
     'create_datastruct', 'create_shuffled', 'create_iterator',
-    'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter'
+    'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter',
+    'create_stack', 'create_vector'
 ]

includecpp/core/cssl/cssl_parser.py

@@ -679,6 +679,44 @@ class CSSLParser:
         self.pos = saved_pos
         return False
 
+    def _looks_like_typed_variable(self) -> bool:
+        """Check if current position looks like a typed variable declaration.
+
+        Patterns:
+        - int x;
+        - stack<string> myStack;
+        - vector<int> nums = [1,2,3];
+
+        Distinguishes from function declarations by checking for '(' after identifier.
+        """
+        saved_pos = self.pos
+
+        # Check for type keyword
+        if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
+            self._advance()
+
+            # Skip generic type parameters <T>
+            if self._check(TokenType.COMPARE_LT):
+                depth = 1
+                self._advance()
+                while depth > 0 and not self._is_at_end():
+                    if self._check(TokenType.COMPARE_LT):
+                        depth += 1
+                    elif self._check(TokenType.COMPARE_GT):
+                        depth -= 1
+                    self._advance()
+
+            # Check for identifier NOT followed by ( (that would be a function)
+            if self._check(TokenType.IDENTIFIER):
+                self._advance()
+                # If followed by '(' it's a function, not a variable
+                is_var = not self._check(TokenType.PAREN_START)
+                self.pos = saved_pos
+                return is_var
+
+        self.pos = saved_pos
+        return False
+
     def _parse_typed_function(self) -> ASTNode:
         """Parse C-style typed function declaration.
 
@@ -800,6 +838,78 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         return node
 
+    def _looks_like_typed_variable(self) -> bool:
+        """Check if current position looks like a typed variable declaration:
+        type_name varName; or type_name<T> varName; or type_name varName = value;
+        """
+        # Save position
+        saved_pos = self.pos
+
+        # Must start with a type keyword (int, string, stack, vector, etc.)
+        if not self._check(TokenType.KEYWORD):
+            return False
+
+        type_name = self._current().value
+
+        # Skip known type keywords
+        type_keywords = {'int', 'string', 'float', 'bool', 'dynamic', 'void',
+                        'stack', 'vector', 'datastruct', 'dataspace', 'shuffled',
+                        'iterator', 'combo', 'array', 'openquote', 'json'}
+        if type_name not in type_keywords:
+            return False
+
+        self._advance()
+
+        # Check for optional generic <T>
+        if self._match(TokenType.COMPARE_LT):
+            # Skip until >
+            depth = 1
+            while depth > 0 and not self._is_at_end():
+                if self._check(TokenType.COMPARE_LT):
+                    depth += 1
+                elif self._check(TokenType.COMPARE_GT):
+                    depth -= 1
+                self._advance()
+
+        # Next should be an identifier (variable name), not '(' (function) or ';'
+        result = self._check(TokenType.IDENTIFIER)
+
+        # Restore position
+        self.pos = saved_pos
+        return result
+
+    def _parse_typed_variable(self) -> Optional[ASTNode]:
+        """Parse a typed variable declaration: type varName; or type<T> varName = value;"""
+        # Get type name
+        type_name = self._advance().value  # Consume type keyword
+
+        # Check for generic type <T>
+        element_type = None
+        if self._match(TokenType.COMPARE_LT):
+            # Get element type
+            if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
+                element_type = self._advance().value
+            self._expect(TokenType.COMPARE_GT)
+
+        # Get variable name
+        if not self._check(TokenType.IDENTIFIER):
+            return None
+        var_name = self._advance().value
+
+        # Check for assignment or just declaration
+        value = None
+        if self._match(TokenType.EQUALS):
+            value = self._parse_expression()
+
+        self._match(TokenType.SEMICOLON)
+
+        return ASTNode('typed_declaration', value={
+            'type': type_name,
+            'element_type': element_type,
+            'name': var_name,
+            'value': value
+        })
+
     def parse_program(self) -> ASTNode:
         """Parse a standalone program (no service wrapper)"""
         root = ASTNode('program', children=[])
@@ -812,6 +922,11 @@ class CSSLParser:
             # Check for C-style typed function declarations
             elif self._looks_like_function_declaration():
                 root.children.append(self._parse_typed_function())
+            # Check for typed variable declarations (int x;, stack<string> s;)
+            elif self._looks_like_typed_variable():
+                decl = self._parse_typed_variable()
+                if decl:
+                    root.children.append(decl)
             # Handle service blocks
             elif self._match_keyword('service-init'):
                 root.children.append(self._parse_service_init())
@@ -827,11 +942,15 @@ class CSSLParser:
             elif self._match_keyword('global'):
                 stmt = self._parse_expression_statement()
                 if stmt:
-                    root.children.append(stmt)
+                    # Wrap in global_assignment to mark as global variable
+                    global_stmt = ASTNode('global_assignment', value=stmt)
+                    root.children.append(global_stmt)
             elif self._check(TokenType.GLOBAL_REF):
                 stmt = self._parse_expression_statement()
                 if stmt:
-                    root.children.append(stmt)
+                    # Wrap in global_assignment to mark as global variable (same as 'global' keyword)
+                    global_stmt = ASTNode('global_assignment', value=stmt)
+                    root.children.append(global_stmt)
             # Handle statements
             elif self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or self._check(TokenType.SELF_REF):
                 stmt = self._parse_expression_statement()
@@ -1143,6 +1262,9 @@ class CSSLParser:
         elif self._match_keyword('define'):
             # Nested define function
             return self._parse_define()
+        elif self._looks_like_typed_variable():
+            # Typed variable declaration (e.g., stack<string> myStack;)
+            return self._parse_typed_variable()
         elif self._looks_like_function_declaration():
             # Nested typed function (e.g., void Level2() { ... })
             return self._parse_typed_function()
@@ -1640,6 +1762,31 @@ class CSSLParser:
                 node = ASTNode('call', value={'callee': node, 'args': args})
             return node
 
+        if self._check(TokenType.GLOBAL_REF):
+            # r@<name> global variable reference/declaration
+            token = self._advance()
+            node = ASTNode('global_ref', value=token.value, line=token.line, column=token.column)
+            # Check for member access, calls, indexing
+            while True:
+                if self._match(TokenType.PAREN_START):
+                    args = []
+                    while not self._check(TokenType.PAREN_END):
+                        args.append(self._parse_expression())
+                        if not self._check(TokenType.PAREN_END):
+                            self._expect(TokenType.COMMA)
+                    self._expect(TokenType.PAREN_END)
+                    node = ASTNode('call', value={'callee': node, 'args': args})
+                elif self._match(TokenType.DOT):
+                    member = self._advance().value
+                    node = ASTNode('member_access', value={'object': node, 'member': member})
+                elif self._match(TokenType.BRACKET_START):
+                    index = self._parse_expression()
+                    self._expect(TokenType.BRACKET_END)
+                    node = ASTNode('index_access', value={'object': node, 'index': index})
+                else:
+                    break
+            return node
+
         if self._check(TokenType.NUMBER):
             return ASTNode('literal', value=self._advance().value)
 

includecpp/core/cssl/cssl_runtime.py

@@ -12,7 +12,10 @@ from .cssl_parser import ASTNode, parse_cssl, parse_cssl_program, CSSLSyntaxErro
 from .cssl_events import CSSLEventManager, EventType, EventData, get_event_manager
 from .cssl_builtins import CSSLBuiltins
 from .cssl_modules import get_module_registry, get_standard_module
-from .cssl_types import Parameter, DataStruct, Shuffled, Iterator, Combo
+from .cssl_types import (
+    Parameter, DataStruct, Shuffled, Iterator, Combo,
+    Stack, Vector, DataSpace, OpenQuote
+)
 
 
 class CSSLRuntimeError(Exception):
@@ -291,6 +294,12 @@ class CSSLRuntime:
                 self._exec_struct(child)
             elif child.type == 'function':
                 self._exec_function(child)
+            elif child.type == 'global_assignment':
+                # Handle global variable declaration: global Name = value
+                result = self._exec_global_assignment(child)
+            elif child.type == 'typed_declaration':
+                # Handle typed variable declaration: type<T> varName = value;
+                result = self._exec_typed_declaration(child)
             elif child.type in ('assignment', 'expression', 'inject', 'receive', 'flow',
                                'if', 'while', 'for', 'foreach', 'switch', 'try'):
                 result = self._execute_node(child)
@@ -564,6 +573,103 @@ class CSSLRuntime:
         self.scope.set(func_name, node)
         return None
 
+    def _exec_typed_declaration(self, node: ASTNode) -> Any:
+        """Execute typed variable declaration: type<T> varName = value;
+
+        Creates appropriate type instances for stack, vector, datastruct, etc.
+        """
+        decl = node.value
+        type_name = decl.get('type')
+        element_type = decl.get('element_type', 'dynamic')
+        var_name = decl.get('name')
+        value_node = decl.get('value')
+
+        # Create the appropriate type instance
+        if type_name == 'stack':
+            instance = Stack(element_type)
+        elif type_name == 'vector':
+            instance = Vector(element_type)
+        elif type_name == 'datastruct':
+            instance = DataStruct(element_type)
+        elif type_name == 'shuffled':
+            instance = Shuffled(element_type)
+        elif type_name == 'iterator':
+            instance = Iterator(element_type)
+        elif type_name == 'combo':
+            instance = Combo(element_type)
+        elif type_name == 'dataspace':
+            instance = DataSpace(element_type)
+        elif type_name == 'openquote':
+            instance = OpenQuote()
+        elif type_name in ('int', 'integer'):
+            instance = 0 if value_node is None else self._evaluate(value_node)
+        elif type_name in ('string', 'str'):
+            instance = "" if value_node is None else self._evaluate(value_node)
+        elif type_name in ('float', 'double'):
+            instance = 0.0 if value_node is None else self._evaluate(value_node)
+        elif type_name == 'bool':
+            instance = False if value_node is None else self._evaluate(value_node)
+        elif type_name == 'dynamic':
+            instance = None if value_node is None else self._evaluate(value_node)
+        elif type_name == 'json':
+            instance = {} if value_node is None else self._evaluate(value_node)
+        elif type_name == 'array':
+            instance = [] if value_node is None else self._evaluate(value_node)
+        else:
+            # Default: evaluate the value or set to None
+            instance = self._evaluate(value_node) if value_node else None
+
+        # If there's an explicit value, use it instead
+        if value_node and type_name not in ('int', 'integer', 'string', 'str', 'float', 'double', 'bool', 'dynamic', 'json', 'array'):
+            # For container types, the value might be initialization data
+            init_value = self._evaluate(value_node)
+            if isinstance(init_value, (list, tuple)):
+                instance.extend(init_value)
+            elif init_value is not None:
+                if hasattr(instance, 'append'):
+                    instance.append(init_value)
+
+        # Store in scope
+        self.scope.set(var_name, instance)
+        return instance
+
+    def _exec_global_assignment(self, node: ASTNode) -> Any:
+        """Execute global variable assignment: global Name = value
+
+        Stores the value in _promoted_globals so it can be accessed via @Name
+        """
+        inner = node.value  # The wrapped assignment/expression node
+
+        if inner is None:
+            return None
+
+        # Handle assignment node: global Name = value
+        if inner.type == 'assignment':
+            target = inner.value.get('target')
+            value = self._evaluate(inner.value.get('value'))
+
+            # Get variable name from target
+            if isinstance(target, ASTNode) and target.type == 'identifier':
+                var_name = target.value
+            elif isinstance(target, str):
+                var_name = target
+            else:
+                var_name = str(target)
+
+            # Store in promoted globals for @Name access
+            self._promoted_globals[var_name] = value
+            # Also store in global scope for regular access
+            self.global_scope.set(var_name, value)
+            return value
+
+        # Handle expression that results in assignment
+        elif inner.type == 'expression':
+            result = self._evaluate(inner.value)
+            return result
+
+        # Fallback: execute normally
+        return self._execute_node(inner)
+
     def _call_function(self, func_node: ASTNode, args: List[Any]) -> Any:
         """Call a function node with arguments"""
         func_info = func_node.value
@@ -1094,6 +1200,10 @@ class CSSLRuntime:
         if isinstance(target, ASTNode):
             if target.type == 'identifier':
                 self.scope.set(target.value, value)
+            elif target.type == 'global_ref':
+                # r@Name = value - store in promoted globals
+                self._promoted_globals[target.value] = value
+                self.global_scope.set(target.value, value)
             elif target.type == 'member_access':
                 self._set_member(target, value)
             elif target.type == 'index_access':
@@ -1177,12 +1287,26 @@ class CSSLRuntime:
             return value
 
         if node.type == 'module_ref':
-            return self.get_module(node.value)
+            # Check modules first, then promoted globals, then scope
+            value = self.get_module(node.value)
+            if value is None:
+                value = self._promoted_globals.get(node.value)
+            if value is None:
+                value = self.global_scope.get(node.value)
+            return value
 
         if node.type == 'self_ref':
             # s@<name> reference to global struct
             return self.get_global_struct(node.value)
 
+        if node.type == 'global_ref':
+            # r@<name> global variable reference
+            # Check promoted globals first, then global scope
+            value = self._promoted_globals.get(node.value)
+            if value is None:
+                value = self.global_scope.get(node.value)
+            return value
+
         if node.type == 'binary':
             return self._eval_binary(node)
 
@@ -1290,6 +1414,11 @@ class CSSLRuntime:
         if obj is None:
             return None
 
+        # Special handling for Parameter.return() -> Parameter.return_()
+        # since 'return' is a Python keyword
+        if isinstance(obj, Parameter) and member == 'return':
+            member = 'return_'
+
         if hasattr(obj, member):
             return getattr(obj, member)
 

includecpp/core/cssl/cssl_types.py

@@ -65,6 +65,90 @@ class DataStruct(list):
         return None
 
 
+class Stack(list):
+    """Stack data structure (LIFO).
+
+    Standard stack with push/pop operations.
+
+    Usage:
+        stack<string> myStack;
+        myStack.push("Item1");
+        myStack.push("Item2");
+        item = myStack.pop();  # Returns "Item2"
+    """
+
+    def __init__(self, element_type: str = 'dynamic'):
+        super().__init__()
+        self._element_type = element_type
+
+    def push(self, item: Any) -> 'Stack':
+        """Push item onto stack"""
+        self.append(item)
+        return self
+
+    def peek(self) -> Any:
+        """View top item without removing"""
+        return self[-1] if self else None
+
+    def is_empty(self) -> bool:
+        """Check if stack is empty"""
+        return len(self) == 0
+
+    def size(self) -> int:
+        """Return stack size"""
+        return len(self)
+
+
+class Vector(list):
+    """Dynamic array (vector) data structure.
+
+    Resizable array with efficient random access.
+
+    Usage:
+        vector<int> myVector;
+        myVector.push(1);
+        myVector.push(2);
+        myVector.at(0);  # Returns 1
+    """
+
+    def __init__(self, element_type: str = 'dynamic'):
+        super().__init__()
+        self._element_type = element_type
+
+    def push(self, item: Any) -> 'Vector':
+        """Add item to end"""
+        self.append(item)
+        return self
+
+    def at(self, index: int) -> Any:
+        """Get item at index"""
+        if 0 <= index < len(self):
+            return self[index]
+        return None
+
+    def set(self, index: int, value: Any) -> 'Vector':
+        """Set item at index"""
+        if 0 <= index < len(self):
+            self[index] = value
+        return self
+
+    def size(self) -> int:
+        """Return vector size"""
+        return len(self)
+
+    def empty(self) -> bool:
+        """Check if vector is empty"""
+        return len(self) == 0
+
+    def front(self) -> Any:
+        """Get first element"""
+        return self[0] if self else None
+
+    def back(self) -> Any:
+        """Get last element"""
+        return self[-1] if self else None
+
+
 class Shuffled(list):
     """Unorganized fast storage for multiple returns.
 
@@ -356,10 +440,13 @@ class Parameter:
         parameter.get(1)  # Get second argument
         parameter.count() # Get total argument count
         parameter.all()   # Get all arguments as list
+        parameter.return(value)  # Yield a return value (generator-like)
+        parameter.returns()  # Get all yielded return values
     """
 
     def __init__(self, args: List[Any] = None):
         self._args = args if args is not None else []
+        self._returns: List[Any] = []
 
     def get(self, index: int, default: Any = None) -> Any:
         """Get argument at index, returns default if not found"""
@@ -379,6 +466,27 @@ class Parameter:
         """Check if argument exists at index"""
         return 0 <= index < len(self._args)
 
+    # Using 'return_' to avoid Python keyword conflict
+    def return_(self, value: Any) -> None:
+        """Yield a return value (generator-like behavior).
+
+        Multiple calls accumulate values that can be retrieved via returns().
+        The CSSL runtime will collect these as the exec() return value.
+        """
+        self._returns.append(value)
+
+    def returns(self) -> List[Any]:
+        """Get all yielded return values"""
+        return list(self._returns)
+
+    def clear_returns(self) -> None:
+        """Clear all yielded return values"""
+        self._returns.clear()
+
+    def has_returns(self) -> bool:
+        """Check if any values have been returned"""
+        return len(self._returns) > 0
+
     def __iter__(self):
         return iter(self._args)
 
@@ -424,15 +532,21 @@ def create_dataspace(space_type: str = 'dynamic') -> DataSpace:
 def create_openquote(db_ref: Any = None) -> OpenQuote:
     return OpenQuote(db_ref)
 
+def create_stack(element_type: str = 'dynamic') -> Stack:
+    return Stack(element_type)
 
-__all__ = [
-    'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
-    'OpenFind', 'Parameter',
-    'create_datastruct', 'create_shuffled', 'create_iterator',
-    'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter'
-]
-
+def create_vector(element_type: str = 'dynamic') -> Vector:
+    return Vector(element_type)
 
 def create_parameter(args: List[Any] = None) -> Parameter:
     """Create a Parameter object for accessing exec arguments"""
     return Parameter(args)
+
+
+__all__ = [
+    'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
+    'OpenFind', 'Parameter', 'Stack', 'Vector',
+    'create_datastruct', 'create_shuffled', 'create_iterator',
+    'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter',
+    'create_stack', 'create_vector'
+]

includecpp/core/cssl_bridge.py

@@ -144,7 +144,8 @@ class CsslLang:
             *args: Arguments to pass to the script
 
         Returns:
-            Execution result
+            Execution result. If parameter.return() was called, returns
+            the list of returned values (or single value if only one).
         """
         runtime = self._get_runtime()
 
@@ -157,13 +158,21 @@ class CsslLang:
 
         # Set arguments in runtime scope
         from .cssl import Parameter
+        param = Parameter(list(args))
         runtime.global_scope.set('args', list(args))
         runtime.global_scope.set('argc', len(args))
-        runtime.global_scope.set('parameter', Parameter(list(args)))
+        runtime.global_scope.set('parameter', param)
 
         # Execute as standalone program
         try:
             result = runtime.execute_program(source)
+
+            # Check if parameter.return() was used (generator-like returns)
+            if param.has_returns():
+                returns = param.returns()
+                # Return single value if only one, else return list
+                return returns[0] if len(returns) == 1 else returns
+
             return result
         except Exception as e:
             raise RuntimeError(f"CSSL Error: {e}") from e

{includecpp-3.4.8.dist-info → includecpp-3.4.10.dist-info}/METADATA

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

{includecpp-3.4.8.dist-info → includecpp-3.4.10.dist-info}/RECORD

@@ -1,9 +1,9 @@
-includecpp/__init__.py,sha256=JTm6AEIeXuM8WBahVIQD_rsuZg0rVRpdDumCb5xmRkk,1672
-includecpp/__init__.pyi,sha256=gNfQTFiM0z-Z2xazX7Hk5ULtW44lEU2j6hGEipcipMY,3637
+includecpp/__init__.py,sha256=ADg4AjowwcXWGRAZLfuz0f494MvuL2vD7Ry4-LtbIBg,1673
+includecpp/__init__.pyi,sha256=SBHwNvqWSUj0c_oS0uVGoOv25uYUOYtORFMxKiN0pkY,3762
 includecpp/__main__.py,sha256=d6QK0PkvUe1ENofpmHRAg3bwNbZr8PiRscfI3-WRfVg,72
 includecpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 includecpp/cli/__init__.py,sha256=Yda-4a5QJb_tKu35YQNfc5lu-LewTsM5abqNNkzS47M,113
-includecpp/cli/commands.py,sha256=90-L9iy4qIvyZR5KlMPSI5YNN7cb_1e6D5p-MTPkYJo,316845
+includecpp/cli/commands.py,sha256=7ozSW7IyUaCoSY1tC0-ieV1TYNP37g7kSoG16XmOkZY,316898
 includecpp/cli/config_parser.py,sha256=KveeYUg2TA9sC5hKVzYYfgdNm2WfLG5y7_yxgBWn9yM,4886
 includecpp/core/__init__.py,sha256=L1bT6oikTjdto-6Px7DpjePtM07ymo3Bnov1saZzsGg,390
 includecpp/core/ai_integration.py,sha256=PW6yFDqdXjfchpfKTKg59AOLhLry9kqJEGf_65BztrY,87603
@@ -11,7 +11,7 @@ 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=PRpXXGj4LfAbeNcFeL5XeCU6wiyavRaxBs5RfR8dYnU,12198
+includecpp/core/cssl_bridge.py,sha256=HpnMbX4lnGCuQq8ZjnvLSfqd-wrobMF5szhQM4T2RGI,12635
 includecpp/core/cssl_bridge.pyi,sha256=Q4zjc2Kf2wPJPnfgHS-koPEon3Kty6o3mCvp9E5Q8tE,7635
 includecpp/core/error_catalog.py,sha256=VS3N-P0yEbiHimsDPtcaYfrUb7mXQ-7pqw18PtSngaU,33869
 includecpp/core/error_formatter.py,sha256=7-MzRIT8cM4uODxy0IZ9pu7pqR4Pq2I8Si0QQZHjmVc,39239
@@ -19,23 +19,23 @@ includecpp/core/exceptions.py,sha256=szeF4qdzi_q8hBBZi7mJxkliyQ0crplkLYe0ymlBGtk
 includecpp/core/path_discovery.py,sha256=jI0oSq6Hsd4LKXmU4dOiGSrXcEO_KWMXfQ5_ylBmXvU,2561
 includecpp/core/project_ui.py,sha256=la2EQZKmUkJGuJxnbs09hH1ZhBh9bfndo6okzZsk2dQ,141134
 includecpp/core/settings_ui.py,sha256=B2SlwgdplF2KiBk5UYf2l8Jjifjd0F-FmBP0DPsVCEQ,11798
-includecpp/core/cssl/__init__.py,sha256=YrlKTifbmdjofU7yGsRPSXw3rwFvTDb2Ic1kq6C3cD0,1613
+includecpp/core/cssl/__init__.py,sha256=Z63V6GjWMyd61WpdoAd-hA_ZB3kgIw2RvA-RR35WBEc,1719
 includecpp/core/cssl/cssl_builtins.py,sha256=PDz4FoWqNdGjBTBLKJ2fc8SqFKpprSey_9gZxV19tIE,61896
 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=T7CfbhdqmxtQEw0BjPZ5kUUsWFBcEsSHGppxl8K_Fj4,73112
-includecpp/core/cssl/cssl_runtime.py,sha256=VjncRlNDuZWrEKdqpKB7RyLEBucJAzIOb71EUI-6jRM,60945
+includecpp/core/cssl/cssl_parser.py,sha256=B52QW-Cc9GBmoJGlqNlmEBq1-3cHcztVbUWNR4KuTH4,79259
+includecpp/core/cssl/cssl_runtime.py,sha256=zvhWTGIkjTxKuQBjouGO6T7miyfSL1vGCXa3RQ7v60c,66626
 includecpp/core/cssl/cssl_syntax.py,sha256=vgI-dgj6gs9cOHwNRff6JbwZZYW_fYutnwCkznlgZiE,17006
-includecpp/core/cssl/cssl_types.py,sha256=G27Gk_xLHvIaAez8P-D8-cEGvGkKf5_acDdQmV3FWs8,14490
+includecpp/core/cssl/cssl_types.py,sha256=-4kevtcUSqjCX9v6TzA_eHW3ZqaeKjEAIc92dGIAodc,17765
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
 includecpp/generator/parser.cpp,sha256=CxVpsBDb22yDaVqp0ljh7dFKBTGlUj65apUGtPRMu0s,76829
 includecpp/generator/parser.h,sha256=EDm0b-pEesIIIQQ2PvH5h2qwlqJU9BH8SiMV7MWbsTo,11073
 includecpp/generator/type_resolver.cpp,sha256=MmFK_4HXd1wqxALDiDyXVuU397SXoQL_o5zb_8N8Hzs,12346
 includecpp/generator/type_resolver.h,sha256=ZsaxQqcCcKJJApYn7KOp2dLlQ1VFVG_oZDjaK5LhBSg,2590
 includecpp/templates/cpp.proj.template,sha256=Iy-L8I4Cl3tIgBMx1Qp5h6gURvkqOAqyodVHuDJ0Luw,359
-includecpp-3.4.8.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-3.4.8.dist-info/METADATA,sha256=906TSNdXml6v_XL747RrNER-_Ibf-QzS9RDbnr3NbfQ,26654
-includecpp-3.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-3.4.8.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-3.4.8.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-3.4.8.dist-info/RECORD,,
+includecpp-3.4.10.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-3.4.10.dist-info/METADATA,sha256=Pu0j0edS2IRiuGTQA6nIAhYDgBsbq3oddp6TMnDdn1E,26655
+includecpp-3.4.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-3.4.10.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-3.4.10.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-3.4.10.dist-info/RECORD,,