gn: start of format command

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"
@@ skipping 29 matching lines @@
 
 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; }
+const BlockCommentNode* ParseNode::AsBlockComment() const { return NULL; }
 
 Comments* ParseNode::comments_mutable() {
   if (!comments_)
     comments_.reset(new Comments);
   return comments_.get();
 }
 
 void ParseNode::PrintComments(std::ostream& out, int indent) const {
   if (comments_) {
     std::string ind = IndentFor(indent + 1);
@@ skipping 390 matching lines @@
   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());
+  results.reserve(contents_.size());
 
   for (size_t i = 0; i < contents_.size(); i++) {
     const ParseNode* cur = contents_[i];
-    results[i] = cur->Execute(scope, err);
+    if (cur->AsBlockComment())
+      continue;
+    results.push_back(cur->Execute(scope, err));
     if (err->has_error())
       return Value();
-    if (results[i].type() == Value::NONE) {
+    if (results.back().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 {
@@ skipping 92 matching lines @@
 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";
   PrintComments(out, indent);
   operand_->Print(out, indent + 1);
 }
+
+// BlockCommentNode ------------------------------------------------------------
+
+BlockCommentNode::BlockCommentNode() {
+}
+
+BlockCommentNode::~BlockCommentNode() {
+}
+
+const BlockCommentNode* BlockCommentNode::AsBlockComment() const {
+  return this;
+}
+
+Value BlockCommentNode::Execute(Scope* scope, Err* err) const {
+  return Value();
+}
+
+LocationRange BlockCommentNode::GetRange() const {
+  return comment_.range();
+}
+
+Err BlockCommentNode::MakeErrorDescribing(const std::string& msg,
+                                     const std::string& help) const {

[brettw, 2014/09/25 22:11:32]

indenting

[scottmg, 2014/09/25 23:03:11]

Done.

+  return Err(comment_, msg, help);
+}
+
+void BlockCommentNode::Print(std::ostream& out, int indent) const {
+  out << IndentFor(indent) << "BLOCK_COMMENT(" << comment_.value() << ")\n";
+  PrintComments(out, indent);
+}