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
|
// file : libbuild2/build/script/script.hxx -*- C++ -*-
// license : MIT; see accompanying LICENSE file
#ifndef LIBBUILD2_BUILD_SCRIPT_SCRIPT_HXX
#define LIBBUILD2_BUILD_SCRIPT_SCRIPT_HXX
#include <libbuild2/types.hxx>
#include <libbuild2/forward.hxx>
#include <libbuild2/utility.hxx>
#include <libbuild2/variable.hxx>
#include <libbuild2/script/script.hxx>
namespace build2
{
namespace build
{
namespace script
{
using build2::script::line;
using build2::script::line_type;
using build2::script::redirect;
using build2::script::redirect_type;
using build2::script::expr_term;
using build2::script::command_expr;
// Notes:
//
// - Once parsed, the script can be executed in multiple threads with
// the state (variable values, etc) maintained in the environment
// object.
//
// - The default script command redirects semantics is none for stdin,
// merge into stderr for stdout, and pass for stderr.
//
class script
{
public:
// Note that the variables are not pre-entered into a pool during the
// parsing phase, so the line variable pointers are NULL.
//
build2::script::lines lines;
// Referenced ordinary (non-special) variables.
//
// Used for the script semantics change tracking. The variable list is
// filled during the pre-parsing phase and is checked against during
// the execution phase. If during execution some non-script-local
// variable is not found in the list (may happen for a computed name),
// then the execution fails since the script semantics may not be
// properly tracked (the variable value change will not trigger the
// target rebuild).
//
small_vector<string, 1> vars;
location start_loc;
location end_loc;
};
//@@ Does environment need script? Can't we just pass it to parser along
// with environment.
//
class environment: public build2::script::environment
{
public:
environment (const target& primary_target);
environment (environment&&) = delete;
environment (const environment&) = delete;
environment& operator= (environment&&) = delete;
environment& operator= (const environment&) = delete;
public:
const target& primary_target;
// Script-local variable pool.
//
variable_pool var_pool;
// Note that if we pass the variable name as a string, then it will
// be looked up in the wrong pool.
//
variable_map vars;
virtual void
set_variable (string&& name, names&&, const string& attrs) override;
// Variables.
//
public:
// Lookup the variable starting from this environment, then the
// primary target, and then outer buildfile scopes.
//
using lookup_type = build2::lookup;
lookup_type
lookup (const variable&) const;
lookup_type
lookup (const string&) const;
// As above but only look for buildfile variables.
//
lookup_type
lookup_in_buildfile (const string&) const;
// Return a value suitable for assignment. If the variable does not
// exist in this environment's map, then a new one with the NULL value
// is added and returned. Otherwise the existing value is returned.
//
value&
assign (const variable& var) {return vars.assign (var);}
// Return a value suitable for append/prepend. If the variable does
// not exist in this environment's map, then outer scopes are searched
// for the same variable. If found then a new variable with the found
// value is added to the environment and returned. Otherwise this
// function proceeds as assign() above.
//
value&
append (const variable&);
};
}
}
}
#endif // LIBBUILD2_BUILD_SCRIPT_SCRIPT_HXX
|
