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