Rename value.* and ast.* to expr.* and stmt.*, respectively
diff --git a/Makefile.ckati b/Makefile.ckati
index 26dc1f7..9c1f016 100644
--- a/Makefile.ckati
+++ b/Makefile.ckati
@@ -22,11 +22,11 @@
KATI_BIN_PATH ?= .
KATI_CXX_SRCS := \
- ast.cc \
command.cc \
dep.cc \
eval.cc \
exec.cc \
+ expr.cc \
file.cc \
file_cache.cc \
fileutil.cc \
@@ -40,12 +40,12 @@
parser.cc \
rule.cc \
stats.cc \
+ stmt.cc \
string_piece.cc \
stringprintf.cc \
strutil.cc \
symtab.cc \
timeutil.cc \
- value.cc \
var.cc
KATI_CXX_GENERATED_SRCS := \
diff --git a/eval.cc b/eval.cc
index d950b8a..3920b05 100644
--- a/eval.cc
+++ b/eval.cc
@@ -19,15 +19,15 @@
#include <errno.h>
#include <string.h>
-#include "ast.h"
+#include "expr.h"
#include "file.h"
#include "file_cache.h"
#include "fileutil.h"
#include "parser.h"
#include "rule.h"
+#include "stmt.h"
#include "strutil.h"
#include "symtab.h"
-#include "value.h"
#include "var.h"
EvalResult::~EvalResult() {
@@ -96,34 +96,34 @@
return NULL;
}
-void Evaluator::EvalAssign(const AssignAST* ast) {
- loc_ = ast->loc();
+void Evaluator::EvalAssign(const AssignStmt* stmt) {
+ loc_ = stmt->loc();
last_rule_ = NULL;
- Symbol lhs = Intern(ast->lhs->Eval(this));
+ Symbol lhs = Intern(stmt->lhs->Eval(this));
if (lhs.empty())
Error("*** empty variable name.");
- Var* rhs = EvalRHS(lhs, ast->rhs, ast->orig_rhs, ast->op,
- ast->directive == AssignDirective::OVERRIDE);
+ Var* rhs = EvalRHS(lhs, stmt->rhs, stmt->orig_rhs, stmt->op,
+ stmt->directive == AssignDirective::OVERRIDE);
if (rhs)
vars_->Assign(lhs, rhs);
}
-void Evaluator::EvalRule(const RuleAST* ast) {
- loc_ = ast->loc();
+void Evaluator::EvalRule(const RuleStmt* stmt) {
+ loc_ = stmt->loc();
last_rule_ = NULL;
- const string&& expr = ast->expr->Eval(this);
+ const string&& expr = stmt->expr->Eval(this);
// See semicolon.mk.
if (expr.find_first_not_of(" \t\n;") == string::npos)
return;
Rule* rule;
RuleVarAssignment rule_var;
- ParseRule(loc_, expr, ast->term, &rule, &rule_var);
+ ParseRule(loc_, expr, stmt->term, &rule, &rule_var);
if (rule) {
- if (ast->term == ';') {
- rule->cmds.push_back(ast->after_term);
+ if (stmt->term == ';') {
+ rule->cmds.push_back(stmt->after_term);
}
LOG("Rule: %s", rule->DebugString().c_str());
@@ -138,13 +138,13 @@
p.first->second = new Vars;
}
- Value* rhs = ast->after_term;
+ Value* rhs = stmt->after_term;
if (!rule_var.rhs.empty()) {
Value* lit = NewLiteral(rule_var.rhs);
if (rhs) {
// TODO: We always insert two whitespaces around the
// terminator. Preserve whitespaces properly.
- if (ast->term == ';') {
+ if (stmt->term == ';') {
rhs = NewExpr3(lit, NewLiteral(StringPiece(" ; ")), rhs);
} else {
rhs = NewExpr3(lit, NewLiteral(StringPiece(" = ")), rhs);
@@ -163,41 +163,41 @@
}
}
-void Evaluator::EvalCommand(const CommandAST* ast) {
- loc_ = ast->loc();
+void Evaluator::EvalCommand(const CommandStmt* stmt) {
+ loc_ = stmt->loc();
if (!last_rule_) {
- vector<AST*> asts;
- ParseNotAfterRule(ast->orig, ast->loc(), &asts);
- for (AST* a : asts)
+ vector<Stmt*> stmts;
+ ParseNotAfterRule(stmt->orig, stmt->loc(), &stmts);
+ for (Stmt* a : stmts)
a->Eval(this);
return;
}
- last_rule_->cmds.push_back(ast->expr);
+ last_rule_->cmds.push_back(stmt->expr);
if (last_rule_->cmd_lineno == 0)
- last_rule_->cmd_lineno = ast->loc().lineno;
- LOG("Command: %s", ast->expr->DebugString().c_str());
+ last_rule_->cmd_lineno = stmt->loc().lineno;
+ LOG("Command: %s", stmt->expr->DebugString().c_str());
}
-void Evaluator::EvalIf(const IfAST* ast) {
- loc_ = ast->loc();
+void Evaluator::EvalIf(const IfStmt* stmt) {
+ loc_ = stmt->loc();
bool is_true;
- switch (ast->op) {
+ switch (stmt->op) {
case CondOp::IFDEF:
case CondOp::IFNDEF: {
- Symbol lhs = Intern(ast->lhs->Eval(this));
+ Symbol lhs = Intern(stmt->lhs->Eval(this));
Var* v = LookupVarInCurrentScope(lhs);
const string&& s = v->Eval(this);
- is_true = (s.empty() == (ast->op == CondOp::IFNDEF));
+ is_true = (s.empty() == (stmt->op == CondOp::IFNDEF));
break;
}
case CondOp::IFEQ:
case CondOp::IFNEQ: {
- const string&& lhs = ast->lhs->Eval(this);
- const string&& rhs = ast->rhs->Eval(this);
- is_true = ((lhs == rhs) == (ast->op == CondOp::IFEQ));
+ const string&& lhs = stmt->lhs->Eval(this);
+ const string&& rhs = stmt->rhs->Eval(this);
+ is_true = ((lhs == rhs) == (stmt->op == CondOp::IFEQ));
break;
}
default:
@@ -205,13 +205,13 @@
abort();
}
- const vector<AST*>* asts;
+ const vector<Stmt*>* stmts;
if (is_true) {
- asts = &ast->true_asts;
+ stmts = &stmt->true_stmts;
} else {
- asts = &ast->false_asts;
+ stmts = &stmt->false_stmts;
}
- for (AST* a : *asts) {
+ for (Stmt* a : *stmts) {
LOG("%s", a->DebugString().c_str());
a->Eval(this);
}
@@ -223,23 +223,23 @@
Var* var_list = LookupVar(Intern("MAKEFILE_LIST"));
var_list->AppendVar(this, NewLiteral(Intern(TrimLeadingCurdir(fname)).str()));
- for (AST* ast : mk->asts()) {
- LOG("%s", ast->DebugString().c_str());
- ast->Eval(this);
+ for (Stmt* stmt : mk->stmts()) {
+ LOG("%s", stmt->DebugString().c_str());
+ stmt->Eval(this);
}
}
-void Evaluator::EvalInclude(const IncludeAST* ast) {
- loc_ = ast->loc();
+void Evaluator::EvalInclude(const IncludeStmt* stmt) {
+ loc_ = stmt->loc();
last_rule_ = NULL;
- const string&& pats = ast->expr->Eval(this);
+ const string&& pats = stmt->expr->Eval(this);
for (StringPiece pat : WordScanner(pats)) {
ScopedTerminator st(pat);
vector<string>* files;
Glob(pat.data(), &files);
- if (ast->should_exist) {
+ if (stmt->should_exist) {
if (files->empty()) {
Error(StringPrintf(
"%s: %s\n"
@@ -249,7 +249,7 @@
}
for (const string& fname : *files) {
- if (!ast->should_exist && g_flags.ignore_optional_include_pattern &&
+ if (!stmt->should_exist && g_flags.ignore_optional_include_pattern &&
Pattern(g_flags.ignore_optional_include_pattern).Match(fname)) {
return;
}
@@ -258,15 +258,15 @@
}
}
-void Evaluator::EvalExport(const ExportAST* ast) {
- loc_ = ast->loc();
+void Evaluator::EvalExport(const ExportStmt* stmt) {
+ loc_ = stmt->loc();
last_rule_ = NULL;
- const string&& exports = ast->expr->Eval(this);
+ const string&& exports = stmt->expr->Eval(this);
for (StringPiece tok : WordScanner(exports)) {
size_t equal_index = tok.find('=');
if (equal_index == string::npos) {
- exports_[Intern(tok)] = ast->is_export;
+ exports_[Intern(tok)] = stmt->is_export;
} else if (equal_index == 0 ||
(equal_index == 1 &&
(tok[0] == ':' || tok[0] == '?' || tok[0] == '+'))) {
@@ -276,7 +276,7 @@
StringPiece lhs, rhs;
AssignOp op;
ParseAssignStatement(tok, equal_index, &lhs, &rhs, &op);
- exports_[Intern(lhs)] = ast->is_export;
+ exports_[Intern(lhs)] = stmt->is_export;
}
}
}
diff --git a/eval.h b/eval.h
index 1326a0e..3ebb21b 100644
--- a/eval.h
+++ b/eval.h
@@ -20,8 +20,8 @@
#include <unordered_set>
#include <vector>
-#include "ast.h"
#include "loc.h"
+#include "stmt.h"
#include "string_piece.h"
#include "symtab.h"
@@ -46,12 +46,12 @@
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);
+ void EvalAssign(const AssignStmt* stmt);
+ void EvalRule(const RuleStmt* stmt);
+ void EvalCommand(const CommandStmt* stmt);
+ void EvalIf(const IfStmt* stmt);
+ void EvalInclude(const IncludeStmt* stmt);
+ void EvalExport(const ExportStmt* stmt);
Var* LookupVar(Symbol name);
// For target specific variables.
diff --git a/exec.cc b/exec.cc
index 563d615..afba609 100644
--- a/exec.cc
+++ b/exec.cc
@@ -27,13 +27,13 @@
#include "command.h"
#include "dep.h"
#include "eval.h"
+#include "expr.h"
#include "fileutil.h"
#include "flags.h"
#include "log.h"
#include "string_piece.h"
#include "strutil.h"
#include "symtab.h"
-#include "value.h"
#include "var.h"
namespace {
diff --git a/value.cc b/expr.cc
similarity index 99%
rename from value.cc
rename to expr.cc
index 83c6b18..07cccc9 100644
--- a/value.cc
+++ b/expr.cc
@@ -14,7 +14,7 @@
// +build ignore
-#include "value.h"
+#include "expr.h"
#include <vector>
diff --git a/value.h b/expr.h
similarity index 96%
rename from value.h
rename to expr.h
index 51ca29c..606ef90 100644
--- a/value.h
+++ b/expr.h
@@ -12,8 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef VALUE_H_
-#define VALUE_H_
+#ifndef EXPR_H_
+#define EXPR_H_
#include <string>
#include <vector>
@@ -68,4 +68,4 @@
Value* NewLiteral(StringPiece s);
-#endif // VALUE_H_
+#endif // EXPR_H_
diff --git a/file.cc b/file.cc
index 7217a37..4c423e5 100644
--- a/file.cc
+++ b/file.cc
@@ -21,9 +21,9 @@
#include <sys/types.h>
#include <unistd.h>
-#include "ast.h"
#include "log.h"
#include "parser.h"
+#include "stmt.h"
Makefile::Makefile(const string& filename)
: buf_(NULL), len_(0), mtime_(0), filename_(filename) {
@@ -56,6 +56,6 @@
Makefile::~Makefile() {
delete[] buf_;
- for (AST* ast : asts_)
- delete ast;
+ for (Stmt* stmt : stmts_)
+ delete stmt;
}
diff --git a/file.h b/file.h
index 5367320..1746343 100644
--- a/file.h
+++ b/file.h
@@ -22,7 +22,7 @@
using namespace std;
-struct AST;
+struct Stmt;
class Makefile {
public:
@@ -33,8 +33,8 @@
size_t len() const { return len_; }
const string& filename() const { return filename_; }
- const vector<AST*>& asts() const { return asts_; }
- vector<AST*>* mutable_asts() { return &asts_; }
+ const vector<Stmt*>& stmts() const { return stmts_; }
+ vector<Stmt*>* mutable_stmts() { return &stmts_; }
bool Exists() const { return buf_; }
@@ -43,7 +43,7 @@
size_t len_;
uint64_t mtime_;
string filename_;
- vector<AST*> asts_;
+ vector<Stmt*> stmts_;
};
#endif // FILE_H_
diff --git a/func.cc b/func.cc
index 25c41c1..6368e02 100644
--- a/func.cc
+++ b/func.cc
@@ -27,13 +27,13 @@
#include <memory>
#include <unordered_map>
-#include "ast.h"
#include "eval.h"
#include "fileutil.h"
#include "find.h"
#include "log.h"
#include "parser.h"
#include "stats.h"
+#include "stmt.h"
#include "strutil.h"
#include "symtab.h"
#include "var.h"
@@ -451,12 +451,12 @@
//const string text = args[0]->Eval(ev);
string* text = new string;
args[0]->Eval(ev, text);
- vector<AST*> asts;
- Parse(*text, ev->loc(), &asts);
- for (AST* ast : asts) {
- LOG("%s", ast->DebugString().c_str());
- ast->Eval(ev);
- //delete ast;
+ vector<Stmt*> stmts;
+ Parse(*text, ev->loc(), &stmts);
+ for (Stmt* stmt : stmts) {
+ LOG("%s", stmt->DebugString().c_str());
+ stmt->Eval(ev);
+ //delete stmt;
}
}
diff --git a/func.h b/func.h
index 11fea28..8db2c7a 100644
--- a/func.h
+++ b/func.h
@@ -19,7 +19,7 @@
#include <string>
#include <vector>
-#include "value.h"
+#include "expr.h"
using namespace std;
diff --git a/main.cc b/main.cc
index 61bedf6..d09eb4f 100644
--- a/main.cc
+++ b/main.cc
@@ -21,7 +21,6 @@
#include <time.h>
#include <unistd.h>
-#include "ast.h"
#include "dep.h"
#include "eval.h"
#include "exec.h"
@@ -35,6 +34,7 @@
#include "ninja.h"
#include "parser.h"
#include "stats.h"
+#include "stmt.h"
#include "string_piece.h"
#include "stringprintf.h"
#include "strutil.h"
@@ -71,7 +71,7 @@
}
static void ReadBootstrapMakefile(const vector<Symbol>& targets,
- vector<AST*>* asts) {
+ vector<Stmt*>* stmts) {
string bootstrap = (
"CC?=cc\n"
#if defined(__APPLE__)
@@ -112,7 +112,7 @@
CHECK(false);
}
bootstrap += StringPrintf("CURDIR:=%s\n", cwd);
- Parse(Intern(bootstrap).str(), Loc("*bootstrap*", 0), asts);
+ Parse(Intern(bootstrap).str(), Loc("*bootstrap*", 0), stmts);
}
static void SetVar(StringPiece l, VarOrigin origin, Vars* vars) {
@@ -155,12 +155,12 @@
}
Evaluator* ev = new Evaluator(vars);
- vector<AST*> bootstrap_asts;
+ vector<Stmt*> bootstrap_asts;
ReadBootstrapMakefile(targets, &bootstrap_asts);
ev->set_is_bootstrap(true);
- for (AST* ast : bootstrap_asts) {
- LOG("%s", ast->DebugString().c_str());
- ast->Eval(ev);
+ for (Stmt* stmt : bootstrap_asts) {
+ LOG("%s", stmt->DebugString().c_str());
+ stmt->Eval(ev);
}
ev->set_is_bootstrap(false);
@@ -175,13 +175,13 @@
{
ScopedTimeReporter tr("eval time");
Makefile* mk = cache_mgr->ReadMakefile(g_flags.makefile);
- for (AST* ast : mk->asts()) {
- LOG("%s", ast->DebugString().c_str());
- ast->Eval(ev);
+ for (Stmt* stmt : mk->stmts()) {
+ LOG("%s", stmt->DebugString().c_str());
+ stmt->Eval(ev);
}
}
- for (ParseErrorAST* err : GetParseErrors()) {
+ for (ParseErrorStmt* err : GetParseErrors()) {
WARN("%s:%d: warning for parse error in an unevaluated line: %s",
LOCF(err->loc()), err->msg.c_str());
}
@@ -221,8 +221,8 @@
Exec(nodes, ev);
}
- for (AST* ast : bootstrap_asts)
- delete ast;
+ for (Stmt* stmt : bootstrap_asts)
+ delete stmt;
delete ev;
delete vars;
delete cache_mgr;
diff --git a/parser.cc b/parser.cc
index d8b33e4..106b576 100644
--- a/parser.cc
+++ b/parser.cc
@@ -19,14 +19,14 @@
#include <stack>
#include <unordered_map>
-#include "ast.h"
+#include "expr.h"
#include "file.h"
#include "loc.h"
#include "log.h"
#include "stats.h"
+#include "stmt.h"
#include "string_piece.h"
#include "strutil.h"
-#include "value.h"
enum struct ParserState {
NOT_AFTER_RULE = 0,
@@ -36,7 +36,7 @@
class Parser {
struct IfState {
- IfAST* ast;
+ IfStmt* stmt;
bool is_in_else;
int num_nest;
};
@@ -46,21 +46,21 @@
typedef unordered_map<StringPiece, DirectiveHandler> DirectiveMap;
public:
- Parser(StringPiece buf, const char* filename, vector<AST*>* asts)
+ Parser(StringPiece buf, const char* filename, vector<Stmt*>* stmts)
: buf_(buf),
state_(ParserState::NOT_AFTER_RULE),
- asts_(asts),
- out_asts_(asts),
+ stmts_(stmts),
+ out_stmts_(stmts),
num_if_nest_(0),
loc_(filename, 0),
fixed_lineno_(false) {
}
- Parser(StringPiece buf, const Loc& loc, vector<AST*>* asts)
+ Parser(StringPiece buf, const Loc& loc, vector<Stmt*>* stmts)
: buf_(buf),
state_(ParserState::NOT_AFTER_RULE),
- asts_(asts),
- out_asts_(asts),
+ stmts_(stmts),
+ out_stmts_(stmts),
num_if_nest_(0),
loc_(loc),
fixed_lineno_(true) {
@@ -131,15 +131,15 @@
void set_state(ParserState st) { state_ = st; }
- static vector<ParseErrorAST*> parse_errors;
+ static vector<ParseErrorStmt*> parse_errors;
private:
void Error(const string& msg) {
- ParseErrorAST* ast = new ParseErrorAST();
- ast->set_loc(loc_);
- ast->msg = msg;
- out_asts_->push_back(ast);
- parse_errors.push_back(ast);
+ ParseErrorStmt* stmt = new ParseErrorStmt();
+ stmt->set_loc(loc_);
+ stmt->msg = msg;
+ out_stmts_->push_back(stmt);
+ parse_errors.push_back(stmt);
}
size_t FindEndOfLine(size_t* lf_cnt) {
@@ -162,11 +162,11 @@
current_directive_ = AssignDirective::NONE;
if (line[0] == '\t' && state_ != ParserState::NOT_AFTER_RULE) {
- CommandAST* ast = new CommandAST();
- ast->set_loc(loc_);
- ast->expr = ParseExpr(line.substr(1), ParseExprOpt::COMMAND);
- ast->orig = line;
- out_asts_->push_back(ast);
+ CommandStmt* stmt = new CommandStmt();
+ stmt->set_loc(loc_);
+ stmt->expr = ParseExpr(line.substr(1), ParseExprOpt::COMMAND);
+ stmt->orig = line;
+ out_stmts_->push_back(stmt);
return;
}
@@ -217,23 +217,23 @@
}
const bool is_rule = sep != string::npos && line[sep] == ':';
- RuleAST* ast = new RuleAST();
- ast->set_loc(loc_);
+ RuleStmt* stmt = new RuleStmt();
+ stmt->set_loc(loc_);
size_t found = FindTwoOutsideParen(line.substr(sep + 1), '=', ';');
if (found != string::npos) {
found += sep + 1;
- ast->term = line[found];
+ stmt->term = line[found];
ParseExprOpt opt =
- ast->term == ';' ? ParseExprOpt::COMMAND : ParseExprOpt::NORMAL;
- ast->after_term = ParseExpr(TrimLeftSpace(line.substr(found + 1)), opt);
- ast->expr = ParseExpr(TrimSpace(line.substr(0, found)));
+ stmt->term == ';' ? ParseExprOpt::COMMAND : ParseExprOpt::NORMAL;
+ stmt->after_term = ParseExpr(TrimLeftSpace(line.substr(found + 1)), opt);
+ stmt->expr = ParseExpr(TrimSpace(line.substr(0, found)));
} else {
- ast->term = 0;
- ast->after_term = NULL;
- ast->expr = ParseExpr(line);
+ stmt->term = 0;
+ stmt->after_term = NULL;
+ stmt->expr = ParseExpr(line);
}
- out_asts_->push_back(ast);
+ out_stmts_->push_back(stmt);
state_ = is_rule ? ParserState::AFTER_RULE : ParserState::MAYBE_AFTER_RULE;
}
@@ -247,23 +247,23 @@
AssignOp op;
ParseAssignStatement(line, sep, &lhs, &rhs, &op);
- AssignAST* ast = new AssignAST();
- ast->set_loc(loc_);
- ast->lhs = ParseExpr(lhs);
- ast->rhs = ParseExpr(rhs);
- ast->orig_rhs = rhs;
- ast->op = op;
- ast->directive = current_directive_;
- out_asts_->push_back(ast);
+ AssignStmt* stmt = new AssignStmt();
+ stmt->set_loc(loc_);
+ stmt->lhs = ParseExpr(lhs);
+ stmt->rhs = ParseExpr(rhs);
+ stmt->orig_rhs = rhs;
+ stmt->op = op;
+ stmt->directive = current_directive_;
+ out_stmts_->push_back(stmt);
state_ = ParserState::NOT_AFTER_RULE;
}
void ParseInclude(StringPiece line, StringPiece directive) {
- IncludeAST* ast = new IncludeAST();
- ast->set_loc(loc_);
- ast->expr = ParseExpr(line);
- ast->should_exist = directive[0] == 'i';
- out_asts_->push_back(ast);
+ IncludeStmt* stmt = new IncludeStmt();
+ stmt->set_loc(loc_);
+ stmt->expr = ParseExpr(line);
+ stmt->should_exist = directive[0] == 'i';
+ out_stmts_->push_back(stmt);
state_ = ParserState::NOT_AFTER_RULE;
}
@@ -292,40 +292,40 @@
WARN("%s:%d: extraneous text after `endef' directive", LOCF(loc_));
}
- AssignAST* ast = new AssignAST();
- ast->set_loc(Loc(loc_.filename, define_start_line_));
- ast->lhs = ParseExpr(define_name_);
+ AssignStmt* stmt = new AssignStmt();
+ stmt->set_loc(Loc(loc_.filename, define_start_line_));
+ stmt->lhs = ParseExpr(define_name_);
StringPiece rhs;
if (define_start_)
rhs = buf_.substr(define_start_, l_ - define_start_ - 1);
- ast->rhs = ParseExpr(rhs, ParseExprOpt::DEFINE);
- ast->orig_rhs = rhs;
- ast->op = AssignOp::EQ;
- ast->directive = current_directive_;
- out_asts_->push_back(ast);
+ stmt->rhs = ParseExpr(rhs, ParseExprOpt::DEFINE);
+ stmt->orig_rhs = rhs;
+ stmt->op = AssignOp::EQ;
+ stmt->directive = current_directive_;
+ out_stmts_->push_back(stmt);
define_name_.clear();
}
- void EnterIf(IfAST* ast) {
+ void EnterIf(IfStmt* stmt) {
IfState* st = new IfState();
- st->ast = ast;
+ st->stmt = stmt;
st->is_in_else = false;
st->num_nest = num_if_nest_;
if_stack_.push(st);
- out_asts_ = &ast->true_asts;
+ out_stmts_ = &stmt->true_stmts;
}
void ParseIfdef(StringPiece line, StringPiece directive) {
- IfAST* ast = new IfAST();
- ast->set_loc(loc_);
- ast->op = directive[2] == 'n' ? CondOp::IFNDEF : CondOp::IFDEF;
- ast->lhs = ParseExpr(line);
- ast->rhs = NULL;
- out_asts_->push_back(ast);
- EnterIf(ast);
+ IfStmt* stmt = new IfStmt();
+ stmt->set_loc(loc_);
+ stmt->op = directive[2] == 'n' ? CondOp::IFNDEF : CondOp::IFDEF;
+ stmt->lhs = ParseExpr(line);
+ stmt->rhs = NULL;
+ out_stmts_->push_back(stmt);
+ EnterIf(stmt);
}
- bool ParseIfEqCond(StringPiece s, IfAST* ast) {
+ bool ParseIfEqCond(StringPiece s, IfStmt* stmt) {
if (s.empty()) {
return false;
}
@@ -334,11 +334,11 @@
s = s.substr(1, s.size() - 2);
char terms[] = {',', '\0'};
size_t n;
- ast->lhs = ParseExprImpl(loc_, s, terms, ParseExprOpt::NORMAL, &n, true);
+ stmt->lhs = ParseExprImpl(loc_, s, terms, ParseExprOpt::NORMAL, &n, true);
if (s[n] != ',')
return false;
s = TrimLeftSpace(s.substr(n+1));
- ast->rhs = ParseExprImpl(loc_, s, NULL, ParseExprOpt::NORMAL, &n);
+ stmt->rhs = ParseExprImpl(loc_, s, NULL, ParseExprOpt::NORMAL, &n);
s = TrimLeftSpace(s.substr(n));
} else {
for (int i = 0; i < 2; i++) {
@@ -352,9 +352,9 @@
return false;
Value* v = ParseExpr(s.substr(1, end - 1), ParseExprOpt::NORMAL);
if (i == 0)
- ast->lhs = v;
+ stmt->lhs = v;
else
- ast->rhs = v;
+ stmt->rhs = v;
s = TrimLeftSpace(s.substr(end+1));
}
}
@@ -366,17 +366,17 @@
}
void ParseIfeq(StringPiece line, StringPiece directive) {
- IfAST* ast = new IfAST();
- ast->set_loc(loc_);
- ast->op = directive[2] == 'n' ? CondOp::IFNEQ : CondOp::IFEQ;
+ IfStmt* stmt = new IfStmt();
+ stmt->set_loc(loc_);
+ stmt->op = directive[2] == 'n' ? CondOp::IFNEQ : CondOp::IFEQ;
- if (!ParseIfEqCond(line, ast)) {
+ if (!ParseIfEqCond(line, stmt)) {
Error("*** invalid syntax in conditional.");
return;
}
- out_asts_->push_back(ast);
- EnterIf(ast);
+ out_stmts_->push_back(stmt);
+ EnterIf(stmt);
}
void ParseElse(StringPiece line, StringPiece) {
@@ -388,7 +388,7 @@
return;
}
st->is_in_else = true;
- out_asts_ = &st->ast->false_asts;
+ out_stmts_ = &st->stmt->false_stmts;
StringPiece next_if = TrimLeftSpace(line);
if (next_if.empty())
@@ -413,13 +413,13 @@
delete if_stack_.top();
if_stack_.pop();
if (if_stack_.empty()) {
- out_asts_ = asts_;
+ out_stmts_ = stmts_;
} else {
IfState* st = if_stack_.top();
if (st->is_in_else)
- out_asts_ = &st->ast->false_asts;
+ out_stmts_ = &st->stmt->false_stmts;
else
- out_asts_ = &st->ast->true_asts;
+ out_stmts_ = &st->stmt->true_stmts;
}
}
}
@@ -430,11 +430,11 @@
}
void CreateExport(StringPiece line, bool is_export) {
- ExportAST* ast = new ExportAST;
- ast->set_loc(loc_);
- ast->expr = ParseExpr(line);
- ast->is_export = is_export;
- out_asts_->push_back(ast);
+ ExportStmt* stmt = new ExportStmt;
+ stmt->set_loc(loc_);
+ stmt->expr = ParseExpr(line);
+ stmt->is_export = is_export;
+ out_stmts_->push_back(stmt);
}
void ParseOverride(StringPiece line, StringPiece) {
@@ -504,8 +504,8 @@
size_t l_;
ParserState state_;
- vector<AST*>* asts_;
- vector<AST*>* out_asts_;
+ vector<Stmt*>* stmts_;
+ vector<Stmt*>* out_stmts_;
StringPiece define_name_;
size_t define_start_;
@@ -531,19 +531,19 @@
COLLECT_STATS("parse file time");
Parser parser(StringPiece(mk->buf(), mk->len()),
mk->filename().c_str(),
- mk->mutable_asts());
+ mk->mutable_stmts());
parser.Parse();
}
-void Parse(StringPiece buf, const Loc& loc, vector<AST*>* out_asts) {
+void Parse(StringPiece buf, const Loc& loc, vector<Stmt*>* out_stmts) {
COLLECT_STATS("parse eval time");
- Parser parser(buf, loc, out_asts);
+ Parser parser(buf, loc, out_stmts);
parser.Parse();
}
void ParseNotAfterRule(StringPiece buf, const Loc& loc,
- vector<AST*>* out_asts) {
- Parser parser(buf, loc, out_asts);
+ vector<Stmt*>* out_stmts) {
+ Parser parser(buf, loc, out_stmts);
parser.set_state(ParserState::NOT_AFTER_RULE);
parser.Parse();
}
@@ -561,7 +561,7 @@
Parser::DirectiveMap* Parser::assign_directives_;
size_t Parser::shortest_directive_len_;
size_t Parser::longest_directive_len_;
-vector<ParseErrorAST*> Parser::parse_errors;
+vector<ParseErrorStmt*> Parser::parse_errors;
void ParseAssignStatement(StringPiece line, size_t sep,
StringPiece* lhs, StringPiece* rhs, AssignOp* op) {
@@ -586,6 +586,6 @@
*rhs = TrimSpace(line.substr(sep + 1));
}
-const vector<ParseErrorAST*>& GetParseErrors() {
+const vector<ParseErrorStmt*>& GetParseErrors() {
return Parser::parse_errors;
}
diff --git a/parser.h b/parser.h
index 857219d..95b7241 100644
--- a/parser.h
+++ b/parser.h
@@ -17,8 +17,8 @@
#include <vector>
-#include "ast.h"
#include "loc.h"
+#include "stmt.h"
#include "string_piece.h"
using namespace std;
@@ -26,9 +26,9 @@
class Makefile;
void Parse(Makefile* mk);
-void Parse(StringPiece buf, const Loc& loc, vector<AST*>* out_asts);
+void Parse(StringPiece buf, const Loc& loc, vector<Stmt*>* out_asts);
void ParseNotAfterRule(StringPiece buf, const Loc& loc,
- vector<AST*>* out_asts);
+ vector<Stmt*>* out_asts);
void ParseAssignStatement(StringPiece line, size_t sep,
StringPiece* lhs, StringPiece* rhs, AssignOp* op);
@@ -36,6 +36,6 @@
void InitParser();
void QuitParser();
-const vector<ParseErrorAST*>& GetParseErrors();
+const vector<ParseErrorStmt*>& GetParseErrors();
#endif // PARSER_H_
diff --git a/rule.cc b/rule.cc
index 175b43a..a77366a 100644
--- a/rule.cc
+++ b/rule.cc
@@ -16,12 +16,12 @@
#include "rule.h"
+#include "expr.h"
#include "log.h"
#include "parser.h"
#include "stringprintf.h"
#include "strutil.h"
#include "symtab.h"
-#include "value.h"
namespace {
diff --git a/rule.h b/rule.h
index c6fd72c..2a67368 100644
--- a/rule.h
+++ b/rule.h
@@ -17,9 +17,9 @@
#include <vector>
-#include "ast.h"
#include "loc.h"
#include "log.h"
+#include "stmt.h"
#include "string_piece.h"
#include "symtab.h"
diff --git a/ast.cc b/stmt.cc
similarity index 66%
rename from ast.cc
rename to stmt.cc
index 50f2a6b..1abab32 100644
--- a/ast.cc
+++ b/stmt.cc
@@ -14,26 +14,26 @@
// +build ignore
-#include "ast.h"
+#include "stmt.h"
#include "eval.h"
+#include "expr.h"
#include "stringprintf.h"
#include "strutil.h"
-#include "value.h"
-AST::AST() {}
+Stmt::Stmt() {}
-AST::~AST() {}
+Stmt::~Stmt() {}
-string RuleAST::DebugString() const {
- return StringPrintf("RuleAST(expr=%s term=%d after_term=%s loc=%s:%d)",
+string RuleStmt::DebugString() const {
+ return StringPrintf("RuleStmt(expr=%s term=%d after_term=%s loc=%s:%d)",
expr->DebugString().c_str(),
term,
after_term->DebugString().c_str(),
LOCF(loc()));
}
-string AssignAST::DebugString() const {
+string AssignStmt::DebugString() const {
const char* opstr = "???";
switch (op) {
case AssignOp::EQ: opstr = "EQ"; break;
@@ -47,7 +47,7 @@
case AssignDirective::OVERRIDE: dirstr = "override"; break;
case AssignDirective::EXPORT: dirstr = "export"; break;
}
- return StringPrintf("AssignAST(lhs=%s rhs=%s (%s) "
+ return StringPrintf("AssignStmt(lhs=%s rhs=%s (%s) "
"opstr=%s dir=%s loc=%s:%d)",
lhs->DebugString().c_str(),
rhs->DebugString().c_str(),
@@ -55,12 +55,12 @@
opstr, dirstr, LOCF(loc()));
}
-string CommandAST::DebugString() const {
- return StringPrintf("CommandAST(%s, loc=%s:%d)",
+string CommandStmt::DebugString() const {
+ return StringPrintf("CommandStmt(%s, loc=%s:%d)",
expr->DebugString().c_str(), LOCF(loc()));
}
-string IfAST::DebugString() const {
+string IfStmt::DebugString() const {
const char* opstr = "???";
switch (op) {
case CondOp::IFEQ: opstr = "ifeq"; break;
@@ -68,88 +68,88 @@
case CondOp::IFDEF: opstr = "ifdef"; break;
case CondOp::IFNDEF: opstr = "ifndef"; break;
}
- return StringPrintf("IfAST(op=%s, lhs=%s, rhs=%s t=%zu f=%zu loc=%s:%d)",
+ return StringPrintf("IfStmt(op=%s, lhs=%s, rhs=%s t=%zu f=%zu loc=%s:%d)",
opstr,
lhs->DebugString().c_str(),
rhs->DebugString().c_str(),
- true_asts.size(),
- false_asts.size(),
+ true_stmts.size(),
+ false_stmts.size(),
LOCF(loc()));
}
-string IncludeAST::DebugString() const {
- return StringPrintf("IncludeAST(%s, loc=%s:%d)",
+string IncludeStmt::DebugString() const {
+ return StringPrintf("IncludeStmt(%s, loc=%s:%d)",
expr->DebugString().c_str(), LOCF(loc()));
}
-string ExportAST::DebugString() const {
- return StringPrintf("ExportAST(%s, %d, loc=%s:%d)",
+string ExportStmt::DebugString() const {
+ return StringPrintf("ExportStmt(%s, %d, loc=%s:%d)",
expr->DebugString().c_str(),
is_export,
LOCF(loc()));
}
-string ParseErrorAST::DebugString() const {
- return StringPrintf("ParseErrorAST(%s, loc=%s:%d)",
+string ParseErrorStmt::DebugString() const {
+ return StringPrintf("ParseErrorStmt(%s, loc=%s:%d)",
msg.c_str(),
LOCF(loc()));
}
-RuleAST::~RuleAST() {
+RuleStmt::~RuleStmt() {
delete expr;
delete after_term;
}
-void RuleAST::Eval(Evaluator* ev) const {
+void RuleStmt::Eval(Evaluator* ev) const {
ev->EvalRule(this);
}
-AssignAST::~AssignAST() {
+AssignStmt::~AssignStmt() {
delete lhs;
delete rhs;
}
-void AssignAST::Eval(Evaluator* ev) const {
+void AssignStmt::Eval(Evaluator* ev) const {
ev->EvalAssign(this);
}
-CommandAST::~CommandAST() {
+CommandStmt::~CommandStmt() {
delete expr;
}
-void CommandAST::Eval(Evaluator* ev) const {
+void CommandStmt::Eval(Evaluator* ev) const {
ev->EvalCommand(this);
}
-IfAST::~IfAST() {
+IfStmt::~IfStmt() {
delete lhs;
delete rhs;
}
-void IfAST::Eval(Evaluator* ev) const {
+void IfStmt::Eval(Evaluator* ev) const {
ev->EvalIf(this);
}
-IncludeAST::~IncludeAST() {
+IncludeStmt::~IncludeStmt() {
delete expr;
}
-void IncludeAST::Eval(Evaluator* ev) const {
+void IncludeStmt::Eval(Evaluator* ev) const {
ev->EvalInclude(this);
}
-ExportAST::~ExportAST() {
+ExportStmt::~ExportStmt() {
delete expr;
}
-void ExportAST::Eval(Evaluator* ev) const {
+void ExportStmt::Eval(Evaluator* ev) const {
ev->EvalExport(this);
}
-ParseErrorAST::~ParseErrorAST() {
+ParseErrorStmt::~ParseErrorStmt() {
}
-void ParseErrorAST::Eval(Evaluator* ev) const {
+void ParseErrorStmt::Eval(Evaluator* ev) const {
ev->set_loc(loc());
ev->Error(msg);
}
diff --git a/ast.h b/stmt.h
similarity index 79%
rename from ast.h
rename to stmt.h
index 0289853..4d4c5eb 100644
--- a/ast.h
+++ b/stmt.h
@@ -12,8 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef AST_H_
-#define AST_H_
+#ifndef STMT_H_
+#define STMT_H_
#include <string>
#include <vector>
@@ -46,9 +46,9 @@
IFNDEF,
};
-struct AST {
+struct Stmt {
public:
- virtual ~AST();
+ virtual ~Stmt();
Loc loc() const { return loc_; }
void set_loc(Loc loc) { loc_ = loc; }
@@ -59,94 +59,94 @@
virtual string DebugString() const = 0;
protected:
- AST();
+ Stmt();
private:
Loc loc_;
StringPiece orig_;
};
-struct RuleAST : public AST {
+struct RuleStmt : public Stmt {
Value* expr;
char term;
Value* after_term;
- virtual ~RuleAST();
+ virtual ~RuleStmt();
virtual void Eval(Evaluator* ev) const;
virtual string DebugString() const;
};
-struct AssignAST : public AST {
+struct AssignStmt : public Stmt {
Value* lhs;
Value* rhs;
StringPiece orig_rhs;
AssignOp op;
AssignDirective directive;
- virtual ~AssignAST();
+ virtual ~AssignStmt();
virtual void Eval(Evaluator* ev) const;
virtual string DebugString() const;
};
-struct CommandAST : public AST {
+struct CommandStmt : public Stmt {
Value* expr;
StringPiece orig;
- virtual ~CommandAST();
+ virtual ~CommandStmt();
virtual void Eval(Evaluator* ev) const;
virtual string DebugString() const;
};
-struct IfAST : public AST {
+struct IfStmt : public Stmt {
CondOp op;
Value* lhs;
Value* rhs;
- vector<AST*> true_asts;
- vector<AST*> false_asts;
+ vector<Stmt*> true_stmts;
+ vector<Stmt*> false_stmts;
- virtual ~IfAST();
+ virtual ~IfStmt();
virtual void Eval(Evaluator* ev) const;
virtual string DebugString() const;
};
-struct IncludeAST : public AST {
+struct IncludeStmt : public Stmt {
Value* expr;
bool should_exist;
- virtual ~IncludeAST();
+ virtual ~IncludeStmt();
virtual void Eval(Evaluator* ev) const;
virtual string DebugString() const;
};
-struct ExportAST : public AST {
+struct ExportStmt : public Stmt {
Value* expr;
bool is_export;
- virtual ~ExportAST();
+ virtual ~ExportStmt();
virtual void Eval(Evaluator* ev) const;
virtual string DebugString() const;
};
-struct ParseErrorAST : public AST {
+struct ParseErrorStmt : public Stmt {
string msg;
- virtual ~ParseErrorAST();
+ virtual ~ParseErrorStmt();
virtual void Eval(Evaluator* ev) const;
virtual string DebugString() const;
};
-#endif // AST_H_
+#endif // STMT_H_
diff --git a/var.cc b/var.cc
index 8ee7588..d21dc4f 100644
--- a/var.cc
+++ b/var.cc
@@ -16,8 +16,8 @@
#include "var.h"
+#include "expr.h"
#include "log.h"
-#include "value.h"
UndefinedVar kUndefinedBuf;
UndefinedVar* kUndefined = &kUndefinedBuf;
diff --git a/var.h b/var.h
index e2eddc7..3bae262 100644
--- a/var.h
+++ b/var.h
@@ -19,10 +19,10 @@
#include <unordered_map>
#include <unordered_set>
-#include "ast.h"
+#include "expr.h"
+#include "stmt.h"
#include "string_piece.h"
#include "symtab.h"
-#include "value.h"
using namespace std;