X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/720a57a8df6f5f151bb263ef4e81e7834c5a9d96..13c7f2fb8fc0619c8da1b5c8a697f7894479b070:/Replace.cpp?ds=sidebyside diff --git a/Replace.cpp b/Replace.cpp index fb83630..b658cf7 100644 --- a/Replace.cpp +++ b/Replace.cpp @@ -1,20 +1,20 @@ /* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2010 Jay Freeman (saurik) + * Copyright (C) 2009-2013 Jay Freeman (saurik) */ -/* GNU Lesser General Public License, Version 3 {{{ */ +/* GNU General Public License, Version 3 {{{ */ /* - * Cycript is free software: you can redistribute it and/or modify it under - * the terms of the GNU Lesser General Public License as published by the - * Free Software Foundation, either version 3 of the License, or (at your - * option) any later version. + * Cycript is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published + * by the Free Software Foundation, either version 3 of the License, + * or (at your option) any later version. * - * Cycript 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 Lesser General Public - * License for more details. + * Cycript 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 General Public License for more details. * - * You should have received a copy of the GNU Lesser General Public License + * You should have received a copy of the GNU General Public License * along with Cycript. If not, see <http://www.gnu.org/licenses/>. **/ /* }}} */ @@ -24,22 +24,24 @@ #include <iomanip> +CYFunctionExpression *CYNonLocalize(CYContext &context, CYFunctionExpression *function) { + function->nonlocal_ = context.nextlocal_; + return function; +} + CYExpression *CYAdd::Replace(CYContext &context) { CYInfix::Replace(context); - CYExpression *lhp(lhs_->Primitive(context)); - CYExpression *rhp(rhs_->Primitive(context)); - - CYString *lhs(dynamic_cast<CYString *>(lhp)); - CYString *rhs(dynamic_cast<CYString *>(rhp)); + CYString *lhs(dynamic_cast<CYString *>(lhs_)); + CYString *rhs(dynamic_cast<CYString *>(rhs_)); if (lhs != NULL || rhs != NULL) { if (lhs == NULL) { - lhs = lhp->String(context); + lhs = lhs_->String(context); if (lhs == NULL) return this; } else if (rhs == NULL) { - rhs = rhp->String(context); + rhs = rhs_->String(context); if (rhs == NULL) return this; } @@ -47,21 +49,29 @@ CYExpression *CYAdd::Replace(CYContext &context) { 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 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) { @@ -72,7 +82,7 @@ CYExpression *CYArray::Replace(CYContext &context) { CYExpression *CYArrayComprehension::Replace(CYContext &context) { CYVariable *cyv($V("$cyv")); - return $C0($F(NULL, $P1("$cyv", comprehensions_->Parameters(context)), $$->* + return $C0($F(NULL, $P1($L("$cyv"), comprehensions_->Parameters(context)), $$->* $E($ CYAssign(cyv, $ CYArray()))->* comprehensions_->Replace(context, $E($C1($M(cyv, $S("push")), expression_)))->* $ CYReturn(cyv) @@ -114,7 +124,7 @@ namespace cy { namespace Syntax { void Catch::Replace(CYContext &context) { $T() - CYScope scope(CYScopeCatch, context, code_.statements_); + CYScope scope(true, context, code_.statements_); context.Replace(name_); context.scope_->Declare(context, name_, CYIdentifierCatch); @@ -136,12 +146,29 @@ CYStatement *CYComment::Replace(CYContext &context) { } CYExpression *CYCompound::Replace(CYContext &context) { - context.ReplaceAll(expressions_); - if (expressions_ == NULL) - return NULL; + if (next_ == NULL) + return expression_; + + context.Replace(expression_); + context.Replace(next_); + + if (CYCompound *compound = dynamic_cast<CYCompound *>(expression_)) { + expression_ = compound->expression_; + compound->expression_ = compound->next_; + compound->next_ = next_; + next_ = compound; + } + return this; } +CYExpression *CYCompound::Primitive(CYContext &context) { + CYExpression *expression(expression_); + if (expression == NULL || next_ != NULL) + return NULL; + return expression->Primitive(context); +} + CYFunctionParameter *CYComprehension::Parameters(CYContext &context) const { $T(NULL) CYFunctionParameter *next(next_->Parameters(context)); if (CYFunctionParameter *parameter = Parameter(context)) { @@ -170,7 +197,7 @@ void CYContext::NonLocal(CYStatement *&statements) { CYIdentifier *unique(nextlocal_->identifier_->Replace(context)); CYStatement *declare( - $ CYVar($L1($L(unique, $ CYObject())))); + $ CYVar($L1($ CYDeclaration(unique, $ CYObject())))); cy::Syntax::Catch *rescue( $ cy::Syntax::Catch(cye, $$->* @@ -188,41 +215,67 @@ void CYContext::NonLocal(CYStatement *&statements) { } CYIdentifier *CYContext::Unique() { - return $ CYIdentifier(apr_psprintf($pool, "$cy%u", unique_++)); + return $ CYIdentifier($pool.strcat("$cy", $pool.itoa(unique_++), NULL)); } CYStatement *CYContinue::Replace(CYContext &context) { return this; } +CYStatement *CYDebugger::Replace(CYContext &context) { + return this; +} + CYAssignment *CYDeclaration::Assignment(CYContext &context) { - CYExpression *variable(Replace(context)); - return initialiser_ == NULL ? NULL : $ CYAssign(variable, initialiser_); + if (initialiser_ == NULL) + return NULL; + + CYAssignment *value($ CYAssign(Variable(context), initialiser_)); + initialiser_ = NULL; + return value; +} + +CYVariable *CYDeclaration::Variable(CYContext &context) { + return $V(identifier_); } CYStatement *CYDeclaration::ForEachIn(CYContext &context, CYExpression *value) { - return $ CYVar($L1($L(identifier_, value))); + return $ CYVar($L1($ CYDeclaration(identifier_, value))); } CYExpression *CYDeclaration::Replace(CYContext &context) { context.Replace(identifier_); context.scope_->Declare(context, identifier_, CYIdentifierVariable); - return $V(identifier_); + return Variable(context); +} + +void CYDeclarations::Replace(CYContext &context) { $T() + declaration_->Replace(context); + next_->Replace(context); } CYProperty *CYDeclarations::Property(CYContext &context) { $T(NULL) - return $ CYProperty(declaration_->identifier_, declaration_->initialiser_ ?: $U, next_->Property(context)); + return $ CYProperty(declaration_->identifier_, declaration_->initialiser_, next_->Property(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)); } -CYCompound *CYDeclarations::Replace(CYContext &context) { - CYCompound *compound(next_ == NULL ? $ CYCompound() : next_->Replace(context)); +CYCompound *CYDeclarations::Compound(CYContext &context) { $T(NULL) + CYCompound *compound(next_->Compound(context)); if (CYAssignment *assignment = declaration_->Assignment(context)) - compound->AddPrev(assignment); + compound = $ CYCompound(assignment, compound); return compound; } CYExpression *CYDirectMember::Replace(CYContext &context) { - Replace_(context); + context.Replace(object_); + context.Replace(property_); return this; } @@ -241,13 +294,13 @@ CYStatement *CYEmpty::Replace(CYContext &context) { return NULL; } +CYExpression *CYEncodedType::Replace(CYContext &context) { + return typed_->Replace(context); +} + CYStatement *CYExpress::Replace(CYContext &context) { while (CYExpress *express = dynamic_cast<CYExpress *>(next_)) { - CYCompound *compound(dynamic_cast<CYCompound *>(express->expression_)); - if (compound == NULL) - compound = $ CYCompound(express->expression_); - compound->AddPrev(expression_); - expression_ = compound; + expression_ = $ CYCompound(expression_, express->expression_); SetNext(express->next_); } @@ -270,6 +323,10 @@ CYStatement *CYExpression::ForEachIn(CYContext &context, CYExpression *value) { return $E($ CYAssign(this, value)); } +CYAssignment *CYExpression::Assignment(CYContext &context) { + return NULL; +} + CYNumber *CYFalse::Number(CYContext &context) { return $D(0); } @@ -278,6 +335,12 @@ 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); } @@ -290,8 +353,19 @@ CYStatement *CYFor::Replace(CYContext &context) { return this; } +CYCompound *CYForDeclarations::Replace(CYContext &context) { + declarations_->Replace(context); + return declarations_->Compound(context); +} + +// XXX: this still feels highly suboptimal CYStatement *CYForIn::Replace(CYContext &context) { - // XXX: this actually might need a prefix statement + if (CYAssignment *assignment = initialiser_->Assignment(context)) + return $ CYBlock($$->* + $E(assignment)->* + this + ); + context.Replace(initialiser_); context.Replace(set_); context.Replace(code_); @@ -299,17 +373,23 @@ CYStatement *CYForIn::Replace(CYContext &context) { } CYFunctionParameter *CYForInComprehension::Parameter(CYContext &context) const { - return $ CYFunctionParameter(name_); + return $ CYFunctionParameter($ CYDeclaration(name_)); } CYStatement *CYForInComprehension::Replace(CYContext &context, CYStatement *statement) const { return $ CYForIn($V(name_), set_, CYComprehension::Replace(context, statement)); } -CYStatement *CYForEachIn::Replace(CYContext &context) { +CYStatement *CYForOf::Replace(CYContext &context) { + if (CYAssignment *assignment = initialiser_->Assignment(context)) + return $ CYBlock($$->* + $E(assignment)->* + this + ); + CYIdentifier *cys($I("$cys")), *cyt($I("$cyt")); - return $ CYLet($L2($L(cys, set_), $L(cyt)), $$->* + return $ CYLetStatement($L2($ CYDeclaration(cys, set_), $ CYDeclaration(cyt)), $$->* $ CYForIn($V(cyt), $V(cys), $ CYBlock($$->* initialiser_->ForEachIn(context, $M($V(cys), $V(cyt)))->* code_ @@ -317,14 +397,14 @@ CYStatement *CYForEachIn::Replace(CYContext &context) { ); } -CYFunctionParameter *CYForEachInComprehension::Parameter(CYContext &context) const { - return $ CYFunctionParameter(name_); +CYFunctionParameter *CYForOfComprehension::Parameter(CYContext &context) const { + return $ CYFunctionParameter($ CYDeclaration(name_)); } -CYStatement *CYForEachInComprehension::Replace(CYContext &context, CYStatement *statement) const { +CYStatement *CYForOfComprehension::Replace(CYContext &context, CYStatement *statement) const { CYIdentifier *cys($I("cys")); - return $E($C0($F(NULL, $P1("$cys"), $$->* + return $E($C0($F(NULL, $P1($L("$cys")), $$->* $E($ CYAssign($V(cys), set_))->* $ CYForIn($V(name_), $V(cys), $ CYBlock($$->* $E($ CYAssign($V(name_), $M($V(cys), $V(name_))))->* @@ -342,7 +422,8 @@ void CYFunction::Replace_(CYContext &context, bool outer) { if (outer) Inject(context); - CYScope scope(CYScopeFunction, context, code_.statements_); + CYThisScope *_this(context.this_); + context.this_ = CYGetLast(&this_); CYNonLocal *nonlocal(context.nonlocal_); CYNonLocal *nextlocal(context.nextlocal_); @@ -357,20 +438,27 @@ void CYFunction::Replace_(CYContext &context, bool outer) { context.nextlocal_ = nonlocal_; } + CYScope scope(!localize, context, code_.statements_); + if (!outer && name_ != NULL) Inject(context); - if (parameters_ != NULL) - parameters_ = parameters_->Replace(context, code_); - + parameters_->Replace(context, code_); code_.Replace(context); + if (CYIdentifier *identifier = this_.identifier_) + code_.statements_ = $$->* + $ CYVar($L1($ CYDeclaration(identifier, $ CYThis())))->* + code_.statements_; + if (localize) context.NonLocal(code_.statements_); context.nextlocal_ = nextlocal; context.nonlocal_ = nonlocal; + context.this_ = _this; + scope.Close(); } @@ -379,12 +467,17 @@ CYExpression *CYFunctionExpression::Replace(CYContext &context) { return this; } -CYFunctionParameter *CYFunctionParameter::Replace(CYContext &context, CYBlock &code) { - context.Replace(name_); - context.scope_->Declare(context, name_, CYIdentifierArgument); - if (next_ != NULL) - next_ = next_->Replace(context, code); - return this; +void CYFunctionParameter::Replace(CYContext &context, CYBlock &code) { $T() + CYAssignment *assignment(initialiser_->Assignment(context)); + context.Replace(initialiser_); + + next_->Replace(context, code); + + if (assignment != NULL) + // XXX: this cast is quite incorrect + code.AddPrev($ CYIf($ CYIdentical($ CYTypeOf(dynamic_cast<CYExpression *>(initialiser_)), $S("undefined")), $$->* + $E(assignment) + )); } CYStatement *CYFunctionStatement::Replace(CYContext &context) { @@ -415,12 +508,10 @@ CYStatement *CYIfComprehension::Replace(CYContext &context, CYStatement *stateme } 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_); } @@ -435,20 +526,29 @@ CYStatement *CYLabel::Replace(CYContext &context) { return this; } -CYStatement *CYLet::Replace(CYContext &context) { - return $ CYWith($ CYObject(declarations_->Property(context)), &code_); +CYExpression *CYLambda::Replace(CYContext &context) { + return $N2($V("Functor"), $ CYFunctionExpression(NULL, parameters_->Parameters(context), statements_), parameters_->TypeSignature(context, typed_->Replace(context))); } -void CYMember::Replace_(CYContext &context) { - context.Replace(object_); - context.Replace(property_); +CYStatement *CYLetStatement::Replace(CYContext &context) { + return $E($ CYCall(CYNonLocalize(context, $ CYFunctionExpression(NULL, declarations_->Parameter(context), code_)), declarations_->Argument(context))); +} + +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; } namespace cy { namespace Syntax { CYExpression *New::AddArgument(CYContext &context, CYExpression *value) { - CYSetLast(arguments_, $ CYArgument(value)); + CYSetLast(arguments_) = $ CYArgument(value); return this; } @@ -474,7 +574,7 @@ CYNumber *CYNumber::Number(CYContext &context) { CYString *CYNumber::String(CYContext &context) { // XXX: there is a precise algorithm for this - return $S(apr_psprintf($pool, "%.17g", Value())); + return $S($pool.sprintf(24, "%.17g", Value())); } CYExpression *CYObject::Replace(CYContext &context) { @@ -482,19 +582,6 @@ CYExpression *CYObject::Replace(CYContext &context) { return this; } -CYFunctionParameter *CYOptionalFunctionParameter::Replace(CYContext &context, CYBlock &code) { - CYFunctionParameter *parameter($ CYFunctionParameter(name_, next_)); - parameter = parameter->Replace(context, code); - context.Replace(initializer_); - - CYVariable *name($V(name_)); - code.AddPrev($ CYIf($ CYIdentical($ CYTypeOf(name), $S("undefined")), $$->* - $E($ CYAssign(name, initializer_)) - )); - - return parameter; -} - CYExpression *CYPostfix::Replace(CYContext &context) { context.Replace(lhs_); return this; @@ -524,7 +611,7 @@ namespace { } void CYProgram::Replace(CYContext &context) { - CYScope scope(CYScopeProgram, context, statements_); + CYScope scope(true, context, statements_); context.nextlocal_ = $ CYNonLocal(); context.ReplaceAll(statements_); @@ -551,7 +638,7 @@ void CYProgram::Replace(CYContext &context) { const char *name; if (context.options_.verbose_) - name = apr_psprintf($pool, "$%"APR_SIZE_T_FMT"", offset); + name = $pool.strcat("$", $pool.itoa(offset), NULL); else { char id[8]; id[7] = '\0'; @@ -570,7 +657,7 @@ void CYProgram::Replace(CYContext &context) { goto id; } - name = apr_pstrmemdup($pool, id + position, 7 - position); + name = $pool.strmemdup(id + position, 7 - position); // XXX: at some point, this could become a keyword } @@ -582,6 +669,8 @@ void CYProgram::Replace(CYContext &context) { void CYProperty::Replace(CYContext &context) { $T() context.Replace(value_); next_->Replace(context); + if (value_ == NULL) + value_ = $U; } CYStatement *CYReturn::Replace(CYContext &context) { @@ -602,13 +691,11 @@ CYExpression *CYRubyBlock::Replace(CYContext &context) { } CYExpression *CYRubyProc::Replace(CYContext &context) { - CYFunctionExpression *function($ CYFunctionExpression(NULL, parameters_, code_)); - function->nonlocal_ = context.nextlocal_; - return function; + return CYNonLocalize(context, $ CYFunctionExpression(NULL, parameters_, code_)); } -CYScope::CYScope(CYScopeType type, CYContext &context, CYStatement *&statements) : - type_(type), +CYScope::CYScope(bool transparent, CYContext &context, CYStatement *&statements) : + transparent_(transparent), context_(context), statements_(statements), parent_(context.scope_) @@ -625,10 +712,10 @@ void CYScope::Close() { } void CYScope::Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags) { - if (type_ == CYScopeCatch && flags != CYIdentifierCatch) - parent_->Declare(context, identifier, flags); - else + 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) { @@ -754,6 +841,8 @@ CYStatement *CYSwitch::Replace(CYContext &context) { } CYExpression *CYThis::Replace(CYContext &context) { + if (context.this_ != NULL) + return $V(context.this_->Identifier(context)); return this; } @@ -791,8 +880,88 @@ CYStatement *Try::Replace(CYContext &context) { } } +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)); +} + +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) { - return $E(declarations_->Replace(context)); + declarations_->Replace(context); + if (CYCompound *compound = declarations_->Compound(context)) + return $E(compound); + return $ CYEmpty(); } CYExpression *CYVariable::Replace(CYContext &context) {