IncludeCPP 4.3.0__py3-none-any.whl → 4.6.0__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -199,6 +199,13 @@ class CSSLReturn(Exception):
         super().__init__()
 
 
+class CSSLThrow(Exception):
+    """Throw statement - v4.5.1: User-thrown exceptions that propagate to catch blocks"""
+    def __init__(self, message: Any = None):
+        self.message = message
+        super().__init__(str(message) if message else "")
+
+
 @dataclass
 class Scope:
     """Variable scope"""
@@ -826,21 +833,70 @@ class CSSLRuntime:
             enum Colors { RED, GREEN, BLUE }
             Colors::RED  // returns 0
             Colors::GREEN  // returns 1
+
+        v4.3.2: Support for embedded enum modification:
+            embedded __NewEnum &OldEnum { ... }       // Replace OldEnum
+            embedded __NewEnum &OldEnum ++ { ... }    // Add to OldEnum
+            embedded __NewEnum &OldEnum -- { ... }    // Remove from OldEnum
         """
         enum_info = node.value
         enum_name = enum_info.get('name')
         members = enum_info.get('members', [])
+        is_embedded = enum_info.get('is_embedded', False)
+        replace_target = enum_info.get('replace_target')
+        mode = enum_info.get('mode', 'replace')
 
         # Create enum object as a dict-like object with members
-        enum_obj = {}
+        new_values = {}
         for member in members:
             member_name = member['name']
             member_value = member['value']
-            enum_obj[member_name] = member_value
+            # Evaluate if value is an ASTNode
+            if isinstance(member_value, ASTNode):
+                member_value = self._evaluate(member_value)
+            new_values[member_name] = member_value
+
+        # v4.3.2: Handle embedded modification
+        if is_embedded and replace_target:
+            target_name = replace_target.lstrip('@') if replace_target.startswith('@') else replace_target
+
+            if mode == 'add':
+                # Get existing enum and add new values
+                existing = self.scope.get(target_name) or self.global_scope.get(target_name) or {}
+                if isinstance(existing, dict):
+                    # For add mode, auto-increment from highest existing int value
+                    max_val = -1
+                    for v in existing.values():
+                        if isinstance(v, int) and v > max_val:
+                            max_val = v
+                    # Update new values that don't have explicit values
+                    for name, val in new_values.items():
+                        if isinstance(val, int) and val <= max_val:
+                            max_val += 1
+                            new_values[name] = max_val
+                    enum_obj = {**existing, **new_values}
+                else:
+                    enum_obj = new_values
+            elif mode == 'remove':
+                # Get existing enum and remove specified keys
+                existing = self.scope.get(target_name) or self.global_scope.get(target_name) or {}
+                if isinstance(existing, dict):
+                    enum_obj = {k: v for k, v in existing.items() if k not in new_values}
+                else:
+                    enum_obj = {}
+            else:
+                # Replace mode - just use new values
+                enum_obj = new_values
 
-        # Register the enum in scope (accessible as EnumName::VALUE)
-        self.scope.set(enum_name, enum_obj)
-        self.global_scope.set(enum_name, enum_obj)
+            self.scope.set(target_name, enum_obj)
+            self.global_scope.set(target_name, enum_obj)
+            if replace_target.startswith('@'):
+                self._promoted_globals[target_name] = enum_obj
+        else:
+            # Regular enum - just register it
+            enum_obj = new_values
+            self.scope.set(enum_name, enum_obj)
+            self.global_scope.set(enum_name, enum_obj)
 
         return enum_obj
 
@@ -1346,9 +1402,34 @@ class CSSLRuntime:
 
         v4.2.6: In namespace mode (_payload_namespace_mode), track replacements
         instead of applying globally. The namespace handler will scope them.
+
+        v4.5.1: Respects 'private' modifier - private functions/methods cannot be overwritten.
         """
         from ..cssl_bridge import _live_objects, SharedObjectProxy
 
