Add libuv to the build (static linking for Apple).

[cycript.git] / Replace.cpp

diff --git a/Replace.cpp b/Replace.cpp
index 155aa58f2d464cfcd83432c0d03e8a6b700809d6..54e931ea7307166a197c33f424505b106aa8ae62 100644 (file)
--- a/Replace.cpp
+++ b/Replace.cpp
@@ -1,5 +1,5 @@
 /* Cycript - Optimizing JavaScript Compiler/Runtime
 /* Cycript - Optimizing JavaScript Compiler/Runtime

- * Copyright (C) 2009-2014  Jay Freeman (saurik)
+ * Copyright (C) 2009-2015  Jay Freeman (saurik)

 */
 
 /* GNU Affero General Public License, Version 3 {{{ */
 */
 
 /* GNU Affero General Public License, Version 3 {{{ */


@@ -19,16 +19,21 @@
 **/
 /* }}} */
 
 **/
 /* }}} */
 

-#include "Parser.hpp"
-#include "Replace.hpp"
-

 #include <iomanip>
 
 #include <iomanip>
 

+#include "Replace.hpp"
+#include "Syntax.hpp"
+

 CYFunctionExpression *CYNonLocalize(CYContext &context, CYFunctionExpression *function) {
     function->nonlocal_ = context.nextlocal_;
     return function;
 }
 
 CYFunctionExpression *CYNonLocalize(CYContext &context, CYFunctionExpression *function) {
     function->nonlocal_ = context.nextlocal_;
     return function;
 }
 

+static void CYImplicitReturn(CYStatement *&code) {
+    if (CYStatement *&last = CYGetLast(code))
+        last = last->Return();
+}
+

 CYExpression *CYAdd::Replace(CYContext &context) {
     CYInfix::Replace(context);
 
 CYExpression *CYAdd::Replace(CYContext &context) {
     CYInfix::Replace(context);
 


@@ -75,7 +80,8 @@ CYArgument *CYArgument::Replace(CYContext &context) { $T(NULL)
 }
 
 CYExpression *CYArray::Replace(CYContext &context) {
 }
 
 CYExpression *CYArray::Replace(CYContext &context) {

-    elements_->Replace(context);
+    if (elements_ != NULL)
+        elements_->Replace(context);

     return this;
 }
 
     return this;
 }
 


@@ -95,9 +101,14 @@ CYExpression *CYAssignment::Replace(CYContext &context) {
     return this;
 }
 
     return this;
 }
 

+CYStatement *CYBlock::Return() {
+    CYImplicitReturn(code_);
+    return this;
+}
+

 CYStatement *CYBlock::Replace(CYContext &context) {
 CYStatement *CYBlock::Replace(CYContext &context) {

-    context.ReplaceAll(statements_);
-    if (statements_ == NULL)
+    context.ReplaceAll(code_);
+    if (code_ == NULL)

         return $ CYEmpty();
     return this;
 }
         return $ CYEmpty();
     return this;
 }


@@ -124,31 +135,24 @@ namespace cy {
 namespace Syntax {
 
 void Catch::Replace(CYContext &context) { $T()
 namespace Syntax {
 
 void Catch::Replace(CYContext &context) { $T()

-    CYScope scope(true, context, code_.statements_);
+    CYScope scope(true, context);

 
     context.Replace(name_);
     context.scope_->Declare(context, name_, CYIdentifierCatch);
 
 
     context.Replace(name_);
     context.scope_->Declare(context, name_, CYIdentifierCatch);
 

-    code_.Replace(context);
-    scope.Close();
+    context.ReplaceAll(code_);
+    scope.Close(context, code_);

 }
 
 } }
 
 void CYClause::Replace(CYContext &context) { $T()
     context.Replace(case_);
 }
 
 } }
 
 void CYClause::Replace(CYContext &context) { $T()
     context.Replace(case_);

-    context.ReplaceAll(statements_);
+    context.ReplaceAll(code_);

     next_->Replace(context);
 }
 
     next_->Replace(context);
 }
 

