Use CYForDeclarations as indirection to finish CYLet.

diff --git a/Cycript.yy.in b/Cycript.yy.in
index 9c05469a3445eebc81fdba7f69e07e55e6934266..56b023aa0f5351e8cc323d67dde87db99a919d72 100644 (file)
--- a/Cycript.yy.in
+++ b/Cycript.yy.in
@@ -396,7 +396,7 @@ int cylex(YYSTYPE *, cy::location *, void *);
 %type <statement_> LabelledStatement
 %type <expression_> LeftHandSideExpression
 %type <expression_> LeftHandSideExpressionNoBF
 %type <statement_> LabelledStatement
 %type <expression_> LeftHandSideExpression
 %type <expression_> LeftHandSideExpressionNoBF

-//%type <statement_> LetStatement
+%type <statement_> LetStatement

 %type <literal_> Literal
 %type <literal_> LiteralNoRE
 %type <literal_> LiteralRE
 %type <literal_> Literal
 %type <literal_> LiteralNoRE
 %type <literal_> LiteralRE


@@ -1379,7 +1379,7 @@ ForStatement
 
 ForStatementInitialiser
     : ExpressionNoInOpt { $$ = $1; }
 
 ForStatementInitialiser
     : ExpressionNoInOpt { $$ = $1; }

-    | LexSetRegExp "var" VariableDeclarationListNoIn { $$ = $3; }
+    | LexSetRegExp "var" VariableDeclarationListNoIn { $$ = CYNew CYForDeclarations($3); }

     ;
 /* }}} */
 /* 12.6.4 The for-in Statement {{{ */
     ;
 /* }}} */
 /* 12.6.4 The for-in Statement {{{ */


@@ -1914,15 +1914,15 @@ ForInStatement
     : "for" "each" "(" ForInStatementInitialiser "in" Expression ")" Statement { $$ = CYNew CYForEachIn($4, $6, $8); }
     ;
 /* }}} */
     : "for" "each" "(" ForInStatementInitialiser "in" Expression ")" Statement { $$ = CYNew CYForEachIn($4, $6, $8); }
     ;
 /* }}} */

-/* JavaScript 1.7: let Statements {{{ *//*
+/* JavaScript 1.7: let Statements {{{ */

 LetStatement
 LetStatement

-    : "let" "(" VariableDeclarationList ")" Block_ { $$ = CYNew CYLet($3, $5); }
+    : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLet($3, $5); }

     ;
 
 Statement_
     : LetStatement
     ;
     ;
 
 Statement_
     : LetStatement
     ;

-*//* }}} */
+/* }}} */

 
 /* JavaScript FTW: Function Statements {{{ */
 Statement
 
 /* JavaScript FTW: Function Statements {{{ */
 Statement

diff --git a/Output.cpp b/Output.cpp
index 122f6c725db7dfcd16045f4e6caf9b7876a3f418..cd04e2ed0bb5fbb89709b983041331e0033057f8 100644 (file)
--- a/Output.cpp
+++ b/Output.cpp
@@ -250,9 +250,9 @@ void CYDeclaration::Output(CYOutput &out, CYFlags flags) const {
     }
 }
 
     }
 }
 

