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
|
// file : build2/context -*- C++ -*-
// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
// license : MIT; see accompanying LICENSE file
#ifndef BUILD2_CONTEXT
#define BUILD2_CONTEXT
#include <build2/types>
#include <build2/utility>
#include <build2/scope>
#include <build2/variable>
#include <build2/operation>
#include <build2/b-options>
namespace build2
{
class file;
extern dir_path work;
extern dir_path home;
extern options ops;
extern string_pool extension_pool;
extern string_pool project_name_pool;
// Current action (meta/operation).
//
// The names unlike info are available during boot but may not yet be
// lifted. The name is always for an outer operation (or meta operation
// that hasn't been recognized as such yet).
//
extern const string* current_mname;
extern const string* current_oname;
extern const meta_operation_info* current_mif;
extern const operation_info* current_inner_oif;
extern const operation_info* current_outer_oif;
extern execution_mode current_mode;
inline void
set_current_mif (const meta_operation_info& mif)
{
current_mif = &mif;
current_mname = &mif.name;
}
inline void
set_current_oif (const operation_info& inner_oif,
const operation_info* outer_oif = nullptr)
{
current_inner_oif = &inner_oif;
current_outer_oif = outer_oif;
current_oname = &(outer_oif == nullptr ? inner_oif : *outer_oif).name;
current_mode = inner_oif.mode;
}
// Total number of dependency relationships in the current action.
// Together with the target::dependents count it is incremented
// during the rule search & match phase and is decremented during
// execution with the expectation of it reaching 0. Used as a sanity
// check.
//
extern uint64_t dependency_count;
// Project-wide (as opposed to global) variable overrides. Returned by
// reset().
//
struct variable_override
{
const variable& var; // Original variable.
const variable& ovr; // Override variable.
value val;
};
using variable_overrides = vector<variable_override>;
// Reset the build state. In particular, this removes all the targets,
// scopes, and variables.
//
variable_overrides
reset (const strings& cmd_vars);
// Return the project name or empty string if unnamed.
//
inline const string&
project (scope& root)
{
auto l (root["project"]);
return l ? cast<string> (l) : empty_string;
}
// Return the src/out directory corresponding to the given out/src. The
// passed directory should be a sub-directory of out/src_root.
//
dir_path
src_out (const dir_path& out, scope& root);
dir_path
src_out (const dir_path& out,
const dir_path& out_root, const dir_path& src_root);
dir_path
out_src (const dir_path& src, scope& root);
dir_path
out_src (const dir_path& src,
const dir_path& out_root, const dir_path& src_root);
// If possible and beneficial, translate an absolute, normalized path
// into relative to the relative_base directory, which is normally
// work. Note that if the passed path is the same as relative_base,
// then this function returns empty path.
//
template <typename K>
basic_path<char, K>
relative (const basic_path<char, K>&);
// By default this points to work. Setting this to something else
// should only be done in tightly controlled, non-parallel
// situations (see dump). If base is empty, then relative()
// returns the original path.
//
extern const dir_path* relative_base;
// In addition to calling relative(), this function also uses shorter
// notations such as '~/'. For directories the result includes the trailing
// slash. If the path is the same as base, returns "./" if current is true
// and empty string otherwise.
//
string
diag_relative (const path&, bool current = true);
// Action phrases, e.g., "configure update exe{foo}", "updating exe{foo}",
// and "updating exe{foo} is configured". Use like this:
//
// info << "while " << diag_doing (a, t);
//
class target;
struct diag_phrase
{
const action& a;
const target& t;
void (*f) (ostream&, const action&, const target&);
};
inline ostream&
operator<< (ostream& os, const diag_phrase& p)
{
p.f (os, p.a, p.t);
return os;
}
void
diag_do (ostream&, const action&, const target&);
inline diag_phrase
diag_do (const action& a, const target& t)
{
return diag_phrase {a, t, &diag_do};
}
void
diag_doing (ostream&, const action&, const target&);
inline diag_phrase
diag_doing (const action& a, const target& t)
{
return diag_phrase {a, t, &diag_doing};
}
void
diag_done (ostream&, const action&, const target&);
inline diag_phrase
diag_done (const action& a, const target& t)
{
return diag_phrase {a, t, &diag_done};
}
}
#include <build2/context.txx>
#endif // BUILD2_CONTEXT
|
