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
|
// Copyright 2015 Google Inc. All rights reserved
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef EVAL_H_
#define EVAL_H_
#include <memory>
#include <unordered_map>
#include <vector>
#include "ast.h"
#include "loc.h"
#include "string_piece.h"
#include "symtab.h"
using namespace std;
class Makefile;
class Rule;
class Var;
class Vars;
struct EvalResult {
~EvalResult();
vector<shared_ptr<Rule>> rules;
Vars* vars;
unordered_map<StringPiece, Vars*> rule_vars;
// TODO: read_mks
unordered_map<StringPiece, bool> exports;
};
class Evaluator {
public:
Evaluator(const Vars* vars);
~Evaluator();
void EvalAssign(const AssignAST* ast);
void EvalRule(const RuleAST* ast);
void EvalCommand(const CommandAST* ast);
void EvalIf(const IfAST* ast);
void EvalInclude(const IncludeAST* ast);
void EvalExport(const ExportAST* ast);
Var* LookupVar(Symbol name);
// For target specific variables.
Var* LookupVarInCurrentScope(Symbol name);
shared_ptr<string> EvalVar(Symbol name);
const Loc& loc() const { return loc_; }
const vector<shared_ptr<Rule>>& rules() const { return rules_; }
const unordered_map<Symbol, Vars*>& rule_vars() const {
return rule_vars_;
}
Vars* mutable_vars() { return vars_; }
const unordered_map<Symbol, bool>& exports() const { return exports_; }
void Error(const string& msg);
void set_is_bootstrap(bool b) { is_bootstrap_ = b; }
void set_current_scope(Vars* v) { current_scope_ = v; }
bool avoid_io() const { return avoid_io_; }
void set_avoid_io(bool a) { avoid_io_ = a; }
private:
Var* EvalRHS(Symbol lhs, Value* rhs, StringPiece orig_rhs, AssignOp op,
bool is_override = false);
void DoInclude(const string& fname);
const Vars* in_vars_;
Vars* vars_;
unordered_map<Symbol, Vars*> rule_vars_;
vector<shared_ptr<Rule>> rules_;
unordered_map<Symbol, bool> exports_;
Rule* last_rule_;
Vars* current_scope_;
Loc loc_;
bool is_bootstrap_;
bool avoid_io_;
};
#endif // EVAL_H_
|