IncludeCPP 3.4.8__py3-none-any.whl → 3.4.21__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -12,14 +12,51 @@ 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, Array, DataSpace, OpenQuote
+)
 
 
 class CSSLRuntimeError(Exception):
-    """Runtime error during CSSL execution"""
-    def __init__(self, message: str, line: int = 0):
+    """Runtime error during CSSL execution with detailed context"""
+    def __init__(self, message: str, line: int = 0, context: str = None, hint: str = None):
         self.line = line
-        super().__init__(f"{message} (line {line})" if line else message)
+        self.context = context
+        self.hint = hint
+
+        # Build detailed error message
+        error_parts = []
+
+        # Main error message
+        if line:
+            error_parts.append(f"Error at line {line}: {message}")
+        else:
+            error_parts.append(f"Error: {message}")
+
+        # Add context if available
+        if context:
+            error_parts.append(f"  Context: {context}")
+
+        # Add hint if available
+        if hint:
+            error_parts.append(f"  Hint: {hint}")
+
+        super().__init__("\n".join(error_parts))
+
+
+# Common error hints for better user experience
+ERROR_HINTS = {
+    'undefined_variable': "Did you forget to declare the variable? Use 'string x = ...' or 'int x = ...'",
+    'undefined_function': "Check function name spelling. Functions are case-sensitive.",
+    'type_mismatch': "Try using explicit type conversion: toInt(), toFloat(), toString()",
+    'null_reference': "Variable is null. Check if it was properly initialized.",
+    'index_out_of_bounds': "Array index must be >= 0 and < array.length()",
+    'division_by_zero': "Cannot divide by zero. Add a check: if (divisor != 0) { ... }",
+    'invalid_operation': "This operation is not supported for this type.",
+    'missing_semicolon': "Statement might be missing a semicolon (;)",
+    'missing_brace': "Check for matching opening and closing braces { }",
+}
 
 
 class CSSLBreak(Exception):
@@ -103,6 +140,7 @@ class CSSLRuntime:
         self._modules: Dict[str, Any] = {}
         self._global_structs: Dict[str, Any] = {}  # Global structs for s@<name> references
         self._function_injections: Dict[str, List[ASTNode]] = {}  # NEW: Permanent function injections
+        self._function_replaced: Dict[str, bool] = {}  # NEW: Track replaced functions (<<==)
         self._promoted_globals: Dict[str, Any] = {}  # NEW: Variables promoted via global()
         self._running = False
         self._exit_code = 0
@@ -291,8 +329,14 @@ 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'):
+                               'if', 'while', 'for', 'c_for', 'foreach', 'switch', 'try'):
                 result = self._execute_node(child)
             elif child.type == 'call':
                 result = self._eval_call(child)
@@ -564,6 +608,109 @@ 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 = Array(element_type)
+        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):
+                if target.type == 'identifier':
+                    var_name = target.value
+                elif target.type == 'global_ref':
+                    # r@Name = value
+                    var_name = target.value
+                else:
+                    var_name = str(target.value) if hasattr(target, 'value') else str(target)
+            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
@@ -638,12 +785,16 @@ class CSSLRuntime:
         return None
 
     def _exec_for(self, node: ASTNode) -> Any:
-        """Execute for loop"""
+        """Execute Python-style for loop: for (i in range(start, end, step)) { }"""
         var_name = node.value.get('var')
         start = int(self._evaluate(node.value.get('start')))
         end = int(self._evaluate(node.value.get('end')))
 
-        for i in range(start, end):
+        # Optional step parameter (default is 1)
+        step_node = node.value.get('step')
+        step = int(self._evaluate(step_node)) if step_node else 1
+
+        for i in range(start, end, step):
             self.scope.set(var_name, i)
             try:
                 for child in node.children:
@@ -655,6 +806,73 @@ class CSSLRuntime:
 
         return None
 
