JavaScriptCore/kjs/nodes2string.cpp

   1 /*
   2  *  Copyright (C) 2002 Harri Porten (porten@kde.org)
   3  *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
   4  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
   5  *
   6  *  This library is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU Library General Public
   8  *  License as published by the Free Software Foundation; either
   9  *  version 2 of the License, or (at your option) any later version.
  10  *
  11  *  This library is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  *  Library General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU Library General Public License
  17  *  along with this library; see the file COPYING.LIB.  If not, write to
  18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  *  Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #include "config.h"
  24 #include "nodes.h"
  25
  26 #include <wtf/MathExtras.h>
  27 #include <wtf/StringExtras.h>
  28 #include <wtf/unicode/Unicode.h>
  29
  30 using namespace WTF;
  31 using namespace Unicode;
  32
  33 namespace KJS {
  34
  35 // A simple text streaming class that helps with code indentation.
  36
  37 enum EndlType { Endl };
  38 enum IndentType { Indent };
  39 enum UnindentType { Unindent };
  40 enum DotExprType { DotExpr };
  41
  42 class SourceStream {
  43 public:
  44     SourceStream() : m_numberNeedsParens(false), m_precedence(PrecExpression) { }
  45     UString toString() const { return m_string; }
  46     SourceStream& operator<<(const Identifier&);
  47     SourceStream& operator<<(const UString&);
  48     SourceStream& operator<<(const char*);
  49     SourceStream& operator<<(double);
  50     SourceStream& operator<<(char);
  51     SourceStream& operator<<(EndlType);
  52     SourceStream& operator<<(IndentType);
  53     SourceStream& operator<<(UnindentType);
  54     SourceStream& operator<<(DotExprType);
  55     SourceStream& operator<<(Precedence);
  56     SourceStream& operator<<(const Node*);
  57     template <typename T> SourceStream& operator<<(const RefPtr<T>& n) { return *this << n.get(); }
  58
  59 private:
  60     UString m_string;
  61     UString m_spacesForIndentation;
  62     bool m_numberNeedsParens;
  63     Precedence m_precedence;
  64 };
  65
  66 // --------
  67
  68 static UString escapeStringForPrettyPrinting(const UString& s)
  69 {
  70     UString escapedString;
  71
  72     for (int i = 0; i < s.size(); i++) {
  73         unsigned short c = s.data()[i].unicode();
  74         switch (c) {
  75             case '\"':
  76                 escapedString += "\\\"";
  77                 break;
  78             case '\n':
  79                 escapedString += "\\n";
  80                 break;
  81             case '\r':
  82                 escapedString += "\\r";
  83                 break;
  84             case '\t':
  85                 escapedString += "\\t";
  86                 break;
  87             case '\\':
  88                 escapedString += "\\\\";
  89                 break;
  90             default:
  91                 if (c < 128 && isPrintableChar(c))
  92                     escapedString.append(c);
  93                 else {
  94                     char hexValue[7];
  95                     snprintf(hexValue, 7, "\\u%04x", c);
  96                     escapedString += hexValue;
  97                 }
  98         }
  99     }
 100
 101     return escapedString;
 102 }
 103
 104 static const char* operatorString(Operator oper)
 105 {
 106     switch (oper) {
 107         case OpEqual:
 108             return "=";
 109         case OpMultEq:
 110             return "*=";
 111         case OpDivEq:
 112             return "/=";
 113         case OpPlusEq:
 114             return "+=";
 115         case OpMinusEq:
 116             return "-=";
 117         case OpLShift:
 118             return "<<=";
 119         case OpRShift:
 120             return ">>=";
 121         case OpURShift:
 122             return ">>>=";
 123         case OpAndEq:
 124             return "&=";
 125         case OpXOrEq:
 126             return "^=";
 127         case OpOrEq:
 128             return "|=";
 129         case OpModEq:
 130             return "%=";
 131         case OpPlusPlus:
 132             return "++";
 133         case OpMinusMinus:
 134             return "--";
 135     }
 136     ASSERT_NOT_REACHED();
 137     return "???";
 138 }
 139
 140 static bool isParserRoundTripNumber(const UString& string)
 141 {
 142     double number = string.toDouble(false, false);
 143     if (isnan(number) || isinf(number))
 144         return false;
 145     return string == UString::from(number);
 146 }
 147
 148 // --------
 149
 150 SourceStream& SourceStream::operator<<(char c)
 151 {
 152     m_numberNeedsParens = false;
 153     UChar ch(c);
 154     m_string.append(ch);
 155     return *this;
 156 }
 157
 158 SourceStream& SourceStream::operator<<(const char* s)
 159 {
 160     m_numberNeedsParens = false;
 161     m_string += s;
 162     return *this;
 163 }
 164
 165 SourceStream& SourceStream::operator<<(double value)
 166 {
 167     bool needParens = m_numberNeedsParens;
 168     m_numberNeedsParens = false;
 169
 170     if (needParens)
 171         m_string.append('(');
 172     m_string += UString::from(value);
 173     if (needParens)
 174         m_string.append(')');
 175
 176     return *this;
 177 }
 178
 179 SourceStream& SourceStream::operator<<(const UString& s)
 180 {
 181     m_numberNeedsParens = false;
 182     m_string += s;
 183     return *this;
 184 }
 185
 186 SourceStream& SourceStream::operator<<(const Identifier& s)
 187 {
 188     m_numberNeedsParens = false;
 189     m_string += s.ustring();
 190     return *this;
 191 }
 192
 193 SourceStream& SourceStream::operator<<(const Node* n)
 194 {
 195     bool needParens = m_precedence != PrecExpression && n->precedence() > m_precedence;
 196     m_precedence = PrecExpression;
 197     if (n) {
 198         if (needParens)
 199             m_string.append('(');
 200         n->streamTo(*this);
 201         if (needParens)
 202             m_string.append(')');
 203     }
 204     return *this;
 205 }
 206
 207 SourceStream& SourceStream::operator<<(EndlType)
 208 {
 209     m_numberNeedsParens = false;
 210     m_string.append('\n');
 211     m_string.append(m_spacesForIndentation);
 212     return *this;
 213 }
 214
 215 SourceStream& SourceStream::operator<<(IndentType)
 216 {
 217     m_numberNeedsParens = false;
 218     m_spacesForIndentation += "  ";
 219     return *this;
 220 }
 221
 222 SourceStream& SourceStream::operator<<(UnindentType)
 223 {
 224     m_numberNeedsParens = false;
 225     m_spacesForIndentation = m_spacesForIndentation.substr(0, m_spacesForIndentation.size() - 2);
 226     return *this;
 227 }
 228
 229 inline SourceStream& SourceStream::operator<<(DotExprType)
 230 {
 231     m_numberNeedsParens = true;
 232     return *this;
 233 }
 234
 235 inline SourceStream& SourceStream::operator<<(Precedence precedence)
 236 {
 237     m_precedence = precedence;
 238     return *this;
 239 }
 240
 241 static void streamLeftAssociativeBinaryOperator(SourceStream& s, Precedence precedence,
 242     const char* operatorString, const Node* left, const Node* right)
 243 {
 244     s << precedence << left
 245         << ' ' << operatorString << ' '
 246         << static_cast<Precedence>(precedence - 1) << right;
 247 }
 248
 249 template <typename T> static inline void streamLeftAssociativeBinaryOperator(SourceStream& s,
 250     Precedence p, const char* o, const RefPtr<T>& l, const RefPtr<T>& r)
 251 {
 252     streamLeftAssociativeBinaryOperator(s, p, o, l.get(), r.get());
 253 }
 254
 255 // --------
 256
 257 UString Node::toString() const
 258 {
 259     SourceStream stream;
 260     streamTo(stream);
 261     return stream.toString();
 262 }
 263
 264 // --------
 265
 266 void NullNode::streamTo(SourceStream& s) const
 267 {
 268     s << "null";
 269 }
 270
 271 void BooleanNode::streamTo(SourceStream& s) const
 272 {
 273     s << (value ? "true" : "false");
 274 }
 275
 276 void NumberNode::streamTo(SourceStream& s) const
 277 {
 278     s << value();
 279 }
 280
 281 void StringNode::streamTo(SourceStream& s) const
 282 {
 283     s << '"' << escapeStringForPrettyPrinting(value) << '"';
 284 }
 285
 286 void RegExpNode::streamTo(SourceStream& s) const
 287 {
 288     s << '/' <<  pattern << '/' << flags;
 289 }
 290
 291 void ThisNode::streamTo(SourceStream& s) const
 292 {
 293     s << "this";
 294 }
 295
 296 void ResolveNode::streamTo(SourceStream& s) const
 297 {
 298     s << ident;
 299 }
 300
 301 void ElementNode::streamTo(SourceStream& s) const
 302 {
 303     for (const ElementNode* n = this; n; n = n->next.get()) {
 304         for (int i = 0; i < n->elision; i++)
 305             s << ',';
 306         s << PrecAssignment << n->node;
 307         if (n->next)
 308             s << ',';
 309     }
 310 }
 311
 312 void ArrayNode::streamTo(SourceStream& s) const
 313 {
 314     s << '[' << element;
 315     for (int i = 0; i < elision; i++)
 316         s << ',';
 317     // Parser consumes one elision comma if there's array elements
 318     // present in the expression.
 319     if (opt && element)
 320         s << ',';
 321     s << ']';
 322 }
 323
 324 void ObjectLiteralNode::streamTo(SourceStream& s) const
 325 {
 326     if (list)
 327         s << "{ " << list << " }";
 328     else
 329         s << "{ }";
 330 }
 331
 332 void PropertyListNode::streamTo(SourceStream& s) const
 333 {
 334     s << node;
 335     for (const PropertyListNode* n = next.get(); n; n = n->next.get())
 336         s << ", " << n->node;
 337 }
 338
 339 void PropertyNode::streamTo(SourceStream& s) const
 340 {
 341     switch (type) {
 342         case Constant: {
 343             UString propertyName = name().ustring();
 344             if (isParserRoundTripNumber(propertyName))
 345                 s << propertyName;
 346             else
 347                 s << '"' << escapeStringForPrettyPrinting(propertyName) << '"';
 348             s << ": " << PrecAssignment << assign;
 349             break;
 350         }
 351         case Getter:
 352         case Setter: {
 353             const FuncExprNode* func = static_cast<const FuncExprNode*>(assign.get());
 354             if (type == Getter)
 355                 s << "get \"";
 356             else
 357                 s << "set \"";
 358             s << escapeStringForPrettyPrinting(name().ustring())
 359                 << "\"(" << func->param << ')' << func->body;
 360             break;
 361         }
 362     }
 363 }
 364
 365 void BracketAccessorNode::streamTo(SourceStream& s) const
 366 {
 367     s << PrecCall << expr1 << "[" << expr2 << "]";
 368 }
 369
 370 void DotAccessorNode::streamTo(SourceStream& s) const
 371 {
 372     s << DotExpr << PrecCall << expr << "." << ident;
 373 }
 374
 375 void ArgumentListNode::streamTo(SourceStream& s) const
 376 {
 377     s << PrecAssignment << expr;
 378     for (ArgumentListNode* n = next.get(); n; n = n->next.get())
 379         s << ", " << PrecAssignment << n->expr;
 380 }
 381
 382 void ArgumentsNode::streamTo(SourceStream& s) const
 383 {
 384     s << '(' << listNode << ')';
 385 }
 386
 387 void NewExprNode::streamTo(SourceStream& s) const
 388 {
 389     s << "new " << PrecMember << expr << args;
 390 }
 391
 392 void FunctionCallValueNode::streamTo(SourceStream& s) const
 393 {
 394     s << PrecCall << expr << args;
 395 }
 396
 397 void FunctionCallResolveNode::streamTo(SourceStream& s) const
 398 {
 399     s << ident << args;
 400 }
 401
 402 void FunctionCallBracketNode::streamTo(SourceStream& s) const
 403 {
 404     s << PrecCall << base << "[" << subscript << "]" << args;
 405 }
 406
 407 void FunctionCallDotNode::streamTo(SourceStream& s) const
 408 {
 409     s << DotExpr << PrecCall << base << "." << ident << args;
 410 }
 411
 412 void PostIncResolveNode::streamTo(SourceStream& s) const
 413 {
 414     s << m_ident << "++";
 415 }
 416
 417 void PostDecResolveNode::streamTo(SourceStream& s) const
 418 {
 419     s << m_ident << "--";
 420 }
 421
 422 void PostfixBracketNode::streamTo(SourceStream& s) const
 423 {
 424     s << PrecCall << m_base << "[" << m_subscript << "]";
 425     if (isIncrement())
 426         s << "++";
 427     else
 428         s << "--";
 429 }
 430
 431 void PostfixDotNode::streamTo(SourceStream& s) const
 432 {
 433     s << DotExpr << PrecCall << m_base << "." << m_ident;
 434     if (isIncrement())
 435         s << "++";
 436     else
 437         s << "--";
 438 }
 439
 440 void PostfixErrorNode::streamTo(SourceStream& s) const
 441 {
 442     s << PrecLeftHandSide << m_expr;
 443     if (m_oper == OpPlusPlus)
 444         s << "++";
 445     else
 446         s << "--";
 447 }
 448
 449 void DeleteResolveNode::streamTo(SourceStream& s) const
 450 {
 451     s << "delete " << m_ident;
 452 }
 453
 454 void DeleteBracketNode::streamTo(SourceStream& s) const
 455 {
 456     s << "delete " << PrecCall << m_base << "[" << m_subscript << "]";
 457 }
 458
 459 void DeleteDotNode::streamTo(SourceStream& s) const
 460 {
 461     s << "delete " << DotExpr << PrecCall << m_base << "." << m_ident;
 462 }
 463
 464 void DeleteValueNode::streamTo(SourceStream& s) const
 465 {
 466     s << "delete " << PrecUnary << m_expr;
 467 }
 468
 469 void VoidNode::streamTo(SourceStream& s) const
 470 {
 471     s << "void " << PrecUnary << expr;
 472 }
 473
 474 void TypeOfValueNode::streamTo(SourceStream& s) const
 475 {
 476     s << "typeof " << PrecUnary << m_expr;
 477 }
 478
 479 void TypeOfResolveNode::streamTo(SourceStream& s) const
 480 {
 481     s << "typeof " << m_ident;
 482 }
 483
 484 void PreIncResolveNode::streamTo(SourceStream& s) const
 485 {
 486     s << "++" << m_ident;
 487 }
 488
 489 void PreDecResolveNode::streamTo(SourceStream& s) const
 490 {
 491     s << "--" << m_ident;
 492 }
 493
 494 void PrefixBracketNode::streamTo(SourceStream& s) const
 495 {
 496     if (isIncrement())
 497         s << "++";
 498     else
 499         s << "--";
 500     s << PrecCall << m_base << "[" << m_subscript << "]";
 501 }
 502
 503 void PrefixDotNode::streamTo(SourceStream& s) const
 504 {
 505     if (isIncrement())
 506         s << "++";
 507     else
 508         s << "--";
 509     s << DotExpr << PrecCall << m_base << "." << m_ident;
 510 }
 511
 512 void PrefixErrorNode::streamTo(SourceStream& s) const
 513 {
 514     if (m_oper == OpPlusPlus)
 515         s << "++" << PrecUnary << m_expr;
 516     else
 517         s << "--" << PrecUnary << m_expr;
 518 }
 519
 520 void UnaryPlusNode::streamTo(SourceStream& s) const
 521 {
 522     s << "+ " << PrecUnary << expr;
 523 }
 524
 525 void NegateNode::streamTo(SourceStream& s) const
 526 {
 527     s << "- " << PrecUnary << expr;
 528 }
 529
 530 void BitwiseNotNode::streamTo(SourceStream& s) const
 531 {
 532     s << "~" << PrecUnary << expr;
 533 }
 534
 535 void LogicalNotNode::streamTo(SourceStream& s) const
 536 {
 537     s << "!" << PrecUnary << expr;
 538 }
 539
 540 void MultNode::streamTo(SourceStream& s) const
 541 {
 542     streamLeftAssociativeBinaryOperator(s, precedence(), "*", term1, term2);
 543 }
 544
 545 void DivNode::streamTo(SourceStream& s) const
 546 {
 547     streamLeftAssociativeBinaryOperator(s, precedence(), "/", term1, term2);
 548 }
 549
 550 void ModNode::streamTo(SourceStream& s) const
 551 {
 552     streamLeftAssociativeBinaryOperator(s, precedence(), "%", term1, term2);
 553 }
 554
 555 void AddNode::streamTo(SourceStream& s) const
 556 {
 557     streamLeftAssociativeBinaryOperator(s, precedence(), "+", term1, term2);
 558 }
 559
 560 void SubNode::streamTo(SourceStream& s) const
 561 {
 562     streamLeftAssociativeBinaryOperator(s, precedence(), "-", term1, term2);
 563 }
 564
 565 void LeftShiftNode::streamTo(SourceStream& s) const
 566 {
 567     streamLeftAssociativeBinaryOperator(s, precedence(), "<<", term1, term2);
 568 }
 569
 570 void RightShiftNode::streamTo(SourceStream& s) const
 571 {
 572     streamLeftAssociativeBinaryOperator(s, precedence(), ">>", term1, term2);
 573 }
 574
 575 void UnsignedRightShiftNode::streamTo(SourceStream& s) const
 576 {
 577     streamLeftAssociativeBinaryOperator(s, precedence(), ">>>", term1, term2);
 578 }
 579
 580 void LessNode::streamTo(SourceStream& s) const
 581 {
 582     streamLeftAssociativeBinaryOperator(s, precedence(), "<", expr1, expr2);
 583 }
 584
 585 void GreaterNode::streamTo(SourceStream& s) const
 586 {
 587     streamLeftAssociativeBinaryOperator(s, precedence(), ">", expr1, expr2);
 588 }
 589
 590 void LessEqNode::streamTo(SourceStream& s) const
 591 {
 592     streamLeftAssociativeBinaryOperator(s, precedence(), "<=", expr1, expr2);
 593 }
 594
 595 void GreaterEqNode::streamTo(SourceStream& s) const
 596 {
 597     streamLeftAssociativeBinaryOperator(s, precedence(), ">=", expr1, expr2);
 598 }
 599
 600 void InstanceOfNode::streamTo(SourceStream& s) const
 601 {
 602     streamLeftAssociativeBinaryOperator(s, precedence(), "instanceof", expr1, expr2);
 603 }
 604
 605 void InNode::streamTo(SourceStream& s) const
 606 {
 607     streamLeftAssociativeBinaryOperator(s, precedence(), "in", expr1, expr2);
 608 }
 609
 610 void EqualNode::streamTo(SourceStream& s) const
 611 {
 612     streamLeftAssociativeBinaryOperator(s, precedence(), "==", expr1, expr2);
 613 }
 614
 615 void NotEqualNode::streamTo(SourceStream& s) const
 616 {
 617     streamLeftAssociativeBinaryOperator(s, precedence(), "!=", expr1, expr2);
 618 }
 619
 620 void StrictEqualNode::streamTo(SourceStream& s) const
 621 {
 622     streamLeftAssociativeBinaryOperator(s, precedence(), "===", expr1, expr2);
 623 }
 624
 625 void NotStrictEqualNode::streamTo(SourceStream& s) const
 626 {
 627     streamLeftAssociativeBinaryOperator(s, precedence(), "!==", expr1, expr2);
 628 }
 629
 630 void BitAndNode::streamTo(SourceStream& s) const
 631 {
 632     streamLeftAssociativeBinaryOperator(s, precedence(), "&", expr1, expr2);
 633 }
 634
 635 void BitXOrNode::streamTo(SourceStream& s) const
 636 {
 637     streamLeftAssociativeBinaryOperator(s, precedence(), "^", expr1, expr2);
 638 }
 639
 640 void BitOrNode::streamTo(SourceStream& s) const
 641 {
 642     streamLeftAssociativeBinaryOperator(s, precedence(), "|", expr1, expr2);
 643 }
 644
 645 void LogicalAndNode::streamTo(SourceStream& s) const
 646 {
 647     streamLeftAssociativeBinaryOperator(s, precedence(), "&&", expr1, expr2);
 648 }
 649
 650 void LogicalOrNode::streamTo(SourceStream& s) const
 651 {
 652     streamLeftAssociativeBinaryOperator(s, precedence(), "||", expr1, expr2);
 653 }
 654
 655 void ConditionalNode::streamTo(SourceStream& s) const
 656 {
 657     s << PrecLogicalOr << logical
 658         << " ? " << PrecAssignment << expr1
 659         << " : " << PrecAssignment << expr2;
 660 }
 661
 662 void ReadModifyResolveNode::streamTo(SourceStream& s) const
 663 {
 664     s << m_ident << ' ' << operatorString(m_oper) << ' ' << PrecAssignment << m_right;
 665 }
 666
 667 void AssignResolveNode::streamTo(SourceStream& s) const
 668 {
 669     s << m_ident << " = " << PrecAssignment << m_right;
 670 }
 671
 672 void ReadModifyBracketNode::streamTo(SourceStream& s) const
 673 {
 674     s << PrecCall << m_base << '[' << m_subscript << "] "
 675         << operatorString(m_oper) << ' ' << PrecAssignment << m_right;
 676 }
 677
 678 void AssignBracketNode::streamTo(SourceStream& s) const
 679 {
 680     s << PrecCall << m_base << '[' << m_subscript << "] = " << PrecAssignment << m_right;
 681 }
 682
 683 void ReadModifyDotNode::streamTo(SourceStream& s) const
 684 {
 685     s << DotExpr << PrecCall << m_base << "." << m_ident << ' '
 686         << operatorString(m_oper) << ' ' << PrecAssignment << m_right;
 687 }
 688
 689 void AssignDotNode::streamTo(SourceStream& s) const
 690 {
 691     s << DotExpr << PrecCall << m_base << "." << m_ident << " = " << PrecAssignment << m_right;
 692 }
 693
 694 void AssignErrorNode::streamTo(SourceStream& s) const
 695 {
 696     s << PrecLeftHandSide << m_left << ' '
 697         << operatorString(m_oper) << ' ' << PrecAssignment << m_right;
 698 }
 699
 700 void CommaNode::streamTo(SourceStream& s) const
 701 {
 702     s << PrecAssignment << expr1 << ", " << PrecAssignment << expr2;
 703 }
 704
 705 void AssignExprNode::streamTo(SourceStream& s) const
 706 {
 707     s << " = " << PrecAssignment << expr;
 708 }
 709
 710 void VarDeclNode::streamTo(SourceStream& s) const
 711 {
 712     s << "var " << ident << init;
 713     for (VarDeclNode* n = next.get(); n; n = n->next.get())
 714         s << ", " << ident << init;
 715 }
 716
 717 void VarStatementNode::streamTo(SourceStream& s) const
 718 {
 719     s << Endl << next << ';';
 720 }
 721
 722 static inline void statementListStreamTo(Vector<RefPtr<StatementNode> >* nodes, SourceStream& s)
 723 {
 724     if (!nodes)
 725         return;
 726
 727     for (Vector<RefPtr<StatementNode> >::iterator ptr = nodes->begin(); ptr != nodes->end(); ptr++)
 728         s << *ptr;
 729 }
 730
 731 void BlockNode::streamTo(SourceStream& s) const
 732 {
 733     s << Endl << "{" << Indent;
 734     statementListStreamTo(m_children.get(), s);
 735     s << Unindent << Endl << "}";
 736 }
 737
 738 void EmptyStatementNode::streamTo(SourceStream& s) const
 739 {
 740     s << Endl << ';';
 741 }
 742
 743 void ExprStatementNode::streamTo(SourceStream& s) const
 744 {
 745     s << Endl << expr << ';';
 746 }
 747
 748 void IfNode::streamTo(SourceStream& s) const
 749 {
 750     s << Endl << "if (" << expr << ')' << Indent << statement1 << Unindent;
 751     if (statement2)
 752         s << Endl << "else" << Indent << statement2 << Unindent;
 753 }
 754
 755 void DoWhileNode::streamTo(SourceStream& s) const
 756 {
 757     s << Endl << "do " << Indent << statement << Unindent << Endl
 758         << "while (" << expr << ");";
 759 }
 760
 761 void WhileNode::streamTo(SourceStream& s) const
 762 {
 763   s << Endl << "while (" << expr << ')' << Indent << statement << Unindent;
 764 }
 765
 766 void ForNode::streamTo(SourceStream& s) const
 767 {
 768     s << Endl << "for ("
 769         << expr1
 770         << "; " << expr2
 771         << "; " << expr3
 772         << ')' << Indent << statement << Unindent;
 773 }
 774
 775 void ForInNode::streamTo(SourceStream& s) const
 776 {
 777     s << Endl << "for (";
 778     if (varDecl)
 779         s << varDecl;
 780     else
 781         s << PrecLeftHandSide << lexpr;
 782
 783     s << " in " << expr << ')' << Indent << statement << Unindent;
 784 }
 785
 786 void ContinueNode::streamTo(SourceStream& s) const
 787 {
 788     s << Endl << "continue";
 789     if (!ident.isNull())
 790         s << ' ' << ident;
 791     s << ';';
 792 }
 793
 794 void BreakNode::streamTo(SourceStream& s) const
 795 {
 796     s << Endl << "break";
 797     if (!ident.isNull())
 798         s << ' ' << ident;
 799     s << ';';
 800 }
 801
 802 void ReturnNode::streamTo(SourceStream& s) const
 803 {
 804     s << Endl << "return";
 805     if (value)
 806         s << ' ' << value;
 807     s << ';';
 808 }
 809
 810 void WithNode::streamTo(SourceStream& s) const
 811 {
 812     s << Endl << "with (" << expr << ") " << statement;
 813 }
 814
 815 void CaseClauseNode::streamTo(SourceStream& s) const
 816 {
 817     s << Endl;
 818     if (expr)
 819         s << "case " << expr;
 820     else
 821         s << "default";
 822     s << ":" << Indent;
 823     statementListStreamTo(m_children.get(), s);
 824     s << Unindent;
 825 }
 826
 827 void ClauseListNode::streamTo(SourceStream& s) const
 828 {
 829     for (const ClauseListNode* n = this; n; n = n->getNext())
 830         s << n->getClause();
 831 }
 832
 833 void CaseBlockNode::streamTo(SourceStream& s) const
 834 {
 835     for (const ClauseListNode* n = list1.get(); n; n = n->getNext())
 836         s << n->getClause();
 837     s << def;
 838     for (const ClauseListNode* n = list2.get(); n; n = n->getNext())
 839         s << n->getClause();
 840 }
 841
 842 void SwitchNode::streamTo(SourceStream& s) const
 843 {
 844     s << Endl << "switch (" << expr << ") {"
 845         << Indent << block << Unindent
 846         << Endl << "}";
 847 }
 848
 849 void LabelNode::streamTo(SourceStream& s) const
 850 {
 851     s << Endl << label << ":" << Indent << statement << Unindent;
 852 }
 853
 854 void ThrowNode::streamTo(SourceStream& s) const
 855 {
 856     s << Endl << "throw " << expr << ';';
 857 }
 858
 859 void TryNode::streamTo(SourceStream& s) const
 860 {
 861     s << Endl << "try " << tryBlock;
 862     if (catchBlock)
 863         s << Endl << "catch (" << exceptionIdent << ')' << catchBlock;
 864     if (finallyBlock)
 865         s << Endl << "finally " << finallyBlock;
 866 }
 867
 868 void ParameterNode::streamTo(SourceStream& s) const
 869 {
 870     s << id;
 871     for (ParameterNode* n = next.get(); n; n = n->next.get())
 872         s << ", " << n->id;
 873 }
 874
 875 void FuncDeclNode::streamTo(SourceStream& s) const
 876 {
 877     s << Endl << "function " << ident << '(' << param << ')' << body;
 878 }
 879
 880 void FuncExprNode::streamTo(SourceStream& s) const
 881 {
 882     s << "function " << ident << '(' << param << ')' << body;
 883 }
 884
 885 }