Add initial prototype for the GN meta-buildsystem.

tools/gn/parse_tree.cc

+// 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/parse_tree.h"
+
+#include <string>
+
+#include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/operators.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/string_utils.h"
+
+namespace {
+
+std::string IndentFor(int value) {
+  std::string ret;
+  for (int i = 0; i < value; i++)
+    ret.append(" ");
+  return ret;
+}
+
+}  // namespace
+
+ParseNode::ParseNode() {
+}
+
+ParseNode::~ParseNode() {
+}
+
+const AccessorNode* ParseNode::AsAccessor() const { return NULL; }
+const BinaryOpNode* ParseNode::AsBinaryOp() const { return NULL; }
+const BlockNode* ParseNode::AsBlock() const { return NULL; }
+const ConditionNode* ParseNode::AsConditionNode() const { return NULL; }
+const FunctionCallNode* ParseNode::AsFunctionCall() const { return NULL; }
+const IdentifierNode* ParseNode::AsIdentifier() const { return NULL; }
+const ListNode* ParseNode::AsList() const { return NULL; }
+const LiteralNode* ParseNode::AsLiteral() const { return NULL; }
+const UnaryOpNode* ParseNode::AsUnaryOp() const { return NULL; }
+
+// AccessorNode ---------------------------------------------------------------
+
+AccessorNode::AccessorNode() {
+}
+
+AccessorNode::~AccessorNode() {
+}
+
+const AccessorNode* AccessorNode::AsAccessor() const {
+  return this;
+}
+
+Value AccessorNode::Execute(Scope* scope, Err* err) const {
+  Value index_value = index_->Execute(scope, err);
+  if (err->has_error())
+    return Value();
+  if (!index_value.VerifyTypeIs(Value::INTEGER, err))
+    return Value();
+
+  const Value* base_value = scope->GetValue(base_.value(), true);
+  if (!base_value) {
+    *err = MakeErrorDescribing("Undefined identifier.");
+    return Value();
+  }
+  if (!base_value->VerifyTypeIs(Value::LIST, err))
+    return Value();
+
+  int64 index_int = index_value.int_value();
+  if (index_int < 0) {
+    *err = Err(index_->GetRange(), "Negative array subscript.",
+        "You gave me " + base::Int64ToString(index_int) + ".");
+    return Value();
+  }
+  size_t index_sizet = static_cast<size_t>(index_int);
+  if (index_sizet >= base_value->list_value().size()) {
+    *err = Err(index_->GetRange(), "Array subscript out of range.",
+        "You gave me " + base::Int64ToString(index_int) +
+        " but I was expecting something from 0 to " +
+        base::Int64ToString(
+            static_cast<int64>(base_value->list_value().size()) - 1) +
+        ", inclusive.");
+    return Value();
+  }
+
+  // Doing this assumes that there's no way in the language to do anything
+  // between the time the reference is created and the time that the reference
+  // is used. If there is, this will crash! Currently, this is just used for
+  // array accesses where this "shouldn't" happen.
+  return base_value->list_value()[index_sizet];
+}
+
+LocationRange AccessorNode::GetRange() const {
+  return LocationRange(base_.location(), index_->GetRange().end());
+}
+
+Err AccessorNode::MakeErrorDescribing(const std::string& msg,
+                                      const std::string& help) const {
+  return Err(GetRange(), msg, help);
+}
+
+void AccessorNode::Print(std::ostream& out, int indent) const {
+  out << IndentFor(indent) << "ACCESSOR\n";
+  out << IndentFor(indent + 1) << base_.value() << "\n";
+  index_->Print(out, indent + 1);
+}
+
+// BinaryOpNode ---------------------------------------------------------------
+
+BinaryOpNode::BinaryOpNode() {
+}
+
+BinaryOpNode::~BinaryOpNode() {
+}
+
+const BinaryOpNode* BinaryOpNode::AsBinaryOp() const {
+  return this;
+}
+
+Value BinaryOpNode::Execute(Scope* scope, Err* err) const {
+  return ExecuteBinaryOperator(scope, this, left_.get(), right_.get(), err);
+}
+
+LocationRange BinaryOpNode::GetRange() const {
+  return left_->GetRange().Union(right_->GetRange());
+}
+
+Err BinaryOpNode::MakeErrorDescribing(const std::string& msg,
+                                      const std::string& help) const {
+  return Err(op_, msg, help);
+}
+
+void BinaryOpNode::Print(std::ostream& out, int indent) const {
+  out << IndentFor(indent) << "BINARY(" << op_.value() << ")\n";
+  left_->Print(out, indent + 1);
+  right_->Print(out, indent + 1);
+}
+
+// BlockNode ------------------------------------------------------------------
+
+BlockNode::BlockNode(bool has_scope)
+    : has_scope_(has_scope),
+      begin_token_(NULL),
+      end_token_(NULL) {
+}
+
+BlockNode::~BlockNode() {
+  STLDeleteContainerPointers(statements_.begin(), statements_.end());
+}
+
+const BlockNode* BlockNode::AsBlock() const {
+  return this;
+}
+
+Value BlockNode::Execute(Scope* containing_scope, Err* err) const {
+  if (has_scope_) {
+    Scope our_scope(containing_scope);
+    Value ret = ExecuteBlockInScope(&our_scope, err);
+    if (err->has_error())
+      return Value();
+
+    // Check for unused vars in the scope.
+    //our_scope.CheckForUnusedVars(err);
+    return ret;
+  }
+  return ExecuteBlockInScope(containing_scope, err);
+}
+
+LocationRange BlockNode::GetRange() const {
+  if (begin_token_ && end_token_) {
+    return begin_token_->range().Union(end_token_->range());
+  }
+  return LocationRange();  // TODO(brettw) indicate the entire file somehow.
+}
+
+Err BlockNode::MakeErrorDescribing(const std::string& msg,
+                                   const std::string& help) const {
+  if (begin_token_)
+    return Err(*begin_token_, msg, help);
+  // TODO(brettw) this should have the beginning of the file in it or something.
+  return Err(Location(NULL, 1, 1), msg, help);
+}
+
+void BlockNode::Print(std::ostream& out, int indent) const {
+  out << IndentFor(indent) << "BLOCK\n";
+  for (size_t i = 0; i < statements_.size(); i++)
+    statements_[i]->Print(out, indent + 1);
+}
+
+Value BlockNode::ExecuteBlockInScope(Scope* our_scope, Err* err) const {
+  for (size_t i = 0; i < statements_.size() && !err->has_error(); i++) {
+    // Check for trying to execute things with no side effects in a block.
+    const ParseNode* cur = statements_[i];
+    if (cur->AsList() || cur->AsLiteral() || cur->AsUnaryOp() ||
+        cur->AsIdentifier()) {
+      *err = cur->MakeErrorDescribing(
+          "This statment has no effect.",
+          "Either delete it or do something with the result.");
+      return Value();
+    }
+    cur->Execute(our_scope, err);
+  }
+  return Value();
+}
+
+// ConditionNode --------------------------------------------------------------
+
+ConditionNode::ConditionNode() {
+}
+
+ConditionNode::~ConditionNode() {
+}
+
+const ConditionNode* ConditionNode::AsConditionNode() const {
+  return this;
+}
+
+Value ConditionNode::Execute(Scope* scope, Err* err) const {
+  Value condition_result = condition_->Execute(scope, err);
+  if (err->has_error())
+    return Value();
+  if (condition_result.type() == Value::NONE) {
+    *err = condition_->MakeErrorDescribing(
+        "This does not evaluate to a value.",
+        "Please give me something to work with for the if statement.");
+    err->AppendRange(if_token_.range());
+    return Value();
+  }
+
+  if (condition_result.InterpretAsInt()) {
+    if_true_->ExecuteBlockInScope(scope, err);
+  } else if (if_false_) {
+    // The else block is optional. It's either another condition (for an
+    // "else if" and we can just Execute it and the condition will handle
+    // the scoping) or it's a block indicating an "else" in which ase we
+    // need to be sure it inherits our scope.
+    const BlockNode* if_false_block = if_false_->AsBlock();
+    if (if_false_block)
+      if_false_block->ExecuteBlockInScope(scope, err);
+    else
+      if_false_->Execute(scope, err);
+  }
+
+  return Value();
+}
+
+LocationRange ConditionNode::GetRange() const {
+  if (if_false_)
+    return if_token_.range().Union(if_false_->GetRange());
+  return if_token_.range().Union(if_true_->GetRange());
+}
+
+Err ConditionNode::MakeErrorDescribing(const std::string& msg,
+                                       const std::string& help) const {
+  return Err(if_token_, msg, help);
+}
+
+void ConditionNode::Print(std::ostream& out, int indent) const {
+  out << IndentFor(indent) << "CONDITION\n";
+  condition_->Print(out, indent + 1);
+  if_true_->Print(out, indent + 1);
+  if (if_false_)
+    if_false_->Print(out, indent + 1);
+}
+
+// FunctionCallNode -----------------------------------------------------------
+
+FunctionCallNode::FunctionCallNode() {
+}
+
+FunctionCallNode::~FunctionCallNode() {
+}
+
+const FunctionCallNode* FunctionCallNode::AsFunctionCall() const {
+  return this;
+}
+
+Value FunctionCallNode::Execute(Scope* scope, Err* err) const {
+  Value args = args_->Execute(scope, err);
+  if (err->has_error())
+    return Value();
+  return ExecuteFunction(scope, this, args.list_value(), block_.get(), err);
+}
+
+LocationRange FunctionCallNode::GetRange() const {
+  if (block_)
+    return function_.range().Union(block_->GetRange());
+  return function_.range().Union(args_->GetRange());
+}
+
+Err FunctionCallNode::MakeErrorDescribing(const std::string& msg,
+                                          const std::string& help) const {
+  return Err(function_, msg, help);
+}
+
+void FunctionCallNode::Print(std::ostream& out, int indent) const {
+  out << IndentFor(indent) << "FUNCTION(" << function_.value() << ")\n";
+  args_->Print(out, indent + 1);
+  if (block_)
+    block_->Print(out, indent + 1);
+}
+
+// IdentifierNode --------------------------------------------------------------
+
+IdentifierNode::IdentifierNode() {
+}
+
+IdentifierNode::IdentifierNode(const Token& token) : value_(token) {
+}
+
+IdentifierNode::~IdentifierNode() {
+}
+
+const IdentifierNode* IdentifierNode::AsIdentifier() const {
+  return this;
+}
+
+Value IdentifierNode::Execute(Scope* scope, Err* err) const {
+  const Value* result = scope->GetValue(value_.value(), true);
+  if (!result) {
+    *err = MakeErrorDescribing("Undefined identifier");
+    return Value();
+  }
+  return *result;
+}
+
+LocationRange IdentifierNode::GetRange() const {
+  return value_.range();
+}
+
+Err IdentifierNode::MakeErrorDescribing(const std::string& msg,
+                                        const std::string& help) const {
+  return Err(value_, msg, help);
+}
+
+void IdentifierNode::Print(std::ostream& out, int indent) const {
+  out << IndentFor(indent) << "IDENTIFIER(" << value_.value() << ")\n";
+}
+
+// ListNode -------------------------------------------------------------------
+
+ListNode::ListNode() {
+}
+
+ListNode::~ListNode() {
+  STLDeleteContainerPointers(contents_.begin(), contents_.end());
+}
+
+const ListNode* ListNode::AsList() const {
+  return this;
+}
+
+Value ListNode::Execute(Scope* scope, Err* err) const {
+  Value result_value(this, Value::LIST);
+  std::vector<Value>& results = result_value.list_value();
+  results.resize(contents_.size());
+
+  for (size_t i = 0; i < contents_.size(); i++) {
+    const ParseNode* cur = contents_[i];
+    results[i] = cur->Execute(scope, err);
+    if (err->has_error())
+      return Value();
+    if (results[i].type() == Value::NONE) {
+      *err = cur->MakeErrorDescribing(
+          "This does not evaluate to a value.",
+          "I can't do something with nothing.");
+      return Value();
+    }
+  }
+  return result_value;
+}
+
+LocationRange ListNode::GetRange() const {
+  return LocationRange(begin_token_.location(), end_token_.location());
+}
+
+Err ListNode::MakeErrorDescribing(const std::string& msg,
+                                  const std::string& help) const {
+  return Err(begin_token_, msg, help);
+}
+
+void ListNode::Print(std::ostream& out, int indent) const {
+  out << IndentFor(indent) << "LIST\n";
+  for (size_t i = 0; i < contents_.size(); i++)
+    contents_[i]->Print(out, indent + 1);
+}
+
+// LiteralNode -----------------------------------------------------------------
+
+LiteralNode::LiteralNode() {
+}
+
+LiteralNode::LiteralNode(const Token& token) : value_(token) {
+}
+
+LiteralNode::~LiteralNode() {
+}
+
+const LiteralNode* LiteralNode::AsLiteral() const {
+  return this;
+}
+
+Value LiteralNode::Execute(Scope* scope, Err* err) const {
+  switch (value_.type()) {
+    case Token::INTEGER: {
+      int64 result_int;
+      if (!base::StringToInt64(value_.value(), &result_int)) {
+        *err = MakeErrorDescribing("This does not look like an integer");
+        return Value();
+      }
+      return Value(this, result_int);
+    }
+    case Token::STRING: {
+      // TODO(brettw) Unescaping probably needs to be moved & improved.
+      // The input value includes the quotes around the string, strip those
+      // off and unescape.
+      Value v(this, Value::STRING);
+      ExpandStringLiteral(scope, value_, &v, err);
+      return v;
+    }
+    default:
+      NOTREACHED();
+      return Value();
+  }
+}
+
+LocationRange LiteralNode::GetRange() const {
+  return value_.range();
+}
+
+Err LiteralNode::MakeErrorDescribing(const std::string& msg,
+                                     const std::string& help) const {
+  return Err(value_, msg, help);
+}
+
+void LiteralNode::Print(std::ostream& out, int indent) const {
+  out << IndentFor(indent) << "LITERAL(" << value_.value() << ")\n";
+}
+
+// UnaryOpNode ----------------------------------------------------------------
+
+UnaryOpNode::UnaryOpNode() {
+}
+
+UnaryOpNode::~UnaryOpNode() {
+}
+
+const UnaryOpNode* UnaryOpNode::AsUnaryOp() const {
+  return this;
+}
+
+Value UnaryOpNode::Execute(Scope* scope, Err* err) const {
+  Value operand_value = operand_->Execute(scope, err);
+  if (err->has_error())
+    return Value();
+  return ExecuteUnaryOperator(scope, this, operand_value, err);
+}
+
+LocationRange UnaryOpNode::GetRange() const {
+  return op_.range().Union(operand_->GetRange());
+}
+
+Err UnaryOpNode::MakeErrorDescribing(const std::string& msg,
+                                     const std::string& help) const {
+  return Err(op_, msg, help);
+}
+
+void UnaryOpNode::Print(std::ostream& out, int indent) const {
+  out << IndentFor(indent) << "UNARY(" << op_.value() << ")\n";
+  operand_->Print(out, indent + 1);
+}