+    def _exec_c_for(self, node: ASTNode) -> Any:
+        """Execute C-style for loop: for (init; condition; update) { }
+
+        Supports:
+        - for (int i = 0; i < n; i++) { }
+        - for (int i = 0; i < n; i = i + 1) { }
+        - for (i = 0; i < n; i += 1) { }
+        - for (; condition; ) { }  (infinite loop with condition)
+        """
+        init = node.value.get('init')
+        condition = node.value.get('condition')
+        update = node.value.get('update')
+
+        # Execute init statement
+        if init:
+            var_name = init.value.get('var')
+            init_value = self._evaluate(init.value.get('value'))
+            self.scope.set(var_name, init_value)
+        else:
+            var_name = None
+
+        # Main loop
+        while True:
+            # Check condition
+            if condition:
+                cond_result = self._evaluate(condition)
+                if not cond_result:
+                    break
+            # If no condition, this would be infinite - we still need a way to break
+
+            # Execute body
+            try:
+                for child in node.children:
+                    self._execute_node(child)
+            except CSSLBreak:
+                break
+            except CSSLContinue:
+                pass  # Continue to update, then next iteration
+
+            # Execute update
+            if update:
+                self._exec_c_for_update(update)
+
+        return None
+
+    def _exec_c_for_update(self, update: 'ASTNode') -> None:
+        """Execute the update part of a C-style for loop."""
+        var_name = update.value.get('var')
+        op = update.value.get('op')
+        value_node = update.value.get('value')
+
+        current = self.scope.get(var_name) or 0
+
+        if op == 'increment':
+            self.scope.set(var_name, current + 1)
+        elif op == 'decrement':
+            self.scope.set(var_name, current - 1)
+        elif op == 'add':
+            add_value = self._evaluate(value_node)
+            self.scope.set(var_name, current + add_value)
+        elif op == 'subtract':
+            sub_value = self._evaluate(value_node)
+            self.scope.set(var_name, current - sub_value)
+        elif op == 'assign':
+            new_value = self._evaluate(value_node)
+            self.scope.set(var_name, new_value)
+
     def _exec_foreach(self, node: ASTNode) -> Any:
         """Execute foreach loop"""
         var_name = node.value.get('var')
@@ -779,7 +997,7 @@ class CSSLRuntime:
     def _apply_injection_filter(self, source: Any, filter_info: dict) -> Any:
         """Apply injection filter to extract specific data from source.
 
-        Filters:
+        All BruteInjector Helpers:
         - string::where=VALUE - Filter strings containing VALUE
         - string::length=LENGTH - Filter strings of specific length
         - integer::where=VALUE - Filter integers matching VALUE
@@ -788,9 +1006,12 @@ class CSSLRuntime:
         - array::index=INDEX - Get specific index from array
         - array::length=LENGTH - Filter arrays of specific length
         - vector::where=VALUE - Filter vectors containing VALUE
+        - vector::index=INDEX - Get specific index from vector
+        - vector::length=LENGTH - Filter vectors of specific length
         - combo::filterdb - Get filter database from combo
         - combo::blocked - Get blocked items from combo
-        - dynamic::VarName=VALUE - Filter by dynamic variable
+        - dynamic::VarName=VALUE - Filter by dynamic variable value
+        - sql::data - Return only SQL-compatible data
         """
         if not filter_info:
             return source
@@ -802,25 +1023,28 @@ class CSSLRuntime:
                 filter_type, helper = filter_key.split('::', 1)
                 filter_val = self._evaluate(filter_value) if isinstance(filter_value, ASTNode) else filter_value
 
+                # === STRING HELPERS ===
                 if filter_type == 'string':
                     if helper == 'where':
-                        if isinstance(result, str) and filter_val in result:
-                            pass  # Keep result
+                        if isinstance(result, str):
+                            result = result if filter_val in result else None
                         elif isinstance(result, list):
                             result = [item for item in result if isinstance(item, str) and filter_val in item]
-                    elif helper == 'length':
+                    elif helper in ('length', 'lenght'):  # Support common typo
                         if isinstance(result, str):
                             result = result if len(result) == filter_val else None
                         elif isinstance(result, list):
                             result = [item for item in result if isinstance(item, str) and len(item) == filter_val]
 
+                # === INTEGER HELPERS ===
                 elif filter_type == 'integer':
                     if helper == 'where':
-                        if isinstance(result, int) and result == filter_val:
-                            pass  # Keep result
+                        if isinstance(result, int):
+                            result = result if result == filter_val else None
                         elif isinstance(result, list):
                             result = [item for item in result if isinstance(item, int) and item == filter_val]
 
+                # === JSON HELPERS ===
                 elif filter_type == 'json':
                     if helper == 'key':
                         if isinstance(result, dict):
