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
|
// file : build/file.cxx -*- C++ -*-
// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
// license : MIT; see accompanying LICENSE file
#include <build/file>
#include <fstream>
#include <build/scope>
#include <build/parser>
#include <build/filesystem>
#include <build/diagnostics>
using namespace std;
namespace build
{
void
source (const path& bf, scope& root, scope& base)
{
tracer trace ("source");
ifstream ifs (bf.string ());
if (!ifs.is_open ())
fail << "unable to open " << bf;
level4 ([&]{trace << "sourcing " << bf;});
ifs.exceptions (ifstream::failbit | ifstream::badbit);
parser p;
try
{
p.parse_buildfile (ifs, bf, root, base);
}
catch (const std::ios_base::failure&)
{
fail << "failed to read from " << bf;
}
}
void
source_once (const path& bf, scope& root, scope& base, scope& once)
{
tracer trace ("source_once");
if (!once.buildfiles.insert (bf).second)
{
level4 ([&]{trace << "skipping already sourced " << bf;});
return;
}
source (bf, root, base);
}
scope&
create_root (const path& out_root, const path& src_root)
{
scope& rs (scopes.insert (out_root, true).first);
// Enter built-in meta-operation and operation names. Note that
// the order of registration should match the id constants; see
// <operation> for details. Loading of modules (via the src
// bootstrap; see below) can result in additional names being
// added.
//
if (rs.meta_operations.empty ())
{
assert (rs.meta_operations.insert (perform) == perform_id);
assert (rs.operations.insert (default_) == default_id);
assert (rs.operations.insert (update) == update_id);
assert (rs.operations.insert (clean) == clean_id);
}
// If this is already a root scope, verify that things are
// consistent.
//
{
auto v (rs.variables["out_root"]);
if (!v)
v = out_root;
else
{
const path& p (v.as<const path&> ());
if (p != out_root)
fail << "new out_root " << out_root << " does not match "
<< "existing " << p;
}
}
if (!src_root.empty ())
{
auto v (rs.variables["src_root"]);
if (!v)
v = src_root;
else
{
const path& p (v.as<const path&> ());
if (p != src_root)
fail << "new src_root " << src_root << " does not match "
<< "existing " << p;
}
}
return rs;
}
void
bootstrap_out (scope& root)
{
path bf (root.path () / path ("build/bootstrap/src-root.build"));
if (!file_exists (bf))
return;
//@@ TODO: if bootstrap files can source other bootstrap files
// (the way to express dependecies), then we need a way to
// prevent multiple sourcing. We handle it here but we still
// need something like source_once (once [scope] source).
//
source_once (bf, root, root);
}
bool
bootstrap_src (scope& root)
{
tracer trace ("bootstrap_src");
path bf (root.src_path () / path ("build/bootstrap.build"));
if (!file_exists (bf))
return false;
// We assume that bootstrap out cannot load this file explicitly. It
// feels wrong to allow this since that makes the whole bootstrap
// process hard to reason about. But we may try to bootstrap the
// same root scope multiple time.
//
source_once (bf, root, root);
return true;
}
void
root_pre (scope& root)
{
tracer trace ("root_pre");
// First load outer roots, if any.
//
if (scope* rs = root.parent_scope ()->root_scope ())
root_pre (*rs);
path bf (root.src_path () / path ("build/root.build"));
if (file_exists (bf))
source_once (bf, root, root);
}
}
|
