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