@@ -829,29 +1053,68 @@ class CSSLRuntime:
                             result = [item.get(filter_val) for item in result if isinstance(item, dict) and filter_val in item]
                     elif helper == 'value':
                         if isinstance(result, dict):
-                            result = {k: v for k, v in result.items() if v == filter_val}
+                            # Find key(s) with matching value
+                            matches = [k for k, v in result.items() if v == filter_val]
+                            result = matches[0] if len(matches) == 1 else matches
                         elif isinstance(result, list):
                             result = [item for item in result if (isinstance(item, dict) and filter_val in item.values())]
 
-                elif filter_type == 'array' or filter_type == 'vector':
+                # === ARRAY HELPERS ===
+                elif filter_type == 'array':
                     if helper == 'index':
-                        if isinstance(result, list) and 0 <= filter_val < len(result):
-                            result = result[filter_val]
-                    elif helper == 'length':
+                        if isinstance(result, (list, tuple)):
+                            idx = int(filter_val) if not isinstance(filter_val, int) else filter_val
+                            if 0 <= idx < len(result):
+                                result = result[idx]
+                            else:
+                                result = None
+                    elif helper in ('length', 'lenght'):  # Support common typo
+                        if isinstance(result, (list, tuple)):
+                            result = result if len(result) == filter_val else []
+                    elif helper == 'where':
                         if isinstance(result, list):
+                            result = [item for item in result if item == filter_val]
+
+                # === VECTOR HELPERS ===
+                elif filter_type == 'vector':
+                    if helper == 'index':
+                        if isinstance(result, (list, tuple)):
+                            idx = int(filter_val) if not isinstance(filter_val, int) else filter_val
+                            if 0 <= idx < len(result):
+                                result = result[idx]
+                            else:
+                                result = None
+                    elif helper in ('length', 'lenght'):  # Support common typo
+                        if isinstance(result, (list, tuple)):
                             result = result if len(result) == filter_val else []
                     elif helper == 'where':
                         if isinstance(result, list):
                             result = [item for item in result if item == filter_val]
 
+                # === COMBO HELPERS ===
                 elif filter_type == 'combo':
                     if helper == 'filterdb':
                         if hasattr(result, '_filterdb'):
                             result = result._filterdb
+                        elif hasattr(result, 'filterdb'):
+                            result = result.filterdb
                     elif helper == 'blocked':
                         if hasattr(result, '_blocked'):
                             result = result._blocked
+                        elif hasattr(result, 'blocked'):
+                            result = result.blocked
+
+                # === DYNAMIC HELPERS ===
+                elif filter_type == 'dynamic':
+                    # dynamic::VarName=VALUE - Match if variable equals value
+                    var_name = helper
+                    var_value = self.scope.get(var_name)
+                    if var_value == filter_val:
+                        pass  # Keep result
+                    else:
+                        result = None
 
+                # === SQL HELPERS ===
                 elif filter_type == 'sql':
                     if helper == 'data':
                         # Return only SQL-compatible data types
@@ -931,6 +1194,12 @@ class CSSLRuntime:
             self.scope.set(target.value, final_value)
         elif target.type == 'module_ref':
             self._set_module_value(target.value, final_value)
+        elif target.type == 'shared_ref':
+            # $Name <== value - 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)
         elif target.type == 'call':
@@ -999,6 +1268,12 @@ class CSSLRuntime:
             self.scope.set(target.value, final_value)
         elif target.type == 'module_ref':
             self._set_module_value(target.value, final_value)
+        elif target.type == 'shared_ref':
+            # value ==> $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)
 
@@ -1008,13 +1283,13 @@ class CSSLRuntime:
         """Execute code infusion (<<==, +<<==, -<<==)
 
         Modes:
-        - replace: func <<== { code } (inject code into function, replaces)
-        - add: func +<<== { code } (add code to function)
-        - remove: func -<<== { code } (remove matching code from function)
+        - replace: func <<== { code } - REPLACES function body (original won't execute)
+        - add: func +<<== { code } - ADDS code to function (both execute)
+        - remove: func -<<== { code } - REMOVES matching code from function
         """
         target = node.value.get('target')
         code_block = node.value.get('code')
-        mode = node.value.get('mode', 'add')
+        mode = node.value.get('mode', 'replace')  # Default is REPLACE for <<==
 
         # Get function name from target
         func_name = None
