IncludeCPP 4.6.0__py3-none-any.whl → 4.9.3__py3-none-any.whl

includecpp/generator/parser.cpp

@@ -230,22 +230,62 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
 
         if (!in_public_block) {
             if (starts_with(line, "SOURCE")) {
-                size_t source_start = line.find('(');
-                size_t source_end = line.find(')');
-                if (source_start != std::string::npos && source_end != std::string::npos) {
-                    desc.source_path = trim(line.substr(source_start + 1, source_end - source_start - 1));
+                // v4.6.5: Support multiple SOURCE() and HEADER() declarations
+                // Format: SOURCE(file1) && SOURCE(file2) && HEADER(h) module_name
+
+                // Find ALL SOURCE(...) declarations
+                std::regex source_regex(R"(SOURCE\s*\(\s*([^)]+)\s*\))");
+                std::sregex_iterator source_it(line.begin(), line.end(), source_regex);
+                std::sregex_iterator end_it;
+                bool first_source = true;
+                while (source_it != end_it) {
+                    std::string src_content = trim((*source_it)[1].str());
+                    // Handle space/comma-separated files within one SOURCE()
+                    std::istringstream iss(src_content);
+                    std::string single_src;
+                    while (iss >> single_src) {
+                        // Remove trailing comma if present
+                        if (!single_src.empty() && single_src.back() == ',') {
+                            single_src.pop_back();
+                        }
+                        if (!single_src.empty()) {
+                            if (first_source && desc.source_path.empty()) {
+                                desc.source_path = single_src;
+                                first_source = false;
+                            } else {
+                                desc.additional_sources.push_back(single_src);
+                            }
+                        }
+                    }
+                    ++source_it;
                 }
 
-                size_t header_pos = line.find("HEADER");
-                if (header_pos != std::string::npos) {
-                    desc.has_header = true;
-                    size_t header_start = line.find('(', header_pos);
-                    size_t header_end = line.find(')', header_pos);
-                    if (header_start != std::string::npos && header_end != std::string::npos) {
-                        desc.header_path = trim(line.substr(header_start + 1, header_end - header_start - 1));
+                // Find ALL HEADER(...) declarations
+                std::regex header_regex(R"(HEADER\s*\(\s*([^)]+)\s*\))");
+                std::sregex_iterator header_it(line.begin(), line.end(), header_regex);
+                bool first_header = true;
+                while (header_it != end_it) {
+                    std::string hdr_content = trim((*header_it)[1].str());
+                    // Handle space/comma-separated headers within one HEADER()
+                    std::istringstream hss(hdr_content);
+                    std::string single_hdr;
+                    while (hss >> single_hdr) {
+                        if (!single_hdr.empty() && single_hdr.back() == ',') {
+                            single_hdr.pop_back();
+                        }
+                        if (!single_hdr.empty()) {
+                            if (first_header) {
+                                desc.header_path = single_hdr;
+                                desc.has_header = true;
+                                first_header = false;
+                            }
+                            // Additional headers can be stored if needed in future
+                        }
                     }
+                    ++header_it;
                 }
 
+                // Module name is at the end after all declarations
                 size_t last_space = line.rfind(' ');
                 if (last_space != std::string::npos) {
                     desc.module_name = trim(line.substr(last_space + 1));
@@ -380,6 +420,66 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
                     desc.functions.push_back(fb);
                 }
             }
+            // v4.6.5: Check ENUM before CLASS (ENUM lines may contain "CLASS" keyword)
+            else if (cleaned.find("ENUM(") != std::string::npos) {
+                EnumBinding eb;
+                auto parts = split(cleaned, ' ');
+                if (parts.size() >= 2) {
+                    eb.module_name = parts[0];
+
+                    size_t enum_start = cleaned.find("ENUM(");
+                    size_t enum_end = cleaned.find(')', enum_start);
+                    size_t enum_paren = enum_start + 4;  // Position of '(' in "ENUM("
+                    eb.enum_name = safe_extract_between(cleaned, enum_paren, enum_end, "ENUM");
+
+                    // Check for CLASS keyword (enum class vs plain enum)
+                    if (cleaned.find(" CLASS") != std::string::npos) {
+                        eb.is_class_enum = true;
+                    }
+
+                    // Check for NOEXPORT keyword
+                    if (cleaned.find("NOEXPORT") != std::string::npos) {
+                        eb.export_values = false;
+                    }
+
+                    // Check for VALUES block: ENUM(Name) { VALUE1 VALUE2 ... }
+                    size_t brace_open = cleaned.find('{');
+                    if (brace_open != std::string::npos) {
+                        std::string values_block;
+                        size_t brace_close = cleaned.find('}', brace_open);
+                        if (brace_close != std::string::npos) {
+                            values_block = cleaned.substr(brace_open + 1, brace_close - brace_open - 1);
+                        } else {
+                            // Multi-line - collect from next lines
+                            for (size_t j = i + 1; j < public_lines.size(); ++j) {
+                                std::string next_line = trim(public_lines[j]);
+                                size_t close_pos = next_line.find('}');
+                                if (close_pos != std::string::npos) {
+                                    values_block += next_line.substr(0, close_pos);
+                                    i = j;
+                                    break;
+                                } else {
+                                    values_block += next_line + " ";
+                                }
+                            }
+                        }
+
+                        // Parse enum values
+                        std::istringstream vss(values_block);
+                        std::string value;
+                        while (vss >> value) {
+                            if (!value.empty() && value.back() == ',') {
+                                value.pop_back();
+                            }
+                            if (!value.empty()) {
+                                eb.values.push_back(value);
+                            }
+                        }
+                    }
+
+                    desc.enums.push_back(eb);
+                }
+            }
             else if (cleaned.find("CLASS") != std::string::npos) {
                 ClassBinding cb;
                 cb.auto_bind_all = false;
@@ -672,6 +772,23 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
                                     }
                                 }
                             }
+                            // v4.6.6: Parse FIELD_ARRAY(name, type, size) for C-style arrays
+                            else if (ftrim.find("FIELD_ARRAY(") != 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) {
+                                    std::string field_content = ftrim.substr(f_start + 1, f_end - f_start - 1);
+                                    auto field_parts = split(field_content, ',');
+                                    if (field_parts.size() >= 3) {
+                                        FieldInfo fi;
+                                        fi.name = trim(field_parts[0]);
+                                        fi.type = trim(field_parts[1]);
+                                        fi.is_array = true;
+                                        fi.array_size = std::stoi(trim(field_parts[2]));
+                                        sb.fields.push_back(fi);
+                                    }
+                                }
+                            }
                             // Parse FIELD(name) or FIELD(type, name)
                             else if (ftrim.find("FIELD(") != std::string::npos) {
                                 size_t f_start = ftrim.find('(');
@@ -680,15 +797,18 @@ ModuleDescriptor API::parse_cp_file(const std::string& filepath) {
                                     std::string field_content = ftrim.substr(f_start + 1, f_end - f_start - 1);
                                     auto field_parts = split(field_content, ',');
 
+                                    FieldInfo fi;
                                     if (field_parts.size() >= 2) {
-                                        std::string field_type = trim(field_parts[0]);
-                                        std::string field_name = trim(field_parts[1]);
-                                        sb.fields.push_back({field_type, field_name});
+                                        fi.type = trim(field_parts[0]);
+                                        fi.name = trim(field_parts[1]);
                                     } 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});
+                                        fi.type = "auto";
+                                        fi.name = trim(field_parts[0]);
                                     }