+        # v4.5.1: Check if target has 'private' modifier - prevent overwrite
+        if not ref_class.startswith('$'):
+            target_func = self.scope.get(ref_class) or self.global_scope.get(ref_class)
+            if target_func is not None:
+                # Check for function with private modifier
+                if hasattr(target_func, 'value') and isinstance(target_func.value, dict):
+                    modifiers = target_func.value.get('modifiers', [])
+                    if 'private' in modifiers:
+                        raise CSSLRuntimeError(
+                            f"Cannot overwrite private function '{ref_class}' - "
+                            f"private functions are protected from embedded replacements"
+                        )
+                # Check for class with private method
+                if ref_member and isinstance(target_func, CSSLClass):
+                    method = target_func.methods.get(ref_member) if hasattr(target_func, 'methods') else None
+                    if method and hasattr(method, 'value') and isinstance(method.value, dict):
+                        modifiers = method.value.get('modifiers', [])
+                        if 'private' in modifiers:
+                            raise CSSLRuntimeError(
+                                f"Cannot overwrite private method '{ref_class}::{ref_member}' - "
+                                f"private methods are protected from embedded replacements"
+                            )
+
         # v4.2.6: Check for namespace mode
         namespace_mode = getattr(self, '_payload_namespace_mode', None)
         if namespace_mode and ref_member is None and not ref_class.startswith('$'):
@@ -1452,9 +1533,34 @@ class CSSLRuntime:
         - &ClassName::method ++ - Append to method in CSSL class
         - &$PyObject.method ++ - Append to method in Python shared object
         - &functionName ++ - Append to standalone function
+
+        v4.5.1: Respects 'private' modifier - private functions/methods cannot be appended to.
         """
         from ..cssl_bridge import _live_objects, SharedObjectProxy
 
+        # v4.5.1: Check if target has 'private' modifier - prevent append
+        if not ref_class.startswith('$'):
+            target_func = self.scope.get(ref_class) or self.global_scope.get(ref_class)
+            if target_func is not None:
+                # Check for function with private modifier
+                if hasattr(target_func, 'value') and isinstance(target_func.value, dict):
+                    modifiers = target_func.value.get('modifiers', [])
+                    if 'private' in modifiers:
+                        raise CSSLRuntimeError(
+                            f"Cannot append to private function '{ref_class}' - "
+                            f"private functions are protected from embedded modifications"
+                        )
+                # Check for class with private method
+                if ref_member and isinstance(target_func, CSSLClass):
+                    method = target_func.methods.get(ref_member) if hasattr(target_func, 'methods') else None
+                    if method and hasattr(method, 'value') and isinstance(method.value, dict):
+                        modifiers = method.value.get('modifiers', [])
+                        if 'private' in modifiers:
+                            raise CSSLRuntimeError(
+                                f"Cannot append to private method '{ref_class}::{ref_member}' - "
+                                f"private methods are protected from embedded modifications"
+                            )
+
         # Handle Python shared objects
         if ref_class.startswith('$'):
             var_name = ref_class[1:]
@@ -2268,7 +2374,18 @@ class CSSLRuntime:
             }
         """
         params_name = node.value.get('params')
-        open_kwargs = self.scope.get('_OpenKwargs') or {}
+        # v4.3.2: Use the actual variable from switch(Variable), not just _OpenKwargs
+        # This allows switch(Input) where Input is the open parameter
+        if params_name == 'Params':
+            open_kwargs = self.scope.get('_OpenKwargs') or {}
+        else:
+            # Try to get kwargs from the named variable
+            open_kwargs = self.scope.get(params_name)
+            if open_kwargs is None:
+                open_kwargs = self.scope.get('_OpenKwargs') or {}
+            elif not isinstance(open_kwargs, dict):
+                # If it's not a dict, try _OpenKwargs as fallback
+                open_kwargs = self.scope.get('_OpenKwargs') or {}
 
         matched = False
         always_node = None