@@ -1030,17 +1305,21 @@ class CSSLRuntime:
             return None
 
         if mode == 'add':
-            # Add code to function (permanent injection)
+            # +<<== : Add code to function (both injection + original execute)
             self.register_function_injection(func_name, code_block)
+            self._function_replaced[func_name] = False  # Don't replace, just add
         elif mode == 'replace':
-            # Replace - clear existing and add new
+            # <<== : Replace function body (only injection executes, original skipped)
             self._function_injections[func_name] = [code_block]
+            self._function_replaced[func_name] = True  # Mark as replaced
         elif mode == 'remove':
-            # Remove matching code patterns from function
+            # -<<== : Remove matching code from function body
+            # For now, this removes all injections for the function
             if func_name in self._function_injections:
-                # For simplicity, clear all injections for this function
-                # A more sophisticated implementation would compare code blocks
                 self._function_injections[func_name] = []
+            self._function_replaced[func_name] = False
+            # Note: Removing from actual function body would require AST manipulation
+            # which is complex - for now we just clear injections
 
         return None
 
@@ -1083,6 +1362,14 @@ class CSSLRuntime:
             self.scope.set(target.value, source)
         elif target.type == 'module_ref':
             self._set_module_value(target.value, source)
+        elif target.type == 'shared_ref':
+            # $Name <== value - create/update shared object
+            from ..cssl_bridge import _live_objects, SharedObjectProxy
+            name = target.value
+            _live_objects[name] = source
+            self.global_scope.set(f'${name}', SharedObjectProxy(name, source))
+        elif target.type == 'member_access':
+            self._set_member(target, source)
 
         return source
 
@@ -1094,6 +1381,20 @@ 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 == 'shared_ref':
+                # $Name = value - create/update shared object
+                from ..cssl_bridge import _live_objects, SharedObjectProxy
+                name = target.value
+                _live_objects[name] = value
+                self.global_scope.set(f'${name}', SharedObjectProxy(name, value))
+            elif target.type == 'module_ref':
+                # @Name = value - store in promoted globals (like global keyword)
+                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 +1478,65 @@ 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 == 'shared_ref':
+            # $<name> shared object reference
+            # Returns the SharedObjectProxy for live access
+            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 as $name
+            scoped_val = self.global_scope.get(f'${name}')
+            if scoped_val is not None:
+                return scoped_val
+            raise CSSLRuntimeError(f"Shared object '${name}' not found. Use share() to share objects.")
+
+        if node.type == 'type_instantiation':
+            # Create new instance of a type: stack<string>, vector<int>, etc.
+            type_name = node.value.get('type')
+            element_type = node.value.get('element_type', 'dynamic')
+
+            if type_name == 'stack':
+                return Stack(element_type)
+            elif type_name == 'vector':
+                return Vector(element_type)
+            elif type_name == 'datastruct':
+                return DataStruct(element_type)
+            elif type_name == 'shuffled':
+                return Shuffled(element_type)
+            elif type_name == 'iterator':
+                return Iterator(element_type)
+            elif type_name == 'combo':
+                return Combo(element_type)
+            elif type_name == 'dataspace':
+                return DataSpace(element_type)
+            elif type_name == 'openquote':
+                return OpenQuote()
+            elif type_name == 'array':
+                return Array(element_type)
+            else:
+                return None
+
         if node.type == 'binary':
             return self._eval_binary(node)
 
@@ -1192,6 +1546,10 @@ class CSSLRuntime:
         if node.type == 'call':
             return self._eval_call(node)
 
+        if node.type == 'typed_call':
+            # Handle OpenFind<type>(args) style calls
+            return self._eval_typed_call(node)
+
         if node.type == 'member_access':
             return self._eval_member_access(node)
 
@@ -1218,32 +1576,161 @@ class CSSLRuntime:
         return None
 
     def _eval_binary(self, node: ASTNode) -> Any:
-        """Evaluate binary operation"""
+        """Evaluate binary operation with auto-casting support"""
         op = node.value.get('op')
         left = self._evaluate(node.value.get('left'))
         right = self._evaluate(node.value.get('right'))
 
