IncludeCPP 3.7.3__py3-none-any.whl

includecpp/generator/parser.h

@@ -0,0 +1,281 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <map>
+#include <set>
+#include <fstream>
+#include <sstream>
+#include <algorithm>
+#include <filesystem>
+
+/*
+This Api is made for Python <-> C++ communication via pybind11.
+This Api Provides several API calls that can be extenden in other c++ modules or directly be imported as function in python.
+For Adding External C++ Modules (simply plugins). Add a Announcer file '<modulename>.cp' in the folder 'src/plugins/'.
+This file connects the external C++ module with the main application via this API. Allowing to also use the external C++ module functions in python via pybind11.
+This API Manager will automatically load all plugins in the folder 'src/plugins/' on startup.
+*/
+
+/*  Basic ShowOff of .cp
+
+SOURCE(<here_your_path_to_module.cpp>) && HEADER(<here_your_path_to_module.h>) <name_your_module>
+
+~oder nur cpp ohne header~
+SOURCE(<here_your_path_to_module.cpp>) <name_your_module>
+
+
+PUBLIC(
+    <name_your_module> FUNC(<funcname>)
+    <name_your_module> FUNC2(<funcname>>)
+    <name_your_module> CLASS(<ClassName>)
+    <name_your_module> VAR(<VariableName>)
+)
+~ wenn alle dann~
+PUBLIC(
+    ALL
+)
+*/
+
+/* The Best is, you also can give and Take params! Here another Example based on real usecase:
+fast_list.cp:
+
+SOURCE(/src/include/fast_list.cpp) && HEADER(/src/include/fast_list.h) fast_list
+PUBLIC(
+    fast_list CLASS(FastList) && PY_PARAM(list, "List to convert") && PY_PARAM(int, "Pointer count")
+    fast_list FUNC(fast_sort)
+)
+PY_PARAM ist rein optional und sollte nicht genutzt werden da Parameter auch von Pybind11 automatisch erkannt werden.
+*/
+
+// v2.3.5: Parameter metadata structure for IntelliSense
+struct ParameterInfo {
+    std::string name;
+    std::string type;
+    std::string default_value;  // Empty if no default
+    bool is_const = false;
+    bool is_reference = false;
+    bool is_pointer = false;
+};
+
+struct FunctionBinding {
+    std::string module_name;
+    std::string function_name;
+    std::vector<std::pair<std::string, std::string>> params;
+    std::string documentation;  // Function documentation from DOC()
+
+    // v2.3.5: Enhanced signature metadata for IntelliSense
+    std::string return_type = "void";
+    std::vector<ParameterInfo> parameters;  // Enhanced parameter info
+    bool is_const = false;
+    bool is_static = false;
+    bool is_inline = false;
+    std::string full_signature;  // Full C++ signature for reference
+
+    // v3.1.5: Template function support
+    bool is_template = false;
+    std::vector<std::string> template_types;  // For TEMPLATE_FUNC(name) TYPES(int, float)
+};
+
+// v2.3.5: Method signature metadata
+// v2.4.13: Extended with param_types for overload resolution
+struct MethodSignature {
+    std::string name;
+    std::string return_type;
+    std::vector<ParameterInfo> parameters;
+    std::vector<std::string> param_types;  // v2.4.13: ["const Circle&", "const Rect&"] for overload_cast
+    bool is_const = false;
+    bool is_static = false;
+    bool is_virtual = false;
+    bool is_override = false;
+    std::string documentation;
+};
+
+// v2.3.5: Field metadata
+struct FieldInfo {
+    std::string name;
+    std::string type;
+    bool is_static = false;
+    bool is_const = false;
+    std::string documentation;
+};
+
+// v2.4.3: Constructor parameter types
+struct ConstructorInfo {
+    std::vector<std::string> param_types;  // e.g., ["double", "double"] for Vector2D(double, double)
+};
+
+struct ClassBinding {
+    std::string module_name;
+    std::string class_name;
+    std::vector<std::pair<std::string, std::string>> params;
+    std::vector<std::string> methods;    // Method names to bind
+    std::vector<std::string> fields;     // Field names to bind
+    std::vector<ConstructorInfo> constructors;  // v2.4.3: Constructor overloads
+    bool auto_bind_all;                  // Bind all methods automatically
+    std::string documentation;           // Class documentation from DOC()
+    std::map<std::string, std::string> method_docs;  // Method-specific docs: method_name -> doc
+
+    // v2.3.5: Enhanced method and field signatures
+    std::vector<MethodSignature> method_signatures;
+    std::vector<FieldInfo> field_infos;
+};
+
+struct VariableBinding {
+    std::string module_name;
+    std::string variable_name;
+    std::string documentation;  // Variable documentation from DOC()
+};
+
+// v2.0: STRUCT() Bindings for Plain-Old-Data types
+struct StructBinding {
+    std::string module_name;
+    std::string struct_name;
+    std::vector<std::pair<std::string, std::string>> fields;  // <type, name>
+    std::vector<std::string> template_types;  // For STRUCT(Point) TYPES(int, float)
+    bool is_template = false;
+    std::string documentation;
+
+    // Helper methods
+    std::string get_full_name() const {
+        return struct_name;
+    }
+
+    std::string get_template_suffix(const std::string& type) const {
+        return "_" + type;
+    }
+};
+
+// v2.0: Enhanced Type Metadata for type resolution
+struct TypeMetadata {
+    enum TypeCategory {
+        PRIMITIVE,      // int, float, double, string, bool
+        STRUCT_TYPE,    // User-defined struct
+        VECTOR_TYPE,    // std::vector<T>
+        MAP_TYPE,       // std::map<K,V>
+        CLASS_TYPE,     // Full C++ class with methods
+        UNKNOWN
+    };
+
+    TypeCategory category = UNKNOWN;
+    std::string base_type;              // "vector", "map", "Point"
+    std::string full_signature;         // "std::vector<Point>", "std::map<string, int>"
+    std::vector<TypeMetadata> template_args;  // Recursive for nested types
+    bool is_const = false;
+    bool is_reference = false;
+    bool is_pointer = false;
+
+    // Conversion methods
+    std::string to_python_type_hint() const;
+    std::string to_pybind11_type() const;
+    std::string to_cpp_type() const;
+    bool is_container() const {
+        return category == VECTOR_TYPE || category == MAP_TYPE;
+    }
+    bool requires_custom_converter() const {
+        return is_container() || category == STRUCT_TYPE;
+    }
+};
+
+// v2.0: Module Dependencies (DEPENDS keyword)
+struct ModuleDependency {
+    std::string target_module;              // Dependent module
+    std::vector<std::string> required_types;  // Required Structs/Classes
+    bool is_optional = false;               // Optional dependency
+};
+
+// v2.0: Enhanced ModuleDescriptor with structs and dependencies
+struct ModuleDescriptor {
+    std::string module_name;
+    std::string source_path;
+    std::string header_path;
+    bool has_header;
+    bool expose_all;
+
+    // Bindings Collections
+    std::vector<FunctionBinding> functions;
+    std::vector<ClassBinding> classes;
+    std::vector<StructBinding> structs;           // v2.0: NEW
+    std::vector<VariableBinding> variables;
+
+    // Dependencies & Multi-Source (v2.0)
+    std::vector<ModuleDependency> dependencies;   // v2.0: NEW
+    std::vector<std::string> additional_sources;  // v2.0: NEW - SOURCES(a.cpp, b.cpp)
+
+    // Metadata
+    std::string version;
+    std::map<std::string, std::string> metadata;
+};
+
+// v2.0: Type Registry for Cross-Module Type Resolution
+class TypeRegistry {
+public:
+    // Type Registration
+    void register_struct(const std::string& module, const StructBinding& s);
+    void register_class(const std::string& module, const ClassBinding& c);
+    void register_dependency(const std::string& from_module, const ModuleDependency& dep);
+
+    // Type Resolution
+    TypeMetadata resolve_type(const std::string& type_string) const;
+    bool is_struct(const std::string& type_name) const;
+    bool is_class(const std::string& type_name) const;
+    bool type_exists(const std::string& type_name) const;
+
+    // Dependency Management
+    std::vector<std::string> get_dependencies(const std::string& module) const;
+    std::vector<std::string> get_dependency_order() const;  // Topological sort
+    bool has_circular_dependency() const;
+    std::vector<std::string> get_circular_path() const;
+
+    // Module Info
+    std::string get_module_for_type(const std::string& type_name) const;
+    std::vector<std::string> get_all_modules() const;
+
+private:
+    std::map<std::string, StructBinding> structs_;
+    std::map<std::string, ClassBinding> classes_;
+    std::map<std::string, std::string> type_to_module_;
+    std::map<std::string, std::vector<ModuleDependency>> dependencies_;
+
+    // Helper methods
+    std::vector<std::string> topological_sort() const;
+    bool has_cycle_dfs(const std::string& module,
+                       std::set<std::string>& visited,
+                       std::set<std::string>& rec_stack,
+                       std::vector<std::string>& path) const;
+};
+
+class API
+{
+public:
+    static int main(int argc, char* argv[]);
+    static std::vector<ModuleDescriptor> parse_all_cp_files(const std::string& plugins_dir);
+    static ModuleDescriptor parse_cp_file(const std::string& filepath);
+    static std::string generate_pybind11_code(const std::vector<ModuleDescriptor>& modules);
+    static std::string generate_class_bindings(const ClassBinding& cls, const ModuleDescriptor& mod);
+    static bool validate_bindings_code(const std::string& code);
+    static void validate_module_name(const std::string& name, int line_num);
+    static void validate_namespace_includecpp(const std::string& source_path, const std::string& module_name);
+    static bool write_files(const std::vector<ModuleDescriptor>& modules,
+                           const std::string& bindings_path,
+                           const std::string& sources_path);
+    static std::string compute_file_hash(const std::string& filepath);
+    static std::string generate_registry_json(const std::vector<ModuleDescriptor>& modules, const std::string& plugins_dir);
+
+    // v2.3.5: Signature extraction for IntelliSense
+    static std::vector<FunctionBinding> parse_cpp_function_signatures(const std::string& cpp_file_path);
+    static std::vector<ParameterInfo> parse_parameter_list(const std::string& params_str);
+
+private:
+    static std::string trim(const std::string& str);
+    static std::vector<std::string> split(const std::string& str, char delimiter);
+    static std::string extract_between(const std::string& str, char open, char close);
+    static std::string safe_extract_between(const std::string& str,
+                                           size_t start_pos,
+                                           size_t end_pos,
+                                           const std::string& context);
+    static bool starts_with(const std::string& str, const std::string& prefix);
+    static std::string normalize_path(const std::string& path);
+    static std::string replace_all(std::string str, const std::string& from, const std::string& to);
+    static std::string extract_doc_string(const std::string& str);
+    static std::map<std::string, std::string> parse_doc_statements(const std::string& content);
+};

