path: root/src/ctor.h

// -*- c++ -*-
// Distributed under the BSD 2-Clause License.
// See accompanying file LICENSE for details.
#pragma once

#include <source_location>
#include <string>
#include <vector>
#include <map>
#include <variant>
#include <cstddef>
#include <functional>
#include <string_view>
#include <cassert>

namespace ctor {

enum class target_type
{
	automatic, // Default - deduce from target name and sources extensions

	executable,
	static_library,
	shared_library,
	dynamic_library = shared_library,
	module,
	object,
	unit_test,
	unit_test_library,
	function,

	unknown,
};

enum class language
{
	automatic, // Default - deduce language from source extensions

	c,
	cpp,
	assembler,
};

enum class output_system
{
	host, // Output for the target system
	build, // Internal tool during cross-compilation
};

enum class arch
{
	unix,    //!< Target platform architecture is unix-based (ie. linux, bsd, etc)
	apple,   //!< Target platform architecture is macos
	windows, //!< Target platform architecture is windows

	unknown, //!< Target platform architecture has not yet detected or was not possible to detect
};

enum class toolchain
{
	any,
	none,
	gcc,
	clang,
};

struct output_file
{
	std::string file;
};

enum class source_type
{
	regular,
	generated,
};

struct source
{
	template <class ... Args>
		requires ((
		          std::is_convertible_v<Args, std::string_view> ||
		          std::is_same_v<Args, ctor::toolchain> ||
		          std::is_same_v<Args, ctor::language> ||
		          std::is_same_v<Args, ctor::source_type> ||
		          std::is_same_v<Args, ctor::output_file>
		          ) && ...)
	constexpr source(Args && ... arg)
	{
		([&]
		{
			if constexpr(std::is_convertible_v<Args, std::string_view>)
			{
				file = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::toolchain>)
			{
				toolchain = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::language>)
			{
				language = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::output_file>)
			{
				output = arg.file;
			}
			else if constexpr(std::is_same_v<Args, ctor::source_type>)
			{
				source_type = arg;
			}
		}(), ...);
	}

	std::string file;
	ctor::toolchain toolchain{ctor::toolchain::any};
	ctor::language language{ctor::language::automatic};
	std::string output{};
	ctor::source_type source_type{ctor::source_type::regular};
};

enum class cxx_opt
{
	//                                  gcc/clang
	output,                          //  -o
	debug,                           //  -g
	warn_all,                        //  -Wall
	warn_conversion,                 //  -Wconversion
	warn_shadow,                     //  -Wshadow
	warn_extra,                      //  -Wextra
	warnings_as_errors,              //  -Werror
	exceptions,                      //  -fexceptions
	generate_dep_tree,               //  -MMD
	no_link,                         //  -c
	include_path,                    //  -I<arg>
	cpp_std,                         //  -std=<arg>
	optimization,                    //  -O<arg>
	position_independent_code,       //  -fPIC
	position_independent_executable, //  -fPIE
	define,                          //  -D<arg>[=<arg2>]
	custom,                          // entire option taken verbatim from <arg>
};

enum class c_opt
{
	//                                  gcc/clang
	output,                          //  -o
	debug,                           //  -g
	warn_all,                        //  -Wall
	warn_conversion,                 //  -Wconversion
	warn_shadow,                     //  -Wshadow
	warn_extra,                      //  -Wextra
	warnings_as_errors,              //  -Werror
	generate_dep_tree,               //  -MMD
	no_link,                         //  -c
	include_path,                    //  -I<arg>
	c_std,                           //  -std=<arg>
	optimization,                    //  -O<arg>
	position_independent_code,       //  -fPIC
	position_independent_executable, //  -fPIE
	define,                          //  -D<arg>[=<arg2>]
	custom,                          // entire option taken verbatim from <arg>
};

enum class ld_opt
{
	//                                  gcc/clang
	output,                          //  -o
	warn_all,                        //  -Wall
	warnings_as_errors,              //  -Werror
	library_path,                    //  -L<arg>
	link,                            //  -l<arg>
	cpp_std,                         //  -std=<arg>
	build_shared,                    //  -shared
	threads,                         //  -pthread
	position_independent_code,       //  -fPIC
	position_independent_executable, //  -fPIE
	custom,                          // entire option taken verbatim from <arg>
};

enum class ar_opt
{
	//                                  gcc/clang
	replace,                         // -r
	add_index,                       // -s
	create,                          // -c
	output,                          // <arg>