-CYStatement *CYComment::Replace(CYContext &context) {
-    return this;
-}
-

 CYExpression *CYCompound::Replace(CYContext &context) {
 CYExpression *CYCompound::Replace(CYContext &context) {

-    if (next_ == NULL)
-        return expression_;
-

     context.Replace(expression_);
     context.Replace(next_);
 
     context.Replace(expression_);
     context.Replace(next_);
 


@@ -162,11 +166,17 @@ CYExpression *CYCompound::Replace(CYContext &context) {
     return this;
 }
 
     return this;
 }
 

-CYExpression *CYCompound::Primitive(CYContext &context) {
-    CYExpression *expression(expression_);
-    if (expression == NULL || next_ != NULL)
+CYFunctionParameter *CYCompound::Parameter() const {
+    CYFunctionParameter *next(next_->Parameter());
+    if (next == NULL)
+        return NULL;
+
+    CYFunctionParameter *parameter(expression_->Parameter());
+    if (parameter == NULL)

         return NULL;
         return NULL;

-    return expression->Primitive(context);
+
+    parameter->SetNext(next);
+    return parameter;

 }
 
 CYFunctionParameter *CYComprehension::Parameters(CYContext &context) const { $T(NULL)
 }
 
 CYFunctionParameter *CYComprehension::Parameters(CYContext &context) const { $T(NULL)


@@ -205,6 +215,7 @@ void CYContext::NonLocal(CYStatement *&statements) {
                     $ CYReturn($M($V(cye), $S("$cyv"))))->*
                 $ cy::Syntax::Throw($V(cye))));
 
                     $ 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);
 
         context.Replace(declare);
         rescue->Replace(context);
 


@@ -266,10 +277,13 @@ CYArgument *CYDeclarations::Argument(CYContext &context) { $T(NULL)
     return $ CYArgument(declaration_->initialiser_, next_->Argument(context));
 }
 
     return $ CYArgument(declaration_->initialiser_, next_->Argument(context));
 }
 

-CYCompound *CYDeclarations::Compound(CYContext &context) { $T(NULL)
-    CYCompound *compound(next_->Compound(context));
+CYExpression *CYDeclarations::Expression(CYContext &context) { $T(NULL)
+    CYExpression *compound(next_->Expression(context));

     if (CYAssignment *assignment = declaration_->Assignment(context))
     if (CYAssignment *assignment = declaration_->Assignment(context))

-        compound = $ CYCompound(assignment, compound);
+        if (compound == NULL)
+            compound = assignment;
+        else
+            compound = $ CYCompound(assignment, compound);

     return compound;
 }
 
     return compound;
 }
 


@@ -281,13 +295,18 @@ CYExpression *CYDirectMember::Replace(CYContext &context) {
 
 CYStatement *CYDoWhile::Replace(CYContext &context) {
     context.Replace(test_);
 
 CYStatement *CYDoWhile::Replace(CYContext &context) {
     context.Replace(test_);

-    context.Replace(code_);
+    context.ReplaceAll(code_);

     return this;
 }
 
     return this;
 }
 

-void CYElement::Replace(CYContext &context) { $T()
+void CYElementSpread::Replace(CYContext &context) {

     context.Replace(value_);
     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) {
 }
 
 CYStatement *CYEmpty::Replace(CYContext &context) {


@@ -298,16 +317,12 @@ CYExpression *CYEncodedType::Replace(CYContext &context) {
     return typed_->Replace(context);
 }
 
     return typed_->Replace(context);
 }
 

-CYStatement *CYExpress::Replace(CYContext &context) {
-    while (CYExpress *express = dynamic_cast<CYExpress *>(next_)) {
-        expression_ = $ CYCompound(expression_, express->expression_);
-        SetNext(express->next_);
-    }
+CYStatement *CYExpress::Return() {
+    return $ CYReturn(expression_);
+}

 
 

+CYStatement *CYExpress::Replace(CYContext &context) {

     context.Replace(expression_);
     context.Replace(expression_);

-    if (expression_ == NULL)
-        return $ CYEmpty();
-

     return this;
 }
 
     return this;
 }
 


@@ -327,6 +342,10 @@ CYAssignment *CYExpression::Assignment(CYContext &context) {
     return NULL;
 }
 
     return NULL;
 }
 

+CYFunctionParameter *CYExpression::Parameter() const {
+    return NULL;
+}
+

 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())))));
 }
 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())))));
 }