-        operators = {
-            '+': lambda a, b: a + b,
-            '-': lambda a, b: a - b,
-            '*': lambda a, b: a * b,
-            '/': lambda a, b: a / b if b != 0 else 0,
-            '%': lambda a, b: a % b if b != 0 else 0,
-            '==': lambda a, b: a == b,
-            '!=': lambda a, b: a != b,
-            '<': lambda a, b: a < b,
-            '>': lambda a, b: a > b,
-            '<=': lambda a, b: a <= b,
-            '>=': lambda a, b: a >= b,
-            'and': lambda a, b: a and b,
-            'or': lambda a, b: a or b,
-        }
+        # === AUTO-CAST FOR STRING OPERATIONS ===
+        if op == '+':
+            # String concatenation with auto-cast
+            if isinstance(left, str) or isinstance(right, str):
+                return str(left if left is not None else '') + str(right if right is not None else '')
+            # List concatenation
+            if isinstance(left, list) and isinstance(right, list):
+                result = type(left)(left._element_type) if hasattr(left, '_element_type') else []
+                if hasattr(result, 'extend'):
+                    result.extend(left)
+                    result.extend(right)
+                else:
+                    result = list(left) + list(right)
+                return result
+            # Numeric addition
+            return (left or 0) + (right or 0)
 
-        if op in operators:
-            return operators[op](left, right)
+        if op == '-':
+            return self._to_number(left) - self._to_number(right)
+
+        if op == '*':
+            # String repeat: "abc" * 3 = "abcabcabc"
+            if isinstance(left, str) and isinstance(right, (int, float)):
+                return left * int(right)
+            if isinstance(right, str) and isinstance(left, (int, float)):
+                return right * int(left)
+            return self._to_number(left) * self._to_number(right)
+
+        if op == '/':
+            r = self._to_number(right)
+            return self._to_number(left) / r if r != 0 else 0
+
+        if op == '//':
+            r = self._to_number(right)
+            return self._to_number(left) // r if r != 0 else 0
+
+        if op == '%':
+            r = self._to_number(right)
+            return self._to_number(left) % r if r != 0 else 0
+
+        if op == '**':
+            return self._to_number(left) ** self._to_number(right)
+
+        # === COMPARISON OPERATIONS ===
+        if op == '==':
+            return left == right
+        if op == '!=':
+            return left != right
+        if op == '<':
+            return self._compare(left, right) < 0
+        if op == '>':
+            return self._compare(left, right) > 0
+        if op == '<=':
+            return self._compare(left, right) <= 0
+        if op == '>=':
+            return self._compare(left, right) >= 0
+
+        # === LOGICAL OPERATIONS ===
+        if op == 'and' or op == '&&':
+            return left and right
+        if op == 'or' or op == '||':
+            return left or right
+
+        # === BITWISE OPERATIONS ===
+        if op == '&':
+            return int(left or 0) & int(right or 0)
+        if op == '|':
+            return int(left or 0) | int(right or 0)
+        if op == '^':
+            return int(left or 0) ^ int(right or 0)
+        if op == '<<':
+            return int(left or 0) << int(right or 0)
+        if op == '>>':
+            return int(left or 0) >> int(right or 0)
+
+        # === IN OPERATOR ===
+        if op == 'in':
+            if right is None:
+                return False
+            return left in right
 
         return None
 
+    def _to_number(self, value: Any) -> Union[int, float]:
+        """Convert value to number with auto-casting"""
+        if value is None:
+            return 0
+        if isinstance(value, (int, float)):
+            return value
+        if isinstance(value, str):
+            value = value.strip()
+            if not value:
+                return 0
+            try:
+                if '.' in value:
+                    return float(value)
+                return int(value)
+            except ValueError:
+                return 0
+        if isinstance(value, bool):
+            return 1 if value else 0
+        if isinstance(value, (list, tuple)):
+            return len(value)
+        return 0
+
+    def _compare(self, left: Any, right: Any) -> int:
+        """Compare two values with auto-casting, returns -1, 0, or 1"""
+        # Handle None
+        if left is None and right is None:
+            return 0
+        if left is None:
+            return -1
+        if right is None:
+            return 1
+
+        # Both strings - compare as strings
+        if isinstance(left, str) and isinstance(right, str):
+            if left < right:
+                return -1
+            elif left > right:
+                return 1
+            return 0
+
+        # Both numbers - compare as numbers
+        if isinstance(left, (int, float)) and isinstance(right, (int, float)):
+            if left < right:
+                return -1
+            elif left > right:
+                return 1
+            return 0
+
+        # Mixed types - try to convert to numbers
+        try:
+            l = self._to_number(left)
+            r = self._to_number(right)
+            if l < r:
+                return -1
+            elif l > r:
+                return 1
+            return 0
+        except:
+            # Fallback to string comparison
+            l_str = str(left)
+            r_str = str(right)
+            if l_str < r_str:
+                return -1
+            elif l_str > r_str:
+                return 1
+            return 0
+
     def _eval_unary(self, node: ASTNode) -> Any:
         """Evaluate unary operation"""
         op = node.value.get('op')
