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

includecpp/core/cssl/cssl_types.py

@@ -1497,12 +1497,21 @@ class ByteArrayed:
 
         return None
 
-    def _probe_functions(self) -> List[Any]:
-        """Execute referenced functions invisibly to get their return values."""
+    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
@@ -1513,26 +1522,133 @@ class ByteArrayed:
                 if func is None:
                     func = self._runtime.builtins.get_function(func_name)
 
-            # Execute the function to get its return value
+            result = None
+
             if func is not None:
                 try:
-                    if callable(func):
-                        result = func()
+                    # 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
-                        result = self._runtime._call_function(func, [])
+                        # CSSL function node - execute with args
+                        result = self._runtime._call_function(func, evaluated_args)
                     else:
                         result = func
                 except Exception:
                     result = None
-            else:
-                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):
@@ -1570,6 +1686,16 @@ class ByteArrayed:
                     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
 
@@ -1597,8 +1723,14 @@ class ByteArrayed:
         if not self._runtime:
             return None
         result = None
-        for node in body:
-            result = self._runtime._execute_node(node)
+        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:

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": [

includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json

@@ -3,6 +3,7 @@
     "name": "CSSL",
     "scopeName": "source.cssl",
     "patterns": [
+        { "include": "#cp-plugin-syntax" },
         { "include": "#super-functions" },
         { "include": "#comments" },
         { "include": "#strings" },
@@ -38,6 +39,82 @@
         { "include": "#variables" }
     ],
     "repository": {
+        "cp-plugin-syntax": {
+            "comment": "IncludeCPP Plugin File (.cp) Syntax Highlighting",
+            "patterns": [
+                {
+                    "comment": "SOURCE(file.cpp) modulename - directive keyword",
+                    "name": "meta.source-directive.cp",
+                    "match": "^\\s*(SOURCE|HEADER)\\s*\\(\\s*([^)]+)\\s*\\)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "keyword.control.directive.cp" },
+                        "2": { "name": "string.quoted.other.cp" },
+                        "3": { "name": "entity.name.namespace.cssl" }
+                    }
+                },
+                {
+                    "comment": "PUBLIC( block start",
+                    "name": "keyword.control.directive.cp",
+                    "match": "^\\s*(PUBLIC)\\s*\\("
+                },
+                {
+                    "comment": "modulename FUNC(name) - function export",
+                    "name": "meta.func-export.cp",
+                    "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*)\\s+(FUNC|TEMPLATE_FUNC)\\s*\\(\\s*([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\)",
+                    "captures": {
+                        "1": { "name": "entity.name.namespace.cssl" },
+                        "2": { "name": "keyword.control.directive.cp" },
+                        "3": { "name": "support.class.cssl" }
+                    }
+                },
+                {
+                    "comment": "modulename CLASS(Name) - class export",
+                    "name": "meta.class-export.cp",
+                    "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*)\\s+(CLASS|STRUCT)\\s*\\(\\s*([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\)",
+                    "captures": {
+                        "1": { "name": "entity.name.namespace.cssl" },
+                        "2": { "name": "keyword.control.directive.cp" },
+                        "3": { "name": "support.class.cssl" }
+                    }
+                },
+                {
+                    "comment": "METHOD(name) - method export",
+                    "name": "meta.method-export.cp",
+                    "match": "\\b(METHOD|METHOD_CONST|FIELD)\\s*\\(\\s*([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\)",
+                    "captures": {
+                        "1": { "name": "keyword.control.directive.cp" },
+                        "2": { "name": "support.class.cssl" }
+                    }
+                },
+                {
+                    "comment": "CONSTRUCTOR() - constructor export",
+                    "name": "meta.constructor-export.cp",
+                    "match": "\\b(CONSTRUCTOR)\\s*\\(([^)]*)\\)",
+                    "captures": {
+                        "1": { "name": "keyword.control.directive.cp" },
+                        "2": { "name": "storage.type.cssl" }
+                    }
+                },
+                {
+                    "comment": "DEPENDS(...) - dependency declaration",
+                    "name": "meta.depends.cp",
+                    "match": "\\b(DEPENDS)\\s*\\(([^)]*)\\)",
+                    "captures": {
+                        "1": { "name": "keyword.control.directive.cp" },
+                        "2": { "name": "entity.name.namespace.cssl" }
+                    }
+                },
+                {
+                    "comment": "TYPES(...) - template types",
+                    "name": "meta.types.cp",
+                    "match": "\\b(TYPES)\\s*\\(([^)]*)\\)",
+                    "captures": {
+                        "1": { "name": "keyword.control.directive.cp" },
+                        "2": { "name": "storage.type.cssl" }
+                    }
+                }
+            ]
+        },
         "append-operator": {
             "patterns": [
                 {
@@ -445,6 +522,16 @@
                     "name": "storage.modifier.extends.cssl",
                     "match": "\\b(extends|overwrites)\\b"
                 },
+                {
+                    "comment": "new Namespace::ClassName() - namespaced class instantiation",
+                    "name": "meta.new-expression.namespaced.cssl",
+                    "match": "\\b(new)\\s+([A-Za-z_][A-Za-z0-9_]*)::([A-Za-z_][A-Za-z0-9_]*)\\s*\\(",
+                    "captures": {
+                        "1": { "name": "keyword.operator.new.cssl" },
+                        "2": { "name": "entity.name.namespace.cssl" },
+                        "3": { "name": "support.class.cssl" }
+                    }
+                },
                 {
                     "comment": "new ClassName() - class instantiation with turquoise class name",
                     "name": "meta.new-expression.cssl",
@@ -458,6 +545,15 @@
                     "name": "keyword.operator.new.cssl",
                     "match": "\\bnew\\b"
                 },
+                {
+                    "comment": "Namespace::identifier - general namespaced access",
+                    "name": "meta.namespace-access.cssl",
+                    "match": "\\b([A-Za-z_][A-Za-z0-9_]*)::([A-Za-z_][A-Za-z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "entity.name.namespace.cssl" },
+                        "2": { "name": "support.class.cssl" }
+                    }
+                },
                 {
                     "name": "variable.language.this.cssl",
                     "match": "\\bthis\\b"

{includecpp-4.3.0.dist-info → includecpp-4.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 4.3.0
+Version: 4.5.2
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-4.3.0.dist-info → includecpp-4.5.2.dist-info}/RECORD

@@ -1,20 +1,20 @@
-includecpp/CHANGELOG.md,sha256=fLSeIacvnmG-Ea8XUnvtvMdgAWfcQW0uybkldXaxsoc,3621
+includecpp/CHANGELOG.md,sha256=zgkItpsqSDaa9oAaax88xgUHoU60ASDQuXFbKUeimi4,4909
 includecpp/DOCUMENTATION.md,sha256=MgCUZtslObxTqTLnxjME34NcGo4Z1h_C3n6gcDs82r0,7961
-includecpp/__init__.py,sha256=CIHeXGlukGABoueKCmFPIhOjubjZvOs6OG2vYJkAjPo,1672
-includecpp/__init__.pyi,sha256=gfpArSojafkBCUoACntpnPBVgKLPZHecsyJtlVhE1A0,7267
+includecpp/__init__.py,sha256=u__pqAfPtmUYuodOLlSWMtIHS5t6caaIChpY194dsAc,1672
+includecpp/__init__.pyi,sha256=Gk5f1DegO1YpKgBQ_liPWjNzJQJ0n_20pGCJ2hMnHx8,7156
 includecpp/__main__.py,sha256=d6QK0PkvUe1ENofpmHRAg3bwNbZr8PiRscfI3-WRfVg,72
 includecpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 includecpp/cli/__init__.py,sha256=Yda-4a5QJb_tKu35YQNfc5lu-LewTsM5abqNNkzS47M,113
-includecpp/cli/commands.py,sha256=vwmWCKPOI7WFC_hSBdBL3ELr7GB1lQDymoGjdRfB_uQ,372181
+includecpp/cli/commands.py,sha256=Rf-ISWe0nIpV-C1VdnwNvKV0thGwePdIpTUz19zAIfs,418783
 includecpp/cli/config_parser.py,sha256=KveeYUg2TA9sC5hKVzYYfgdNm2WfLG5y7_yxgBWn9yM,4886
 includecpp/core/__init__.py,sha256=L1bT6oikTjdto-6Px7DpjePtM07ymo3Bnov1saZzsGg,390
 includecpp/core/ai_integration.py,sha256=Q44Y1SD_4yXETO4AwtoR51QnX0T4Tc14_Ux9VozQJhQ,89146
 includecpp/core/build_manager.py,sha256=uLuYsuiC6OsOGaU5wAJfl4M3IbdnIDgogfMd8VsVpq8,102866
 includecpp/core/cpp_api.py,sha256=8y_B1L18rhSBZln654xPPzqO2PdvAlLpJrfEjzl7Wnc,14039
 includecpp/core/cpp_api.pyi,sha256=IEiaKqaPItnn6rjL7aK32D3o9FYmRYCgCZbqiQNUwdc,3496
-includecpp/core/cpp_api_extensions.pyi,sha256=Eb_QywS4qpRRsMvHCYxoeBQ8Vw0P1ffu-rwzTIpvpnE,10622
+includecpp/core/cpp_api_extensions.pyi,sha256=eqqi7A1pUGg9GTDpWLWViNFNdQZ0AG8rV0oSysynJvs,10432
 includecpp/core/cppy_converter.py,sha256=b7yqu-aoa0wShNY0GvQT67TnNhYya4GyYmG7oDdqDV4,156686
-includecpp/core/cssl_bridge.py,sha256=xYfIRagegO8irdWl97dfanRB1qLU80p9lQ2wxkttGQ4,49963
+includecpp/core/cssl_bridge.py,sha256=o8huFAOg9_OQt0opZeT2nX1CtuH-iSNnAgvFG-KWil4,51755
 includecpp/core/cssl_bridge.pyi,sha256=nreh2gtK94I6VFrzTWcYVUHN97wcYQF0dY_-HySi7yQ,28787
 includecpp/core/error_catalog.py,sha256=VS3N-P0yEbiHimsDPtcaYfrUb7mXQ-7pqw18PtSngaU,33869
 includecpp/core/error_formatter.py,sha256=7-MzRIT8cM4uODxy0IZ9pu7pqR4Pq2I8Si0QQZHjmVc,39239
@@ -24,18 +24,27 @@ includecpp/core/project_ui.py,sha256=la2EQZKmUkJGuJxnbs09hH1ZhBh9bfndo6okzZsk2dQ
 includecpp/core/settings_ui.py,sha256=B2SlwgdplF2KiBk5UYf2l8Jjifjd0F-FmBP0DPsVCEQ,11798
 includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=Ax7x6h_ZFg4rhghtSNG9dahySh-bJc2upEqP4E-mfck,43486
 includecpp/core/cssl/CSSL_DOCUMENTATION_NEW.md,sha256=I_bVeKWlbcgHYkl2o9L2vk3r5sDvG44bGh__RJIYduw,28222
-includecpp/core/cssl/__init__.py,sha256=scDXRBNK2L6A8qmlpNyaqQj6BFcSfPInBlucdeNfMF0,1975
-includecpp/core/cssl/cssl_builtins.py,sha256=1JZpOdLOJawc-ZlKwAA9Ff4BwlrCweLfG9bfMbjF6H8,114033
+includecpp/core/cssl/__init__.py,sha256=46EcmJKxziXupgqhqBRnMl5QlvUP6KA8x6JGlls_JyY,11993
+includecpp/core/cssl/cssl_builtins.py,sha256=pAm0lHzdI3DraNVGrVlZM-RfJF76rDsmKCUS1iMk7IE,118787
 includecpp/core/cssl/cssl_builtins.pyi,sha256=-yr9JbxHKFv9Vc1iufChcqCQvNQLL3-Ow_Hgg0YwQnc,135180
+includecpp/core/cssl/cssl_compiler.py,sha256=0yv8qbCm7ikC5pZXhYvAiNM5oBZmiNgVyyjrCtyjieg,14409
 includecpp/core/cssl/cssl_events.py,sha256=nupIcXW_Vjdud7zCU6hdwkQRQ0MujlPM7Tk2u7eDAiY,21013
 includecpp/core/cssl/cssl_languages.py,sha256=qftMcBiNT1pbIn5OniTZDx8rFtGYU4yx4Iw1QYKAC1U,62342
 includecpp/core/cssl/cssl_modules.py,sha256=cUg0-zdymMnWWTsA_BUrW5dx4R04dHpKcUhm-Wfiwwo,103006
-includecpp/core/cssl/cssl_parser.py,sha256=sureKmhbA1mxn21LJ_A-tRK49vrM8SvfF_X-4kEsmTg,193366
-includecpp/core/cssl/cssl_runtime.py,sha256=GmeR7hlZpAgikoeSVz7BH8w5CmmXCWfBRLl8VNrZSyk,257539
-includecpp/core/cssl/cssl_syntax.py,sha256=AcFvqCB9WKitNA32izCWf5jeFWNc6ncc-xLw0J5UjBg,20933
-includecpp/core/cssl/cssl_types.py,sha256=wLS2gj9sibklRqnqaZYQC_AsSsopJtBj8WTEmSDLo1g,67149
+includecpp/core/cssl/cssl_optimizer.py,sha256=EUWGkd-N4KeI98ENXOkIGQVmz68VE2AGOG_7cYHMsh4,28322
+includecpp/core/cssl/cssl_parser.py,sha256=hXn693e4uucYUkcPFfvSIgtz-OJL5YCxm6idJmqHTBY,212208
+includecpp/core/cssl/cssl_runtime.py,sha256=m1LdghxYhw6oolkEgvDcgHLgqH1xoDhDNcRI8cJynEo,271043
+includecpp/core/cssl/cssl_syntax.py,sha256=RLvpDymbe66eubD51dcICtDcKyJQ2qQ5IxPNp9SlhW4,21730
+includecpp/core/cssl/cssl_types.py,sha256=ZqUfDRNH1V_c0qsDbfAXz8nfkTSZ9DIlr5VTGd-udak,73090
+includecpp/core/cssl/cpp/cssl_core.cp,sha256=0ycXtd7IEIPCq11-uS-WZpD-6ShVgIqD_tMGBVnaut8,2944
+includecpp/core/cssl/cpp/cssl_lexer.hpp,sha256=ItpblJWnu2BnaAUNsmGwJEjOJPjzTCJlygvpel9MI3g,7563
+includecpp/core/cssl/cpp/build/api.pyd,sha256=Cf129k9jtZj2Df7eu8zS513nVlYDPClSiCQTFGQYdFI,4267449
+includecpp/core/cssl/cpp/build/cssl_core.pyi,sha256=pAxrzrkH9r81mbhdIx9HoEq1vbgs2B69ADuocTM303M,7228
+includecpp/core/cssl/cpp/build/libgcc_s_seh-1.dll,sha256=LeQ1VkhEHbAjCpq6GhSfyCmwlPg8FMN-o_d1NW0z2LE,150196
+includecpp/core/cssl/cpp/build/libstdc++-6.dll,sha256=Qo0iqKTSXjntrTaFESJwGzRgwrz2KIhM3SZkUw0t1jQ,2461848
+includecpp/core/cssl/cpp/build/libwinpthread-1.dll,sha256=8MSLzx8fCmW0-ZQG9W23NJ3tiGbNhlSGh6tqmOhZrzU,64403
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
-includecpp/generator/parser.cpp,sha256=KT_rrZFJi8KF6emstIW5lKOMaD5gOTC9IcrGEIuIuYw,83251
+includecpp/generator/parser.cpp,sha256=4zOlMe0VmMqlDAHhm92Ug0rx4C7WbmCkKuHPluqfIX8,84285
 includecpp/generator/parser.h,sha256=z8qHnsiY8cXAwq5JW9O-V-hCSjDQacYLgi91ViqzHSw,11405
 includecpp/generator/type_resolver.cpp,sha256=MmFK_4HXd1wqxALDiDyXVuU397SXoQL_o5zb_8N8Hzs,12346
 includecpp/generator/type_resolver.h,sha256=ZsaxQqcCcKJJApYn7KOp2dLlQ1VFVG_oZDjaK5LhBSg,2590
@@ -44,14 +53,14 @@ includecpp/vscode/__init__.py,sha256=yLKw-_7MTX1Rx3jLk5JjharJQfFXbwtZVE7YqHpM7yg
 includecpp/vscode/cssl/__init__.py,sha256=rQJAx5X05v-mAwqX1Qb-rbZO219iR73MziFNRUCNUIo,31
 includecpp/vscode/cssl/extension.js,sha256=FZaKfOpzo2jXtubVCZmnhDZd4eUVHltm5VW_fgNnSkE,4327
 includecpp/vscode/cssl/language-configuration.json,sha256=61Q00cKI9may5L8YpxMmvfo6PAc-abdJqApfR85DWuw,904
-includecpp/vscode/cssl/package.json,sha256=u5iHl79-GfeJiQ7vPe8DP5hXlOpGP41d1A54bn4Yy6M,6391
+includecpp/vscode/cssl/package.json,sha256=v0QNcE1u_F2BzHBzLy6nztZWl_OMYgoomHG-0g24S-U,6931
 includecpp/vscode/cssl/images/cssl.png,sha256=BxAGsnfS0ZzzCvqV6Zb1OAJAZpDUoXlR86MsvUGlSZw,510
 includecpp/vscode/cssl/images/cssl_pl.png,sha256=z4WMk7g6YCTbUUbSFk343BO6yi_OmNEVYkRenWGydwM,799
 includecpp/vscode/cssl/snippets/cssl.snippets.json,sha256=uV3nHJyQ5f7Pr3FzfbQT2VZOEY3AlGs4wrmqe884jm4,37372
-includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=IMDF2IqTh-jXx6x5lVfShDmJb5cRVIuJ70P30ahwkME,44674
-includecpp-4.3.0.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-4.3.0.dist-info/METADATA,sha256=9C2fO6sSgyjMy3AKk_lEU4zt4MiCEqJ9gL5cQzsUhdA,5887
-includecpp-4.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-4.3.0.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-4.3.0.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-4.3.0.dist-info/RECORD,,
+includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=DOruG97tnY-OuQqiGciXwUE9kofb1THb03kKMhUQ4-E,49505
+includecpp-4.5.2.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-4.5.2.dist-info/METADATA,sha256=j0ZykypVIRVHS0ygW41i-t1tVhgYL7Z2l6lY2ZuDVLw,5887
+includecpp-4.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-4.5.2.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-4.5.2.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-4.5.2.dist-info/RECORD,,