Output.cpp

   1 /* Cycript - Inlining/Optimizing JavaScript Compiler
   2  * Copyright (C) 2009  Jay Freeman (saurik)
   3 */
   4
   5 /* Modified BSD License {{{ */
   6 /*
   7  *        Redistribution and use in source and binary
   8  * forms, with or without modification, are permitted
   9  * provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the
  12  *    above copyright notice, this list of conditions
  13  *    and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the
  15  *    above copyright notice, this list of conditions
  16  *    and the following disclaimer in the documentation
  17  *    and/or other materials provided with the
  18  *    distribution.
  19  * 3. The name of the author may not be used to endorse
  20  *    or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  25  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  26  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  29  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  31  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  34  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  35  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  36  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37 */
  38 /* }}} */
  39
  40 #include "cycript.hpp"
  41 #include "Parser.hpp"
  42
  43 #include <sstream>
  44
  45 _finline CYFlags operator ~(CYFlags rhs) {
  46     return static_cast<CYFlags>(~static_cast<unsigned>(rhs));
  47 }
  48
  49 _finline CYFlags operator &(CYFlags lhs, CYFlags rhs) {
  50     return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs));
  51 }
  52
  53 _finline CYFlags operator |(CYFlags lhs, CYFlags rhs) {
  54     return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs));
  55 }
  56
  57 _finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) {
  58     return lhs = lhs | rhs;
  59 }
  60
  61 _finline CYFlags CYLeft(CYFlags flags) {
  62     return flags & ~(CYNoDangle | CYNoInteger);
  63 }
  64
  65 _finline CYFlags CYRight(CYFlags flags) {
  66     return flags & ~CYNoBF;
  67 }
  68
  69 _finline CYFlags CYCenter(CYFlags flags) {
  70     return CYLeft(CYRight(flags));
  71 }
  72
  73 void CYOutput::Terminate() {
  74     out_ << ';';
  75     mode_ = NoMode;
  76 }
  77
  78 CYOutput &CYOutput::operator <<(char rhs) {
  79     if (rhs == ' ' || rhs == '\n')
  80         if (pretty_)
  81             out_ << rhs;
  82         else goto done;
  83     else if (rhs == '\t')
  84         if (pretty_)
  85             for (unsigned i(0); i != indent_; ++i)
  86                 out_ << "    ";
  87         else goto done;
  88     else if (rhs == '\r') {
  89         if (right_) {
  90             out_ << '\n';
  91             right_ = false;
  92         } goto done;
  93     } else goto work;
  94
  95     right_ = true;
  96     mode_ = NoMode;
  97     goto done;
  98
  99   work:
 100     if (mode_ == Terminated && rhs != '}') {
 101         right_ = true;
 102         out_ << ';';
 103     }
 104
 105     if (rhs == ';') {
 106         if (pretty_)
 107             goto none;
 108         else {
 109             mode_ = Terminated;
 110             goto done;
 111         }
 112     } else if (rhs == '+') {
 113         if (mode_ == NoPlus)
 114             out_ << ' ';
 115         mode_ = NoPlus;
 116     } else if (rhs == '-') {
 117         if (mode_ == NoHyphen)
 118             out_ << ' ';
 119         mode_ = NoHyphen;
 120     } else if (WordEndRange_[rhs]) {
 121         if (mode_ == NoLetter)
 122             out_ << ' ';
 123         mode_ = NoLetter;
 124     } else none:
 125         mode_ = NoMode;
 126
 127     right_ = true;
 128     out_ << rhs;
 129   done:
 130     return *this;
 131 }
 132
 133 CYOutput &CYOutput::operator <<(const char *rhs) {
 134     size_t size(strlen(rhs));
 135
 136     if (size == 1)
 137         return *this << *rhs;
 138
 139     if (mode_ == Terminated)
 140         out_ << ';';
 141     else if (
 142         mode_ == NoPlus && *rhs == '+' ||
 143         mode_ == NoHyphen && *rhs == '-' ||
 144         mode_ == NoLetter && WordEndRange_[*rhs]
 145     )
 146         out_ << ' ';
 147
 148     if (WordEndRange_[rhs[size - 1]])
 149         mode_ = NoLetter;
 150     else
 151         mode_ = NoMode;
 152
 153     right_ = true;
 154     out_ << rhs;
 155     return *this;
 156 }
 157
 158 void CYArgument::Output(CYOutput &out) const {
 159     if (name_ != NULL) {
 160         out << *name_;
 161         if (value_ != NULL)
 162             out << ':' << ' ';
 163     }
 164     if (value_ != NULL)
 165         value_->Output(out, CYPA, CYNoFlags);
 166     if (next_ != NULL) {
 167         if (next_->name_ == NULL)
 168             out << ',';
 169         out << ' ' << *next_;
 170     }
 171 }
 172
 173 void CYArray::Output(CYOutput &out, CYFlags flags) const {
 174     out << '[' << elements_ << ']';
 175 }
 176
 177 void CYArrayComprehension::Output(CYOutput &out, CYFlags flags) const {
 178     out << '[' << *expression_ << ' ' << *comprehensions_ << ']';
 179 }
 180
 181 void CYAssignment::Output(CYOutput &out, CYFlags flags) const {
 182     lhs_->Output(out, Precedence() - 1, CYLeft(flags) | CYNoRightHand);
 183     out << ' ' << Operator() << ' ';
 184     rhs_->Output(out, Precedence(), CYRight(flags));
 185 }
 186
 187 void CYBlock::Output(CYOutput &out) const {
 188     out << '{' << '\n';
 189     ++out.indent_;
 190     if (statements_ != NULL)
 191         statements_->Multiple(out);
 192     --out.indent_;
 193     out << '\t' << '}';
 194 }
 195
 196 void CYBlock::Output(CYOutput &out, CYFlags flags) const {
 197     if (statements_ == NULL)
 198         out.Terminate();
 199     else if (statements_->next_ == NULL)
 200         statements_->Single(out, flags);
 201     else
 202         Output(out);
 203 }
 204
 205 void CYBoolean::Output(CYOutput &out, CYFlags flags) const {
 206     out << (Value() ? "true" : "false");
 207 }
 208
 209 void CYBreak::Output(CYOutput &out, CYFlags flags) const {
 210     out << "break";
 211     if (label_ != NULL)
 212         out << ' ' << *label_;
 213     out << ';';
 214 }
 215
 216 void CYCall::Output(CYOutput &out, CYFlags flags) const {
 217     bool protect((flags & CYNoCall) != 0);
 218     if (protect)
 219         out << '(';
 220     function_->Output(out, Precedence(), protect ? CYNoFlags : flags);
 221     out << '(' << arguments_ << ')';
 222     if (protect)
 223         out << ')';
 224 }
 225
 226 namespace cy {
 227 namespace Syntax {
 228
 229 void Catch::Output(CYOutput &out) const {
 230     out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' ' << code_;
 231 }
 232
 233 } }
 234
 235 void CYComment::Output(CYOutput &out, CYFlags flags) const {
 236     out << '\r';
 237     out.out_ << value_;
 238     out.right_ = true;
 239     out << '\r';
 240 }
 241
 242 void CYCompound::Output(CYOutput &out, CYFlags flags) const {
 243     if (CYExpression *expression = expressions_)
 244         if (CYExpression *next = expression->next_) {
 245             expression->Output(out, CYLeft(flags));
 246             CYFlags center(CYCenter(flags));
 247             while (next != NULL) {
 248                 expression = next;
 249                 out << ',' << ' ';
 250                 next = expression->next_;
 251                 CYFlags right(next != NULL ? center : CYRight(flags));
 252                 expression->Output(out, right);
 253             }
 254         } else
 255             expression->Output(out, flags);
 256 }
 257
 258 void CYCondition::Output(CYOutput &out, CYFlags flags) const {
 259     test_->Output(out, Precedence() - 1, CYLeft(flags));
 260     out << ' ' << '?' << ' ';
 261     if (true_ != NULL)
 262         true_->Output(out, CYPA, CYNoFlags);
 263     out << ' ' << ':' << ' ';
 264     false_->Output(out, CYPA, CYRight(flags));
 265 }
 266
 267 void CYContinue::Output(CYOutput &out, CYFlags flags) const {
 268     out << "continue";
 269     if (label_ != NULL)
 270         out << ' ' << *label_;
 271     out << ';';
 272 }
 273
 274 void CYClause::Output(CYOutput &out) const {
 275     if (case_ != NULL)
 276         out << "case" << ' ' << *case_;
 277     else
 278         out << "default";
 279     out << ':' << '\n';
 280     if (statements_ != NULL)
 281         statements_->Multiple(out);
 282     out << next_;
 283 }
 284
 285 const char *CYDeclaration::ForEachIn() const {
 286     return identifier_->Word();
 287 }
 288
 289 void CYDeclaration::ForIn(CYOutput &out, CYFlags flags) const {
 290     out << "var";
 291     Output(out, CYRight(flags));
 292 }
 293
 294 void CYDeclaration::Output(CYOutput &out, CYFlags flags) const {
 295     out << *identifier_;
 296     //out.out_ << ':' << identifier_->usage_ << '#' << identifier_->offset_;
 297     if (initialiser_ != NULL) {
 298         out << ' ' << '=' << ' ';
 299         initialiser_->Output(out, CYPA, CYRight(flags));
 300     }
 301 }
 302
 303 void CYDeclarations::For(CYOutput &out) const {
 304     out << "var";
 305     Output(out, CYNoIn);
 306 }
 307
 308 void CYDeclarations::Output(CYOutput &out) const {
 309     Output(out, CYNoFlags);
 310 }
 311
 312 void CYDeclarations::Output(CYOutput &out, CYFlags flags) const {
 313     const CYDeclarations *declaration(this);
 314     bool first(true);
 315   output:
 316     CYDeclarations *next(declaration->next_);
 317     CYFlags jacks(first ? CYLeft(flags) : next == NULL ? CYRight(flags) : CYCenter(flags));
 318     first = false;
 319     declaration->declaration_->Output(out, jacks);
 320
 321     if (next != NULL) {
 322         out << ',' << ' ';
 323         declaration = next;
 324         goto output;
 325     }
 326 }
 327
 328 void CYDirectMember::Output(CYOutput &out, CYFlags flags) const {
 329     object_->Output(out, Precedence(), CYLeft(flags) | CYNoInteger);
 330     if (const char *word = property_->Word())
 331         out << '.' << word;
 332     else
 333         out << '[' << *property_ << ']';
 334 }
 335
 336 void CYDoWhile::Output(CYOutput &out, CYFlags flags) const {
 337     out << "do";
 338     code_->Single(out, CYCenter(flags));
 339     out << "while" << ' ' << '(' << *test_ << ')';
 340 }
 341
 342 void CYElement::Output(CYOutput &out) const {
 343     if (value_ != NULL)
 344         value_->Output(out, CYPA, CYNoFlags);
 345     if (next_ != NULL || value_ == NULL) {
 346         out << ',';
 347         if (next_ != NULL && next_->value_ != NULL)
 348             out << ' ';
 349     }
 350     if (next_ != NULL)
 351         next_->Output(out);
 352 }
 353
 354 void CYEmpty::Output(CYOutput &out, CYFlags flags) const {
 355     out.Terminate();
 356 }
 357
 358 void CYExpress::Output(CYOutput &out, CYFlags flags) const {
 359     expression_->Output(out, flags | CYNoBF);
 360     out << ';';
 361 }
 362
 363 void CYExpression::ClassName(CYOutput &out, bool object) const {
 364     Output(out, CYPA, CYNoFlags);
 365 }
 366
 367 const char *CYExpression::ForEachIn() const {
 368     return NULL;
 369 }
 370
 371 void CYExpression::For(CYOutput &out) const {
 372     Output(out, CYNoIn);
 373 }
 374
 375 void CYExpression::ForIn(CYOutput &out, CYFlags flags) const {
 376     Output(out, flags | CYNoRightHand);
 377 }
 378
 379 void CYExpression::Output(CYOutput &out) const {
 380     Output(out, CYNoFlags);
 381 }
 382
 383 void CYExpression::Output(CYOutput &out, unsigned precedence, CYFlags flags) const {
 384     if (precedence < Precedence() || (flags & CYNoRightHand) != 0 && RightHand())
 385         out << '(' << *this << ')';
 386     else
 387         Output(out, flags);
 388 }
 389
 390 void CYFinally::Output(CYOutput &out) const {
 391     out << ' ' << "finally" << ' ' << code_;
 392 }
 393
 394 void CYFor::Output(CYOutput &out, CYFlags flags) const {
 395     out << "for" << ' ' << '(';
 396     if (initialiser_ != NULL)
 397         initialiser_->For(out);
 398     out.Terminate();
 399     out << test_;
 400     out.Terminate();
 401     out << increment_;
 402     out << ')';
 403     code_->Single(out, CYRight(flags));
 404 }
 405
 406 void CYForEachIn::Output(CYOutput &out, CYFlags flags) const {
 407     out << "for" << ' ' << "each" << ' ' << '(';
 408     initialiser_->ForIn(out, CYNoIn);
 409     out << "in" << *set_ << ')';
 410     code_->Single(out, CYRight(flags));
 411 }
 412
 413 void CYForEachInComprehension::Output(CYOutput &out) const {
 414     out << "for" << ' ' << "each" << ' ' << '(' << *name_ << ' ' << "in" << ' ' << *set_ << ')' << next_;
 415 }
 416
 417 void CYForIn::Output(CYOutput &out, CYFlags flags) const {
 418     out << "for" << ' ' << '(';
 419     if (initialiser_ != NULL)
 420         initialiser_->ForIn(out, CYNoIn);
 421     out << "in" << *set_ << ')';
 422     code_->Single(out, CYRight(flags));
 423 }
 424
 425 void CYForInComprehension::Output(CYOutput &out) const {
 426     out << "for" << ' ' << '(' << *name_ << ' ' << "in" << ' ' << *set_ << ')';
 427 }
 428
 429 void CYFunction::Output(CYOutput &out, CYFlags flags) const {
 430     // XXX: one could imagine using + here to save a byte
 431     bool protect((flags & CYNoFunction) != 0);
 432     if (protect)
 433         out << '(';
 434     out << "function";
 435     if (name_ != NULL)
 436         out << ' ' << *name_;
 437     out << '(' << parameters_ << ')';
 438     out << ' ' << code_;
 439     if (protect)
 440         out << ')';
 441 }
 442
 443 void CYFunctionExpression::Output(CYOutput &out, CYFlags flags) const {
 444     CYFunction::Output(out, flags);
 445 }
 446
 447 void CYFunctionStatement::Output(CYOutput &out, CYFlags flags) const {
 448     CYFunction::Output(out, flags);
 449 }
 450
 451 void CYFunctionParameter::Output(CYOutput &out) const {
 452     out << *name_;
 453     if (next_ != NULL)
 454         out << ',' << ' ' << *next_;
 455 }
 456
 457 const char *CYIdentifier::Word() const {
 458     return replace_ == NULL || replace_ == this ? CYWord::Word() : replace_->Word();
 459 }
 460
 461 void CYIf::Output(CYOutput &out, CYFlags flags) const {
 462     bool protect(false);
 463     if (false_ == NULL && (flags & CYNoDangle) != 0) {
 464         protect = true;
 465         out << '{';
 466     }
 467
 468     out << "if" << ' ' << '(' << *test_ << ')';
 469
 470     CYFlags right(protect ? CYNoFlags : CYRight(flags));
 471
 472     CYFlags jacks(CYNoDangle);
 473     if (false_ == NULL)
 474         jacks |= right;
 475     else
 476         jacks |= protect ? CYNoFlags : CYCenter(flags);
 477
 478     true_->Single(out, jacks);
 479
 480     if (false_ != NULL) {
 481         out << "else";
 482         false_->Single(out, right);
 483     }
 484
 485     if (protect)
 486         out << '}';
 487 }
 488
 489 void CYIfComprehension::Output(CYOutput &out) const {
 490     out << "if" << ' ' << '(' << *test_ << ')' << next_;
 491 }
 492
 493 void CYIndirectMember::Output(CYOutput &out, CYFlags flags) const {
 494     object_->Output(out, Precedence(), CYLeft(flags));
 495     if (const char *word = property_->Word())
 496         out << "->" << word;
 497     else
 498         out << "->" << '[' << *property_ << ']';
 499 }
 500
 501 void CYInfix::Output(CYOutput &out, CYFlags flags) const {
 502     const char *name(Operator());
 503     bool protect((flags & CYNoIn) != 0 && strcmp(name, "in") == 0);
 504     if (protect)
 505         out << '(';
 506     CYFlags left(protect ? CYNoFlags : CYLeft(flags));
 507     lhs_->Output(out, Precedence(), left);
 508     out << ' ' << name << ' ';
 509     CYFlags right(protect ? CYNoFlags : CYRight(flags));
 510     rhs_->Output(out, Precedence() - 1, right);
 511     if (protect)
 512         out << ')';
 513 }
 514
 515 void CYLabel::Output(CYOutput &out, CYFlags flags) const {
 516     out << *name_ << ':' << ' ';
 517     statement_->Single(out, CYRight(flags));
 518 }
 519
 520 void CYLet::Output(CYOutput &out, CYFlags flags) const {
 521     out << "let" << ' ' << '(' << *declarations_ << ')' << ' ' << code_;
 522 }
 523
 524 namespace cy {
 525 namespace Syntax {
 526
 527 void New::Output(CYOutput &out, CYFlags flags) const {
 528     out << "new" << ' ';
 529     CYFlags jacks(CYNoCall | CYCenter(flags));
 530     constructor_->Output(out, Precedence(), jacks);
 531     if (arguments_ != NULL)
 532         out << '(' << *arguments_ << ')';
 533 }
 534
 535 } }
 536
 537 void CYNull::Output(CYOutput &out, CYFlags flags) const {
 538     CYWord::Output(out);
 539 }
 540
 541 void CYNumber::Output(CYOutput &out, CYFlags flags) const {
 542     std::ostringstream str;
 543     CYNumerify(str, Value());
 544     std::string value(str.str());
 545     out << value.c_str();
 546     // XXX: this should probably also handle hex conversions and exponents
 547     if ((flags & CYNoInteger) != 0 && value.find('.') == std::string::npos)
 548         out << '.';
 549 }
 550
 551 void CYNumber::PropertyName(CYOutput &out) const {
 552     Output(out, CYNoFlags);
 553 }
 554
 555 void CYObject::Output(CYOutput &out, CYFlags flags) const {
 556     bool protect((flags & CYNoBrace) != 0);
 557     if (protect)
 558         out << '(';
 559     out << '{' << '\n';
 560     ++out.indent_;
 561     out << properties_;
 562     --out.indent_;
 563     out << '\t' << '}';
 564     if (protect)
 565         out << ')';
 566 }
 567
 568 void CYOptionalFunctionParameter::Output(CYOutput &out) const {
 569     out << *name_ << '=';
 570     initializer_->Output(out, CYPA, CYNoFlags);
 571     if (next_ != NULL)
 572         out << ',' << ' ' << *next_;
 573 }
 574
 575 void CYPostfix::Output(CYOutput &out, CYFlags flags) const {
 576     lhs_->Output(out, Precedence(), CYLeft(flags));
 577     out << Operator();
 578 }
 579
 580 void CYPrefix::Output(CYOutput &out, CYFlags flags) const {
 581     const char *name(Operator());
 582     out << name;
 583     if (Alphabetic())
 584         out << ' ';
 585     rhs_->Output(out, Precedence(), CYRight(flags));
 586 }
 587
 588 void CYProgram::Output(CYOutput &out) const {
 589     if (statements_ != NULL)
 590         statements_->Multiple(out);
 591 }
 592
 593 void CYProperty::Output(CYOutput &out) const {
 594     out << '\t';
 595     name_->PropertyName(out);
 596     out << ':' << ' ';
 597     value_->Output(out, CYPA, CYNoFlags);
 598     if (next_ != NULL)
 599         out << ',' << '\n' << *next_;
 600     else
 601         out << '\n';
 602 }
 603
 604 void CYRegEx::Output(CYOutput &out, CYFlags flags) const {
 605     out << Value();
 606 }
 607
 608 void CYReturn::Output(CYOutput &out, CYFlags flags) const {
 609     out << "return";
 610     if (value_ != NULL)
 611         out << ' ' << *value_;
 612     out << ';';
 613 }
 614
 615 void CYRubyBlock::Output(CYOutput &out, CYFlags flags) const {
 616     call_->Output(out, CYLeft(flags));
 617     out << ' ';
 618     proc_->Output(out, CYRight(flags));
 619 }
 620
 621 void CYRubyProc::Output(CYOutput &out, CYFlags flags) const {
 622     // XXX: this is not outputting the parameters
 623     out << code_;
 624 }
 625
 626 void CYStatement::Multiple(CYOutput &out, CYFlags flags) const {
 627     bool first(true);
 628     for (const CYStatement *next(this); next != NULL; next = next->next_) {
 629         bool last(next->next_ == NULL);
 630         CYFlags jacks(first ? last ? flags : CYLeft(flags) : last ? CYCenter(flags) : CYRight(flags));
 631         first = false;
 632         out << '\t';
 633         next->Output(out, jacks);
 634         out << '\n';
 635     }
 636 }
 637
 638 void CYStatement::Single(CYOutput &out, CYFlags flags) const {
 639     _assert(next_ == NULL);
 640     out << '\n';
 641     ++out.indent_;
 642     out << '\t';
 643     Output(out, flags);
 644     out << '\n';
 645     --out.indent_;
 646 }
 647
 648 void CYString::Output(CYOutput &out, CYFlags flags) const {
 649     std::ostringstream str;
 650     CYStringify(str, value_, size_);
 651     out << str.str().c_str();
 652 }
 653
 654 void CYString::PropertyName(CYOutput &out) const {
 655     if (const char *word = Word())
 656         out << word;
 657     else
 658         out << *this;
 659 }
 660
 661 static const char *Reserved_[] = {
 662     "false", "null", "true",
 663
 664     "break", "case", "catch", "continue", "default",
 665     "delete", "do", "else", "finally", "for", "function",
 666     "if", "in", "instanceof", "new", "return", "switch",
 667     "this", "throw", "try", "typeof", "var", "void",
 668     "while", "with",
 669
 670     "debugger", "const",
 671
 672     "class", "enum", "export", "extends", "import", "super",
 673
 674     "abstract", "boolean", "byte", "char", "double", "final",
 675     "float", "goto", "int", "long", "native", "short",
 676     "synchronized", "throws", "transient", "volatile",
 677
 678     "let", "yield",
 679
 680     NULL
 681 };
 682
 683 const char *CYString::Word() const {
 684     if (size_ == 0 || !WordStartRange_[value_[0]])
 685         return NULL;
 686     for (size_t i(1); i != size_; ++i)
 687         if (!WordEndRange_[value_[i]])
 688             return NULL;
 689     const char *value(Value());
 690     for (const char **reserved(Reserved_); *reserved != NULL; ++reserved)
 691         if (strcmp(*reserved, value) == 0)
 692             return NULL;
 693     return value;
 694 }
 695
 696 void CYSwitch::Output(CYOutput &out, CYFlags flags) const {
 697     out << "switch" << ' ' << '(' << *value_ << ')' << ' ' << '{';
 698     out << clauses_;
 699     out << '}';
 700 }
 701
 702 void CYThis::Output(CYOutput &out, CYFlags flags) const {
 703     CYWord::Output(out);
 704 }
 705
 706 namespace cy {
 707 namespace Syntax {
 708
 709 void Throw::Output(CYOutput &out, CYFlags flags) const {
 710     out << "throw";
 711     if (value_ != NULL)
 712         out << ' ' << *value_;
 713     out << ';';
 714 }
 715
 716 void Try::Output(CYOutput &out, CYFlags flags) const {
 717     out << "try" << ' ' << code_ << catch_ << finally_;
 718 }
 719
 720 } }
 721
 722 void CYVar::Output(CYOutput &out, CYFlags flags) const {
 723     out << "var";
 724     declarations_->Output(out, flags);
 725     out << ';';
 726 }
 727
 728 void CYVariable::Output(CYOutput &out, CYFlags flags) const {
 729     out << *name_;
 730 }
 731
 732 void CYWhile::Output(CYOutput &out, CYFlags flags) const {
 733     out << "while" << '(' << *test_ << ')';
 734     code_->Single(out, CYRight(flags));
 735 }
 736
 737 void CYWith::Output(CYOutput &out, CYFlags flags) const {
 738     out << "with" << '(' << *scope_ << ')';
 739     code_->Single(out, CYRight(flags));
 740 }
 741
 742 void CYWord::ClassName(CYOutput &out, bool object) const {
 743     if (object)
 744         out << "objc_getClass(";
 745     out << '"' << Word() << '"';
 746     if (object)
 747         out << ')';
 748 }
 749
 750 void CYWord::Output(CYOutput &out) const {
 751     out << Word();
 752     if (out.options_.verbose_)
 753         out.out_ << '@' << this;
 754 }
 755
 756 void CYWord::PropertyName(CYOutput &out) const {
 757     Output(out);
 758 }
 759
 760 const char *CYWord::Word() const {
 761     return word_;
 762 }