IncludeCPP 3.4.2__py3-none-any.whl → 3.4.10__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -12,6 +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,
+    Stack, Vector, DataSpace, OpenQuote
+)
 
 
 class CSSLRuntimeError(Exception):
@@ -290,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)
@@ -563,20 +573,123 @@ 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
         params = func_info.get('params', [])
+        modifiers = func_info.get('modifiers', [])
+
+        # Check for undefined modifier - suppress errors if present
+        is_undefined = 'undefined' in modifiers
 
         # Create new scope
         new_scope = Scope(parent=self.scope)
 
-        # Bind parameters
+        # Bind parameters - handle both string and dict formats
         for i, param in enumerate(params):
+            # Extract param name from dict format: {'name': 'a', 'type': 'int'}
+            param_name = param['name'] if isinstance(param, dict) else param
             if i < len(args):
-                new_scope.set(param, args[i])
+                new_scope.set(param_name, args[i])
             else:
-                new_scope.set(param, None)
+                new_scope.set(param_name, None)
 
         # Execute body
         old_scope = self.scope
@@ -587,6 +700,11 @@ class CSSLRuntime:
                 self._execute_node(child)
         except CSSLReturn as ret:
             return ret.value
+        except Exception as e:
+            # If undefined modifier, suppress all errors
+            if is_undefined:
+                return None
+            raise
         finally:
             self.scope = old_scope
 
@@ -881,7 +999,11 @@ class CSSLRuntime:
         # Get current target value for add/move modes
         current_value = None
         if mode in ('add', 'move'):
-            current_value = self._evaluate(target)
+            try:
+                current_value = self._evaluate(target)
+            except Exception:
+                # Target might not exist yet, that's okay for add mode
+                current_value = None
 
         # Determine final value based on mode
         if mode == 'replace':
@@ -1078,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':
@@ -1161,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)
 
@@ -1188,6 +1328,17 @@ class CSSLRuntime:
         if node.type == 'object':
             return {k: self._evaluate(v) for k, v in node.value.items()}
 
+        if node.type == 'reference':
+            # &variable - return a reference object wrapping the actual value
+            inner = node.value
+            if isinstance(inner, ASTNode):
+                if inner.type == 'identifier':
+                    # Return a reference wrapper with the variable name
+                    return {'__ref__': True, 'name': inner.value, 'value': self.scope.get(inner.value)}
+                elif inner.type == 'module_ref':
+                    return {'__ref__': True, 'name': inner.value, 'value': self.get_module(inner.value)}
+            return {'__ref__': True, 'value': self._evaluate(inner)}
+
         return None
 
     def _eval_binary(self, node: ASTNode) -> Any:
@@ -1263,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)
 
@@ -1388,15 +1544,26 @@ class CSSLRuntime:
 
     # NEW: Execute injected code for a function
     def _execute_function_injections(self, func_name: str):
-        """Execute all injected code blocks for a function - NEW"""
+        """Execute all injected code blocks for a function - NEW
+
+        Includes protection against recursive execution to prevent doubled output.
+        """
+        # Prevent recursive injection execution (fixes doubled output bug)
+        if getattr(self, '_injection_executing', False):
+            return
+
         if func_name in self._function_injections:
-            for code_block in self._function_injections[func_name]:
-                if isinstance(code_block, ASTNode):
-                    if code_block.type == 'action_block':
-                        for child in code_block.children:
-                            self._execute_node(child)
-                    else:
-                        self._execute_node(code_block)
+            self._injection_executing = True
+            try:
+                for code_block in self._function_injections[func_name]:
+                    if isinstance(code_block, ASTNode):
+                        if code_block.type == 'action_block':
+                            for child in code_block.children:
+                                self._execute_node(child)
+                        else:
+                            self._execute_node(code_block)
+            finally:
+                self._injection_executing = False
 
     # Output functions for builtins
     def set_output_callback(self, callback: Callable[[str, str], None]):

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.
 
@@ -346,6 +430,73 @@ class OpenQuote:
         return self._data
 
 
+class Parameter:
+    """Parameter accessor for CSSL exec() arguments.
+
+    Provides access to arguments passed to CSSL.exec() via parameter.get(index).
+
+    Usage in CSSL:
+        parameter.get(0)  # Get first argument
+        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"""
+        if 0 <= index < len(self._args):
+            return self._args[index]
+        return default
+
+    def count(self) -> int:
+        """Return total number of arguments"""
+        return len(self._args)
+
+    def all(self) -> List[Any]:
+        """Return all arguments as a list"""
+        return list(self._args)
+
+    def has(self, index: int) -> bool:
+        """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)
+
+    def __len__(self):
+        return len(self._args)
+
+    def __getitem__(self, index: int) -> Any:
+        return self.get(index)
+
+
 def OpenFind(combo_or_type: Union[Combo, type], index: int = 0) -> Optional[Any]:
     """Find open parameter by type or combo space.
 
@@ -381,10 +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)
+
+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',
+    'OpenFind', 'Parameter', 'Stack', 'Vector',
     'create_datastruct', 'create_shuffled', 'create_iterator',
-    'create_combo', 'create_dataspace', 'create_openquote'
+    'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter',
+    'create_stack', 'create_vector'
 ]