Replace.cpp

   1 /* Cycript - Optimizing JavaScript Compiler/Runtime
   2  * Copyright (C) 2009-2010  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Lesser General Public License, Version 3 {{{ */
   6 /*
   7  * Cycript is free software: you can redistribute it and/or modify it under
   8  * the terms of the GNU Lesser General Public License as published by the
   9  * Free Software Foundation, either version 3 of the License, or (at your
  10  * option) any later version.
  11  *
  12  * Cycript is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  15  * License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public License
  18  * along with Cycript.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #include "Parser.hpp"
  23 #include "Replace.hpp"
  24
  25 #include <iomanip>
  26
  27 CYExpression *CYAdd::Replace(CYContext &context) {
  28     CYInfix::Replace(context);
  29
  30     CYExpression *lhp(lhs_->Primitive(context));
  31     CYExpression *rhp(rhs_->Primitive(context));
  32
  33     CYString *lhs(dynamic_cast<CYString *>(lhp));
  34     CYString *rhs(dynamic_cast<CYString *>(rhp));
  35
  36     if (lhs != NULL || rhs != NULL) {
  37         if (lhs == NULL) {
  38             lhs = lhp->String(context);
  39             if (lhs == NULL)
  40                 return this;
  41         } else if (rhs == NULL) {
  42             rhs = rhp->String(context);
  43             if (rhs == NULL)
  44                 return this;
  45         }
  46
  47         return lhs->Concat(context, rhs);
  48     }
  49
  50     if (CYNumber *lhn = lhp->Number(context))
  51         if (CYNumber *rhn = rhp->Number(context))
  52             return $D(lhn->Value() + rhn->Value());
  53
  54     return this;
  55 }
  56
  57 CYExpression *CYAddressOf::Replace(CYContext &context) {
  58     CYPrefix::Replace(context);
  59     return $C0($M(rhs_, $S("$cya")));
  60 }
  61
  62 void CYArgument::Replace(CYContext &context) { $T()
  63     context.Replace(value_);
  64     next_->Replace(context);
  65 }
  66
  67 CYExpression *CYArray::Replace(CYContext &context) {
  68     elements_->Replace(context);
  69     return this;
  70 }
  71
  72 CYExpression *CYArrayComprehension::Replace(CYContext &context) {
  73     CYVariable *cyv($V("$cyv"));
  74
  75     return $C0($F(NULL, $P1("$cyv", comprehensions_->Parameters(context)), $$->*
  76         $E($ CYAssign(cyv, $ CYArray()))->*
  77         comprehensions_->Replace(context, $E($C1($M(cyv, $S("push")), expression_)))->*
  78         $ CYReturn(cyv)
  79     ));
  80 }
  81
  82 CYExpression *CYAssignment::Replace(CYContext &context) {
  83     context.Replace(lhs_);
  84     context.Replace(rhs_);
  85     return this;
  86 }
  87
  88 CYStatement *CYBlock::Replace(CYContext &context) {
  89     statements_ = statements_->ReplaceAll(context);
  90     if (statements_ == NULL)
  91         return $ CYEmpty();
  92     return this;
  93 }
  94
  95 CYStatement *CYBreak::Replace(CYContext &context) {
  96     return this;
  97 }
  98
  99 CYExpression *CYCall::AddArgument(CYContext &context, CYExpression *value) {
 100     CYArgument **argument(&arguments_);
 101     while (*argument != NULL)
 102         argument = &(*argument)->next_;
 103     *argument = $ CYArgument(value);
 104     return this;
 105 }
 106
 107 CYExpression *CYCall::Replace(CYContext &context) {
 108     context.Replace(function_);
 109     arguments_->Replace(context);
 110     return this;
 111 }
 112
 113 namespace cy {
 114 namespace Syntax {
 115
 116 void Catch::Replace(CYContext &context) { $T()
 117     CYScope scope(CYScopeCatch, context, code_.statements_);
 118
 119     context.Replace(name_);
 120     context.scope_->Declare(context, name_, CYIdentifierCatch);
 121
 122     code_.Replace(context);
 123     scope.Close();
 124 }
 125
 126 } }
 127
 128 void CYClause::Replace(CYContext &context) { $T()
 129     context.Replace(case_);
 130     statements_ = statements_->ReplaceAll(context);
 131     next_->Replace(context);
 132 }
 133
 134 CYStatement *CYComment::Replace(CYContext &context) {
 135     return this;
 136 }
 137
 138 CYExpression *CYCompound::Replace(CYContext &context) {
 139     expressions_ = expressions_->ReplaceAll(context);
 140     return expressions_ == NULL ? NULL : this;
 141 }
 142
 143 CYFunctionParameter *CYComprehension::Parameters(CYContext &context) const { $T(NULL)
 144     CYFunctionParameter *next(next_->Parameters(context));
 145     if (CYFunctionParameter *parameter = Parameter(context)) {
 146         parameter->SetNext(next);
 147         return parameter;
 148     } else
 149         return next;
 150 }
 151
 152 CYStatement *CYComprehension::Replace(CYContext &context, CYStatement *statement) const {
 153     return next_ == NULL ? statement : next_->Replace(context, statement);
 154 }
 155
 156 CYExpression *CYCondition::Replace(CYContext &context) {
 157     context.Replace(test_);
 158     context.Replace(true_);
 159     context.Replace(false_);
 160     return this;
 161 }
 162
 163 void CYContext::NonLocal(CYStatement *&statements) {
 164     CYContext &context(*this);
 165
 166     if (nextlocal_ != NULL && nextlocal_->identifier_ != NULL) {
 167         CYIdentifier *cye($I("$cye")->Replace(context));
 168         CYIdentifier *unique(nextlocal_->identifier_->Replace(context));
 169
 170         CYStatement *declare(
 171             $ CYVar($L1($L(unique, $ CYObject()))));
 172
 173         cy::Syntax::Catch *rescue(
 174             $ cy::Syntax::Catch(cye, $$->*
 175                 $ CYIf($ CYIdentical($M($V(cye), $S("$cyk")), $V(unique)), $$->*
 176                     $ CYReturn($M($V(cye), $S("$cyv"))))->*
 177                 $ cy::Syntax::Throw($V(cye))));
 178
 179         context.Replace(declare);
 180         rescue->Replace(context);
 181
 182         statements = $$->*
 183             declare->*
 184             $ cy::Syntax::Try(statements, rescue, NULL);
 185     }
 186 }
 187
 188 CYIdentifier *CYContext::Unique() {
 189     return $ CYIdentifier(apr_psprintf($pool, "$cy%u", unique_++));
 190 }
 191
 192 CYStatement *CYContinue::Replace(CYContext &context) {
 193     return this;
 194 }
 195
 196 CYAssignment *CYDeclaration::Assignment(CYContext &context) {
 197     CYExpression *variable(Replace(context));
 198     return initialiser_ == NULL ? NULL : $ CYAssign(variable, initialiser_);
 199 }
 200
 201 CYExpression *CYDeclaration::ForEachIn(CYContext &context) {
 202     return $V(identifier_);
 203 }
 204
 205 CYExpression *CYDeclaration::Replace(CYContext &context) {
 206     context.Replace(identifier_);
 207     context.scope_->Declare(context, identifier_, CYIdentifierVariable);
 208     return $V(identifier_);
 209 }
 210
 211 CYProperty *CYDeclarations::Property(CYContext &context) { $T(NULL)
 212     return $ CYProperty(declaration_->identifier_, declaration_->initialiser_ ?: $U, next_->Property(context));
 213 }
 214
 215 CYCompound *CYDeclarations::Replace(CYContext &context) {
 216     CYCompound *compound;
 217     if (next_ == NULL) compound:
 218         compound = $ CYCompound();
 219     else {
 220         compound = next_->Replace(context);
 221         if (compound == NULL)
 222             goto compound;
 223     }
 224
 225     if (CYAssignment *assignment = declaration_->Assignment(context))
 226         compound->AddPrev(assignment);
 227     return compound;
 228 }
 229
 230 CYExpression *CYDirectMember::Replace(CYContext &context) {
 231     Replace_(context);
 232     return this;
 233 }
 234
 235 CYStatement *CYDoWhile::Replace(CYContext &context) {
 236     context.Replace(test_);
 237     context.Replace(code_);
 238     return this;
 239 }
 240
 241 void CYElement::Replace(CYContext &context) { $T()
 242     context.Replace(value_);
 243     next_->Replace(context);
 244 }
 245
 246 CYStatement *CYEmpty::Collapse(CYContext &context) {
 247     return next_;
 248 }
 249
 250 CYStatement *CYEmpty::Replace(CYContext &context) {
 251     return this;
 252 }
 253
 254 CYStatement *CYExpress::Collapse(CYContext &context) {
 255     if (CYExpress *express = dynamic_cast<CYExpress *>(next_)) {
 256         CYCompound *next(dynamic_cast<CYCompound *>(express->expression_));
 257         if (next == NULL)
 258             next = $ CYCompound(express->expression_);
 259         next->AddPrev(expression_);
 260         expression_ = next;
 261         SetNext(express->next_);
 262     }
 263
 264     return this;
 265 }
 266
 267 CYStatement *CYExpress::Replace(CYContext &context) {
 268     context.Replace(expression_);
 269     if (expression_ == NULL)
 270         return $ CYEmpty();
 271     return this;
 272 }
 273
 274 CYExpression *CYExpression::AddArgument(CYContext &context, CYExpression *value) {
 275     return $C1(this, value);
 276 }
 277
 278 CYExpression *CYExpression::ClassName(CYContext &context, bool object) {
 279     return this;
 280 }
 281
 282 CYExpression *CYExpression::ForEachIn(CYContext &context) {
 283     return this;
 284 }
 285
 286 CYExpression *CYExpression::ReplaceAll(CYContext &context) { $T(NULL)
 287     CYExpression *replace(this);
 288     context.Replace(replace);
 289
 290     if (CYExpression *next = next_->ReplaceAll(context))
 291         replace->SetNext(next);
 292     else
 293         replace->SetNext(next_);
 294
 295     return replace;
 296 }
 297
 298 CYNumber *CYFalse::Number(CYContext &context) {
 299     return $D(0);
 300 }
 301
 302 CYString *CYFalse::String(CYContext &context) {
 303     return $S("false");
 304 }
 305
 306 void CYFinally::Replace(CYContext &context) { $T()
 307     code_.Replace(context);
 308 }
 309
 310 CYStatement *CYFor::Replace(CYContext &context) {
 311     context.Replace(initialiser_);
 312     context.Replace(test_);
 313     context.Replace(increment_);
 314     context.Replace(code_);
 315     return this;
 316 }
 317
 318 CYStatement *CYForIn::Replace(CYContext &context) {
 319     // XXX: this actually might need a prefix statement
 320     context.Replace(initialiser_);
 321     context.Replace(set_);
 322     context.Replace(code_);
 323     return this;
 324 }
 325
 326 CYFunctionParameter *CYForInComprehension::Parameter(CYContext &context) const {
 327     return $ CYFunctionParameter(name_);
 328 }
 329
 330 CYStatement *CYForInComprehension::Replace(CYContext &context, CYStatement *statement) const {
 331     return $ CYForIn($V(name_), set_, CYComprehension::Replace(context, statement));
 332 }
 333
 334 CYStatement *CYForEachIn::Replace(CYContext &context) {
 335     CYIdentifier *cys($I("$cys")), *cyt($I("$cyt"));
 336
 337     return $ CYLet($L2($L(cys, set_), $L(cyt)), $$->*
 338         $ CYForIn($V(cyt), $V(cys), $ CYBlock($$->*
 339             $E($ CYAssign(initialiser_->ForEachIn(context), $M($V(cys), $V(cyt))))->*
 340             code_
 341         ))
 342     );
 343 }
 344
 345 CYFunctionParameter *CYForEachInComprehension::Parameter(CYContext &context) const {
 346     return $ CYFunctionParameter(name_);
 347 }
 348
 349 CYStatement *CYForEachInComprehension::Replace(CYContext &context, CYStatement *statement) const {
 350     CYIdentifier *cys($I("cys"));
 351
 352     return $E($C0($F(NULL, $P1("$cys"), $$->*
 353         $E($ CYAssign($V(cys), set_))->*
 354         $ CYForIn($V(name_), $V(cys), $ CYBlock($$->*
 355             $E($ CYAssign($V(name_), $M($V(cys), $V(name_))))->*
 356             CYComprehension::Replace(context, statement)
 357         ))
 358     )));
 359 }
 360
 361 void CYFunction::Inject(CYContext &context) {
 362     context.Replace(name_);
 363     context.scope_->Declare(context, name_, CYIdentifierOther);
 364 }
 365
 366 void CYFunction::Replace_(CYContext &context, bool outer) {
 367     if (outer)
 368         Inject(context);
 369
 370     CYScope scope(CYScopeFunction, context, code_.statements_);
 371
 372     CYNonLocal *nonlocal(context.nonlocal_);
 373     CYNonLocal *nextlocal(context.nextlocal_);
 374
 375     bool localize;
 376     if (nonlocal_ != NULL) {
 377         localize = false;
 378         context.nonlocal_ = nonlocal_;
 379     } else {
 380         localize = true;
 381         nonlocal_ = $ CYNonLocal();
 382         context.nextlocal_ = nonlocal_;
 383     }
 384
 385     if (!outer && name_ != NULL)
 386         Inject(context);
 387
 388     if (parameters_ != NULL)
 389         parameters_ = parameters_->Replace(context, code_);
 390
 391     code_.Replace(context);
 392
 393     if (localize)
 394         context.NonLocal(code_.statements_);
 395
 396     context.nextlocal_ = nextlocal;
 397     context.nonlocal_ = nonlocal;
 398
 399     scope.Close();
 400 }
 401
 402 CYExpression *CYFunctionExpression::Replace(CYContext &context) {
 403     Replace_(context, false);
 404     return this;
 405 }
 406
 407 CYFunctionParameter *CYFunctionParameter::Replace(CYContext &context, CYBlock &code) {
 408     context.Replace(name_);
 409     context.scope_->Declare(context, name_, CYIdentifierArgument);
 410     if (next_ != NULL)
 411         next_ = next_->Replace(context, code);
 412     return this;
 413 }
 414
 415 CYStatement *CYFunctionStatement::Replace(CYContext &context) {
 416     Replace_(context, true);
 417     return this;
 418 }
 419
 420 CYIdentifier *CYIdentifier::Replace(CYContext &context) {
 421     if (replace_ != NULL && replace_ != this)
 422         return replace_->Replace(context);
 423     replace_ = context.scope_->Lookup(context, this);
 424     return replace_;
 425 }
 426
 427 CYStatement *CYIf::Replace(CYContext &context) {
 428     context.Replace(test_);
 429     context.Replace(true_);
 430     context.Replace(false_);
 431     return this;
 432 }
 433
 434 CYFunctionParameter *CYIfComprehension::Parameter(CYContext &context) const {
 435     return NULL;
 436 }
 437
 438 CYStatement *CYIfComprehension::Replace(CYContext &context, CYStatement *statement) const {
 439     return $ CYIf(test_, CYComprehension::Replace(context, statement));
 440 }
 441
 442 CYExpression *CYIndirect::Replace(CYContext &context) {
 443     CYPrefix::Replace(context);
 444     return $M(rhs_, $S("$cyi"));
 445 }
 446
 447 CYExpression *CYIndirectMember::Replace(CYContext &context) {
 448     Replace_(context);
 449     return $M($ CYIndirect(object_), property_);
 450 }
 451
 452 CYExpression *CYInfix::Replace(CYContext &context) {
 453     context.Replace(lhs_);
 454     context.Replace(rhs_);
 455     return this;
 456 }
 457
 458 CYStatement *CYLabel::Replace(CYContext &context) {
 459     context.Replace(statement_);
 460     return this;
 461 }
 462
 463 CYStatement *CYLet::Replace(CYContext &context) {
 464     return $ CYWith($ CYObject(declarations_->Property(context)), &code_);
 465 }
 466
 467 void CYMember::Replace_(CYContext &context) {
 468     context.Replace(object_);
 469     context.Replace(property_);
 470 }
 471
 472 namespace cy {
 473 namespace Syntax {
 474
 475 CYExpression *New::AddArgument(CYContext &context, CYExpression *value) {
 476     CYArgument **argument(&arguments_);
 477     while (*argument != NULL)
 478         argument = &(*argument)->next_;
 479     *argument = $ CYArgument(value);
 480     return this;
 481 }
 482
 483 CYExpression *New::Replace(CYContext &context) {
 484     context.Replace(constructor_);
 485     arguments_->Replace(context);
 486     return this;
 487 }
 488
 489 } }
 490
 491 CYNumber *CYNull::Number(CYContext &context) {
 492     return $D(0);
 493 }
 494
 495 CYString *CYNull::String(CYContext &context) {
 496     return $S("null");
 497 }
 498
 499 CYNumber *CYNumber::Number(CYContext &context) {
 500     return this;
 501 }
 502
 503 CYString *CYNumber::String(CYContext &context) {
 504     // XXX: there is a precise algorithm for this
 505     return $S(apr_psprintf($pool, "%.17g", Value()));
 506 }
 507
 508 CYExpression *CYObject::Replace(CYContext &context) {
 509     properties_->Replace(context);
 510     return this;
 511 }
 512
 513 CYFunctionParameter *CYOptionalFunctionParameter::Replace(CYContext &context, CYBlock &code) {
 514     CYFunctionParameter *parameter($ CYFunctionParameter(name_, next_));
 515     parameter = parameter->Replace(context, code);
 516     context.Replace(initializer_);
 517
 518     CYVariable *name($V(name_));
 519     code.AddPrev($ CYIf($ CYIdentical($ CYTypeOf(name), $S("undefined")), $$->*
 520         $E($ CYAssign(name, initializer_))
 521     ));
 522
 523     return parameter;
 524 }
 525
 526 CYExpression *CYPostfix::Replace(CYContext &context) {
 527     context.Replace(lhs_);
 528     return this;
 529 }
 530
 531 CYExpression *CYPrefix::Replace(CYContext &context) {
 532     context.Replace(rhs_);
 533     return this;
 534 }
 535
 536 // XXX: this is evil evil black magic. don't ask, don't tell... don't believe!
 537 #define MappingSet "0etnirsoalfucdphmgyvbxTwSNECAFjDLkMOIBPqzRH$_WXUVGYKQJZ"
 538 //#define MappingSet "0abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_"
 539
 540 namespace {
 541     struct IdentifierUsageLess :
 542         std::binary_function<CYIdentifier *, CYIdentifier *, bool>
 543     {
 544         _finline bool operator ()(CYIdentifier *lhs, CYIdentifier *rhs) const {
 545             if (lhs->usage_ != rhs->usage_)
 546                 return lhs->usage_ > rhs->usage_;
 547             return lhs < rhs;
 548         }
 549     };
 550
 551     typedef std::set<CYIdentifier *, IdentifierUsageLess> IdentifierUsages;
 552 }
 553
 554 void CYProgram::Replace(CYContext &context) {
 555     CYScope scope(CYScopeProgram, context, statements_);
 556
 557     context.nextlocal_ = $ CYNonLocal();
 558     statements_ = statements_->ReplaceAll(context);
 559     context.NonLocal(statements_);
 560
 561     scope.Close();
 562
 563     size_t offset(0);
 564
 565     CYCStringSet external;
 566     for (CYIdentifierValueSet::const_iterator i(scope.identifiers_.begin()); i != scope.identifiers_.end(); ++i)
 567         external.insert((*i)->Word());
 568
 569     IdentifierUsages usages;
 570
 571     if (offset < context.rename_.size())
 572         for (CYIdentifier *i(context.rename_[offset].identifier_); i != NULL; i = i->next_)
 573              usages.insert(i);
 574
 575     // XXX: totalling the probable occurrences and sorting by them would improve the result
 576     for (CYIdentifierUsageVector::const_iterator i(context.rename_.begin()); i != context.rename_.end(); ++i, ++offset) {
 577         //std::cout << *i << ":" << (*i)->offset_ << std::endl;
 578
 579         const char *name;
 580
 581         if (context.options_.verbose_)
 582             name = apr_psprintf($pool, "$%"APR_SIZE_T_FMT"", offset);
 583         else {
 584             char id[8];
 585             id[7] = '\0';
 586
 587           id:
 588             unsigned position(7), local(offset + 1);
 589
 590             do {
 591                 unsigned index(local % (sizeof(MappingSet) - 1));
 592                 local /= sizeof(MappingSet) - 1;
 593                 id[--position] = MappingSet[index];
 594             } while (local != 0);
 595
 596             if (external.find(id + position) != external.end()) {
 597                 ++offset;
 598                 goto id;
 599             }
 600
 601             name = apr_pstrmemdup($pool, id + position, 7 - position);
 602             // XXX: at some point, this could become a keyword
 603         }
 604
 605         for (CYIdentifier *identifier(i->identifier_); identifier != NULL; identifier = identifier->next_)
 606             identifier->Set(name);
 607     }
 608 }
 609
 610 void CYProperty::Replace(CYContext &context) { $T()
 611     context.Replace(value_);
 612     next_->Replace(context);
 613 }
 614
 615 CYStatement *CYReturn::Replace(CYContext &context) {
 616     if (context.nonlocal_ != NULL) {
 617         CYProperty *value(value_ == NULL ? NULL : $ CYProperty($S("$cyv"), value_));
 618         return $ cy::Syntax::Throw($ CYObject(
 619             $ CYProperty($S("$cyk"), $V(context.nonlocal_->Target(context)), value)
 620         ));
 621     }
 622
 623     context.Replace(value_);
 624     return this;
 625 }
 626
 627 CYExpression *CYRubyBlock::Replace(CYContext &context) {
 628     // XXX: this needs to do something much more epic to handle return
 629     return call_->AddArgument(context, proc_->Replace(context));
 630 }
 631
 632 CYExpression *CYRubyProc::Replace(CYContext &context) {
 633     CYFunctionExpression *function($ CYFunctionExpression(NULL, parameters_, code_));
 634     function->nonlocal_ = context.nextlocal_;
 635     return function;
 636 }
 637
 638 CYScope::CYScope(CYScopeType type, CYContext &context, CYStatement *&statements) :
 639     type_(type),
 640     context_(context),
 641     statements_(statements),
 642     parent_(context.scope_)
 643 {
 644     context_.scope_ = this;
 645 }
 646
 647 void CYScope::Close() {
 648     context_.scope_ = parent_;
 649     Scope(context_, statements_);
 650 }
 651
 652 void CYScope::Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags) {
 653     if (type_ == CYScopeCatch && flags != CYIdentifierCatch)
 654         parent_->Declare(context, identifier, flags);
 655     else
 656         internal_.insert(CYIdentifierAddressFlagsMap::value_type(identifier, flags));
 657 }
 658
 659 CYIdentifier *CYScope::Lookup(CYContext &context, CYIdentifier *identifier) {
 660     std::pair<CYIdentifierValueSet::iterator, bool> insert(identifiers_.insert(identifier));
 661     return *insert.first;
 662 }
 663
 664 void CYScope::Merge(CYContext &context, CYIdentifier *identifier) {
 665     std::pair<CYIdentifierValueSet::iterator, bool> insert(identifiers_.insert(identifier));
 666     if (!insert.second) {
 667         if ((*insert.first)->offset_ < identifier->offset_)
 668             (*insert.first)->offset_ = identifier->offset_;
 669         identifier->replace_ = *insert.first;
 670         (*insert.first)->usage_ += identifier->usage_ + 1;
 671     }
 672 }
 673
 674 namespace {
 675     struct IdentifierOffset {
 676         size_t offset_;
 677         CYIdentifierFlags flags_;
 678         size_t usage_;
 679         CYIdentifier *identifier_;
 680
 681         IdentifierOffset(CYIdentifier *identifier, CYIdentifierFlags flags) :
 682             offset_(identifier->offset_),
 683             flags_(flags),
 684             usage_(identifier->usage_),
 685             identifier_(identifier)
 686         {
 687         }
 688     };
 689
 690     struct IdentifierOffsetLess :
 691         std::binary_function<const IdentifierOffset &, const IdentifierOffset &, bool>
 692     {
 693         _finline bool operator ()(const IdentifierOffset &lhs, const IdentifierOffset &rhs) const {
 694             if (lhs.offset_ != rhs.offset_)
 695                 return lhs.offset_ < rhs.offset_;
 696             if (lhs.flags_ != rhs.flags_)
 697                 return lhs.flags_ < rhs.flags_;
 698             /*if (lhs.usage_ != rhs.usage_)
 699                 return lhs.usage_ < rhs.usage_;*/
 700             return lhs.identifier_ < rhs.identifier_;
 701         }
 702     };
 703
 704     typedef std::set<IdentifierOffset, IdentifierOffsetLess> IdentifierOffsets;
 705 }
 706
 707 void CYScope::Scope(CYContext &context, CYStatement *&statements) {
 708     if (parent_ == NULL)
 709         return;
 710
 711     CYDeclarations *last(NULL), *curr(NULL);
 712
 713     IdentifierOffsets offsets;
 714
 715     for (CYIdentifierAddressFlagsMap::const_iterator i(internal_.begin()); i != internal_.end(); ++i)
 716         if (i->second != CYIdentifierMagic)
 717             offsets.insert(IdentifierOffset(i->first, i->second));
 718
 719     size_t offset(0);
 720
 721     for (IdentifierOffsets::const_iterator i(offsets.begin()); i != offsets.end(); ++i) {
 722         if (i->flags_ == CYIdentifierVariable) {
 723             CYDeclarations *next($ CYDeclarations($ CYDeclaration(i->identifier_)));
 724             if (last == NULL)
 725                 last = next;
 726             if (curr != NULL)
 727                 curr->SetNext(next);
 728             curr = next;
 729         }
 730
 731         if (offset < i->offset_)
 732             offset = i->offset_;
 733         if (context.rename_.size() <= offset)
 734             context.rename_.resize(offset + 1);
 735
 736         CYIdentifierUsage &rename(context.rename_[offset++]);
 737         i->identifier_->SetNext(rename.identifier_);
 738         rename.identifier_ = i->identifier_;
 739         rename.usage_ += i->identifier_->usage_ + 1;
 740     }
 741
 742     if (last != NULL) {
 743         CYVar *var($ CYVar(last));
 744         var->SetNext(statements);
 745         statements = var;
 746     }
 747
 748     for (CYIdentifierValueSet::const_iterator i(identifiers_.begin()); i != identifiers_.end(); ++i)
 749         if (internal_.find(*i) == internal_.end()) {
 750             //std::cout << *i << '=' << offset << std::endl;
 751             if ((*i)->offset_ < offset)
 752                 (*i)->offset_ = offset;
 753             parent_->Merge(context, *i);
 754         }
 755 }
 756
 757 CYStatement *CYStatement::Collapse(CYContext &context) {
 758     return this;
 759 }
 760
 761 CYStatement *CYStatement::ReplaceAll(CYContext &context) { $T(NULL)
 762     CYStatement *replace(this);
 763     context.Replace(replace);
 764     replace->SetNext(next_->ReplaceAll(context));
 765     return replace->Collapse(context);
 766 }
 767
 768 CYString *CYString::Concat(CYContext &context, CYString *rhs) const {
 769     size_t size(size_ + rhs->size_);
 770     char *value($ char[size + 1]);
 771     memcpy(value, value_, size_);
 772     memcpy(value + size_, rhs->value_, rhs->size_);
 773     value[size] = '\0';
 774     return $S(value, size);
 775 }
 776
 777 CYNumber *CYString::Number(CYContext &context) {
 778     // XXX: there is a precise algorithm for this
 779     return NULL;
 780 }
 781
 782 CYString *CYString::String(CYContext &context) {
 783     return this;
 784 }
 785
 786 CYStatement *CYSwitch::Replace(CYContext &context) {
 787     context.Replace(value_);
 788     clauses_->Replace(context);
 789     return this;
 790 }
 791
 792 CYExpression *CYThis::Replace(CYContext &context) {
 793     return this;
 794 }
 795
 796 namespace cy {
 797 namespace Syntax {
 798
 799 CYStatement *Throw::Replace(CYContext &context) {
 800     context.Replace(value_);
 801     return this;
 802 }
 803
 804 } }
 805
 806 CYExpression *CYTrivial::Replace(CYContext &context) {
 807     return this;
 808 }
 809
 810 CYNumber *CYTrue::Number(CYContext &context) {
 811     return $D(1);
 812 }
 813
 814 CYString *CYTrue::String(CYContext &context) {
 815     return $S("true");
 816 }
 817
 818 namespace cy {
 819 namespace Syntax {
 820
 821 CYStatement *Try::Replace(CYContext &context) {
 822     code_.Replace(context);
 823     catch_->Replace(context);
 824     finally_->Replace(context);
 825     return this;
 826 }
 827
 828 } }
 829
 830 CYStatement *CYVar::Replace(CYContext &context) {
 831     return $E(declarations_->Replace(context));
 832 }
 833
 834 CYExpression *CYVariable::Replace(CYContext &context) {
 835     context.Replace(name_);
 836     return this;
 837 }
 838
 839 CYStatement *CYWhile::Replace(CYContext &context) {
 840     context.Replace(test_);
 841     context.Replace(code_);
 842     return this;
 843 }
 844
 845 CYStatement *CYWith::Replace(CYContext &context) {
 846     context.Replace(scope_);
 847     context.Replace(code_);
 848     return this;
 849 }
 850
 851 CYExpression *CYWord::ClassName(CYContext &context, bool object) {
 852     CYString *name($S(this));
 853     if (object)
 854         return $C1($V("objc_getClass"), name);
 855     else
 856         return name;
 857 }