X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/550ee46a9be4b8e9a9e25c1d080f081cbdfa10b9..ca6a1b2b2dce57a7ad9e11bdd3649f00ca855a15:/Replace.cpp?ds=inline diff --git a/Replace.cpp b/Replace.cpp index fe93557..ac673ad 100644 --- a/Replace.cpp +++ b/Replace.cpp @@ -1,97 +1,106 @@ -/* Cycript - Remove Execution Server and Disassembler - * Copyright (C) 2009 Jay Freeman (saurik) +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2015 Jay Freeman (saurik) */ -/* Modified BSD License {{{ */ +/* GNU Affero General Public License, Version 3 {{{ */ /* - * Redistribution and use in source and binary - * forms, with or without modification, are permitted - * provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the - * above copyright notice, this list of conditions - * and the following disclaimer. - * 2. Redistributions in binary form must reproduce the - * above copyright notice, this list of conditions - * and the following disclaimer in the documentation - * and/or other materials provided with the - * distribution. - * 3. The name of the author may not be used to endorse - * or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, - * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . +**/ /* }}} */ -#include "Parser.hpp" - #include #include "Replace.hpp" +#include "Syntax.hpp" + +CYFunctionExpression *CYNonLocalize(CYContext &context, CYFunctionExpression *function) { + function->nonlocal_ = context.nextlocal_; + return function; +} + +CYFunctionExpression *CYSuperize(CYContext &context, CYFunctionExpression *function) { + function->super_ = context.super_; + return function; +} + +CYStatement *CYDefineProperty(CYExpression *object, CYExpression *name, bool configurable, bool enumerable, CYProperty *descriptor) { + return $E($C3($M($V("Object"), $S("defineProperty")), object, name, $ CYObject(CYList() + ->* (configurable ? $ CYPropertyValue($S("configurable"), $ CYTrue()) : NULL) + ->* (enumerable ? $ CYPropertyValue($S("enumerable"), $ CYTrue()) : NULL) + ->* descriptor))); +} + +static void CYImplicitReturn(CYStatement *&code) { + if (CYStatement *&last = CYGetLast(code)) + last = last->Return(); +} CYExpression *CYAdd::Replace(CYContext &context) { CYInfix::Replace(context); - CYExpression *lhp(lhs_->Primitive(context)); - CYExpression *rhp(rhs_->Primitive(context)); - - CYString *lhs(dynamic_cast(lhp)); - CYString *rhs(dynamic_cast(rhp)); + CYString *lhs(dynamic_cast(lhs_)); + CYString *rhs(dynamic_cast(rhs_)); if (lhs != NULL || rhs != NULL) { if (lhs == NULL) { - lhs = lhp->String(context); + lhs = lhs_->String(context); if (lhs == NULL) - return NULL; + return this; } else if (rhs == NULL) { - rhs = rhp->String(context); + rhs = rhs_->String(context); if (rhs == NULL) - return NULL; + return this; } return lhs->Concat(context, rhs); } - if (CYNumber *lhn = lhp->Number(context)) - if (CYNumber *rhn = rhp->Number(context)) + if (CYNumber *lhn = lhs_->Number(context)) + if (CYNumber *rhn = rhs_->Number(context)) return $D(lhn->Value() + rhn->Value()); - return NULL; + return this; } CYExpression *CYAddressOf::Replace(CYContext &context) { - CYPrefix::Replace(context); return $C0($M(rhs_, $S("$cya"))); } -void CYArgument::Replace(CYContext &context) { $T() +CYArgument *CYArgument::Replace(CYContext &context) { $T(NULL) context.Replace(value_); - next_->Replace(context); + next_ = next_->Replace(context); + + if (value_ == NULL) { + if (next_ == NULL) + return NULL; + else + value_ = $U; + } + + return this; } CYExpression *CYArray::Replace(CYContext &context) { - elements_->Replace(context); - return NULL; + if (elements_ != NULL) + elements_->Replace(context); + return this; } CYExpression *CYArrayComprehension::Replace(CYContext &context) { CYVariable *cyv($V("$cyv")); - return $C0($F(NULL, $P1("$cyv", comprehensions_->Parameters(context)), $$->* + return $C0($F(NULL, $P1($L($I("$cyv")), comprehensions_->Parameters(context)), $$->* $E($ CYAssign(cyv, $ CYArray()))->* comprehensions_->Replace(context, $E($C1($M(cyv, $S("push")), expression_)))->* $ CYReturn(cyv) @@ -101,42 +110,124 @@ CYExpression *CYArrayComprehension::Replace(CYContext &context) { CYExpression *CYAssignment::Replace(CYContext &context) { context.Replace(lhs_); context.Replace(rhs_); - return NULL; + return this; +} + +CYStatement *CYBlock::Return() { + CYImplicitReturn(code_); + return this; } CYStatement *CYBlock::Replace(CYContext &context) { - statements_ = statements_->ReplaceAll(context); - return NULL; + context.ReplaceAll(code_); + if (code_ == NULL) + return $ CYEmpty(); + return this; } CYStatement *CYBreak::Replace(CYContext &context) { - return NULL; + return this; +} + +CYExpression *CYCall::AddArgument(CYContext &context, CYExpression *value) { + CYArgument **argument(&arguments_); + while (*argument != NULL) + argument = &(*argument)->next_; + *argument = $ CYArgument(value); + return this; } CYExpression *CYCall::Replace(CYContext &context) { context.Replace(function_); arguments_->Replace(context); - return NULL; + return this; } namespace cy { namespace Syntax { void Catch::Replace(CYContext &context) { $T() - code_.Replace(context); + CYScope scope(true, context); + + context.Replace(name_); + context.scope_->Declare(context, name_, CYIdentifierCatch); + + context.ReplaceAll(code_); + scope.Close(context, code_); } } } +CYExpression *CYClassExpression::Replace(CYContext &context) { + CYBuilder builder; + + CYIdentifier *super(context.Unique()); + + CYIdentifier *old(context.super_); + context.super_ = super; + + CYIdentifier *constructor(context.Unique()); + CYForEach (member, tail_->static_) + member->Replace(context, builder, $V(constructor), true); + + CYIdentifier *prototype(context.Unique()); + CYForEach (member, tail_->instance_) + member->Replace(context, builder, $V(prototype), true); + + if (tail_->constructor_ == NULL) + tail_->constructor_ = $ CYFunctionExpression(NULL, NULL, NULL); + tail_->constructor_ = CYSuperize(context, tail_->constructor_); + + context.super_ = old; + + return $C1($ CYFunctionExpression(NULL, $P($L(super)), $$ + ->* $ CYVar($L1($L(constructor, tail_->constructor_))) + ->* $ CYVar($L1($L(prototype, $ CYFunctionExpression(NULL, NULL, NULL)))) + ->* $E($ CYAssign($M($V(prototype), $S("prototype")), $M($V(super), $S("prototype")))) + ->* $E($ CYAssign($V(prototype), $N($V(prototype)))) + ->* CYDefineProperty($V(prototype), $S("constructor"), false, false, $ CYPropertyValue($S("value"), $V(constructor))) + ->* $ CYVar(builder.declarations_) + ->* builder.statements_ + ->* CYDefineProperty($V(constructor), $S("prototype"), false, false, $ CYPropertyValue($S("value"), $V(prototype))) + ->* $ CYReturn($V(constructor)) + ), tail_->extends_ ?: $V($I("Object"))); +} + +CYStatement *CYClassStatement::Replace(CYContext &context) { + return $ CYVar($L1($L(name_, $ CYClassExpression(name_, tail_)))); +} + void CYClause::Replace(CYContext &context) { $T() context.Replace(case_); - statements_ = statements_->ReplaceAll(context); + context.ReplaceAll(code_); next_->Replace(context); } CYExpression *CYCompound::Replace(CYContext &context) { - expressions_ = expressions_->ReplaceAll(context); - return NULL; + context.Replace(expression_); + context.Replace(next_); + + if (CYCompound *compound = dynamic_cast(expression_)) { + expression_ = compound->expression_; + compound->expression_ = compound->next_; + compound->next_ = next_; + next_ = compound; + } + + return this; +} + +CYFunctionParameter *CYCompound::Parameter() const { + CYFunctionParameter *next(next_->Parameter()); + if (next == NULL) + return NULL; + + CYFunctionParameter *parameter(expression_->Parameter()); + if (parameter == NULL) + return NULL; + + parameter->SetNext(next); + return parameter; } CYFunctionParameter *CYComprehension::Parameters(CYContext &context) const { $T(NULL) @@ -152,27 +243,76 @@ CYStatement *CYComprehension::Replace(CYContext &context, CYStatement *statement return next_ == NULL ? statement : next_->Replace(context, statement); } +CYExpression *CYComputed::PropertyName(CYContext &context) { + return expression_; +} + CYExpression *CYCondition::Replace(CYContext &context) { context.Replace(test_); context.Replace(true_); context.Replace(false_); - return NULL; + return this; +} + +void CYContext::NonLocal(CYStatement *&statements) { + CYContext &context(*this); + + if (nextlocal_ != NULL && nextlocal_->identifier_ != NULL) { + CYIdentifier *cye($I("$cye")->Replace(context)); + CYIdentifier *unique(nextlocal_->identifier_->Replace(context)); + + CYStatement *declare( + $ CYVar($L1($L(unique, $ CYObject())))); + + cy::Syntax::Catch *rescue( + $ cy::Syntax::Catch(cye, $$->* + $ CYIf($ CYIdentical($M($V(cye), $S("$cyk")), $V(unique)), $$->* + $ CYReturn($M($V(cye), $S("$cyv"))))->* + $ cy::Syntax::Throw($V(cye)))); + + // XXX: I don't understand any of this + context.Replace(declare); + rescue->Replace(context); + + statements = $$->* + declare->* + $ cy::Syntax::Try(statements, rescue, NULL); + } +} + +CYIdentifier *CYContext::Unique() { + return $ CYIdentifier($pool.strcat("$cy", $pool.itoa(unique_++), NULL)); } CYStatement *CYContinue::Replace(CYContext &context) { - return NULL; + return this; } -CYExpression *CYDeclaration::ForEachIn(CYContext &context) { - return $ CYVariable(identifier_); +CYStatement *CYDebugger::Replace(CYContext &context) { + return this; } -void CYDeclaration::Replace(CYContext &context) { - context.Replace(initialiser_); +CYAssignment *CYDeclaration::Assignment(CYContext &context) { + if (initialiser_ == NULL) + return NULL; + + CYAssignment *value($ CYAssign(Variable(context), initialiser_)); + initialiser_ = NULL; + return value; } -CYProperty *CYDeclarations::Property(CYContext &context) { $T(NULL) - return $ CYProperty(declaration_->identifier_, declaration_->initialiser_ ?: $U, next_->Property(context)); +CYVariable *CYDeclaration::Variable(CYContext &context) { + return $V(identifier_); +} + +CYStatement *CYDeclaration::ForEachIn(CYContext &context, CYExpression *value) { + return $ CYVar($L1($ CYDeclaration(identifier_, value))); +} + +CYExpression *CYDeclaration::Replace(CYContext &context) { + context.Replace(identifier_); + context.scope_->Declare(context, identifier_, CYIdentifierVariable); + return Variable(context); } void CYDeclarations::Replace(CYContext &context) { $T() @@ -180,49 +320,81 @@ void CYDeclarations::Replace(CYContext &context) { $T() next_->Replace(context); } +CYFunctionParameter *CYDeclarations::Parameter(CYContext &context) { $T(NULL) + return $ CYFunctionParameter($ CYDeclaration(declaration_->identifier_), next_->Parameter(context)); +} + +CYArgument *CYDeclarations::Argument(CYContext &context) { $T(NULL) + return $ CYArgument(declaration_->initialiser_, next_->Argument(context)); +} + +CYExpression *CYDeclarations::Expression(CYContext &context) { $T(NULL) + CYExpression *compound(next_->Expression(context)); + if (CYAssignment *assignment = declaration_->Assignment(context)) + if (compound == NULL) + compound = assignment; + else + compound = $ CYCompound(assignment, compound); + return compound; +} + CYExpression *CYDirectMember::Replace(CYContext &context) { - Replace_(context); - return NULL; + context.Replace(object_); + context.Replace(property_); + return this; } CYStatement *CYDoWhile::Replace(CYContext &context) { context.Replace(test_); - context.Replace(code_); - return NULL; + context.ReplaceAll(code_); + return this; } -void CYElement::Replace(CYContext &context) { $T() +void CYElementSpread::Replace(CYContext &context) { context.Replace(value_); - next_->Replace(context); +} + +void CYElementValue::Replace(CYContext &context) { + context.Replace(value_); + if (next_ != NULL) + next_->Replace(context); } CYStatement *CYEmpty::Replace(CYContext &context) { return NULL; } +CYExpression *CYEncodedType::Replace(CYContext &context) { + return typed_->Replace(context); +} + +CYStatement *CYExpress::Return() { + return $ CYReturn(expression_); +} + CYStatement *CYExpress::Replace(CYContext &context) { context.Replace(expression_); - return NULL; + return this; } -CYExpression *CYExpression::ClassName(CYContext &context, bool object) { - return this; +CYExpression *CYExpression::AddArgument(CYContext &context, CYExpression *value) { + return $C1(this, value); } -CYExpression *CYExpression::ForEachIn(CYContext &context) { - return this; +CYStatement *CYExpression::ForEachIn(CYContext &context, CYExpression *value) { + return $E($ CYAssign(this, value)); } -CYExpression *CYExpression::ReplaceAll(CYContext &context) { $T(NULL) - CYExpression *replace(this); - context.Replace(replace); +CYAssignment *CYExpression::Assignment(CYContext &context) { + return NULL; +} - if (CYExpression *next = next_->ReplaceAll(context)) - replace->SetNext(next); - else - replace->SetNext(next_); +CYFunctionParameter *CYExpression::Parameter() const { + return NULL; +} - return replace; +CYStatement *CYExternal::Replace(CYContext &context) { + return $E($ CYAssign($V(typed_->identifier_), $C1(typed_->Replace(context), $C2($V("dlsym"), $V("RTLD_DEFAULT"), $S(typed_->identifier_->Word()))))); } CYNumber *CYFalse::Number(CYContext &context) { @@ -233,79 +405,182 @@ CYString *CYFalse::String(CYContext &context) { return $S("false"); } +CYExpression *CYFatArrow::Replace(CYContext &context) { + CYFunctionExpression *function($ CYFunctionExpression(NULL, parameters_, code_)); + function->this_.SetNext(context.this_); + return function; +} + void CYFinally::Replace(CYContext &context) { $T() - code_.Replace(context); + context.ReplaceAll(code_); } CYStatement *CYFor::Replace(CYContext &context) { - // XXX: initialiser_ + context.Replace(initialiser_); context.Replace(test_); context.Replace(increment_); - context.Replace(code_); - return NULL; + context.ReplaceAll(code_); + return this; } +CYExpression *CYForDeclarations::Replace(CYContext &context) { + declarations_->Replace(context); + return declarations_->Expression(context); +} + +// XXX: this still feels highly suboptimal CYStatement *CYForIn::Replace(CYContext &context) { - // XXX: initialiser_ + if (CYAssignment *assignment = initialiser_->Assignment(context)) + return $ CYBlock($$->* + $E(assignment)->* + this + ); + + context.Replace(initialiser_); context.Replace(set_); - context.Replace(code_); - return NULL; + context.ReplaceAll(code_); + return this; } CYFunctionParameter *CYForInComprehension::Parameter(CYContext &context) const { - return $ CYFunctionParameter(name_); + return $ CYFunctionParameter(declaration_); } CYStatement *CYForInComprehension::Replace(CYContext &context, CYStatement *statement) const { - return $ CYForIn($ CYVariable(name_), set_, CYComprehension::Replace(context, statement)); + return $ CYForIn(declaration_->Variable(context), set_, CYComprehension::Replace(context, statement)); } -CYStatement *CYForEachIn::Replace(CYContext &context) { - CYVariable *cys($V("$cys")), *cyt($V("$cyt")); +CYStatement *CYForOf::Replace(CYContext &context) { + if (CYAssignment *assignment = initialiser_->Assignment(context)) + return $ CYBlock($$->* + $E(assignment)->* + this + ); - return $ CYLet($L2($L($I("$cys"), set_), $L($I("$cyt"))), $$->* - $ CYForIn(cyt, cys, $ CYBlock($$->* - $E($ CYAssign(initialiser_->ForEachIn(context), $M(cys, cyt)))->* - code_ - )) - ); + CYIdentifier *cys(context.Unique()), *cyt(context.Unique()); + + return $ CYBlock($$ + ->* $ CYLet($L2($L(cys, set_), $L(cyt))) + ->* $ CYForIn($V(cyt), $V(cys), $ CYBlock($$ + ->* initialiser_->ForEachIn(context, $M($V(cys), $V(cyt))) + ->* code_ + ))); } -CYFunctionParameter *CYForEachInComprehension::Parameter(CYContext &context) const { - return $ CYFunctionParameter(name_); +CYFunctionParameter *CYForOfComprehension::Parameter(CYContext &context) const { + return $ CYFunctionParameter(declaration_); } -CYStatement *CYForEachInComprehension::Replace(CYContext &context, CYStatement *statement) const { - CYVariable *cys($V("$cys")), *name($ CYVariable(name_)); +CYStatement *CYForOfComprehension::Replace(CYContext &context, CYStatement *statement) const { + CYIdentifier *cys($I("$cys")); - return $E($C0($F(NULL, $P1("$cys"), $$->* - $E($ CYAssign(cys, set_))->* - $ CYForIn(name, cys, $ CYBlock($$->* - $E($ CYAssign(name, $M(cys, name)))->* + return $E($C0($F(NULL, $P1($L($I("$cys"))), $$->* + $E($ CYAssign($V(cys), set_))->* + $ CYForIn(declaration_->Variable(context), $V(cys), $ CYBlock($$->* + $E($ CYAssign(declaration_->Variable(context), $M($V(cys), declaration_->Variable(context))))->* CYComprehension::Replace(context, statement) )) ))); } -void CYFunction::Replace_(CYContext &context) { - code_.Replace(context); +void CYFunction::Replace(CYContext &context) { + CYThisScope *_this(context.this_); + context.this_ = &this_; + context.this_ = CYGetLast(context.this_); + + CYIdentifier *super(context.super_); + context.super_ = super_; + + CYNonLocal *nonlocal(context.nonlocal_); + CYNonLocal *nextlocal(context.nextlocal_); + + bool localize; + if (nonlocal_ != NULL) { + localize = false; + context.nonlocal_ = nonlocal_; + } else { + localize = true; + nonlocal_ = $ CYNonLocal(); + context.nextlocal_ = nonlocal_; + } + + CYScope scope(!localize, context); + + parameters_->Replace(context, code_); + + context.ReplaceAll(code_); + + if (implicit_) + CYImplicitReturn(code_); + + if (CYIdentifier *identifier = this_.identifier_) { + context.scope_->Declare(context, identifier, CYIdentifierVariable); + code_ = $$ + ->*$E($ CYAssign($V(identifier), $ CYThis())) + ->*code_ + ; + } + + if (localize) + context.NonLocal(code_); + + context.nextlocal_ = nextlocal; + context.nonlocal_ = nonlocal; + + context.super_ = super; + context.this_ = _this; + + scope.Close(context, code_); } CYExpression *CYFunctionExpression::Replace(CYContext &context) { - Replace_(context); - return NULL; + CYScope scope(false, context); + if (name_ != NULL) + context.scope_->Declare(context, name_, CYIdentifierOther); + CYFunction::Replace(context); + scope.Close(context, code_); + return this; +} + +void CYFunctionParameter::Replace(CYContext &context, CYStatement *&statements) { $T() + CYAssignment *assignment(initialiser_->Assignment(context)); + context.Replace(initialiser_); + + next_->Replace(context, statements); + + if (assignment != NULL) + statements = $$->* + // XXX: this cast is quite incorrect + $ CYIf($ CYIdentical($ CYTypeOf(dynamic_cast(initialiser_)), $S("undefined")), $$->* + $E(assignment) + )->* + statements; } CYStatement *CYFunctionStatement::Replace(CYContext &context) { - Replace_(context); - return NULL; + context.scope_->Declare(context, name_, CYIdentifierOther); + CYFunction::Replace(context); + return this; +} + +CYIdentifier *CYIdentifier::Replace(CYContext &context) { + if (replace_ != NULL && replace_ != this) + return replace_->Replace(context); + replace_ = context.scope_->Lookup(context, this); + return replace_; +} + +CYStatement *CYIf::Return() { + CYImplicitReturn(true_); + CYImplicitReturn(false_); + return this; } CYStatement *CYIf::Replace(CYContext &context) { context.Replace(test_); - context.Replace(true_); - context.Replace(false_); - return NULL; + context.ReplaceAll(true_); + context.ReplaceAll(false_); + return this; } CYFunctionParameter *CYIfComprehension::Parameter(CYContext &context) const { @@ -316,42 +591,80 @@ CYStatement *CYIfComprehension::Replace(CYContext &context, CYStatement *stateme return $ CYIf(test_, CYComprehension::Replace(context, statement)); } +CYStatement *CYImport::Replace(CYContext &context) { + return $ CYVar($L1($L($I(module_->part_->Word()), $C1($V("require"), module_->Replace(context, "/"))))); +} + CYExpression *CYIndirect::Replace(CYContext &context) { - CYPrefix::Replace(context); return $M(rhs_, $S("$cyi")); } CYExpression *CYIndirectMember::Replace(CYContext &context) { - Replace_(context); return $M($ CYIndirect(object_), property_); } CYExpression *CYInfix::Replace(CYContext &context) { context.Replace(lhs_); context.Replace(rhs_); - return NULL; + return this; } CYStatement *CYLabel::Replace(CYContext &context) { context.Replace(statement_); - return NULL; + return this; +} + +CYExpression *CYLambda::Replace(CYContext &context) { + return $N2($V("Functor"), $ CYFunctionExpression(NULL, parameters_->Parameters(context), code_), parameters_->TypeSignature(context, typed_->Replace(context))); } CYStatement *CYLet::Replace(CYContext &context) { - return $ CYWith($ CYObject(declarations_->Property(context)), &code_); + declarations_->Replace(context); + if (CYExpression *expression = declarations_->Expression(context)) + return $E(expression); + return $ CYEmpty(); } -void CYMember::Replace_(CYContext &context) { - context.Replace(object_); - context.Replace(property_); +CYFunctionExpression *CYMethod::Constructor() { + return NULL; +} + +void CYMethod::Replace(CYContext &context) { + CYFunction::Replace(context); +} + +CYString *CYModule::Replace(CYContext &context, const char *separator) const { + if (next_ == NULL) + return $ CYString(part_); + return $ CYString($pool.strcat(next_->Replace(context, separator)->Value(), separator, part_->Word(), NULL)); +} + +CYExpression *CYMultiply::Replace(CYContext &context) { + CYInfix::Replace(context); + + if (CYNumber *lhn = lhs_->Number(context)) + if (CYNumber *rhn = rhs_->Number(context)) + return $D(lhn->Value() * rhn->Value()); + + return this; } -CYExpression *CYNew::Replace(CYContext &context) { +namespace cy { +namespace Syntax { + +CYExpression *New::AddArgument(CYContext &context, CYExpression *value) { + CYSetLast(arguments_) = $ CYArgument(value); + return this; +} + +CYExpression *New::Replace(CYContext &context) { context.Replace(constructor_); arguments_->Replace(context); - return NULL; + return this; } +} } + CYNumber *CYNull::Number(CYContext &context) { return $D(0); } @@ -366,57 +679,336 @@ CYNumber *CYNumber::Number(CYContext &context) { CYString *CYNumber::String(CYContext &context) { // XXX: there is a precise algorithm for this - return $S(apr_psprintf(context.pool_, "%.17g", Value())); + return $S($pool.sprintf(24, "%.17g", Value())); +} + +CYExpression *CYNumber::PropertyName(CYContext &context) { + return String(context); } CYExpression *CYObject::Replace(CYContext &context) { - properties_->Replace(context); - return NULL; + CYBuilder builder; + if (properties_ != NULL) + properties_ = properties_->ReplaceAll(context, builder, $ CYThis(), false); + + if (builder) { + return $C1($M($ CYFunctionExpression(NULL, builder.declarations_->Parameter(context), + builder.statements_->* + $ CYReturn($ CYThis()) + ), $S("call")), this, builder.declarations_->Argument(context)); + } + + CYForEach (property, properties_) + property->Replace(context); + return this; +} + +CYExpression *CYParenthetical::Replace(CYContext &context) { + return expression_; } CYExpression *CYPostfix::Replace(CYContext &context) { context.Replace(lhs_); - return NULL; + return this; } CYExpression *CYPrefix::Replace(CYContext &context) { context.Replace(rhs_); - return NULL; + return this; +} + +CYProperty *CYProperty::ReplaceAll(CYContext &context, CYBuilder &builder, CYExpression *self, bool update) { + update |= name_->Computed(); + if (update) + Replace(context, builder, self, false); + if (next_ != NULL) + next_ = next_->ReplaceAll(context, builder, self, update); + return update ? next_ : this; +} + +void CYProperty::Replace(CYContext &context, CYBuilder &builder, CYExpression *self, bool protect) { + CYExpression *name(name_->PropertyName(context)); + if (name_->Computed()) { + CYIdentifier *unique(context.Unique()); + builder.declarations_->*$L1($L(unique, name)); + name = $V(unique); + } + + Replace(context, builder, self, name, protect); +} + +void CYPropertyGetter::Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect) { + CYIdentifier *unique(context.Unique()); + builder.declarations_ + ->* $L1($L(unique, CYSuperize(context, $ CYFunctionExpression(NULL, parameters_, code_)))); + builder.statements_ + ->* CYDefineProperty(self, name, true, !protect, $ CYPropertyValue($S("get"), $V(unique))); } -void CYProgram::Replace(CYContext &context) { - statements_ = statements_->ReplaceAll(context); +CYFunctionExpression *CYPropertyMethod::Constructor() { + return name_->Constructor() ? $ CYFunctionExpression(NULL, parameters_, code_) : NULL; } -void CYProperty::Replace(CYContext &context) { $T() +void CYPropertyMethod::Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect) { + CYIdentifier *unique(context.Unique()); + builder.declarations_ + ->* $L1($L(unique, CYSuperize(context, $ CYFunctionExpression(NULL, parameters_, code_)))); + builder.statements_ + ->* (!protect ? $E($ CYAssign($M(self, name), $V(unique))) : + CYDefineProperty(self, name, true, !protect, $ CYPropertyValue($S("value"), $V(unique), $ CYPropertyValue($S("writable"), $ CYTrue())))); +} + +void CYPropertySetter::Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect) { + CYIdentifier *unique(context.Unique()); + builder.declarations_ + ->* $L1($L(unique, CYSuperize(context, $ CYFunctionExpression(NULL, parameters_, code_)))); + builder.statements_ + ->* CYDefineProperty(self, name, true, !protect, $ CYPropertyValue($S("set"), $V(unique))); +} + +void CYPropertyValue::Replace(CYContext &context, CYBuilder &builder, CYExpression *self, CYExpression *name, bool protect) { + _assert(!protect); + CYIdentifier *unique(context.Unique()); + builder.declarations_ + ->* $L1($L(unique, value_)); + builder.statements_ + ->* $E($ CYAssign($M(self, name), $V(unique))); +} + +void CYPropertyValue::Replace(CYContext &context) { context.Replace(value_); - next_->Replace(context); +} + +// XXX: this is evil evil black magic. don't ask, don't tell... don't believe! +#define MappingSet "0etnirsoalfucdphmgyvbxTwSNECAFjDLkMOIBPqzRH$_WXUVGYKQJZ" +//#define MappingSet "0abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_" + +namespace { + struct IdentifierUsageLess : + std::binary_function + { + _finline bool operator ()(CYIdentifier *lhs, CYIdentifier *rhs) const { + if (lhs->usage_ != rhs->usage_) + return lhs->usage_ > rhs->usage_; + return lhs < rhs; + } + }; + + typedef std::set IdentifierUsages; +} + +void CYScript::Replace(CYContext &context) { + CYScope scope(true, context); + + context.nextlocal_ = $ CYNonLocal(); + context.ReplaceAll(code_); + context.NonLocal(code_); + + scope.Close(context, code_); + + size_t offset(0); + + CYCStringSet external; + for (CYIdentifierValueSet::const_iterator i(scope.identifiers_.begin()); i != scope.identifiers_.end(); ++i) + external.insert((*i)->Word()); + + IdentifierUsages usages; + + if (offset < context.rename_.size()) + CYForEach (i, context.rename_[offset].identifier_) + usages.insert(i); + + // XXX: totalling the probable occurrences and sorting by them would improve the result + for (CYIdentifierUsageVector::const_iterator i(context.rename_.begin()); i != context.rename_.end(); ++i, ++offset) { + //std::cout << *i << ":" << (*i)->offset_ << std::endl; + + const char *name; + + if (context.options_.verbose_) + name = $pool.strcat("$", $pool.itoa(offset), NULL); + else { + char id[8]; + id[7] = '\0'; + + id: + unsigned position(7), local(offset + 1); + + do { + unsigned index(local % (sizeof(MappingSet) - 1)); + local /= sizeof(MappingSet) - 1; + id[--position] = MappingSet[index]; + } while (local != 0); + + if (external.find(id + position) != external.end()) { + ++offset; + goto id; + } + + name = $pool.strmemdup(id + position, 7 - position); + // XXX: at some point, this could become a keyword + } + + CYForEach (identifier, i->identifier_) + identifier->Set(name); + } } CYStatement *CYReturn::Replace(CYContext &context) { + if (context.nonlocal_ != NULL) { + CYProperty *value(value_ == NULL ? NULL : $ CYPropertyValue($S("$cyv"), value_)); + return $ cy::Syntax::Throw($ CYObject( + $ CYPropertyValue($S("$cyk"), $V(context.nonlocal_->Target(context)), value) + )); + } + context.Replace(value_); - return NULL; + return this; +} + +CYExpression *CYRubyBlock::Replace(CYContext &context) { + return call_->AddArgument(context, proc_->Replace(context)); +} + +CYExpression *CYRubyBlock::AddArgument(CYContext &context, CYExpression *value) { + return Replace(context)->AddArgument(context, value); +} + +CYExpression *CYRubyProc::Replace(CYContext &context) { + CYFunctionExpression *function($ CYFunctionExpression(NULL, parameters_, code_)); + function = CYNonLocalize(context, function); + function->implicit_ = true; + return function; +} + +CYScope::CYScope(bool transparent, CYContext &context) : + transparent_(transparent), + parent_(context.scope_) +{ + context.scope_ = this; +} + +void CYScope::Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags) { + if (!transparent_ || flags == CYIdentifierArgument || flags == CYIdentifierCatch) + internal_.insert(CYIdentifierAddressFlagsMap::value_type(identifier, flags)); + else if (parent_ != NULL) + parent_->Declare(context, identifier, flags); +} + +CYIdentifier *CYScope::Lookup(CYContext &context, CYIdentifier *identifier) { + std::pair insert(identifiers_.insert(identifier)); + return *insert.first; +} + +void CYScope::Merge(CYContext &context, CYIdentifier *identifier) { + std::pair insert(identifiers_.insert(identifier)); + if (!insert.second) { + if ((*insert.first)->offset_ < identifier->offset_) + (*insert.first)->offset_ = identifier->offset_; + identifier->replace_ = *insert.first; + (*insert.first)->usage_ += identifier->usage_ + 1; + } +} + +namespace { + struct IdentifierOffset { + size_t offset_; + CYIdentifierFlags flags_; + size_t usage_; + CYIdentifier *identifier_; + + IdentifierOffset(CYIdentifier *identifier, CYIdentifierFlags flags) : + offset_(identifier->offset_), + flags_(flags), + usage_(identifier->usage_), + identifier_(identifier) + { + } + }; + + struct IdentifierOffsetLess : + std::binary_function + { + _finline bool operator ()(const IdentifierOffset &lhs, const IdentifierOffset &rhs) const { + if (lhs.offset_ != rhs.offset_) + return lhs.offset_ < rhs.offset_; + if (lhs.flags_ != rhs.flags_) + return lhs.flags_ < rhs.flags_; + /*if (lhs.usage_ != rhs.usage_) + return lhs.usage_ < rhs.usage_;*/ + return lhs.identifier_ < rhs.identifier_; + } + }; + + typedef std::set IdentifierOffsets; } -CYStatement *CYStatement::ReplaceAll(CYContext &context) { $T(NULL) - CYStatement *replace(this); - context.Replace(replace); +void CYScope::Close(CYContext &context, CYStatement *&statements) { + context.scope_ = parent_; + + if (parent_ == NULL) + return; + + CYDeclarations *last(NULL), *curr(NULL); + + IdentifierOffsets offsets; + + for (CYIdentifierAddressFlagsMap::const_iterator i(internal_.begin()); i != internal_.end(); ++i) + if (i->second != CYIdentifierMagic) + offsets.insert(IdentifierOffset(i->first, i->second)); + + size_t offset(0); + + for (IdentifierOffsets::const_iterator i(offsets.begin()); i != offsets.end(); ++i) { + if (i->flags_ == CYIdentifierVariable) { + CYDeclarations *next($ CYDeclarations($ CYDeclaration(i->identifier_))); + if (last == NULL) + last = next; + if (curr != NULL) + curr->SetNext(next); + curr = next; + } + + if (offset < i->offset_) + offset = i->offset_; + if (context.rename_.size() <= offset) + context.rename_.resize(offset + 1); + + CYIdentifierUsage &rename(context.rename_[offset++]); + i->identifier_->SetNext(rename.identifier_); + rename.identifier_ = i->identifier_; + rename.usage_ += i->identifier_->usage_ + 1; + } + + if (last != NULL) { + CYVar *var($ CYVar(last)); + var->SetNext(statements); + statements = var; + } - if (CYStatement *next = next_->ReplaceAll(context)) - replace->SetNext(next); - else - replace->SetNext(next_); + for (CYIdentifierValueSet::const_iterator i(identifiers_.begin()); i != identifiers_.end(); ++i) + if (internal_.find(*i) == internal_.end()) { + //std::cout << *i << '=' << offset << std::endl; + if ((*i)->offset_ < offset) + (*i)->offset_ = offset; + parent_->Merge(context, *i); + } +} - return replace; +CYElementValue *CYSpan::Replace(CYContext &context) { $T(NULL) + return $ CYElementValue(expression_, $ CYElementValue(string_, next_->Replace(context))); +} + +CYStatement *CYStatement::Return() { + return this; } CYString *CYString::Concat(CYContext &context, CYString *rhs) const { size_t size(size_ + rhs->size_); - char *value(new(context.pool_) char[size + 1]); + char *value($ char[size + 1]); memcpy(value, value_, size_); memcpy(value + size_, rhs->value_, rhs->size_); value[size] = '\0'; - return $S(value); + return $S(value, size); } CYNumber *CYString::Number(CYContext &context) { @@ -424,18 +1016,36 @@ CYNumber *CYString::Number(CYContext &context) { return NULL; } +CYExpression *CYString::PropertyName(CYContext &context) { + return this; +} + CYString *CYString::String(CYContext &context) { return this; } +CYExpression *CYSuperAccess::Replace(CYContext &context) { + return $C1($M($M($M($V(context.super_), $S("prototype")), property_), $S("bind")), $ CYThis()); +} + +CYExpression *CYSuperCall::Replace(CYContext &context) { + return $C($C1($M($V(context.super_), $S("bind")), $ CYThis()), arguments_); +} + CYStatement *CYSwitch::Replace(CYContext &context) { context.Replace(value_); clauses_->Replace(context); - return NULL; + return this; +} + +CYExpression *CYTemplate::Replace(CYContext &context) { + return $C2($M($M($M($V("String"), $S("prototype")), $S("concat")), $S("apply")), $S(""), $ CYArray($ CYElementValue(string_, spans_->Replace(context)))); } CYExpression *CYThis::Replace(CYContext &context) { - return NULL; + if (context.this_ != NULL) + return $V(context.this_->Identifier(context)); + return this; } namespace cy { @@ -443,13 +1053,13 @@ namespace Syntax { CYStatement *Throw::Replace(CYContext &context) { context.Replace(value_); - return NULL; + return this; } } } CYExpression *CYTrivial::Replace(CYContext &context) { - return NULL; + return this; } CYNumber *CYTrue::Number(CYContext &context) { @@ -464,39 +1074,132 @@ namespace cy { namespace Syntax { CYStatement *Try::Replace(CYContext &context) { - code_.Replace(context); + context.ReplaceAll(code_); catch_->Replace(context); finally_->Replace(context); - return NULL; + return this; } } } +CYExpression *CYTypeArrayOf::Replace_(CYContext &context, CYExpression *type) { + return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("arrayOf")), $ CYArgument(size_))); +} + +CYExpression *CYTypeBlockWith::Replace_(CYContext &context, CYExpression *type) { + return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("blockWith")), parameters_->Argument(context))); +} + +CYExpression *CYTypeConstant::Replace_(CYContext &context, CYExpression *type) { + return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("constant")))); +} + +CYStatement *CYTypeDefinition::Replace(CYContext &context) { + return $E($ CYAssign($V(typed_->identifier_), typed_->Replace(context))); +} + +CYExpression *CYTypeError::Replace(CYContext &context) { + _assert(false); + return NULL; +} + +CYExpression *CYTypeModifier::Replace(CYContext &context, CYExpression *type) { $T(type) + return Replace_(context, type); +} + +CYExpression *CYTypeFunctionWith::Replace_(CYContext &context, CYExpression *type) { + return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("functionWith")), parameters_->Argument(context))); +} + +CYExpression *CYTypeLong::Replace(CYContext &context) { + return $ CYCall($ CYDirectMember(specifier_->Replace(context), $ CYString("long"))); +} + +CYExpression *CYTypePointerTo::Replace_(CYContext &context, CYExpression *type) { + return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("pointerTo")))); +} + +CYExpression *CYTypeShort::Replace(CYContext &context) { + return $ CYCall($ CYDirectMember(specifier_->Replace(context), $ CYString("short"))); +} + +CYExpression *CYTypeSigned::Replace(CYContext &context) { + return $ CYCall($ CYDirectMember(specifier_->Replace(context), $ CYString("signed"))); +} + +CYExpression *CYTypeUnsigned::Replace(CYContext &context) { + return $ CYCall($ CYDirectMember(specifier_->Replace(context), $ CYString("unsigned"))); +} + +CYExpression *CYTypeVariable::Replace(CYContext &context) { + return $V(name_); +} + +CYExpression *CYTypeVoid::Replace(CYContext &context) { + return $N1($V("Type"), $ CYString("v")); +} + +CYExpression *CYTypeVolatile::Replace_(CYContext &context, CYExpression *type) { + return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("volatile")))); +} + +CYExpression *CYTypedIdentifier::Replace(CYContext &context) { + return modifier_->Replace(context, specifier_->Replace(context)); +} + +CYTypeFunctionWith *CYTypedIdentifier::Function() { + CYTypeModifier **modifier(&modifier_); + if (*modifier == NULL) + return NULL; + while ((*modifier)->next_ != NULL) + modifier = &(*modifier)->next_; + CYTypeFunctionWith *function((*modifier)->Function()); + if (function == NULL) + return NULL; + *modifier = NULL; + return function; +} + +CYArgument *CYTypedParameter::Argument(CYContext &context) { $T(NULL) + return $ CYArgument(typed_->Replace(context), next_->Argument(context)); +} + +CYFunctionParameter *CYTypedParameter::Parameters(CYContext &context) { $T(NULL) + return $ CYFunctionParameter($ CYDeclaration(typed_->identifier_ ?: context.Unique()), next_->Parameters(context)); +} + +CYExpression *CYTypedParameter::TypeSignature(CYContext &context, CYExpression *prefix) { $T(prefix) + return next_->TypeSignature(context, $ CYAdd(prefix, typed_->Replace(context))); +} + CYStatement *CYVar::Replace(CYContext &context) { declarations_->Replace(context); - return NULL; + if (CYExpression *expression = declarations_->Expression(context)) + return $E(expression); + return $ CYEmpty(); } CYExpression *CYVariable::Replace(CYContext &context) { - return NULL; + context.Replace(name_); + return this; +} + +CYFunctionParameter *CYVariable::Parameter() const { + return $ CYFunctionParameter($ CYDeclaration(name_)); } CYStatement *CYWhile::Replace(CYContext &context) { context.Replace(test_); - context.Replace(code_); - return NULL; + context.ReplaceAll(code_); + return this; } CYStatement *CYWith::Replace(CYContext &context) { context.Replace(scope_); - context.Replace(code_); - return NULL; + context.ReplaceAll(code_); + return this; } -CYExpression *CYWord::ClassName(CYContext &context, bool object) { - CYString *name($S(this)); - if (object) - return $C1($V("objc_getClass"), name); - else - return name; +CYExpression *CYWord::PropertyName(CYContext &context) { + return $S(this); }