X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/6c093cce11bcc8875e4459b3670811227e8dafa7..13c7f2fb8fc0619c8da1b5c8a697f7894479b070:/Replace.cpp?ds=inline diff --git a/Replace.cpp b/Replace.cpp index 1285e8f..b658cf7 100644 --- a/Replace.cpp +++ b/Replace.cpp @@ -1,40 +1,22 @@ -/* Cycript - Inlining/Optimizing JavaScript Compiler - * Copyright (C) 2009 Jay Freeman (saurik) +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2013 Jay Freeman (saurik) */ -/* Modified BSD License {{{ */ +/* GNU 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: + * 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. * - * 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. + * 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. * - * 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. -*/ + * You should have received a copy of the GNU General Public License + * along with Cycript. If not, see . +**/ /* }}} */ #include "Parser.hpp" @@ -42,22 +24,24 @@ #include +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(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 this; } else if (rhs == NULL) { - rhs = rhp->String(context); + rhs = rhs_->String(context); if (rhs == NULL) return this; } @@ -65,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) { @@ -90,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) @@ -104,7 +96,7 @@ CYExpression *CYAssignment::Replace(CYContext &context) { } CYStatement *CYBlock::Replace(CYContext &context) { - statements_ = statements_->ReplaceAll(context); + context.ReplaceAll(statements_); if (statements_ == NULL) return $ CYEmpty(); return this; @@ -132,14 +124,20 @@ namespace cy { namespace Syntax { void Catch::Replace(CYContext &context) { $T() + CYScope scope(true, context, code_.statements_); + + context.Replace(name_); + context.scope_->Declare(context, name_, CYIdentifierCatch); + code_.Replace(context); + scope.Close(); } } } void CYClause::Replace(CYContext &context) { $T() context.Replace(case_); - statements_ = statements_->ReplaceAll(context); + context.ReplaceAll(statements_); next_->Replace(context); } @@ -148,8 +146,27 @@ CYStatement *CYComment::Replace(CYContext &context) { } CYExpression *CYCompound::Replace(CYContext &context) { - expressions_ = expressions_->ReplaceAll(context); - return expressions_ == NULL ? NULL : this; + if (next_ == NULL) + return expression_; + + 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; +} + +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) @@ -172,46 +189,93 @@ CYExpression *CYCondition::Replace(CYContext &context) { 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($ CYDeclaration(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)))); + + 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 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) { - return $ CYVariable(identifier_); +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 $ CYVariable(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)); } -CYCompound *CYDeclarations::Replace(CYContext &context) { - CYCompound *compound; - if (next_ == NULL) compound: - compound = $ CYCompound(); - else { - compound = next_->Replace(context); - if (compound == NULL) - goto compound; - } +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::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; } @@ -226,31 +290,24 @@ 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_)) { + expression_ = $ CYCompound(expression_, express->expression_); SetNext(express->next_); } - return this; -} - -CYStatement *CYExpress::Replace(CYContext &context) { context.Replace(expression_); if (expression_ == NULL) return $ CYEmpty(); + return this; } @@ -262,20 +319,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)); } -CYExpression *CYExpression::ReplaceAll(CYContext &context) { $T(NULL) - CYExpression *replace(this); - context.Replace(replace); - - if (CYExpression *next = next_->ReplaceAll(context)) - replace->SetNext(next); - else - replace->SetNext(next_); - - return replace; +CYAssignment *CYExpression::Assignment(CYContext &context) { + return NULL; } CYNumber *CYFalse::Number(CYContext &context) { @@ -286,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); } @@ -298,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_); @@ -307,35 +373,41 @@ 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($ CYVariable(name_), set_, CYComprehension::Replace(context, statement)); + return $ CYForIn($V(name_), 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 + ); + + CYIdentifier *cys($I("$cys")), *cyt($I("$cyt")); - return $ CYLet($L2($L($I("$cys"), set_), $L($I("$cyt"))), $$->* - $ CYForIn(cyt, cys, $ CYBlock($$->* - $E($ CYAssign(initialiser_->ForEachIn(context), $M(cys, cyt)))->* + return $ CYLetStatement($L2($ CYDeclaration(cys, set_), $ CYDeclaration(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($ CYDeclaration(name_)); } -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("$cys")), $$->* + $E($ CYAssign($V(cys), set_))->* + $ CYForIn($V(name_), $V(cys), $ CYBlock($$->* + $E($ CYAssign($V(name_), $M($V(cys), $V(name_))))->* CYComprehension::Replace(context, statement) )) ))); @@ -350,19 +422,44 @@ void CYFunction::Replace_(CYContext &context, bool outer) { if (outer) Inject(context); - CYScope scope; - scope.parent_ = context.scope_; - context.scope_ = &scope; + CYThisScope *_this(context.this_); + context.this_ = CYGetLast(&this_); + + 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, code_.statements_); if (!outer && name_ != NULL) Inject(context); - if (parameters_ != NULL) - parameters_ = parameters_->Replace(context, code_); + parameters_->Replace(context, code_); code_.Replace(context); - context.scope_ = scope.parent_; - scope.Scope(context, code_.statements_); + 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(); } CYExpression *CYFunctionExpression::Replace(CYContext &context) { @@ -370,12 +467,17 @@ CYExpression *CYFunctionExpression::Replace(CYContext &context) { return this; } -CYFunctionParameter *CYFunctionParameter::Replace(CYContext &context, CYBlock &code) { - name_ = name_->Replace(context); - 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) { @@ -406,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_); } @@ -426,29 +526,40 @@ 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 *CYNew::AddArgument(CYContext &context, CYExpression *value) { - CYArgument **argument(&arguments_); - while (*argument != NULL) - argument = &(*argument)->next_; - *argument = $ CYArgument(value); +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); return this; } -CYExpression *CYNew::Replace(CYContext &context) { +CYExpression *New::Replace(CYContext &context) { context.Replace(constructor_); arguments_->Replace(context); return this; } +} } + CYNumber *CYNull::Number(CYContext &context) { return $D(0); } @@ -463,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(context.pool_, "%.17g", Value())); + return $S($pool.sprintf(24, "%.17g", Value())); } CYExpression *CYObject::Replace(CYContext &context) { @@ -471,18 +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); - - CYVariable *name($ CYVariable(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; @@ -512,12 +611,13 @@ namespace { } void CYProgram::Replace(CYContext &context) { - CYScope scope; - scope.parent_ = context.scope_; - context.scope_ = &scope; - statements_ = statements_->ReplaceAll(context); - context.scope_ = scope.parent_; - scope.Scope(context, statements_); + CYScope scope(true, context, statements_); + + context.nextlocal_ = $ CYNonLocal(); + context.ReplaceAll(statements_); + context.NonLocal(statements_); + + scope.Close(); size_t offset(0); @@ -528,8 +628,8 @@ void CYProgram::Replace(CYContext &context) { IdentifierUsages usages; if (offset < context.rename_.size()) - for (CYIdentifier *i(context.rename_[offset].identifier_); i != NULL; i = i->next_) - usages.insert(i); + 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) { @@ -538,7 +638,7 @@ void CYProgram::Replace(CYContext &context) { const char *name; if (context.options_.verbose_) - name = apr_psprintf(context.pool_, "$%"APR_SIZE_T_FMT"", offset); + name = $pool.strcat("$", $pool.itoa(offset), NULL); else { char id[8]; id[7] = '\0'; @@ -557,11 +657,11 @@ void CYProgram::Replace(CYContext &context) { goto id; } - name = apr_pstrmemdup(context.pool_, id + position, 7 - position); + name = $pool.strmemdup(id + position, 7 - position); // XXX: at some point, this could become a keyword } - for (CYIdentifier *identifier(i->identifier_); identifier != NULL; identifier = identifier->next_) + CYForEach (identifier, i->identifier_) identifier->Set(name); } } @@ -569,9 +669,18 @@ 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) { + if (context.nonlocal_ != NULL) { + CYProperty *value(value_ == NULL ? NULL : $ CYProperty($S("$cyv"), value_)); + return $ cy::Syntax::Throw($ CYObject( + $ CYProperty($S("$cyk"), $V(context.nonlocal_->Target(context)), value) + )); + } + context.Replace(value_); return this; } @@ -582,11 +691,31 @@ CYExpression *CYRubyBlock::Replace(CYContext &context) { } CYExpression *CYRubyProc::Replace(CYContext &context) { - return $ CYFunctionExpression(NULL, parameters_, code_); + return CYNonLocalize(context, $ CYFunctionExpression(NULL, parameters_, code_)); +} + +CYScope::CYScope(bool transparent, CYContext &context, CYStatement *&statements) : + transparent_(transparent), + context_(context), + statements_(statements), + parent_(context.scope_) +{ + context_.scope_ = this; +} + +CYScope::~CYScope() { +} + +void CYScope::Close() { + context_.scope_ = parent_; + Scope(context_, statements_); } void CYScope::Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags) { - internal_.insert(CYIdentifierAddressFlagsMap::value_type(identifier, 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) { @@ -687,20 +816,9 @@ void CYScope::Scope(CYContext &context, CYStatement *&statements) { } } -CYStatement *CYStatement::Collapse(CYContext &context) { - return this; -} - -CYStatement *CYStatement::ReplaceAll(CYContext &context) { $T(NULL) - CYStatement *replace(this); - context.Replace(replace); - replace->SetNext(next_->ReplaceAll(context)); - return replace->Collapse(context); -} - 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'; @@ -723,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; } @@ -760,12 +880,92 @@ 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) { - name_ = name_->Replace(context); + context.Replace(name_); return this; }