IncludeCPP 3.7.19__tar.gz → 3.7.21__tar.gz

{includecpp-3.7.19 → includecpp-3.7.21}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.19
+Version: 3.7.21
 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.7.19 → includecpp-3.7.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.19
+Version: 3.7.21
 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.7.19 → includecpp-3.7.21}/includecpp/__init__.py

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

{includecpp-3.7.19 → includecpp-3.7.21}/includecpp/core/cssl/cssl_builtins.py

@@ -307,6 +307,10 @@ class CSSLBuiltins:
         self._functions['dataspace'] = self.builtin_dataspace
         self._functions['openquote'] = self.builtin_openquote
         self._functions['OpenFind'] = self.builtin_openfind
+        self._functions['vector'] = self.builtin_vector
+        self._functions['array'] = self.builtin_array
+        self._functions['stack'] = self.builtin_stack
+        self._functions['map'] = self.builtin_map
 
         # Print aliases for CSSL
         self._functions['printl'] = self.builtin_println  # CSSL uses printl for println
@@ -433,13 +437,50 @@ class CSSLBuiltins:
     # ============= Type Checking =============
 
     def builtin_typeof(self, value: Any) -> str:
-        """Get type name"""
+        """Get type name - returns CSSL-specific type names for CSSL types"""
         if value is None:
             return 'null'
