Output.cpp

   1 #include "Parser.hpp"
   2
   3 #include <iostream>
   4 #include <iomanip>
   5
   6 #include <objc/runtime.h>
   7 #include <sstream>
   8
   9 _finline CYFlags operator ~(CYFlags rhs) {
  10     return static_cast<CYFlags>(~static_cast<unsigned>(rhs));
  11 }
  12
  13 _finline CYFlags operator &(CYFlags lhs, CYFlags rhs) {
  14     return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs));
  15 }
  16
  17 _finline CYFlags operator |(CYFlags lhs, CYFlags rhs) {
  18     return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs));
  19 }
  20
  21 _finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) {
  22     return lhs = lhs | rhs;
  23 }
  24
  25 _finline CYFlags CYLeft(CYFlags flags) {
  26     return flags & ~CYNoTrailer;
  27 }
  28
  29 _finline CYFlags CYCenter(CYFlags flags) {
  30     return flags & CYNoIn;
  31 }
  32
  33 _finline CYFlags CYRight(CYFlags flags) {
  34     return flags & (CYNoIn | CYNoTrailer);
  35 }
  36
  37 bool CYFalse::Value() const {
  38     return false;
  39 }
  40
  41 bool CYTrue::Value() const {
  42     return true;
  43 }
  44
  45 #define CYPA 16
  46
  47 void CYAddressOf::Output(std::ostream &out, CYFlags flags) const {
  48     rhs_->Output(out, 1, CYLeft(flags));
  49     out << ".$cya()";
  50 }
  51
  52 void CYArgument::Output(std::ostream &out) const {
  53     if (name_ != NULL) {
  54         out << *name_;
  55         if (value_ != NULL)
  56             out << ":";
  57     }
  58     if (value_ != NULL)
  59         value_->Output(out, CYPA, CYNoFlags);
  60     if (next_ != NULL) {
  61         if (next_->name_ == NULL)
  62             out << ',';
  63         else
  64             out << ' ';
  65         next_->Output(out);
  66     }
  67 }
  68
  69 void CYArray::Output(std::ostream &out, CYFlags flags) const {
  70     out << '[';
  71     if (elements_ != NULL)
  72         elements_->Output(out);
  73     out << ']';
  74 }
  75
  76 void CYArrayComprehension::Output(std::ostream &out, CYFlags flags) const {
  77     // XXX: I don't necc. need the ()s
  78     out << "(function($cyv";
  79     for (CYComprehension *comprehension(comprehensions_); comprehension != NULL; comprehension = comprehension->next_)
  80         if (const char *name = comprehension->Name())
  81             out << ',' << name;
  82     out << "){";
  83     out << "$cyt=[];";
  84     comprehensions_->Output(out);
  85     out << "$cyt.push(";
  86     expression_->Output(out, CYPA, CYNoFlags);
  87     out << ");";
  88     for (CYComprehension *comprehension(comprehensions_); comprehension != NULL; comprehension = comprehension->next_)
  89         comprehension->End_(out);
  90     out << "return $cyt;";
  91     out << "}())";
  92 }
  93
  94 void CYAssignment::Output(std::ostream &out, CYFlags flags) const {
  95     lhs_->Output(out, Precedence() - 1, CYLeft(flags));
  96     out << Operator();
  97     rhs_->Output(out, Precedence(), CYRight(flags));
  98 }
  99
 100 void CYBlock::Output(std::ostream &out) const {
 101     for (CYSource *statement(statements_); statement != NULL; statement = statement->next_)
 102         statement->Output(out);
 103 }
 104
 105 void CYBoolean::Output(std::ostream &out, CYFlags flags) const {
 106     if ((flags & CYNoLeader) != 0)
 107         out << ' ';
 108     out << (Value() ? "true" : "false");
 109     if ((flags & CYNoTrailer) != 0)
 110         out << ' ';
 111 }
 112
 113 void CYBreak::Output(std::ostream &out) const {
 114     out << "break";
 115     if (label_ != NULL)
 116         out << ' ' << *label_;
 117     out << ';';
 118 }
 119
 120 void CYCall::Output(std::ostream &out, CYFlags flags) const {
 121     function_->Output(out, Precedence(), CYLeft(flags));
 122     out << '(';
 123     if (arguments_ != NULL)
 124         arguments_->Output(out);
 125     out << ')';
 126 }
 127
 128 void CYCatch::Output(std::ostream &out) const {
 129     out << "catch(" << *name_ << ')';
 130     code_->Output(out, true);
 131 }
 132
 133 void CYCategory::Output(std::ostream &out) const {
 134     out << "(function($cys,$cyp,$cyc,$cyn,$cyt){";
 135     out << "$cyp=object_getClass($cys);";
 136     out << "$cyc=$cys;";
 137     if (messages_ != NULL)
 138         messages_->Output(out, true);
 139     out << "})(";
 140     name_->ClassName(out, true);
 141     out << ");";
 142 }
 143
 144 void CYClass::Output(std::ostream &out) const {
 145     Output(out, CYNoBF);
 146     out << ";";
 147 }
 148
 149 void CYClass::Output(std::ostream &out, CYFlags flags) const {
 150     // XXX: I don't necc. need the ()s
 151     out << "(function($cys,$cyp,$cyc,$cyn,$cyt,$cym){";
 152     out << "$cyp=object_getClass($cys);";
 153     out << "$cyc=objc_allocateClassPair($cys,";
 154     if (name_ != NULL)
 155         name_->ClassName(out, false);
 156     else
 157         out << "$cyq(\"CY$\")";
 158     out << ",0);";
 159     out << "$cym=object_getClass($cyc);";
 160     if (fields_ != NULL)
 161         fields_->Output(out);
 162     if (messages_ != NULL)
 163         messages_->Output(out, false);
 164     out << "objc_registerClassPair($cyc);";
 165     out << "return $cyc;";
 166     out << "}(";
 167     if (super_ != NULL)
 168         super_->Output(out, CYPA, CYNoFlags);
 169     else
 170         out << "null";
 171     out << "))";
 172 }
 173
 174 void CYCompound::Output(std::ostream &out, CYFlags flags) const {
 175     if (CYExpression *expression = expressions_)
 176         if (CYExpression *next = expression->next_) {
 177             expression->Output(out, CYLeft(flags));
 178             CYFlags center(CYCenter(flags));
 179             while (next != NULL) {
 180                 expression = next;
 181                 out << ',';
 182                 next = expression->next_;
 183                 CYFlags right(next != NULL ? center : CYRight(flags));
 184                 expression->Output(out, right);
 185             }
 186         } else
 187             expression->Output(out, flags);
 188 }
 189
 190 void CYComprehension::Output(std::ostream &out) const {
 191     Begin_(out);
 192     if (next_ != NULL)
 193         next_->Output(out);
 194 }
 195
 196 void CYCondition::Output(std::ostream &out, CYFlags flags) const {
 197     test_->Output(out, Precedence() - 1, CYLeft(flags));
 198     out << '?';
 199     if (true_ != NULL)
 200         true_->Output(out, CYPA, CYNoFlags);
 201     out << ':';
 202     false_->Output(out, CYPA, CYRight(flags));
 203 }
 204
 205 void CYContinue::Output(std::ostream &out) const {
 206     out << "continue";
 207     if (label_ != NULL)
 208         out << ' ' << *label_;
 209     out << ';';
 210 }
 211
 212 void CYClause::Output(std::ostream &out) const {
 213     if (case_ != NULL) {
 214         out << "case";
 215         case_->Output(out, CYNoFlags);
 216     } else
 217         out << "default";
 218     out << ':';
 219     if (code_ != NULL)
 220         code_->Output(out, false);
 221     out << *next_;
 222 }
 223
 224 void CYDeclaration::Part(std::ostream &out, CYFlags flags) const {
 225     if ((flags & CYNoLeader) != 0)
 226         out << ' ';
 227     out << "var ";
 228     Output(out, CYRight(flags));
 229 }
 230
 231 void CYDeclaration::ForEachIn(std::ostream &out) const {
 232     out << *identifier_;
 233 }
 234
 235 void CYDeclaration::Output(std::ostream &out, CYFlags flags) const {
 236     out << *identifier_;
 237     if (initialiser_ != NULL) {
 238         out << '=';
 239         initialiser_->Output(out, CYPA, CYRight(flags));
 240     } else if ((flags & CYNoTrailer) != 0)
 241         out << ' ';
 242 }
 243
 244 void CYDeclarations::Part(std::ostream &out, CYFlags flags) const {
 245     if ((flags & CYNoLeader) != 0)
 246         out << ' ';
 247     out << "var ";
 248
 249     const CYDeclarations *declaration(this);
 250   output:
 251     CYDeclarations *next(declaration->next_);
 252     CYFlags right(next == NULL ? CYRight(flags) : CYCenter(flags));
 253     declaration->declaration_->Output(out, right);
 254
 255     if (next != NULL) {
 256         out << ',';
 257         declaration = next;
 258         goto output;
 259     }
 260 }
 261
 262 void CYDeclarations::Output(std::ostream &out) const {
 263     Part(out, CYNoFlags);
 264     out << ';';
 265 }
 266
 267 void CYDirectMember::Output(std::ostream &out, CYFlags flags) const {
 268     object_->Output(out, Precedence(), CYLeft(flags));
 269     if (const char *word = property_->Word())
 270         out << '.' << word;
 271     else {
 272         out << '[';
 273         property_->Output(out, CYNoFlags);
 274         out << ']';
 275     }
 276 }
 277
 278 void CYDoWhile::Output(std::ostream &out) const {
 279     // XXX: extra space character!
 280     out << "do ";
 281     code_->Output(out, false);
 282     out << "while(";
 283     test_->Output(out, CYNoFlags);
 284     out << ')';
 285 }
 286
 287 void CYElement::Output(std::ostream &out) const {
 288     if (value_ != NULL)
 289         value_->Output(out, CYPA, CYNoFlags);
 290     if (next_ != NULL || value_ == NULL)
 291         out << ',';
 292     if (next_ != NULL)
 293         next_->Output(out);
 294 }
 295
 296 void CYEmpty::Output(std::ostream &out) const {
 297     out << ';';
 298 }
 299
 300 void CYEmpty::Output(std::ostream &out, bool block) const {
 301     if (next_ != NULL)
 302         CYSource::Output(out, block);
 303     else
 304         out << "{}";
 305 }
 306
 307 void CYExpress::Output(std::ostream &out) const {
 308     expression_->Output(out, CYNoBF);
 309     out << ';';
 310 }
 311
 312 void CYExpression::ClassName(std::ostream &out, bool object) const {
 313     Output(out, CYPA, CYNoFlags);
 314 }
 315
 316 void CYExpression::ForEachIn(std::ostream &out) const {
 317     // XXX: this should handle LeftHandSideExpression
 318     Output(out, CYPA, CYNoFlags);
 319 }
 320
 321 void CYExpression::Part(std::ostream &out, CYFlags flags) const {
 322     // XXX: this should handle LeftHandSideExpression
 323     Output(out, flags);
 324 }
 325
 326 void CYExpression::Output(std::ostream &out, unsigned precedence, CYFlags flags) const {
 327     if (precedence < Precedence()) {
 328         out << '(';
 329         Output(out, CYNoFlags);
 330         out << ')';
 331     } else
 332         Output(out, flags);
 333 }
 334
 335 void CYField::Output(std::ostream &out) const {
 336     // XXX: implement!
 337 }
 338
 339 void CYFor::Output(std::ostream &out) const {
 340     out << "for(";
 341     if (initialiser_ != NULL)
 342         initialiser_->Part(out, CYNoFlags);
 343     out << ';';
 344     if (test_ != NULL)
 345         test_->Output(out, CYNoFlags);
 346     out << ';';
 347     if (increment_ != NULL)
 348         increment_->Output(out, CYNoFlags);
 349     out << ')';
 350     code_->Output(out, false);
 351 }
 352
 353 void CYForEachIn::Output(std::ostream &out) const {
 354     const char *name(initialiser_->ForEachIn());
 355
 356     if (name != NULL) {
 357         out << '{';
 358         out << "var " << name << ';';
 359     }
 360
 361     out << "(function($cys,$cyt){";
 362     out << "$cys=";
 363     set_->Output(out, CYPA, CYNoFlags);
 364     out << ";";
 365
 366     out << "for($cyt in $cys){";
 367
 368     initialiser_->ForEachIn(out);
 369     out << "=$cys[$cyt];";
 370
 371     code_->Show(out);
 372
 373     out << "}}());";
 374
 375     if (name != NULL)
 376         out << '}';
 377 }
 378
 379 void CYForEachInComprehension::Begin_(std::ostream &out) const {
 380     out << "(function($cys){";
 381     out << "$cys=";
 382     set_->Output(out, CYPA, CYNoFlags);
 383     out << ";";
 384
 385     out << "for(" << *name_ << " in $cys){";
 386     out << *name_ << "=$cys[" << *name_ << "];";
 387 }
 388
 389 void CYForEachInComprehension::End_(std::ostream &out) const {
 390     out << "}}());";
 391 }
 392
 393 void CYForIn::Output(std::ostream &out) const {
 394     out << "for(";
 395     initialiser_->Part(out, CYNoIn | CYNoTrailer);
 396     out << "in";
 397     set_->Output(out, CYNoLeader);
 398     out << ')';
 399     code_->Output(out, false);
 400 }
 401
 402 void CYForInComprehension::Begin_(std::ostream &out) const {
 403     out << "for(" << *name_ << " in";
 404     set_->Output(out, CYNoLeader);
 405     out << ')';
 406 }
 407
 408 void CYFunction::Output(std::ostream &out) const {
 409     CYLambda::Output(out, CYNoFlags);
 410 }
 411
 412 void CYFunctionParameter::Output(std::ostream &out) const {
 413     out << *name_;
 414     if (next_ != NULL) {
 415         out << ',';
 416         out << *next_;
 417     }
 418 }
 419
 420 void CYIf::Output(std::ostream &out) const {
 421     out << "if(";
 422     test_->Output(out, CYNoFlags);
 423     out << ')';
 424     true_->Output(out, true);
 425     if (false_ != NULL) {
 426         out << "else ";
 427         false_->Output(out, false);
 428     }
 429 }
 430
 431 void CYIfComprehension::Begin_(std::ostream &out) const {
 432     out << "if(";
 433     test_->Output(out, CYNoFlags);
 434     out << ')';
 435 }
 436
 437 void CYIndirect::Output(std::ostream &out, CYFlags flags) const {
 438     rhs_->Output(out, 1, CYLeft(flags));
 439     out << ".$cyi";
 440 }
 441
 442 void CYIndirectMember::Output(std::ostream &out, CYFlags flags) const {
 443     object_->Output(out, Precedence(), CYLeft(flags));
 444     out << ".$cyi";
 445     if (const char *word = property_->Word())
 446         out << '.' << word;
 447     else {
 448         out << '[';
 449         property_->Output(out, CYNoFlags);
 450         out << ']';
 451     }
 452 }
 453
 454 void CYInfix::Output(std::ostream &out, CYFlags flags) const {
 455     const char *name(Operator());
 456     bool protect((flags & CYNoIn) != 0 && strcmp(name, "in"));
 457     if (protect)
 458         out << '(';
 459     bool alphabetic(Alphabetic());
 460     CYFlags left(protect ? CYNoFlags : CYLeft(flags));
 461     if (alphabetic)
 462         left |= CYNoTrailer;
 463     lhs_->Output(out, Precedence(), left);
 464     out << name;
 465     CYFlags right(protect ? CYNoFlags : CYRight(flags));
 466     if (alphabetic)
 467         right |= CYNoLeader;
 468     if (strcmp(name, "-") == 0)
 469         right |= CYNoHyphen;
 470     rhs_->Output(out, Precedence() - 1, right);
 471     if (protect)
 472         out << ')';
 473 }
 474
 475 void CYLambda::Output(std::ostream &out, CYFlags flags) const {
 476     bool protect((flags & CYNoFunction) != 0);
 477     if (protect)
 478         out << '(';
 479     else if ((flags & CYNoLeader) != 0)
 480         out << ' ';
 481     out << "function";
 482     if (name_ != NULL)
 483         out << ' ' << *name_;
 484     out << '(';
 485     if (parameters_ != NULL)
 486         out << *parameters_;
 487     out << "){";
 488     if (body_ != NULL)
 489         body_->Show(out);
 490     out << '}';
 491     if (protect)
 492         out << ')';
 493 }
 494
 495 void CYMessage::Output(std::ostream &out, bool replace) const {
 496     if (next_ != NULL)
 497         next_->Output(out, replace);
 498     out << "$cyn=new Selector(\"";
 499     for (CYMessageParameter *parameter(parameter_); parameter != NULL; parameter = parameter->next_)
 500         if (parameter->tag_ != NULL) {
 501             out << *parameter->tag_;
 502             if (parameter->name_ != NULL)
 503                 out << ':';
 504         }
 505     out << "\");";
 506     out << "$cyt=$cyn.type($cy" << (instance_ ? 's' : 'p') << ");";
 507     out << "class_" << (replace ? "replace" : "add") << "Method($cy" << (instance_ ? 'c' : 'm') << ",$cyn,";
 508     out << "new Functor(function(self,_cmd";
 509     for (CYMessageParameter *parameter(parameter_); parameter != NULL; parameter = parameter->next_)
 510         if (parameter->name_ != NULL)
 511             out << ',' << *parameter->name_;
 512     out << "){return function(){";
 513     if (body_ != NULL)
 514         body_->Show(out);
 515     out << "}.call(self);},$cyt),$cyt);";
 516 }
 517
 518 void CYNew::Output(std::ostream &out, CYFlags flags) const {
 519     if ((flags & CYNoLeader) != 0)
 520         out << ' ';
 521     out << "new";
 522     constructor_->Output(out, Precedence(), CYCenter(flags) | CYNoLeader);
 523     out << '(';
 524     if (arguments_ != NULL)
 525         arguments_->Output(out);
 526     out << ')';
 527 }
 528
 529 void CYNull::Output(std::ostream &out, CYFlags flags) const {
 530     if ((flags & CYNoLeader) != 0)
 531         out << ' ';
 532     CYWord::Output(out);
 533     if ((flags & CYNoTrailer) != 0)
 534         out << ' ';
 535 }
 536
 537 void CYNumber::Output(std::ostream &out, CYFlags flags) const {
 538     double value(Value());
 539     if ((flags & CYNoLeader) != 0 || value < 0 && (flags & CYNoHyphen) != 0)
 540         out << ' ';
 541     // XXX: decide on correct precision
 542     out << std::setprecision(9) << value;
 543     if ((flags & CYNoTrailer) != 0)
 544         out << ' ';
 545 }
 546
 547 void CYNumber::PropertyName(std::ostream &out) const {
 548     Output(out);
 549 }
 550
 551 void CYObject::Output(std::ostream &out, CYFlags flags) const {
 552     bool protect((flags & CYNoBrace) != 0);
 553     if (protect)
 554         out << '(';
 555     out << '{';
 556     if (property_ != NULL)
 557         property_->Output(out);
 558     out << '}';
 559     if (protect)
 560         out << ')';
 561 }
 562
 563 void CYPostfix::Output(std::ostream &out, CYFlags flags) const {
 564     lhs_->Output(out, Precedence(), CYLeft(flags));
 565     out << Operator();
 566 }
 567
 568 void CYPrefix::Output(std::ostream &out, CYFlags flags) const {
 569     const char *name(Operator());
 570     bool alphabetic(Alphabetic());
 571     if (alphabetic && (flags & CYNoLeader) != 0 || name[0] == '-' && (flags & CYNoHyphen) != 0)
 572         out << ' ';
 573     out << name;
 574     CYFlags right(CYRight(flags));
 575     if (alphabetic)
 576         right |= CYNoLeader;
 577     rhs_->Output(out, Precedence(), right);
 578 }
 579
 580 void CYProperty::Output(std::ostream &out) const {
 581     name_->PropertyName(out);
 582     out << ':';
 583     value_->Output(out, CYPA, CYNoFlags);
 584     if (next_ != NULL) {
 585         out << ',';
 586         next_->Output(out);
 587     }
 588 }
 589
 590 void CYReturn::Output(std::ostream &out) const {
 591     out << "return";
 592     if (value_ != NULL)
 593         value_->Output(out, CYNoLeader);
 594     out << ';';
 595 }
 596
 597 void CYSelector::Output(std::ostream &out, CYFlags flags) const {
 598     if ((flags & CYNoLeader) != 0)
 599         out << ' ';
 600     out << "new Selector(\"";
 601     if (name_ != NULL)
 602         name_->Output(out);
 603     out << "\")";
 604 }
 605
 606 void CYSelectorPart::Output(std::ostream &out) const {
 607     if (name_ != NULL)
 608         out << *name_;
 609     if (value_)
 610         out << ':';
 611     if (next_ != NULL)
 612         next_->Output(out);
 613 }
 614
 615 void CYSend::Output(std::ostream &out, CYFlags flags) const {
 616     if ((flags & CYNoLeader) != 0)
 617         out << ' ';
 618     out << "objc_msgSend(";
 619     self_->Output(out, CYPA, CYNoFlags);
 620     out << ",";
 621     std::ostringstream name;
 622     for (CYArgument *argument(arguments_); argument != NULL; argument = argument->next_)
 623         if (argument->name_ != NULL) {
 624             name << *argument->name_;
 625             if (argument->value_ != NULL)
 626                 name << ':';
 627         }
 628     out << reinterpret_cast<void *>(sel_registerName(name.str().c_str()));
 629     for (CYArgument *argument(arguments_); argument != NULL; argument = argument->next_)
 630         if (argument->value_ != NULL) {
 631             out << ",";
 632             argument->value_->Output(out, CYPA, CYNoFlags);
 633         }
 634     out << ')';
 635 }
 636
 637 void CYSource::Show(std::ostream &out) const {
 638     for (const CYSource *next(this); next != NULL; next = next->next_)
 639         next->Output_(out);
 640 }
 641
 642 void CYSource::Output(std::ostream &out, bool block) const {
 643     if (!block && !IsBlock())
 644         Output(out);
 645     else {
 646         out << '{';
 647         Show(out);
 648         out << '}';
 649     }
 650 }
 651
 652 void CYSource::Output_(std::ostream &out) const {
 653     Output(out);
 654 }
 655
 656 void CYStatement::Output_(std::ostream &out) const {
 657     for (CYLabel *label(labels_); label != NULL; label = label->next_)
 658         out << *label->name_ << ':';
 659     Output(out);
 660 }
 661
 662 void CYString::Output(std::ostream &out, CYFlags flags) const {
 663     unsigned quot(0), apos(0);
 664     for (const char *value(value_), *end(value_ + size_); value != end; ++value)
 665         if (*value == '"')
 666             ++quot;
 667         else if (*value == '\'')
 668             ++apos;
 669
 670     bool single(quot > apos);
 671
 672     out << (single ? '\'' : '"');
 673     for (const char *value(value_), *end(value_ + size_); value != end; ++value)
 674         switch (*value) {
 675             case '\\': out << "\\\\"; break;
 676             case '\b': out << "\\b"; break;
 677             case '\f': out << "\\f"; break;
 678             case '\n': out << "\\n"; break;
 679             case '\r': out << "\\r"; break;
 680             case '\t': out << "\\t"; break;
 681             case '\v': out << "\\v"; break;
 682
 683             case '"':
 684                 if (!single)
 685                     out << "\\\"";
 686                 else goto simple;
 687             break;
 688
 689             case '\'':
 690                 if (single)
 691                     out << "\\'";
 692                 else goto simple;
 693             break;
 694
 695             default:
 696                 if (*value < 0x20 || *value >= 0x7f)
 697                     out << "\\x" << std::setbase(16) << std::setw(2) << std::setfill('0') << unsigned(*value);
 698                 else simple:
 699                     out << *value;
 700         }
 701     out << (single ? '\'' : '"');
 702 }
 703
 704 void CYString::PropertyName(std::ostream &out) const {
 705     if (const char *word = Word())
 706         out << word;
 707     else
 708         Output(out);
 709 }
 710
 711 void CYSwitch::Output(std::ostream &out) const {
 712     out << "switch(";
 713     value_->Output(out, CYNoFlags);
 714     out << "){";
 715     if (clauses_ != NULL)
 716         out << *clauses_;
 717     out << '}';
 718 }
 719
 720 void CYThis::Output(std::ostream &out, CYFlags flags) const {
 721     if ((flags & CYNoLeader) != 0)
 722         out << ' ';
 723     CYWord::Output(out);
 724     if ((flags & CYNoTrailer) != 0)
 725         out << ' ';
 726 }
 727
 728 void CYThrow::Output(std::ostream &out) const {
 729     out << "throw";
 730     if (value_ != NULL)
 731         value_->Output(out, CYNoLeader);
 732     out << ';';
 733 }
 734
 735 void CYTry::Output(std::ostream &out) const {
 736     out << "try";
 737     try_->Output(out, true);
 738     if (catch_ != NULL)
 739         catch_->Output(out);
 740     if (finally_ != NULL) {
 741         out << "finally";
 742         finally_->Output(out, true);
 743     }
 744 }
 745
 746 void CYVariable::Output(std::ostream &out, CYFlags flags) const {
 747     if ((flags & CYNoLeader) != 0)
 748         out << ' ';
 749     out << *name_;
 750     if ((flags & CYNoTrailer) != 0)
 751         out << ' ';
 752 }
 753
 754 void CYWhile::Output(std::ostream &out) const {
 755     out << "while(";
 756     test_->Output(out, CYNoFlags);
 757     out << ')';
 758     code_->Output(out, false);
 759 }
 760
 761 void CYWith::Output(std::ostream &out) const {
 762     out << "with(";
 763     scope_->Output(out, CYNoFlags);
 764     out << ')';
 765     code_->Output(out, false);
 766 }
 767
 768 void CYWord::ClassName(std::ostream &out, bool object) const {
 769     if (object)
 770         out << "objc_getClass(";
 771     out << '"' << Value() << '"';
 772     if (object)
 773         out << ')';
 774 }
 775
 776 void CYWord::Output(std::ostream &out) const {
 777     out << Value();
 778 }
 779
 780 void CYWord::PropertyName(std::ostream &out) const {
 781     Output(out);
 782 }