@@ -346,20 +365,20 @@ CYExpression *CYFatArrow::Replace(CYContext &context) {
 }
 
 void CYFinally::Replace(CYContext &context) { $T()
 }
 
 void CYFinally::Replace(CYContext &context) { $T()

-    code_.Replace(context);
+    context.ReplaceAll(code_);

 }
 
 CYStatement *CYFor::Replace(CYContext &context) {
     context.Replace(initialiser_);
     context.Replace(test_);
     context.Replace(increment_);
 }
 
 CYStatement *CYFor::Replace(CYContext &context) {
     context.Replace(initialiser_);
     context.Replace(test_);
     context.Replace(increment_);

-    context.Replace(code_);
+    context.ReplaceAll(code_);

     return this;
 }
 
     return this;
 }
 

-CYCompound *CYForDeclarations::Replace(CYContext &context) {
+CYExpression *CYForDeclarations::Replace(CYContext &context) {

     declarations_->Replace(context);
     declarations_->Replace(context);

-    return declarations_->Compound(context);
+    return declarations_->Expression(context);

 }
 
 // XXX: this still feels highly suboptimal
 }
 
 // XXX: this still feels highly suboptimal


@@ -372,16 +391,16 @@ CYStatement *CYForIn::Replace(CYContext &context) {
 
     context.Replace(initialiser_);
     context.Replace(set_);
 
     context.Replace(initialiser_);
     context.Replace(set_);

-    context.Replace(code_);
+    context.ReplaceAll(code_);

     return this;
 }
 
 CYFunctionParameter *CYForInComprehension::Parameter(CYContext &context) const {
     return this;
 }
 
 CYFunctionParameter *CYForInComprehension::Parameter(CYContext &context) const {

-    return $ CYFunctionParameter($ CYDeclaration(name_));
+    return $ CYFunctionParameter(declaration_);

 }
 
 CYStatement *CYForInComprehension::Replace(CYContext &context, CYStatement *statement) const {
 }
 
 CYStatement *CYForInComprehension::Replace(CYContext &context, CYStatement *statement) const {

-    return $ CYForIn($V(name_), set_, CYComprehension::Replace(context, statement));
+    return $ CYForIn(declaration_->Variable(context), set_, CYComprehension::Replace(context, statement));

 }
 
 CYStatement *CYForOf::Replace(CYContext &context) {
 }
 
 CYStatement *CYForOf::Replace(CYContext &context) {


@@ -402,7 +421,7 @@ CYStatement *CYForOf::Replace(CYContext &context) {
 }
 
 CYFunctionParameter *CYForOfComprehension::Parameter(CYContext &context) const {
 }
 
 CYFunctionParameter *CYForOfComprehension::Parameter(CYContext &context) const {

-    return $ CYFunctionParameter($ CYDeclaration(name_));
+    return $ CYFunctionParameter(declaration_);

 }
 
 CYStatement *CYForOfComprehension::Replace(CYContext &context, CYStatement *statement) const {
 }
 
 CYStatement *CYForOfComprehension::Replace(CYContext &context, CYStatement *statement) const {


@@ -410,8 +429,8 @@ CYStatement *CYForOfComprehension::Replace(CYContext &context, CYStatement *stat
 
     return $E($C0($F(NULL, $P1($L("$cys")), $$->*
         $E($ CYAssign($V(cys), set_))->*
 
     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_))))->*
+        $ CYForIn(declaration_->Variable(context), $V(cys), $ CYBlock($$->*
+            $E($ CYAssign(declaration_->Variable(context), $M($V(cys), declaration_->Variable(context))))->*

             CYComprehension::Replace(context, statement)
         ))
     )));
             CYComprehension::Replace(context, statement)
         ))
     )));