+
+        # Check CSSL-specific types first
+        from .cssl_types import (Vector, Array, Stack, DataStruct,
+                                  List as CSSLList, Dictionary, Map,
+                                  Shuffled, Iterator, Combo, DataSpace,
+                                  OpenQuote, Parameter, CSSLInstance)
+
+        if isinstance(value, Vector):
+            return 'vector'
+        elif isinstance(value, Array):
+            return 'array'
+        elif isinstance(value, Stack):
+            return 'stack'
+        elif isinstance(value, DataStruct):
+            return 'datastruct'
+        elif isinstance(value, CSSLList):
+            return 'list'
+        elif isinstance(value, Dictionary):
+            return 'dictionary'
+        elif isinstance(value, Map):
+            return 'map'
+        elif isinstance(value, Shuffled):
+            return 'shuffled'
+        elif isinstance(value, Iterator):
+            return 'iterator'
+        elif isinstance(value, Combo):
+            return 'combo'
+        elif isinstance(value, DataSpace):
+            return 'dataspace'
+        elif isinstance(value, OpenQuote):
+            return 'openquote'
+        elif isinstance(value, Parameter):
+            return 'parameter'
+        elif isinstance(value, CSSLInstance):
+            return value._class.name
+
+        # Python types as fallback
         type_map = {
             int: 'int',
             float: 'float',
-            str: 'str',
+            str: 'string',
             bool: 'bool',
             list: 'list',
             dict: 'dict',
@@ -2322,6 +2363,38 @@ class CSSLBuiltins:
         from .cssl_types import OpenQuote
         return OpenQuote(db_ref)
 
+    def builtin_vector(self, element_type: str = 'dynamic') -> Any:
+        """Create a vector container.
+
+        Usage: vector<int> myVector; or vector('int')
+        """
+        from .cssl_types import Vector
+        return Vector(element_type)
+
+    def builtin_array(self, element_type: str = 'dynamic') -> Any:
+        """Create an array container.
+
+        Usage: array<string> myArray; or array('string')
+        """
+        from .cssl_types import Array
+        return Array(element_type)
+
+    def builtin_stack(self, element_type: str = 'dynamic') -> Any:
+        """Create a stack container.
+
+        Usage: stack<int> myStack; or stack('int')
+        """
+        from .cssl_types import Stack
+        return Stack(element_type)
+
+    def builtin_map(self, key_type: str = 'dynamic', value_type: str = 'dynamic') -> Any:
+        """Create a map container.
+
+        Usage: map<string, int> myMap; or map('string', 'int')
+        """
+        from .cssl_types import Map
+        return Map(key_type, value_type)
+
     def builtin_openfind(self, combo_or_type: Any, index: int = 0, params: list = None) -> Any:
         """Find open parameter by type or combo space.
 

{includecpp-3.7.19 → includecpp-3.7.21}/includecpp/core/cssl/cssl_parser.py

@@ -848,7 +848,7 @@ class CSSLParser:
             if self._match_keyword('open'):
                 param_info['open'] = True
 
-            # Handle type annotations
+            # Handle type annotations (builtin types like int, string, etc.)
             if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
                 param_info['type'] = self._advance().value
 
@@ -872,6 +872,39 @@ class CSSLParser:
                         self._advance()
                     param_info['generic'] = ''.join(generic_parts)
 
+            # Handle custom class types (identifier followed by another identifier = type + name)
+            elif self._check(TokenType.IDENTIFIER):
+                # Look ahead: if next token is also an identifier, current is the type
+                saved_pos = self.pos
+                potential_type = self._advance().value
+
+                # Check for generic type parameter <T> on custom type
+                if self._check(TokenType.COMPARE_LT):
+                    self._advance()
+                    generic_parts = []
+                    depth = 1
+                    while depth > 0 and not self._is_at_end():
+                        if self._check(TokenType.COMPARE_LT):
+                            depth += 1
+                            generic_parts.append('<')
+                        elif self._check(TokenType.COMPARE_GT):
+                            depth -= 1
+                            if depth > 0:
+                                generic_parts.append('>')
+                        elif self._check(TokenType.COMMA):
+                            generic_parts.append(',')
+                        else:
+                            generic_parts.append(self._current().value)
+                        self._advance()
+                    param_info['generic'] = ''.join(generic_parts)
+
+                # If followed by identifier, this is "Type name" pattern
+                if self._check(TokenType.IDENTIFIER):
+                    param_info['type'] = potential_type
+                else:
+                    # Not a type, restore position - this is just a param name
+                    self.pos = saved_pos
+
             # Handle reference operator &
             if self._match(TokenType.AMPERSAND):
                 param_info['ref'] = True
@@ -2118,6 +2151,11 @@ class CSSLParser:
             elif self._match(TokenType.COMPARE_GE):
                 right = self._parse_term()
                 left = ASTNode('binary', value={'op': '>=', 'left': left, 'right': right})
+            elif self._check(TokenType.KEYWORD) and self._peek().value == 'in':
+                # 'in' operator for containment: item in list
+                self._advance()  # consume 'in'
+                right = self._parse_term()
+                left = ASTNode('binary', value={'op': 'in', 'left': left, 'right': right})
             else:
                 break
 
@@ -2504,6 +2542,20 @@ class CSSLParser:
 
                 self._expect(TokenType.BLOCK_END)  # consume }
 
+            # Check for array-style initialization: vector<int>[1, 2, 3], array<string>["a", "b"]
+            elif self._check(TokenType.BRACKET_START):
+                self._advance()  # consume [
+                init_values = []
+
+                while not self._check(TokenType.BRACKET_END) and not self._is_at_end():
+                    init_values.append(self._parse_expression())
+
+                    # Optional comma
+                    if self._check(TokenType.COMMA):
+                        self._advance()
+
+                self._expect(TokenType.BRACKET_END)  # consume ]
+
             return ASTNode('type_instantiation', value={
                 'type': name,
                 'element_type': element_type,

{includecpp-3.7.19 → includecpp-3.7.21}/includecpp/core/cssl/cssl_runtime.py

@@ -830,8 +830,18 @@ class CSSLRuntime:
                 if hasattr(instance, 'append'):
                     instance.append(init_value)
 
+        # Check for global modifier
+        modifiers = decl.get('modifiers', [])
+        is_global = 'global' in modifiers
+
         # Store in scope
         self.scope.set(var_name, instance)
+
+        # If global, also store in promoted_globals and global_scope
+        if is_global:
+            self._promoted_globals[var_name] = instance
+            self.global_scope.set(var_name, instance)
+
         return instance
 
     def _exec_instance_declaration(self, node: ASTNode) -> Any:
@@ -978,6 +988,14 @@ class CSSLRuntime:
             result = self._evaluate(inner.value)
             return result
 
+        # Handle typed declaration: global datastruct<int> data;
+        elif inner.type == 'typed_declaration':
+            # Add global modifier to the declaration
+            if isinstance(inner.value, dict):
+                inner.value['modifiers'] = inner.value.get('modifiers', []) + ['global']
+            result = self._exec_typed_declaration(inner)
+            return result
+
         # Fallback: execute normally
         return self._execute_node(inner)
 
@@ -1756,9 +1774,14 @@ class CSSLRuntime:
         elif mode == 'move':
             # Move & remove from source
             final_value = source
-            # Clear the source
-            if isinstance(source_node, ASTNode) and source_node.type == 'identifier':
-                self.scope.set(source_node.value, None)
+            # Clear the source - handle all node types
+            if isinstance(source_node, ASTNode):
+                if source_node.type == 'identifier':
+                    self.scope.set(source_node.value, None)
+                elif source_node.type == 'module_ref':
+                    self._set_module_value(source_node.value, None)
+                elif source_node.type == 'member_access':
+                    self._set_member(source_node, None)
         else:
             final_value = source
 
@@ -1830,9 +1853,14 @@ class CSSLRuntime:
                 final_value = [current_value, source]
         elif mode == 'move':
             final_value = source
-            # Clear the source
-            if isinstance(source_node, ASTNode) and source_node.type == 'identifier':
-                self.scope.set(source_node.value, None)
+            # Clear the source - handle all node types
+            if isinstance(source_node, ASTNode):
+                if source_node.type == 'identifier':
+                    self.scope.set(source_node.value, None)
+                elif source_node.type == 'module_ref':
+                    self._set_module_value(source_node.value, None)
+                elif source_node.type == 'member_access':
+                    self._set_member(source_node, None)
         else:
             final_value = source
 
@@ -2047,6 +2075,10 @@ class CSSLRuntime:
         """Execute expression statement"""
         return self._evaluate(node.value)
 
+    def _exec_type_instantiation(self, node: ASTNode) -> Any:
+        """Execute type instantiation as statement (e.g., vector<int>)"""
+        return self._evaluate(node)
+
     def _exec_await(self, node: ASTNode) -> Any:
         """Execute await statement - waits for expression to complete"""
         # Evaluate the awaited expression
@@ -2128,12 +2160,13 @@ class CSSLRuntime:
             return value
 
         if node.type == 'module_ref':
-            # 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)
+            # User-defined globals have priority over SDK modules
+            # Check promoted globals first, then global scope, then SDK modules
+            value = self._promoted_globals.get(node.value)
             if value is None:
                 value = self.global_scope.get(node.value)
+            if value is None:
+                value = self.get_module(node.value)  # SDK modules as fallback
             return value
 
         if node.type == 'self_ref':
@@ -2217,12 +2250,28 @@ class CSSLRuntime:
             value_type = node.value.get('value_type')  # For map<K, V>
             init_values = node.value.get('init_values')  # For inline init: map<K,V>{...}
 
+            # Helper to populate container with init values
+            def _populate_container(container, init_vals):
+                if init_vals and isinstance(init_vals, list):
+                    for val_node in init_vals:
+                        val = self._evaluate(val_node) if isinstance(val_node, ASTNode) else val_node
+                        if hasattr(container, 'push'):
+                            container.push(val)
+                        elif hasattr(container, 'add'):
+                            container.add(val)
+                        elif hasattr(container, 'append'):
+                            container.append(val)
+                return container
+
             if type_name == 'stack':
-                return Stack(element_type)
+                s = Stack(element_type)
+                return _populate_container(s, init_values)
             elif type_name == 'vector':
-                return Vector(element_type)
+                v = Vector(element_type)
+                return _populate_container(v, init_values)
             elif type_name == 'datastruct':
-                return DataStruct(element_type)
+                d = DataStruct(element_type)
+                return _populate_container(d, init_values)
             elif type_name == 'shuffled':
                 return Shuffled(element_type)
             elif type_name == 'iterator':
@@ -2234,9 +2283,11 @@ class CSSLRuntime:
             elif type_name == 'openquote':
                 return OpenQuote()
             elif type_name == 'array':
-                return Array(element_type)
+                a = Array(element_type)
+                return _populate_container(a, init_values)
             elif type_name == 'list':
-                return List(element_type)
+                l = List(element_type)
+                return _populate_container(l, init_values)
             elif type_name in ('dictionary', 'dict'):
                 return Dictionary(element_type)
             elif type_name == 'map':
@@ -3023,12 +3074,20 @@ class CSSLRuntime:
                 pass
 
     def _set_module_value(self, path: str, value: Any):
-        """Set a value on a module path"""
+        """Set a value on a module path or promoted global"""
         parts = path.split('.')
         if len(parts) < 2:
+            # Single name (no dots) - set in promoted_globals and global_scope
+            self._promoted_globals[path] = value
+            self.global_scope.set(path, value)
             return
 
         obj = self._modules.get(parts[0])
+        # Also check promoted_globals for the base object
+        if obj is None:
+            obj = self._promoted_globals.get(parts[0])
+        if obj is None:
+            obj = self.global_scope.get(parts[0])
         if obj is None:
             return
 

{includecpp-3.7.19 → includecpp-3.7.21}/includecpp/core/cssl/cssl_types.py

@@ -64,6 +64,33 @@ class DataStruct(list):
             return target_type(self[0])
         return None
 
+    def length(self) -> int:
+        """Return datastruct length"""
+        return len(self)
+
+    def size(self) -> int:
+        """Return datastruct size (alias for length)"""
+        return len(self)
+
+    def push(self, item: Any) -> 'DataStruct':
+        """Push item to datastruct (alias for add)"""
+        self.append(item)
+        return self
+
+    def isEmpty(self) -> bool:
+        """Check if datastruct is empty"""
+        return len(self) == 0
+
+    def contains(self, item: Any) -> bool:
+        """Check if datastruct contains item"""
+        return item in self
+
+    def at(self, index: int) -> Any:
+        """Get item at index (safe access)"""
+        if 0 <= index < len(self):
+            return self[index]
+        return None
+
     def begin(self) -> int:
         """Return iterator to beginning (C++ style)"""
         return 0
@@ -99,6 +126,16 @@ class Stack(list):
         self.append(item)
         return self
 
+    def pop(self) -> Any:
+        """Pop and return top element from stack"""
+        if len(self) == 0:
+            return None
+        return super().pop()
+
+    def pop_back(self) -> Any:
+        """Pop and return top element (alias for pop)"""
+        return self.pop()
+
     def peek(self) -> Any:
         """View top item without removing"""
         return self[-1] if self else None
@@ -701,6 +738,39 @@ class List(list):
             self.extend([value] * count)
         return self
 
+    def map(self, func: Callable[[Any], Any]) -> 'List':
+        """Apply function to all elements"""
+        result = List(self._element_type)
+        result.extend(func(item) for item in self)
+        return result
+
+    def filter(self, predicate: Callable[[Any], bool]) -> 'List':
+        """Filter elements by predicate"""
+        result = List(self._element_type)
+        result.extend(item for item in self if predicate(item))
+        return result
+
+    def forEach(self, func: Callable[[Any], None]) -> 'List':
+        """Execute function for each element"""
+        for item in self:
+            func(item)
+        return self
+
+    def reduce(self, func: Callable[[Any, Any], Any], initial: Any = None) -> Any:
+        """Reduce list to single value"""
+        from functools import reduce as py_reduce
+        if initial is None:
+            return py_reduce(func, self)
+        return py_reduce(func, self, initial)
+
+    def every(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if all elements match predicate"""
+        return all(predicate(item) for item in self)
+
+    def some(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if any element matches predicate"""
+        return any(predicate(item) for item in self)
+
     def begin(self) -> int:
         """Return iterator to beginning"""
         return 0

{includecpp-3.7.19 → includecpp-3.7.21}/includecpp/core/cssl_bridge.py

@@ -422,12 +422,19 @@ class CsslLang:
         """
         runtime = self._get_runtime()
 
-        # Check if it's a file path
-        path = Path(path_or_code)
-        if path.exists() and path.suffix in ('.cssl', '.cssl-mod', '.cssl-pl'):
-            source = path.read_text(encoding='utf-8')
-        else:
-            source = path_or_code
+        # Check if it's a file path (not code)
+        # Code detection: contains newlines, semicolons, or braces = definitely code
+        is_likely_code = '\n' in path_or_code or ';' in path_or_code or '{' in path_or_code
+        source = path_or_code
+
+        if not is_likely_code:
+            try:
+                path = Path(path_or_code)
+                if path.exists() and path.suffix in ('.cssl', '.cssl-mod', '.cssl-pl'):
+                    source = path.read_text(encoding='utf-8')
+            except OSError:
+                # Path too long or invalid - treat as code
+                pass
 
         # Set arguments in runtime scope
         from .cssl import Parameter

{includecpp-3.7.19 → includecpp-3.7.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "IncludeCPP"
-version = "3.7.19"
+version = "3.7.21"
 description = "Professional C++ Python bindings with type-generic templates, pystubs and native threading"
 readme = "README.md"
 requires-python = ">=3.9"