IncludeCPP 4.0.3__py3-none-any.whl → 4.2.1__py3-none-any.whl

includecpp/core/cssl/cssl_syntax.py

@@ -31,6 +31,11 @@ class TokenCategory(Enum):
     NULL = auto()             # null, None
     PACKAGE_KW = auto()       # package, package-includes - NEW
     TYPE_LITERAL = auto()     # list, dict - NEW
+    # v4.1.0: Multi-language support
+    SUPPORTS_KW = auto()      # supports keyword (magenta)
+    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
 
 
 @dataclass
@@ -52,9 +57,17 @@ KEYWORDS = {
     'start', 'stop', 'wait_for', 'on_event', 'emit_event',
     'await',
     # NEW: Extended keywords
-    'package', 'package-includes', 'exec', 'as', 'global'
+    'package', 'package-includes', 'exec', 'as', 'global',
+    # v4.1.0: Multi-language support (handled separately for special colors)
+    # 'supports', 'libinclude' - see MULTI_LANG_KEYWORDS
 }
 
+# v4.1.0: Multi-language keywords with special highlighting
+MULTI_LANG_KEYWORDS = {'supports', 'libinclude'}
+
+# v4.1.0: Language identifiers for cross-language instance access
+LANGUAGE_IDS = {'cpp', 'py', 'python', 'java', 'csharp', 'js', 'javascript'}
+
 # NEW: Package-related keywords for special highlighting
 PACKAGE_KEYWORDS = {'package', 'package-includes'}
 
@@ -145,6 +158,33 @@ class CSSLSyntaxRules:
             category=TokenCategory.TYPE_LITERAL
         ))
 
+        # v4.1.0: Multi-language support keywords
+        # 'supports' keyword (magenta) - must be before regular keywords
+        rules.append(HighlightRule(
+            pattern=r'\bsupports\b',
+            category=TokenCategory.SUPPORTS_KW
+        ))
+
+        # 'libinclude' keyword (yellow/gold)
+        rules.append(HighlightRule(
+            pattern=r'\blibinclude\b',
+            category=TokenCategory.LIBINCLUDE_KW
+        ))
+
+        # v4.1.0: Language$Instance patterns (cpp$ClassName, py$Object)
+        # Match language prefix before $ (cyan)
+        rules.append(HighlightRule(
+            pattern=r'\b(cpp|py|python|java|csharp|js|javascript)\$',
+            category=TokenCategory.LANG_PREFIX,
+            group=1
+        ))
+        # Match instance name after $ (orange)
+        rules.append(HighlightRule(
+            pattern=r'\b(?:cpp|py|python|java|csharp|js|javascript)\$([A-Za-z_][A-Za-z0-9_]*)',
+            category=TokenCategory.LANG_INSTANCE,
+            group=1
+        ))
+
         # Self-references (s@Name, s@Backend.Loop)
         rules.append(HighlightRule(
             pattern=r's@[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*',
@@ -233,6 +273,11 @@ class ColorScheme:
         TokenCategory.NULL: '#ff6464',         # Red
         TokenCategory.PACKAGE_KW: '#bd93f9',   # Purple for package - NEW
         TokenCategory.TYPE_LITERAL: '#8be9fd', # Cyan for type literals - NEW
+        # v4.1.0: Multi-language support colors
+        TokenCategory.SUPPORTS_KW: '#ff79c6',  # Magenta/Pink for 'supports'
+        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)
     }
 
     # Light theme variant
@@ -252,6 +297,11 @@ class ColorScheme:
         TokenCategory.NULL: '#ff0000',         # Red
         TokenCategory.PACKAGE_KW: '#8b008b',   # DarkMagenta for package - NEW
         TokenCategory.TYPE_LITERAL: '#008b8b', # Dark cyan for type literals - NEW
+        # v4.1.0: Multi-language support colors
+        TokenCategory.SUPPORTS_KW: '#d63384',  # Dark Magenta for 'supports'
+        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)
     }
 
 
