Args

args.h

class Args

Public Functions

Args() = delete

Args(const Args&) = delete

Args(Args&&) = delete

Public Static Functions

static Instance &Init()

static void Deinit()

static bool IsInit()

static bool IsParsed()

static bool Clean()

static env::LogLevel GetLogLevel()

static const fs::path &GetProjectRootDir()

static const fs::path &GetProjectBuildDir()

class Instance

Public Functions

Instance &AddToolchain(const std::string &name, const std::string &description, ArgToolchain &out, const ArgToolchain &initial = ArgToolchain())

Add toolchain with a unique name and description.

Parameters

• out – Receive the toolchain information through the CLI

• initial – Set the default toolchain information as a fallback

Instance &AddTarget(const std::string &name, const std::string &description, ArgTarget &out, const ArgTarget &initial = ArgTarget())

Add toolchain with a unique name and description.

Parameters

• out – Receive the toolchain information through the CLI

• initial – Set the default toolchain information as a fallback

Instance &AddCustomCallback(const std::function<void(CLI::App&)> &add_cb)

Custom callback for data.

Parameters

add_cb – Add callback that exposes underlying CLI::App

Instance &AddCustomData(ArgCustom &data)

Add custom data.

Parameters

data – Derive from buildcc::ArgCustom and override the Add API

Public Static Functions

static void Parse(int argc, const char *const *argv)

Parse command line information to CLI11.

Parameters

• argc – from int main(int argc, char ** argv)

• argv – from int main(int argc, char ** argv)

struct Internal

Public Members

Instance instance

CLI::App app = {"BuildCC Buildsystem"}

CLI::App *toolchain = {nullptr}

CLI::App *target = {nullptr}

struct ArgCustom

Public Functions

virtual void Add(CLI::App &app) = 0

struct ArgToolchainState

Toolchain State used to selectively build and test targets.

Public Functions

inline ArgToolchainState(bool b = false, bool t = false)

Public Members

bool build

bool test

class ArgToolchain

Toolchain Arg used to receive toolchain information through the command line Bundled with Toolchain State.

Public Functions

inline ArgToolchain()

inline ArgToolchain(ToolchainId initial_id, const std::string &initial_name, const ToolchainExecutables &initial_executables, const ToolchainConfig &initial_config)

inline Toolchain &ConstructToolchain()

Public Members

ArgToolchainState state

ToolchainId id

std::string name

ToolchainExecutables executables

ToolchainConfig config

struct ArgTarget

Public Functions

inline ArgTarget()

inline TargetConfig GetTargetConfig()

Public Members

std::string compile_command

std::string link_command

Example

using namespace buildcc;

struct CustomData : ArgCustom {
    void Add(CLI::App & app) override {
        // setup your app from data1, data2, data3, data...
        // NOTE: The Add method should not be invoked by the user
        // NOTE: The Add method is only expected to be invoked once, not multiple times.
    }

    std::string data1;
    int data2;
    float data3;
    // etc
};

int main(int argc, char ** argv) {
    ArgToolchain arg_gcc_toolchain;
    ArgCustomData custom_data;
    Args::Init()
        .AddToolchain("gcc", "Generic GCC toolchain", arg_gcc_toolchain)
        .AddCustomCallback([](CLI::App &app) {});
        .AddCustomData(custom_data);
        .Parse(argc, argv);

    // Root
    Args::GetProjectRootDir(); // Contains ``root_dir`` value
    Args::GetProjectBuildDir(); // Contains ``build_dir`` value
    Args::GetLogLevel(); // Contains ``loglevel`` enum
    Args::Clean(); // Contains ``clean`` value

    // Toolchain
    // .build, .test
    arg_gcc_toolchain.state;
    // .id, .name, .asm_compiler, .c_compiler, .cpp_compiler, .archiver, .linker -> BaseToolchain
    auto &gcc_toolchain = arg_gcc_toolchain;
    gcc_toolchain.SetToolchainInfoFunc(GlobalToolchainInfo::Get(gcc_toolchain.id));
    return 0;
}

# Root
root_dir = ""
build_dir = "_build"
loglevel = "trace"
clean = true

# Toolchain
[toolchain.gcc]
build = true
test = true

id = "gcc"
name = "x86_64-linux-gnu"
asm_compiler = "as"
c_compiler = "gcc"
cpp_compiler = "g++"
archiver = "ar"
linker = "ld"