1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
// -*- 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>
namespace ctor {
enum class target_type
{
automatic, // Default - deduce from target name and sources extensions
executable,
static_library,
dynamic_library,
object,
unit_test,
unit_test_library,
function,
};
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
};
struct source
{
source(const char* file) : file(file) {}
source(const std::string& file) : file(file) {}
source(const char* file, ctor::language lang) : file(file), language(lang) {}
source(const std::string& file, ctor::language lang) : file(file), language(lang) {}
source(const char* file, const char* output) : file(file), output(output) {}
source(const std::string& file, const std::string& output) : file(file), output(output) {}
source(const char* file, ctor::language lang, const char* output) : file(file), language(lang), output(output) {}
source(const std::string& file, ctor::language lang, const std::string& output) : file(file), language(lang), output(output) {}
std::string file;
ctor::language language{ctor::language::automatic};
std::string output{};
};
enum class toolchain
{
any,
none,
gcc,
clang,
};
enum class opt
{
// gcc/clang
output, // -o
debug, // -g
strip, // -s
warn_all, // -Wall
warnings_as_errors, // -Werror
generate_dep_tree, // -MMD
no_link, // -c
include_path, // -I<arg>
library_path, // -L<arg>
link, // -l<arg>
cpp_std, // -std=<arg>
build_shared, // -shared
threads, // -pthread
optimization, // -O<arg>
position_independent_code, // -fPIC
position_independent_executable, // -fPIE
custom, // entire option taken verbatim from <arg>
};
struct flags
{
std::vector<std::string> cxxflags; // flags for c++ compiler
std::vector<std::string> cflags; // flags for c compiler
std::vector<std::string> ldflags; // flags for linker
std::vector<std::string> 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, ...
};
struct build_configuration;
using GeneratorCb = std::function<int(const std::string& input,
const std::string& output,
const build_configuration& config,
const ctor::settings& settings)>;
struct build_configuration
{
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::host};
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
GeneratorCb function;
};
using build_configurations = std::vector<build_configuration>;
int reg(ctor::build_configurations (*cb)(const ctor::settings&),
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::host};
std::variant<ctor::external_manual> external;
};
using external_configurations = std::vector<ctor::external_configuration>;
int reg(ctor::external_configurations (*cb)(const ctor::settings&),
const std::source_location location = std::source_location::current());
// Convenience macro - ugly but keeps things simple(r)
#define CONCAT(a, b) CONCAT_INNER(a, b)
#define CONCAT_INNER(a, b) a ## b
#define UNIQUE_NAME(base) CONCAT(base, __LINE__)
#define REG(cb) namespace { int 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-cpp";
constexpr auto host_ar = "host-ar";
constexpr auto host_ld = "host-ld";
constexpr auto build_cc = "build-cc";
constexpr auto build_cxx = "build-cpp";
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;
const std::string& get(const std::string& key, const std::string& default_value = {}) const;
ctor::toolchain host_toolchain{ctor::toolchain::none};
ctor::toolchain build_toolchain{ctor::toolchain::none};
std::vector<std::string> args; // vector of arguments used when last calling configure
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::
|
