Revert 214254 "Add initial prototype for the GN meta-buildsystem."

trunk/src/tools/gn/operators.cc

Index: trunk/src/tools/gn/operators.cc
===================================================================
--- trunk/src/tools/gn/operators.cc	(revision 214322)
+++ trunk/src/tools/gn/operators.cc	(working copy)
@@ -1,573 +0,0 @@
-// 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();
-}