Simplify Block, Compound, and (new) Parenthetical.

diff --git a/Console.cpp b/Console.cpp
index 883f03f0977cbf5b13e150f2b3765e7de73fe297..df349966623b4fc912590725f3e3405ad2b1cfc3 100644 (file)
--- a/Console.cpp
+++ b/Console.cpp
@@ -226,14 +226,17 @@ static CYExpression *ParseExpression(CYUTF8String code) {
     CYOptions options;
     CYContext context(options);
 
     CYOptions options;
     CYContext context(options);
 

-    CYStatement *statement(driver.program_->statements_);
+    CYStatement *statement(driver.program_->code_);

     _assert(statement != NULL);
     _assert(statement->next_ == NULL);
 
     _assert(statement != NULL);
     _assert(statement->next_ == NULL);
 

-    CYExpress *express(dynamic_cast<CYExpress *>(driver.program_->statements_));
+    CYExpress *express(dynamic_cast<CYExpress *>(driver.program_->code_));

     _assert(express != NULL);
 
     _assert(express != NULL);
 

-    return express->expression_;
+    CYParenthetical *parenthetical(dynamic_cast<CYParenthetical *>(express->expression_));
+    _assert(parenthetical != NULL);
+
+    return parenthetical->expression_;

 }
 
 static int client_;
 }
 
 static int client_;

diff --git a/Cycript.yy.in b/Cycript.yy.in
index 8eba3a40e0d98c7961fb411ab03d055d39ebdc19..1e9d2bad9e43efe74d8e5898a7c65e75dd1a56fb 100644 (file)
--- a/Cycript.yy.in
+++ b/Cycript.yy.in
@@ -55,7 +55,6 @@ typedef struct {
         cy::Syntax::Catch *catch_;
         CYComment *comment_;
         CYComprehension *comprehension_;
         cy::Syntax::Catch *catch_;
         CYComment *comment_;
         CYComprehension *comprehension_;

-        CYCompound *compound_;

         CYDeclaration *declaration_;
         CYDeclarations *declarations_;
         CYElement *element_;
         CYDeclaration *declaration_;
         CYDeclarations *declarations_;
         CYElement *element_;


@@ -72,6 +71,7 @@ typedef struct {
         CYModule *module_;
         CYNull *null_;
         CYNumber *number_;
         CYModule *module_;
         CYNull *null_;
         CYNumber *number_;

+        CYParenthetical *parenthetical_;

         CYProgram *program_;
         CYProperty *property_;
         CYPropertyName *propertyName_;
         CYProgram *program_;
         CYProperty *property_;
         CYPropertyName *propertyName_;


@@ -396,8 +396,7 @@ int cylex(YYSTYPE *, CYLocation *, void *);
 %type <statement_> ElseStatementOpt
 %type <statement_> EmptyStatement
 %type <expression_> EqualityExpression
 %type <statement_> ElseStatementOpt
 %type <statement_> EmptyStatement
 %type <expression_> EqualityExpression

-%type <compound_> Expression_
-%type <compound_> Expression
+%type <expression_> Expression

 %type <expression_> ExpressionOpt
 %type <statement_> ExpressionStatement
 %type <finally_> FinallyOpt
 %type <expression_> ExpressionOpt
 %type <statement_> ExpressionStatement
 %type <finally_> FinallyOpt


@@ -434,7 +433,7 @@ int cylex(YYSTYPE *, CYLocation *, void *);
 %type <expression_> NewExpression
 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral
 %type <expression_> NewExpression
 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral

-%type <compound_> Parenthetical
+%type <parenthetical_> Parenthetical

 %type <expression_> PostfixExpression
 %type <expression_> PrimaryExpression
 %type <statement_> Program
 %type <expression_> PostfixExpression
 %type <expression_> PrimaryExpression
 %type <statement_> Program


@@ -766,7 +765,7 @@ TerminatorOpt
 
 /* 11.1 Primary Expressions {{{ */
 Parenthetical
 
 /* 11.1 Primary Expressions {{{ */
 Parenthetical

-    : "(" LexPushInOff Expression ")" LexPopIn { $$ = $3; }
+    : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); }

     ;
 
 Variable
     ;
 
 Variable