@@ -2325,25 +2442,54 @@ class CSSLRuntime:
         """Evaluate a param switch condition.
 
         Condition types:
-            {'type': 'exists', 'param': 'name'}  -> 'name' in kwargs
-            {'type': 'not', 'param': 'name'}     -> 'name' not in kwargs
+            {'type': 'exists', 'param': 'name'}  -> 'name' in kwargs OR variable 'name' is truthy
+            {'type': 'not', 'param': 'name'}     -> 'name' not in kwargs AND variable 'name' is falsy
             {'type': 'and', 'left': {...}, 'right': {...}} -> left AND right
+            {'type': 'or', 'left': {...}, 'right': {...}}  -> left OR right
+
+        v4.3.2: Added 'or' type for || operator support.
+        v4.3.2: Enhanced to check both kwargs AND scope variables (from OpenFind).
+                This allows positional args found via OpenFind<type>(index) to work
+                with param_switch conditions like 'case text & !error:'.
         """
         cond_type = condition.get('type')
 
         if cond_type == 'exists':
             param = condition.get('param')
-            return param in kwargs
+            # Check kwargs first
+            if param in kwargs:
+                return True
+            # Also check if a variable with this name exists in scope and is truthy
+            # This allows OpenFind results to work with param_switch
+            var_value = self.scope.get(param)
+            if var_value is not None and var_value != '' and var_value != 0 and var_value != False:
+                # Make sure it's not a builtin function
+                if not callable(var_value):
+                    return True
+            return False
 
         elif cond_type == 'not':
             param = condition.get('param')
-            return param not in kwargs
+            # Check kwargs first
+            if param in kwargs:
+                return False
+            # Also check if variable is truthy (then it's "provided")
+            var_value = self.scope.get(param)
+            if var_value is not None and var_value != '' and var_value != 0 and var_value != False:
+                if not callable(var_value):
+                    return False  # Variable has value, so it IS provided
+            return True  # Not in kwargs and variable is null/empty
 
         elif cond_type == 'and':
             left = self._eval_param_condition(condition.get('left'), kwargs)
             right = self._eval_param_condition(condition.get('right'), kwargs)
             return left and right
 
+        elif cond_type == 'or':
+            left = self._eval_param_condition(condition.get('left'), kwargs)
+            right = self._eval_param_condition(condition.get('right'), kwargs)
+            return left or right
+
         return False
 
     def _exec_return(self, node: ASTNode) -> Any:
@@ -2371,6 +2517,23 @@ class CSSLRuntime:
         """Execute continue statement"""
         raise CSSLContinue()
 
