tools/gn/parse_tree.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "tools/gn/parse_tree.h"
   6
   7 #include <string>
   8
   9 #include "base/stl_util.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "tools/gn/functions.h"
  12 #include "tools/gn/operators.h"
  13 #include "tools/gn/scope.h"
  14 #include "tools/gn/string_utils.h"
  15
  16 namespace {
  17
  18 std::string IndentFor(int value) {
  19   return std::string(value, ' ');
  20 }
  21
  22 bool IsSortRangeSeparator(const ParseNode* node, const ParseNode* prev) {
  23   // If it's a block comment, or has an attached comment with a blank line
  24   // before it, then we break the range at this point.
  25   return node->AsBlockComment() != nullptr ||
  26          (prev && node->comments() && !node->comments()->before().empty() &&
  27           (node->GetRange().begin().line_number() >
  28            prev->GetRange().end().line_number() +
  29                static_cast<int>(node->comments()->before().size() + 1)));
  30 }
  31
  32 base::StringPiece GetStringRepresentation(const ParseNode* node) {
  33   DCHECK(node->AsLiteral() || node->AsIdentifier() || node->AsAccessor());
  34   if (node->AsLiteral())
  35     return node->AsLiteral()->value().value();
  36   else if (node->AsIdentifier())
  37     return node->AsIdentifier()->value().value();
  38   else if (node->AsAccessor())
  39     return node->AsAccessor()->base().value();
  40   return base::StringPiece();
  41 }
  42
  43 }  // namespace
  44
  45 Comments::Comments() {
  46 }
  47
  48 Comments::~Comments() {
  49 }
  50
  51 void Comments::ReverseSuffix() {
  52   for (int i = 0, j = static_cast<int>(suffix_.size() - 1); i < j; ++i, --j)
  53     std::swap(suffix_[i], suffix_[j]);
  54 }
  55
  56 ParseNode::ParseNode() {
  57 }
  58
  59 ParseNode::~ParseNode() {
  60 }
  61
  62 const AccessorNode* ParseNode::AsAccessor() const { return nullptr; }
  63 const BinaryOpNode* ParseNode::AsBinaryOp() const { return nullptr; }
  64 const BlockCommentNode* ParseNode::AsBlockComment() const { return nullptr; }
  65 const BlockNode* ParseNode::AsBlock() const { return nullptr; }
  66 const ConditionNode* ParseNode::AsConditionNode() const { return nullptr; }
  67 const EndNode* ParseNode::AsEnd() const { return nullptr; }
  68 const FunctionCallNode* ParseNode::AsFunctionCall() const { return nullptr; }
  69 const IdentifierNode* ParseNode::AsIdentifier() const { return nullptr; }
  70 const ListNode* ParseNode::AsList() const { return nullptr; }
  71 const LiteralNode* ParseNode::AsLiteral() const { return nullptr; }
  72 const UnaryOpNode* ParseNode::AsUnaryOp() const { return nullptr; }
  73
  74 Comments* ParseNode::comments_mutable() {
  75   if (!comments_)
  76     comments_.reset(new Comments);
  77   return comments_.get();
  78 }
  79
  80 void ParseNode::PrintComments(std::ostream& out, int indent) const {
  81   if (comments_) {
  82     std::string ind = IndentFor(indent + 1);
  83     for (const auto& token : comments_->before())
  84       out << ind << "+BEFORE_COMMENT(\"" << token.value() << "\")\n";
  85     for (const auto& token : comments_->suffix())
  86       out << ind << "+SUFFIX_COMMENT(\"" << token.value() << "\")\n";
  87     for (const auto& token : comments_->after())
  88       out << ind << "+AFTER_COMMENT(\"" << token.value() << "\")\n";
  89   }
  90 }
  91
  92 // AccessorNode ---------------------------------------------------------------
  93
  94 AccessorNode::AccessorNode() {
  95 }
  96
  97 AccessorNode::~AccessorNode() {
  98 }
  99
 100 const AccessorNode* AccessorNode::AsAccessor() const {
 101   return this;
 102 }
 103
 104 Value AccessorNode::Execute(Scope* scope, Err* err) const {
 105   if (index_)
 106     return ExecuteArrayAccess(scope, err);
 107   else if (member_)
 108     return ExecuteScopeAccess(scope, err);
 109   NOTREACHED();
 110   return Value();
 111 }
 112
 113 LocationRange AccessorNode::GetRange() const {
 114   if (index_)
 115     return LocationRange(base_.location(), index_->GetRange().end());
 116   else if (member_)
 117     return LocationRange(base_.location(), member_->GetRange().end());
 118   NOTREACHED();
 119   return LocationRange();
 120 }
 121
 122 Err AccessorNode::MakeErrorDescribing(const std::string& msg,
 123                                       const std::string& help) const {
 124   return Err(GetRange(), msg, help);
 125 }
 126
 127 void AccessorNode::Print(std::ostream& out, int indent) const {
 128   out << IndentFor(indent) << "ACCESSOR\n";
 129   PrintComments(out, indent);
 130   out << IndentFor(indent + 1) << base_.value() << "\n";
 131   if (index_)
 132     index_->Print(out, indent + 1);
 133   else if (member_)
 134     member_->Print(out, indent + 1);
 135 }
 136
 137 Value AccessorNode::ExecuteArrayAccess(Scope* scope, Err* err) const {
 138   Value index_value = index_->Execute(scope, err);
 139   if (err->has_error())
 140     return Value();
 141   if (!index_value.VerifyTypeIs(Value::INTEGER, err))
 142     return Value();
 143
 144   const Value* base_value = scope->GetValue(base_.value(), true);
 145   if (!base_value) {
 146     *err = MakeErrorDescribing("Undefined identifier.");
 147     return Value();
 148   }
 149   if (!base_value->VerifyTypeIs(Value::LIST, err))
 150     return Value();
 151
 152   int64 index_int = index_value.int_value();
 153   if (index_int < 0) {
 154     *err = Err(index_->GetRange(), "Negative array subscript.",
 155         "You gave me " + base::Int64ToString(index_int) + ".");
 156     return Value();
 157   }
 158   size_t index_sizet = static_cast<size_t>(index_int);
 159   if (index_sizet >= base_value->list_value().size()) {
 160     *err = Err(index_->GetRange(), "Array subscript out of range.",
 161         "You gave me " + base::Int64ToString(index_int) +
 162         " but I was expecting something from 0 to " +
 163         base::Int64ToString(
 164             static_cast<int64>(base_value->list_value().size()) - 1) +
 165         ", inclusive.");
 166     return Value();
 167   }
 168
 169   // Doing this assumes that there's no way in the language to do anything
 170   // between the time the reference is created and the time that the reference
 171   // is used. If there is, this will crash! Currently, this is just used for
 172   // array accesses where this "shouldn't" happen.
 173   return base_value->list_value()[index_sizet];
 174 }
 175
 176 Value AccessorNode::ExecuteScopeAccess(Scope* scope, Err* err) const {
 177   // We jump through some hoops here since ideally a.b will count "b" as
 178   // accessed in the given scope. The value "a" might be in some normal nested
 179   // scope and we can modify it, but it might also be inherited from the
 180   // readonly root scope and we can't do used variable tracking on it. (It's
 181   // not legal to const cast it away since the root scope will be in readonly
 182   // mode and being accessed from multiple threads without locking.) So this
 183   // code handles both cases.
 184   const Value* result = nullptr;
 185
 186   // Look up the value in the scope named by "base_".
 187   Value* mutable_base_value = scope->GetMutableValue(base_.value(), true);
 188   if (mutable_base_value) {
 189     // Common case: base value is mutable so we can track variable accesses
 190     // for unused value warnings.
 191     if (!mutable_base_value->VerifyTypeIs(Value::SCOPE, err))
 192       return Value();
 193     result = mutable_base_value->scope_value()->GetValue(
 194         member_->value().value(), true);
 195   } else {
 196     // Fall back to see if the value is on a read-only scope.
 197     const Value* const_base_value = scope->GetValue(base_.value(), true);
 198     if (const_base_value) {
 199       // Read only value, don't try to mark the value access as a "used" one.
 200       if (!const_base_value->VerifyTypeIs(Value::SCOPE, err))
 201         return Value();
 202       result =
 203           const_base_value->scope_value()->GetValue(member_->value().value());
 204     } else {
 205       *err = Err(base_, "Undefined identifier.");
 206       return Value();
 207     }
 208   }
 209
 210   if (!result) {
 211     *err = Err(member_.get(), "No value named \"" +
 212         member_->value().value() + "\" in scope \"" + base_.value() + "\"");
 213     return Value();
 214   }
 215   return *result;
 216 }
 217
 218 void AccessorNode::SetNewLocation(int line_number) {
 219   Location old = base_.location();
 220   base_.set_location(
 221       Location(old.file(), line_number, old.char_offset(), old.byte()));
 222 }
 223
 224 // BinaryOpNode ---------------------------------------------------------------
 225
 226 BinaryOpNode::BinaryOpNode() {
 227 }
 228
 229 BinaryOpNode::~BinaryOpNode() {
 230 }
 231
 232 const BinaryOpNode* BinaryOpNode::AsBinaryOp() const {
 233   return this;
 234 }
 235
 236 Value BinaryOpNode::Execute(Scope* scope, Err* err) const {
 237   return ExecuteBinaryOperator(scope, this, left_.get(), right_.get(), err);
 238 }
 239
 240 LocationRange BinaryOpNode::GetRange() const {
 241   return left_->GetRange().Union(right_->GetRange());
 242 }
 243
 244 Err BinaryOpNode::MakeErrorDescribing(const std::string& msg,
 245                                       const std::string& help) const {
 246   return Err(op_, msg, help);
 247 }
 248
 249 void BinaryOpNode::Print(std::ostream& out, int indent) const {
 250   out << IndentFor(indent) << "BINARY(" << op_.value() << ")\n";
 251   PrintComments(out, indent);
 252   left_->Print(out, indent + 1);
 253   right_->Print(out, indent + 1);
 254 }
 255
 256 // BlockNode ------------------------------------------------------------------
 257
 258 BlockNode::BlockNode() {
 259 }
 260
 261 BlockNode::~BlockNode() {
 262   STLDeleteContainerPointers(statements_.begin(), statements_.end());
 263 }
 264
 265 const BlockNode* BlockNode::AsBlock() const {
 266   return this;
 267 }
 268
 269 Value BlockNode::Execute(Scope* scope, Err* err) const {
 270   for (size_t i = 0; i < statements_.size() && !err->has_error(); i++) {
 271     // Check for trying to execute things with no side effects in a block.
 272     const ParseNode* cur = statements_[i];
 273     if (cur->AsList() || cur->AsLiteral() || cur->AsUnaryOp() ||
 274         cur->AsIdentifier()) {
 275       *err = cur->MakeErrorDescribing(
 276           "This statement has no effect.",
 277           "Either delete it or do something with the result.");
 278       return Value();
 279     }
 280     cur->Execute(scope, err);
 281   }
 282   return Value();
 283 }
 284
 285 LocationRange BlockNode::GetRange() const {
 286   if (begin_token_.type() != Token::INVALID &&
 287       end_->value().type() != Token::INVALID) {
 288     return begin_token_.range().Union(end_->value().range());
 289   } else if (!statements_.empty()) {
 290     return statements_[0]->GetRange().Union(
 291         statements_[statements_.size() - 1]->GetRange());
 292   }
 293   return LocationRange();
 294 }
 295
 296 Err BlockNode::MakeErrorDescribing(const std::string& msg,
 297                                    const std::string& help) const {
 298   return Err(GetRange(), msg, help);
 299 }
 300
 301 void BlockNode::Print(std::ostream& out, int indent) const {
 302   out << IndentFor(indent) << "BLOCK\n";
 303   PrintComments(out, indent);
 304   for (const auto& statement : statements_)
 305     statement->Print(out, indent + 1);
 306   if (end_ && end_->comments())
 307     end_->Print(out, indent + 1);
 308 }
 309
 310 // ConditionNode --------------------------------------------------------------
 311
 312 ConditionNode::ConditionNode() {
 313 }
 314
 315 ConditionNode::~ConditionNode() {
 316 }
 317
 318 const ConditionNode* ConditionNode::AsConditionNode() const {
 319   return this;
 320 }
 321
 322 Value ConditionNode::Execute(Scope* scope, Err* err) const {
 323   Value condition_result = condition_->Execute(scope, err);
 324   if (err->has_error())
 325     return Value();
 326   if (condition_result.type() != Value::BOOLEAN) {
 327     *err = condition_->MakeErrorDescribing(
 328         "Condition does not evaluate to a boolean value.",
 329         std::string("This is a value of type \"") +
 330             Value::DescribeType(condition_result.type()) +
 331             "\" instead.");
 332     err->AppendRange(if_token_.range());
 333     return Value();
 334   }
 335
 336   if (condition_result.boolean_value()) {
 337     if_true_->Execute(scope, err);
 338   } else if (if_false_) {
 339     // The else block is optional.
 340     if_false_->Execute(scope, err);
 341   }
 342
 343   return Value();
 344 }
 345
 346 LocationRange ConditionNode::GetRange() const {
 347   if (if_false_)
 348     return if_token_.range().Union(if_false_->GetRange());
 349   return if_token_.range().Union(if_true_->GetRange());
 350 }
 351
 352 Err ConditionNode::MakeErrorDescribing(const std::string& msg,
 353                                        const std::string& help) const {
 354   return Err(if_token_, msg, help);
 355 }
 356
 357 void ConditionNode::Print(std::ostream& out, int indent) const {
 358   out << IndentFor(indent) << "CONDITION\n";
 359   PrintComments(out, indent);
 360   condition_->Print(out, indent + 1);
 361   if_true_->Print(out, indent + 1);
 362   if (if_false_)
 363     if_false_->Print(out, indent + 1);
 364 }
 365
 366 // FunctionCallNode -----------------------------------------------------------
 367
 368 FunctionCallNode::FunctionCallNode() {
 369 }
 370
 371 FunctionCallNode::~FunctionCallNode() {
 372 }
 373
 374 const FunctionCallNode* FunctionCallNode::AsFunctionCall() const {
 375   return this;
 376 }
 377
 378 Value FunctionCallNode::Execute(Scope* scope, Err* err) const {
 379   return functions::RunFunction(scope, this, args_.get(), block_.get(), err);
 380 }
 381
 382 LocationRange FunctionCallNode::GetRange() const {
 383   if (function_.type() == Token::INVALID)
 384     return LocationRange();  // This will be null in some tests.
 385   if (block_)
 386     return function_.range().Union(block_->GetRange());
 387   return function_.range().Union(args_->GetRange());
 388 }
 389
 390 Err FunctionCallNode::MakeErrorDescribing(const std::string& msg,
 391                                           const std::string& help) const {
 392   return Err(function_, msg, help);
 393 }
 394
 395 void FunctionCallNode::Print(std::ostream& out, int indent) const {
 396   out << IndentFor(indent) << "FUNCTION(" << function_.value() << ")\n";
 397   PrintComments(out, indent);
 398   args_->Print(out, indent + 1);
 399   if (block_)
 400     block_->Print(out, indent + 1);
 401 }
 402
 403 // IdentifierNode --------------------------------------------------------------
 404
 405 IdentifierNode::IdentifierNode() {
 406 }
 407
 408 IdentifierNode::IdentifierNode(const Token& token) : value_(token) {
 409 }
 410
 411 IdentifierNode::~IdentifierNode() {
 412 }
 413
 414 const IdentifierNode* IdentifierNode::AsIdentifier() const {
 415   return this;
 416 }
 417
 418 Value IdentifierNode::Execute(Scope* scope, Err* err) const {
 419   const Value* value = scope->GetValue(value_.value(), true);
 420   Value result;
 421   if (!value) {
 422     *err = MakeErrorDescribing("Undefined identifier");
 423     return result;
 424   }
 425
 426   result = *value;
 427   result.set_origin(this);
 428   return result;
 429 }
 430
 431 LocationRange IdentifierNode::GetRange() const {
 432   return value_.range();
 433 }
 434
 435 Err IdentifierNode::MakeErrorDescribing(const std::string& msg,
 436                                         const std::string& help) const {
 437   return Err(value_, msg, help);
 438 }
 439
 440 void IdentifierNode::Print(std::ostream& out, int indent) const {
 441   out << IndentFor(indent) << "IDENTIFIER(" << value_.value() << ")\n";
 442   PrintComments(out, indent);
 443 }
 444
 445 void IdentifierNode::SetNewLocation(int line_number) {
 446   Location old = value_.location();
 447   value_.set_location(
 448       Location(old.file(), line_number, old.char_offset(), old.byte()));
 449 }
 450
 451 // ListNode -------------------------------------------------------------------
 452
 453 ListNode::ListNode() : prefer_multiline_(false) {
 454 }
 455
 456 ListNode::~ListNode() {
 457   STLDeleteContainerPointers(contents_.begin(), contents_.end());
 458 }
 459
 460 const ListNode* ListNode::AsList() const {
 461   return this;
 462 }
 463
 464 Value ListNode::Execute(Scope* scope, Err* err) const {
 465   Value result_value(this, Value::LIST);
 466   std::vector<Value>& results = result_value.list_value();
 467   results.reserve(contents_.size());
 468
 469   for (const auto& cur : contents_) {
 470     if (cur->AsBlockComment())
 471       continue;
 472     results.push_back(cur->Execute(scope, err));
 473     if (err->has_error())
 474       return Value();
 475     if (results.back().type() == Value::NONE) {
 476       *err = cur->MakeErrorDescribing(
 477           "This does not evaluate to a value.",
 478           "I can't do something with nothing.");
 479       return Value();
 480     }
 481   }
 482   return result_value;
 483 }
 484
 485 LocationRange ListNode::GetRange() const {
 486   return LocationRange(begin_token_.location(),
 487                        end_->value().location());
 488 }
 489
 490 Err ListNode::MakeErrorDescribing(const std::string& msg,
 491                                   const std::string& help) const {
 492   return Err(begin_token_, msg, help);
 493 }
 494
 495 void ListNode::Print(std::ostream& out, int indent) const {
 496   out << IndentFor(indent) << "LIST" << (prefer_multiline_ ? " multiline" : "")
 497       << "\n";
 498   PrintComments(out, indent);
 499   for (const auto& cur : contents_)
 500     cur->Print(out, indent + 1);
 501   if (end_ && end_->comments())
 502     end_->Print(out, indent + 1);
 503 }
 504
 505 void ListNode::SortAsStringsList() {
 506   // Sorts alphabetically. Partitions first on BlockCommentNodes and sorts each
 507   // partition separately.
 508   for (auto sr : GetSortRanges()) {
 509     // Save the original line number so that we can re-assign ranges. We assume
 510     // they're contiguous lines because GetSortRanges() does so above. We need
 511     // to re-assign these line numbers primiarily because `gn format` uses them
 512     // to determine whether two nodes were initially separated by a blank line
 513     // or not.
 514     int start_line = contents_[sr.begin]->GetRange().begin().line_number();
 515     const ParseNode* original_first = contents_[sr.begin];
 516     std::sort(contents_.begin() + sr.begin, contents_.begin() + sr.end,
 517               [](const ParseNode* a, const ParseNode* b) {
 518                 base::StringPiece astr = GetStringRepresentation(a);
 519                 base::StringPiece bstr = GetStringRepresentation(b);
 520                 return astr < bstr;
 521               });
 522     // If the beginning of the range had before comments, and the first node
 523     // moved during the sort, then move its comments to the new head of the
 524     // range.
 525     if (original_first->comments() && contents_[sr.begin] != original_first) {
 526       for (const auto& hc : original_first->comments()->before()) {
 527         const_cast<ParseNode*>(contents_[sr.begin])
 528             ->comments_mutable()
 529             ->append_before(hc);
 530       }
 531       const_cast<ParseNode*>(original_first)
 532           ->comments_mutable()
 533           ->clear_before();
 534     }
 535     const ParseNode* prev = nullptr;
 536     for (size_t i = sr.begin; i != sr.end; ++i) {
 537       const ParseNode* node = contents_[i];
 538       DCHECK(node->AsLiteral() || node->AsIdentifier() || node->AsAccessor());
 539       int line_number =
 540           prev ? prev->GetRange().end().line_number() + 1 : start_line;
 541       if (node->AsLiteral()) {
 542         const_cast<LiteralNode*>(node->AsLiteral())
 543             ->SetNewLocation(line_number);
 544       } else if (node->AsIdentifier()) {
 545         const_cast<IdentifierNode*>(node->AsIdentifier())
 546             ->SetNewLocation(line_number);
 547       } else if (node->AsAccessor()) {
 548         const_cast<AccessorNode*>(node->AsAccessor())
 549             ->SetNewLocation(line_number);
 550       }
 551       prev = node;
 552     }
 553   }
 554 }
 555
 556 // Breaks the ParseNodes of |contents| up by ranges that should be separately
 557 // sorted. In particular, we break at a block comment, or an item that has an
 558 // attached "before" comment and is separated by a blank line from the item
 559 // before it. The assumption is that both of these indicate a separate 'section'
 560 // of a sources block across which items should not be inter-sorted.
 561 std::vector<ListNode::SortRange> ListNode::GetSortRanges() const {
 562   std::vector<SortRange> ranges;
 563   const ParseNode* prev = nullptr;
 564   size_t begin = 0;
 565   for (size_t i = begin; i < contents_.size(); prev = contents_[i++]) {
 566     if (IsSortRangeSeparator(contents_[i], prev)) {
 567       if (i > begin) {
 568         ranges.push_back(SortRange(begin, i));
 569         // If |i| is an item with an attached comment, then we start the next
 570         // range at that point, because we want to include it in the sort.
 571         // Otherwise, it's a block comment which we skip over entirely because
 572         // we don't want to move or include it in the sort. The two cases are:
 573         //
 574         // sources = [
 575         //   "a",
 576         //   "b",
 577         //
 578         //   #
 579         //   # This is a block comment.
 580         //   #
 581         //
 582         //   "c",
 583         //   "d",
 584         // ]
 585         //
 586         // which contains 5 elements, and for which the ranges would be { [0,
 587         // 2), [3, 5) } (notably excluding 2, the block comment), and:
 588         //
 589         // sources = [
 590         //   "a",
 591         //   "b",
 592         //
 593         //   # This is a header comment.
 594         //   "c",
 595         //   "d",
 596         // ]
 597         //
 598         // which contains 4 elements, index 2 containing an attached 'before'
 599         // comments, and the ranges should be { [0, 2), [2, 4) }.
 600         if (!contents_[i]->AsBlockComment())
 601           begin = i;
 602         else
 603           begin = i + 1;
 604       } else {
 605         // If it was a one item range, just skip over it.
 606         begin = i + 1;
 607       }
 608     }
 609   }
 610   if (begin != contents_.size())
 611     ranges.push_back(SortRange(begin, contents_.size()));
 612   return ranges;
 613 }
 614
 615 // LiteralNode -----------------------------------------------------------------
 616
 617 LiteralNode::LiteralNode() {
 618 }
 619
 620 LiteralNode::LiteralNode(const Token& token) : value_(token) {
 621 }
 622
 623 LiteralNode::~LiteralNode() {
 624 }
 625
 626 const LiteralNode* LiteralNode::AsLiteral() const {
 627   return this;
 628 }
 629
 630 Value LiteralNode::Execute(Scope* scope, Err* err) const {
 631   switch (value_.type()) {
 632     case Token::TRUE_TOKEN:
 633       return Value(this, true);
 634     case Token::FALSE_TOKEN:
 635       return Value(this, false);
 636     case Token::INTEGER: {
 637       base::StringPiece s = value_.value();
 638       if ((s.starts_with("0") && s.size() > 1) || s.starts_with("-0")) {
 639         if (s == "-0")
 640           *err = MakeErrorDescribing("Negative zero doesn't make sense");
 641         else
 642           *err = MakeErrorDescribing("Leading zeros not allowed");
 643         return Value();
 644       }
 645       int64 result_int;
 646       if (!base::StringToInt64(s, &result_int)) {
 647         *err = MakeErrorDescribing("This does not look like an integer");
 648         return Value();
 649       }
 650       return Value(this, result_int);
 651     }
 652     case Token::STRING: {
 653       Value v(this, Value::STRING);
 654       ExpandStringLiteral(scope, value_, &v, err);
 655       return v;
 656     }
 657     default:
 658       NOTREACHED();
 659       return Value();
 660   }
 661 }
 662
 663 LocationRange LiteralNode::GetRange() const {
 664   return value_.range();
 665 }
 666
 667 Err LiteralNode::MakeErrorDescribing(const std::string& msg,
 668                                      const std::string& help) const {
 669   return Err(value_, msg, help);
 670 }
 671
 672 void LiteralNode::Print(std::ostream& out, int indent) const {
 673   out << IndentFor(indent) << "LITERAL(" << value_.value() << ")\n";
 674   PrintComments(out, indent);
 675 }
 676
 677 void LiteralNode::SetNewLocation(int line_number) {
 678   Location old = value_.location();
 679   value_.set_location(
 680       Location(old.file(), line_number, old.char_offset(), old.byte()));
 681 }
 682
 683 // UnaryOpNode ----------------------------------------------------------------
 684
 685 UnaryOpNode::UnaryOpNode() {
 686 }
 687
 688 UnaryOpNode::~UnaryOpNode() {
 689 }
 690
 691 const UnaryOpNode* UnaryOpNode::AsUnaryOp() const {
 692   return this;
 693 }
 694
 695 Value UnaryOpNode::Execute(Scope* scope, Err* err) const {
 696   Value operand_value = operand_->Execute(scope, err);
 697   if (err->has_error())
 698     return Value();
 699   return ExecuteUnaryOperator(scope, this, operand_value, err);
 700 }
 701
 702 LocationRange UnaryOpNode::GetRange() const {
 703   return op_.range().Union(operand_->GetRange());
 704 }
 705
 706 Err UnaryOpNode::MakeErrorDescribing(const std::string& msg,
 707                                      const std::string& help) const {
 708   return Err(op_, msg, help);
 709 }
 710
 711 void UnaryOpNode::Print(std::ostream& out, int indent) const {
 712   out << IndentFor(indent) << "UNARY(" << op_.value() << ")\n";
 713   PrintComments(out, indent);
 714   operand_->Print(out, indent + 1);
 715 }
 716
 717 // BlockCommentNode ------------------------------------------------------------
 718
 719 BlockCommentNode::BlockCommentNode() {
 720 }
 721
 722 BlockCommentNode::~BlockCommentNode() {
 723 }
 724
 725 const BlockCommentNode* BlockCommentNode::AsBlockComment() const {
 726   return this;
 727 }
 728
 729 Value BlockCommentNode::Execute(Scope* scope, Err* err) const {
 730   return Value();
 731 }
 732
 733 LocationRange BlockCommentNode::GetRange() const {
 734   return comment_.range();
 735 }
 736
 737 Err BlockCommentNode::MakeErrorDescribing(const std::string& msg,
 738                                           const std::string& help) const {
 739   return Err(comment_, msg, help);
 740 }
 741
 742 void BlockCommentNode::Print(std::ostream& out, int indent) const {
 743   out << IndentFor(indent) << "BLOCK_COMMENT(" << comment_.value() << ")\n";
 744   PrintComments(out, indent);
 745 }
 746
 747 // EndNode ---------------------------------------------------------------------
 748
 749 EndNode::EndNode(const Token& token) : value_(token) {
 750 }
 751
 752 EndNode::~EndNode() {
 753 }
 754
 755 const EndNode* EndNode::AsEnd() const {
 756   return this;
 757 }
 758
 759 Value EndNode::Execute(Scope* scope, Err* err) const {
 760   return Value();
 761 }
 762
 763 LocationRange EndNode::GetRange() const {
 764   return value_.range();
 765 }
 766
 767 Err EndNode::MakeErrorDescribing(const std::string& msg,
 768                                         const std::string& help) const {
 769   return Err(value_, msg, help);
 770 }
 771
 772 void EndNode::Print(std::ostream& out, int indent) const {
 773   out << IndentFor(indent) << "END(" << value_.value() << ")\n";
 774   PrintComments(out, indent);
 775 }