@@ -1055,13 +1054,9 @@ AssignmentExpression
     ;
 /* }}} */
 /* 11.14 Comma Operator {{{ */
     ;
 /* }}} */
 /* 11.14 Comma Operator {{{ */

-Expression_
-    : "," Expression { $$ = $2; }
-    | { $$ = NULL; }
-    ;
-

 Expression
 Expression

-    : AssignmentExpression Expression_ { $$ = CYNew CYCompound($1, $2); }
+    : AssignmentExpression { $$ = $1; }
+    | AssignmentExpression "," Expression { $$ = CYNew CYCompound($1, $3); }

     ;
 
 ExpressionOpt
     ;
 
 ExpressionOpt


@@ -1375,7 +1370,7 @@ ArrowFunction
 ArrowParameters
     : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); }
     | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; }
 ArrowParameters
     : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); }
     | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; }

-    | Parenthetical { $$ = $1->Parameters(); if ($$ == NULL) error(@1, "invalid parameter list"); }
+    | Parenthetical { $$ = $1->expression_->Parameter(); if ($$ == NULL) error(@1, "invalid parameter list"); }

     ;
 
 ConciseBody
     ;
 
 ConciseBody

diff --git a/ObjectiveC/Replace.cpp b/ObjectiveC/Replace.cpp
index b7071f9b8e2cddc36c6c03897886fcc0af6df7dc..086287baab243c0a25878d2a78a656900d442aeb 100644 (file)
--- a/ObjectiveC/Replace.cpp
+++ b/ObjectiveC/Replace.cpp
@@ -108,7 +108,7 @@ CYStatement *CYMessage::Replace(CYContext &context, bool replace) const { $T(NUL
             cyn,
             $N2($V("Functor"), $F(NULL, $P2($L("self"), $L("_cmd"), parameters_->Parameters(context)), $$->*
                 $ CYVar($L1($L("$cyr", $N2($V("objc_super"), self, _class))))->*
             cyn,
             $N2($V("Functor"), $F(NULL, $P2($L("self"), $L("_cmd"), parameters_->Parameters(context)), $$->*
                 $ CYVar($L1($L("$cyr", $N2($V("objc_super"), self, _class))))->*

-                $ CYReturn($C1($M($F(NULL, NULL, code_), $S("call")), self))
+                $ CYReturn($C1($M($F(NULL, NULL, code_.code_), $S("call")), self))

             ), cyt),
             cyt
         ))
             ), cyt),
             cyt
         ))