+    def _exec_throw(self, node: ASTNode) -> Any:
+        """Execute throw statement - v4.5.1
+
+        Throws a CSSLThrow exception that propagates to the nearest catch block.
+
+        Syntax:
+            throw "Error message";
+            throw errorVar;
+            throw;  // re-throw current exception
+        """
+        if node.value is None:
+            # throw; - re-throw current exception (should be in a catch block)
+            raise CSSLThrow("Re-thrown exception")
+
+        message = self._evaluate(node.value)
+        raise CSSLThrow(message)
+
     def _exec_constructor(self, node: ASTNode) -> Any:
         """Execute constructor node - only called when encountered directly.
 
@@ -2454,6 +2617,20 @@ class CSSLRuntime:
                 if child.type == 'try-block':
                     for stmt in child.children:
                         self._execute_node(stmt)
+        except CSSLThrow as e:
+            # v4.5.1: Handle user-thrown exceptions from throw statement
+            for child in node.children:
+                if child.type == 'catch-block':
+                    error_var = child.value.get('error_var') if child.value else None
+                    if error_var:
+                        # Store the thrown message in the error variable
+                        self.scope.set(error_var, e.message if e.message else str(e))
+                    for stmt in child.children:
+                        self._execute_node(stmt)
+                    break  # Only execute first matching catch block
+            else:
+                # No catch block found - re-raise for outer try-catch
+                raise
         except CSSLRuntimeError as e:
             for child in node.children:
                 if child.type == 'catch-block':
@@ -2462,6 +2639,9 @@ class CSSLRuntime:
                         self.scope.set(error_var, str(e))
                     for stmt in child.children:
                         self._execute_node(stmt)
+                    break
+            else:
+                raise  # Re-raise if no catch block
         except Exception as e:
             # v4.2.6: Also catch Python exceptions
             for child in node.children:
@@ -2471,6 +2651,9 @@ class CSSLRuntime:
                         self.scope.set(error_var, str(e))
                     for stmt in child.children:
                         self._execute_node(stmt)
+                    break
+            else:
+                raise  # Re-raise if no catch block
         finally:
             # v4.2.6: Execute finally block if present
             for child in node.children:
@@ -3733,6 +3916,10 @@ class CSSLRuntime:
                     elif hasattr(container, member_name):
                         return getattr(container, member_name)
 
+                # v4.3.2: Check if full name exists as builtin function (json::write, string::cut, etc.)
+                if self.builtins.has_function(name):
+                    return self.builtins.get_function(name)
+
                 # Fall through to normal lookup if container not found
                 return None
 
@@ -5066,6 +5253,33 @@ class CSSLRuntime:
         if isinstance(obj, Parameter) and member == 'return':
             member = 'return_'
 
+        # === ServiceDefinition (from include()) ===
+        if isinstance(obj, ServiceDefinition):
+            # Check functions dict first
+            if member in obj.functions:
+                func_node = obj.functions[member]
+                return lambda *args, **kwargs: self._call_function(func_node, list(args), kwargs)
+            # Check structs dict
+            if member in obj.structs:
+                return obj.structs[member]
+            # Check regular attributes
+            if hasattr(obj, member):
+                return getattr(obj, member)
+            # Build helpful error
+            available = list(obj.functions.keys()) + list(obj.structs.keys())
+            similar = _find_similar_names(member, available)
+            if similar:
+                hint = f"Did you mean: {', '.join(similar)}?"
+            elif available:
+                hint = f"Available: {', '.join(available[:10])}"
+            else:
+                hint = "No functions or structs defined in this module."
+            raise self._format_error(
+                node.line if hasattr(node, 'line') else 0,
+                f"Module has no function or struct '{member}'",
+                hint
+            )
+
         # === CSSL CLASS INSTANCE METHODS ===
         if isinstance(obj, CSSLInstance):
             # Check for member variable
@@ -5803,14 +6017,79 @@ class CSSLServiceRunner:
         return list(self.running_services.keys())
 
 
-# Convenience function
-def run_cssl(source: str, service_engine=None) -> Any:
-    """Run CSSL source code"""
+# C++ interpreter cache
+_cpp_interpreter = None
+
+
+def _get_cpp_interpreter():
+    """Get or create C++ interpreter instance."""
+    global _cpp_interpreter
+    if _cpp_interpreter is not None:
+        return _cpp_interpreter
+
+    try:
+        from . import _CPP_AVAILABLE, _cpp_module
+        if _CPP_AVAILABLE and _cpp_module and hasattr(_cpp_module, 'Interpreter'):
+            _cpp_interpreter = _cpp_module.Interpreter()
+            return _cpp_interpreter
+    except Exception:
+        pass
+    return None
+
+
+def run_cssl(source: str, service_engine=None, force_python: bool = False) -> Any:
+    """Run CSSL source code.
+
+    Uses C++ interpreter for maximum performance when available.
+    Falls back to Python interpreter for unsupported features.
+
+    Args:
+        source: CSSL source code
+        service_engine: Optional service engine for external integrations
+        force_python: Force Python interpreter (for debugging)
+
+    Returns:
+        Execution result
+    """
+    # Try C++ interpreter first (10-20x faster)
+    if not force_python:
+        cpp_interp = _get_cpp_interpreter()
+        if cpp_interp:
+            try:
+                return cpp_interp.run_string(source)
+            except Exception as e:
+                # C++ doesn't support this feature, fall back to Python
+                error_msg = str(e).lower()
+                # Only fall back for unsupported features, not syntax errors
+                if 'unsupported' in error_msg or 'not implemented' in error_msg:
+                    pass  # Fall through to Python
+                else:
+                    # Re-raise actual errors
+                    raise CSSLRuntimeError(str(e))
+
+    # Python fallback (full feature support)
     runtime = CSSLRuntime(service_engine)
     return runtime.execute(source)
 
 
-def run_cssl_file(filepath: str, service_engine=None) -> Any:
-    """Run a CSSL file"""
+def run_cssl_file(filepath: str, service_engine=None, force_python: bool = False) -> Any:
+    """Run a CSSL file.
+
+    Uses C++ interpreter for maximum performance when available.
+    """
+    # Try C++ interpreter first
+    if not force_python:
+        cpp_interp = _get_cpp_interpreter()
+        if cpp_interp:
+            try:
+                return cpp_interp.run(filepath)
+            except Exception as e:
+                error_msg = str(e).lower()
+                if 'unsupported' in error_msg or 'not implemented' in error_msg:
+                    pass  # Fall through to Python
+                else:
+                    raise CSSLRuntimeError(str(e))
+
+    # Python fallback
     runtime = CSSLRuntime(service_engine)
     return runtime.execute_file(filepath)

includecpp/core/cssl/cssl_syntax.py

@@ -36,6 +36,8 @@ class TokenCategory(Enum):
     LIBINCLUDE_KW = auto()    # libinclude (yellow/gold)
     LANG_PREFIX = auto()      # Language prefix before $ (cyan): cpp$, py$, java$
     LANG_INSTANCE = auto()    # Instance name after $ (orange): cpp$ClassName
+    # v4.6.0: C++ execution control
+    NATIVE_KW = auto()        # native keyword (cyan/bright) - forces C++ execution
 
 
 @dataclass
@@ -65,6 +67,9 @@ KEYWORDS = {
 # v4.1.0: Multi-language keywords with special highlighting
 MULTI_LANG_KEYWORDS = {'supports', 'libinclude'}
 
+# v4.6.0: C++ execution control keyword
+NATIVE_KEYWORD = {'native'}  # Forces C++ execution (no Python fallback)
+
 # v4.1.0: Language identifiers for cross-language instance access
 LANGUAGE_IDS = {'cpp', 'py', 'python', 'java', 'csharp', 'js', 'javascript'}
 
@@ -171,6 +176,12 @@ class CSSLSyntaxRules:
             category=TokenCategory.LIBINCLUDE_KW
         ))
 
+        # v4.6.0: 'native' keyword (cyan/bright) - forces C++ execution
+        rules.append(HighlightRule(
+            pattern=r'\bnative\b',
+            category=TokenCategory.NATIVE_KW
+        ))
+
         # v4.1.0: Language$Instance patterns (cpp$ClassName, py$Object)
         # Match language prefix before $ (cyan)
         rules.append(HighlightRule(
@@ -278,6 +289,8 @@ class ColorScheme:
         TokenCategory.LIBINCLUDE_KW: '#f1fa8c',# Yellow/Gold for 'libinclude'
         TokenCategory.LANG_PREFIX: '#8be9fd',  # Cyan for language prefix (cpp$)
         TokenCategory.LANG_INSTANCE: '#ffb86c',# Orange for instance name ($ClassName)
+        # v4.6.0: C++ execution control
+        TokenCategory.NATIVE_KW: '#50fa7b',    # Green/Cyan for 'native' (C++ forced)
     }
 
     # Light theme variant
@@ -302,6 +315,8 @@ class ColorScheme:
         TokenCategory.LIBINCLUDE_KW: '#b8860b',# DarkGoldenrod for 'libinclude'
         TokenCategory.LANG_PREFIX: '#0d6efd',  # Blue for language prefix (cpp$)
         TokenCategory.LANG_INSTANCE: '#fd7e14',# Orange for instance name ($ClassName)
+        # v4.6.0: C++ execution control
+        TokenCategory.NATIVE_KW: '#198754',    # Green for 'native' (C++ forced)
     }
 
 
@@ -389,6 +404,8 @@ def highlight_cssl_ansi(source: str) -> str:
         TokenCategory.LIBINCLUDE_KW: '\033[93m',# Yellow for 'libinclude'
         TokenCategory.LANG_PREFIX: '\033[96m',  # Cyan for language prefix (cpp$)
         TokenCategory.LANG_INSTANCE: '\033[33m',# Orange/Yellow for instance name
+        # v4.6.0: C++ execution control
+        TokenCategory.NATIVE_KW: '\033[92m',    # Bright Green for 'native'
     }
     RESET = '\033[0m'