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

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/vscode/cssl/package.json

@@ -2,7 +2,7 @@
     "name": "cssl",
     "displayName": "CSSL Language",
     "description": "Professional syntax highlighting, snippets, and language support for CSSL scripts (.cssl, .cssl-pl, .cssl-mod)",
-    "version": "1.6.0",
+    "version": "1.7.1",
     "publisher": "IncludeCPP",
     "icon": "images/cssl.png",
     "engines": {
@@ -151,6 +151,48 @@
                     "description": "Show output panel when running CSSL files"
                 }
             }
+        },
+        "configurationDefaults": {
+            "editor.tokenColorCustomizations": {
+                "textMateRules": [
+                    {
+                        "scope": "storage.modifier.cssl",
+                        "settings": {
+                            "fontStyle": "italic"
+                        }
+                    },
+                    {
+                        "scope": "storage.modifier.extends.cssl",
+                        "settings": {
+                            "fontStyle": "italic"
+                        }
+                    },
+                    {
+                        "scope": "storage.modifier.overwrites.cssl",
+                        "settings": {
+                            "fontStyle": "italic"
+                        }
+                    },
+                    {
+                        "scope": "support.type.cssl",
+                        "settings": {
+                            "foreground": "#C586C0"
+                        }
+                    },
+                    {
+                        "scope": "variable.other.declaration.cssl",
+                        "settings": {
+                            "foreground": "#9CDCFE"
+                        }
+                    },
+                    {
+                        "scope": "variable.parameter.cssl",
+                        "settings": {
+                            "foreground": "#9CDCFE"
+                        }
+                    }
+                ]
+            }
         }
     }
 }

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

@@ -15,6 +15,7 @@
         { "include": "#super-call" },
         { "include": "#sql-types" },
         { "include": "#keywords" },
+        { "include": "#typed-declarations" },
         { "include": "#types" },
         { "include": "#function-modifiers" },
         { "include": "#injection-operators" },
@@ -211,17 +212,21 @@
                         { "include": "#constructor-definition" },
                         { "include": "#class-method-definition" },
                         { "include": "#class-member-declaration" },
+                        { "include": "#typed-declarations" },
                         { "include": "#types" },
+                        { "include": "#function-modifiers" },
                         { "include": "#this-access" },
                         { "include": "#captured-references" },
                         { "include": "#global-references" },
                         { "include": "#shared-references" },
+                        { "include": "#instance-references" },
                         { "include": "#strings" },
                         { "include": "#numbers" },
                         { "include": "#keywords" },
                         { "include": "#function-calls" },
                         { "include": "#builtins" },
-                        { "include": "#operators" }
+                        { "include": "#operators" },
+                        { "include": "#constants" }
                     ]
                 },
                 {
@@ -241,17 +246,21 @@
                         { "include": "#constructor-definition" },
                         { "include": "#class-method-definition" },
                         { "include": "#class-member-declaration" },
+                        { "include": "#typed-declarations" },
                         { "include": "#types" },
+                        { "include": "#function-modifiers" },
                         { "include": "#this-access" },
                         { "include": "#captured-references" },
                         { "include": "#global-references" },
                         { "include": "#shared-references" },
+                        { "include": "#instance-references" },
                         { "include": "#strings" },
                         { "include": "#numbers" },
                         { "include": "#keywords" },
                         { "include": "#function-calls" },
                         { "include": "#builtins" },
-                        { "include": "#operators" }
+                        { "include": "#operators" },
+                        { "include": "#constants" }
                     ]
                 },
                 {
@@ -267,17 +276,21 @@
                         { "include": "#constructor-definition" },
                         { "include": "#class-method-definition" },
                         { "include": "#class-member-declaration" },
+                        { "include": "#typed-declarations" },
                         { "include": "#types" },
+                        { "include": "#function-modifiers" },
                         { "include": "#this-access" },
                         { "include": "#captured-references" },
                         { "include": "#global-references" },
                         { "include": "#shared-references" },
+                        { "include": "#instance-references" },
                         { "include": "#strings" },
                         { "include": "#numbers" },
                         { "include": "#keywords" },
                         { "include": "#function-calls" },
                         { "include": "#builtins" },
-                        { "include": "#operators" }
+                        { "include": "#operators" },
+                        { "include": "#constants" }
                     ]
                 }
             ]
@@ -354,11 +367,42 @@
         "class-member-declaration": {
             "patterns": [
                 {
+                    "comment": "Generic type member: datastruct<dynamic> Container;",
+                    "name": "meta.member.generic.cssl",
+                    "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type member: string ApiID;",
                     "name": "meta.member.cssl",
-                    "match": "\\b(int|string|float|bool|dynamic|auto)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
+                    "match": "\\b(int|string|float|bool|dynamic|auto|void|json|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
                     "captures": {
-                        "1": { "name": "storage.type.cssl" },
-                        "2": { "name": "variable.other.member.cssl" }
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Container type member without generic: list items;",
+                    "name": "meta.member.container.cssl",
+                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type member with assignment: string ApiID = value;",
+                    "name": "meta.member.assigned.cssl",
+                    "match": "\\b(int|string|float|bool|dynamic|auto|void|json|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*=",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
                     }
                 }
             ]
@@ -440,10 +484,65 @@
                 }
             ]
         },
