Rename CYForEachIn to CYForOf to better match ECMA6.

[cycript.git] / Parser.hpp

diff --git a/Parser.hpp b/Parser.hpp
index 19addb8dc7b0226292e588c6b038b938adc74ee8..47a60c04ece3ddaf26e13631ea07028714c7138c 100644 (file)
--- a/Parser.hpp
+++ b/Parser.hpp
@@ -24,6 +24,7 @@
 
 #include <iostream>
 
 
 #include <iostream>
 

+#include <stack>

 #include <string>
 #include <vector>
 #include <map>
 #include <string>
 #include <vector>
 #include <map>


@@ -98,6 +99,7 @@ struct CYPropertyName {
 };
 
 struct CYExpression;
 };
 
 struct CYExpression;

+struct CYAssignment;

 
 enum CYNeeded {
     CYNever     = -1,
 
 enum CYNeeded {
     CYNever     = -1,


@@ -311,15 +313,8 @@ struct CYIdentifierUsage {
 
 typedef std::vector<CYIdentifierUsage> CYIdentifierUsageVector;
 
 
 typedef std::vector<CYIdentifierUsage> CYIdentifierUsageVector;
 

-// XXX: strategy pattern, maybe subclass
-enum CYScopeType {
-    CYScopeCatch,
-    CYScopeFunction,
-    CYScopeProgram,
-};
-

 struct CYScope {
 struct CYScope {

-    CYScopeType type_;
+    bool transparent_;

 
     CYContext &context_;
     CYStatement *&statements_;
 
     CYContext &context_;
     CYStatement *&statements_;


@@ -329,7 +324,7 @@ struct CYScope {
     CYIdentifierAddressFlagsMap internal_;
     CYIdentifierValueSet identifiers_;
 
     CYIdentifierAddressFlagsMap internal_;
     CYIdentifierValueSet identifiers_;
 

-    CYScope(CYScopeType type, CYContext &context, CYStatement *&statements);
+    CYScope(bool transparent, CYContext &context, CYStatement *&statements);

     virtual ~CYScope();
 
     void Close();
     virtual ~CYScope();
 
     void Close();


@@ -453,9 +448,12 @@ enum CYState {
 
 class CYDriver {
   public:
 
 class CYDriver {
   public:

-    CYState state_;

     void *scanner_;
 
     void *scanner_;
 

+    CYState state_;
+    bool nobrace_;
+    std::stack<bool> in_;
+

     const char *data_;
     size_t size_;
     FILE *file_;
     const char *data_;
     size_t size_;
     FILE *file_;


@@ -529,8 +527,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 {


@@ -541,6 +539,9 @@ struct CYForInInitialiser {
     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value) = 0;
 
     virtual CYExpression *Replace(CYContext &context) = 0;
     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value) = 0;
 
     virtual CYExpression *Replace(CYContext &context) = 0;

+    virtual CYAssignment *Assignment(CYContext &context) = 0;
+
+    virtual void Output(CYOutput &out, CYFlags flags) const = 0;

 };
 
 struct CYNumber;
 };
 
 struct CYNumber;


@@ -559,7 +560,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);
 


@@ -573,6 +573,7 @@ struct CYExpression :
     virtual void ClassName(CYOutput &out, bool object) const;
 
     virtual CYExpression *Replace(CYContext &context) = 0;
     virtual void ClassName(CYOutput &out, bool object) const;
 
     virtual CYExpression *Replace(CYContext &context) = 0;

+    virtual CYAssignment *Assignment(CYContext &context);

 
     virtual CYExpression *Primitive(CYContext &context) {
         return this;
 
     virtual CYExpression *Primitive(CYContext &context) {
         return this;


@@ -628,35 +629,22 @@ struct CYCompound :
     void Output(CYOutput &out, CYFlags flags) const;
 };
 
     void Output(CYOutput &out, CYFlags flags) const;
 };
 

+struct CYDeclaration;
+

 struct CYFunctionParameter :
     CYNext<CYFunctionParameter>,
     CYThing
 {
 struct CYFunctionParameter :
     CYNext<CYFunctionParameter>,
     CYThing
 {

-    CYIdentifier *name_;
+    CYForInInitialiser *initialiser_;

 
 

-    CYFunctionParameter(CYIdentifier *name, CYFunctionParameter *next = NULL) :
+    CYFunctionParameter(CYForInInitialiser *initialiser, CYFunctionParameter *next = NULL) :

         CYNext<CYFunctionParameter>(next),
         CYNext<CYFunctionParameter>(next),

-        name_(name)
-    {
-    }
-
-    virtual CYFunctionParameter *Replace(CYContext &context, CYBlock &code);
-    virtual void Output(CYOutput &out) const;
-};
-
-struct CYOptionalFunctionParameter :
-    CYFunctionParameter
-{
-    CYExpression *initializer_;
-
-    CYOptionalFunctionParameter(CYIdentifier *name, CYExpression *initializer, CYFunctionParameter *next = NULL) :
-        CYFunctionParameter(name, next),
-        initializer_(initializer)
+        initialiser_(initialiser)

     {
     }
 
     {
     }
 

-    virtual CYFunctionParameter *Replace(CYContext &context, CYBlock &code);
-    virtual void Output(CYOutput &out) const;
+    void Replace(CYContext &context, CYBlock &code);
+    void Output(CYOutput &out) const;

 };
 
 struct CYComprehension :
 };
 
 struct CYComprehension :


@@ -692,13 +680,13 @@ struct CYForInComprehension :
     virtual void Output(CYOutput &out) const;
 };
 
     virtual void Output(CYOutput &out) const;
 };
 

-struct CYForEachInComprehension :
+struct CYForOfComprehension :

     CYComprehension
 {
     CYIdentifier *name_;
     CYExpression *set_;
 
     CYComprehension
 {
     CYIdentifier *name_;
     CYExpression *set_;
 

-    CYForEachInComprehension(CYIdentifier *name, CYExpression *set) :
+    CYForOfComprehension(CYIdentifier *name, CYExpression *set) :

         name_(name),
         set_(set)
     {
         name_(name),
         set_(set)
     {


@@ -1074,7 +1062,7 @@ struct CYArgument :
     {
     }
 
     {
     }
 

-    void Replace(CYContext &context);
+    CYArgument *Replace(CYContext &context);

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


@@ -1168,15 +1156,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_;
 


@@ -1186,15 +1175,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
 {


@@ -1209,15 +1214,15 @@ struct CYVar :
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 

-struct CYLet :
+struct CYLetStatement :

     CYStatement
 {
     CYDeclarations *declarations_;
     CYStatement
 {
     CYDeclarations *declarations_;

-    CYBlock code_;
+    CYStatement *code_;

 
 

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

         declarations_(declarations),
         declarations_(declarations),

-        code_(statements)
+        code_(code)

     {
     }
 
     {
     }
 


@@ -1263,14 +1268,14 @@ struct CYForIn :
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 

-struct CYForEachIn :
+struct CYForOf :

     CYStatement
 {
     CYForInInitialiser *initialiser_;
     CYExpression *set_;
     CYStatement *code_;
 
     CYStatement
 {
     CYForInInitialiser *initialiser_;
     CYExpression *set_;
     CYStatement *code_;
 

-    CYForEachIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
+    CYForOf(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :

         initialiser_(initialiser),
         set_(set),
         code_(code)
         initialiser_(initialiser),
         set_(set),
         code_(code)


@@ -1310,8 +1315,6 @@ struct CYMember :
     void SetLeft(CYExpression *object) {
         object_ = object;
     }
     void SetLeft(CYExpression *object) {
         object_ = object;
     }

-
-    void Replace_(CYContext &context);

 };
 
 struct CYDirectMember :
 };
 
 struct CYDirectMember :


@@ -1696,6 +1699,17 @@ struct CYSwitch :
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 

+struct CYDebugger :
+    CYStatement
+{
+    CYDebugger()
+    {
+    }
+
+    virtual CYStatement *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+

 struct CYCondition :
     CYExpression
 {
 struct CYCondition :
     CYExpression
 {