@@ -427,7 +446,8 @@ void CYFunction::Replace_(CYContext &context, bool outer) {
         Inject(context);
 
     CYThisScope *_this(context.this_);
         Inject(context);
 
     CYThisScope *_this(context.this_);

-    context.this_ = CYGetLast(&this_);
+    context.this_ = &this_;
+    context.this_ = CYGetLast(context.this_);

 
     CYNonLocal *nonlocal(context.nonlocal_);
     CYNonLocal *nextlocal(context.nextlocal_);
 
     CYNonLocal *nonlocal(context.nonlocal_);
     CYNonLocal *nextlocal(context.nextlocal_);


@@ -442,28 +462,31 @@ void CYFunction::Replace_(CYContext &context, bool outer) {
         context.nextlocal_ = nonlocal_;
     }
 
         context.nextlocal_ = nonlocal_;
     }
 

-    CYScope scope(!localize, context, code_.statements_);
+    CYScope scope(!localize, context);

 
     if (!outer && name_ != NULL)
         Inject(context);
 
     parameters_->Replace(context, code_);
 
     if (!outer && name_ != NULL)
         Inject(context);
 
     parameters_->Replace(context, code_);

-    code_.Replace(context);
+    context.ReplaceAll(code_);
+
+    if (implicit_)
+        CYImplicitReturn(code_);

 
     if (CYIdentifier *identifier = this_.identifier_)
 
     if (CYIdentifier *identifier = this_.identifier_)

-        code_.statements_ = $$->*
+        code_ = $$->*

             $ CYVar($L1($ CYDeclaration(identifier, $ CYThis())))->*
             $ CYVar($L1($ CYDeclaration(identifier, $ CYThis())))->*

-            code_.statements_;
+            code_;

 
     if (localize)
 
     if (localize)

-        context.NonLocal(code_.statements_);
+        context.NonLocal(code_);

 
     context.nextlocal_ = nextlocal;
     context.nonlocal_ = nonlocal;
 
     context.this_ = _this;
 
 
     context.nextlocal_ = nextlocal;
     context.nonlocal_ = nonlocal;
 
     context.this_ = _this;
 

-    scope.Close();
+    scope.Close(context, code_);

 }
 
 CYExpression *CYFunctionExpression::Replace(CYContext &context) {
 }
 
 CYExpression *CYFunctionExpression::Replace(CYContext &context) {


@@ -471,17 +494,19 @@ CYExpression *CYFunctionExpression::Replace(CYContext &context) {
     return this;
 }
 
     return this;
 }
 

