main.cc File Reference

#include "cli/cli_handler.h"
#include "common/compilation_database.h"
#include "common/generators/generators.h"
#include "util/query_driver_output_extractor.h"
#include "util/util.h"
#include <cli11/CLI11.hpp>
#include <spdlog/spdlog.h>
#include <cstring>

Go to the source code of this file.

Functions
int	main (int argc, const char *argv[])

Function Documentation

main()

int main	(	int	argc,
		const char *	argv[]
	)

Definition at line 44 of file main.cc.

{
    cli::cli_handler cli;
 
    try {
        auto res = cli.handle_options(argc, argv);
 
        if (res == cli::cli_flow_t::kExit)
            return 0;
 
        if (res == cli::cli_flow_t::kError)
            return 1;
 
#if !defined(NDEBUG)
        // Catch invalid logger message formats, e.g. missing arguments
        spdlog::set_error_handler([](const std::string & /*msg*/) {
            assert(0 == 1); // NOLINT
        });
#endif
 
        const auto db =
            common::compilation_database::auto_detect_from_directory(
                cli.config);
 
        const auto compilation_database_files = db->getAllFiles();
 
        std::map<std::string /* diagram name */,
            std::vector<std::string> /* translation units */>
            translation_units_map;
 
        // We have to generate the translation units list for each diagram
        // before scheduling tasks, because std::filesystem::current_path
        // cannot be trusted with multiple threads
        common::generators::find_translation_units_for_diagrams(
            cli.diagram_names, cli.config, compilation_database_files,
            translation_units_map);
 
        if (cli.progress) {
            // llvm::errs() output stream mangles the stdout stream , we need
            // to close it here so that it doesn't interfere with the rendering
            // of progress indicators
            llvm::errs().close();
        }
 
        return common::generators::generate_diagrams(cli.diagram_names,
            cli.config, db, cli.get_runtime_config(), translation_units_map);
    }
    catch (error::compilation_database_error &e) {
        if (clanguml::logging::logger_type() == logging::logger_type_t::text) {
            fmt::println(
                "ERROR: Failed to load compilation database from {} due to: {}",
                cli.config.compilation_database_dir(), e.what());
        }
        else {
            LOG_ERROR("Failed to load compilation database from {} due to: {}",
                cli.config.compilation_database_dir(), e.what());
        }
        return 1;
    }
    catch (error::query_driver_no_paths &e) {
        if (clanguml::logging::logger_type() == logging::logger_type_t::text) {
            fmt::println(
                "ERROR: Querying provided compiler driver {} did not provide "
                "any "
                "paths, please make sure the path is correct and that your "
                "compiler is GCC-compatible: {}",
                cli.config.query_driver(), e.what());
        }
        else {
            LOG_ERROR(
                "Querying provided compiler driver {} did not provide any "
                "paths, please make sure the path is correct and that your "
                "compiler is GCC-compatible: {}",
                cli.config.query_driver(), e.what());
        }
        return 1;
    }
    catch (error::diagram_generation_error &e) {
        if (clanguml::logging::logger_type() == logging::logger_type_t::text)
            fmt::println("ERROR: {}", e.what());
        else
            LOG_ERROR("{}", e.what());
        return 1;
    }
    catch (std::exception &e) {
        if (clanguml::logging::logger_type() == logging::logger_type_t::text)
            fmt::println("ERROR: {}", e.what());
        else
            LOG_ERROR("{}", e.what());
        return 1;
    }
 
    return 0;
}