Build.cpp

Go to the documentation of this file.

 
// C++ librarries
#include "../../headers/map.hpp"
#include "array"
#include "stdlib.h"
#include "string"
#include "vector"
// Project headers
#include "../../headers/CBuild_defs.hpp"
#include "../../headers/build/Build.hpp"
#include "../../headers/build_data.hpp"
#include "../../headers/filesystem++.hpp"
#include "../../headers/hasher/hasher.hpp"
#include "../../headers/pkgconfig.hpp"
#include "../../headers/print.hpp"
#include "../../headers/register.hpp"
#include "../../headers/system.hpp"
/* Build.hpp - arguments */
void CBuild::Toolchain::add_compile_arg(std::string arg) {
    // Push compiler arg if it is not an empty string
    if (arg != std::string("")) {
        this->compiler_args.push_back(arg);
    }
}
void CBuild::Toolchain::add_link_arg(std::string arg) {
    // Push linker arg if it is not an empty string
    if (arg != std::string("")) {
        this->link_args.push_back(arg);
    }
}
void CBuild::Toolchain::add_define(std::string def, std::string val) {
    // Create buffer with base of define
    std::string tmp = "-D";
    // Add define only if it is not empty
    if (def != std::string("")) {
        tmp += def;
        // If define value is something, add it
        if (val != std::string("")) {
            tmp += '=';
            tmp += val;
        }
        this->add_compile_arg(tmp);
    }
}
void CBuild::Toolchain::add_undef(std::string def) {
    // Create buffer with base of undefine
    std::string tmp = "-U";
    // Add undefine only if it is not empty
    if (def != std::string("")) {
        tmp += def;
        this->add_compile_arg(tmp);
    }
}
void CBuild::Toolchain::add_include(std::string inc) {
    // Create buffer with base of include
    std::string tmp = "-include \"";
    // Add only if incude is not empty
    if (inc != std::string("")) {
        tmp += inc;
        tmp += "\"";
        this->add_compile_arg(tmp);
    }
}
void CBuild::Toolchain::add_library_include(std::string lib) {
    // Create buffer with base of lib link
    std::string tmp = "-l";
    // Add only if lib name is not emoty
    if (lib != std::string("")) {
        tmp += lib;
        this->add_link_arg(tmp);
    }
}
void CBuild::Toolchain::add_library_dir(std::string inc, std::string lib) {
    // Create buffers with base of include and link pathes
    std::string itmp = "-I";
    std::string ltmp = "-L";
    // Only if two pathes not empty
    if ((inc != std::string("")) && (lib != std::string(""))) {
        itmp += inc;
        ltmp += lib;
        this->add_compile_arg(itmp);
        this->add_link_arg(ltmp);
    }
}
void CBuild::Toolchain::add_requirment(std::string task_, CBuild::stage run_stage) {
    // Add required task only if it's id is non-empty
    if (task_ != std::string("")) {
        this->required.push_back_check(task_, run_stage);
    }
}
void CBuild::Toolchain::warn() {
    // Push all arguments for normal waning (-Wall, -Wextra but
    // -Wno-comments)
    this->add_compile_arg("-Wall");
    this->add_compile_arg("-Wextra");
    this->add_compile_arg("-Wno-comments");
}
void CBuild::Toolchain::static_analizer() {
    // Push all aruments needed for static anlization of code
    this->add_compile_arg("-fanalyzer");
    this->add_compile_arg("-Wanalyzer-too-complex");
}
void CBuild::Toolchain::error() {
    // Push argument for treating warning as errors
    this->add_compile_arg("-Werror");
}
void CBuild::Toolchain::set_standart(std::string std_) {
    // Only if non empty
    if (std_ != std::string("")) {
        // Push corectly formated stadart arg
        this->add_compile_arg(std::string("-std=") + std_);
    }
}
void CBuild::Toolchain::set_type(CBuild::build_type type) {
    this->build_type = type;
}
void CBuild::Toolchain::depends_on(std::string target) {
    // Push target in list of dependencies
    this->depends.push_back(target);
}
void CBuild::Toolchain::depends_on_project(std::string path, std::string name, std::string id,
                                           std::string headers_path) {
    CBuild::Project_dependency dep;
    dep.headers_path = headers_path;
    dep.id = id;
    dep.name = name;
    dep.path = path;
    this->project_deps.push_back(dep);
}
void CBuild::Toolchain::set_profiling_mode() {
    this->add_compile_arg("-pg");
    this->add_link_arg("-pg");
}
void CBuild::Toolchain::set_version_major(int version) {
    this->version_major = version;
}
void CBuild::Toolchain::multithreaded_target() {
    this->add_compile_arg("-pthread");
    this->add_link_arg("-pthread");
}
void CBuild::Toolchain::add_pkgconfig_entry(std::string id) {
    this->pkg_config_include_entries.push_back(id);
}
void CBuild::Toolchain::set_hasher(CBuild::Hash* hasher) {
    this->hasher = hasher;
}
void CBuild::Toolchain::set_name(std::string name) {
    this->name = name;
}
void CBuild::Toolchain::set_id(std::string id) {
    this->id = id;
}
void CBuild::Toolchain::add_external_dependency(CBuild::Dependency* dep) {
    this->dependency_list.push_back(dep);
}
/* Build.hpp - files */
void CBuild::Toolchain::add_file(std::string path) {
    // If path is non-empty
    if (path != std::string("")) {
        // Create new path to file
        CBuild::Path p;
        p.folder = false;
        p.path = path;
        // Push it to list of targets for compilation
        this->targets.push_back(p);
    }
}
void CBuild::Toolchain::add_folder(std::string path) {
    // Only if path is non-empty
    if (path != std::string("")) {
        // Create new path to folder
        CBuild::Path p;
        p.folder = true;
        p.path = path;
        // Push it to list of targets for compilation
        this->targets.push_back(p);
    }
}
/* Build.hpp - helper */
std::string CBuild::Toolchain::gen_out_file(std::string file) {
    // path to base diretory for out files
    std::string base = CBUILD_BUILD_DIR + "/" + this->id + "/" + CBUILD_BUILD_CACHE_DIR + "/";
    // Find dot in file name
    unsigned long pos = file.find_last_of(".");
    // Cut it out
    file = file.substr(0, pos);
    // Replace all slashes by dots
    while (file.find("/") != std::string::npos) {
        file.replace(file.find("/"), std::string("/").size(), ".");
    }
    // Add .o extension
    file += ".o";
    // Return full path
    base += file;
    return base;
}
lib::map<std::string, std::string> CBuild::Toolchain::gen_file_list(bool force_) {
    // File - object
    lib::map<std::string, std::string> ret, for_recomp;
    std::vector<std::string> objects, filelist;
    bool not_use_hash = false;
    // Collect all files from directories
    for (auto elem : this->targets) {
        if (elem.folder) {
            auto files = CBuild::fs::dir(elem.path);
            for (auto file : files) {
                filelist.push_back(CBuild::fs::normalize_relative_path(file));
            }
        } else {
            filelist.push_back(CBuild::fs::normalize_relative_path(elem.path));
        }
    }
    // Create objects list
    for (auto elem : filelist) {
        try {
            for_recomp.push_back(elem, this->gen_out_file(elem));
            objects.push_back(this->gen_out_file(elem));
        } catch (std::exception& e) {
        }
    }
    // If we do dummy, compilation, we do force compilation, assumption based on
    // internal CBuild structure, else get hashes
    if (this->dummy == true) {
        // for_recomp = filelist;
        not_use_hash = true;
    } else if (this->gen_file_list_for_linking) {
        // for_recomp = filelist;
        not_use_hash = true;
    } else {
        // for_recomp = CBuild::get_files(filelist, this->id);
        for_recomp = this->hasher->get_files_for_recompilation(filelist, objects);
        not_use_hash = false;
    }
    // Real force, we need to recalculate hashes here
    if (this->force) {
        // for_recomp = filelist;
        not_use_hash = true;
    }
    // Not force
    // if (!force_) {
    //  // For every target path
    //  for (auto elem : this->targets) {
    //      // If folder
    //      if (elem.folder) {
    //          // For every file in folder
    //          std::vector<std::string> files =
    //              CBuild::fs::dir(elem.path);
    //          for (auto file : files) {
    //              // Check if hash file exists
    //              if (!CBuild::fs::exists(
    //                  this->gen_hash_file(file))) {
    //                  CBuild::fs::create(
    //                      {this->gen_hash_file(file)},
    //                      CBuild::fs::FILE);
    //                  std::ofstream f(
    //                      this->gen_hash_file(file));
    //                  f << "-";
    //                  f.close();
    //              }
    //              // Push file only if hash is different
    //              if (!CBuild::load_hash(
    //                  this->gen_hash_file(file),
    //                  file)) {
    //                  ret.push_back(
    //                      this->cmd_str(file),
    //                      this->cmd_str(
    //                      this->gen_out_file(
    //                          file)));
    //              }
    //          }
    //      }
    //      // If file
    //      else {
    //          std::string file = elem.path;
    //          // Check if hash file exists
    //          if (!CBuild::fs::exists(
    //              this->gen_hash_file(file))) {
    //              CBuild::fs::create(
    //                  {this->gen_hash_file(file)},
    //                  CBuild::fs::FILE);
    //              std::ofstream f(
    //                  this->gen_hash_file(file));
    //              f << "-";
    //              f.close();
    //          }
    //          // Push file only if hash is different
    //          if (!CBuild::load_hash(
    //              this->gen_hash_file(file), file)) {
    //              ret.push_back(
    //                  this->cmd_str(file),
    //                  this->cmd_str(
    //                  this->gen_out_file(file)));
    //          }
    //      }
    //  }
    // }
    // // Force
    // else {
    //  // For every target path
    //  for (auto elem : this->targets) {
    //      // If folder
    //      if (elem.folder) {
    //          // For every file in folder
    //          std::vector<std::string> files =
    //              CBuild::fs::dir(elem.path);
    //          for (auto f : files) {
    //              // Push file
    //              ret.push_back(
    //                  this->cmd_str(f),
    //                  this->cmd_str(
    //                  this->gen_out_file(f)));
    //              // Generate hash file
    //              if (!CBuild::fs::exists(
    //                  this->gen_hash_file(f))) {
    //                  CBuild::fs::create(
    //                      {this->gen_hash_file(f)},
    //                      CBuild::fs::FILE);
    //                  std::ofstream fl(
    //                      this->gen_hash_file(f));
    //                  fl << "-";
    //                  fl.close();
    //              }
    //          }
    //      }
    //      // If file
    //      else {
    //          // Push file
    //          ret.push_back(this->cmd_str(elem.path),
    //                    this->cmd_str(this->gen_out_file(
    //                    elem.path)));
    //          // Generate hash file
    //          if (!CBuild::fs::exists(
    //              this->gen_hash_file(elem.path))) {
    //              CBuild::fs::create(
    //                  {this->gen_hash_file(elem.path)},
    //                  CBuild::fs::FILE);
    //              std::ofstream f(
    //                  this->gen_hash_file(elem.path));
    //              f << "-";
    //              f.close();
    //          }
    //      }
    //  }
    // }
    if (not_use_hash == true) {
        for_recomp.clear();
        for (size_t i = 0; i < filelist.size(); i++) {
            for_recomp.push_back(filelist.at(i), objects.at(i));
        }
    }
    for (auto elem : for_recomp) {
        ret.push_back(this->cmd_str(elem.key), this->cmd_str(elem.data));
    }
    CBuild::print_full("CBuild::Build::gen_file_list() - dbg: ");
    for (unsigned int i = 0; i < ret.size(); i++) {
        CBuild::print_full(ret.at(i).key);
    }
    return ret;
}
lib::map<std::string, std::string> CBuild::Toolchain::gen_file_list_force() {
    bool tmp = this->force;
    this->force = true;
    auto ret = this->gen_file_list(true);
    this->force = tmp;
    return ret;
}
std::string CBuild::Toolchain::get_compile_args() {
    std::string ret = "";
    for (auto arg : this->compiler_args) {
        ret += arg;
        ret += " ";
    }
    return ret;
}
std::string CBuild::Toolchain::gen_out_name(std::string executable, std::string dyn_lib,
                                            std::string stat_lib) {
    // Base path
    std::string base = "";
    if (!this->gen_out_name_without_base_path) {
        base = CBUILD_BUILD_DIR + "/" + this->id + "/" + CBUILD_BUILD_OUT_DIR + "/";
    }
    // If name defined
    if (this->name != std::string("")) {
        // If this is executable add file excutable extension
        if (this->build_type == CBuild::EXECUTABLE) {
            base += this->name;
            base += executable;
        }
        // We build lib
        else {
            // Push "lib" and file name
            base += "lib";
            base += this->name;
            // Based on type push different file extensions
            if (this->build_type == CBuild::DYNAMIC_LIBRARY) {
                base += dyn_lib;
            } else {
                base += stat_lib;
            }
        }
    }
    // Else use id
    else {
        // If this is executable add file excutable extension
        if (this->build_type == CBuild::EXECUTABLE) {
            base += this->id;
            base += executable;
        }
        // We build lib
        else {
            // Push "lib" and file name
            base += "lib";
            base += this->id;
            // Based on type push different file extensions
            if (this->build_type == CBuild::DYNAMIC_LIBRARY) {
                base += dyn_lib;
            } else {
                base += stat_lib;
            }
        }
    }
    return this->cmd_str(base);
}
std::string CBuild::Toolchain::cmd_str(std::string in) {
    // Replace all spaces with backslash and placeholder
    while (in.find(" ") != std::string::npos) {
        in.replace(in.find(" "), std::string(" ").size(), "\\^");
    }
    // Replace placeholder by real space
    while (in.find("\\^") != std::string::npos) {
        in.replace(in.find("\\^"), std::string("\\^").size(), "\\ ");
    }
    return in;
}
void CBuild::Toolchain::init() {
    // Init toolchain
    if (this->id == std::string(""))
        this->id = "null";
    // Check all neeaded dirs and create it's if it doesnot exists
    if (!CBuild::fs::exists(CBUILD_BUILD_DIR)) {
        CBuild::fs::create({CBUILD_BUILD_DIR}, CBuild::fs::DIR);
    }
    if (!CBuild::fs::exists(CBUILD_BUILD_DIR + "/" + this->id)) {
        CBuild::fs::create({CBUILD_BUILD_DIR + "/" + this->id}, CBuild::fs::DIR);
    }
    if (!CBuild::fs::exists(CBUILD_BUILD_DIR + "/" + this->id + "/" + CBUILD_BUILD_CACHE_DIR)) {
        CBuild::fs::create({CBUILD_BUILD_DIR + "/" + this->id + "/" + CBUILD_BUILD_CACHE_DIR},
                           CBuild::fs::DIR);
    }
    if (!CBuild::fs::exists(CBUILD_BUILD_DIR + "/" + this->id + "/" + CBUILD_BUILD_OUT_DIR)) {
        CBuild::fs::create({CBUILD_BUILD_DIR + "/" + this->id + "/" + CBUILD_BUILD_OUT_DIR},
                           CBuild::fs::DIR);
    }
    if (!CBuild::fs::exists(CBUILD_BUILD_DIR + "/" + this->id + "/" + CBUILD_METADATA_FOLDER)) {
        CBuild::fs::create({CBUILD_BUILD_DIR + "/" + this->id + "/" + CBUILD_METADATA_FOLDER},
                           CBuild::fs::DIR);
    }
}
void CBuild::Toolchain::load_project_deps(std::string curr_path) {
    for (auto elem : this->project_deps) {
        // Generate and execute command for build dependencie
        std::string cmd = "cd " + elem.path + " && ./CBuild.run -b " + elem.id;
        CBuild::system(cmd);
        // Copy files
        CBuild::system("cp -r " + elem.path + "/" + CBUILD_BUILD_DIR + "/" + elem.id + "/" +
                       CBUILD_BUILD_OUT_DIR + "/*.* " + CBUILD_CACHE_DIR + "/" +
                       CBUILD_PROJECT_DEPS_DIR);
        CBuild::system("cp -r " + elem.headers_path + "/ " + CBUILD_CACHE_DIR + "/" +
                       CBUILD_PROJECT_DEPS_HEADERS + "/" + elem.id);
        // Add lib in dependencies
        this->add_library_dir(CBUILD_CACHE_DIR + "/" + CBUILD_PROJECT_DEPS_HEADERS,
                              CBUILD_CACHE_DIR + "/" + CBUILD_PROJECT_DEPS_DIR);
        this->add_library_include(elem.name);
        this->add_compile_arg(" -Wl,-rpath,\"\\$ORIGIN/../../../" + CBUILD_CACHE_DIR + "/" +
                              CBUILD_PROJECT_DEPS_DIR + "\"");
    }
}
std::array<std::string, 3> CBuild::Toolchain::get_cmds() {
    return std::array<std::string, 3>{this->compiler, this->linker, this->packer};
}
void CBuild::Toolchain::crash() {
    CBuild::print("Error in compilation! Stopping compilation...", CBuild::RED);
    exit(0xFF);
}
void CBuild::Toolchain::compile(std::string str) {
    int ret = CBuild::system(str);
    if (ret != 0) {
        this->crash();
    }
}
void CBuild::Toolchain::stdargs() {
    if (!this->stdargs_lock) {
        // Sometimes binaryes gcc throws error if this option is not set when linking to shared
        // library
        this->compiler_args.push_back("-fPIC");
        this->link_args.push_back("-fPIC");
        // Some standart compile and link args
        this->add_compile_arg("-I" + CBUILD_CACHE_DIR + "/" + CBUILD_PROJECT_DEPS_HEADERS);
        this->add_link_arg("-L" + CBUILD_CACHE_DIR + "/" + CBUILD_PROJECT_DEPS_DIR);
        // Special link tag for dynamick libraries
        if (this->build_type == CBuild::DYNAMIC_LIBRARY) {
            this->link_args.push_back("-shared");
        }
        // For packing in deb fomat
        if (this->build_type == CBuild::DYNAMIC_LIBRARY) {
            std::string lib = this->gen_out_name();
            int pos = lib.find_last_of('/');
            lib = lib.substr(pos + 1);
            if (this->version_major < 0) {
                this->add_link_arg(" -Wl,-soname," + lib);
            } else {
                this->add_link_arg(" -Wl,-soname," + lib + std::string(".") +
                                   std::to_string(this->version_major));
            }
        }
        // Add link arsg for dependancy libraries
        for (std::string id : this->depends) {
            auto target = CBuild::Registry::GetToolchain(id, true);
            if (target != NULL) {
                // get lib name
                auto out_path = target->gen_out_name();
                unsigned int end_slash = out_path.find_last_of('/');
                unsigned int end_dot = out_path.find_last_of('.');
                std::string out = out_path.substr(end_slash + 4, end_dot - end_slash - 4);
                // Add lib include
                this->add_library_include(out);
                // Add all needed for linking to that library
                this->add_library_dir(".", CBUILD_BUILD_DIR + "/" + target->get_id() + "/" +
                                               CBUILD_BUILD_OUT_DIR + "/");
                this->add_link_arg("-Wl,-rpath,\"\\$ORIGIN/../../" + target->get_id() + "/" +
                                   CBUILD_BUILD_OUT_DIR + "\"");
            }
        }
        // pkg-config database search
        for (auto pkg : this->pkg_config_include_entries) {
            CBuild::package_info info;
            info.name = pkg;
            if (!CBuild::get_pkg_info(&info)) {
                this->crash();
            }
            this->add_link_arg(info.largs);
            this->add_compile_arg(info.cargs);
        }
        // External dependencies
        for (auto dep : this->dependency_list) {
            this->add_link_arg(dep->largs());
            this->add_compile_arg(dep->cargs());
        } // Set lock
        this->stdargs_lock = true;
    }
}
/* Build.hpp - main */
void CBuild::Toolchain::call(std::vector<std::string>* args, bool force, bool debug, bool dummy) {
    CBuild::print("Starting " + this->id + " toolchain in build mode ", CBuild::color::RED);
    // Load all deps
    CBuild::print("Trying to load required dependencies...", CBuild::GREEN);
    for (auto dep : this->dependency_list) {
        if (dep->need_prepare()) {
            dep->prepare();
        }
    }
    // Save scratch variables
    this->args = args;
    this->force = force;
    this->dummy = dummy;
    // Debug mode of compilation
    if (debug) {
        this->compiler_args.push_back("-g");
    }
    this->stdargs();
    // Init dirs
    this->init();
    // Init
    CBuild::print("Calling tasks marked as PRE ", CBuild::color::GREEN);
    // Call all dependencies (tasks) marked as PRE
    for (unsigned int i = 0; i < this->required.size(); i++) {
        auto elem = this->required.at(i);
        if (elem.data == CBuild::PRE) {
            CBuild::Registry::CallTask(elem.key, {});
        }
    }
    CBuild::print("Calling all required toolchains ", CBuild::color::GREEN);
    // Call all dependencies (toolchains)
    for (std::string id : this->depends) {
        // Call target
        auto target = CBuild::Registry::GetToolchain(id, force);
        if (target != NULL) {
            target->call(args, force, debug, dummy);
        }
    }
    // Does metadata checks fails with file not found error
    bool meta_error = false;
    // Perform some metadata checks
    if (this->hasher->compare_and_set_output_file(this->gen_out_name()) != 0) {
        this->force = true;
        meta_error = true;
    }
    if (this->hasher->compare_and_set_cargs(this->compiler_args) != 0) {
        this->force = true;
        meta_error = true;
    }
    if (this->hasher->compare_and_set_largs(this->link_args) != 0) {
        this->force = true;
        meta_error = true;
    }
    if (this->hasher->compare_and_set_commands(this->compiler, this->linker, this->packer) != 0) {
        this->force = true;
        meta_error = true;
    }
    // 4 steps
    if (!force)
        CBuild::print("Using precompiled object were possible ", CBuild::color::MAGENTA);
    CBuild::print("Running pre build tasks ", CBuild::GREEN);
    this->pre_build();
    CBuild::print("Running build tasks ", CBuild::GREEN);
    CBuild::print("Now you can see compiler output", CBuild::MAGENTA);
    this->build();
    CBuild::print("Running post build tasks ", CBuild::GREEN);
    this->post_build();
    CBuild::print("Running pre link tasks ", CBuild::GREEN);
    this->pre_link();
    CBuild::print("Running link tasks ", CBuild::GREEN);
    CBuild::print("Now you can see linker output", CBuild::MAGENTA);
    // 5-th step - special linking for static libraries
    if (this->build_type == CBuild::STATIC_LIBRARY) {
        this->link_pack();
    } else {
        this->link();
    }
    // Last, 6-th step
    CBuild::print("Running post link tasks ", CBuild::GREEN);
    this->post_link();
    if (this->build_type == CBuild::DYNAMIC_LIBRARY && this->version_major != -1) {
        CBuild::print("Creating symlink lib<id>.so.<major>", CBuild::GREEN);
        CBuild::system("rm -rf " + CBUILD_BUILD_DIR + "/" + this->get_id() + "/" +
                       CBUILD_BUILD_OUT_DIR + "/*.so.*");
        this->gen_out_name_without_base_path = true;
        CBuild::system("cd " + CBUILD_BUILD_DIR + "/" + this->get_id() + "/" +
                       CBUILD_BUILD_OUT_DIR + " && ln -s " + this->gen_out_name() + " " +
                       this->gen_out_name() + "." + std::to_string(this->version_major));
        this->gen_out_name_without_base_path = false;
    }
    // If we had a metadata file not found error we need to update metadata
    if (meta_error == true) {
        this->hasher->set_target_meta(this->compiler_args, this->link_args, this->gen_out_name(),
                                      this->compiler, this->linker, this->packer);
    }
    CBuild::print("Calling tasks marked as POST ", CBuild::GREEN);
    // Call all dependencies (tasks) marked as POSt
    for (unsigned int i = 0; i < this->required.size(); i++) {
        auto elem = this->required.at(i);
        if (elem.data == CBuild::POST) {
            CBuild::Registry::CallTask(elem.key, {});
        }
    }
    CBuild::print("End of execution of toolchain " + this->id + " ", CBuild::RED);
}
void CBuild::Toolchain::run(std::vector<std::string>* args) {
    CBuild::print("Starting \"" + ((this->name == "") ? this->id : this->name) + "\" ",
                  CBuild::RED);
    // Parse args
    std::string pargs = "";
    if (args != NULL) {
        for (auto elem : *args) {
            pargs += elem;
            pargs += " ";
        }
    }
    // Construct command
    std::string cmd;
    cmd = this->gen_out_name();
    cmd += " ";
    cmd += pargs;
    // Call app
    CBuild::print("App output (if any):", CBuild::MAGENTA);
    CBuild::system(cmd);
    CBuild::print("End of app execution", CBuild::RED);
}
void CBuild::Toolchain::debug(std::vector<std::string>* args, std::vector<std::string>* pargs) {
    CBuild::print("Starting \"" + ((this->name == "") ? this->id : this->name) +
                      "\" toolchain in debug mode ",
                  CBuild::RED);
    // Build in debug mode
    this->call(args, true, true);
    CBuild::print("Running builded app with gdb ", CBuild::GREEN);
    std::string ppargs = "";
    if (pargs != NULL) {
        for (auto elem : *pargs) {
            ppargs += elem;
            ppargs += " ";
        }
    }
    // Construct command
    std::string cmd;
    cmd = "gdb ";
    cmd += this->gen_out_name();
    cmd += " ";
    cmd += ppargs;
    // Call gdb on app
    CBuild::print("Now you can see gdb shell ", CBuild::MAGENTA);
    CBuild::system(cmd);
    CBuild::print("End of app execution", CBuild::RED);
}
void CBuild::Toolchain::clear() {
    // Simple clear though shell ;)
    CBuild::system(std::string("rm -r ") + CBUILD_BUILD_DIR + "/" + this->id);
}