@@ -1262,7 +1749,7 @@ class CSSLRuntime:
         callee = self._evaluate(callee_node)
         args = [self._evaluate(a) for a in node.value.get('args', [])]
 
-        # NEW: Get function name for injection check
+        # Get function name for injection check
         func_name = None
         if isinstance(callee_node, ASTNode):
             if callee_node.type == 'identifier':
@@ -1270,17 +1757,81 @@ class CSSLRuntime:
             elif callee_node.type == 'member_access':
                 func_name = callee_node.value.get('member')
 
-        # NEW: Execute any permanently injected code first
-        if func_name and func_name in self._function_injections:
+        # Check if function has injections
+        has_injections = func_name and func_name in self._function_injections
+        is_replaced = func_name and self._function_replaced.get(func_name, False)
+
+        # Execute injected code first (if any)
+        if has_injections:
             self._execute_function_injections(func_name)
 
+        # If function is REPLACED (<<==), skip original body execution
+        if is_replaced:
+            return None  # Injection already ran, don't run original
+
+        # Execute original function
         if callable(callee):
             return callee(*args)
 
         if isinstance(callee, ASTNode) and callee.type == 'function':
             return self._call_function(callee, args)
 
-        raise CSSLRuntimeError(f"Cannot call non-function: {type(callee)}", node.line)
+        callee_name = callee_node.value if isinstance(callee_node, ASTNode) and hasattr(callee_node, 'value') else str(callee_node)
+        raise CSSLRuntimeError(
+            f"Cannot call '{callee_name}' - it is not a function",
+            node.line,
+            context=f"Type: {type(callee).__name__}",
+            hint=ERROR_HINTS['undefined_function']
+        )
+
+    def _eval_typed_call(self, node: ASTNode) -> Any:
+        """Evaluate typed function call like OpenFind<string>(0)"""
+        name = node.value.get('name')
+        type_param = node.value.get('type_param', 'dynamic')
+        args = [self._evaluate(a) for a in node.value.get('args', [])]
+
+        # Handle OpenFind<type>(index)
+        if name == 'OpenFind':
+            # OpenFind searches for a value of the specified type
+            # from the open parameters in scope
+            open_params = self.scope.get('Params') or []
+            index = args[0] if args else 0
+
+            # Search for value of matching type at or near the index
+            type_map = {
+                'string': str, 'str': str,
+                'int': int, 'integer': int,
+                'float': float, 'double': float,
+                'bool': bool, 'boolean': bool,
+                'list': list, 'array': list,
+                'dict': dict, 'json': dict,
+            }
+
+            target_type = type_map.get(type_param.lower())
+
+            if isinstance(open_params, (list, tuple)):
+                # Find first matching type starting from index
+                for i in range(index, len(open_params)):
+                    if target_type is None or isinstance(open_params[i], target_type):
+                        return open_params[i]
+                # Also search before index
+                for i in range(0, min(index, len(open_params))):
+                    if target_type is None or isinstance(open_params[i], target_type):
+                        return open_params[i]
+
+            return None
+
+        # Fallback: call as regular function with type hint
+        func = self.builtins.get_function(name)
+        if func and callable(func):
+            return func(type_param, *args)
+
+        raise CSSLRuntimeError(
+            f"Unknown typed function: {name}<{type_param}>",
+            node.line,
+            context=f"Available typed functions: OpenFind<type>",
+            hint="Typed functions use format: FunctionName<Type>(args)"
+        )
 
     def _eval_member_access(self, node: ASTNode) -> Any:
         """Evaluate member access"""