+        "typed-declarations": {
+            "patterns": [
+                {
+                    "comment": "Generic type declaration: datastruct<dynamic> Container; or vector<int> items;",
+                    "name": "meta.declaration.typed.generic.cssl",
+                    "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type declaration: string ID; or int count;",
+                    "name": "meta.declaration.typed.primitive.cssl",
+                    "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[;=])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Container type declaration without generic: list items;",
+                    "name": "meta.declaration.typed.container.cssl",
+                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[;=])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Generic type in function parameter: func(datastruct<dynamic> param)",
+                    "name": "meta.parameter.typed.generic.cssl",
+                    "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[,)])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.parameter.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type in function parameter: func(string name)",
+                    "name": "meta.parameter.typed.primitive.cssl",
+                    "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[,)])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.parameter.cssl" }
+                    }
+                }
+            ]
+        },
         "types": {
             "patterns": [
                 {
-                    "name": "storage.type.primitive.cssl",
+                    "name": "support.type.cssl",
                     "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\b"
                 },
                 {
@@ -451,18 +550,18 @@
                     "name": "meta.generic.cssl",
                     "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)",
                     "captures": {
-                        "1": { "name": "storage.type.container.cssl" },
+                        "1": { "name": "support.type.cssl" },
                         "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
-                        "3": { "name": "storage.type.parameter.cssl" },
+                        "3": { "name": "support.type.cssl" },
                         "4": { "name": "punctuation.definition.typeparameters.end.cssl" }
                     }
                 },
                 {
-                    "name": "storage.type.container.cssl",
+                    "name": "support.type.cssl",
                     "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance|tuple|set|queue)\\b"
                 },
                 {
-                    "name": "storage.type.combo-open.cssl",
+                    "name": "support.type.cssl",
                     "match": "\\bcombo\\s*<\\s*open\\s*&"
                 }
             ]
@@ -471,7 +570,7 @@
             "patterns": [
                 {
                     "name": "storage.modifier.cssl",
-                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased|protected|limited)\\b"
+                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased|protected|limited|const|static|final|abstract|readonly)\\b"
                 }
             ]
         },
@@ -619,24 +718,48 @@
         "instance-references": {
             "patterns": [
                 {
-                    "comment": "instance<\"name\"> - shared instance reference with string",
+                    "comment": "instance<\"name\"> varName - shared instance declaration with variable",
+                    "name": "meta.instance.declaration.cssl",
+                    "match": "(\\binstance)(<)(\"[^\"]+\")(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "string.quoted.double.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "instance<Type> varName - shared instance declaration with type and variable",
+                    "name": "meta.instance.declaration.cssl",
+                    "match": "(\\binstance)(<)([a-zA-Z_][a-zA-Z0-9_]*)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "instance<\"name\"> - shared instance reference without variable",
                     "name": "meta.instance.cssl",
                     "match": "(\\binstance)(<)(\"[^\"]+\")(>)",
                     "captures": {
-                        "1": { "name": "storage.type.instance.cssl" },
+                        "1": { "name": "support.type.cssl" },
                         "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
                         "3": { "name": "string.quoted.double.cssl" },
                         "4": { "name": "punctuation.definition.typeparameters.end.cssl" }
                     }
                 },
                 {
-                    "comment": "instance<Type> - shared instance reference with type",
+                    "comment": "instance<Type> - shared instance reference without variable",
                     "name": "meta.instance.cssl",
                     "match": "(\\binstance)(<)([a-zA-Z_][a-zA-Z0-9_]*)(>)",
                     "captures": {
-                        "1": { "name": "storage.type.instance.cssl" },
+                        "1": { "name": "support.type.cssl" },
                         "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
-                        "3": { "name": "entity.name.type.cssl" },
+                        "3": { "name": "support.type.cssl" },
                         "4": { "name": "punctuation.definition.typeparameters.end.cssl" }
                     }
                 }

{includecpp-4.0.0.dist-info → includecpp-4.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 4.0.0
+Version: 4.2.2
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt
@@ -27,6 +27,7 @@ Requires-Dist: pybind11>=2.11.0
 Requires-Dist: click>=8.0.0
 Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: requests>=2.28.0
+Requires-Dist: colorama>=0.4.0
 Dynamic: author-email
 Dynamic: home-page
 Dynamic: license-file
@@ -905,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