IncludeCPP 4.2.2__py3-none-any.whl → 4.5.2__py3-none-any.whl

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'
 

includecpp/core/cssl/cssl_types.py

@@ -1443,6 +1443,327 @@ def create_map(key_type: str = 'dynamic', value_type: str = 'dynamic') -> Map:
     return Map(key_type, value_type)
 
 
+class ByteArrayed:
+    """Function-to-byte mapping with pattern matching (v4.2.5).
+
+    Maps function references to byte positions and executes pattern matching
+    based on function return values.
+
+    Usage:
+        bytearrayed MyBytes {
+            &func1;              // Position 0x0
+            &func2;              // Position 0x1
+            case {0, 1} {        // Match when func1=0, func2=1
+                printl("Match!");
+            }
+            default {
+                printl("No match");
+            }
+        }
+
+        MyBytes();           // Execute pattern matching
+        x = MyBytes["0x0"];  // Get value at position 0
+        x = MyBytes[0];      // Get value at position 0
+    """
+
+    def __init__(self, name: str, func_refs: List[Dict], cases: List[Dict],
+                 default_block: Any = None, runtime: Any = None):
+        self.name = name
+        self.func_refs = func_refs  # [{position, hex_pos, func_ref}, ...]
+        self.cases = cases          # [{pattern, body}, ...]
+        self.default_block = default_block
+        self._runtime = runtime
+        self._cached_values: Dict[int, Any] = {}  # Cached return values
+
+    def __call__(self, *args, **kwargs) -> Any:
+        """Execute pattern matching - probe functions and match cases.
+
+        Functions are executed "invisibly" (side-effect free where possible)
+        to get their current return values, then patterns are matched.
+        """
+        # Get current return values from all referenced functions
+        values = self._probe_functions()
+
+        # Try to match each case pattern
+        for case in self.cases:
+            pattern = case['pattern']
+            body = case['body']
+            if self._match_pattern(pattern, values):
+                return self._execute_body(body)
+
+        # No case matched - execute default if present
+        if self.default_block:
+            return self._execute_body(self.default_block)
+
+        return None
+
+    def _probe_functions(self, simulate: bool = True) -> List[Any]:
+        """Probe referenced functions to get their return values.
+
+        v4.3.2: When simulate=True, analyzes function return statements without
+        full execution. This is more precise for pattern matching.
+
+        Args:
+            simulate: If True, analyze return values without executing.
+                     If False, execute functions to get actual return values.
+        """
+        values = []
+        for ref in self.func_refs:
+            func_name = ref['func_ref']
+            position = ref['position']
+            func_args = ref.get('args', [])  # v4.3.2: Support function arguments
+
+            # Look up the function in runtime scope
+            func = None
+            if self._runtime:
+                func = self._runtime.scope.get(func_name)
+                if func is None:
+                    func = self._runtime.global_scope.get(func_name)
+                if func is None:
+                    func = self._runtime.builtins.get_function(func_name)
+
+            result = None
+
+            if func is not None:
+                try:
+                    # v4.3.2: Evaluate arguments if present
+                    evaluated_args = []
+                    for arg in func_args:
+                        if hasattr(arg, 'type'):
+                            evaluated_args.append(self._runtime._evaluate(arg))
+                        else:
+                            evaluated_args.append(arg)
+
+                    if simulate and hasattr(func, 'type') and func.type == 'function':
+                        # v4.3.2: Simulate - analyze return statements without full execution
+                        result = self._simulate_function_return(func, evaluated_args)
+                    elif callable(func):
+                        result = func(*evaluated_args) if evaluated_args else func()
+                    elif hasattr(func, 'type') and func.type == 'function':
+                        # CSSL function node - execute with args
+                        result = self._runtime._call_function(func, evaluated_args)
+                    else:
+                        result = func
+                except Exception:
+                    result = None
+
+            values.append(result)
+            self._cached_values[position] = result
+
+        return values
+
+    def _simulate_function_return(self, func_node, args: List[Any] = None) -> Any:
+        """Simulate a function and extract its return value without full execution.
+
+        v4.3.2: Analyzes the function's return statements and evaluates them
+        in isolation to get precise return values for pattern matching.
+        """
+        if not self._runtime or not func_node:
+            return None
+
+        # Create a temporary scope with function parameters bound to args
+        func_info = func_node.value
+        params = func_info.get('params', [])
+        args = args or []
+
+        # Bind parameters to arguments in a temporary scope
+        old_scope = self._runtime.scope
+        # v4.3.2: Create child scope manually (Scope is a dataclass)
+        from includecpp.core.cssl.cssl_runtime import Scope
+        self._runtime.scope = Scope(variables={}, parent=old_scope)
+
+        try:
+            # Bind parameters
+            for i, param in enumerate(params):
+                if isinstance(param, dict):
+                    param_name = param.get('name')
+                    default_value = param.get('default')
+                    if i < len(args):
+                        self._runtime.scope.set(param_name, args[i])
+                    elif default_value is not None:
+                        val = self._runtime._evaluate(default_value) if hasattr(default_value, 'type') else default_value
+                        self._runtime.scope.set(param_name, val)
+                else:
+                    if i < len(args):
+                        self._runtime.scope.set(param, args[i])
+
+            # Find and evaluate the first return statement
+            for child in func_node.children:
+                ret_val = self._extract_return_value(child)
+                if ret_val is not None:
+                    return ret_val
+
+            return None
+        finally:
+            # Restore original scope
+            self._runtime.scope = old_scope
+
+    def _extract_return_value(self, node) -> Any:
+        """Extract return value from a node, handling conditionals and blocks.
+
+        v4.3.2: Properly evaluates if/else conditions to find the correct return path.
+        """
+        if not hasattr(node, 'type'):
+            return None
+
+        if node.type == 'return':
+            # Found a return - evaluate it
+            if node.value is None:
+                return None
+            if isinstance(node.value, dict) and node.value.get('multiple'):
+                # Multiple return values (shuffled)
+                return tuple(
+                    self._runtime._evaluate(v) for v in node.value.get('values', [])
+                )
+            return self._runtime._evaluate(node.value)
+
+        # v4.3.2: Handle if statements by evaluating condition
+        if node.type == 'if':
+            condition = node.value.get('condition')
+            if condition:
+                # Evaluate the condition
+                cond_result = self._runtime._evaluate(condition)
+                if cond_result:
+                    # Condition is true - check children (then block)
+                    if node.children:
+                        for child in node.children:
+                            ret_val = self._extract_return_value(child)
+                            if ret_val is not None:
+                                return ret_val
+                else:
+                    # Condition is false - check else_block if present
+                    else_block = node.value.get('else_block')
+                    if else_block:
+                        for child in else_block:
+                            ret_val = self._extract_return_value(child)
+                            if ret_val is not None:
+                                return ret_val
+            return None
+
+        # Check children for returns
+        if hasattr(node, 'children') and node.children:
+            for child in node.children:
+                ret_val = self._extract_return_value(child)
+                if ret_val is not None:
+                    return ret_val
+
+        return None
+
+    def _match_pattern(self, pattern: List[Dict], values: List[Any]) -> bool:
+        """Check if pattern matches the current values."""
+        for i, p in enumerate(pattern):
+            if i >= len(values):
+                return False
+
+            p_type = p.get('type')
+            value = values[i]
+
+            if p_type == 'wildcard':
+                # _ matches anything
+                continue
+            elif p_type == 'value':
+                # Exact value match
+                if value != p.get('value'):
+                    return False
+            elif p_type == 'indexed':
+                # Match at specific index
+                idx = p.get('index')
+                if isinstance(idx, str) and idx.startswith('0x'):
+                    idx = int(idx, 16)
+                if idx < len(values):
+                    if values[idx] != self._runtime._evaluate(p.get('value')) if hasattr(p.get('value'), 'type') else p.get('value'):
+                        return False
+            elif p_type == 'type_match':
+                # Match by type
+                type_name = p.get('type_name')
+                if not self._check_type(value, type_name):
+                    return False
+            elif p_type == 'variable':
+                # Match against variable value
+                var_name = p.get('name')
+                var_value = self._runtime.scope.get(var_name)
+                if var_value is None:
+                    var_value = self._runtime.global_scope.get(var_name)
+                if value != var_value:
+                    return False
+            elif p_type == 'list':
+                # v4.3.2: Match against list value: ["read", "write"]
+                pattern_list = p.get('values', [])
+                if not isinstance(value, (list, tuple)):
+                    return False
+                if len(value) != len(pattern_list):
+                    return False
+                for j, pval in enumerate(pattern_list):
+                    if value[j] != pval:
+                        return False
+
+        return True
+
+    def _check_type(self, value: Any, type_name: str) -> bool:
+        """Check if value matches the specified type."""
+        type_checks = {
+            'int': lambda v: isinstance(v, int) and not isinstance(v, bool),
+            'float': lambda v: isinstance(v, float),
+            'string': lambda v: isinstance(v, str),
+            'bool': lambda v: isinstance(v, bool),
+            'list': lambda v: isinstance(v, list),
+            'dict': lambda v: isinstance(v, dict),
+            'dynamic': lambda v: True,
+        }
+        if type_name in type_checks:
+            return type_checks[type_name](value)
+        # Check for generic types like vector<string>
+        if '<' in type_name:
+            base = type_name.split('<')[0]
+            return isinstance(value, (list, tuple, set))
+        return True
+
+    def _execute_body(self, body: List) -> Any:
+        """Execute a case body block."""
+        if not self._runtime:
+            return None
+        result = None
+        try:
+            for node in body:
+                result = self._runtime._execute_node(node)
+        except Exception as e:
+            # v4.3.2: Catch CSSLReturn exception by name to handle return statements
+            if type(e).__name__ == 'CSSLReturn':
+                return e.value
+            raise
+        return result
+
+    def __getitem__(self, key: Union[int, str]) -> Any:
+        """Access byte value by index or hex position.
+
+        MyBytes[0]      - Get value at position 0
+        MyBytes["0x0"]  - Get value at position 0
+        """
+        if isinstance(key, str):
+            if key.startswith('0x') or key.startswith('0X'):
+                key = int(key, 16)
+            elif key.isdigit():
+                key = int(key)
+            else:
+                raise KeyError(f"Invalid bytearrayed key: {key}")
+
+        if key in self._cached_values:
+            return self._cached_values[key]
+
+        # Probe functions to get values if not cached
+        if not self._cached_values:
+            self._probe_functions()
+
+        return self._cached_values.get(key)
+
+    def __len__(self) -> int:
+        """Return number of byte positions."""
+        return len(self.func_refs)
+
+    def __repr__(self) -> str:
+        return f"ByteArrayed({self.name}, positions={len(self.func_refs)})"
+
+
 class CSSLClass:
     """Represents a CSSL class definition.
 

includecpp/core/cssl_bridge.py

@@ -410,6 +410,7 @@ class CsslLang:
         Execute CSSL code or file.
 
         This is the primary method for running CSSL code in v3.8.0+.
+        Uses C++ acceleration when available (375x+ faster).
 
         Args:
             path_or_code: Path to .cssl file or CSSL code string
@@ -425,22 +426,44 @@ class CsslLang:
                 printl("Hello " + parameter.get(0));
             ''', "World")
         """
