clanguml::common Namespace Reference

Detailed Description

This namespace provides common interfaces for all kinds of diagrams.

The core diagram functionality is divided into 3 groups: visitor, model and generators.

Namespaces
namespace	generators
namespace	model
namespace	visitor

Classes
class	compilation_database
	Custom compilation database class. More...
class	eid_t
	Universal class for representing all kinds of Id's in the diagram model. More...
class	optional_ref
	Simple optional reference type. More...
struct	or_regex
	Convenience class for configuration options with regex support. More...
struct	path_or_regex
struct	regex
	Wrapper around std::regex, which contains original pattern. More...

Typedefs
using	compilation_database_ptr = std::unique_ptr< compilation_database >
template<typename T >
using	opt_ref = optional_ref< T >
template<typename T >
using	reference_vector = std::vector< std::reference_wrapper< T > >
template<typename T >
using	reference_set = std::unordered_set< std::reference_wrapper< T > >
using	string_or_regex = or_regex< std::string >
using	namespace_or_regex = common::or_regex< common::model::namespace_ >

Enumerations
enum class	generator_type_t { plantuml , json , mermaid }

Functions
model::access_t	access_specifier_to_access_t (clang::AccessSpecifier access_specifier)
	Convert clang::AccessSpecifier to.
model::namespace_	get_tag_namespace (const clang::TagDecl &declaration)
model::namespace_	get_template_namespace (const clang::TemplateDecl &declaration)
std::string	get_tag_name (const clang::TagDecl &declaration)
	Generate full qualified name for clang::TagDecl instance.
std::string	to_string (const clang::ArrayType &array_type, const clang::ASTContext &ctx, bool try_canonical, std::vector< std::string > &dimensions)
std::string	to_string (const clang::QualType &type, const clang::ASTContext &ctx, bool try_canonical)
std::string	to_string (const clang::RecordType &type, const clang::ASTContext &ctx, bool try_canonical)
std::string	to_string (const clang::TemplateArgument &arg, const clang::ASTContext *ctx)
std::string	to_string (const clang::TemplateName &templ)
std::string	to_string (const clang::Expr *expr)
std::string	to_string (const clang::ValueDecl *val)
std::string	to_string (const clang::Stmt *stmt)
std::string	to_string (const clang::FunctionTemplateDecl *decl)
std::string	to_string (const clang::TypeConstraint *tc)
std::string	get_source_text_raw (clang::SourceRange range, const clang::SourceManager &sm)
	Get raw text of specific source range.
std::string	get_source_text (clang::SourceRange range, const clang::SourceManager &sm)
	Get printable range of text of specific source range.
std::tuple< unsigned int, unsigned int, std::string >	extract_template_parameter_index (const std::string &type_parameter)
	Extract template depth and index.
void	ensure_lambda_type_is_relative (const config::diagram &config, std::string &parameter_type)
bool	is_subexpr_of (const clang::Stmt *parent_stmt, const clang::Stmt *sub_stmt)
	Check if an expression is contained in another expression.
template<>
eid_t	to_id (const std::string &full_name)
eid_t	to_id (const clang::QualType &type, const clang::ASTContext &ctx)
template<>
eid_t	to_id (const clang::NamespaceDecl &declaration)
template<>
eid_t	to_id (const clang::RecordDecl &declaration)
template<>
eid_t	to_id (const clang::EnumDecl &declaration)
template<>
eid_t	to_id (const clang::TagDecl &declaration)
template<>
eid_t	to_id (const clang::CXXRecordDecl &declaration)
template<>
eid_t	to_id (const clang::EnumType &t)
template<>
eid_t	to_id (const std::filesystem::path &file)
template<>
eid_t	to_id (const clang::TemplateArgument &template_argument)
std::pair< common::model::namespace_, std::string >	split_ns (const std::string &full_name)
	Split qualified name to namespace and name.
std::vector< common::model::template_parameter >	parse_unexposed_template_params (const std::string &params, const std::function< std::string(const std::string &)> &ns_resolve, int depth=0)
	Parse unexposed (available as string) template params.
bool	is_type_parameter (const std::string &t)
bool	is_qualifier (const std::string &q)
bool	is_bracket (const std::string &b)
bool	is_identifier_character (char c)
bool	is_identifier (const std::string &t)
bool	is_keyword (const std::string &t)
bool	is_qualified_identifier (const std::string &t)
bool	is_type_token (const std::string &t)
std::string	format_condition_text (const std::string &condition_text)
std::string	get_condition_text (clang::SourceManager &sm, clang::IfStmt *stmt)
std::string	get_condition_text (clang::SourceManager &sm, clang::WhileStmt *stmt)
std::string	get_condition_text (clang::SourceManager &sm, clang::CXXForRangeStmt *stmt)
std::string	get_condition_text (clang::SourceManager &sm, clang::ForStmt *stmt)
std::string	get_condition_text (clang::SourceManager &sm, clang::DoStmt *stmt)
std::string	get_condition_text (clang::SourceManager &sm, clang::ConditionalOperator *stmt)
clang::QualType	dereference (clang::QualType type)
std::pair< clang::QualType, std::deque< common::model::context > >	consume_type_context (clang::QualType type)
	Extract type context and return raw type.
std::vector< std::string >	tokenize_unexposed_template_parameter (const std::string &t)
bool	parse_source_location (const std::string &location_str, std::string &file, unsigned &line, unsigned &column)
clang::RawComment *	get_expression_raw_comment (const clang::SourceManager &sm, const clang::ASTContext &context, const clang::Stmt *stmt)
	Extract a comment before or next to a statement.
clang::RawComment *	get_declaration_raw_comment (const clang::SourceManager &sm, const clang::ASTContext &context, const clang::Decl *decl)
clang::RawComment *	get_raw_comment (const clang::SourceManager &sm, const clang::ASTContext &context, const clang::SourceRange &source_range)
bool	is_coroutine (const clang::FunctionDecl &decl)
bool	is_struct (const clang::NamedDecl *decl)
bool	has_attr (const clang::FunctionDecl *decl, clang::attr::Kind function_attr)
std::optional< size_t >	get_array_size (const clang::ArrayType &type)
template<typename T >
std::string	get_qualified_name (const T &declaration)
	Get qualified name of some Clang declaration.
