X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/e46761272105b911e12186212afa6e9373ff9641..3fe16be7c02b11754e3d367ffd228beb14da2555:/Replace.cpp diff --git a/Replace.cpp b/Replace.cpp index e6b761f..83a5c47 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 . **/ /* }}} */ @@ -24,6 +24,11 @@ #include +CYFunctionExpression *CYNonLocalize(CYContext &context, CYFunctionExpression *function) { + function->nonlocal_ = context.nextlocal_; + return function; +} + CYExpression *CYAdd::Replace(CYContext &context) { CYInfix::Replace(context); @@ -55,13 +60,21 @@ CYExpression *CYAdd::Replace(CYContext &context) { } 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 +85,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 +127,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); @@ -137,9 +150,20 @@ CYStatement *CYComment::Replace(CYContext &context) { CYExpression *CYCompound::Replace(CYContext &context) { context.ReplaceAll(expressions_); + if (expressions_ == NULL) + return NULL; return this; } +CYExpression *CYCompound::Primitive(CYContext &context) { + CYExpression *expression(expressions_); + if (expression == NULL) + return NULL; + while (expression->next_ != NULL) + expression = expression->next_; + return expression->Primitive(context); +} + CYFunctionParameter *CYComprehension::Parameters(CYContext &context) const { $T(NULL) CYFunctionParameter *next(next_->Parameters(context)); if (CYFunctionParameter *parameter = Parameter(context)) { @@ -168,7 +192,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, $$->* @@ -186,41 +210,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; } -CYExpression *CYDeclaration::ForEachIn(CYContext &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 $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) ?: $ CYCompound()); if (CYAssignment *assignment = declaration_->Assignment(context)) compound->AddPrev(assignment); return compound; } CYExpression *CYDirectMember::Replace(CYContext &context) { - Replace_(context); + context.Replace(object_); + context.Replace(property_); return this; } @@ -235,31 +285,28 @@ void CYElement::Replace(CYContext &context) { $T() next_->Replace(context); } -CYStatement *CYEmpty::Collapse(CYContext &context) { - return next_; +CYStatement *CYEmpty::Replace(CYContext &context) { + return NULL; } -CYStatement *CYEmpty::Replace(CYContext &context) { - return this; +CYExpression *CYEncodedType::Replace(CYContext &context) { + return typed_->Replace(context); } -CYStatement *CYExpress::Collapse(CYContext &context) { - if (CYExpress *express = dynamic_cast(next_)) { - CYCompound *next(dynamic_cast(express->expression_)); - if (next == NULL) - next = $ CYCompound(express->expression_); - next->AddPrev(expression_); - expression_ = next; +CYStatement *CYExpress::Replace(CYContext &context) { + while (CYExpress *express = dynamic_cast(next_)) { + CYCompound *compound(dynamic_cast(express->expression_)); + if (compound == NULL) + compound = $ CYCompound(express->expression_); + compound->AddPrev(expression_); + expression_ = compound; SetNext(express->next_); } - return this; -} - -CYStatement *CYExpress::Replace(CYContext &context) { context.Replace(expression_); if (expression_ == NULL) return $ CYEmpty(); + return this; } @@ -271,8 +318,12 @@ CYExpression *CYExpression::ClassName(CYContext &context, bool object) { return this; } -CYExpression *CYExpression::ForEachIn(CYContext &context) { - return this; +CYStatement *CYExpression::ForEachIn(CYContext &context, CYExpression *value) { + return $E($ CYAssign(this, value)); +} + +CYAssignment *CYExpression::Assignment(CYContext &context) { + return NULL; } CYNumber *CYFalse::Number(CYContext &context) { @@ -283,6 +334,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); } @@ -295,8 +352,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_); @@ -304,32 +372,38 @@ 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($$->* - $E($ CYAssign(initialiser_->ForEachIn(context), $M($V(cys), $V(cyt))))->* + 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($ 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_))))->* @@ -347,7 +421,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_); @@ -362,20 +437,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(); } @@ -384,12 +466,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(initialiser_)), $S("undefined")), $$->* + $E(assignment) + )); } CYStatement *CYFunctionStatement::Replace(CYContext &context) { @@ -420,12 +507,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_); } @@ -440,20 +525,19 @@ 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))); } namespace cy { namespace Syntax { CYExpression *New::AddArgument(CYContext &context, CYExpression *value) { - CYSetLast(arguments_, $ CYArgument(value)); + CYSetLast(arguments_) = $ CYArgument(value); return this; } @@ -479,7 +563,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) { @@ -487,19 +571,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; @@ -529,7 +600,7 @@ namespace { } void CYProgram::Replace(CYContext &context) { - CYScope scope(CYScopeProgram, context, statements_); + CYScope scope(true, context, statements_); context.nextlocal_ = $ CYNonLocal(); context.ReplaceAll(statements_); @@ -556,7 +627,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'; @@ -575,7 +646,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 } @@ -587,6 +658,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) { @@ -607,13 +680,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_) @@ -630,10 +701,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) { @@ -734,10 +805,6 @@ void CYScope::Scope(CYContext &context, CYStatement *&statements) { } } -CYStatement *CYStatement::Collapse(CYContext &context) { - return this; -} - CYString *CYString::Concat(CYContext &context, CYString *rhs) const { size_t size(size_ + rhs->size_); char *value($ char[size + 1]); @@ -763,6 +830,8 @@ CYStatement *CYSwitch::Replace(CYContext &context) { } CYExpression *CYThis::Replace(CYContext &context) { + if (context.this_ != NULL) + return $V(context.this_->Identifier(context)); return this; } @@ -800,8 +869,57 @@ 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 *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 *CYTypePointerTo::Replace_(CYContext &context, CYExpression *type) { + return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("pointerTo")))); +} + +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, type_); +} + +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_->type_->Replace(context))); +} + CYStatement *CYVar::Replace(CYContext &context) { - return $E(declarations_->Replace(context)); + declarations_->Replace(context); + return $E(declarations_->Compound(context)); } CYExpression *CYVariable::Replace(CYContext &context) {