@@ -334,6 +384,11 @@ def highlight_cssl_ansi(source: str) -> str:
         TokenCategory.NULL: '\033[91m',         # Red
         TokenCategory.PACKAGE_KW: '\033[95m',   # Magenta for package - NEW
         TokenCategory.TYPE_LITERAL: '\033[96m', # Cyan for type literals - NEW
+        # v4.1.0: Multi-language support colors
+        TokenCategory.SUPPORTS_KW: '\033[95m',  # Magenta for 'supports'
+        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
     }
     RESET = '\033[0m'
 
@@ -439,6 +494,10 @@ def export_textmate_grammar() -> dict:
                 "name": "comment.line.cssl",
                 "match": "#.*$"
             },
+            {
+                "name": "comment.line.double-slash.cssl",
+                "match": "//.*$"
+            },
             {
                 "name": "string.quoted.double.cssl",
                 "match": '"(?:[^"\\\\]|\\\\.)*"'
@@ -447,6 +506,23 @@ def export_textmate_grammar() -> dict:
                 "name": "string.quoted.single.cssl",
                 "match": "'(?:[^'\\\\]|\\\\.)*'"
             },
+            # v4.1.0: Multi-language support
+            {
+                "name": "keyword.control.supports.cssl",
+                "match": "\\bsupports\\b"
+            },
+            {
+                "name": "support.function.libinclude.cssl",
+                "match": "\\blibinclude\\b"
+            },
+            {
+                "name": "variable.language.lang-instance.cssl",
+                "match": "\\b(cpp|py|python|java|csharp|js|javascript)\\$([A-Za-z_][A-Za-z0-9_]*)",
+                "captures": {
+                    "1": {"name": "entity.name.type.language.cssl"},
+                    "2": {"name": "variable.other.instance.cssl"}
+                }
+            },
             {
                 "name": "variable.other.self-reference.cssl",
                 "match": "s@[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*"
@@ -455,9 +531,13 @@ def export_textmate_grammar() -> dict:
                 "name": "variable.other.module-reference.cssl",
                 "match": "@[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*"
             },
+            {
+                "name": "keyword.other.package.cssl",
+                "match": "\\b(package|package-includes)\\b"
+            },
             {
                 "name": "keyword.control.cssl",
-                "match": "\\b(service-init|service-run|service-include|struct|define|if|else|elif|while|for|foreach|in|switch|case|default|break|continue|return|try|catch|await)\\b"
+                "match": "\\b(service-init|service-run|service-include|struct|define|class|constr|if|else|elif|while|for|foreach|in|switch|case|default|break|continue|return|try|catch|finally|throw|await|extends|overwrites|global|as|exec)\\b"
             },
             {
                 "name": "keyword.operator.cssl",
@@ -465,7 +545,7 @@ def export_textmate_grammar() -> dict:
             },
             {
                 "name": "constant.language.cssl",
-                "match": "\\b(True|False|true|false|null|None)\\b"
+                "match": "\\b(True|False|true|false|null|None|none)\\b"
             },
             {
                 "name": "constant.numeric.cssl",
@@ -473,7 +553,11 @@ def export_textmate_grammar() -> dict:
             },
             {
                 "name": "keyword.operator.assignment.cssl",
-                "match": "<==|==>|->|<-"
+                "match": "<==|==>|->|<-|::"
+            },
+            {
+                "name": "support.type.cssl",
+                "match": "\\b(list|dict)\\b(?!\\s*\\()"
             }
         ]
     }

includecpp/core/cssl/cssl_types.py

@@ -1648,6 +1648,7 @@ class UniversalInstance:
         self._members: Dict[str, Any] = {}
         self._methods: Dict[str, Any] = {}  # Method name -> AST node or callable
         self._injections: List[Any] = []  # Code blocks injected via +<<==
+        self._runtime = None  # Weak reference to CSSL runtime for method calls
         # Register globally
         UniversalInstance._registry[name] = self
 