@@ -1290,6 +1841,23 @@ 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_'
+
+        # === STRING METHODS ===
+        if isinstance(obj, str):
+            string_methods = self._get_string_method(obj, member)
+            if string_methods is not None:
+                return string_methods
+
+        # === LIST/ARRAY METHODS for plain lists ===
+        if isinstance(obj, list) and not isinstance(obj, (Stack, Vector, Array)):
+            list_methods = self._get_list_method(obj, member)
+            if list_methods is not None:
+                return list_methods
+
         if hasattr(obj, member):
             return getattr(obj, member)
 
@@ -1298,6 +1866,198 @@ class CSSLRuntime:
 
         return None
 
+    def _get_string_method(self, s: str, method: str) -> Any:
+        """Get string method implementation for CSSL.
+
+        Provides C++/Java/JS style string methods that Python doesn't have.
+        """
+        # === C++/Java/JS STRING METHODS ===
+        if method == 'contains':
+            return lambda substr: substr in s
+        elif method == 'indexOf':
+            return lambda substr, start=0: s.find(substr, start)
+        elif method == 'lastIndexOf':
+            return lambda substr: s.rfind(substr)
+        elif method == 'charAt':
+            return lambda index: s[index] if 0 <= index < len(s) else ''
+        elif method == 'charCodeAt':
+            return lambda index: ord(s[index]) if 0 <= index < len(s) else -1
+        elif method == 'substring':
+            return lambda start, end=None: s[start:end] if end else s[start:]
+        elif method == 'substr':
+            return lambda start, length=None: s[start:start+length] if length else s[start:]
+        elif method == 'slice':
+            return lambda start, end=None: s[start:end] if end else s[start:]
+
+        # === TRIM METHODS ===
+        elif method == 'trim':
+            return lambda: s.strip()
+        elif method == 'trimStart' or method == 'trimLeft' or method == 'ltrim':
+            return lambda: s.lstrip()
+        elif method == 'trimEnd' or method == 'trimRight' or method == 'rtrim':
+            return lambda: s.rstrip()
+
+        # === CASE METHODS ===
+        elif method in ('toUpperCase', 'toUpper', 'upper'):
+            return lambda: s.upper()
+        elif method in ('toLowerCase', 'toLower', 'lower'):
+            return lambda: s.lower()
+        elif method == 'capitalize':
+            return lambda: s.capitalize()
+        elif method == 'title':
+            return lambda: s.title()
+        elif method == 'swapcase':
+            return lambda: s.swapcase()
+
+        # === REPLACE METHODS ===
+        elif method == 'replaceAll':
+            return lambda old, new: s.replace(old, new)
+        elif method == 'replaceFirst':
+            return lambda old, new: s.replace(old, new, 1)
+
+        # === CHECK METHODS ===
+        elif method == 'isEmpty':
+            return lambda: len(s) == 0
+        elif method == 'isBlank':
+            return lambda: len(s.strip()) == 0
+        elif method == 'isDigit' or method == 'isNumeric':
+            return lambda: s.isdigit()
+        elif method == 'isAlpha':
+            return lambda: s.isalpha()
+        elif method == 'isAlphaNumeric' or method == 'isAlnum':
+            return lambda: s.isalnum()
+        elif method == 'isSpace' or method == 'isWhitespace':
+            return lambda: s.isspace()
+        elif method == 'isUpper':
+            return lambda: s.isupper()
+        elif method == 'isLower':
+            return lambda: s.islower()
+
+        # === STARTS/ENDS WITH ===
+        elif method == 'startsWith' or method == 'startswith':
+            return lambda prefix: s.startswith(prefix)
+        elif method == 'endsWith' or method == 'endswith':
+            return lambda suffix: s.endswith(suffix)
+
+        # === LENGTH/SIZE ===
+        elif method == 'length' or method == 'size':
+            return lambda: len(s)
+
+        # === SPLIT/JOIN ===
+        elif method == 'toArray':
+            return lambda sep=None: list(s.split(sep) if sep else list(s))
+        elif method == 'lines':
+            return lambda: s.splitlines()
+        elif method == 'words':
+            return lambda: s.split()
+
+        # === PADDING ===
+        elif method == 'padStart' or method == 'padLeft' or method == 'lpad':
+            return lambda width, char=' ': s.rjust(width, char[0] if char else ' ')
+        elif method == 'padEnd' or method == 'padRight' or method == 'rpad':
+            return lambda width, char=' ': s.ljust(width, char[0] if char else ' ')
+        elif method == 'center':
+            return lambda width, char=' ': s.center(width, char[0] if char else ' ')
+        elif method == 'zfill':
+            return lambda width: s.zfill(width)
+
+        # === REPEAT ===
+        elif method == 'repeat':
+            return lambda n: s * n
+
+        # === REVERSE ===
+        elif method == 'reverse':
+            return lambda: s[::-1]
+
+        # === FORMAT ===
+        elif method == 'format':
+            return lambda *args, **kwargs: s.format(*args, **kwargs)
+
+        # === ENCODING ===
+        elif method == 'encode':
+            return lambda encoding='utf-8': s.encode(encoding)
+        elif method == 'bytes':
+            return lambda encoding='utf-8': list(s.encode(encoding))
+
+        # === NUMERIC CONVERSION ===
+        elif method == 'toInt' or method == 'toInteger':
+            return lambda base=10: int(s, base) if s.lstrip('-').isdigit() else 0
+        elif method == 'toFloat' or method == 'toDouble':
+            try:
+                return lambda: float(s)
+            except:
+                return lambda: 0.0
+        elif method == 'toBool':
+            return lambda: s.lower() in ('true', '1', 'yes', 'on')
+
+        # === C++ ITERATOR STYLE ===
+        elif method == 'begin':
+            return lambda: 0
+        elif method == 'end':
+            return lambda: len(s)
+
+        # Return None if not a string method
+        return None
+
+    def _get_list_method(self, lst: list, method: str) -> Any:
+        """Get list method implementation for plain Python lists in CSSL."""
+        if method == 'contains':
+            return lambda item: item in lst
+        elif method == 'indexOf':
+            def index_of(item):
+                try:
+                    return lst.index(item)
+                except ValueError:
+                    return -1
+            return index_of
+        elif method == 'lastIndexOf':
+            def last_index_of(item):
+                for i in range(len(lst) - 1, -1, -1):
+                    if lst[i] == item:
+                        return i
+                return -1
+            return last_index_of
+        elif method == 'length' or method == 'size':
+            return lambda: len(lst)
+        elif method == 'isEmpty':
+            return lambda: len(lst) == 0
+        elif method == 'first':
+            return lambda: lst[0] if lst else None
+        elif method == 'last':
+            return lambda: lst[-1] if lst else None
+        elif method == 'at':
+            return lambda i: lst[i] if 0 <= i < len(lst) else None
+        elif method == 'slice':
+            return lambda start, end=None: lst[start:end] if end else lst[start:]
+        elif method == 'join':
+            return lambda sep=',': sep.join(str(x) for x in lst)
+        elif method == 'find':
+            def find_item(val):
+                for item in lst:
+                    if item == val:
+                        return item
+                return None
+            return find_item
+        elif method == 'push':
+            def push_item(item):
+                lst.append(item)
+                return lst
+            return push_item
+        elif method == 'push_back':
+            def push_back_item(item):
+                lst.append(item)
+                return lst
+            return push_back_item
+        elif method == 'toArray':
+            return lambda: list(lst)
+        # === C++ ITERATOR STYLE ===
+        elif method == 'begin':
+            return lambda: 0
+        elif method == 'end':
+            return lambda: len(lst)
+
+        return None
+
     def _eval_index_access(self, node: ASTNode) -> Any:
         """Evaluate index access"""
         obj = self._evaluate(node.value.get('object'))
@@ -1319,10 +2079,30 @@ class CSSLRuntime:
         if obj is None:
             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'):
+            # This is a SharedObjectProxy - get the real object directly
+            real_obj = object.__getattribute__(obj, '_direct_object')
+            if real_obj is None:
+                # Fallback to _live_objects registry
+                name = object.__getattribute__(obj, '_name')
+                from ..cssl_bridge import _live_objects
+                real_obj = _live_objects.get(name)
+            if real_obj is not None:
+                setattr(real_obj, member, value)
+                return
+
         if hasattr(obj, member):
             setattr(obj, member, value)
         elif isinstance(obj, dict):
             obj[member] = value
+        else:
+            # Try setattr anyway for objects that support dynamic attributes
+            try:
+                setattr(obj, member, value)
+            except (AttributeError, TypeError):
+                pass
 
     def _set_index(self, node: ASTNode, value: Any):
         """Set index value"""