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

includecpp/core/cssl_bridge.pyi

@@ -412,7 +412,37 @@ class CsslLang:
         """
         ...
 
-    def makemodule(self, code_or_script: Union[str, CSSLScript], *more: Any) -> CSSLFunctionModule:
+    def makepayload(self, name: str, path: str) -> str:
+        """
+        Register a payload from a file path.
+
+        Reads the file and registers it as a payload accessible via payload(name) in CSSL.
+        This is a convenience method for loading payload files.
+
+        Args:
+            name: Name to register the payload under (used in payload(name) and bind=name)
+            path: Path to the .cssl-pl or .cssl file
+
+        Returns:
+            The payload code that was registered
+
+        Usage:
+            # Register a payload from file
+            cssl.makepayload("api", "lib/api/myapi.cssl-pl")
+
+            # Use with makemodule for automatic binding
+            mod = cssl.makemodule("writer", "lib/writer.cssl", bind="api")
+            mod.SaySomething("Hello!")
+        """
+        ...
+
+    def makemodule(
+        self,
+        main_script: Union[str, CSSLScript],
+        payload_script: Union[str, CSSLScript, None] = ...,
+        name: str = ...,
+        bind: str = ...
+    ) -> CSSLFunctionModule:
         """
         Create a CSSL module with accessible functions as methods.
 
@@ -420,14 +450,23 @@ class CsslLang:
         Functions defined in the code become callable Python methods.
 
         Args:
-            code_or_script: CSSL code string or CSSLScript object
-            *more: Additional scripts or module name
+            main_script: CSSL code string, file path, or CSSLScript object
+            payload_script: Optional payload code (string or CSSLScript)
+            name: Optional name to register for payload(name) access
+            bind: Optional payload name to auto-prepend (from makepayload)
 
         Returns:
             CSSLFunctionModule with callable function attributes
 
-        Usage:
-            # From code string
+        Usage (simplified - with file path and bind):
+            # First register the payload
+            cssl.makepayload("api", "lib/api/einkaufsmanager.cssl-pl")
+
+            # Then create module from file, binding to payload
+            mod = cssl.makemodule("writer", "lib/writer.cssl", bind="api")
+            mod.SaySomething("Hello!")  # Functions are now accessible
+
+        Usage (from code string):
             math = cssl.makemodule('''
                 int add(int a, int b) { return a + b; }
                 int sub(int a, int b) { return a - b; }
@@ -435,7 +474,7 @@ class CsslLang:
             print(math.add(10, 5))  # 15
             print(math.sub(10, 5))  # 5
 
-            # From script objects (for .cssl-mod creation)
+        Usage (from script objects):
             main = cssl.script("cssl", "...")
             helpers = cssl.script("cssl-pl", "...")
             mod = cssl.makemodule(main, helpers, "mymodule")
@@ -541,6 +580,66 @@ class CsslLang:
         """
         ...
 
+    def getInstance(self, name: str) -> Optional[Any]:
+        """
+        Get a universal instance by name (for Python-side access).
+
+        Universal instances are shared containers accessible from CSSL, Python, and C++.
+        They support dynamic member/method access and are mutable across all contexts.
+
+        Args:
+            name: Name of the instance (without quotes)
+
+        Returns:
+            The UniversalInstance or None if not found
+
+        Usage:
+            # In CSSL: instance<"myContainer"> container;
+            # Then in Python:
+            container = cssl.getInstance("myContainer")
+            container.member = "value"
+            print(container.member)  # value
+        """
+        ...
+
+    def createInstance(self, name: str) -> Any:
+        """
+        Create or get a universal instance by name (for Python-side creation).
+
+        Args:
+            name: Name for the instance
+
+        Returns:
+            The UniversalInstance (new or existing)
+
+        Usage:
+            container = cssl.createInstance("myContainer")
+            container.data = {"key": "value"}
+            # Now accessible in CSSL via instance<"myContainer">
+        """
+        ...
+
+    def deleteInstance(self, name: str) -> bool:
+        """
+        Delete a universal instance by name.
+
+        Args:
+            name: Name of the instance to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        ...
+
+    def listInstances(self) -> List[str]:
+        """
+        List all universal instance names.
+
+        Returns:
+            List of instance names
+        """
+        ...
+
     def set_global(self, name: str, value: Any) -> None:
         """
         Set a global variable in the CSSL runtime.
@@ -733,20 +832,59 @@ def module(code: str) -> CSSLModule:
     ...
 
 
-def makemodule(code_or_script: Union[str, CSSLScript], *more: Any) -> CSSLFunctionModule:
+def makepayload(name: str, path: str) -> str:
+    """
+    Register a payload from a file path.
+
+    Reads the file and registers it as a payload accessible via payload(name) in CSSL.
+
+    Args:
+        name: Name to register the payload under (used in payload(name) and bind=name)
+        path: Path to the .cssl-pl or .cssl file
+
+    Returns:
+        The payload code that was registered
+
+    Usage:
+        from includecpp import CSSL
+
+        # Register a payload from file
+        CSSL.makepayload("api", "lib/api/myapi.cssl-pl")
+
+        # Use with makemodule for automatic binding
+        mod = CSSL.makemodule("writer", "lib/writer.cssl", bind="api")
+        mod.SaySomething("Hello!")
+    """
+    ...
+
+
+def makemodule(
+    main_script: Union[str, CSSLScript],
+    payload_script: Union[str, CSSLScript, None] = ...,
+    name: str = ...,
+    bind: str = ...
+) -> CSSLFunctionModule:
     """
     Create a CSSL module with accessible functions.
 
     Args:
-        code_or_script: CSSL code string or CSSLScript object
-        *more: Additional scripts or module name
+        main_script: CSSL code string, file path, or CSSLScript object
+        payload_script: Optional payload code (string or CSSLScript)
+        name: Optional name to register for payload(name) access
+        bind: Optional payload name to auto-prepend (from makepayload)
 
     Returns:
         CSSLFunctionModule with callable function attributes
 
-    Usage:
+    Usage (simplified):
         from includecpp import CSSL
 
+        # Register payload and create module
+        CSSL.makepayload("api", "lib/api/myapi.cssl-pl")
+        mod = CSSL.makemodule("writer", "lib/writer.cssl", bind="api")
+        mod.SaySomething("Hello!")
+
+    Usage (code string):
         math = CSSL.makemodule('''
             int add(int a, int b) { return a + b; }
         ''')

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"
+                        }
+                    }
+                ]
+            }
         }
     }
 }