	custom,                          // entire option taken verbatim from <arg>
};

enum class asm_opt
{
	//                                  gcc/clang
	custom,                          // entire option taken verbatim from <arg>
};

template<typename T>
class flag
{
public:
	template <class ... Args>
		requires ((
		          std::is_convertible_v<Args, std::string_view> ||
		          std::is_same_v<Args, ctor::toolchain> ||
		          std::is_same_v<Args, T>
		          ) && ...)
	constexpr flag(Args && ... _arg)
	{
		constexpr std::size_t n = sizeof...(Args);
		int state{}; // 0: opt, 1: arg1, 2: arg2, 3: error
		([&]
		{
			if constexpr(std::is_convertible_v<Args, std::string_view>)
			{
				if constexpr(n == 1)
				{
					std::string str(_arg);
					to_flag(str);
				}
				else
				{
					assert(state > 0); // opt must be before args
					if(state == 1)
					{
						this->arg = _arg;
					}
					else
					{
						assert(state == 2); // up to 2 args supported
						this->arg2 = _arg;
					}
					++state;
				}
			}
			else if constexpr(std::is_same_v<Args, ctor::toolchain>)
			{
				toolchain = _arg;
			}
			else if constexpr(std::is_same_v<Args, T>)
			{
				assert(state == 0); // opt must be before args
				opt = _arg;
				++state;
			}
		}(), ...);
	}

	ctor::toolchain toolchain{ctor::toolchain::any};
	T opt{};
	std::string arg;
	std::string arg2;

private:
	void to_flag(std::string_view str);
};

using c_flag = ctor::flag<ctor::c_opt>;
using cxx_flag = ctor::flag<ctor::cxx_opt>;
using ld_flag = ctor::flag<ctor::ld_opt>;
using ar_flag = ctor::flag<ctor::ar_opt>;
using asm_flag = ctor::flag<ctor::asm_opt>;

using c_flags = std::vector<ctor::c_flag>;
using cxx_flags = std::vector<ctor::cxx_flag>;
using ld_flags = std::vector<ctor::ld_flag>;
using ar_flags = std::vector<ctor::ar_flag>;
using asm_flags = std::vector<ctor::asm_flag>;

struct flags
{
	template <class ... Args>
		requires ((
		          std::is_same_v<Args, ctor::c_flags> ||
		          std::is_same_v<Args, ctor::cxx_flags> ||
		          std::is_same_v<Args, ctor::ld_flags> ||
		          std::is_same_v<Args, ctor::ar_flags> ||
		          std::is_same_v<Args, ctor::asm_flags>
		          ) && ...)
	constexpr flags(Args && ... arg)
	{
		([&]
		{
			if constexpr(std::is_same_v<Args, ctor::c_flags>)
			{
				cflags = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::cxx_flags>)
			{
				cxxflags = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::ld_flags>)
			{
				ldflags = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::ar_flags>)
			{
				arflags = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::asm_flags>)
			{
				asmflags = arg;
			}
		}(), ...);
	}