@@ -142,7 +142,7 @@ CYExpression *CYBox::Replace(CYContext &context) {
 }
 
 CYExpression *CYObjCBlock::Replace(CYContext &context) {
 }
 
 CYExpression *CYObjCBlock::Replace(CYContext &context) {

-    return $C1($ CYEncodedType(($ CYTypedIdentifier(*typed_))->Modify($ CYTypeBlockWith(parameters_))), $ CYFunctionExpression(NULL, parameters_->Parameters(context), statements_));
+    return $C1($ CYEncodedType(($ CYTypedIdentifier(*typed_))->Modify($ CYTypeBlockWith(parameters_))), $ CYFunctionExpression(NULL, parameters_->Parameters(context), code_));

 }
 
 CYStatement *CYProtocol::Replace(CYContext &context) const { $T(NULL)
 }
 
 CYStatement *CYProtocol::Replace(CYContext &context) const { $T(NULL)

diff --git a/ObjectiveC/Syntax.hpp b/ObjectiveC/Syntax.hpp
index 642aae4e298db6775b56242883fb5d43742372a0..8beabb98342160c2cbee4bed12b912e10b1bed1d 100644 (file)
--- a/ObjectiveC/Syntax.hpp
+++ b/ObjectiveC/Syntax.hpp
@@ -45,12 +45,12 @@ struct CYObjCBlock :
 {
     CYTypedIdentifier *typed_;
     CYTypedParameter *parameters_;
 {
     CYTypedIdentifier *typed_;
     CYTypedParameter *parameters_;

-    CYStatement *statements_;
+    CYStatement *code_;

 
 

-    CYObjCBlock(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *statements) :
+    CYObjCBlock(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *code) :

         typed_(typed),
         parameters_(parameters),
         typed_(typed),
         parameters_(parameters),

-        statements_(statements)
+        code_(code)

     {
     }
 
     {
     }
 


@@ -151,11 +151,11 @@ struct CYMessage :
     CYMessageParameter *parameters_;
     CYBlock code_;
 
     CYMessageParameter *parameters_;
     CYBlock code_;
 

-    CYMessage(bool instance, CYTypedIdentifier *type, CYMessageParameter *parameter, CYStatement *statements) :
+    CYMessage(bool instance, CYTypedIdentifier *type, CYMessageParameter *parameter, CYStatement *code) :

         instance_(instance),
         type_(type),
         parameters_(parameter),
         instance_(instance),
         type_(type),
         parameters_(parameter),

-        code_(statements)
+        code_(code)

     {
     }
 
     {
     }
 

diff --git a/Output.cpp b/Output.cpp
index 12c72df46b4210e075240c9372619cebd03abd90..50740050b40694f718ef41322e3770d1456901f6 100644 (file)
--- a/Output.cpp
+++ b/Output.cpp
@@ -137,24 +137,14 @@ void CYAssignment::Output(CYOutput &out, CYFlags flags) const {
     rhs_->Output(out, Precedence(), CYRight(flags));
 }
 
     rhs_->Output(out, Precedence(), CYRight(flags));
 }
 

-void CYBlock::Output(CYOutput &out) const {
+void CYBlock::Output(CYOutput &out, CYFlags flags) const {

     out << '{' << '\n';
     ++out.indent_;
     out << '{' << '\n';
     ++out.indent_;

-    if (statements_ != NULL)
-        statements_->Multiple(out);
+    out << code_;

     --out.indent_;
     out << '\t' << '}';
 }
 
     --out.indent_;
     out << '\t' << '}';
 }
 

-void CYBlock::Output(CYOutput &out, CYFlags flags) const {
-    if (statements_ == NULL)
-        out.Terminate();
-    else if (statements_->next_ == NULL)
-        statements_->Single(out, flags);
-    else
-        Output(out);
-}
-

 void CYBoolean::Output(CYOutput &out, CYFlags flags) const {
     out << (Value() ? "true" : "false");
 }
 void CYBoolean::Output(CYOutput &out, CYFlags flags) const {
     out << (Value() ? "true" : "false");
 }


@@ -180,7 +170,12 @@ namespace cy {
 namespace Syntax {
 
 void Catch::Output(CYOutput &out) const {
 namespace Syntax {
 
 void Catch::Output(CYOutput &out) const {

-    out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' ' << code_;
+    out << ' ' << "catch" << ' ' << '(' << *name_ << ')' << ' ';
+    out << '{' << '\n';
+    ++out.indent_;
+    out << code_;
+    --out.indent_;
+    out << '\t' << '}';

 }
 
 } }
 }
 
 } }


@@ -224,8 +219,7 @@ void CYClause::Output(CYOutput &out) const {
     else
         out << "default";
     out << ':' << '\n';
     else
         out << "default";
     out << ':' << '\n';

-    if (statements_ != NULL)
-        statements_->Multiple(out);
+    out << code_;

     out << next_;
 }
 
     out << next_;
 }
 


@@ -334,11 +328,16 @@ void CYExternal::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYFatArrow::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYFatArrow::Output(CYOutput &out, CYFlags flags) const {

-    out << '(' << parameters_ << ')' << ' ' << "=>" << ' ' << code_;
+    out << '(' << parameters_ << ')' << ' ' << "=>" << ' ' << '{' << code_ << '}';

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

-    out << ' ' << "finally" << ' ' << code_;
+    out << ' ' << "finally" << ' ';
+    out << '{' << '\n';
+    ++out.indent_;
+    out << code_;
+    --out.indent_;
+    out << '\t' << '}';

 }
 
 void CYFor::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYFor::Output(CYOutput &out, CYFlags flags) const {


@@ -388,8 +387,12 @@ void CYFunction::Output(CYOutput &out, CYFlags flags) const {
     out << "function";
     if (name_ != NULL)
         out << ' ' << *name_;
     out << "function";
     if (name_ != NULL)
         out << ' ' << *name_;

-    out << '(' << parameters_ << ')';
-    out << ' ' << code_;
+    out << '(' << parameters_ << ')' << ' ';
+    out << '{' << '\n';
+    ++out.indent_;
+    out << code_;
+    --out.indent_;
+    out << '\t' << '}';

     if (protect)
         out << ')';
 }
     if (protect)
         out << ')';
 }