@@ -1707,9 +1708,16 @@ class UniversalInstance:
         """Check if member exists."""
         return name in self._members
 
-    def set_method(self, name: str, method: Any) -> None:
+    def set_runtime(self, runtime: Any) -> None:
+        """Set the runtime reference for method calls from Python."""
+        import weakref
+        self._runtime = weakref.ref(runtime)
+
+    def set_method(self, name: str, method: Any, runtime: Any = None) -> None:
         """Set a method (AST node or callable)."""
         self._methods[name] = method
+        if runtime is not None and self._runtime is None:
+            self.set_runtime(runtime)
 
     def get_method(self, name: str) -> Any:
         """Get a method by name."""
@@ -1744,7 +1752,28 @@ class UniversalInstance:
         if name in object.__getattribute__(self, '_members'):
             return object.__getattribute__(self, '_members')[name]
         if name in object.__getattribute__(self, '_methods'):
-            return object.__getattribute__(self, '_methods')[name]
+            method = object.__getattribute__(self, '_methods')[name]
+            runtime_ref = object.__getattribute__(self, '_runtime')
+
+            # If method is an AST node and we have a runtime, create a callable wrapper
+            if hasattr(method, 'type') and method.type == 'function' and runtime_ref is not None:
+                runtime = runtime_ref()  # Dereference weakref
+                if runtime is not None:
+                    instance = self
+                    def method_caller(*args, **kwargs):
+                        # Set 'this' context and call the method
+                        old_this = runtime.scope.get('this')
+                        runtime.scope.set('this', instance)
+                        try:
+                            return runtime._call_function(method, list(args))
+                        finally:
+                            if old_this is not None:
+                                runtime.scope.set('this', old_this)
+                            elif hasattr(runtime.scope, 'remove'):
+                                runtime.scope.remove('this')
+                    return method_caller
+            # Return method directly if already callable or no runtime
+            return method
         raise AttributeError(f"Instance '{object.__getattribute__(self, '_name')}' has no attribute '{name}'")
 
     def __setattr__(self, name: str, value: Any) -> None:

includecpp/generator/parser.cpp

@@ -599,13 +599,81 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
                             }
                         }
 
