Initial commit
This commit is contained in:
Bartek Kryza
6
src/CMakeLists.txt
Normal file
6
src/CMakeLists.txt
Normal file
@@ -0,0 +1,6 @@
|
||||
|
||||
set(SOURCE_FILES "
|
||||
config/config.cc
|
||||
")
|
||||
|
||||
|
||||
14
src/config/config.cc
Normal file
14
src/config/config.cc
Normal file
@@ -0,0 +1,14 @@
|
||||
#include "config.h"
|
||||
|
||||
namespace clanguml {
|
||||
namespace config {
|
||||
|
||||
config load(const std::string &config_file)
|
||||
{
|
||||
YAML::Node doc = YAML::LoadFile(config_file);
|
||||
|
||||
return doc.as<config>();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
110
src/config/config.h
Normal file
110
src/config/config.h
Normal file
@@ -0,0 +1,110 @@
|
||||
#pragma once
|
||||
|
||||
#include <spdlog/spdlog.h>
|
||||
#include <yaml-cpp/yaml.h>
|
||||
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace clanguml {
|
||||
namespace config {
|
||||
|
||||
struct diagram {
|
||||
virtual ~diagram() = default;
|
||||
|
||||
std::string name;
|
||||
std::vector<std::string> glob;
|
||||
std::vector<std::string> puml;
|
||||
std::string using_namespace;
|
||||
};
|
||||
|
||||
enum class class_scopes { public_, protected_, private_ };
|
||||
|
||||
struct class_diagram : public diagram {
|
||||
virtual ~class_diagram() = default;
|
||||
|
||||
std::vector<std::string> classes;
|
||||
std::vector<class_scopes> methods;
|
||||
std::vector<class_scopes> members;
|
||||
|
||||
bool has_class(std::string clazz)
|
||||
{
|
||||
spdlog::debug("CHECKING IF {} IS WHITE LISTED", clazz);
|
||||
for (const auto &c : classes) {
|
||||
std::string prefix{};
|
||||
if (!using_namespace.empty()) {
|
||||
prefix = using_namespace + "::";
|
||||
}
|
||||
if (prefix + c == clazz)
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
struct config {
|
||||
// the glob list is additive and relative to the current
|
||||
// directory
|
||||
std::vector<std::string> glob;
|
||||
std::string compilation_database_dir{"."};
|
||||
std::map<std::string, std::unique_ptr<diagram>> diagrams;
|
||||
};
|
||||
|
||||
config load(const std::string &config_file);
|
||||
}
|
||||
}
|
||||
|
||||
namespace YAML {
|
||||
using clanguml::config::class_diagram;
|
||||
using clanguml::config::config;
|
||||
//
|
||||
// class_diagram Yaml decoder
|
||||
//
|
||||
template <> struct convert<class_diagram> {
|
||||
static bool decode(const Node &node, class_diagram &rhs)
|
||||
{
|
||||
rhs.using_namespace = node["using_namespace"].as<std::string>();
|
||||
rhs.glob = node["glob"].as<std::vector<std::string>>();
|
||||
rhs.puml = node["puml"].as<std::vector<std::string>>();
|
||||
rhs.classes = node["classes"].as<std::vector<std::string>>();
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// config Yaml decoder
|
||||
//
|
||||
template <> struct convert<config> {
|
||||
static bool decode(const Node &node, config &rhs)
|
||||
{
|
||||
rhs.glob = node["glob"].as<std::vector<std::string>>();
|
||||
if (node["compilation_database_dir"])
|
||||
rhs.compilation_database_dir =
|
||||
node["compilation_database_dir"].as<std::string>();
|
||||
|
||||
auto diagrams = node["diagrams"];
|
||||
|
||||
assert(diagrams.Type() == NodeType::Map);
|
||||
|
||||
for (const auto &d : diagrams) {
|
||||
const auto diagram_type = d.second["type"].as<std::string>();
|
||||
if (diagram_type == "class") {
|
||||
rhs.diagrams[d.first.as<std::string>()] =
|
||||
std::make_unique<class_diagram>(
|
||||
d.second.as<class_diagram>());
|
||||
}
|
||||
else {
|
||||
spdlog::warn(
|
||||
"Diagrams of type {} are not supported at the moment... ",
|
||||
diagram_type);
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
108
src/main.cc
Normal file
108
src/main.cc
Normal file
@@ -0,0 +1,108 @@
|
||||
#include "config/config.h"
|
||||
#include "puml/class_diagram_generator.h"
|
||||
#include "uml/class_diagram_model.h"
|
||||
#include "uml/class_diagram_visitor.h"
|
||||
#include "uml/compilation_database.h"
|
||||
|
||||
#include <cli11/CLI11.hpp>
|
||||
#include <glob/glob.hpp>
|
||||
#include <spdlog/spdlog.h>
|
||||
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <limits.h>
|
||||
#include <malloc.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
using clanguml::config::config;
|
||||
using clanguml::cx::compilation_database;
|
||||
|
||||
int main(int argc, const char *argv[])
|
||||
{
|
||||
spdlog::set_pattern("[%l] %v");
|
||||
|
||||
CLI::App app{"Clang-based PlantUML generator from C++ sources"};
|
||||
|
||||
std::string config_path{".clanguml"};
|
||||
std::string compilation_database_dir{'.'};
|
||||
bool verbose{false};
|
||||
|
||||
app.add_option(
|
||||
"-c,--config", config_path, "Location of configuration file");
|
||||
app.add_option("-d,--compile-database", compilation_database_dir,
|
||||
"Location of configuration file");
|
||||
app.add_flag("-v,--verbose", verbose, "Verbose logging");
|
||||
|
||||
CLI11_PARSE(app, argc, argv);
|
||||
|
||||
if (verbose)
|
||||
spdlog::set_level(spdlog::level::debug);
|
||||
|
||||
spdlog::info("Loading clang-uml config from {}", config_path);
|
||||
|
||||
auto config = clanguml::config::load(config_path);
|
||||
|
||||
spdlog::info("Loading compilation database from {} directory",
|
||||
config.compilation_database_dir);
|
||||
|
||||
auto db =
|
||||
compilation_database::from_directory(config.compilation_database_dir);
|
||||
|
||||
for (const auto &[name, diagram] : config.diagrams) {
|
||||
spdlog::info("Generating diagram {}.puml", name);
|
||||
clanguml::model::class_diagram::diagram d;
|
||||
d.name = name;
|
||||
|
||||
// Get all translation units matching the glob from diagram
|
||||
// configuration
|
||||
std::vector<std::filesystem::path> translation_units{};
|
||||
for (const auto &g : diagram->glob) {
|
||||
spdlog::debug("Processing glob: {}", g);
|
||||
const auto matches = glob::glob(g);
|
||||
std::copy(matches.begin(), matches.end(),
|
||||
std::back_inserter(translation_units));
|
||||
}
|
||||
|
||||
// Process all matching translation units
|
||||
for (const auto &tu_path : translation_units) {
|
||||
spdlog::debug("Processing translation unit: {}",
|
||||
std::filesystem::canonical(tu_path).c_str());
|
||||
|
||||
auto tu = db.parse_translation_unit(tu_path);
|
||||
|
||||
auto cursor = clang_getTranslationUnitCursor(tu);
|
||||
|
||||
if (clang_Cursor_isNull(cursor)) {
|
||||
spdlog::debug("CURSOR IS NULL");
|
||||
}
|
||||
|
||||
spdlog::debug("Cursor kind: {}",
|
||||
clang_getCString(clang_getCursorKindSpelling(cursor.kind)));
|
||||
spdlog::debug("Cursor name: {}",
|
||||
clang_getCString(clang_getCursorDisplayName(cursor)));
|
||||
|
||||
clanguml::visitor::class_diagram::tu_context ctx(d);
|
||||
auto res = clang_visitChildren(cursor,
|
||||
clanguml::visitor::class_diagram::translation_unit_visitor,
|
||||
&ctx);
|
||||
|
||||
spdlog::debug("Processing result: {}", res);
|
||||
}
|
||||
|
||||
std::filesystem::path path{"puml/" + d.name + ".puml"};
|
||||
std::ofstream ofs;
|
||||
ofs.open(path, std::ofstream::out | std::ofstream::trunc);
|
||||
|
||||
auto generator = clanguml::generators::class_diagram::puml::generator(
|
||||
dynamic_cast<clanguml::config::class_diagram &>(*diagram), d);
|
||||
|
||||
ofs << generator;
|
||||
|
||||
ofs.close();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
88
src/uml/class_diagram_model.h
Normal file
88
src/uml/class_diagram_model.h
Normal file
@@ -0,0 +1,88 @@
|
||||
#pragma once
|
||||
|
||||
#include <clang-c/CXCompilationDatabase.h>
|
||||
#include <clang-c/Index.h>
|
||||
#include <spdlog/spdlog.h>
|
||||
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <variant>
|
||||
|
||||
namespace clanguml {
|
||||
namespace model {
|
||||
namespace class_diagram {
|
||||
|
||||
enum class scope_t { kPublic, kProtected, kPrivate };
|
||||
|
||||
enum class relationship_t {
|
||||
kExtension,
|
||||
kComposition,
|
||||
kAggregation,
|
||||
kContainment,
|
||||
kOwnership,
|
||||
kAssociation
|
||||
};
|
||||
|
||||
struct element {
|
||||
std::string name;
|
||||
std::vector<std::string> namespace_;
|
||||
};
|
||||
|
||||
struct class_element {
|
||||
scope_t scope;
|
||||
std::string name;
|
||||
std::string type;
|
||||
};
|
||||
|
||||
struct class_member : public class_element {
|
||||
bool is_relationship{false};
|
||||
};
|
||||
|
||||
struct method_argument {
|
||||
std::string type;
|
||||
std::string name;
|
||||
};
|
||||
|
||||
struct class_method : public class_element {
|
||||
std::vector<method_argument> arguments;
|
||||
};
|
||||
|
||||
struct class_parent {
|
||||
enum class access_t { kPublic, kProtected, kPrivate };
|
||||
std::string name;
|
||||
bool is_virtual{false};
|
||||
access_t access;
|
||||
};
|
||||
|
||||
struct class_relationship {
|
||||
relationship_t type{relationship_t::kAssociation};
|
||||
std::string destination;
|
||||
std::string cardinality_source;
|
||||
std::string cardinality_destination;
|
||||
std::string label;
|
||||
};
|
||||
|
||||
struct class_ : public element {
|
||||
bool is_struct{false};
|
||||
bool is_template{false};
|
||||
std::vector<class_member> members;
|
||||
std::vector<class_method> methods;
|
||||
std::vector<class_parent> bases;
|
||||
std::vector<std::string> inner_classes;
|
||||
|
||||
std::vector<class_relationship> relationships;
|
||||
};
|
||||
|
||||
struct enum_ : public element {
|
||||
std::vector<std::string> constants;
|
||||
};
|
||||
|
||||
struct diagram {
|
||||
std::string name;
|
||||
std::vector<class_> classes;
|
||||
std::vector<enum_> enums;
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
353
src/uml/class_diagram_visitor.h
Normal file
353
src/uml/class_diagram_visitor.h
Normal file
@@ -0,0 +1,353 @@
|
||||
#pragma once
|
||||
|
||||
#include "class_diagram_model.h"
|
||||
|
||||
#include <clang-c/CXCompilationDatabase.h>
|
||||
#include <clang-c/Index.h>
|
||||
#include <spdlog/spdlog.h>
|
||||
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
namespace clanguml {
|
||||
namespace visitor {
|
||||
namespace class_diagram {
|
||||
|
||||
using clanguml::model::class_diagram::class_;
|
||||
using clanguml::model::class_diagram::class_member;
|
||||
using clanguml::model::class_diagram::class_method;
|
||||
using clanguml::model::class_diagram::class_parent;
|
||||
using clanguml::model::class_diagram::class_relationship;
|
||||
using clanguml::model::class_diagram::diagram;
|
||||
using clanguml::model::class_diagram::enum_;
|
||||
using clanguml::model::class_diagram::relationship_t;
|
||||
using clanguml::model::class_diagram::scope_t;
|
||||
|
||||
template <typename T> struct element_visitor_context {
|
||||
element_visitor_context(T &e)
|
||||
: element(e)
|
||||
{
|
||||
}
|
||||
CXCursorKind current_cursor_kind;
|
||||
std::vector<std::string> namespace_;
|
||||
|
||||
T &element;
|
||||
};
|
||||
|
||||
struct class_visitor_context : element_visitor_context<class_> {
|
||||
class_visitor_context(class_ &c)
|
||||
: element_visitor_context<class_>(c)
|
||||
{
|
||||
}
|
||||
scope_t scope;
|
||||
};
|
||||
|
||||
struct tu_context {
|
||||
tu_context(diagram &d)
|
||||
: diagram(d)
|
||||
{
|
||||
}
|
||||
|
||||
std::vector<std::string> namespace_;
|
||||
diagram &diagram;
|
||||
};
|
||||
|
||||
enum CXChildVisitResult visit_if_cursor_valid(
|
||||
CXCursor cursor, std::function<void(CXCursor)> f)
|
||||
{
|
||||
enum CXChildVisitResult ret = CXChildVisit_Break;
|
||||
CXString cursorName = clang_getCursorSpelling(cursor);
|
||||
if (clang_isCursorDefinition(cursor)) {
|
||||
if (*clang_getCString(cursorName)) {
|
||||
f(cursor);
|
||||
ret = CXChildVisit_Continue;
|
||||
}
|
||||
else {
|
||||
ret = CXChildVisit_Recurse;
|
||||
}
|
||||
}
|
||||
else {
|
||||
ret = CXChildVisit_Continue;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static enum CXChildVisitResult enum_visitor(
|
||||
CXCursor cursor, CXCursor parent, CXClientData client_data)
|
||||
{
|
||||
auto e = (struct enum_ *)client_data;
|
||||
|
||||
CXString cursorName = clang_getCursorSpelling(cursor);
|
||||
std::string cursor_name_str = clang_getCString(cursorName);
|
||||
|
||||
spdlog::info(
|
||||
"Visiting enum {}: {} - {}:{}", e->name, cursor_name_str, cursor.kind);
|
||||
|
||||
enum CXChildVisitResult ret = CXChildVisit_Break;
|
||||
switch (cursor.kind) {
|
||||
case CXCursor_EnumConstantDecl:
|
||||
visit_if_cursor_valid(
|
||||
cursor, [e, cursor_name_str](CXCursor cursor) {
|
||||
spdlog::info("Adding enum constant {}::{}", e->name,
|
||||
cursor_name_str);
|
||||
|
||||
e->constants.emplace_back(cursor_name_str);
|
||||
});
|
||||
|
||||
ret = CXChildVisit_Continue;
|
||||
break;
|
||||
default:
|
||||
ret = CXChildVisit_Continue;
|
||||
break;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static enum CXChildVisitResult class_visitor(
|
||||
CXCursor cursor, CXCursor parent, CXClientData client_data)
|
||||
{
|
||||
auto c = (struct class_ *)client_data;
|
||||
|
||||
CXString cursorName = clang_getCursorSpelling(cursor);
|
||||
std::string cursor_name_str = clang_getCString(cursorName);
|
||||
|
||||
spdlog::info("Visiting {}: {} - {}:{}", c->is_struct ? "struct" : "class",
|
||||
c->name, cursor_name_str, cursor.kind);
|
||||
|
||||
enum CXChildVisitResult ret = CXChildVisit_Break;
|
||||
switch (cursor.kind) {
|
||||
case CXCursor_CXXMethod:
|
||||
case CXCursor_Constructor:
|
||||
case CXCursor_Destructor:
|
||||
case CXCursor_FunctionTemplate: {
|
||||
visit_if_cursor_valid(
|
||||
cursor, [c, cursor_name_str](CXCursor cursor) {
|
||||
class_method m;
|
||||
m.name = cursor_name_str;
|
||||
m.type = clang_getCString(clang_getTypeSpelling(
|
||||
clang_getResultType(clang_getCursorType(cursor))));
|
||||
|
||||
spdlog::info("Adding method {} {}::{}()", m.type, c->name,
|
||||
cursor_name_str);
|
||||
|
||||
c->methods.emplace_back(std::move(m));
|
||||
});
|
||||
ret = CXChildVisit_Continue;
|
||||
break;
|
||||
}
|
||||
case CXCursor_FieldDecl: {
|
||||
visit_if_cursor_valid(cursor, [c, cursor_name_str](CXCursor cursor) {
|
||||
auto t = clang_getCursorType(cursor);
|
||||
class_member m;
|
||||
m.name = cursor_name_str;
|
||||
m.type = clang_getCString(clang_getTypeSpelling(t));
|
||||
|
||||
spdlog::info("Adding member {} {}::{}", m.type, c->name,
|
||||
cursor_name_str);
|
||||
|
||||
relationship_t relationship_type = relationship_t::kOwnership;
|
||||
|
||||
// Parse the field declaration to determine the relationship
|
||||
// type
|
||||
if (!clang_isPODType(t)) {
|
||||
while (true) {
|
||||
if (t.kind == CXType_Pointer) {
|
||||
relationship_type = relationship_t::kAssociation;
|
||||
t = clang_getPointeeType(t);
|
||||
continue;
|
||||
}
|
||||
else if (t.kind == CXType_LValueReference) {
|
||||
relationship_type = relationship_t::kAggregation;
|
||||
t = clang_getPointeeType(t);
|
||||
continue;
|
||||
}
|
||||
else if (t.kind == CXType_RValueReference) {
|
||||
relationship_type = relationship_t::kAssociation;
|
||||
t = clang_getPointeeType(t);
|
||||
continue;
|
||||
}
|
||||
/*else if(t.kind == CXType_Elaborated) {
|
||||
t = clang_Type_getNamedType(t);
|
||||
continue;
|
||||
}*/
|
||||
else /*if (t.kind == CXType_Record) */ {
|
||||
spdlog::error("UNKNOWN CXTYPE: {}", t.kind);
|
||||
class_relationship r;
|
||||
auto template_argument_count =
|
||||
clang_Type_getNumTemplateArguments(t);
|
||||
std::string name{
|
||||
clang_getCString(clang_getTypeSpelling(t))};
|
||||
|
||||
if (template_argument_count > 0) {
|
||||
std::vector<CXType> template_arguments;
|
||||
for (int i = 0; i < template_argument_count;
|
||||
i++) {
|
||||
auto tt =
|
||||
clang_Type_getTemplateArgumentAsType(
|
||||
t, i);
|
||||
template_arguments.push_back(tt);
|
||||
}
|
||||
|
||||
if (name.rfind("vector") == 0 ||
|
||||
name.rfind("std::vector") == 0) {
|
||||
r.type = relationship_t::kAggregation;
|
||||
r.destination =
|
||||
clang_getCString(clang_getTypeSpelling(
|
||||
template_arguments[0]));
|
||||
}
|
||||
if (name.rfind("map") == 0 ||
|
||||
name.rfind("std::map") == 0) {
|
||||
r.type = relationship_t::kAggregation;
|
||||
r.destination =
|
||||
clang_getCString(clang_getTypeSpelling(
|
||||
template_arguments[1]));
|
||||
}
|
||||
r.label = m.name;
|
||||
c->relationships.emplace_back(std::move(r));
|
||||
}
|
||||
else {
|
||||
r.destination = name;
|
||||
r.type = relationship_type;
|
||||
r.label = m.name;
|
||||
c->relationships.emplace_back(std::move(r));
|
||||
}
|
||||
|
||||
spdlog::debug(
|
||||
"Adding relationship to: {}", r.destination);
|
||||
}
|
||||
// else {
|
||||
// spdlog::error("UNKNOWN CXTYPE: {}", t.kind);
|
||||
//}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
c->members.emplace_back(std::move(m));
|
||||
});
|
||||
ret = CXChildVisit_Continue;
|
||||
break;
|
||||
}
|
||||
case CXCursor_CXXBaseSpecifier: {
|
||||
CXCursor ref_cursor = clang_getCursorReferenced(cursor);
|
||||
CXString display_name = clang_getCursorDisplayName(ref_cursor);
|
||||
|
||||
auto base_access = clang_getCXXAccessSpecifier(cursor);
|
||||
|
||||
spdlog::error("Found base specifier: {} - {}", cursor_name_str,
|
||||
clang_getCString(display_name));
|
||||
|
||||
class_parent cp;
|
||||
cp.name = clang_getCString(display_name);
|
||||
cp.is_virtual = false;
|
||||
switch (base_access) {
|
||||
case CX_CXXAccessSpecifier::CX_CXXPrivate:
|
||||
cp.access = class_parent::access_t::kPrivate;
|
||||
break;
|
||||
case CX_CXXAccessSpecifier::CX_CXXPublic:
|
||||
cp.access = class_parent::access_t::kPublic;
|
||||
break;
|
||||
case CX_CXXAccessSpecifier::CX_CXXProtected:
|
||||
cp.access = class_parent::access_t::kProtected;
|
||||
break;
|
||||
default:
|
||||
cp.access = class_parent::access_t::kPublic;
|
||||
}
|
||||
|
||||
c->bases.emplace_back(std::move(cp));
|
||||
|
||||
ret = CXChildVisit_Continue;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
ret = CXChildVisit_Continue;
|
||||
break;
|
||||
}
|
||||
|
||||
return ret;
|
||||
};
|
||||
|
||||
static enum CXChildVisitResult translation_unit_visitor(
|
||||
CXCursor cursor, CXCursor parent, CXClientData client_data)
|
||||
{
|
||||
if (clang_Location_isFromMainFile(clang_getCursorLocation(cursor)) == 0) {
|
||||
return CXChildVisit_Continue;
|
||||
}
|
||||
|
||||
struct tu_context *ctx = (struct tu_context *)client_data;
|
||||
|
||||
enum CXChildVisitResult ret = CXChildVisit_Break;
|
||||
|
||||
CXString cursorName = clang_getCursorSpelling(cursor);
|
||||
std::string cursor_name_str = clang_getCString(cursorName);
|
||||
|
||||
spdlog::debug("Visiting cursor: {}", cursor_name_str);
|
||||
|
||||
bool is_struct{false};
|
||||
auto scope{scope_t::kPrivate};
|
||||
switch (cursor.kind) {
|
||||
case CXCursor_StructDecl:
|
||||
spdlog::debug("Found struct declaration: {}", cursor_name_str);
|
||||
|
||||
is_struct = true;
|
||||
|
||||
[[fallthrough]];
|
||||
case CXCursor_ClassTemplate:
|
||||
[[fallthrough]];
|
||||
case CXCursor_ClassDecl: {
|
||||
spdlog::debug("Found class or class template declaration: {}",
|
||||
cursor_name_str);
|
||||
|
||||
scope = scope_t::kPublic;
|
||||
|
||||
visit_if_cursor_valid(
|
||||
cursor, [ctx, is_struct, cursor_name_str](CXCursor cursor) {
|
||||
class_ c{};
|
||||
c.is_struct = is_struct;
|
||||
c.name = cursor_name_str;
|
||||
c.namespace_ = ctx->namespace_;
|
||||
|
||||
clang_visitChildren(cursor, class_visitor, &c);
|
||||
|
||||
ctx->diagram.classes.emplace_back(std::move(c));
|
||||
});
|
||||
|
||||
ret = CXChildVisit_Continue;
|
||||
break;
|
||||
}
|
||||
case CXCursor_EnumDecl: {
|
||||
spdlog::debug("Found enum declaration: {}", cursor_name_str);
|
||||
|
||||
visit_if_cursor_valid(
|
||||
cursor, [ctx, is_struct, cursor_name_str](CXCursor cursor) {
|
||||
enum_ e{};
|
||||
e.name = cursor_name_str;
|
||||
e.namespace_ = ctx->namespace_;
|
||||
|
||||
clang_visitChildren(cursor, enum_visitor, &e);
|
||||
|
||||
ctx->diagram.enums.emplace_back(std::move(e));
|
||||
});
|
||||
ret = CXChildVisit_Continue;
|
||||
|
||||
break;
|
||||
}
|
||||
case CXCursor_Namespace: {
|
||||
spdlog::debug("Found namespace specifier: {}", cursor_name_str);
|
||||
|
||||
ret = CXChildVisit_Recurse;
|
||||
|
||||
break;
|
||||
}
|
||||
default:
|
||||
spdlog::debug("Found cursor: {}", cursor_name_str);
|
||||
|
||||
ret = CXChildVisit_Recurse;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
88
src/uml/compilation_database.cc
Normal file
88
src/uml/compilation_database.cc
Normal file
@@ -0,0 +1,88 @@
|
||||
#include "compilation_database.h"
|
||||
|
||||
#include <filesystem>
|
||||
#include <spdlog/fmt/fmt.h>
|
||||
#include <spdlog/spdlog.h>
|
||||
|
||||
namespace clanguml {
|
||||
namespace cx {
|
||||
compilation_database::compilation_database(CXCompilationDatabase &&d)
|
||||
: m_database{std::move(d)}
|
||||
, m_index{clang_createIndex(0, 1)}
|
||||
{
|
||||
}
|
||||
|
||||
compilation_database::~compilation_database()
|
||||
{
|
||||
clang_CompilationDatabase_dispose(m_database);
|
||||
}
|
||||
|
||||
compilation_database compilation_database::from_directory(
|
||||
const std::string &dir)
|
||||
{
|
||||
CXCompilationDatabase_Error error;
|
||||
auto path = std::filesystem::path{dir};
|
||||
CXCompilationDatabase cdb =
|
||||
clang_CompilationDatabase_fromDirectory(path.c_str(), &error);
|
||||
|
||||
if (error != CXCompilationDatabase_Error::CXCompilationDatabase_NoError) {
|
||||
throw std::runtime_error(fmt::format(
|
||||
"Cannot load compilation database database from: {}", dir));
|
||||
}
|
||||
|
||||
return compilation_database{std::move(cdb)};
|
||||
}
|
||||
|
||||
CXTranslationUnit compilation_database::parse_translation_unit(
|
||||
const std::string &path)
|
||||
{
|
||||
const auto p = std::filesystem::canonical(path);
|
||||
|
||||
CXCompileCommands compile_commands =
|
||||
clang_CompilationDatabase_getCompileCommands(m_database, p.c_str());
|
||||
|
||||
unsigned int compile_commands_count =
|
||||
clang_CompileCommands_getSize(compile_commands);
|
||||
|
||||
int i;
|
||||
// for (i = 0; i < compile_commands_count; i++) {
|
||||
CXCompileCommand compile_command =
|
||||
clang_CompileCommands_getCommand(compile_commands, 0);
|
||||
|
||||
auto cc_filename = clang_CompileCommand_getFilename(compile_command);
|
||||
spdlog::debug(
|
||||
"Processing compile command file: {}", clang_getCString(cc_filename));
|
||||
|
||||
auto num_args = clang_CompileCommand_getNumArgs(compile_command);
|
||||
|
||||
char **arguments = NULL;
|
||||
if (num_args) {
|
||||
int j;
|
||||
arguments = (char **)malloc(sizeof(char *) * num_args);
|
||||
for (j = 0; j < num_args; ++j) {
|
||||
CXString arg = clang_CompileCommand_getArg(compile_command, j);
|
||||
spdlog::debug("Processing argument: {}", clang_getCString(arg));
|
||||
arguments[j] = strdup(clang_getCString(arg));
|
||||
clang_disposeString(arg);
|
||||
}
|
||||
}
|
||||
|
||||
CXTranslationUnit tu = clang_parseTranslationUnit(m_index, nullptr,
|
||||
(const char *const *)arguments, num_args, NULL, 0,
|
||||
CXTranslationUnit_None);
|
||||
|
||||
if (num_args) {
|
||||
int j;
|
||||
for (j = 0; j < num_args; ++j) {
|
||||
free(arguments[j]);
|
||||
}
|
||||
free(arguments);
|
||||
}
|
||||
//}
|
||||
|
||||
return tu;
|
||||
}
|
||||
|
||||
CXCompilationDatabase &compilation_database::db() { return m_database; }
|
||||
}
|
||||
}
|
||||
32
src/uml/compilation_database.h
Normal file
32
src/uml/compilation_database.h
Normal file
@@ -0,0 +1,32 @@
|
||||
#pragma once
|
||||
|
||||
#include <clang-c/CXCompilationDatabase.h>
|
||||
#include <clang-c/Index.h>
|
||||
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
namespace clanguml {
|
||||
namespace cx {
|
||||
|
||||
class compilation_database {
|
||||
public:
|
||||
compilation_database(CXCompilationDatabase &&d);
|
||||
~compilation_database();
|
||||
|
||||
CXCompilationDatabase &db();
|
||||
|
||||
CXIndex &index();
|
||||
|
||||
CXTranslationUnit parse_translation_unit(
|
||||
const std::string &path);
|
||||
|
||||
static compilation_database from_directory(const std::string &dir);
|
||||
|
||||
private:
|
||||
CXCompilationDatabase m_database;
|
||||
CXIndex m_index;
|
||||
};
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user