@@ -475,6 +478,16 @@ void CYLabel::Output(CYOutput &out, CYFlags flags) const {
     statement_->Single(out, CYRight(flags));
 }
 
     statement_->Single(out, CYRight(flags));
 }
 

+void CYParenthetical::Output(CYOutput &out, CYFlags flags) const {
+    out << '(';
+    expression_->Output(out, CYCompound::Precedence_, CYNoFlags);
+    out << ')';
+}
+
+void CYStatement::Output(CYOutput &out) const {
+    Multiple(out);
+}
+

 void CYTypeArrayOf::Output(CYOutput &out, CYIdentifier *identifier) const {
     next_->Output(out, Precedence(), identifier);
     out << '[';
 void CYTypeArrayOf::Output(CYOutput &out, CYIdentifier *identifier) const {
     next_->Output(out, Precedence(), identifier);
     out << '[';


@@ -619,8 +632,7 @@ void CYPrefix::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void CYProgram::Output(CYOutput &out) const {
 }
 
 void CYProgram::Output(CYOutput &out) const {

-    if (statements_ != NULL)
-        statements_->Multiple(out);
+    out << code_;

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


@@ -653,7 +665,11 @@ void CYRubyBlock::Output(CYOutput &out, CYFlags flags) const {
 
 void CYRubyProc::Output(CYOutput &out, CYFlags flags) const {
     // XXX: this is not outputting the parameters
 
 void CYRubyProc::Output(CYOutput &out, CYFlags flags) const {
     // XXX: this is not outputting the parameters

+    out << '{' << '\n';
+    ++out.indent_;

     out << code_;
     out << code_;

+    --out.indent_;
+    out << '\t' << '}';

 }
 
 void CYStatement::Multiple(CYOutput &out, CYFlags flags) const {
 }
 
 void CYStatement::Multiple(CYOutput &out, CYFlags flags) const {


@@ -750,7 +766,13 @@ void Throw::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void Try::Output(CYOutput &out, CYFlags flags) const {
 }
 
 void Try::Output(CYOutput &out, CYFlags flags) const {

-    out << "try" << ' ' << code_ << catch_ << finally_;
+    out << "try" << ' ';
+    out << '{' << '\n';
+    ++out.indent_;
+    out << code_;
+    --out.indent_;
+    out << '\t' << '}';
+    out << catch_ << finally_;

 }
 
 } }
 }
 
 } }

diff --git a/Parser.hpp b/Parser.hpp
index e02a16610eafe199d14c5480baffe5f99230be40..8bd7cdc6f26fbae55e9c024b0d45ae30cee9247b 100644 (file)
--- a/Parser.hpp
+++ b/Parser.hpp
@@ -146,13 +146,15 @@ _finline CYFlags CYCenter(CYFlags flags) {
 }
 
 struct CYStatement :
 }
 
 struct CYStatement :