+                                    fi.is_array = false;
+                                    fi.array_size = 0;
+                                    sb.fields.push_back(fi);
                                 }
                             }
                         }
@@ -962,15 +1082,23 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
             }
 
             // Fields - readwrite access
-            for (const auto& [field_type, field_name] : sb.fields) {
-                std::string actual_type = field_type;
+            // v4.6.6: Handle array fields with def_property
+            for (const auto& fi : sb.fields) {
+                std::string actual_type = fi.type;
                 // Replace template parameter T with actual type
                 if (actual_type == "T") {
                     actual_type = ttype;
                 }
 
-                code << "        .def_readwrite(\"" << field_name << "\", &"
-                     << cpp_type << "::" << field_name << ")\n";
+                if (fi.is_array) {
+                    // Array field: use def_property with lambda getter returning py::bytes
+                    code << "        .def_property_readonly(\"" << fi.name << "\", [](" << cpp_type << "& self) {\n";
+                    code << "            return py::bytes(reinterpret_cast<const char*>(self." << fi.name << "), " << fi.array_size << ");\n";
+                    code << "        })\n";
+                } else {
+                    code << "        .def_readwrite(\"" << fi.name << "\", &"
+                         << cpp_type << "::" << fi.name << ")\n";
+                }
             }
 
             // v4.1.1: Generate method bindings
@@ -985,8 +1113,10 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
             // Auto-generate to_dict() method
             code << "        .def(\"to_dict\", [](" << cpp_type << "& self) {\n";
             code << "            py::dict d;\n";
-            for (const auto& [field_type, field_name] : sb.fields) {
-                code << "            d[\"" << field_name << "\"] = self." << field_name << ";\n";
+            for (const auto& fi : sb.fields) {
+                if (!fi.is_array) {
+                    code << "            d[\"" << fi.name << "\"] = self." << fi.name << ";\n";
+                }
             }
             code << "            return d;\n";
             code << "        })\n";
@@ -994,8 +1124,9 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
             // Auto-generate from_dict() static method
             // 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;
+            for (const auto& fi : sb.fields) {
+                if (fi.is_array) continue;
+                std::string actual_type = fi.type;
                 if (actual_type == "T") actual_type = ttype;
                 if (actual_type == "auto" || actual_type.empty()) {
                     template_all_types_known = false;
@@ -1006,13 +1137,14 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
             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;
+                for (const auto& fi : sb.fields) {
+                    if (fi.is_array) continue;
+                    std::string actual_type = fi.type;
                     if (actual_type == "T") {
                         actual_type = ttype;
                     }
 
-                    code << "            obj." << field_name << " = d[\"" << field_name
+                    code << "            obj." << fi.name << " = d[\"" << fi.name
                          << "\"].cast<" << actual_type << ">();\n";
                 }
                 code << "            return obj;\n";
@@ -1045,9 +1177,17 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
         }
 
         // Fields
-        for (const auto& [field_type, field_name] : sb.fields) {
-            code << "        .def_readwrite(\"" << field_name << "\", &"
-                 << sb.struct_name << "::" << field_name << ")\n";
+        // v4.6.6: Handle array fields with def_property
+        for (const auto& fi : sb.fields) {
+            if (fi.is_array) {
+                // Array field: use def_property_readonly with lambda getter returning py::bytes
+                code << "        .def_property_readonly(\"" << fi.name << "\", [](" << sb.struct_name << "& self) {\n";
+                code << "            return py::bytes(reinterpret_cast<const char*>(self." << fi.name << "), " << fi.array_size << ");\n";
+                code << "        })\n";
+            } else {
+                code << "        .def_readwrite(\"" << fi.name << "\", &"
+                     << sb.struct_name << "::" << fi.name << ")\n";
+            }
         }
 
         // v4.1.1: Generate method bindings
@@ -1058,8 +1198,10 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
         // Auto-generate to_dict() method
         code << "        .def(\"to_dict\", [](" << sb.struct_name << "& self) {\n";
         code << "            py::dict d;\n";
-        for (const auto& [field_type, field_name] : sb.fields) {
-            code << "            d[\"" << field_name << "\"] = self." << field_name << ";\n";
+        for (const auto& fi : sb.fields) {
+            if (!fi.is_array) {
+                code << "            d[\"" << fi.name << "\"] = self." << fi.name << ";\n";
+            }
         }
         code << "            return d;\n";
         code << "        })\n";
@@ -1067,8 +1209,9 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
         // Auto-generate from_dict() static method
         // 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) {
-            if (field_type == "auto" || field_type.empty()) {
+        for (const auto& fi : sb.fields) {
+            if (fi.is_array) continue;
+            if (fi.type == "auto" || fi.type.empty()) {
                 all_types_known = false;
                 break;
             }
@@ -1077,9 +1220,10 @@ std::string generate_struct_bindings(const StructBinding& sb, const ModuleDescri
         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";
+            for (const auto& fi : sb.fields) {
+                if (fi.is_array) continue;
+                code << "            obj." << fi.name << " = d[\"" << fi.name
+                     << "\"].cast<" << fi.type << ">();\n";
             }
             code << "            return obj;\n";
             code << "        })\n";
@@ -1156,6 +1300,22 @@ std::string API::generate_pybind11_code(const std::vector<ModuleDescriptor>& mod
             code << generate_struct_bindings(st, mod);
         }
 
+        // v4.6.5: Generate enum bindings
+        for (const auto& en : mod.enums) {
+            code << "    py::enum_<" << en.enum_name << ">(";
+            code << mod.module_name << "_module, \"" << en.enum_name << "\")\n";
+
+            for (const auto& val : en.values) {
+                code << "        .value(\"" << val << "\", " << en.enum_name << "::" << val << ")\n";
+            }
+
+            if (en.export_values) {
+                code << "        .export_values();\n\n";
+            } else {
+                code << "        ;\n\n";
+            }
+        }
+
         for (const auto& func : mod.functions) {
             if (func.is_template && !func.template_types.empty()) {
                 for (const auto& ttype : func.template_types) {
@@ -1505,8 +1665,12 @@ std::string API::generate_registry_json(const std::vector<ModuleDescriptor>& mod
             }
             json << ",\n          \"fields\": [\n";
             for (size_t k = 0; k < st.fields.size(); ++k) {
-                const auto& [type, name] = st.fields[k];
-                json << "            {\"type\": \"" << type << "\", \"name\": \"" << name << "\"}";
+                const auto& fi = st.fields[k];
+                json << "            {\"type\": \"" << fi.type << "\", \"name\": \"" << fi.name << "\"";
+                if (fi.is_array) {
+                    json << ", \"is_array\": true, \"array_size\": " << fi.array_size;
+                }
+                json << "}";
                 if (k < st.fields.size() - 1) json << ",";
                 json << "\n";
             }

includecpp/generator/parser.h

@@ -91,11 +91,14 @@ struct MethodSignature {
 };
 
 // v2.3.5: Field metadata
+// v4.6.6: Added array support
 struct FieldInfo {
     std::string name;
     std::string type;
     bool is_static = false;
     bool is_const = false;
+    bool is_array = false;        // v4.6.6: Is this a C-style array?
+    int array_size = 0;           // v4.6.6: Size of array (0 if not array)
     std::string documentation;
 };
 
@@ -126,12 +129,22 @@ struct VariableBinding {
     std::string documentation;  // Variable documentation from DOC()
 };
 
+// v4.6.5: ENUM() Bindings for C++ enums
+struct EnumBinding {
+    std::string module_name;
+    std::string enum_name;
+    std::vector<std::string> values;  // Enum values to expose
+    bool export_values = true;        // Call .export_values() to export to module scope
+    bool is_class_enum = false;       // enum class vs plain enum
+    std::string documentation;
+};
+
 // 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;
-    std::vector<std::pair<std::string, std::string>> fields;  // <type, name>
+    std::vector<FieldInfo> fields;  // v4.6.6: Changed from pair to FieldInfo for array support
     std::vector<std::string> template_types;  // For STRUCT(Point) TYPES(int, float)
     bool is_template = false;
     std::string documentation;
@@ -202,6 +215,7 @@ struct ModuleDescriptor {
     std::vector<ClassBinding> classes;
     std::vector<StructBinding> structs;           // v2.0: NEW
     std::vector<VariableBinding> variables;
+    std::vector<EnumBinding> enums;               // v4.6.5: NEW
 
     // Dependencies & Multi-Source (v2.0)
     std::vector<ModuleDependency> dependencies;   // v2.0: NEW

includecpp/templates/cpp.proj.template

@@ -15,4 +15,4 @@
     "enabled": true,
     "max_workers": 8
   }
-}
+}

includecpp/vscode/cssl/snippets/cssl.snippets.json

@@ -1202,5 +1202,168 @@
             "parameter.return(python::pythonize(${7}));$0"
         ],
         "description": "Create a class and export as Python object"
+    },
+
+    "fmt::red": {
+        "prefix": ["fmt::red", "fmtred"],
+        "body": "fmt::red(${1:text})$0",
+        "description": "Red colored text"
+    },
+    "fmt::green": {
+        "prefix": ["fmt::green", "fmtgreen"],
+        "body": "fmt::green(${1:text})$0",
+        "description": "Green colored text"
+    },
+    "fmt::blue": {
+        "prefix": ["fmt::blue", "fmtblue"],
+        "body": "fmt::blue(${1:text})$0",
+        "description": "Blue colored text"
+    },
+    "fmt::yellow": {
+        "prefix": ["fmt::yellow", "fmtyellow"],
+        "body": "fmt::yellow(${1:text})$0",
+        "description": "Yellow colored text"
+    },
+    "fmt::cyan": {
+        "prefix": ["fmt::cyan", "fmtcyan"],
+        "body": "fmt::cyan(${1:text})$0",
+        "description": "Cyan colored text"
+    },
+    "fmt::magenta": {
+        "prefix": ["fmt::magenta", "fmtmagenta"],
+        "body": "fmt::magenta(${1:text})$0",
+        "description": "Magenta colored text"
+    },
+    "fmt::white": {
+        "prefix": ["fmt::white", "fmtwhite"],
+        "body": "fmt::white(${1:text})$0",
+        "description": "White colored text"
+    },
+    "fmt::black": {
+        "prefix": ["fmt::black", "fmtblack"],
+        "body": "fmt::black(${1:text})$0",
+        "description": "Black colored text"
+    },
+    "fmt::bold": {
+        "prefix": ["fmt::bold", "fmtbold"],
+        "body": "fmt::bold(${1:text})$0",
+        "description": "Bold text"
+    },
+    "fmt::dim": {
+        "prefix": ["fmt::dim", "fmtdim"],
+        "body": "fmt::dim(${1:text})$0",
+        "description": "Dim text"
+    },
+    "fmt::italic": {
+        "prefix": ["fmt::italic", "fmtitalic"],
+        "body": "fmt::italic(${1:text})$0",
+        "description": "Italic text"
+    },
+    "fmt::underline": {
+        "prefix": ["fmt::underline", "fmtunderline"],
+        "body": "fmt::underline(${1:text})$0",
+        "description": "Underlined text"
+    },
+    "fmt::blink": {
+        "prefix": ["fmt::blink", "fmtblink"],
+        "body": "fmt::blink(${1:text})$0",
+        "description": "Blinking text"
+    },
+    "fmt::reverse": {
+        "prefix": ["fmt::reverse", "fmtreverse"],
+        "body": "fmt::reverse(${1:text})$0",
+        "description": "Reversed color text"
+    },
+    "fmt::bright_red": {
+        "prefix": "fmt::bright_red",
+        "body": "fmt::bright_red(${1:text})$0",
+        "description": "Bright red colored text"
+    },
+    "fmt::bright_green": {
+        "prefix": "fmt::bright_green",
+        "body": "fmt::bright_green(${1:text})$0",
+        "description": "Bright green colored text"
+    },
+    "fmt::bright_blue": {
+        "prefix": "fmt::bright_blue",
+        "body": "fmt::bright_blue(${1:text})$0",
+        "description": "Bright blue colored text"
+    },
+    "fmt::bright_yellow": {
+        "prefix": "fmt::bright_yellow",
+        "body": "fmt::bright_yellow(${1:text})$0",
+        "description": "Bright yellow colored text"
+    },
+    "fmt::bright_cyan": {
+        "prefix": "fmt::bright_cyan",
+        "body": "fmt::bright_cyan(${1:text})$0",
+        "description": "Bright cyan colored text"
+    },
+    "fmt::bright_magenta": {
+        "prefix": "fmt::bright_magenta",
+        "body": "fmt::bright_magenta(${1:text})$0",
+        "description": "Bright magenta colored text"
+    },
+    "fmt::color": {
+        "prefix": ["fmt::color", "fmtcolor"],
+        "body": "fmt::color(${1:text}, ${2:\"green\"}, ${3:\"black\"})$0",
+        "description": "Custom foreground and background color"
+    },
+    "fmt::rgb": {
+        "prefix": ["fmt::rgb", "fmtrgb"],
+        "body": "fmt::rgb(${1:text}, ${2:255}, ${3:128}, ${4:0})$0",
+        "description": "24-bit RGB color"
+    },
+    "fmt::hex": {
+        "prefix": ["fmt::hex", "fmthex"],
+        "body": "fmt::hex(${1:text}, ${2:\"#ff8800\"})$0",
+        "description": "Hex color code"
+    },
+    "fmt::reset": {
+        "prefix": "fmt::reset",
+        "body": "fmt::reset()$0",
+        "description": "ANSI reset code"
+    },
+    "fmt::strip": {
+        "prefix": "fmt::strip",
+        "body": "fmt::strip(${1:text})$0",
+        "description": "Strip all ANSI codes from text"
+    },
+
+    "Namespace Definition": {
+        "prefix": ["namespace", "ns"],
+        "body": [
+            "namespace ${1:mylib} {",
+            "\t// Functions",
+            "\t${2:void} ${3:myFunc}(${4:params}) {",
+            "\t\t$0",
+            "\t}",
+            "}"
+        ],
+        "description": "Create a namespace with functions accessible via mylib::myFunc()"
+    },
+    "Namespace with Class": {
+        "prefix": ["namespace-class", "nsclass"],
+        "body": [
+            "namespace ${1:mylib} {",
+            "\tclass ${2:MyClass} {",
+            "\t\t${3:string} ${4:value};",
+            "\t\t",
+            "\t\t${2}(${5:params}) {",
+            "\t\t\tthis->${4} = ${6:initialValue};",
+            "\t\t}",
+            "\t\t",
+            "\t\t${7:void} ${8:method}() {",
+            "\t\t\t$0",
+            "\t\t}",
+            "\t}",
+            "}"
+        ],
+        "description": "Create a namespace with a class accessible via mylib::MyClass"
+    },
+    "Namespace Function Call": {
+        "prefix": ["ns::", "namespace::"],
+        "body": "${1:namespace}::${2:function}(${3:args})$0",
+        "description": "Call a namespaced function"
     }
 }