template<typename T >
eid_t	to_id (const T &declaration)
template<>
eid_t	to_id (const std::string &full_name)
template<>
eid_t	to_id (const clang::NamespaceDecl &declaration)
template<>
eid_t	to_id (const clang::CXXRecordDecl &declaration)
template<>
eid_t	to_id (const clang::RecordDecl &declaration)
template<>
eid_t	to_id (const clang::EnumDecl &declaration)
template<>
eid_t	to_id (const clang::TagDecl &declaration)
template<>
eid_t	to_id (const clang::EnumType &type)
template<>
eid_t	to_id (const clang::TemplateSpecializationType &type)
template<>
eid_t	to_id (const std::filesystem::path &type)
template<typename T , typename P , typename F >
void	if_dyn_cast (P pointer, F &&func)
bool	operator== (const eid_t &lhs, const eid_t &rhs)
bool	operator== (const eid_t &lhs, const uint64_t &v)
bool	operator!= (const eid_t &lhs, const uint64_t &v)
bool	operator!= (const eid_t &lhs, const eid_t &rhs)
bool	operator< (const eid_t &lhs, const eid_t &rhs)
std::string	to_string (const std::string &s)
std::string	to_string (const string_or_regex &sr)
std::string	to_string (const generator_type_t type)
YAML::Emitter &	operator<< (YAML::Emitter &out, const string_or_regex &m)

Typedef Documentation

compilation_database_ptr

using clanguml::common::compilation_database_ptr = typedef std::unique_ptr<compilation_database>

Definition at line 126 of file compilation_database.h.

namespace_or_regex

using clanguml::common::namespace_or_regex = typedef common::or_regex<common::model::namespace_>

Definition at line 342 of file types.h.

opt_ref

template<typename T >

using clanguml::common::opt_ref = typedef optional_ref<T>

Definition at line 224 of file types.h.

reference_set

template<typename T >

using clanguml::common::reference_set = typedef std::unordered_set<std::reference_wrapper<T> >

Definition at line 230 of file types.h.

reference_vector

template<typename T >

using clanguml::common::reference_vector = typedef std::vector<std::reference_wrapper<T> >

Definition at line 227 of file types.h.

string_or_regex

using clanguml::common::string_or_regex = typedef or_regex<std::string>

Definition at line 338 of file types.h.

Enumeration Type Documentation

generator_type_t

enum class clanguml::common::generator_type_t

strong

Type of output diagram format generator.

Enumerator
plantuml	Diagrams will be generated in PlantUML format
json	Diagrams will be generated in JSON format
mermaid	Diagrams will be generated in MermaidJS format

Definition at line 86 of file types.h.

                            {
    plantuml, /*!< Diagrams will be generated in PlantUML format */
    json,     /*!< Diagrams will be generated in JSON format */
    mermaid   /*!< Diagrams will be generated in MermaidJS format */
};

Function Documentation

access_specifier_to_access_t()

model::access_t clanguml::common::access_specifier_to_access_t

(

clang::AccessSpecifier

access_specifier

)

Convert clang::AccessSpecifier to.

See also

clanguml::model::access_t

Parameters

access_specifier

Clang member access specifier

Returns

Enum value of

See also

clanguml::model::access_t

Definition at line 25 of file clang_utils.cc.

{
    auto access = model::access_t::kPublic;
    switch (access_specifier) {
    case clang::AccessSpecifier::AS_public:
        access = model::access_t::kPublic;
        break;
    case clang::AccessSpecifier::AS_private:
        access = model::access_t::kPrivate;
        break;
    case clang::AccessSpecifier::AS_protected:
        access = model::access_t::kProtected;
        break;
    default:
        break;
    }
 
    return access;
}

consume_type_context()

std::pair< clang::QualType, std::deque< common::model::context > > clanguml::common::consume_type_context

(

clang::QualType

type

)

Extract type context and return raw type.

This function removes the context for a type, for example for: std::string const& it will return (std::string, [const&])

Parameters

type	Type to process

Returns

(type, [qualifiers])

Definition at line 731 of file clang_utils.cc.

{
    std::deque<common::model::context> res;
 
    while (true) {
        bool try_again{false};
        common::model::context ctx;
 
        if (type.isConstQualified()) {
            ctx.is_const = true;
            try_again = true;
        }
 
        if (type.isVolatileQualified()) {
            ctx.is_volatile = true;
            try_again = true;
        }
 
        if (type->isPointerType() || type->isReferenceType()) {
            if (type.isConstQualified() || type.isVolatileQualified()) {
                ctx.is_ref_const = type.isConstQualified();
                ctx.is_ref_volatile = type.isVolatileQualified();
 
                try_again = true;
            }
        }
 
        if (type->isLValueReferenceType()) {
            ctx.pr = common::model::rpqualifier::kLValueReference;
            try_again = true;
        }
        else if (type->isRValueReferenceType()) {
            ctx.pr = common::model::rpqualifier::kRValueReference;
            try_again = true;
        }
        else if (type->isMemberFunctionPointerType() &&
            type->getPointeeType()->getAs<clang::FunctionProtoType>() !=
                nullptr) {
            const auto ref_qualifier =
                type->getPointeeType()                  // NOLINT
                    ->getAs<clang::FunctionProtoType>() // NOLINT
                    ->getRefQualifier();
 
            if (ref_qualifier == clang::RefQualifierKind::RQ_RValue) {
                ctx.pr = common::model::rpqualifier::kRValueReference;
                try_again = true;
            }
            else if (ref_qualifier == clang::RefQualifierKind::RQ_LValue) {
                ctx.pr = common::model::rpqualifier::kLValueReference;
                try_again = true;
            }
        }
        else if (type->isPointerType()) {
            ctx.pr = common::model::rpqualifier::kPointer;
            try_again = true;
        }
 
        if (try_again) {
            if (type->isPointerType()) {
                if (type->getPointeeType().isConstQualified())
                    ctx.is_const = true;
                if (type->getPointeeType().isVolatileQualified())
                    ctx.is_volatile = true;
 
                type = type->getPointeeType().getUnqualifiedType();
            }
            else if (type->isReferenceType()) {
                if (type.getNonReferenceType().isConstQualified())
                    ctx.is_const = true;
                if (type.getNonReferenceType().isVolatileQualified())
                    ctx.is_volatile = true;
 
                type = type.getNonReferenceType().getUnqualifiedType();
            }
            else if (type.isConstQualified() || type.isVolatileQualified()) {
                ctx.is_const = type.isConstQualified();
                ctx.is_volatile = type.isVolatileQualified();
                type = type.getUnqualifiedType();
            }
 
            res.push_front(ctx);
 
            if (type->isMemberFunctionPointerType())
                return std::make_pair(type, res);
        }
        else
            return std::make_pair(type, res);
    }
}

