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

includecpp/core/cssl/cssl_runtime.py

@@ -14,7 +14,8 @@ 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, Array, DataSpace, OpenQuote, List, Dictionary
+    Stack, Vector, Array, DataSpace, OpenQuote, List, Dictionary, Map,
+    CSSLClass, CSSLInstance
 )
 
 
@@ -145,6 +146,7 @@ class CSSLRuntime:
         self._injection_captures: Dict[str, Dict[str, Any]] = {}  # Captured %vars per injection
         self._current_captured_values: Dict[str, Any] = {}  # Current captured values during injection execution
         self._promoted_globals: Dict[str, Any] = {}  # NEW: Variables promoted via global()
+        self._current_instance: Optional[CSSLInstance] = None  # Current class instance for this-> access
         self._running = False
         self._exit_code = 0
         self._output_callback = output_callback  # Callback for console output (text, level)
@@ -386,6 +388,8 @@ class CSSLRuntime:
 
             if child.type == 'struct':
                 self._exec_struct(child)
+            elif child.type == 'class':
+                self._exec_class(child)
             elif child.type == 'function':
                 self._exec_function(child)
             elif child.type == 'global_assignment':
@@ -394,6 +398,12 @@ class CSSLRuntime:
             elif child.type == 'typed_declaration':
                 # Handle typed variable declaration: type<T> varName = value;
                 result = self._exec_typed_declaration(child)
+            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)
@@ -661,6 +671,57 @@ class CSSLRuntime:
 
         return struct_data
 
+    def _exec_class(self, node: ASTNode) -> CSSLClass:
+        """Execute class definition - registers class in scope.
+
+        Parses class members and methods, creating a CSSLClass object
+        that can be instantiated with 'new'.
+        """
+        class_info = node.value
+        class_name = class_info.get('name')
+
+        members = {}  # Member variable defaults/types
+        methods = {}  # Method AST nodes
+        constructor = None
+
+        for child in node.children:
+            if child.type == 'function':
+                # This is a method
+                func_info = child.value
+                method_name = func_info.get('name')
+
+                if func_info.get('is_constructor') or method_name == class_name or method_name == '__init__':
+                    constructor = child
+                else:
+                    methods[method_name] = child
+
+            elif child.type == 'typed_declaration':
+                # This is a member variable
+                decl = child.value
+                member_name = decl.get('name')
+                member_type = decl.get('type')
+                member_value = decl.get('value')
+
+                # Store member info with type and optional default
+                members[member_name] = {
+                    'type': member_type,
+                    'default': self._evaluate(member_value) if member_value else None
+                }
+
+        # Create class definition object
+        class_def = CSSLClass(
+            name=class_name,
+            members=members,
+            methods=methods,
+            constructor=constructor
+        )
+
+        # Register class in scope
+        self.scope.set(class_name, class_def)
+        self.global_scope.set(class_name, class_def)
+
+        return class_def
+
     def _exec_function(self, node: ASTNode) -> Any:
         """Execute function definition - just registers it"""
         func_info = node.value
@@ -714,6 +775,8 @@ class CSSLRuntime:
             instance = List(element_type)
         elif type_name in ('dictionary', 'dict'):
             instance = Dictionary(element_type)
+        elif type_name == 'map':
+            instance = Map(element_type)
         else:
             # Default: evaluate the value or set to None
             instance = self._evaluate(value_node) if value_node else None
@@ -732,6 +795,110 @@ class CSSLRuntime:
         self.scope.set(var_name, instance)
         return instance
 
+    def _exec_instance_declaration(self, node: ASTNode) -> Any:
+        """Execute instance declaration: instance<"name"> varName;
+
+        Gets or creates a shared instance by name.
+        """
+        from ..cssl_bridge import _live_objects, SharedObjectProxy
+        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}')
+
+        # If value is provided, use that and register as shared
+        if value_node:
+            instance = self._evaluate(value_node)
+            # Register in global scope for future access
+            self.global_scope.set(f'${instance_name}', instance)
+
+        # Store in scope
+        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
 