	ctor::c_flags cflags; // flags for c compiler
	ctor::cxx_flags cxxflags; // flags for c++ compiler
	ctor::ld_flags ldflags; // flags for linker
	ctor::ar_flags arflags; // flags for archiver
	ctor::asm_flags asmflags; // flags for asm translator
};

struct settings
{
	std::string builddir{"build"};
	std::size_t parallel_processes{1};
	int verbose{0}; // -1: completely silent, 0: normal, 1: verbose, ...
	bool dry_run{false};
};

struct build_configuration;
using GeneratorOneToOne =
	std::function<int(const std::string& input,
	                  const std::string& output,
	                  const build_configuration& config,
	                  const ctor::settings& settings)>;

using GeneratorManyToOne =
	std::function<int(const std::vector<std::string>& input,
	                  const std::string& output,
	                  const ctor::build_configuration& config,
	                  const ctor::settings& settings)>;

struct name
{
	std::string name;
};

struct target
{
	std::string target;
};

using sources = std::vector<ctor::source>;

struct depends
{
	std::vector<std::string> depends;
};

struct externals
{
	std::vector<std::string> externals;
};

struct build_configuration
{
	template <class ... Args>
		requires ((
		          std::is_same_v<Args, ctor::name> ||
		          std::is_same_v<Args, ctor::target_type> ||
		          std::is_same_v<Args, ctor::output_system> ||
		          std::is_same_v<Args, ctor::target> ||
		          std::is_same_v<Args, ctor::sources> ||
		          std::is_same_v<Args, ctor::depends> ||
		          std::is_same_v<Args, ctor::flags> ||
		          std::is_same_v<Args, ctor::externals> ||
		          std::is_same_v<Args, ctor::GeneratorOneToOne> ||
		          std::is_same_v<Args, ctor::GeneratorManyToOne>
		          ) && ...)
	constexpr build_configuration(Args && ... arg)
	{
		([&]
		{
			if constexpr(std::is_same_v<Args, ctor::name>)
			{
				name = arg.name;
			}
			else if constexpr(std::is_same_v<Args, ctor::target_type>)
			{
				type = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::output_system>)
			{
				system = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::target>)
			{
				target = arg.target;
			}
			else if constexpr(std::is_same_v<Args, ctor::sources>)
			{
				sources = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::depends>)
			{
				depends = arg.depends;
			}
			else if constexpr(std::is_same_v<Args, ctor::flags>)
			{
				flags = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::externals>)
			{
				externals = arg.externals;
			}
			else if constexpr(std::is_same_v<Args, ctor::GeneratorOneToOne>)
			{
				function_one_to_one = arg;
			}
			else if constexpr(std::is_same_v<Args, ctor::GeneratorManyToOne>)
			{
				function_many_to_one = arg;
			}
		}(), ...);
	}

	std::string name; // Name - used for referring in other configurations.
	ctor::target_type type{ctor::target_type::automatic};
	ctor::output_system system{ctor::output_system::build};
	std::string target; // Output target file for this configuration
	std::vector<ctor::source> sources; // source list
	std::vector<std::string> depends; // internal target dependencies
	ctor::flags flags;
	std::vector<std::string> externals; // externals used by this configuration
	ctor::GeneratorOneToOne function_one_to_one;
	ctor::GeneratorManyToOne function_many_to_one;
};

using build_configurations = std::vector<build_configuration>;

int reg(std::function<ctor::build_configurations (const ctor::settings&)> cb,
        const std::source_location location = std::source_location::current());

// This type will use flags verbatim
struct external_manual
{
	ctor::flags flags;
};


struct external_configuration
{
	std::string name; // Name for configuration
	ctor::output_system system{ctor::output_system::build};
	std::variant<ctor::external_manual> external;
};

using external_configurations = std::vector<ctor::external_configuration>;

int reg(std::function<ctor::external_configurations (const ctor::settings&)> cb,
        const std::source_location location = std::source_location::current());

// Convenience macro - ugly but keeps things simple(r)
#define CTOR_CONCAT(a, b) CTOR_CONCAT_INNER(a, b)
#define CTOR_CONCAT_INNER(a, b) a ## b
#define CTOR_UNIQUE_NAME(base) CTOR_CONCAT(base, __LINE__)
#define REG(cb) namespace { int CTOR_UNIQUE_NAME(unique) = reg(cb); }

// Predefined configuration keys
namespace cfg
{
constexpr auto builddir = "builddir";

constexpr auto host_cc = "host-cc";
constexpr auto host_cxx = "host-cxx";
constexpr auto host_ar = "host-ar";
constexpr auto host_ld = "host-ld";

constexpr auto build_cc = "build-cc";
constexpr auto build_cxx = "build-cxx";
constexpr auto build_ar = "build-ar";
constexpr auto build_ld = "build-ld";

constexpr auto ctor_includedir = "ctor-includedir";
constexpr auto ctor_libdir = "ctor-libdir";
}

struct configuration
{
	bool has(const std::string& key) const;
	std::string get(const std::string& key, const std::string& default_value = {}) const;

	ctor::toolchain host_toolchain{ctor::toolchain::none};
	ctor::arch host_arch{ctor::arch::unknown};

	ctor::toolchain build_toolchain{ctor::toolchain::none};
	ctor::arch build_arch{ctor::arch::unknown};

	std::vector<std::string> args; // vector of arguments used when last calling configure

	std::string getenv(const std::string& key) const;
	std::map<std::string, std::string> env; // env used when last calling configure

	std::map<std::string, std::string> tools; // tools
	std::map<std::string, ctor::flags> externals;
};

const ctor::configuration& get_configuration();

} // ctor::