-void CYDeclarations::For(CYOutput &out) const {
+void CYForDeclarations::Output(CYOutput &out, CYFlags flags) const {

     out << "var";
     out << "var";

-    Output(out, CYNoIn);
+    Output(out, CYRight(flags));

 }
 
 void CYDeclarations::Output(CYOutput &out) const {
 }
 
 void CYDeclarations::Output(CYOutput &out) const {


@@ -314,10 +314,6 @@ void CYExpression::ClassName(CYOutput &out, bool object) const {
     Output(out, CYAssign::Precedence_, CYNoFlags);
 }
 
     Output(out, CYAssign::Precedence_, CYNoFlags);
 }
 

-void CYExpression::For(CYOutput &out) const {
-    Output(out, CYNoIn);
-}
-

 void CYExpression::ForIn(CYOutput &out, CYFlags flags) const {
     Output(out, flags | CYNoRightHand);
 }
 void CYExpression::ForIn(CYOutput &out, CYFlags flags) const {
     Output(out, flags | CYNoRightHand);
 }


@@ -340,7 +336,7 @@ void CYFinally::Output(CYOutput &out) const {
 void CYFor::Output(CYOutput &out, CYFlags flags) const {
     out << "for" << ' ' << '(';
     if (initialiser_ != NULL)
 void CYFor::Output(CYOutput &out, CYFlags flags) const {
     out << "for" << ' ' << '(';
     if (initialiser_ != NULL)

-        initialiser_->For(out);
+        initialiser_->Output(out, CYNoIn);

     out.Terminate();
     if (test_ != NULL)
         out << ' ';
     out.Terminate();
     if (test_ != NULL)
         out << ' ';


@@ -468,7 +464,8 @@ void CYLabel::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYLet::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYLet::Output(CYOutput &out, CYFlags flags) const {

-    out << "let" << ' ' << '(' << *declarations_ << ')' << ' ' << code_;
+    out << "let" << ' ' << '(' << *declarations_ << ')';
+    code_->Single(out, CYRight(flags));

 }
 
 namespace cy {
 }
 
 namespace cy {

diff --git a/Parser.hpp b/Parser.hpp
index d711d1db1e008a4360d0bdf2e842833d0d6e1852..db4b1e6f297dc6f9a51ee2dd2f7aa784f318241f 100644 (file)
--- a/Parser.hpp
+++ b/Parser.hpp
@@ -530,8 +530,8 @@ struct CYForInitialiser {
     virtual ~CYForInitialiser() {
     }
 
     virtual ~CYForInitialiser() {
     }
 

-    virtual void For(CYOutput &out) const = 0;

     virtual CYExpression *Replace(CYContext &context) = 0;
     virtual CYExpression *Replace(CYContext &context) = 0;

+    virtual void Output(CYOutput &out, CYFlags flags) const = 0;

 };
 
 struct CYForInInitialiser {
 };
 
 struct CYForInInitialiser {


@@ -561,7 +561,6 @@ struct CYExpression :
         return true;
     }
 
         return true;
     }
 

-    virtual void For(CYOutput &out) const;

     virtual void ForIn(CYOutput &out, CYFlags flags) const;
     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value);
 
     virtual void ForIn(CYOutput &out, CYFlags flags) const;
     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value);
 


@@ -1171,15 +1170,16 @@ struct CYDeclaration :
     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value);
 
     virtual CYExpression *Replace(CYContext &context);
     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value);
 
     virtual CYExpression *Replace(CYContext &context);

+

     virtual CYAssignment *Assignment(CYContext &context);
     virtual CYAssignment *Assignment(CYContext &context);

+    CYVariable *Variable(CYContext &context);

 
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYDeclarations :
     CYNext<CYDeclarations>,
 
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYDeclarations :
     CYNext<CYDeclarations>,