includecpp/generator/type_resolver.cpp

@@ -0,0 +1,363 @@
+#include "type_resolver.h"
+#include <algorithm>
+#include <cctype>
+#include <sstream>
+
+namespace includecpp {
+namespace generator {
+
+// ============================================================================
+// TypeResolver Implementation
+// ============================================================================
+
+TypeResolver::ParsedType TypeResolver::parse_type(const std::string& type_str) {
+    ParsedType result;
+    std::string working_str = type_str;
+
+    // Remove leading/trailing whitespace
+    working_str.erase(0, working_str.find_first_not_of(" \t\n\r"));
+    working_str.erase(working_str.find_last_not_of(" \t\n\r") + 1);
+
+    // Check for const qualifier
+    if (working_str.find("const") == 0) {
+        result.is_const = true;
+        working_str = working_str.substr(5);
+        working_str.erase(0, working_str.find_first_not_of(" \t"));
+    }
+
+    // Check for reference (&) or pointer (*)
+    if (!working_str.empty() && working_str.back() == '&') {
+        result.is_reference = true;
+        working_str.pop_back();
+        working_str.erase(working_str.find_last_not_of(" \t") + 1);
+    } else if (!working_str.empty() && working_str.back() == '*') {
+        result.is_pointer = true;
+        working_str.pop_back();
+        working_str.erase(working_str.find_last_not_of(" \t") + 1);
+    }
+
+    // Check if template type
+    size_t template_start = working_str.find('<');
+    if (template_start != std::string::npos) {
+        result.is_template = true;
+        result.base_name = working_str.substr(0, template_start);
+
+        // Extract template arguments
+        std::string template_content = extract_template_content(working_str);
+        auto args = split_template_args(template_content);
+
+        for (const auto& arg : args) {
+            result.template_args.push_back(parse_type(arg));
+        }
+    } else {
+        result.base_name = working_str;
+    }
+
+    return result;
+}
+
+std::string TypeResolver::ParsedType::to_cpp_string() const {
+    std::ostringstream oss;
+
+    if (is_const) oss << "const ";
+
+    oss << base_name;
+
+    if (is_template && !template_args.empty()) {
+        oss << "<";
+        for (size_t i = 0; i < template_args.size(); ++i) {
+            if (i > 0) oss << ", ";
+            oss << template_args[i].to_cpp_string();
+        }
+        oss << ">";
+    }
+
+    if (is_pointer) oss << "*";
+    if (is_reference) oss << "&";
+
+    return oss.str();
+}
+
+std::string TypeResolver::ParsedType::to_python_hint() const {
+    // Convert C++ types to Python type hints
+    static const std::map<std::string, std::string> type_map = {
+        {"int", "int"}, {"long", "int"}, {"short", "int"},
+        {"float", "float"}, {"double", "float"},
+        {"bool", "bool"},
+        {"string", "str"}, {"std::string", "str"},
+        {"void", "None"}
+    };
+
+    if (type_map.count(base_name)) {
+        return type_map.at(base_name);
+    }
+
+    // Handle containers
+    if (base_name == "vector" || base_name == "std::vector") {
+        if (!template_args.empty()) {
+            return "List[" + template_args[0].to_python_hint() + "]";
+        }
+        return "List[Any]";
+    }
+
+    if (base_name == "map" || base_name == "std::map") {
+        if (template_args.size() >= 2) {
+            return "Dict[" + template_args[0].to_python_hint() + ", " +
+                   template_args[1].to_python_hint() + "]";
+        }
+        return "Dict[Any, Any]";
+    }
+
+    // Custom type (struct/class)
+    if (is_template && !template_args.empty()) {
+        std::string result = base_name + "_";
+        for (size_t i = 0; i < template_args.size(); ++i) {
+            if (i > 0) result += "_";
+            result += template_args[i].base_name;
+        }
+        return result;
+    }
+
+    return base_name;
+}
+
+std::string TypeResolver::to_python_hint(const ParsedType& type) {
+    return type.to_python_hint();
+}
+
+std::string TypeResolver::to_pybind11_signature(const ParsedType& type) {
+    return type.to_cpp_string();
+}
+
+std::string TypeResolver::strip_qualifiers(const std::string& type) {
+    std::string result = type;
+
+    // Remove const
+    size_t const_pos = result.find("const");
+    while (const_pos != std::string::npos) {
+        result.erase(const_pos, 5);
+        const_pos = result.find("const");
+    }
+
+    // Remove &, *
+    result.erase(std::remove(result.begin(), result.end(), '&'), result.end());
+    result.erase(std::remove(result.begin(), result.end(), '*'), result.end());
+
+    // Remove leading/trailing whitespace
+    result.erase(0, result.find_first_not_of(" \t\n\r"));
+    result.erase(result.find_last_not_of(" \t\n\r") + 1);
+
+    return result;
+}
+
+std::string TypeResolver::normalize_type(const std::string& type) {
+    std::string normalized = strip_qualifiers(type);
+
+    // Normalize common types
+    if (normalized == "string") return "std::string";
+    if (normalized == "vector") return "std::vector";
+    if (normalized == "map") return "std::map";
+
+    return normalized;
+}
+
+bool TypeResolver::is_container_type(const std::string& type) {
+    std::string lower = to_lower(type);
+    return lower.find("vector") != std::string::npos ||
+           lower.find("map") != std::string::npos ||
+           lower.find("set") != std::string::npos ||
+           lower.find("array") != std::string::npos ||
+           lower.find("list") != std::string::npos;
+}
+
+bool TypeResolver::is_primitive_type(const std::string& type) {
+    static const std::set<std::string> primitives = {
+        "int", "long", "short", "char",
+        "float", "double",
+        "bool",
+        "void",
+        "unsigned", "signed"
+    };
+
+    std::string clean_type = strip_qualifiers(type);
+    return primitives.count(clean_type) > 0;
+}
+
+bool TypeResolver::is_numeric_type(const std::string& type) {
+    static const std::set<std::string> numerics = {
+        "int", "long", "short", "char",
+        "float", "double",
+        "unsigned", "signed",
+        "int8_t", "int16_t", "int32_t", "int64_t",
+        "uint8_t", "uint16_t", "uint32_t", "uint64_t",
+        "size_t"
+    };
+
+    std::string clean_type = strip_qualifiers(type);
+    return numerics.count(clean_type) > 0;
+}
+
+bool TypeResolver::requires_custom_converter(const ParsedType& type) {
+    return is_container_type(type.base_name) ||
+           (!is_primitive_type(type.base_name) && !is_container_type(type.base_name));
+}
+
+std::vector<std::string> TypeResolver::split_template_args(const std::string& args) {
+    std::vector<std::string> result;
+    std::string current;
+    int depth = 0;
+
+    for (char c : args) {
+        if (c == '<') {
+            depth++;
+            current += c;
+        } else if (c == '>') {
+            depth--;
+            current += c;
+        } else if (c == ',' && depth == 0) {
+            // Remove leading/trailing whitespace
+            current.erase(0, current.find_first_not_of(" \t"));
+            current.erase(current.find_last_not_of(" \t") + 1);
+            if (!current.empty()) {
+                result.push_back(current);
+            }
+            current.clear();
+        } else {
+            current += c;
+        }
+    }
+
+    // Add last argument
+    current.erase(0, current.find_first_not_of(" \t"));
+    current.erase(current.find_last_not_of(" \t") + 1);
+    if (!current.empty()) {
+        result.push_back(current);
+    }
+
+    return result;
+}
+
+std::string TypeResolver::extract_template_content(const std::string& type_str) {
+    size_t start = type_str.find('<');
+    if (start == std::string::npos) return "";
+
+    size_t end = type_str.rfind('>');
+    if (end == std::string::npos || end <= start) return "";
+
+    return type_str.substr(start + 1, end - start - 1);
+}
+
+std::string TypeResolver::to_lower(const std::string& str) {
+    std::string result = str;
+    std::transform(result.begin(), result.end(), result.begin(),
+                  [](unsigned char c) { return std::tolower(c); });
+    return result;
+}
+
+// ============================================================================
+// ContainerBindings Implementation
+// ============================================================================
+
+std::string ContainerBindings::generate_vector_binding(const std::string& element_type,
+                                                       const std::string& module_var) {
+    std::ostringstream code;
+    std::string sanitized = sanitize_type_name(element_type);
+
+    code << "    // Vector binding for " << element_type << "\n";
+    code << "    py::bind_vector<std::vector<" << element_type << ">>(";
+    code << module_var << ", \"vector_" << sanitized << "\");\n\n";
+
+    return code.str();
+}
+
+std::string ContainerBindings::generate_map_binding(const std::string& key_type,
+                                                    const std::string& value_type,
+                                                    const std::string& module_var) {
+    std::ostringstream code;
+    std::string sanitized_key = sanitize_type_name(key_type);
+    std::string sanitized_val = sanitize_type_name(value_type);
+
+    code << "    // Map binding for " << key_type << " -> " << value_type << "\n";
+    code << "    py::bind_map<std::map<" << key_type << ", " << value_type << ">>(";
+    code << module_var << ", \"map_" << sanitized_key << "_" << sanitized_val << "\");\n\n";
+
+    return code.str();
+}
+
+std::string ContainerBindings::generate_nested_container_binding(const TypeMetadata& type,
+                                                                 const std::string& module_var) {
+    std::ostringstream code;
+
+    // For nested containers, we need to bind inner containers first
+    if (type.category == TypeMetadata::VECTOR_TYPE && !type.template_args.empty()) {
+        const auto& element = type.template_args[0];
+
+        // If element is also a container, bind it first
+        if (element.is_container()) {
+            code << generate_nested_container_binding(element, module_var);
+        }
+
+        code << generate_vector_binding(element.base_type, module_var);
+    }
+
+    return code.str();
+}
+
+std::set<std::string> ContainerBindings::find_used_containers(const ModuleDescriptor& module) {
+    std::set<std::string> containers;
+
+    // Check function parameters and return types
+    for (const auto& func : module.functions) {
+        for (const auto& [type, name] : func.params) {
+            if (TypeResolver::is_container_type(type)) {
+                containers.insert(type);
+            }
+        }
+    }
+
+    // Check class fields
+    for (const auto& cls : module.classes) {
+        for (const auto& [type, name] : cls.params) {
+            if (TypeResolver::is_container_type(type)) {
+                containers.insert(type);
+            }
+        }
+    }
+
+    // Check struct fields
+    for (const auto& st : module.structs) {
+        for (const auto& [type, name] : st.fields) {
+            if (TypeResolver::is_container_type(type)) {
+                containers.insert(type);
+            }
+        }
+    }
+
+    return containers;
+}
+
+std::string ContainerBindings::sanitize_type_name(const std::string& type) {
+    std::string result = type;
+
+    // Replace problematic characters
+    std::replace(result.begin(), result.end(), ':', '_');
+    std::replace(result.begin(), result.end(), '<', '_');
+    std::replace(result.begin(), result.end(), '>', '_');
+    std::replace(result.begin(), result.end(), ',', '_');
+    std::replace(result.begin(), result.end(), ' ', '_');
+    std::replace(result.begin(), result.end(), '*', '_');
+    std::replace(result.begin(), result.end(), '&', '_');
+
+    // Remove consecutive underscores
+    auto new_end = std::unique(result.begin(), result.end(),
+                               [](char a, char b) { return a == '_' && b == '_'; });
+    result.erase(new_end, result.end());
+
+    // Remove leading/trailing underscores
+    while (!result.empty() && result.front() == '_') result.erase(0, 1);
+    while (!result.empty() && result.back() == '_') result.pop_back();
+
+    return result;
+}
+
+}} // namespace includecpp::generator