// 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.
|
|
// +build ignore
|
|
#include "eval.h"
|
|
#include <errno.h>
|
#include <pthread.h>
|
#include <string.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 "var.h"
|
|
Evaluator::Evaluator()
|
: last_rule_(NULL),
|
current_scope_(NULL),
|
avoid_io_(false),
|
eval_depth_(0),
|
posix_sym_(Intern(".POSIX")),
|
is_posix_(false),
|
export_error_(false) {
|
#if defined(__APPLE__)
|
stack_size_ = pthread_get_stacksize_np(pthread_self());
|
stack_addr_ = (char*)pthread_get_stackaddr_np(pthread_self()) - stack_size_;
|
#else
|
pthread_attr_t attr;
|
CHECK(pthread_getattr_np(pthread_self(), &attr) == 0);
|
CHECK(pthread_attr_getstack(&attr, &stack_addr_, &stack_size_) == 0);
|
CHECK(pthread_attr_destroy(&attr) == 0);
|
#endif
|
|
lowest_stack_ = (char*)stack_addr_ + stack_size_;
|
LOG_STAT("Stack size: %zd bytes", stack_size_);
|
}
|
|
Evaluator::~Evaluator() {
|
// delete vars_;
|
// for (auto p : rule_vars) {
|
// delete p.second;
|
// }
|
}
|
|
Var* Evaluator::EvalRHS(Symbol lhs,
|
Value* rhs_v,
|
StringPiece orig_rhs,
|
AssignOp op,
|
bool is_override,
|
bool* needs_assign) {
|
VarOrigin origin =
|
((is_bootstrap_ ? VarOrigin::DEFAULT
|
: is_commandline_ ? VarOrigin::COMMAND_LINE
|
: is_override ? VarOrigin::OVERRIDE
|
: VarOrigin::FILE));
|
|
Var* result = NULL;
|
Var* prev = NULL;
|
*needs_assign = true;
|
|
switch (op) {
|
case AssignOp::COLON_EQ: {
|
prev = PeekVarInCurrentScope(lhs);
|
result = new SimpleVar(origin, this, rhs_v);
|
break;
|
}
|
case AssignOp::EQ:
|
prev = PeekVarInCurrentScope(lhs);
|
result = new RecursiveVar(rhs_v, origin, orig_rhs);
|
break;
|
case AssignOp::PLUS_EQ: {
|
prev = LookupVarInCurrentScope(lhs);
|
if (!prev->IsDefined()) {
|
result = new RecursiveVar(rhs_v, origin, orig_rhs);
|
} else if (prev->ReadOnly()) {
|
Error(StringPrintf("*** cannot assign to readonly variable: %s",
|
lhs.c_str()));
|
} else {
|
result = prev;
|
result->AppendVar(this, rhs_v);
|
*needs_assign = false;
|
}
|
break;
|
}
|
case AssignOp::QUESTION_EQ: {
|
prev = LookupVarInCurrentScope(lhs);
|
if (!prev->IsDefined()) {
|
result = new RecursiveVar(rhs_v, origin, orig_rhs);
|
} else {
|
result = prev;
|
*needs_assign = false;
|
}
|
break;
|
}
|
}
|
|
if (prev != NULL) {
|
prev->Used(this, lhs);
|
if (prev->Deprecated() && *needs_assign) {
|
result->SetDeprecated(prev->DeprecatedMessage());
|
}
|
}
|
|
LOG("Assign: %s=%s", lhs.c_str(), result->DebugString().c_str());
|
return result;
|
}
|
|
void Evaluator::EvalAssign(const AssignStmt* stmt) {
|
loc_ = stmt->loc();
|
last_rule_ = NULL;
|
Symbol lhs = stmt->GetLhsSymbol(this);
|
if (lhs.empty())
|
Error("*** empty variable name.");
|
|
if (lhs == kKatiReadonlySym) {
|
string rhs;
|
stmt->rhs->Eval(this, &rhs);
|
for (auto const& name : WordScanner(rhs)) {
|
Var* var = Intern(name).GetGlobalVar();
|
if (!var->IsDefined()) {
|
Error(
|
StringPrintf("*** unknown variable: %s", name.as_string().c_str()));
|
}
|
var->SetReadOnly();
|
}
|
return;
|
}
|
|
bool needs_assign;
|
Var* var =
|
EvalRHS(lhs, stmt->rhs, stmt->orig_rhs, stmt->op,
|
stmt->directive == AssignDirective::OVERRIDE, &needs_assign);
|
if (needs_assign) {
|
bool readonly;
|
lhs.SetGlobalVar(var, stmt->directive == AssignDirective::OVERRIDE,
|
&readonly);
|
if (readonly) {
|
Error(StringPrintf("*** cannot assign to readonly variable: %s",
|
lhs.c_str()));
|
}
|
}
|
|
if (stmt->is_final) {
|
var->SetReadOnly();
|
}
|
}
|
|
// With rule broken into
|
// <before_term> <term> <after_term>
|
// parses <before_term> into Symbol instances until encountering ':'
|
// Returns the remainder of <before_term>.
|
static StringPiece ParseRuleTargets(const Loc& loc,
|
const StringPiece& before_term,
|
vector<Symbol>* targets,
|
bool* is_pattern_rule) {
|
size_t pos = before_term.find(':');
|
if (pos == string::npos) {
|
ERROR_LOC(loc, "*** missing separator.");
|
}
|
StringPiece targets_string = before_term.substr(0, pos);
|
size_t pattern_rule_count = 0;
|
for (auto const& word : WordScanner(targets_string)) {
|
StringPiece target = TrimLeadingCurdir(word);
|
targets->push_back(Intern(target));
|
if (Rule::IsPatternRule(target)) {
|
++pattern_rule_count;
|
}
|
}
|
// Check consistency: either all outputs are patterns or none.
|
if (pattern_rule_count && (pattern_rule_count != targets->size())) {
|
ERROR_LOC(loc, "*** mixed implicit and normal rules: deprecated syntax");
|
}
|
*is_pattern_rule = pattern_rule_count;
|
return before_term.substr(pos + 1);
|
}
|
|
void Evaluator::MarkVarsReadonly(Value* vars_list) {
|
string vars_list_string;
|
vars_list->Eval(this, &vars_list_string);
|
for (auto const& name : WordScanner(vars_list_string)) {
|
Var* var = current_scope_->Lookup(Intern(name));
|
if (!var->IsDefined()) {
|
Error(StringPrintf("*** unknown variable: %s", name.as_string().c_str()));
|
}
|
var->SetReadOnly();
|
}
|
}
|
|
void Evaluator::EvalRuleSpecificAssign(const vector<Symbol>& targets,
|
const RuleStmt* stmt,
|
const StringPiece& after_targets,
|
size_t separator_pos) {
|
StringPiece var_name;
|
StringPiece rhs_string;
|
AssignOp assign_op;
|
ParseAssignStatement(after_targets, separator_pos, &var_name, &rhs_string,
|
&assign_op);
|
Symbol var_sym = Intern(var_name);
|
bool is_final = (stmt->sep == RuleStmt::SEP_FINALEQ);
|
for (Symbol target : targets) {
|
auto p = rule_vars_.emplace(target, nullptr);
|
if (p.second) {
|
p.first->second = new Vars;
|
}
|
|
Value* rhs;
|
if (rhs_string.empty()) {
|
rhs = stmt->rhs;
|
} else if (stmt->rhs) {
|
StringPiece sep(stmt->sep == RuleStmt::SEP_SEMICOLON ? " ; " : " = ");
|
rhs = Value::NewExpr(Value::NewLiteral(rhs_string),
|
Value::NewLiteral(sep), stmt->rhs);
|
} else {
|
rhs = Value::NewLiteral(rhs_string);
|
}
|
|
current_scope_ = p.first->second;
|
if (var_sym == kKatiReadonlySym) {
|
MarkVarsReadonly(rhs);
|
} else {
|
bool needs_assign;
|
Var* rhs_var = EvalRHS(var_sym, rhs, StringPiece("*TODO*"), assign_op,
|
false, &needs_assign);
|
if (needs_assign) {
|
bool readonly;
|
rhs_var->SetAssignOp(assign_op);
|
current_scope_->Assign(var_sym, rhs_var, &readonly);
|
if (readonly) {
|
Error(StringPrintf("*** cannot assign to readonly variable: %s",
|
var_name));
|
}
|
}
|
if (is_final) {
|
rhs_var->SetReadOnly();
|
}
|
}
|
current_scope_ = NULL;
|
}
|
}
|
|
void Evaluator::EvalRule(const RuleStmt* stmt) {
|
loc_ = stmt->loc();
|
last_rule_ = NULL;
|
|
const string&& before_term = stmt->lhs->Eval(this);
|
// See semicolon.mk.
|
if (before_term.find_first_not_of(" \t;") == string::npos) {
|
if (stmt->sep == RuleStmt::SEP_SEMICOLON)
|
Error("*** missing rule before commands.");
|
return;
|
}
|
|
vector<Symbol> targets;
|
bool is_pattern_rule;
|
StringPiece after_targets =
|
ParseRuleTargets(loc_, before_term, &targets, &is_pattern_rule);
|
bool is_double_colon = (after_targets[0] == ':');
|
if (is_double_colon) {
|
after_targets = after_targets.substr(1);
|
}
|
|
// Figure out if this is a rule-specific variable assignment.
|
// It is an assignment when either after_targets contains an assignment token
|
// or separator is an assignment token, but only if there is no ';' before the
|
// first assignment token.
|
size_t separator_pos = after_targets.find_first_of("=;");
|
char separator = '\0';
|
if (separator_pos != string::npos) {
|
separator = after_targets[separator_pos];
|
} else if (separator_pos == string::npos &&
|
(stmt->sep == RuleStmt::SEP_EQ ||
|
stmt->sep == RuleStmt::SEP_FINALEQ)) {
|
separator_pos = after_targets.size();
|
separator = '=';
|
}
|
|
// If variable name is not empty, we have rule- or target-specific
|
// variable assignment.
|
if (separator == '=' && separator_pos) {
|
EvalRuleSpecificAssign(targets, stmt, after_targets, separator_pos);
|
return;
|
}
|
|
// "test: =foo" is questionable but a valid rule definition (not a
|
// target specific variable).
|
// See https://github.com/google/kati/issues/83
|
string buf;
|
if (!separator_pos) {
|
KATI_WARN_LOC(loc_,
|
"defining a target which starts with `=', "
|
"which is not probably what you meant");
|
buf = after_targets.as_string();
|
if (stmt->sep == RuleStmt::SEP_SEMICOLON) {
|
buf += ';';
|
} else if (stmt->sep == RuleStmt::SEP_EQ ||
|
stmt->sep == RuleStmt::SEP_FINALEQ) {
|
buf += '=';
|
}
|
if (stmt->rhs) {
|
buf += stmt->rhs->Eval(this);
|
}
|
after_targets = buf;
|
separator_pos = string::npos;
|
}
|
|
Rule* rule = new Rule();
|
rule->loc = loc_;
|
rule->is_double_colon = is_double_colon;
|
if (is_pattern_rule) {
|
rule->output_patterns.swap(targets);
|
} else {
|
rule->outputs.swap(targets);
|
}
|
rule->ParsePrerequisites(after_targets, separator_pos, stmt);
|
|
if (stmt->sep == RuleStmt::SEP_SEMICOLON) {
|
rule->cmds.push_back(stmt->rhs);
|
}
|
|
for (Symbol o : rule->outputs) {
|
if (o == posix_sym_)
|
is_posix_ = true;
|
}
|
|
LOG("Rule: %s", rule->DebugString().c_str());
|
rules_.push_back(rule);
|
last_rule_ = rule;
|
}
|
|
void Evaluator::EvalCommand(const CommandStmt* stmt) {
|
loc_ = stmt->loc();
|
|
if (!last_rule_) {
|
vector<Stmt*> stmts;
|
ParseNotAfterRule(stmt->orig, stmt->loc(), &stmts);
|
for (Stmt* a : stmts)
|
a->Eval(this);
|
return;
|
}
|
|
last_rule_->cmds.push_back(stmt->expr);
|
if (last_rule_->cmd_lineno == 0)
|
last_rule_->cmd_lineno = stmt->loc().lineno;
|
LOG("Command: %s", Value::DebugString(stmt->expr).c_str());
|
}
|
|
void Evaluator::EvalIf(const IfStmt* stmt) {
|
loc_ = stmt->loc();
|
|
bool is_true;
|
switch (stmt->op) {
|
case CondOp::IFDEF:
|
case CondOp::IFNDEF: {
|
string var_name;
|
stmt->lhs->Eval(this, &var_name);
|
Symbol lhs = Intern(TrimRightSpace(var_name));
|
if (lhs.str().find_first_of(" \t") != string::npos)
|
Error("*** invalid syntax in conditional.");
|
Var* v = LookupVarInCurrentScope(lhs);
|
v->Used(this, lhs);
|
is_true = (v->String().empty() == (stmt->op == CondOp::IFNDEF));
|
break;
|
}
|
case CondOp::IFEQ:
|
case CondOp::IFNEQ: {
|
const string&& lhs = stmt->lhs->Eval(this);
|
const string&& rhs = stmt->rhs->Eval(this);
|
is_true = ((lhs == rhs) == (stmt->op == CondOp::IFEQ));
|
break;
|
}
|
default:
|
CHECK(false);
|
abort();
|
}
|
|
const vector<Stmt*>* stmts;
|
if (is_true) {
|
stmts = &stmt->true_stmts;
|
} else {
|
stmts = &stmt->false_stmts;
|
}
|
for (Stmt* a : *stmts) {
|
LOG("%s", a->DebugString().c_str());
|
a->Eval(this);
|
}
|
}
|
|
void Evaluator::DoInclude(const string& fname) {
|
CheckStack();
|
|
Makefile* mk = MakefileCacheManager::Get()->ReadMakefile(fname);
|
if (!mk->Exists()) {
|
Error(StringPrintf("%s does not exist", fname.c_str()));
|
}
|
|
Var* var_list = LookupVar(Intern("MAKEFILE_LIST"));
|
var_list->AppendVar(
|
this, Value::NewLiteral(Intern(TrimLeadingCurdir(fname)).str()));
|
for (Stmt* stmt : mk->stmts()) {
|
LOG("%s", stmt->DebugString().c_str());
|
stmt->Eval(this);
|
}
|
}
|
|
void Evaluator::EvalInclude(const IncludeStmt* stmt) {
|
loc_ = stmt->loc();
|
last_rule_ = NULL;
|
|
const string&& pats = stmt->expr->Eval(this);
|
for (StringPiece pat : WordScanner(pats)) {
|
ScopedTerminator st(pat);
|
vector<string>* files;
|
Glob(pat.data(), &files);
|
|
if (stmt->should_exist) {
|
if (files->empty()) {
|
// TODO: Kati does not support building a missing include file.
|
Error(StringPrintf("%s: %s", pat.data(), strerror(errno)));
|
}
|
}
|
|
for (const string& fname : *files) {
|
if (!stmt->should_exist && g_flags.ignore_optional_include_pattern &&
|
Pattern(g_flags.ignore_optional_include_pattern).Match(fname)) {
|
continue;
|
}
|
DoInclude(fname);
|
}
|
}
|
}
|
|
void Evaluator::EvalExport(const ExportStmt* stmt) {
|
loc_ = stmt->loc();
|
last_rule_ = NULL;
|
|
const string&& exports = stmt->expr->Eval(this);
|
for (StringPiece tok : WordScanner(exports)) {
|
size_t equal_index = tok.find('=');
|
StringPiece lhs;
|
if (equal_index == string::npos) {
|
lhs = tok;
|
} else if (equal_index == 0 ||
|
(equal_index == 1 &&
|
(tok[0] == ':' || tok[0] == '?' || tok[0] == '+'))) {
|
// Do not export tokens after an assignment.
|
break;
|
} else {
|
StringPiece rhs;
|
AssignOp op;
|
ParseAssignStatement(tok, equal_index, &lhs, &rhs, &op);
|
}
|
Symbol sym = Intern(lhs);
|
exports_[sym] = stmt->is_export;
|
|
if (export_message_) {
|
const char* prefix = "";
|
if (!stmt->is_export) {
|
prefix = "un";
|
}
|
|
if (export_error_) {
|
Error(StringPrintf("*** %s: %sexport is obsolete%s.", sym.c_str(),
|
prefix, export_message_->c_str()));
|
} else {
|
WARN_LOC(loc(), "%s: %sexport has been deprecated%s.", sym.c_str(),
|
prefix, export_message_->c_str());
|
}
|
}
|
}
|
}
|
|
Var* Evaluator::LookupVarGlobal(Symbol name) {
|
Var* v = name.GetGlobalVar();
|
if (v->IsDefined())
|
return v;
|
used_undefined_vars_.insert(name);
|
return v;
|
}
|
|
Var* Evaluator::LookupVar(Symbol name) {
|
if (current_scope_) {
|
Var* v = current_scope_->Lookup(name);
|
if (v->IsDefined())
|
return v;
|
}
|
return LookupVarGlobal(name);
|
}
|
|
Var* Evaluator::PeekVar(Symbol name) {
|
if (current_scope_) {
|
Var* v = current_scope_->Peek(name);
|
if (v->IsDefined())
|
return v;
|
}
|
return name.PeekGlobalVar();
|
}
|
|
Var* Evaluator::LookupVarInCurrentScope(Symbol name) {
|
if (current_scope_) {
|
return current_scope_->Lookup(name);
|
}
|
return LookupVarGlobal(name);
|
}
|
|
Var* Evaluator::PeekVarInCurrentScope(Symbol name) {
|
if (current_scope_) {
|
return current_scope_->Peek(name);
|
}
|
return name.PeekGlobalVar();
|
}
|
|
string Evaluator::EvalVar(Symbol name) {
|
return LookupVar(name)->Eval(this);
|
}
|
|
string Evaluator::GetShell() {
|
return EvalVar(kShellSym);
|
}
|
|
string Evaluator::GetShellFlag() {
|
// TODO: Handle $(.SHELLFLAGS)
|
return is_posix_ ? "-ec" : "-c";
|
}
|
|
string Evaluator::GetShellAndFlag() {
|
string shell = GetShell();
|
shell += ' ';
|
shell += GetShellFlag();
|
return shell;
|
}
|
|
void Evaluator::Error(const string& msg) {
|
ERROR_LOC(loc_, "%s", msg.c_str());
|
}
|
|
void Evaluator::DumpStackStats() const {
|
LOG_STAT("Max stack use: %zd bytes at %s:%d",
|
((char*)stack_addr_ - (char*)lowest_stack_) + stack_size_,
|
LOCF(lowest_loc_));
|
}
|
|
SymbolSet Evaluator::used_undefined_vars_;
|
