Build.hpp

Go to the documentation of this file.

 
#ifndef __CBUILD_TOOLCHAIN_HPP__
#define __CBUILD_TOOLCHAIN_HPP__
// C++ libraries
#include "../map.hpp"
#include "array"
#include "string"
#include "vector"
// Project headers
#include "../dependency/dependency.hpp"
#include "../generator/generator.hpp"
#include "../hasher/hasher.hpp"
#include "../hasher/manual_hash.hpp"
// Code
namespace CBuild {
typedef struct {
    std::string path;
    bool folder;
} Path;
typedef struct {
    std::string path;
    std::string id;
    std::string name;
    std::string headers_path;
} Project_dependency;
typedef enum { PRE, POST } stage;
typedef enum { EXECUTABLE, STATIC_LIBRARY, DYNAMIC_LIBRARY } build_type;
template <class T>
concept HashImpl = std::is_base_of<CBuild::Hash, T>::value;
typedef struct ToolState {};
class Toolchain {
  protected:
    std::string name = "";
    std::string id;
    lib::map<std::string, CBuild::stage> required;
    std::vector<std::string> depends;
    std::vector<CBuild::Path> targets;
    std::vector<std::string> compiler_args;
    std::vector<std::string> link_args;
    std::string compiler;
    std::string linker;
    std::string packer;
    CBuild::build_type build_type;
    std::vector<CBuild::Project_dependency> project_deps;
    bool dummy = false;
    int version_major = -1;
    bool gen_out_name_without_base_path = false;
    bool gen_file_list_for_linking = false;
    std::vector<std::string> pkg_config_include_entries;
    Hash* hasher;
    std::vector<CBuild::Dependency*> dependency_list;
 
  protected:
    // Scratch variables
    std::vector<std::string>* args;
    bool force;
    bool stdargs_lock = false;
 
  protected:
    /* Build stages */
    virtual void pre_build() {};
    virtual void post_build() {};
    virtual void pre_link() {};
    virtual void post_link() {};
    virtual void build() = 0;
    virtual void link() = 0;
    virtual void link_pack() = 0;
    /* Helper */
    virtual lib::map<std::string, std::string> gen_file_list(bool force);
    virtual std::string gen_out_file(std::string file);
 
  public:
    virtual std::string gen_out_name(std::string executable = ".run", std::string dyn_lib = ".so",
                                     std::string stat_lib = ".a");
    virtual void load_project_deps(std::string curr_path);
 
  protected:
    virtual std::string cmd_str(std::string in);
    virtual void init();
 
  public:
    virtual void stdargs();
 
  public:
    Toolchain() {}
    virtual ~Toolchain() {}
    std::string get_id() {
        return this->id;
    }
    virtual void call(std::vector<std::string>* args, bool force = false, bool debug = false,
                      bool dummy = false);
    virtual void run(std::vector<std::string>* args);
    virtual void debug(std::vector<std::string>* args, std::vector<std::string>* pargs);
    virtual void clear();
    virtual void add_define(std::string define, std::string val = "");
    virtual void add_undef(std::string define);
    virtual void add_include(std::string include_path);
    virtual void add_compile_arg(std::string arg);
    virtual void add_link_arg(std::string arg);
    virtual void add_library_include(std::string library);
    virtual void add_library_dir(std::string include, std::string lib);
    virtual void add_requirment(std::string task_, CBuild::stage run_stage = CBuild::PRE);
    virtual void depends_on(std::string target);
    virtual void warn();
    virtual void static_analizer();
    virtual void error();
    virtual void multithreaded_target();
    virtual void set_standart(std::string std_);
    virtual void add_file(std::string path);
    virtual void add_folder(std::string path);
    virtual void set_type(CBuild::build_type type);
    virtual void depends_on_project(std::string path, std::string name, std::string id,
                                    std::string headers_path);
    virtual void set_profiling_mode();
    virtual void set_version_major(int version);
    virtual std::array<std::string, 3> get_cmds();
    virtual lib::map<std::string, std::string> gen_file_list_force();
    virtual std::string get_compile_args();
    virtual void crash() __attribute__((__noreturn__));
    virtual void compile(std::string cmd);
    virtual void add_pkgconfig_entry(std::string id);
    virtual void set_hasher(Hash* hasher);
    virtual void set_name(std::string name);
    virtual void set_id(std::string id);
    void add_external_dependency(CBuild::Dependency* dep);
};
template <class T>
concept ToolchainImpl = std::is_base_of<CBuild::Toolchain, T>::value;
} // namespace CBuild
#endif // __CBUILD_TOOLCHAIN_HPP__