@@ -796,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):
@@ -1009,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:
@@ -1471,6 +1660,12 @@ class CSSLRuntime:
             name = target.value
             _live_objects[name] = final_value
             self.global_scope.set(f'${name}', SharedObjectProxy(name, final_value))
+        elif target.type == 'instance_ref':
+            # value ==> instance<"name"> - create/update shared object
+            from ..cssl_bridge import _live_objects, SharedObjectProxy
+            name = target.value
+            _live_objects[name] = final_value
+            self.global_scope.set(f'${name}', SharedObjectProxy(name, final_value))
         elif target.type == 'member_access':
             self._set_member(target, final_value)
 
@@ -1620,11 +1815,47 @@ class CSSLRuntime:
                 self._set_member(target, value)
             elif target.type == 'index_access':
                 self._set_index(target, value)
+            elif target.type == 'this_access':
+                # this->member = value
+                if self._current_instance is None:
+                    raise CSSLRuntimeError("'this' used outside of class method context")
+                member = target.value.get('member')
+                self._current_instance.set_member(member, value)
         elif isinstance(target, str):
             self.scope.set(target, value)
 
         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)
@@ -1678,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
@@ -1767,10 +2001,34 @@ class CSSLRuntime:
                 return value
             raise CSSLRuntimeError(f"Captured reference '%{name}' not found.")
 
+        if node.type == 'instance_ref':
+            # instance<"name"> - get shared instance by name
+            # Works like $name but with explicit syntax
+            from ..cssl_bridge import _live_objects, SharedObjectProxy
+            name = node.value
+            if name in _live_objects:
+                return SharedObjectProxy(name, _live_objects[name])
+            # Check if stored in runtime's scope
+            scoped_val = self.global_scope.get(f'${name}')
+            if scoped_val is not None:
+                return scoped_val
+            # Return None if instance doesn't exist (can be created via ==>)
+            return None
+
+        if node.type == 'new':
+            # Create new instance of a class: new ClassName(args)
+            return self._eval_new(node)
+
+        if node.type == 'this_access':
+            # this->member access
+            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)
@@ -1794,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
 
@@ -2136,6 +2403,140 @@ class CSSLRuntime:
             hint="Typed functions use format: FunctionName<Type>(args)"
         )
 