dereference()

clang::QualType clanguml::common::dereference

(

clang::QualType

type

)

Definition at line 714 of file clang_utils.cc.

{
    auto res = type;
 
    while (true) {
        if (res->isReferenceType())
            res = res.getNonReferenceType();
        else if (res->isPointerType())
            res = res->getPointeeType();
        else
            break;
    }
 
    return res;
}

ensure_lambda_type_is_relative()

void clanguml::common::ensure_lambda_type_is_relative	(	const config::diagram &	config,
		std::string &	parameter_type
	)

Definition at line 372 of file clang_utils.cc.

{
#ifdef _MSC_VER
    auto root_name =
        fmt::format("{}", std::filesystem::current_path().root_name().string());
#else
    auto root_name = std::string{"/"};
#endif
 
    std::string lambda_prefix{fmt::format("(lambda at {}", root_name)};
 
    while (parameter_type.find(lambda_prefix) != std::string::npos) {
        auto lambda_begin = parameter_type.find(lambda_prefix);
        auto lambda_prefix_size = lambda_prefix.size();
#ifdef _MSC_VER
        // Skip the `\` or `/` after drive letter and semicolon
        lambda_prefix_size++;
#endif
        auto absolute_lambda_path_end =
            parameter_type.find(':', lambda_begin + lambda_prefix_size);
        auto absolute_lambda_path = parameter_type.substr(
            lambda_begin + lambda_prefix_size - 1,
            absolute_lambda_path_end - (lambda_begin + lambda_prefix_size - 1));
 
        auto relative_lambda_path = util::path_to_url(
            config.make_path_relative(absolute_lambda_path).string());
 
        parameter_type = fmt::format("{}(lambda at {}{}",
            parameter_type.substr(0, lambda_begin), relative_lambda_path,
            parameter_type.substr(absolute_lambda_path_end));
    }
}

extract_template_parameter_index()

std::tuple< unsigned int, unsigned int, std::string > clanguml::common::extract_template_parameter_index

(

const std::string &

type_parameter

)

Extract template depth and index.

This function extracts template depth and index values from Clang's type-parameter- names.

Parameters

type_parameter

Clang's type parameter string

Returns

(depth, index, qualifier)

Definition at line 353 of file clang_utils.cc.

{
    assert(type_parameter.find("type-parameter-") == 0);
 
    auto type_parameter_and_suffix = util::split(type_parameter, " ");
 
    auto toks = util::split(
        type_parameter_and_suffix.front().substr(strlen("type-parameter-")),
        "-");
 
    std::string qualifier;
 
    if (type_parameter_and_suffix.size() > 1) {
        qualifier = type_parameter_and_suffix.at(1);
    }
 
    return {std::stoi(toks.at(0)), std::stoi(toks.at(1)), std::move(qualifier)};
}

format_condition_text()

std::string clanguml::common::format_condition_text

(

const std::string &

condition_text

)

Definition at line 645 of file clang_utils.cc.

{
    std::string result{condition_text};
 
    if (result.size() < 2)
        return {};
 
    std::vector<std::string> text_lines = util::split(result, "\n", true);
 
    // Trim each line
    for (auto &line : text_lines) {
        line = util::trim(line);
    }
 
    result = util::join(" ", text_lines);
 
    if (result.at(0) == '(' && result.back() == ')')
        return result.substr(1, result.size() - 2);
 
    return result;
}

get_array_size()

std::optional< size_t > clanguml::common::get_array_size

(

const clang::ArrayType &

type

)

If type is a constant array, return it's number of elements. Otherwise nothing.

Parameters

type

Returns

Number of elements in the array.

Definition at line 1009 of file clang_utils.cc.

{
    if (const auto *constant_array =
            clang::dyn_cast<clang::ConstantArrayType>(&type);
        constant_array != nullptr) {
        return {constant_array->getSize().getZExtValue()};
    }
 
    return {};
}

get_condition_text() [1/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::ConditionalOperator *	stmt
	)

Definition at line 706 of file clang_utils.cc.