-    CYThing,
-    CYForInitialiser
+    CYThing

 {
     CYDeclaration *declaration_;
 
 {
     CYDeclaration *declaration_;
 


@@ -1189,15 +1189,31 @@ struct CYDeclarations :
     {
     }
 
     {
     }
 

-    virtual void For(CYOutput &out) const;
+    void Replace(CYContext &context);

 
 

-    virtual CYCompound *Replace(CYContext &context);
+    CYCompound *Compound(CYContext &context);

     CYProperty *Property(CYContext &context);
     CYProperty *Property(CYContext &context);

+    CYArgument *Argument(CYContext &context);
+    CYFunctionParameter *Parameter(CYContext &context);

 
     virtual void Output(CYOutput &out) const;
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 
     virtual void Output(CYOutput &out) const;
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 

+struct CYForDeclarations :
+    CYForInitialiser
+{
+    CYDeclarations *declarations_;
+
+    CYForDeclarations(CYDeclarations *declarations) :
+        declarations_(declarations)
+    {
+    }
+
+    virtual CYCompound *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+

 struct CYVar :
     CYStatement
 {
 struct CYVar :
     CYStatement
 {


@@ -1216,11 +1232,11 @@ struct CYLet :
     CYStatement
 {
     CYDeclarations *declarations_;
     CYStatement
 {
     CYDeclarations *declarations_;

-    CYBlock code_;
+    CYStatement *code_;

 
 

-    CYLet(CYDeclarations *declarations, CYStatement *statements) :
+    CYLet(CYDeclarations *declarations, CYStatement *code) :

         declarations_(declarations),
         declarations_(declarations),

-        code_(statements)
+        code_(code)

     {
     }
 
     {
     }
 

diff --git a/Replace.cpp b/Replace.cpp
index c9f57b8dff93d791d1161ea81419a74140575c95..2caa728e32e4ed39af2d64a12b763357dcb7ddf4 100644 (file)
--- a/Replace.cpp
+++ b/Replace.cpp
@@ -196,10 +196,13 @@ CYStatement *CYContinue::Replace(CYContext &context) {
 }
 
 CYAssignment *CYDeclaration::Assignment(CYContext &context) {
 }
 
 CYAssignment *CYDeclaration::Assignment(CYContext &context) {

-    context.Replace(identifier_);
-    CYExpression *variable(Replace(context));
-    context.scope_->Declare(context, identifier_, CYIdentifierVariable);
-    return initialiser_ == NULL ? NULL : $ CYAssign(variable, initialiser_);
+    if (initialiser_ == NULL)
+        return NULL;
+    return $ CYAssign(Variable(context), initialiser_);
+}
+
+CYVariable *CYDeclaration::Variable(CYContext &context) {
+    return $V(identifier_);

 }
 
 CYStatement *CYDeclaration::ForEachIn(CYContext &context, CYExpression *value) {
 }
 
 CYStatement *CYDeclaration::ForEachIn(CYContext &context, CYExpression *value) {


@@ -207,15 +210,30 @@ CYStatement *CYDeclaration::ForEachIn(CYContext &context, CYExpression *value) {
 }
 
 CYExpression *CYDeclaration::Replace(CYContext &context) {
 }
 
 CYExpression *CYDeclaration::Replace(CYContext &context) {

-    return $V(identifier_);
+    context.Replace(identifier_);
+    context.scope_->Declare(context, identifier_, CYIdentifierVariable);
+    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));
 }
 
 }
 
 CYProperty *CYDeclarations::Property(CYContext &context) { $T(NULL)
     return $ CYProperty(declaration_->identifier_, declaration_->initialiser_ ?: $U, next_->Property(context));
 }
 

-CYCompound *CYDeclarations::Replace(CYContext &context) {
-    CYCompound *compound(next_ == NULL ? $ CYCompound() : next_->Replace(context));
+CYFunctionParameter *CYDeclarations::Parameter(CYContext &context) { $T(NULL)
+    return $ CYFunctionParameter(declaration_->identifier_, next_->Parameter(context));
+}
+
+CYArgument *CYDeclarations::Argument(CYContext &context) { $T(NULL)
+    return $ CYArgument(declaration_->initialiser_ ?: $U, next_->Argument(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;
     if (CYAssignment *assignment = declaration_->Assignment(context))
         compound->AddPrev(assignment);
     return compound;


@@ -294,20 +312,26 @@ CYStatement *CYFor::Replace(CYContext &context) {
     return this;
 }
 
     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) {
 CYStatement *CYForIn::Replace(CYContext &context) {

-    CYAssignment *assignment(initialiser_->Assignment(context));
+    CYForInInitialiser *initialiser(initialiser_);

 
     context.Replace(initialiser_);
     context.Replace(set_);
     context.Replace(code_);
 
 
     context.Replace(initialiser_);
     context.Replace(set_);
     context.Replace(code_);
 

-    if (assignment == NULL)
-        return this;
+    if (CYAssignment *assignment = initialiser->Assignment(context))
+        return $ CYBlock($$->*
+            $E(assignment)->*
+            this
+        );

 
 

-    return $ CYBlock($$->*
-        $E(assignment)->*
-        this
-    );
+    return this;

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


@@ -448,7 +472,8 @@ CYStatement *CYLabel::Replace(CYContext &context) {
 }
 
 CYStatement *CYLet::Replace(CYContext &context) {
 }
 
 CYStatement *CYLet::Replace(CYContext &context) {

-    return $ CYWith($ CYObject(declarations_->Property(context)), &code_);
+    declarations_->Replace(context);
+    return $ CYWith($ CYObject(declarations_->Property(context)), code_);

 }
 
 void CYMember::Replace_(CYContext &context) {
 }
 
 void CYMember::Replace_(CYContext &context) {


@@ -804,7 +829,8 @@ CYStatement *Try::Replace(CYContext &context) {
 } }
 
 CYStatement *CYVar::Replace(CYContext &context) {
 } }
 
 CYStatement *CYVar::Replace(CYContext &context) {

-    return $E(declarations_->Replace(context));
+    declarations_->Replace(context);
+    return $E(declarations_->Compound(context));

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