+    def _eval_new(self, node: ASTNode) -> CSSLInstance:
+        """Evaluate 'new ClassName(args)' expression.
+
+        Creates a new instance of a CSSL class and calls its constructor.
+        """
+        class_name = node.value.get('class')
+        args = [self._evaluate(arg) for arg in node.value.get('args', [])]
+        kwargs = {k: self._evaluate(v) for k, v in node.value.get('kwargs', {}).items()}
+
+        # Get class definition from scope
+        class_def = self.scope.get(class_name)
+        if class_def is None:
+            class_def = self.global_scope.get(class_name)
+
+        if class_def is None:
+            raise CSSLRuntimeError(
+                f"Class '{class_name}' not found",
+                node.line,
+                hint="Make sure the class is defined before instantiation"
+            )
+
+        if not isinstance(class_def, CSSLClass):
+            raise CSSLRuntimeError(
+                f"'{class_name}' is not a class",
+                node.line,
+                hint=f"'{class_name}' is of type {type(class_def).__name__}"
+            )
+
+        # Create new instance
+        instance = CSSLInstance(class_def)
+
+        # Call constructor if defined
+        if class_def.constructor:
+            self._call_method(instance, class_def.constructor, args, kwargs)
+
+        return instance
+
+    def _eval_this_access(self, node: ASTNode) -> Any:
+        """Evaluate 'this->member' access.
+
+        Returns the value of a member from the current class instance.
+        """
+        if self._current_instance is None:
+            raise CSSLRuntimeError(
+                "'this' used outside of class method context",
+                node.line if hasattr(node, 'line') else 0,
+                hint="'this->' can only be used inside class methods"
+            )
+
+        member = node.value.get('member')
+
+        # Check if it's a chained access (this->a->b)
+        if 'object' in node.value:
+            # First evaluate the object part
+            obj = self._evaluate(node.value.get('object'))
+            if obj is None:
+                return None
+            if hasattr(obj, member):
+                return getattr(obj, member)
+            if isinstance(obj, dict):
+                return obj.get(member)
+            return None
+
+        # Direct this->member access
+        instance = self._current_instance
+
+        # Check if it's a member variable
+        if instance.has_member(member):
+            return instance.get_member(member)
+
+        # Check if it's a method
+        if instance.has_method(member):
+            # Return a callable that will invoke the method with instance context
+            method_node = instance.get_method(member)
+            return lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
+
+        raise CSSLRuntimeError(
+            f"'{instance._class.name}' has no member or method '{member}'",
+            node.line if hasattr(node, 'line') else 0
+        )
+
+    def _call_method(self, instance: CSSLInstance, method_node: ASTNode, args: list, kwargs: dict = None) -> Any:
+        """Call a method on an instance with 'this' context.
+
+        Sets up the instance as the current 'this' context and executes the method.
+        """
+        kwargs = kwargs or {}
+        func_info = method_node.value
+        params = func_info.get('params', [])
+        modifiers = func_info.get('modifiers', [])
+
+        # Check for undefined modifier
+        is_undefined = 'undefined' in modifiers
+
+        # Create new scope for method
+        new_scope = Scope(parent=self.scope)
+
+        # Bind parameters
+        for i, param in enumerate(params):
+            param_name = param['name'] if isinstance(param, dict) else param
+
+            if param_name in kwargs:
+                new_scope.set(param_name, kwargs[param_name])
+            elif i < len(args):
+                new_scope.set(param_name, args[i])
+            else:
+                new_scope.set(param_name, None)
+
+        # Save current state
+        old_scope = self.scope
+        old_instance = self._current_instance
+
+        # Set up method context
+        self.scope = new_scope
+        self._current_instance = instance
+
+        try:
+            for child in method_node.children:
+                if not self._running:
+                    break
+                self._execute_node(child)
+        except CSSLReturn as ret:
+            return ret.value
+        except Exception as e:
+            if is_undefined:
+                return None
+            raise
+        finally:
+            # Restore previous state
+            self.scope = old_scope
+            self._current_instance = old_instance
+
+        return None
+
     def _eval_member_access(self, node: ASTNode) -> Any:
         """Evaluate member access"""
         obj = self._evaluate(node.value.get('object'))
@@ -2149,6 +2550,17 @@ class CSSLRuntime:
         if isinstance(obj, Parameter) and member == 'return':
             member = 'return_'
 
+        # === CSSL CLASS INSTANCE METHODS ===
+        if isinstance(obj, CSSLInstance):
+            # 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)
+                return lambda *args, **kwargs: self._call_method(obj, method_node, list(args), kwargs)
+            raise CSSLRuntimeError(f"'{obj._class.name}' has no member or method '{member}'")
+
         # === STRING METHODS ===
         if isinstance(obj, str):
             string_methods = self._get_string_method(obj, member)
@@ -2382,6 +2794,11 @@ class CSSLRuntime:
         if obj is None:
             return
 
+        # Check for CSSLInstance - use set_member method
+        if isinstance(obj, CSSLInstance):
+            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'):
@@ -2442,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.
+
+        Both syntaxes are supported (variables only, not expressions):
+            "Hello {name}!"   -> "Hello John!"  (f-string style)
+            "Hello <name>!"   -> "Hello John!"  (legacy CSSL style)
 
-        Example: "Hello <name>!" becomes "Hello John!" if name = "John"
+        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)
@@ -2461,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):