574 lines
19 KiB
C++
574 lines
19 KiB
C++
// Copyright (c) 2013 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "tools/gn/operators.h"
|
|
|
|
#include "base/strings/string_number_conversions.h"
|
|
#include "tools/gn/err.h"
|
|
#include "tools/gn/parse_tree.h"
|
|
#include "tools/gn/scope.h"
|
|
#include "tools/gn/token.h"
|
|
#include "tools/gn/value.h"
|
|
|
|
namespace {
|
|
|
|
const char kSourcesName[] = "sources";
|
|
|
|
// Applies the sources assignment filter from the given scope to each element
|
|
// of source (can be a list or a string), appending it to dest if it doesn't
|
|
// match.
|
|
void AppendFilteredSourcesToValue(const Scope* scope,
|
|
const Value& source,
|
|
Value* dest) {
|
|
const PatternList* filter = scope->GetSourcesAssignmentFilter();
|
|
|
|
const std::vector<Value>& source_list = source.list_value();
|
|
|
|
if (source.type() == Value::STRING) {
|
|
if (!filter || filter->is_empty() ||
|
|
!filter->MatchesValue(source))
|
|
dest->list_value().push_back(source);
|
|
return;
|
|
}
|
|
|
|
// Otherwise source is a list.
|
|
DCHECK(source.type() == Value::LIST);
|
|
if (!filter || filter->is_empty()) {
|
|
// No filter, append everything.
|
|
for (size_t i = 0; i < source_list.size(); i++)
|
|
dest->list_value().push_back(source_list[i]);
|
|
return;
|
|
}
|
|
|
|
// Note: don't reserve() the dest vector here since that actually hurts
|
|
// the allocation pattern when the build script is doing multiple small
|
|
// additions.
|
|
for (size_t i = 0; i < source_list.size(); i++) {
|
|
if (!filter->MatchesValue(source_list[i]))
|
|
dest->list_value().push_back(source_list[i]);
|
|
}
|
|
}
|
|
|
|
void RemoveMatchesFromList(const BinaryOpNode* op_node,
|
|
Value* list,
|
|
const Value& to_remove,
|
|
Err* err) {
|
|
std::vector<Value>& v = list->list_value();
|
|
switch (to_remove.type()) {
|
|
case Value::INTEGER: // Filter out the individual int/string.
|
|
case Value::STRING: {
|
|
bool found_match = false;
|
|
for (size_t i = 0; i < v.size(); /* nothing */) {
|
|
if (v[i] == to_remove) {
|
|
found_match = true;
|
|
v.erase(v.begin() + i);
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
if (!found_match) {
|
|
*err = Err(to_remove.origin()->GetRange(), "Item not found",
|
|
"You were trying to remove \"" + to_remove.ToString() +
|
|
"\"\nfrom the list but it wasn't there.");
|
|
}
|
|
break;
|
|
}
|
|
|
|
case Value::LIST: // Filter out each individual thing.
|
|
for (size_t i = 0; i < to_remove.list_value().size(); i++) {
|
|
// TODO(brettw) if the nested item is a list, we may want to search
|
|
// for the literal list rather than remote the items in it.
|
|
RemoveMatchesFromList(op_node, list, to_remove.list_value()[i], err);
|
|
if (err->has_error())
|
|
return;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Assignment -----------------------------------------------------------------
|
|
|
|
Value ExecuteEquals(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Token& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
const Value* old_value = scope->GetValue(left.value(), false);
|
|
if (old_value) {
|
|
if (scope->IsSetButUnused(left.value())) {
|
|
// Throw an error for re-assigning without using the value first. The
|
|
// exception is that you can overwrite an empty list with another list
|
|
// since this is the way to get around the "can't overwrite a nonempty
|
|
// list with another nonempty list" restriction.
|
|
if (old_value->type() != Value::LIST ||
|
|
!old_value->list_value().empty()) {
|
|
*err = Err(op_node->left()->GetRange(), "Overwriting unused variable.",
|
|
"This overwrites a previous assignment to \"" +
|
|
left.value().as_string() + "\" that had no effect.");
|
|
err->AppendSubErr(Err(*scope->GetValue(left.value()),
|
|
"Previously set here.",
|
|
"Maybe you wanted \"+=\" to append instead?"));
|
|
return Value();
|
|
}
|
|
} else {
|
|
// Throw an error when overwriting a nonempty list with another nonempty
|
|
// list item. This is to detect the case where you write
|
|
// defines = ["FOO"]
|
|
// and you overwrote inherited ones, when instead you mean to append:
|
|
// defines += ["FOO"]
|
|
if (old_value->type() == Value::LIST &&
|
|
!old_value->list_value().empty() &&
|
|
right.type() == Value::LIST &&
|
|
!right.list_value().empty()) {
|
|
*err = Err(op_node->left()->GetRange(), "Replacing nonempty list.",
|
|
std::string("This overwrites a previously-defined nonempty list ") +
|
|
"(length " + base::IntToString(old_value->list_value().size()) +
|
|
").");
|
|
err->AppendSubErr(Err(*old_value, "for previous definition",
|
|
"with another one (length " +
|
|
base::IntToString(right.list_value().size()) + "). Did you mean " +
|
|
"\"+=\" to append instead? If you\nreally want to do this, do\n " +
|
|
left.value().as_string() + " = []\nbefore reassigning."));
|
|
return Value();
|
|
}
|
|
}
|
|
}
|
|
if (err->has_error())
|
|
return Value();
|
|
|
|
if (right.type() == Value::LIST && left.value() == kSourcesName) {
|
|
// Assigning to sources, filter the list. Here we do the filtering and
|
|
// copying in one step to save an extra list copy (the lists may be
|
|
// long).
|
|
Value* set_value = scope->SetValue(left.value(),
|
|
Value(op_node, Value::LIST), op_node);
|
|
set_value->list_value().reserve(right.list_value().size());
|
|
AppendFilteredSourcesToValue(scope, right, set_value);
|
|
} else {
|
|
// Normal value set, just copy it.
|
|
scope->SetValue(left.value(), right, op_node->right());
|
|
}
|
|
return Value();
|
|
}
|
|
|
|
// allow_type_conversion indicates if we're allowed to change the type of the
|
|
// left value. This is set to true when doing +, and false when doing +=.
|
|
void ValuePlusEquals(const Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Token& left_token,
|
|
Value* left,
|
|
const Value& right,
|
|
bool allow_type_conversion,
|
|
Err* err) {
|
|
switch (left->type()) {
|
|
// Left-hand-side int.
|
|
case Value::INTEGER:
|
|
switch (right.type()) {
|
|
case Value::INTEGER: // int + int -> addition.
|
|
left->int_value() += right.int_value();
|
|
return;
|
|
|
|
case Value::STRING: // int + string -> string concat.
|
|
if (allow_type_conversion) {
|
|
*left = Value(op_node,
|
|
base::Int64ToString(left->int_value()) + right.string_value());
|
|
return;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
// Left-hand-side string.
|
|
case Value::STRING:
|
|
switch (right.type()) {
|
|
case Value::INTEGER: // string + int -> string concat.
|
|
left->string_value().append(base::Int64ToString(right.int_value()));
|
|
return;
|
|
|
|
case Value::STRING: // string + string -> string contat.
|
|
left->string_value().append(right.string_value());
|
|
return;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
// Left-hand-side list.
|
|
case Value::LIST:
|
|
switch (right.type()) {
|
|
case Value::INTEGER: // list + integer -> list append.
|
|
case Value::STRING: // list + string -> list append.
|
|
if (left_token.value() == kSourcesName)
|
|
AppendFilteredSourcesToValue(scope, right, left);
|
|
else
|
|
left->list_value().push_back(right);
|
|
return;
|
|
|
|
case Value::LIST: // list + list -> list concat.
|
|
if (left_token.value() == kSourcesName) {
|
|
// Filter additions through the assignment filter.
|
|
AppendFilteredSourcesToValue(scope, right, left);
|
|
} else {
|
|
// Normal list concat.
|
|
for (size_t i = 0; i < right.list_value().size(); i++)
|
|
left->list_value().push_back(right.list_value()[i]);
|
|
}
|
|
return;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
*err = Err(op_node->op(), "Incompatible types to add.",
|
|
std::string("I see a ") + Value::DescribeType(left->type()) + " and a " +
|
|
Value::DescribeType(right.type()) + ".");
|
|
}
|
|
|
|
Value ExecutePlusEquals(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Token& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
// We modify in-place rather than doing read-modify-write to avoid
|
|
// copying large lists.
|
|
Value* left_value =
|
|
scope->GetValueForcedToCurrentScope(left.value(), op_node);
|
|
if (!left_value) {
|
|
*err = Err(left, "Undefined variable for +=.",
|
|
"I don't have something with this name in scope now.");
|
|
return Value();
|
|
}
|
|
ValuePlusEquals(scope, op_node, left, left_value, right, false, err);
|
|
left_value->set_origin(op_node);
|
|
scope->MarkUnused(left.value());
|
|
return Value();
|
|
}
|
|
|
|
void ValueMinusEquals(const BinaryOpNode* op_node,
|
|
Value* left,
|
|
const Value& right,
|
|
bool allow_type_conversion,
|
|
Err* err) {
|
|
switch (left->type()) {
|
|
// Left-hand-side int.
|
|
case Value::INTEGER:
|
|
switch (right.type()) {
|
|
case Value::INTEGER: // int - int -> subtraction.
|
|
left->int_value() -= right.int_value();
|
|
return;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
// Left-hand-side string.
|
|
case Value::STRING:
|
|
break; // All are errors.
|
|
|
|
// Left-hand-side list.
|
|
case Value::LIST:
|
|
RemoveMatchesFromList(op_node, left, right, err);
|
|
return;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
*err = Err(op_node->op(), "Incompatible types to add.",
|
|
std::string("I see a ") + Value::DescribeType(left->type()) + " and a " +
|
|
Value::DescribeType(right.type()) + ".");
|
|
}
|
|
|
|
Value ExecuteMinusEquals(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Token& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
Value* left_value =
|
|
scope->GetValueForcedToCurrentScope(left.value(), op_node);
|
|
if (!left_value) {
|
|
*err = Err(left, "Undefined variable for -=.",
|
|
"I don't have something with this name in scope now.");
|
|
return Value();
|
|
}
|
|
ValueMinusEquals(op_node, left_value, right, false, err);
|
|
left_value->set_origin(op_node);
|
|
scope->MarkUnused(left.value());
|
|
return Value();
|
|
}
|
|
|
|
// Plus/Minus -----------------------------------------------------------------
|
|
|
|
Value ExecutePlus(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
Value ret = left;
|
|
ValuePlusEquals(scope, op_node, Token(), &ret, right, true, err);
|
|
ret.set_origin(op_node);
|
|
return ret;
|
|
}
|
|
|
|
Value ExecuteMinus(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
Value ret = left;
|
|
ValueMinusEquals(op_node, &ret, right, true, err);
|
|
ret.set_origin(op_node);
|
|
return ret;
|
|
}
|
|
|
|
// Comparison -----------------------------------------------------------------
|
|
|
|
Value ExecuteEqualsEquals(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
if (left == right)
|
|
return Value(op_node, 1);
|
|
return Value(op_node, 0);
|
|
}
|
|
|
|
Value ExecuteNotEquals(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
// Evaluate in terms of ==.
|
|
Value result = ExecuteEqualsEquals(scope, op_node, left, right, err);
|
|
result.int_value() = static_cast<int64>(!result.int_value());
|
|
return result;
|
|
}
|
|
|
|
Value FillNeedsToIntegersError(const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
*err = Err(op_node, "Comparison requires two integers.",
|
|
"This operator can only compare two integers.");
|
|
err->AppendRange(left.origin()->GetRange());
|
|
err->AppendRange(right.origin()->GetRange());
|
|
return Value();
|
|
}
|
|
|
|
Value ExecuteLessEquals(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
if (left.type() != Value::INTEGER || right.type() != Value::INTEGER)
|
|
return FillNeedsToIntegersError(op_node, left, right, err);
|
|
return Value(op_node, left.int_value() <= right.int_value());
|
|
}
|
|
|
|
Value ExecuteGreaterEquals(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
if (left.type() != Value::INTEGER || right.type() != Value::INTEGER)
|
|
return FillNeedsToIntegersError(op_node, left, right, err);
|
|
return Value(op_node, left.int_value() >= right.int_value());
|
|
}
|
|
|
|
Value ExecuteGreater(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
if (left.type() != Value::INTEGER || right.type() != Value::INTEGER)
|
|
return FillNeedsToIntegersError(op_node, left, right, err);
|
|
return Value(op_node, left.int_value() > right.int_value());
|
|
}
|
|
|
|
Value ExecuteLess(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
if (left.type() != Value::INTEGER || right.type() != Value::INTEGER)
|
|
return FillNeedsToIntegersError(op_node, left, right, err);
|
|
return Value(op_node, left.int_value() < right.int_value());
|
|
}
|
|
|
|
// Binary ----------------------------------------------------------------------
|
|
|
|
Value ExecuteOr(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
return Value(op_node,
|
|
static_cast<int64>(left.InterpretAsInt() || right.InterpretAsInt()));
|
|
}
|
|
|
|
Value ExecuteAnd(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const Value& left,
|
|
const Value& right,
|
|
Err* err) {
|
|
return Value(op_node,
|
|
static_cast<int64>(left.InterpretAsInt() && right.InterpretAsInt()));
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool IsUnaryOperator(const Token& token) {
|
|
if (token.type() != Token::OPERATOR)
|
|
return false;
|
|
return token.value() == "!";
|
|
}
|
|
|
|
bool IsBinaryOperator(const Token& token) {
|
|
if (token.type() != Token::OPERATOR)
|
|
return false;
|
|
return token.value() == "=" ||
|
|
token.value() == "+=" ||
|
|
token.value() == "-=" ||
|
|
token.value() == "+" ||
|
|
token.value() == "-" ||
|
|
token.value() == "==" ||
|
|
token.value() == "!=" ||
|
|
token.value() == "<=" ||
|
|
token.value() == ">=" ||
|
|
token.value() == "<" ||
|
|
token.value() == ">" ||
|
|
token.value() == "&&" ||
|
|
token.value() == "||";
|
|
}
|
|
|
|
bool IsFunctionCallArgBeginScoper(const Token& token) {
|
|
return token.IsScoperEqualTo("(");
|
|
}
|
|
|
|
bool IsFunctionCallArgEndScoper(const Token& token) {
|
|
return token.IsScoperEqualTo(")");
|
|
}
|
|
|
|
bool IsScopeBeginScoper(const Token& token) {
|
|
return token.IsScoperEqualTo("{");
|
|
}
|
|
|
|
bool IsScopeEndScoper(const Token& token) {
|
|
return token.IsScoperEqualTo("}");
|
|
}
|
|
|
|
Value ExecuteUnaryOperator(Scope* scope,
|
|
const UnaryOpNode* op_node,
|
|
const Value& expr,
|
|
Err* err) {
|
|
DCHECK(op_node->op().IsOperatorEqualTo("!"));
|
|
return Value(op_node, !expr.InterpretAsInt());
|
|
}
|
|
|
|
Value ExecuteBinaryOperator(Scope* scope,
|
|
const BinaryOpNode* op_node,
|
|
const ParseNode* left,
|
|
const ParseNode* right,
|
|
Err* err) {
|
|
const Token& op = op_node->op();
|
|
|
|
// First handle the ones that take an lvalue.
|
|
if (op.IsOperatorEqualTo("=") ||
|
|
op.IsOperatorEqualTo("+=") ||
|
|
op.IsOperatorEqualTo("-=")) {
|
|
const IdentifierNode* left_id = left->AsIdentifier();
|
|
if (!left_id) {
|
|
*err = Err(op, "Operator requires an lvalue.",
|
|
"This thing on the left is not an idenfitier.");
|
|
err->AppendRange(left->GetRange());
|
|
return Value();
|
|
}
|
|
const Token& dest = left_id->value();
|
|
|
|
Value right_value = right->Execute(scope, err);
|
|
if (err->has_error())
|
|
return Value();
|
|
if (right_value.type() == Value::NONE) {
|
|
*err = Err(op, "Operator requires an rvalue.",
|
|
"This thing on the right does not evaluate to a value.");
|
|
err->AppendRange(right->GetRange());
|
|
return Value();
|
|
}
|
|
|
|
if (op.IsOperatorEqualTo("="))
|
|
return ExecuteEquals(scope, op_node, dest, right_value, err);
|
|
if (op.IsOperatorEqualTo("+="))
|
|
return ExecutePlusEquals(scope, op_node, dest, right_value, err);
|
|
if (op.IsOperatorEqualTo("-="))
|
|
return ExecuteMinusEquals(scope, op_node, dest, right_value, err);
|
|
NOTREACHED();
|
|
return Value();
|
|
}
|
|
|
|
// Left value.
|
|
Value left_value = left->Execute(scope, err);
|
|
if (err->has_error())
|
|
return Value();
|
|
if (left_value.type() == Value::NONE) {
|
|
*err = Err(op, "Operator requires an value.",
|
|
"This thing on the left does not evaluate to a value.");
|
|
err->AppendRange(left->GetRange());
|
|
return Value();
|
|
}
|
|
|
|
// Right value. Note: don't move this above to share code with the lvalue
|
|
// version since in this case we want to execute the left side first.
|
|
Value right_value = right->Execute(scope, err);
|
|
if (err->has_error())
|
|
return Value();
|
|
if (right_value.type() == Value::NONE) {
|
|
*err = Err(op, "Operator requires an value.",
|
|
"This thing on the right does not evaluate to a value.");
|
|
err->AppendRange(right->GetRange());
|
|
return Value();
|
|
}
|
|
|
|
// +, -.
|
|
if (op.IsOperatorEqualTo("-"))
|
|
return ExecuteMinus(scope, op_node, left_value, right_value, err);
|
|
if (op.IsOperatorEqualTo("+"))
|
|
return ExecutePlus(scope, op_node, left_value, right_value, err);
|
|
|
|
// Comparisons.
|
|
if (op.IsOperatorEqualTo("=="))
|
|
return ExecuteEqualsEquals(scope, op_node, left_value, right_value, err);
|
|
if (op.IsOperatorEqualTo("!="))
|
|
return ExecuteNotEquals(scope, op_node, left_value, right_value, err);
|
|
if (op.IsOperatorEqualTo(">="))
|
|
return ExecuteGreaterEquals(scope, op_node, left_value, right_value, err);
|
|
if (op.IsOperatorEqualTo("<="))
|
|
return ExecuteLessEquals(scope, op_node, left_value, right_value, err);
|
|
if (op.IsOperatorEqualTo(">"))
|
|
return ExecuteGreater(scope, op_node, left_value, right_value, err);
|
|
if (op.IsOperatorEqualTo("<"))
|
|
return ExecuteLess(scope, op_node, left_value, right_value, err);
|
|
|
|
// ||, &&.
|
|
if (op.IsOperatorEqualTo("||"))
|
|
return ExecuteOr(scope, op_node, left_value, right_value, err);
|
|
if (op.IsOperatorEqualTo("&&"))
|
|
return ExecuteAnd(scope, op_node, left_value, right_value, err);
|
|
|
|
return Value();
|
|
}
|