IncludeCPP 3.7.1__py3-none-any.whl → 3.7.9__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -401,6 +401,9 @@ class CSSLRuntime:
             elif child.type == 'instance_declaration':
                 # Handle instance declaration: instance<"name"> varName;
                 result = self._exec_instance_declaration(child)
+            elif child.type == 'super_func':
+                # Super-function for .cssl-pl payload files (#$run, #$exec, #$printl)
+                result = self._exec_super_func(child)
             elif child.type in ('assignment', 'expression', 'inject', 'receive', 'flow',
                                'if', 'while', 'for', 'c_for', 'foreach', 'switch', 'try'):
                 result = self._execute_node(child)
@@ -820,6 +823,82 @@ class CSSLRuntime:
         self.scope.set(var_name, instance)
         return instance
 
+    def _exec_super_func(self, node: ASTNode) -> Any:
+        """Execute super-function for .cssl-pl payload files.
+
+        Super-functions are pre-execution hooks that run when payload() loads a file.
+
+        Supported super-functions:
+            #$run(funcName)        - Call a function defined in the payload
+            #$exec(expression)     - Execute an expression immediately
+            #$printl(message)      - Print a message during load
+
+        Example .cssl-pl file:
+            void initDatabase() {
+                printl("DB initialized");
+            }
+
+            #$run(initDatabase);       // Calls initDatabase when payload loads
+            #$printl("Payload loaded"); // Prints during load
+        """
+        super_info = node.value
+        super_name = super_info.get('name', '')  # e.g., "#$run", "#$exec", "#$printl"
+        args = super_info.get('args', [])
+
+        # Extract the function name part (after #$)
+        if super_name.startswith('#$'):
+            func_type = super_name[2:]  # "run", "exec", "printl"
+        else:
+            func_type = super_name
+
+        if func_type == 'run':
+            # #$run(funcName) - Call a function by name
+            if args:
+                func_ref = args[0]
+                if isinstance(func_ref, ASTNode):
+                    if func_ref.type == 'identifier':
+                        func_name = func_ref.value
+                    elif func_ref.type == 'call':
+                        # Direct call like #$run(setup())
+                        return self._eval_call(func_ref)
+                    else:
+                        func_name = self._evaluate(func_ref)
+                else:
+                    func_name = str(func_ref)
+
+                # Look up and call the function
+                func_node = self.scope.get(func_name)
+                if func_node and isinstance(func_node, ASTNode) and func_node.type == 'function':
+                    return self._call_function(func_node, [])
+                else:
+                    raise CSSLRuntimeError(f"#$run: Function '{func_name}' not found", node.line)
+
+        elif func_type == 'exec':
+            # #$exec(expression) - Execute an expression
+            if args:
+                return self._evaluate(args[0])
+
+        elif func_type == 'printl':
+            # #$printl(message) - Print a message
+            if args:
+                msg = self._evaluate(args[0])
+                print(str(msg))
+                self.output_buffer.append(str(msg))
+                return None
+
+        elif func_type == 'print':
+            # #$print(message) - Print without newline
+            if args:
+                msg = self._evaluate(args[0])
+                print(str(msg), end='')
+                self.output_buffer.append(str(msg))
+                return None
+
+        else:
+            raise CSSLRuntimeError(f"Unknown super-function: {super_name}", node.line)
+
+        return None
+
     def _exec_global_assignment(self, node: ASTNode) -> Any:
         """Execute global variable assignment: global Name = value
 
@@ -884,10 +963,20 @@ class CSSLRuntime:
 
         # Bind parameters - handle both positional and named arguments
         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 param_name in kwargs:
+            # Extract param name and type from dict format: {'name': 'a', 'type': 'int'}
+            if isinstance(param, dict):
+                param_name = param['name']
+                param_type = param.get('type', '')
+            else:
+                param_name = param
+                param_type = ''
+
+            # Check if this is an 'open' parameter - receives all args as a list
+            if param_type == 'open' or param_name == 'Params':
+                # 'open Params' receives all arguments as a list
+                new_scope.set(param_name, list(args))
+                new_scope.set('Params', list(args))  # Also set 'Params' for OpenFind
+            elif param_name in kwargs:
                 # Named argument takes priority
                 new_scope.set(param_name, kwargs[param_name])
             elif i < len(args):
@@ -1097,8 +1186,20 @@ class CSSLRuntime:
         return None
 
     def _exec_return(self, node: ASTNode) -> Any:
-        """Execute return statement"""
-        value = self._evaluate(node.value) if node.value else None
+        """Execute return statement.
+
+        Supports multiple return values for shuffled functions:
+            return a, b, c;  // Returns tuple (a, b, c)
+        """
+        if node.value is None:
+            raise CSSLReturn(None)
+
+        # Check if this is a multiple return value
+        if isinstance(node.value, dict) and node.value.get('multiple'):
+            values = [self._evaluate(v) for v in node.value.get('values', [])]
+            raise CSSLReturn(tuple(values))
+
+        value = self._evaluate(node.value)
         raise CSSLReturn(value)
 
     def _exec_break(self, node: ASTNode) -> Any:
@@ -1725,6 +1826,36 @@ class CSSLRuntime:
 
         return value
 
+    def _exec_tuple_assignment(self, node: ASTNode) -> Any:
+        """Execute tuple unpacking assignment: a, b, c = shuffled_func()
+
+        Used with shuffled functions that return multiple values.
+        """
+        targets = node.value.get('targets', [])
+        value = self._evaluate(node.value.get('value'))
+
+        # Convert value to list if it's a tuple or iterable
+        if isinstance(value, (list, tuple)):
+            values = list(value)
+        elif hasattr(value, '__iter__') and not isinstance(value, (str, dict)):
+            values = list(value)
+        else:
+            # Single value - assign to first target only
+            values = [value]
+
+        # Assign values to targets
+        for i, target in enumerate(targets):
+            if i < len(values):
+                var_name = target.value if isinstance(target, ASTNode) else target
+                self.scope.set(var_name, values[i])
+            else:
+                # More targets than values - set to None
+                var_name = target.value if isinstance(target, ASTNode) else target
+                self.scope.set(var_name, None)
+
+        # Assignment statements don't produce a visible result
+        return None
+
     def _exec_expression(self, node: ASTNode) -> Any:
         """Execute expression statement"""
         return self._evaluate(node.value)
@@ -1778,9 +1909,12 @@ class CSSLRuntime:
 
         if node.type == 'literal':
             value = node.value
-            # NEW: String interpolation - replace <variable> with scope values
-            if isinstance(value, str) and '<' in value and '>' in value:
-                value = self._interpolate_string(value)
+            # String interpolation - replace {var} or <var> with scope values
+            if isinstance(value, str):
+                has_fstring = '{' in value and '}' in value
+                has_legacy = '<' in value and '>' in value
+                if has_fstring or has_legacy:
+                    value = self._interpolate_string(value)
             return value
 
         # NEW: Type literals (list, dict) - create empty instances
@@ -1890,9 +2024,11 @@ class CSSLRuntime:
             return self._eval_this_access(node)
 
         if node.type == 'type_instantiation':
-            # Create new instance of a type: stack<string>, vector<int>, etc.
+            # Create new instance of a type: stack<string>, vector<int>, map<K,V>, etc.
             type_name = node.value.get('type')
             element_type = node.value.get('element_type', 'dynamic')
+            value_type = node.value.get('value_type')  # For map<K, V>
+            init_values = node.value.get('init_values')  # For inline init: map<K,V>{...}
 
             if type_name == 'stack':
                 return Stack(element_type)
@@ -1916,6 +2052,15 @@ class CSSLRuntime:
                 return List(element_type)
             elif type_name in ('dictionary', 'dict'):
                 return Dictionary(element_type)
+            elif type_name == 'map':
+                # Create Map with key_type and value_type
+                m = Map(element_type, value_type or 'dynamic')
+                # If inline initialization provided, populate the map
+                if init_values:
+                    for key, value_node in init_values.items():
+                        value = self._evaluate(value_node)
+                        m.insert(key, value)
+                return m
             else:
                 return None
 
@@ -2714,14 +2859,24 @@ class CSSLRuntime:
         elif isinstance(obj, dict):
             obj[final_attr] = value
 
-    # NEW: String interpolation
+    # String interpolation (supports both <var> and {var} syntax)
     def _interpolate_string(self, string: str) -> str:
-        """Replace <variable> placeholders with values from scope - NEW
+        """Replace {variable} and <variable> placeholders with values from scope.
 
-        Example: "Hello <name>!" becomes "Hello John!" if name = "John"
+        Both syntaxes are supported (variables only, not expressions):
+            "Hello {name}!"   -> "Hello John!"  (f-string style)
+            "Hello <name>!"   -> "Hello John!"  (legacy CSSL style)
+
+        Examples:
+            string name = "Alice";
+            int age = 30;
+            printl("Hello {name}, you are {age} years old!");
+            printl("Hello <name>, you are <age> years old!");
+
+        Note: Only simple variable names are supported, not expressions.
+        Use string concatenation for complex expressions.
         """
         import re
-        pattern = r'<([A-Za-z_][A-Za-z0-9_]*)>'
 
         def replacer(match):
             var_name = match.group(1)
@@ -2733,10 +2888,23 @@ class CSSLRuntime:
             # Try modules
             if value is None:
                 value = self._modules.get(var_name)
+            # Try global scope
+            if value is None:
+                value = self.global_scope.get(var_name)
             # Return string representation or empty string if None
             return str(value) if value is not None else ''
 
-        return re.sub(pattern, replacer, string)
+        # Support both {var} and <var> syntax - simple variable names only
+        # Pattern: {identifier} or <identifier>
+        patterns = [
+            r'\{([A-Za-z_][A-Za-z0-9_]*)\}',  # {name} f-string style
+            r'<([A-Za-z_][A-Za-z0-9_]*)>',     # <name> legacy CSSL style
+        ]
+
+        result = string
+        for pattern in patterns:
+            result = re.sub(pattern, replacer, result)
+        return result
 
     # NEW: Promote variable to global scope via global()
     def promote_to_global(self, s_ref_name: str):