-                        // Parse FIELD(type, name) entries
+                        // v4.1.1: Parse CONSTRUCTOR, METHOD, and FIELD entries for STRUCT
                         auto field_lines = split(field_block, '\n');
                         for (const auto& fline : field_lines) {
                             std::string ftrim = trim(fline);
                             if (ftrim.empty()) continue;
 
-                            if (ftrim.find("FIELD(") != std::string::npos) {
+                            // v4.1.1: Parse CONSTRUCTOR(type1, type2, ...) for parametrized constructors
+                            if (ftrim.find("CONSTRUCTOR") != std::string::npos) {
+                                size_t c_start = ftrim.find('(');
+                                size_t c_end = ftrim.rfind(')');
+                                if (c_start != std::string::npos && c_end != std::string::npos) {
+                                    std::string params_str = ftrim.substr(c_start + 1, c_end - c_start - 1);
+                                    ConstructorInfo ctor;
+                                    if (!params_str.empty()) {
+                                        auto params = split(params_str, ',');
+                                        for (auto& p : params) {
+                                            std::string param_type = trim(p);
+                                            if (!param_type.empty()) {
+                                                ctor.param_types.push_back(param_type);
+                                            }
+                                        }
+                                    }
+                                    sb.constructors.push_back(ctor);
+                                }
+                            }
+                            // v4.1.1: Parse METHOD and METHOD_CONST for STRUCT
+                            else if (ftrim.find("METHOD") != std::string::npos) {
+                                MethodSignature sig;
+                                bool is_const_method = ftrim.find("METHOD_CONST") != std::string::npos;
+
+                                size_t m_start = ftrim.find('(');
+                                size_t m_end = ftrim.rfind(')');
+
+                                if (m_start != std::string::npos && m_end != std::string::npos) {
+                                    std::string content = ftrim.substr(m_start + 1, m_end - m_start - 1);
+
+                                    // Parse method name and optional parameter types
+                                    std::vector<std::string> parts;
+                                    int template_depth = 0;
+                                    std::string current_part;
+
+                                    for (char c : content) {
+                                        if (c == '<') {
+                                            template_depth++;
+                                            current_part += c;
+                                        } else if (c == '>') {
+                                            template_depth--;
+                                            current_part += c;
+                                        } else if (c == ',' && template_depth == 0) {
+                                            parts.push_back(trim(current_part));
+                                            current_part.clear();
+                                        } else {
+                                            current_part += c;
+                                        }
+                                    }
+                                    if (!current_part.empty()) {
+                                        parts.push_back(trim(current_part));
+                                    }
+
+                                    if (!parts.empty()) {
+                                        sig.name = parts[0];
+                                        sig.is_const = is_const_method;
+
+                                        // Remaining parts are parameter types
+                                        for (size_t k = 1; k < parts.size(); ++k) {
+                                            sig.param_types.push_back(parts[k]);
+                                        }
+
+                                        sb.method_signatures.push_back(sig);
+                                        sb.methods.push_back(sig.name);
+                                    }
+                                }
+                            }
+                            // Parse FIELD(name) or FIELD(type, name)
+                            else if (ftrim.find("FIELD(") != std::string::npos) {
                                 size_t f_start = ftrim.find('(');
                                 size_t f_end = ftrim.find(')');
                                 if (f_start != std::string::npos && f_end != std::string::npos) {
@@ -616,6 +684,10 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
                                         std::string field_type = trim(field_parts[0]);
                                         std::string field_name = trim(field_parts[1]);
                                         sb.fields.push_back({field_type, field_name});
+                                    } else if (field_parts.size() == 1) {
+                                        // Simple FIELD(name) - type will be inferred
+                                        std::string field_name = trim(field_parts[0]);
+                                        sb.fields.push_back({"auto", field_name});
                                     }
                                 }
                             }
@@ -870,7 +942,24 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
 
             code << "    py::class_<" << cpp_type << ">(";
             code << mod.module_name << "_module, \"" << struct_full_name << "\")\n";
-            code << "        .def(py::init<>())\n";
+
+            // v4.1.1: Generate all constructor overloads from CONSTRUCTOR() entries
+            if (sb.constructors.empty()) {
+                // Backward compatibility: default constructor if none specified
+                code << "        .def(py::init<>())\n";
+            } else {
+                for (const auto& ctor : sb.constructors) {
+                    code << "        .def(py::init<";
+                    for (size_t i = 0; i < ctor.param_types.size(); ++i) {
+                        if (i > 0) code << ", ";
+                        // Replace T with actual template type
+                        std::string ptype = ctor.param_types[i];
+                        if (ptype == "T") ptype = ttype;
+                        code << ptype;
+                    }
+                    code << ">())\n";
+                }
+            }
 
             // Fields - readwrite access
             for (const auto& [field_type, field_name] : sb.fields) {
@@ -884,6 +973,15 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
                      << cpp_type << "::" << field_name << ")\n";
             }
 
+            // v4.1.1: Generate method bindings
+            for (const auto& sig : sb.method_signatures) {
+                if (sig.is_const) {
+                    code << "        .def(\"" << sig.name << "\", &" << cpp_type << "::" << sig.name << ")\n";
+                } else {
+                    code << "        .def(\"" << sig.name << "\", &" << cpp_type << "::" << sig.name << ")\n";
+                }
+            }
+
             // Auto-generate to_dict() method
             code << "        .def(\"to_dict\", [](" << cpp_type << "& self) {\n";
             code << "            py::dict d;\n";
@@ -917,7 +1015,21 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
         // Non-template struct
         code << "    py::class_<" << sb.struct_name << ">(";
         code << mod.module_name << "_module, \"" << sb.struct_name << "\")\n";
-        code << "        .def(py::init<>())\n";
+
+        // v4.1.1: Generate all constructor overloads from CONSTRUCTOR() entries
+        if (sb.constructors.empty()) {
+            // Backward compatibility: default constructor if none specified
+            code << "        .def(py::init<>())\n";
+        } else {
+            for (const auto& ctor : sb.constructors) {
+                code << "        .def(py::init<";
+                for (size_t i = 0; i < ctor.param_types.size(); ++i) {
+                    if (i > 0) code << ", ";
+                    code << ctor.param_types[i];
+                }
+                code << ">())\n";
+            }
+        }
 
         // Fields
         for (const auto& [field_type, field_name] : sb.fields) {
@@ -925,6 +1037,11 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
                  << sb.struct_name << "::" << field_name << ")\n";
         }
 
+        // v4.1.1: Generate method bindings
+        for (const auto& sig : sb.method_signatures) {
+            code << "        .def(\"" << sig.name << "\", &" << sb.struct_name << "::" << sig.name << ")\n";
+        }
+
         // Auto-generate to_dict() method
         code << "        .def(\"to_dict\", [](" << sb.struct_name << "& self) {\n";
         code << "            py::dict d;\n";

includecpp/generator/parser.h

@@ -127,6 +127,7 @@ struct VariableBinding {
 };
 
 // v2.0: STRUCT() Bindings for Plain-Old-Data types
+// v4.1.1: Added CONSTRUCTOR and METHOD support (same as CLASS)
 struct StructBinding {
     std::string module_name;
     std::string struct_name;
@@ -135,6 +136,11 @@ struct StructBinding {
     bool is_template = false;
     std::string documentation;
 
+    // v4.1.1: CONSTRUCTOR and METHOD support for STRUCT (same as CLASS)
+    std::vector<ConstructorInfo> constructors;
+    std::vector<MethodSignature> method_signatures;
+    std::vector<std::string> methods;  // Simple method names for backward compatibility
+
     // Helper methods
     std::string get_full_name() const {
         return struct_name;

{includecpp-4.0.3.dist-info → includecpp-4.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 4.0.3
+Version: 4.2.1
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -906,3 +906,103 @@ print(greeter.name)           # "Python"
 - `python::export(instance)` - Alias
 
 All three do the same thing: wrap a CSSL class instance for Python use.
+
+## Universal Instances (v4.0.3+)
+
+Universal instances are shared containers accessible from CSSL, Python, and C++:
+
+```python
+from includecpp import CSSL
+
+cssl = CSSL.CsslLang()
+
+# Create in CSSL
+cssl.run('''
+    instance<"myContainer"> container;
+    container.data = "Hello";
+    container.count = 42;
+''')
+
+# Access from Python
+container = cssl.getInstance("myContainer")
+print(container.data)   # "Hello"
+print(container.count)  # 42
+
+# Modify from Python
+container.newValue = "Added from Python"
+
+# Changes reflect in CSSL
+cssl.run('''
+    instance<"myContainer"> c;
+    printl(c.newValue);  // "Added from Python"
+''')
+```
+
+### Instance Methods
+
+```python
+cssl.getInstance("name")      # Get instance (None if not found)
+cssl.createInstance("name")   # Create or get instance
+cssl.deleteInstance("name")   # Delete instance
+cssl.listInstances()          # List all instance names
+```
+
+### Method Injection
+
+Inject methods into instances using `+<<==`:
+
+```cssl
+instance<"api"> api;
+
+// Inject a method
+api +<<== {
+    void greet(string name) {
+        printl("Hello, " + name + "!");
+    }
+};
+
+api.greet("World");  // Hello, World!
+```
+
+## Simplified Module API (v4.0.2+)
+
+Create CSSL modules from files with payload binding:
+
+```python
+from includecpp import CSSL
+
+# Register payload from file
+CSSL.makepayload("api", "lib/api/myapi.cssl-pl")
+
+# Create module from file, binding to payload
+mod = CSSL.makemodule("writer", "lib/writer.cssl", bind="api")
+mod.SaySomething("Hello!")  # Call functions directly
+```
+
+## VSCode Extension
+
+IncludeCPP includes a VSCode extension for CSSL syntax highlighting.
+
+### Installation
+
+```bash
+# Copy extension to VSCode extensions folder
+# Windows: %USERPROFILE%\.vscode\extensions\
+# Linux/Mac: ~/.vscode/extensions/
+
+# Or install from included files
+pip show includecpp  # Find package location
+# Copy vscode/cssl folder to extensions
+```
+
+### Features
+
+- Syntax highlighting for `.cssl`, `.cssl-pl`, `.cssl-mod` files
+- Snippets for common patterns
+- Run CSSL files with F5
+- Proper coloring for:
+  - Keywords and control flow
+  - Data types (purple/lilac)
+  - Variable declarations (light blue)
+  - Injection operators (`<<==`, `<==`)
+  - Global (`@`), shared (`$`), and captured (`%`) references

{includecpp-4.0.3.dist-info → includecpp-4.2.1.dist-info}/RECORD

@@ -1,15 +1,18 @@
-includecpp/__init__.py,sha256=kyD1GPUlAX67eTPg5FgXkPAkTbMulKjmsgpiaFykMvQ,1672
-includecpp/__init__.pyi,sha256=uSDYlbqd2TinmrdepmE_zvN25jd3Co2cgyPzXgDpopM,7193
+includecpp/CHANGELOG.md,sha256=tY7jzlx61TK8Y7Hmaxrwi9tcsrAXE9Lnah-xuKD6YhM,5187
+includecpp/DOCUMENTATION.md,sha256=DuDN5EesEv9h-uTgJpNNBTi3R-RibXjrGfIKUK6uEg0,9762
+includecpp/__init__.py,sha256=KiNyF9Vjc6Snee1SM3ylgiqqXG9TWZReb6uz-Uj6lEE,1672
+includecpp/__init__.pyi,sha256=gfpArSojafkBCUoACntpnPBVgKLPZHecsyJtlVhE1A0,7267
 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=bSUVlj_LXiZJMxdZBg7pI35fICvVNoIRJdwrvXZsMFY,350247
+includecpp/cli/commands.py,sha256=7Cu1zgXmK6ghOebzKqTwZHXvROHWpqiYHKnrBW3g0ZA,372152
 includecpp/cli/config_parser.py,sha256=KveeYUg2TA9sC5hKVzYYfgdNm2WfLG5y7_yxgBWn9yM,4886
 includecpp/core/__init__.py,sha256=L1bT6oikTjdto-6Px7DpjePtM07ymo3Bnov1saZzsGg,390
-includecpp/core/ai_integration.py,sha256=PW6yFDqdXjfchpfKTKg59AOLhLry9kqJEGf_65BztrY,87603
+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/cppy_converter.py,sha256=b7yqu-aoa0wShNY0GvQT67TnNhYya4GyYmG7oDdqDV4,156686
 includecpp/core/cssl_bridge.py,sha256=xYfIRagegO8irdWl97dfanRB1qLU80p9lQ2wxkttGQ4,49963
 includecpp/core/cssl_bridge.pyi,sha256=nreh2gtK94I6VFrzTWcYVUHN97wcYQF0dY_-HySi7yQ,28787
@@ -19,20 +22,21 @@ includecpp/core/exceptions.py,sha256=szeF4qdzi_q8hBBZi7mJxkliyQ0crplkLYe0ymlBGtk
 includecpp/core/path_discovery.py,sha256=jI0oSq6Hsd4LKXmU4dOiGSrXcEO_KWMXfQ5_ylBmXvU,2561
 includecpp/core/project_ui.py,sha256=la2EQZKmUkJGuJxnbs09hH1ZhBh9bfndo6okzZsk2dQ,141134
 includecpp/core/settings_ui.py,sha256=B2SlwgdplF2KiBk5UYf2l8Jjifjd0F-FmBP0DPsVCEQ,11798
-includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=0zutiYNa-ohTzZ5fWsEgMD5ThOvyTwuMgmkzSBr7yrA,32491
+includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=M55jgDBNrgjcLQHpdN5KbHvwLWgV7SQBGEAGEFFmNCo,36847
 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=oPsPyQk5b0b1I02Y80oIaDX39GOeG32-nBPEqwbo_Pw,105110
+includecpp/core/cssl/cssl_builtins.py,sha256=x8bKQ2WEzxjkFWmGb6dK2jggiylkj04-6f15iDwEi_U,108791
 includecpp/core/cssl/cssl_builtins.pyi,sha256=-yr9JbxHKFv9Vc1iufChcqCQvNQLL3-Ow_Hgg0YwQnc,135180
 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=4GHFcGa6jv7sgQxP0wWqCci8eS4E8Ie2t-qfJ2Ux9BU,154072
-includecpp/core/cssl/cssl_runtime.py,sha256=7R3lGdw-2G9_0H5jf3D8Cn_2inLHyw2771XFopMz51s,217360
-includecpp/core/cssl/cssl_syntax.py,sha256=bgo3NFehoPTQa5dqwNd_CstkVGVCNYAXbGYUcu5BEN0,16982
-includecpp/core/cssl/cssl_types.py,sha256=e3yJfM7VqaeuU92jtmvpxfwURWXGmIJlEC41baZryvw,58452
+includecpp/core/cssl/cssl_parser.py,sha256=SZ908zCPlbHryktr75OsrYw_6srDVjmoFb4-q39abg8,169935
+includecpp/core/cssl/cssl_runtime.py,sha256=6jz6XnjjEZlWDuHxUhiiuM3HwkT4Ah74yRQqUCfw_KY,237635
+includecpp/core/cssl/cssl_syntax.py,sha256=AcFvqCB9WKitNA32izCWf5jeFWNc6ncc-xLw0J5UjBg,20933
+includecpp/core/cssl/cssl_types.py,sha256=Vs61dnMh8iUxVu7LPz8HM-XyojuQptykkedlVA3J2Bc,60031
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
-includecpp/generator/parser.cpp,sha256=hbhHdtFH65rzp6prnARN9pNFF_ssr0NseVVcxq0fJh4,76833
-includecpp/generator/parser.h,sha256=EDm0b-pEesIIIQQ2PvH5h2qwlqJU9BH8SiMV7MWbsTo,11073
+includecpp/generator/parser.cpp,sha256=KT_rrZFJi8KF6emstIW5lKOMaD5gOTC9IcrGEIuIuYw,83251
+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
 includecpp/templates/cpp.proj.template,sha256=Iy-L8I4Cl3tIgBMx1Qp5h6gURvkqOAqyodVHuDJ0Luw,359
@@ -45,9 +49,9 @@ includecpp/vscode/cssl/images/cssl.png,sha256=BxAGsnfS0ZzzCvqV6Zb1OAJAZpDUoXlR86
 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=nYy7aRWREcgCu9Jbx5QmtQHfD4WRlk-HkPhqzKVtoIA,42806
-includecpp-4.0.3.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-4.0.3.dist-info/METADATA,sha256=HrQsoVYGdTmArZ8MsnftKkBoY7a25f9Zv3AiyFpuHn8,22542
-includecpp-4.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-4.0.3.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-4.0.3.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-4.0.3.dist-info/RECORD,,
+includecpp-4.2.1.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-4.2.1.dist-info/METADATA,sha256=zeSBOAz9sK3PP7dcDDSsFE0dlODRWii-e9Wx2kX-l20,24887
+includecpp-4.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-4.2.1.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-4.2.1.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-4.2.1.dist-info/RECORD,,