{
    auto condition_range = stmt->getCond()->getSourceRange();
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_condition_text() [2/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::CXXForRangeStmt *	stmt
	)

Definition at line 683 of file clang_utils.cc.

{
    auto condition_range = stmt->getRangeStmt()->getSourceRange();
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_condition_text() [3/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::DoStmt *	stmt
	)

Definition at line 699 of file clang_utils.cc.

{
    auto condition_range = stmt->getCond()->getSourceRange();
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_condition_text() [4/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::ForStmt *	stmt
	)

Definition at line 691 of file clang_utils.cc.

{
    auto condition_range =
        clang::SourceRange(stmt->getLParenLoc(), stmt->getRParenLoc());
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_condition_text() [5/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::IfStmt *	stmt
	)

Definition at line 667 of file clang_utils.cc.

{
    auto condition_range =
        clang::SourceRange(stmt->getLParenLoc(), stmt->getRParenLoc());
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_condition_text() [6/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::WhileStmt *	stmt
	)

Definition at line 675 of file clang_utils.cc.

{
    auto condition_range =
        clang::SourceRange(stmt->getLParenLoc(), stmt->getRParenLoc());
 
    return format_condition_text(get_source_text(condition_range, sm));
}

get_declaration_raw_comment()

clang::RawComment * clanguml::common::get_declaration_raw_comment	(	const clang::SourceManager &	sm,
		const clang::ASTContext &	context,
		const clang::Decl *	decl
	)

Definition at line 947 of file clang_utils.cc.

{
    return get_raw_comment(sm, context, decl->getSourceRange());
}

get_expression_raw_comment()

clang::RawComment * clanguml::common::get_expression_raw_comment	(	const clang::SourceManager &	sm,
		const clang::ASTContext &	context,
		const clang::Stmt *	stmt
	)

Extract a comment before or next to a statement.

Parameters

sm	clang::SourceManager reference
context	clang::ASTContext reference
stmt	Pointer to the current clang::Stmt

Returns

Pointer to a clang::RawComment* or nullptr

Definition at line 941 of file clang_utils.cc.

{
    return get_raw_comment(sm, context, stmt->getSourceRange());
}

get_qualified_name()

template<typename T >

std::string clanguml::common::get_qualified_name

(

const T &

declaration

)

Get qualified name of some Clang declaration.

This template is convenient for getting qualified name of various types of clang declarations.

Template Parameters

T	Type of Clang's declaration, e.g. clang::TagDecl

Parameters

declaration

Reference to a clang declaration

Returns

Fully qualified name

Definition at line 69 of file clang_utils.h.

{
    auto qualified_name = declaration.getQualifiedNameAsString();
    util::replace_all(qualified_name, "(anonymous namespace)", "");
    util::replace_all(qualified_name, "::::", "::");
 
    if constexpr (std::is_base_of_v<clang::TagDecl, T>) {
        auto base_name = get_tag_name(declaration);
        model::namespace_ ns{qualified_name};
        ns.pop_back();
        ns = ns | base_name;
 
        return ns.to_string();
    }
 
    return qualified_name;
}

get_raw_comment()

clang::RawComment * clanguml::common::get_raw_comment	(	const clang::SourceManager &	sm,
		const clang::ASTContext &	context,
		const clang::SourceRange &	source_range
	)

Definition at line 953 of file clang_utils.cc.

{
    auto expr_begin = source_range.getBegin();
    const auto expr_begin_line = sm.getSpellingLineNumber(expr_begin);
 
    std::string file_Path = sm.getFilename(expr_begin).str();
 
    auto file_id = sm.getFileID(expr_begin);
 
    if (!context.Comments.empty() &&
        context.Comments.getCommentsInFile(file_id) != nullptr) {
        for (const auto [offset, raw_comment] :
            *context.Comments.getCommentsInFile(sm.getFileID(expr_begin))) {
            const auto comment_end_line = sm.getSpellingLineNumber(
                raw_comment->getSourceRange().getEnd());
 
            if (expr_begin_line == comment_end_line ||
                expr_begin_line == comment_end_line + 1)
                return raw_comment;
        }
    }
 
    return {};
}

get_source_text()

std::string clanguml::common::get_source_text	(	clang::SourceRange	range,
		const clang::SourceManager &	sm
	)

Get printable range of text of specific source range.

Parameters

range	Source range
sm	Source manager reference

Returns

Printable source text

Definition at line 340 of file clang_utils.cc.

{
    const clang::LangOptions lo;
 
    auto start_loc = sm.getSpellingLoc(range.getBegin());
    auto last_token_loc = sm.getSpellingLoc(range.getEnd());
    auto end_loc = clang::Lexer::getLocForEndOfToken(last_token_loc, 0, sm, lo);
    auto printable_range = clang::SourceRange{start_loc, end_loc};
    return get_source_text_raw(printable_range, sm);
}

get_source_text_raw()

std::string clanguml::common::get_source_text_raw	(	clang::SourceRange	range,
		const clang::SourceManager &	sm
	)

Get raw text of specific source range.

Parameters

range	Source range
sm	Source manager reference

Returns

Raw source text

Definition at line 332 of file clang_utils.cc.

{
    return clang::Lexer::getSourceText(
        clang::CharSourceRange::getCharRange(range), sm, clang::LangOptions())
        .str();
}

get_tag_name()

std::string clanguml::common::get_tag_name

(

const clang::TagDecl &

declaration

)

Generate full qualified name for clang::TagDecl instance.

Parameters

declaration

Input declaration

Returns

String representation including any templates, parameters and attribtues

Definition at line 84 of file clang_utils.cc.

{
    auto base_name = declaration.getNameAsString();
 
    if (base_name.empty()) {
        base_name =
            fmt::format("(anonymous_{})", std::to_string(declaration.getID()));
    }
 
    if ((declaration.getParent() != nullptr) &&
        declaration.getParent()->isRecord()) {
        // If the record is nested within another record (e.g. class or struct)
        // we have to maintain a containment namespace in order to ensure
        // unique names within the diagram
        std::deque<std::string> record_parent_names;
        record_parent_names.push_front(base_name);
 
        const auto *cls_parent{declaration.getParent()};
        while (cls_parent->isRecord()) {
            if (const auto *record_decl =
                    clang::dyn_cast<clang::RecordDecl>(cls_parent);
                record_decl != nullptr) {
                record_parent_names.push_front(record_decl->getNameAsString());
            }
            cls_parent = cls_parent->getParent();
        }
        return fmt::format("{}", fmt::join(record_parent_names, "##"));
    }
 
    return base_name;
}

get_tag_namespace()

model::namespace_ clanguml::common::get_tag_namespace

(

const clang::TagDecl &

declaration

)

Get namespace of a specific clang::TagDecl

Parameters

declaration

Reference to clang::TagDecl

Returns

Namespace instance

Definition at line 46 of file clang_utils.cc.

{
    model::namespace_ ns;
 
    const auto *parent{declaration.getParent()};
 
    // First walk up to the nearest namespace, e.g. from nested class or enum
    while ((parent != nullptr) && !parent->isNamespace()) {
        parent = parent->getParent();
    }
 
    // Now build up the namespace
    std::deque<std::string> namespace_tokens;
    while ((parent != nullptr) && parent->isNamespace()) {
        if (const auto *ns_decl = clang::dyn_cast<clang::NamespaceDecl>(parent);
            ns_decl != nullptr) {
            if (!ns_decl->isInline() && !ns_decl->isAnonymousNamespace())
                namespace_tokens.push_front(ns_decl->getNameAsString());
        }
 
        parent = parent->getParent();
    }
 
    for (const auto &ns_token : namespace_tokens) {
        ns |= ns_token;
    }
 
    return ns;
}

get_template_namespace()

model::namespace_ clanguml::common::get_template_namespace

(

const clang::TemplateDecl &

declaration

)

Get namespace of a specific clang::TemplateDecl

Parameters

declaration

Reference to clang::TemplateDecl

Returns

Namespace instance

Definition at line 76 of file clang_utils.cc.

{
    model::namespace_ ns{declaration.getQualifiedNameAsString()};
    ns.pop_back();
 
    return ns;
}

has_attr()

bool clanguml::common::has_attr	(	const clang::FunctionDecl *	decl,
		clang::attr::Kind	function_attr
	)

Check if function declaration contains specified attributed

Parameters

decl	Function declaration
function_attr	Clang function attribute

Returns

True, if decl contains specified function attribute

Definition at line 1002 of file clang_utils.cc.

{
    return std::any_of(decl->attrs().begin(), decl->attrs().end(),
        [function_attr](
            auto &&attr) { return attr->getKind() == function_attr; });
}

if_dyn_cast()

template<typename T , typename P , typename F >

void clanguml::common::if_dyn_cast	(	P	pointer,
		F &&	func
	)

Definition at line 230 of file clang_utils.h.

{
    if (pointer == nullptr)
        return;
 
    if (const auto *dyn_cast_value = clang::dyn_cast<T>(pointer);
        dyn_cast_value) {
        std::forward<F>(func)(dyn_cast_value);
    }
}

is_bracket()

bool clanguml::common::is_bracket

(

const std::string &

b

)

Definition at line 596 of file clang_utils.cc.

{
    return b == "(" || b == ")" || b == "[" || b == "]";
}

is_coroutine()

bool clanguml::common::is_coroutine

(

const clang::FunctionDecl &

decl

)

Check if function or method declaration is a C++20 coroutine.

Parameters

decl	Function declaration

Returns

True, if the function is a C++20 coroutine.

Definition at line 979 of file clang_utils.cc.

{
    const auto *body = decl.getBody();
    return clang::isa_and_nonnull<clang::CoroutineBodyStmt>(body);
}

is_identifier()

bool clanguml::common::is_identifier

(

const std::string &

t

)

Definition at line 606 of file clang_utils.cc.

{
    return std::all_of(t.begin(), t.end(),
        [](const char c) { return is_identifier_character(c); });
}

is_identifier_character()

bool clanguml::common::is_identifier_character

(

char

c

)

Definition at line 601 of file clang_utils.cc.

{
    return std::isalnum(c) != 0 || c == '_';
}

is_keyword()

bool clanguml::common::is_keyword

(

const std::string &

t

)

Definition at line 612 of file clang_utils.cc.

{
    static std::vector<std::string> keywords{"alignas", "alignof", "asm",
        "auto", "bool", "break", "case", "catch", "char", "char16_t",
        "char32_t", "class", "concept", "const", "constexpr", "const_cast",
        "continue", "decltype", "default", "delete", "do", "double",
        "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false",
        "float", "for", "friend", "goto", "if", "inline", "int", "long",
        "mutable", "namespace", "new", "noexcept", "nullptr", "operator",
        "private", "protected", "public", "register", "reinterpret_cast",
        "return", "requires", "short", "signed", "sizeof", "static",
        "static_assert", "static_cast", "struct", "switch", "template", "this",
        "thread_local", "throw", "true", "try", "typedef", "typeid", "typename",
        "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t",
        "while"};
 
    return util::contains(keywords, t);
}

is_qualified_identifier()

bool clanguml::common::is_qualified_identifier

(

const std::string &

t

)

Definition at line 631 of file clang_utils.cc.

{
    return std::isalpha(t.at(0)) != 0 &&
        std::all_of(t.begin(), t.end(), [](const char c) {
            return is_identifier_character(c) || c == ':';
        });
}

is_qualifier()

bool clanguml::common::is_qualifier

(

const std::string &

q

)

Definition at line 591 of file clang_utils.cc.

{
    return q == "&" || q == "&&" || q == "const&";
}

is_struct()

bool clanguml::common::is_struct

(

const clang::NamedDecl *

decl

)

Check if named declaration is a C++ struct.

Parameters

decl	Declaration to check

Returns

True, if declaration represents a struct.

Definition at line 985 of file clang_utils.cc.

{
    if (decl == nullptr)
        return false;
 
    if (const auto *record = clang::dyn_cast<clang::CXXRecordDecl>(decl);
        record) {
        return record->isStruct();
    }
 
    if (const auto *tag = clang::dyn_cast<clang::TagDecl>(decl); tag) {
        return tag->isStruct();
    }
 
    return false;
}

is_subexpr_of()

bool clanguml::common::is_subexpr_of	(	const clang::Stmt *	parent_stmt,
		const clang::Stmt *	sub_stmt
	)

Check if an expression is contained in another expression.

This method returns true if sub_stmt is equal to or is contained in the AST subtree of parent_stmt

Parameters

parent_stmt	Parent statement
sub_stmt	Sub statement

Returns

Definition at line 406 of file clang_utils.cc.

{
    if (parent_stmt == nullptr || sub_stmt == nullptr)
        return false;
 
    if (parent_stmt == sub_stmt)
        return true;
 
    return std::any_of(parent_stmt->child_begin(), parent_stmt->child_end(),
        [sub_stmt](const auto *e) { return is_subexpr_of(e, sub_stmt); });
}

is_type_parameter()

bool clanguml::common::is_type_parameter

(

const std::string &

t

)

Definition at line 586 of file clang_utils.cc.

{
    return t.find("type-parameter-") == 0;
}

is_type_token()

bool clanguml::common::is_type_token

(

const std::string &

t

)

Definition at line 639 of file clang_utils.cc.

{
    return is_type_parameter(t) ||
        (is_identifier(t) && !is_qualifier(t) && !is_bracket(t));
}

operator!=() [1/2]

bool clanguml::common::operator!=	(	const eid_t &	lhs,
		const eid_t &	rhs
	)

Definition at line 72 of file types.cc.

{ return !(lhs == rhs); }

operator!=() [2/2]

bool clanguml::common::operator!=	(	const eid_t &	lhs,
		const uint64_t &	v
	)

Definition at line 59 of file types.cc.

{
    // This is sadly necessary to catch accidental comparisons to empty
    // std::optional<id_t>:
    //
    //     std::optional<id_t> id{};
    //     if(id != 0) { /* id is nullopt, not 0 - so this executes... */ }
    //
    assert(v != 0);
 
    return lhs.value_ != v;
}

operator<()

bool clanguml::common::operator<	(	const eid_t &	lhs,
		const eid_t &	rhs
	)

Definition at line 74 of file types.cc.

{
    if (lhs.is_global_ != rhs.is_global_) {
        return lhs.value_ < rhs.value_ + 1;
    }
 
    return lhs.value_ < rhs.value_; // Compare values if is_global_ are the same
}

operator<<()

YAML::Emitter & clanguml::common::operator<<	(	YAML::Emitter &	out,
		const string_or_regex &	m
	)

Definition at line 23 of file yaml_emitters.cc.

{
    if (std::holds_alternative<std::string>(m.value())) {
        out << std::get<std::string>(m.value());
    }
    else {
        out << YAML::BeginMap;
        out << YAML::Key << "r" << YAML::Value
            << std::get<regex>(m.value()).pattern;
        out << YAML::EndMap;
    }
 
    return out;
}

operator==() [1/2]

bool clanguml::common::operator==	(	const eid_t &	lhs,
		const eid_t &	rhs
	)

Definition at line 52 of file types.cc.

{
    return (lhs.is_global_ == rhs.is_global_) && (lhs.value_ == rhs.value_);
}

operator==() [2/2]

bool clanguml::common::operator==	(	const eid_t &	lhs,
		const uint64_t &	v
	)

Definition at line 57 of file types.cc.

{ return lhs.value_ == v; }

parse_source_location()

bool clanguml::common::parse_source_location	(	const std::string &	location_str,
		std::string &	file,
		unsigned &	line,
		unsigned &	column
	)

Definition at line 904 of file clang_utils.cc.

{
    auto tokens = util::split(location_str, ":");
 
    if (tokens.size() < 3)
        return false;
 
    if (tokens.size() == 4) {
        // Handle Windows paths
        decltype(tokens) tmp_tokens{};
        tmp_tokens.emplace_back(
            fmt::format("{}:{}", tokens.at(0), tokens.at(1)));
        tmp_tokens.emplace_back(tokens.at(2));
        tmp_tokens.emplace_back(tokens.at(3));
 
        tokens = std::move(tmp_tokens);
    }
 
    file = tokens.at(0);
    try {
        line = std::stoi(tokens.at(1));
    }
    catch (std::invalid_argument &e) {
        return false;
    }
 
    try {
        column = std::stoi(tokens.at(2));
    }
    catch (std::invalid_argument &e) {
        column = 0;
    }
 
    return true;
}

parse_unexposed_template_params()

std::vector< common::model::template_parameter > clanguml::common::parse_unexposed_template_params	(	const std::string &	params,
		const std::function< std::string(const std::string &)> &	ns_resolve,
		int	depth = 0
	)

Parse unexposed (available as string) template params.

Parameters

params	String parameters as provided by Clang
ns_resolve	Namespace resolver function
depth	Current depth in the template specification

Returns

Parsed template parameter

Definition at line 494 of file clang_utils.cc.

{
    using common::model::template_parameter;
 
    std::vector<template_parameter> res;
 
    auto it = params.begin();
    while (std::isspace(*it) != 0)
        ++it;
 
    std::string type{};
    std::vector<template_parameter> nested_params;
    bool complete_class_template_argument{false};
 
    while (it != params.end()) {
        if (*it == '<') {
            int nested_level{0};
            auto bracket_match_begin = it + 1;
            auto bracket_match_end = bracket_match_begin;
            while (bracket_match_end != params.end()) {
                if (*bracket_match_end == '<') {
                    nested_level++;
                }
                else if (*bracket_match_end == '>') {
                    if (nested_level > 0)
                        nested_level--;
                    else
                        break;
                }
                else {
                }
                bracket_match_end++;
            }
 
            std::string nested_params_str(
                bracket_match_begin, bracket_match_end);
 
            nested_params = parse_unexposed_template_params(
                nested_params_str, ns_resolve, depth + 1);
 
            if (nested_params.empty()) {
                // We couldn't extract any nested template parameters from
                // `nested_params_str` so just add it as type of template
                // argument as is
                nested_params.emplace_back(
                    template_parameter::make_unexposed_argument(
                        nested_params_str));
            }
 
            it = bracket_match_end - 1;
        }
        else if (*it == '>') {
            complete_class_template_argument = true;
            if (depth == 0) {
                break;
            }
        }
        else if (*it == ',') {
            complete_class_template_argument = true;
        }
        else {
            type += *it;
        }
        if (complete_class_template_argument) {
            auto t = template_parameter::make_unexposed_argument(
                ns_resolve(clanguml::util::trim_typename(type)));
            type = "";
            for (auto &&param : nested_params)
                t.add_template_param(std::move(param));
 
            res.emplace_back(std::move(t));
            complete_class_template_argument = false;
        }
        it++;
    }
 
    if (!type.empty()) {
        auto t = template_parameter::make_unexposed_argument(
            ns_resolve(clanguml::util::trim_typename(type)));
        type = "";
        for (auto &&param : nested_params)
            t.add_template_param(std::move(param));
 
        res.emplace_back(std::move(t));
    }
 
    return res;
}

split_ns()

std::pair< common::model::namespace_, std::string > clanguml::common::split_ns

(

const std::string &

full_name

)

Split qualified name to namespace and name.

Parameters

full_name

Fully qualified element name

Returns

(namespace, name)

Definition at line 481 of file clang_utils.cc.

{
    assert(!full_name.empty());
 
    auto name_before_template = ::clanguml::util::split(full_name, "<")[0];
    auto ns = common::model::namespace_{
        ::clanguml::util::split(name_before_template, "::")};
    auto name = ns.name();
    ns.pop_back();
    return {ns, name};
}

to_id()

template<>

eid_t clanguml::common::to_id

(

const clang::TemplateArgument &

template_argument

)

Definition at line 464 of file clang_utils.cc.

{
    if (template_argument.getKind() == clang::TemplateArgument::Type) {
        if (const auto *enum_type =
                template_argument.getAsType()->getAs<clang::EnumType>();
            enum_type != nullptr)
            return to_id(*enum_type->getAsTagDecl());
 
        if (const auto *record_type =
                template_argument.getAsType()->getAs<clang::RecordType>();
            record_type != nullptr)
            return to_id(*record_type->getAsRecordDecl());
    }
 
    throw std::runtime_error("Cannot generate id for template argument");
}

to_string() [1/13]

std::string clanguml::common::to_string	(	const clang::ArrayType &	array_type,
		const clang::ASTContext &	ctx,
		bool	try_canonical,
		std::vector< std::string > &	dimensions
	)

Definition at line 116 of file clang_utils.cc.

{
    auto maybe_size = get_array_size(array_type);
    std::string array_size =
        maybe_size.has_value() ? std::to_string(maybe_size.value()) : "";
    dimensions.emplace_back(std::move(array_size));
 
    const auto underlying_type = array_type.getElementType();
 
    if (underlying_type->isArrayType())
        return to_string(*underlying_type->getAsArrayTypeUnsafe(), ctx,
            try_canonical, dimensions);
 
    std::string dimensions_str;
    for (const auto &d : dimensions) {
        dimensions_str += fmt::format("[{}]", d);
    }
    return fmt::format(
        "{}{}", to_string(underlying_type, ctx, try_canonical), dimensions_str);
}

to_string() [2/13]

std::string clanguml::common::to_string

(

const clang::Expr *

expr

)

Definition at line 266 of file clang_utils.cc.

{
    const clang::LangOptions lang_options;
    std::string result;
    llvm::raw_string_ostream ostream(result);
    expr->printPretty(ostream, nullptr, clang::PrintingPolicy(lang_options));
 
    return result;
}

to_string() [3/13]

std::string clanguml::common::to_string

(

const clang::FunctionTemplateDecl *

decl

)

Definition at line 291 of file clang_utils.cc.

{
    std::vector<std::string> template_parameters;
    // Handle template function
    for (const auto *parameter : *decl->getTemplateParameters()) {
        if (clang::dyn_cast_or_null<clang::TemplateTypeParmDecl>(parameter) !=
            nullptr) {
            const auto *template_type_parameter =
                clang::dyn_cast_or_null<clang::TemplateTypeParmDecl>(parameter);
 
            std::string template_parameter{
                template_type_parameter->getNameAsString()};
 
            if (template_type_parameter->isParameterPack())
                template_parameter += "...";
 
            template_parameters.emplace_back(std::move(template_parameter));
        }
        else {
            // TODO
        }
    }
    return fmt::format("{}<{}>({})", decl->getQualifiedNameAsString(),
        fmt::join(template_parameters, ","), "");
}

to_string() [4/13]

std::string clanguml::common::to_string	(	const clang::QualType &	type,
		const clang::ASTContext &	ctx,
		bool	try_canonical
	)

Definition at line 139 of file clang_utils.cc.

{
    if (type->isArrayType()) {
        std::vector<std::string> dimensions;
        return to_string(
            *type->getAsArrayTypeUnsafe(), ctx, try_canonical, dimensions);
    }
 
    clang::PrintingPolicy print_policy(ctx.getLangOpts());
    print_policy.SuppressScope = 0;
    print_policy.PrintCanonicalTypes = 0;
 
    std::string result;
 
    result = type.getAsString(print_policy);
 
    if (try_canonical && result.find('<') != std::string::npos) {
        auto canonical_type_name =
            type.getCanonicalType().getAsString(print_policy);
 
        auto result_qualified_template_name =
            result.substr(0, result.find('<'));
        auto result_template_arguments = result.substr(result.find('<'));
 
        auto canonical_qualified_template_name =
            canonical_type_name.substr(0, canonical_type_name.find('<'));
 
        // Choose the longer name (why do I have to do this?)
        if (result_qualified_template_name.size() <
            canonical_qualified_template_name.size()) {
 
            result =
                canonical_qualified_template_name + result_template_arguments;
        }
    }
 
    // If for any reason clang reports the type as empty string, make sure
    // it has some default name
    if (result.empty())
        result = "(anonymous)";
    else if (util::contains(result, "unnamed struct") ||
        util::contains(result, "unnamed union")) {
        const auto *declarationTag = type->getAsTagDecl();
        if (declarationTag == nullptr) {
            result = "(unnamed undeclared)";
        }
        else {
            result = common::get_tag_name(*declarationTag);
        }
    }
    else if (util::contains(result, "anonymous struct") ||
        util::contains(result, "anonymous union")) {
        result = common::get_tag_name(*type->getAsTagDecl());
    }
 
    // Remove trailing spaces after commas in template arguments
    clanguml::util::replace_all(result, ", ", ",");
    clanguml::util::replace_all(result, "> >", ">>");
 
    // Try to get rid of 'type-parameter-X-Y' ugliness
    if (result.find("type-parameter-") != std::string::npos) {
        util::if_not_null(
            common::dereference(type)->getAs<clang::TypedefType>(),
            [&result, &type](auto *p) {
                auto [unqualified_type, context] =
                    common::consume_type_context(type);
                result = p->getDecl()->getNameAsString();
                if (!context.empty()) {
                    std::vector<std::string> deduced_contexts;
 
                    for (const auto &c : context) {
                        deduced_contexts.push_back(c.to_string());
                    }
 
                    result = fmt::format(
                        "{} {}", result, fmt::join(deduced_contexts, " "));
                }
            });
    }
 
    return result;
}

to_string() [5/13]

std::string clanguml::common::to_string	(	const clang::RecordType &	type,
		const clang::ASTContext &	ctx,
		bool	try_canonical
	)

Definition at line 223 of file clang_utils.cc.

{
    return to_string(type.desugar(), ctx, try_canonical);
}

to_string() [6/13]

std::string clanguml::common::to_string

(

const clang::Stmt *

stmt

)

Definition at line 281 of file clang_utils.cc.

{
    const clang::LangOptions lang_options;
    std::string result;
    llvm::raw_string_ostream ostream(result);
    stmt->printPretty(ostream, nullptr, clang::PrintingPolicy(lang_options));
 
    return result;
}

to_string() [7/13]

std::string clanguml::common::to_string	(	const clang::TemplateArgument &	arg,
		const clang::ASTContext *	ctx
	)

Definition at line 229 of file clang_utils.cc.

{
    switch (arg.getKind()) {
    case clang::TemplateArgument::Expression:
        return to_string(arg.getAsExpr());
    case clang::TemplateArgument::Type:
        return to_string(arg.getAsType(), *ctx, false);
    case clang::TemplateArgument::Null:
        return "";
    case clang::TemplateArgument::NullPtr:
        return "nullptr";
    case clang::TemplateArgument::Integral:
        return std::to_string(arg.getAsIntegral().getExtValue());
    case clang::TemplateArgument::Template:
        return to_string(arg.getAsTemplate());
    case clang::TemplateArgument::TemplateExpansion:
        return to_string(arg.getAsTemplateOrTemplatePattern());
    default:
        return "";
    }
}

to_string() [8/13]

std::string clanguml::common::to_string

(

const clang::TemplateName &

templ

)

Definition at line 252 of file clang_utils.cc.

{
    if (templ.getAsTemplateDecl() != nullptr) {
        return templ.getAsTemplateDecl()->getQualifiedNameAsString();
    }
 
    std::string result;
    const clang::LangOptions lang_options;
    llvm::raw_string_ostream ostream(result);
    templ.print(ostream, clang::PrintingPolicy(lang_options));
 
    return result;
}

to_string() [9/13]

std::string clanguml::common::to_string

(

const clang::TypeConstraint *

tc

)

Definition at line 317 of file clang_utils.cc.

{
    if (tc == nullptr)
        return {};
 
    const clang::PrintingPolicy print_policy(
        tc->getNamedConcept()->getASTContext().getLangOpts());
 
    std::string ostream_buf;
    llvm::raw_string_ostream ostream{ostream_buf};
    tc->print(ostream, print_policy);
 
    return ostream.str();
}

to_string() [10/13]

std::string clanguml::common::to_string

(

const clang::ValueDecl *

val

)

Definition at line 276 of file clang_utils.cc.

{
    return val->getQualifiedNameAsString();
}

to_string() [11/13]

std::string clanguml::common::to_string

(

const generator_type_t

type

)

Definition at line 96 of file types.cc.

{
    switch (type) {
    case generator_type_t::plantuml:
        return "plantuml";
    case generator_type_t::mermaid:
        return "mermaid";
    case generator_type_t::json:
        return "json";
    default:
        return "<unknown>";
    }
}

to_string() [12/13]

std::string clanguml::common::to_string

(

const std::string &

s

)

Definition at line 92 of file types.cc.

{ return s; }

to_string() [13/13]

std::string clanguml::common::to_string

(

const string_or_regex &

sr

)

Definition at line 94 of file types.cc.

{ return sr.to_string(); }

tokenize_unexposed_template_parameter()

std::vector< std::string > clanguml::common::tokenize_unexposed_template_parameter

(

const std::string &

t

)

Definition at line 821 of file clang_utils.cc.

{
    std::vector<std::string> result;
 
    auto spaced_out = util::split(t, " ");
 
    for (const auto &word : spaced_out) {
        if (is_qualified_identifier(word)) {
            if (word != "class" && word != "templated" && word != "struct")
                result.emplace_back(word);
            continue;
        }
 
        std::string tok;
 
        for (const char c : word) {
            if (c == '(' || c == ')' || c == '[' || c == ']' || c == '<' ||
                c == '>') {
                if (!tok.empty())
                    result.emplace_back(tok);
                result.emplace_back(std::string{c});
                tok.clear();
            }
            else if (c == ':') {
                if (!tok.empty() && tok != ":") {
                    result.emplace_back(tok);
                    tok = ":";
                }
                else if (tok == ":") {
                    result.emplace_back("::");
                    tok = "";
                }
                else {
                    tok += ':';
                }
            }
            else if (c == ',') {
                if (!tok.empty()) {
                    result.emplace_back(tok);
                }
                result.emplace_back(",");
                tok.clear();
            }
            else if (c == '*') {
                if (!tok.empty()) {
                    result.emplace_back(tok);
                }
                result.emplace_back("*");
                tok.clear();
            }
            else if (c == '.') {
                // This can only be the case if we have a variadic template,
                // right?
                if (tok == "..") {
                    result.emplace_back("...");
                    tok.clear();
                }
                else if (tok == ".") {
                    tok = "..";
                }
                else if (!tok.empty()) {
                    result.emplace_back(tok);
                    tok = ".";
                }
            }
            else {
                tok += c;
            }
        }
 
        tok = util::trim(tok);
 
        if (!tok.empty()) {
            if (tok != "class" && tok != "typename" && word != "struct")
                result.emplace_back(tok);
            tok.clear();
        }
    }
 
    return result;
}