-void CYFunctionParameter::Replace(CYContext &context, CYBlock &code) { $T()
+void CYFunctionParameter::Replace(CYContext &context, CYStatement *&statements) { $T()

     CYAssignment *assignment(initialiser_->Assignment(context));
     context.Replace(initialiser_);
 
     CYAssignment *assignment(initialiser_->Assignment(context));
     context.Replace(initialiser_);
 

-    next_->Replace(context, code);
+    next_->Replace(context, statements);

 
     if (assignment != NULL)
 
     if (assignment != NULL)

-        // XXX: this cast is quite incorrect
-        code.AddPrev($ CYIf($ CYIdentical($ CYTypeOf(dynamic_cast<CYExpression *>(initialiser_)), $S("undefined")), $$->*
-            $E(assignment)
-        ));
+        statements = $$->*
+            // XXX: this cast is quite incorrect
+            $ CYIf($ CYIdentical($ CYTypeOf(dynamic_cast<CYExpression *>(initialiser_)), $S("undefined")), $$->*
+                $E(assignment)
+            )->*
+            statements;

 }
 
 CYStatement *CYFunctionStatement::Replace(CYContext &context) {
 }
 
 CYStatement *CYFunctionStatement::Replace(CYContext &context) {


@@ -496,10 +521,16 @@ CYIdentifier *CYIdentifier::Replace(CYContext &context) {
     return replace_;
 }
 
     return replace_;
 }
 

+CYStatement *CYIf::Return() {
+    CYImplicitReturn(true_);
+    CYImplicitReturn(false_);
+    return this;
+}
+

 CYStatement *CYIf::Replace(CYContext &context) {
     context.Replace(test_);
 CYStatement *CYIf::Replace(CYContext &context) {
     context.Replace(test_);

-    context.Replace(true_);
-    context.Replace(false_);
+    context.ReplaceAll(true_);
+    context.ReplaceAll(false_);

     return this;
 }
 
     return this;
 }
 


@@ -535,7 +566,7 @@ CYStatement *CYLabel::Replace(CYContext &context) {
 }
 
 CYExpression *CYLambda::Replace(CYContext &context) {
 }
 
 CYExpression *CYLambda::Replace(CYContext &context) {

-    return $N2($V("Functor"), $ CYFunctionExpression(NULL, parameters_->Parameters(context), statements_), parameters_->TypeSignature(context, typed_->Replace(context)));
+    return $N2($V("Functor"), $ CYFunctionExpression(NULL, parameters_->Parameters(context), code_), parameters_->TypeSignature(context, typed_->Replace(context)));

 }
 
 CYStatement *CYLetStatement::Replace(CYContext &context) {
 }
 
 CYStatement *CYLetStatement::Replace(CYContext &context) {


@@ -596,6 +627,10 @@ CYExpression *CYObject::Replace(CYContext &context) {
     return this;
 }
 
     return this;
 }
 

+CYExpression *CYParenthetical::Replace(CYContext &context) {
+    return expression_;
+}
+

 CYExpression *CYPostfix::Replace(CYContext &context) {
     context.Replace(lhs_);
     return this;
 CYExpression *CYPostfix::Replace(CYContext &context) {
     context.Replace(lhs_);
     return this;


@@ -624,14 +659,14 @@ namespace {
     typedef std::set<CYIdentifier *, IdentifierUsageLess> IdentifierUsages;
 }
 
     typedef std::set<CYIdentifier *, IdentifierUsageLess> IdentifierUsages;
 }
 

-void CYProgram::Replace(CYContext &context) {
-    CYScope scope(true, context, statements_);
+void CYScript::Replace(CYContext &context) {
+    CYScope scope(true, context);

 
     context.nextlocal_ = $ CYNonLocal();
 
     context.nextlocal_ = $ CYNonLocal();

-    context.ReplaceAll(statements_);
-    context.NonLocal(statements_);
+    context.ReplaceAll(code_);
+    context.NonLocal(code_);

 
 

-    scope.Close();
+    scope.Close(context, code_);

 
     size_t offset(0);
 
 
     size_t offset(0);
 


@@ -700,29 +735,21 @@ CYStatement *CYReturn::Replace(CYContext &context) {
 }
 
 CYExpression *CYRubyBlock::Replace(CYContext &context) {
 }
 
 CYExpression *CYRubyBlock::Replace(CYContext &context) {

-    // XXX: this needs to do something much more epic to handle return

     return call_->AddArgument(context, proc_->Replace(context));
 }
 
 CYExpression *CYRubyProc::Replace(CYContext &context) {
     return call_->AddArgument(context, proc_->Replace(context));
 }
 
 CYExpression *CYRubyProc::Replace(CYContext &context) {

-    return CYNonLocalize(context, $ CYFunctionExpression(NULL, parameters_, code_));
+    CYFunctionExpression *function($ CYFunctionExpression(NULL, parameters_, code_));
+    function = CYNonLocalize(context, function);
+    function->implicit_ = true;
+    return function;

 }
 
 }
 

-CYScope::CYScope(bool transparent, CYContext &context, CYStatement *&statements) :
+CYScope::CYScope(bool transparent, CYContext &context) :

     transparent_(transparent),
     transparent_(transparent),

-    context_(context),
-    statements_(statements),

     parent_(context.scope_)
 {
     parent_(context.scope_)
 {

-    context_.scope_ = this;
-}
-
-CYScope::~CYScope() {
-}
-
-void CYScope::Close() {
-    context_.scope_ = parent_;
-    Scope(context_, statements_);
+    context.scope_ = this;

 }
 
 void CYScope::Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags) {
 }
 
 void CYScope::Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags) {


@@ -780,7 +807,9 @@ namespace {
     typedef std::set<IdentifierOffset, IdentifierOffsetLess> IdentifierOffsets;
 }
 
     typedef std::set<IdentifierOffset, IdentifierOffsetLess> IdentifierOffsets;
 }
 

-void CYScope::Scope(CYContext &context, CYStatement *&statements) {
+void CYScope::Close(CYContext &context, CYStatement *&statements) {
+    context.scope_ = parent_;
+

     if (parent_ == NULL)
         return;
 
     if (parent_ == NULL)
         return;
 


@@ -830,6 +859,14 @@ void CYScope::Scope(CYContext &context, CYStatement *&statements) {
         }
 }
 
         }
 }
 

+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($ char[size + 1]);
 CYString *CYString::Concat(CYContext &context, CYString *rhs) const {
     size_t size(size_ + rhs->size_);
     char *value($ char[size + 1]);


@@ -854,6 +891,10 @@ CYStatement *CYSwitch::Replace(CYContext &context) {
     return this;
 }
 
     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) {
     if (context.this_ != NULL)
         return $V(context.this_->Identifier(context));
 CYExpression *CYThis::Replace(CYContext &context) {
     if (context.this_ != NULL)
         return $V(context.this_->Identifier(context));


@@ -886,7 +927,7 @@ namespace cy {
 namespace Syntax {
 
 CYStatement *Try::Replace(CYContext &context) {
 namespace Syntax {
 
 CYStatement *Try::Replace(CYContext &context) {

-    code_.Replace(context);
+    context.ReplaceAll(code_);

     catch_->Replace(context);
     finally_->Replace(context);
     return this;
     catch_->Replace(context);
     finally_->Replace(context);
     return this;


@@ -959,6 +1000,19 @@ CYExpression *CYTypedIdentifier::Replace(CYContext &context) {
     return modifier_->Replace(context, specifier_->Replace(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));
 }
 CYArgument *CYTypedParameter::Argument(CYContext &context) { $T(NULL)
     return $ CYArgument(typed_->Replace(context), next_->Argument(context));
 }


@@ -973,8 +1027,8 @@ CYExpression *CYTypedParameter::TypeSignature(CYContext &context, CYExpression *
 
 CYStatement *CYVar::Replace(CYContext &context) {
     declarations_->Replace(context);
 
 CYStatement *CYVar::Replace(CYContext &context) {
     declarations_->Replace(context);

-    if (CYCompound *compound = declarations_->Compound(context))
-        return $E(compound);
+    if (CYExpression *expression = declarations_->Expression(context))
+        return $E(expression);

     return $ CYEmpty();
 }
 
     return $ CYEmpty();
 }
 


@@ -983,15 +1037,19 @@ CYExpression *CYVariable::Replace(CYContext &context) {
     return this;
 }
 
     return this;
 }
 

+CYFunctionParameter *CYVariable::Parameter() const {
+    return $ CYFunctionParameter($ CYDeclaration(name_));
+}
+

 CYStatement *CYWhile::Replace(CYContext &context) {
     context.Replace(test_);
 CYStatement *CYWhile::Replace(CYContext &context) {
     context.Replace(test_);

-    context.Replace(code_);
+    context.ReplaceAll(code_);

     return this;
 }
 
 CYStatement *CYWith::Replace(CYContext &context) {
     context.Replace(scope_);
     return this;
 }
 
 CYStatement *CYWith::Replace(CYContext &context) {
     context.Replace(scope_);

-    context.Replace(code_);
+    context.ReplaceAll(code_);

     return this;
 }
 
     return this;
 }