Rename CYForEachIn to CYForOf to better match ECMA6.

[cycript.git] / Parser.hpp

diff --git a/Parser.hpp b/Parser.hpp
index aad1d478db2ec111ddf7ab8121897a40a8eb519a..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,


@@ -117,6 +119,34 @@ enum CYFlags {
     CYNoBF =         (CYNoBrace | CYNoFunction),
 };
 
     CYNoBF =         (CYNoBrace | CYNoFunction),
 };
 

+_finline CYFlags operator ~(CYFlags rhs) {
+    return static_cast<CYFlags>(~static_cast<unsigned>(rhs));
+}
+
+_finline CYFlags operator &(CYFlags lhs, CYFlags rhs) {
+    return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs));
+}
+
+_finline CYFlags operator |(CYFlags lhs, CYFlags rhs) {
+    return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs));
+}
+
+_finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) {
+    return lhs = lhs | rhs;
+}
+
+_finline CYFlags CYLeft(CYFlags flags) {
+    return flags & ~(CYNoDangle | CYNoInteger);
+}
+
+_finline CYFlags CYRight(CYFlags flags) {
+    return flags & ~CYNoBF;
+}
+
+_finline CYFlags CYCenter(CYFlags flags) {
+    return CYLeft(CYRight(flags));
+}
+

 struct CYStatement :
     CYNext<CYStatement>
 {
 struct CYStatement :
     CYNext<CYStatement>
 {


@@ -126,7 +156,6 @@ struct CYStatement :
     void Single(CYOutput &out, CYFlags flags) const;
     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
 
     void Single(CYOutput &out, CYFlags flags) const;
     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
 

-    virtual CYStatement *Collapse(CYContext &context);

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


@@ -284,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_;


@@ -302,7 +324,8 @@ 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();
 
 
     void Close();
 


@@ -355,7 +378,8 @@ struct CYContext {
         Type_ **last(&values);
         CYForEach (next, values) {
             Replace(*last = next);
         Type_ **last(&values);
         CYForEach (next, values) {
             Replace(*last = next);

-            last = &(*last)->next_;
+            if (*last != NULL)
+                last = &(*last)->next_;

         }
     }
 
         }
     }
 


@@ -424,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_;


@@ -500,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 {


@@ -509,9 +536,12 @@ struct CYForInInitialiser {
     }
 
     virtual void ForIn(CYOutput &out, CYFlags flags) const = 0;
     }
 
     virtual void ForIn(CYOutput &out, CYFlags flags) const = 0;

-    virtual const char *ForEachIn() const = 0;
-    virtual CYExpression *ForEachIn(CYContext &out) = 0;
+    virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value) = 0;
+

     virtual CYExpression *Replace(CYContext &context) = 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;


@@ -530,11 +560,8 @@ struct CYExpression :
         return true;
     }
 
         return true;
     }
 

-    virtual void For(CYOutput &out) const;

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

-
-    virtual const char *ForEachIn() const;
-    virtual CYExpression *ForEachIn(CYContext &out);
+    virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value);

 
     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
 
 
     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
 


@@ -546,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;


@@ -601,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 :


@@ -665,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)
     {


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

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

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


@@ -1138,20 +1153,19 @@ struct CYDeclaration :
     }
 
     virtual void ForIn(CYOutput &out, CYFlags flags) const;
     }
 
     virtual void ForIn(CYOutput &out, CYFlags flags) const;

-
-    virtual const char *ForEachIn() const;
-    virtual CYExpression *ForEachIn(CYContext &out);
+    virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value);

 
     virtual CYExpression *Replace(CYContext &context);
 
     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_;
 


@@ -1161,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
 {


@@ -1184,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)

     {
     }
 
     {
     }
 


@@ -1238,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)


@@ -1285,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 :


@@ -1519,7 +1547,6 @@ struct CYExpress :
             throw;
     }
 
             throw;
     }
 

-    virtual CYStatement *Collapse(CYContext &context);

     virtual CYStatement *Replace(CYContext &context);
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
     virtual CYStatement *Replace(CYContext &context);
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };


@@ -1569,7 +1596,6 @@ struct CYReturn :
 struct CYEmpty :
     CYStatement
 {
 struct CYEmpty :
     CYStatement
 {

-    virtual CYStatement *Collapse(CYContext &context);

     virtual CYStatement *Replace(CYContext &context);
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
     virtual CYStatement *Replace(CYContext &context);
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };


@@ -1673,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
 {