-        runtime = self._get_runtime()
-
         # Check if it's a file path (not code)
         # Code detection: contains newlines, semicolons, or braces = definitely code
         is_likely_code = '\n' in path_or_code or ';' in path_or_code or '{' in path_or_code
         source = path_or_code
+        is_file = False
+        file_path = None
 
         if not is_likely_code:
             try:
                 path = Path(path_or_code)
                 if path.exists() and path.suffix in ('.cssl', '.cssl-mod', '.cssl-pl'):
+                    is_file = True
+                    file_path = str(path.absolute())
                     source = path.read_text(encoding='utf-8')
             except OSError:
                 # Path too long or invalid - treat as code
                 pass
 
+        # Try C++ accelerated execution first (375x faster)
+        # Only use C++ for simple scripts without parameter passing
+        if not args:
+            try:
+                from .cssl import run_cssl, run_cssl_file
+                if is_file and file_path:
+                    return run_cssl_file(file_path)
+                else:
+                    return run_cssl(source)
+            except Exception as cpp_error:
+                # Fall back to Python for unsupported features
+                error_msg = str(cpp_error).lower()
+                if 'unsupported' not in error_msg and 'not implemented' not in error_msg:
+                    # Real error - re-raise it
+                    raise RuntimeError(str(cpp_error)) from cpp_error
+                # Otherwise fall through to Python
+
+        # Python execution (for scripts with args or when C++ fails)
+        runtime = self._get_runtime()
+
         # Set arguments in runtime scope
         from .cssl import Parameter
         param = Parameter(list(args))
