// 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 "rule.h"
|
|
#include "expr.h"
|
#include "log.h"
|
#include "parser.h"
|
#include "stringprintf.h"
|
#include "strutil.h"
|
#include "symtab.h"
|
|
Rule::Rule() : is_double_colon(false), is_suffix_rule(false), cmd_lineno(0) {}
|
|
void Rule::ParseInputs(const StringPiece& inputs_str) {
|
bool is_order_only = false;
|
for (auto const& input : WordScanner(inputs_str)) {
|
if (input == "|") {
|
is_order_only = true;
|
continue;
|
}
|
Symbol input_sym = Intern(TrimLeadingCurdir(input));
|
(is_order_only ? order_only_inputs : inputs).push_back(input_sym);
|
}
|
}
|
|
void Rule::ParsePrerequisites(const StringPiece& line,
|
size_t separator_pos,
|
const RuleStmt* rule_stmt) {
|
// line is either
|
// prerequisites [ ; command ]
|
// or
|
// target-prerequisites : prereq-patterns [ ; command ]
|
// First, separate command. At this point separator_pos should point to ';'
|
// unless null.
|
StringPiece prereq_string = line;
|
if (separator_pos != string::npos &&
|
rule_stmt->sep != RuleStmt::SEP_SEMICOLON) {
|
CHECK(line[separator_pos] == ';');
|
// TODO: Maybe better to avoid Intern here?
|
cmds.push_back(Value::NewLiteral(
|
Intern(TrimLeftSpace(line.substr(separator_pos + 1))).str()));
|
prereq_string = line.substr(0, separator_pos);
|
}
|
|
if ((separator_pos = prereq_string.find(':')) == string::npos) {
|
// Simple prerequisites
|
ParseInputs(prereq_string);
|
return;
|
}
|
|
// Static pattern rule.
|
if (!output_patterns.empty()) {
|
ERROR_LOC(loc, "*** mixed implicit and normal rules: deprecated syntax");
|
}
|
|
// Empty static patterns should not produce rules, but need to eat the
|
// commands So return a rule with no outputs nor output_patterns
|
if (outputs.empty()) {
|
return;
|
}
|
|
StringPiece target_prereq = prereq_string.substr(0, separator_pos);
|
StringPiece prereq_patterns = prereq_string.substr(separator_pos + 1);
|
|
for (StringPiece target_pattern : WordScanner(target_prereq)) {
|
target_pattern = TrimLeadingCurdir(target_pattern);
|
for (Symbol target : outputs) {
|
if (!Pattern(target_pattern).Match(target.str())) {
|
WARN_LOC(loc, "target `%s' doesn't match the target pattern",
|
target.c_str());
|
}
|
}
|
output_patterns.push_back(Intern(target_pattern));
|
}
|
|
if (output_patterns.empty()) {
|
ERROR_LOC(loc, "*** missing target pattern.");
|
}
|
if (output_patterns.size() > 1) {
|
ERROR_LOC(loc, "*** multiple target patterns.");
|
}
|
if (!IsPatternRule(output_patterns[0].str())) {
|
ERROR_LOC(loc, "*** target pattern contains no '%%'.");
|
}
|
ParseInputs(prereq_patterns);
|
}
|
|
string Rule::DebugString() const {
|
vector<string> v;
|
v.push_back(StringPrintf("outputs=[%s]", JoinSymbols(outputs, ",").c_str()));
|
v.push_back(StringPrintf("inputs=[%s]", JoinSymbols(inputs, ",").c_str()));
|
if (!order_only_inputs.empty()) {
|
v.push_back(StringPrintf("order_only_inputs=[%s]",
|
JoinSymbols(order_only_inputs, ",").c_str()));
|
}
|
if (!output_patterns.empty()) {
|
v.push_back(StringPrintf("output_patterns=[%s]",
|
JoinSymbols(output_patterns, ",").c_str()));
|
}
|
if (is_double_colon)
|
v.push_back("is_double_colon");
|
if (is_suffix_rule)
|
v.push_back("is_suffix_rule");
|
if (!cmds.empty()) {
|
v.push_back(StringPrintf("cmds=[%s]", JoinValues(cmds, ",").c_str()));
|
}
|
return JoinStrings(v, " ");
|
}
|