-    CYNext<CYStatement>
+    CYNext<CYStatement>,
+    CYThing

 {
     virtual ~CYStatement() {
     }
 
     void Single(CYOutput &out, CYFlags flags) const;
     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
 {
     virtual ~CYStatement() {
     }
 
     void Single(CYOutput &out, CYFlags flags) const;
     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;

+    virtual void Output(CYOutput &out) const;

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


@@ -329,10 +331,10 @@ struct CYScope {
 struct CYProgram :
     CYThing
 {
 struct CYProgram :
     CYThing
 {

-    CYStatement *statements_;
+    CYStatement *code_;

 
 

-    CYProgram(CYStatement *statements) :
-        statements_(statements)
+    CYProgram(CYStatement *code) :
+        code_(code)

     {
     }
 
     {
     }
 


@@ -368,14 +370,18 @@ struct CYContext {
     virtual ~CYContext() {
     }
 
     virtual ~CYContext() {
     }
 

-    template <typename Type_>
-    void ReplaceAll(Type_ *&values) {
-        Type_ **last(&values);
-        CYForEach (next, values) {
-            Replace(*last = next);
-            if (*last != NULL)
-                last = &(*last)->next_;
-        }
+    void ReplaceAll(CYStatement *&statement) {
+        if (statement == NULL)
+            return;
+        CYStatement *next(statement->next_);
+
+        Replace(statement);
+        ReplaceAll(next);
+
+        if (statement == NULL)
+            statement = next;
+        else
+            statement->SetNext(next);

     }
 
     template <typename Type_>
     }
 
     template <typename Type_>


@@ -429,28 +435,17 @@ struct CYThisScope :
 };
 
 struct CYBlock :
 };
 
 struct CYBlock :

-    CYStatement,
-    CYThing
+    CYStatement

 {
 {

-    CYStatement *statements_;
+    CYStatement *code_;

 
 

-    CYBlock(CYStatement *statements) :
-        statements_(statements)
+    CYBlock(CYStatement *code) :
+        code_(code)

     {
     }
 
     {
     }
 

-    operator CYStatement *() const {
-        return statements_;
-    }
-
-    void AddPrev(CYStatement *statement) {
-        CYSetLast(statement) = statements_;
-        statements_ = statement;
-    }
-

     virtual CYStatement *Replace(CYContext &context);
 
     virtual CYStatement *Replace(CYContext &context);
 

-    virtual void Output(CYOutput &out) const;

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


@@ -512,7 +507,6 @@ struct CYExpression :
     }
 
     virtual CYFunctionParameter *Parameter() const;
     }
 
     virtual CYFunctionParameter *Parameter() const;

-    virtual CYFunctionParameter *Parameters() const;

 
     virtual CYNumber *Number(CYContext &context) {
         return NULL;
 
     virtual CYNumber *Number(CYContext &context) {
         return NULL;


@@ -549,13 +543,12 @@ struct CYCompound :
     CYExpression *expression_;
     CYExpression *next_;
 
     CYExpression *expression_;
     CYExpression *next_;
 

-    CYCompound(CYExpression *expression, CYExpression *next = NULL) :
+    CYCompound(CYExpression *expression, CYExpression *next) :

         expression_(expression),
         next_(next)
     {
         expression_(expression),
         next_(next)
     {

-        if (expression_ == NULL)
-            throw;

         _assert(expression_ != NULL);
         _assert(expression_ != NULL);

+        _assert(next != NULL);

     }
 
     CYPrecedence(17)
     }
 
     CYPrecedence(17)


@@ -563,8 +556,23 @@ struct CYCompound :
     virtual CYExpression *Replace(CYContext &context);
     void Output(CYOutput &out, CYFlags flags) const;
 
     virtual CYExpression *Replace(CYContext &context);
     void Output(CYOutput &out, CYFlags flags) const;
 

-    virtual CYExpression *Primitive(CYContext &context);
-    virtual CYFunctionParameter *Parameters() const;
+    virtual CYFunctionParameter *Parameter() const;
+};
+
+struct CYParenthetical :
+    CYExpression
+{
+    CYExpression *expression_;
+
+    CYParenthetical(CYExpression *expression) :
+        expression_(expression)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual CYExpression *Replace(CYContext &context);
+    void Output(CYOutput &out, CYFlags flags) const;

 };
 
 struct CYDeclaration;
 };
 
 struct CYDeclaration;


@@ -581,7 +589,7 @@ struct CYFunctionParameter :
     {
     }
 
     {
     }
 

-    void Replace(CYContext &context, CYBlock &code);
+    void Replace(CYContext &context, CYStatement *&statements);

     void Output(CYOutput &out) const;
 };
 
     void Output(CYOutput &out) const;
 };
 


@@ -1037,11 +1045,11 @@ struct CYClause :
     CYNext<CYClause>
 {
     CYExpression *case_;
     CYNext<CYClause>
 {
     CYExpression *case_;

-    CYStatement *statements_;
+    CYStatement *code_;

 
 

-    CYClause(CYExpression *_case, CYStatement *statements) :
+    CYClause(CYExpression *_case, CYStatement *code) :

         case_(_case),
         case_(_case),

-        statements_(statements)
+        code_(code)

     {
     }
 
     {
     }
 


@@ -1134,7 +1142,7 @@ struct CYDeclarations :
 
     void Replace(CYContext &context);
 
 
     void Replace(CYContext &context);
 

-    CYCompound *Compound(CYContext &context);
+    CYExpression *Expression(CYContext &context);

     CYProperty *Property(CYContext &context);
     CYArgument *Argument(CYContext &context);
     CYFunctionParameter *Parameter(CYContext &context);
     CYProperty *Property(CYContext &context);
     CYArgument *Argument(CYContext &context);
     CYFunctionParameter *Parameter(CYContext &context);


@@ -1153,7 +1161,7 @@ struct CYForDeclarations :
     {
     }
 
     {
     }
 

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

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


@@ -1429,15 +1437,15 @@ struct CYWhile :
 struct CYFunction {
     CYIdentifier *name_;
     CYFunctionParameter *parameters_;
 struct CYFunction {
     CYIdentifier *name_;
     CYFunctionParameter *parameters_;

-    CYBlock code_;
+    CYStatement *code_;

 
     CYNonLocal *nonlocal_;
     CYThisScope this_;
 
 
     CYNonLocal *nonlocal_;
     CYThisScope this_;
 

-    CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
+    CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) :

         name_(name),
         parameters_(parameters),
         name_(name),
         parameters_(parameters),

-        code_(statements),
+        code_(code),

         nonlocal_(NULL)
     {
     }
         nonlocal_(NULL)
     {
     }


@@ -1455,8 +1463,8 @@ struct CYFunctionExpression :
     CYFunction,
     CYExpression
 {
     CYFunction,
     CYExpression
 {

-    CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
-        CYFunction(name, parameters, statements)
+    CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) :
+        CYFunction(name, parameters, code)

     {
     }
 
     {
     }
 


@@ -1472,8 +1480,8 @@ struct CYFatArrow :
     CYFunction,
     CYExpression
 {
     CYFunction,
     CYExpression
 {

-    CYFatArrow(CYFunctionParameter *parameters, CYStatement *statements) :
-        CYFunction(NULL, parameters, statements)
+    CYFatArrow(CYFunctionParameter *parameters, CYStatement *code) :
+        CYFunction(NULL, parameters, code)

     {
     }
 
     {
     }
 


@@ -1488,8 +1496,8 @@ struct CYFatArrow :
 struct CYRubyProc :
     CYFunctionExpression
 {
 struct CYRubyProc :
     CYFunctionExpression
 {

-    CYRubyProc(CYFunctionParameter *parameters, CYStatement *statements) :
-        CYFunctionExpression(NULL, parameters, statements)
+    CYRubyProc(CYFunctionParameter *parameters, CYStatement *code) :
+        CYFunctionExpression(NULL, parameters, code)

     {
     }
 
     {
     }
 


@@ -1502,8 +1510,8 @@ struct CYFunctionStatement :
     CYFunction,
     CYStatement
 {
     CYFunction,
     CYStatement
 {

-    CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
-        CYFunction(name, parameters, statements)
+    CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) :
+        CYFunction(name, parameters, code)

     {
     }
 
     {
     }
 


@@ -1579,10 +1587,10 @@ struct CYEmpty :
 struct CYFinally :
     CYThing
 {
 struct CYFinally :
     CYThing
 {

-    CYBlock code_;
+    CYStatement *code_;

 
 

-    CYFinally(CYStatement *statements) :
-        code_(statements)
+    CYFinally(CYStatement *code) :
+        code_(code)

     {
     }
 
     {
     }
 


@@ -1846,12 +1854,12 @@ struct CYLambda :
 {
     CYTypedIdentifier *typed_;
     CYTypedParameter *parameters_;
 {
     CYTypedIdentifier *typed_;
     CYTypedParameter *parameters_;

-    CYStatement *statements_;
+    CYStatement *code_;

 
 

-    CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *statements) :
+    CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *code) :

         typed_(typed),
         parameters_(parameters),
         typed_(typed),
         parameters_(parameters),

-        statements_(statements)
+        code_(code)

     {
     }
 
     {
     }
 


@@ -1964,11 +1972,11 @@ struct Catch :
     CYThing
 {
     CYIdentifier *name_;
     CYThing
 {
     CYIdentifier *name_;

-    CYBlock code_;
+    CYStatement *code_;

 
 

-    Catch(CYIdentifier *name, CYStatement *statements) :
+    Catch(CYIdentifier *name, CYStatement *code) :

         name_(name),
         name_(name),

-        code_(statements)
+        code_(code)

     {
     }
 
     {
     }
 


@@ -1979,12 +1987,12 @@ struct Catch :
 struct Try :
     CYStatement
 {
 struct Try :
     CYStatement
 {

-    CYBlock code_;
+    CYStatement *code_;

     Catch *catch_;
     CYFinally *finally_;
 
     Catch *catch_;
     CYFinally *finally_;
 

-    Try(CYStatement *statements, Catch *_catch, CYFinally *finally) :
-        code_(statements),
+    Try(CYStatement *code, Catch *_catch, CYFinally *finally) :
+        code_(code),

         catch_(_catch),
         finally_(finally)
     {
         catch_(_catch),
         finally_(finally)
     {

diff --git a/Replace.cpp b/Replace.cpp
index 0f53d926a37e828f5aff1e5d74de94a4e1dc1845..74f04d9d489f7712d48366cd7837dc44ca35a32e 100644 (file)
--- a/Replace.cpp
+++ b/Replace.cpp
@@ -96,8 +96,8 @@ CYExpression *CYAssignment::Replace(CYContext &context) {
 }
 
 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;
 }


@@ -129,15 +129,15 @@ void Catch::Replace(CYContext &context) { $T()
     context.Replace(name_);
     context.scope_->Declare(context, name_, CYIdentifierCatch);
 
     context.Replace(name_);
     context.scope_->Declare(context, name_, CYIdentifierCatch);
 

-    code_.Replace(context);
-    scope.Close(context, code_.statements_);
+    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);
 }
 


@@ -146,9 +146,6 @@ CYStatement *CYComment::Replace(CYContext &context) {
 }
 
 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,22 +159,10 @@ 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;
         return NULL;

-    return expression->Primitive(context);
-}
-
-CYFunctionParameter *CYCompound::Parameters() const {
-    CYFunctionParameter *next;
-    if (next_ == NULL)
-        next = NULL;
-    else {
-        next = next_->Parameters();
-        if (next == NULL)
-            return NULL;
-    }

 
     CYFunctionParameter *parameter(expression_->Parameter());
     if (parameter == NULL)
 
     CYFunctionParameter *parameter(expression_->Parameter());
     if (parameter == NULL)


@@ -223,6 +208,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);
 


@@ -284,10 +270,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;
 }
 


@@ -299,7 +288,7 @@ 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;
 }
 


@@ -317,15 +306,7 @@ CYExpression *CYEncodedType::Replace(CYContext &context) {
 }
 
 CYStatement *CYExpress::Replace(CYContext &context) {
 }
 
 CYStatement *CYExpress::Replace(CYContext &context) {

-    while (CYExpress *express = dynamic_cast<CYExpress *>(next_)) {
-        expression_ = $ CYCompound(expression_, express->expression_);
-        SetNext(express->next_);
-    }
-

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

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

     return this;
 }
 
     return this;
 }
 


@@ -349,10 +330,6 @@ CYFunctionParameter *CYExpression::Parameter() const {
     return NULL;
 }
 
     return NULL;
 }
 

-CYFunctionParameter *CYExpression::Parameters() 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())))));
 }


@@ -372,20 +349,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


@@ -398,7 +375,7 @@ 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;
 }
 
     return this;
 }
 


@@ -474,22 +451,22 @@ void CYFunction::Replace_(CYContext &context, bool outer) {
         Inject(context);
 
     parameters_->Replace(context, code_);
         Inject(context);
 
     parameters_->Replace(context, code_);

-    code_.Replace(context);
+    context.ReplaceAll(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(context, code_.statements_);
+    scope.Close(context, code_);

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


@@ -497,17 +474,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) {


@@ -524,8 +503,8 @@ CYIdentifier *CYIdentifier::Replace(CYContext &context) {
 
 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;
 }
 


@@ -561,7 +540,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) {


@@ -622,6 +601,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;


@@ -654,10 +637,10 @@ void CYProgram::Replace(CYContext &context) {
     CYScope scope(true, context);
 
     context.nextlocal_ = $ CYNonLocal();
     CYScope scope(true, context);
 
     context.nextlocal_ = $ CYNonLocal();

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

 
 

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

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


@@ -904,7 +887,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;


@@ -1004,8 +987,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();
 }
 


@@ -1020,13 +1003,13 @@ CYFunctionParameter *CYVariable::Parameter() const {
 
 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;
 }