@@ -459,6 +482,17 @@ class CsslLang:
                 return returns[0] if len(returns) == 1 else returns
 
             return result
+        except UnicodeEncodeError as e:
+            # v4.3.2: Catch unicode/emoji encoding errors and provide helpful message
+            char = e.object[e.start:e.end] if hasattr(e, 'object') else '?'
+            error_msg = (
+                f"Unicode encoding error: Character '{char}' cannot be displayed.\n"
+                f"  The console encoding ({e.encoding}) doesn't support this character.\n\n"
+                f"  Hint: Use encode() to safely handle emojis/unicode:\n"
+                f"    printl(\"Status: \" + encode(\"{char}\"));\n"
+                f"    printl(encode(\"Your text with emojis\", \"[emoji]\"));"
+            )
+            raise RuntimeError(error_msg) from e
         except Exception as e:
             # Format error message nicely - don't add prefixes, let CLI handle that
             error_msg = str(e)

includecpp/generator/parser.cpp

@@ -992,19 +992,32 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
             code << "        })\n";
 
             // Auto-generate from_dict() static method
-            code << "        .def_static(\"from_dict\", [](py::dict d) {\n";
-            code << "            " << cpp_type << " obj;\n";
+            // v4.3.2: Check if all fields have known types (not "auto")
+            bool template_all_types_known = true;
             for (const auto& [field_type, field_name] : sb.fields) {
                 std::string actual_type = field_type;
-                if (actual_type == "T") {
-                    actual_type = ttype;
+                if (actual_type == "T") actual_type = ttype;
+                if (actual_type == "auto" || actual_type.empty()) {
+                    template_all_types_known = false;
+                    break;
                 }
+            }
 
-                code << "            obj." << field_name << " = d[\"" << field_name
-                     << "\"].cast<" << actual_type << ">();\n";
+            if (template_all_types_known && !sb.fields.empty()) {
+                code << "        .def_static(\"from_dict\", [](py::dict d) {\n";
+                code << "            " << cpp_type << " obj;\n";
+                for (const auto& [field_type, field_name] : sb.fields) {
+                    std::string actual_type = field_type;
+                    if (actual_type == "T") {
+                        actual_type = ttype;
+                    }
+
+                    code << "            obj." << field_name << " = d[\"" << field_name
+                         << "\"].cast<" << actual_type << ">();\n";
+                }
+                code << "            return obj;\n";
+                code << "        })\n";
             }
-            code << "            return obj;\n";
-            code << "        })\n";
 
             // v2.8: Add __repr__ for better debugging output
             code << "        .def(\"__repr__\", [](" << cpp_type << "& self) {\n";
@@ -1052,14 +1065,25 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
         code << "        })\n";
 
         // Auto-generate from_dict() static method
-        code << "        .def_static(\"from_dict\", [](py::dict d) {\n";
-        code << "            " << sb.struct_name << " obj;\n";
+        // v4.3.2: Check if all fields have known types (not "auto")
+        bool all_types_known = true;
         for (const auto& [field_type, field_name] : sb.fields) {
-            code << "            obj." << field_name << " = d[\"" << field_name
-                 << "\"].cast<" << field_type << ">();\n";
+            if (field_type == "auto" || field_type.empty()) {
+                all_types_known = false;
+                break;
+            }
+        }
+
+        if (all_types_known && !sb.fields.empty()) {
+            code << "        .def_static(\"from_dict\", [](py::dict d) {\n";
+            code << "            " << sb.struct_name << " obj;\n";
+            for (const auto& [field_type, field_name] : sb.fields) {
+                code << "            obj." << field_name << " = d[\"" << field_name
+                     << "\"].cast<" << field_type << ">();\n";
+            }
+            code << "            return obj;\n";
+            code << "        })\n";
         }
-        code << "            return obj;\n";
-        code << "        })\n";
 
         // v2.8: Add __repr__ for better debugging output
         code << "        .def(\"__repr__\", [](" << sb.struct_name << "& self) {\n";

includecpp/vscode/cssl/package.json

@@ -56,6 +56,16 @@
                     "light": "./images/cssl_pl.png",
                     "dark": "./images/cssl_pl.png"
                 }
+            },
+            {
+                "id": "cp",
+                "aliases": ["IncludeCPP Plugin", "cp"],
+                "extensions": [".cp"],
+                "configuration": "./language-configuration.json",
+                "icon": {
+                    "light": "./images/cssl.png",
+                    "dark": "./images/cssl.png"
+                }
             }
         ],
         "grammars": [
@@ -73,6 +83,11 @@
                 "language": "cssl-pl",
                 "scopeName": "source.cssl",
                 "path": "./syntaxes/cssl.tmLanguage.json"
+            },
+            {
+                "language": "cp",
+                "scopeName": "source.cssl",
+                "path": "./syntaxes/cssl.tmLanguage.json"
             }
         ],
         "snippets": [