X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/359e8b829aeee532360ef95d60fe4a242e7e7128..e06e5ee1f12b9b79b34570e65c1f5e9c12b9b8c3:/Parser.hpp

diff --git a/Parser.hpp b/Parser.hpp
index 0b9099a..7197428 100644
--- a/Parser.hpp
+++ b/Parser.hpp
@@ -1,5 +1,5 @@
 /* Cycript - Optimizing JavaScript Compiler/Runtime
- * Copyright (C) 2009-2010  Jay Freeman (saurik)
+ * Copyright (C) 2009-2012  Jay Freeman (saurik)
 */
 
 /* GNU Lesser General Public License, Version 3 {{{ */
@@ -19,11 +19,12 @@
 **/
 /* }}} */
 
-#ifndef CYPARSER_HPP
-#define CYPARSER_HPP
+#ifndef CYCRIPT_PARSER_HPP
+#define CYCRIPT_PARSER_HPP
 
 #include <iostream>
 
+#include <stack>
 #include <string>
 #include <vector>
 #include <map>
@@ -33,45 +34,13 @@
 #include <cstdlib>
 
 #include "location.hh"
+
+#include "List.hpp"
 #include "Pooling.hpp"
 #include "Options.hpp"
 
 class CYContext;
 
-template <typename Type_>
-struct CYNext {
-    Type_ *next_;
-
-    CYNext() :
-        next_(NULL)
-    {
-    }
-
-    CYNext(Type_ *next) :
-        next_(next)
-    {
-    }
-
-    void SetNext(Type_ *next) {
-        next_ = next;
-    }
-};
-
-template <typename Type_>
-void CYSetLast(Type_ *&list, Type_ *item) {
-    if (list == NULL)
-        list = item;
-    else {
-        Type_ *next(list);
-        while (next->next_ != NULL)
-            next = next->next_;
-        next->next_ = item;
-    }
-}
-
-#define CYForEach(value, list) \
-    for (__typeof__(*list) *value(list); value != NULL; value = value->next_)
-
 struct CYThing {
     virtual ~CYThing() {
     }
@@ -130,6 +99,7 @@ struct CYPropertyName {
 };
 
 struct CYExpression;
+struct CYAssignment;
 
 enum CYNeeded {
     CYNever     = -1,
@@ -149,6 +119,34 @@ enum CYFlags {
     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>
 {
@@ -158,7 +156,6 @@ struct CYStatement :
     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:
@@ -316,15 +313,8 @@ struct CYIdentifierUsage {
 
 typedef std::vector<CYIdentifierUsage> CYIdentifierUsageVector;
 
-// XXX: strategy pattern, maybe subclass
-enum CYScopeType {
-    CYScopeCatch,
-    CYScopeFunction,
-    CYScopeProgram,
-};
-
 struct CYScope {
-    CYScopeType type_;
+    bool transparent_;
 
     CYContext &context_;
     CYStatement *&statements_;
@@ -334,7 +324,8 @@ struct CYScope {
     CYIdentifierAddressFlagsMap internal_;
     CYIdentifierValueSet identifiers_;
 
-    CYScope(CYScopeType type, CYContext &context, CYStatement *&statements);
+    CYScope(bool transparent, CYContext &context, CYStatement *&statements);
+    virtual ~CYScope();
 
     void Close();
 
@@ -386,8 +377,9 @@ struct CYContext {
     void ReplaceAll(Type_ *&values) {
         Type_ **last(&values);
         CYForEach (next, values) {
-            Replace(*last);
-            last = &(*last)->next_;
+            Replace(*last = next);
+            if (*last != NULL)
+                last = &(*last)->next_;
         }
     }
 
@@ -456,9 +448,12 @@ enum CYState {
 
 class CYDriver {
   public:
-    CYState state_;
     void *scanner_;
 
+    CYState state_;
+    bool nobrace_;
+    std::stack<bool> in_;
+
     const char *data_;
     size_t size_;
     FILE *file_;
@@ -532,8 +527,8 @@ struct CYForInitialiser {
     virtual ~CYForInitialiser() {
     }
 
-    virtual void For(CYOutput &out) const = 0;
     virtual CYExpression *Replace(CYContext &context) = 0;
+    virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 };
 
 struct CYForInInitialiser {
@@ -541,9 +536,12 @@ struct CYForInInitialiser {
     }
 
     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 CYAssignment *Assignment(CYContext &context) = 0;
+
+    virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 };
 
 struct CYNumber;
@@ -562,11 +560,8 @@ struct CYExpression :
         return true;
     }
 
-    virtual void For(CYOutput &out) 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);
 
@@ -578,6 +573,7 @@ struct CYExpression :
     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;
@@ -631,37 +627,26 @@ struct CYCompound :
 
     virtual CYExpression *Replace(CYContext &context);
     void Output(CYOutput &out, CYFlags flags) const;
+
+    virtual CYExpression *Primitive(CYContext &context);
 };
 
+struct CYDeclaration;
+
 struct CYFunctionParameter :
     CYNext<CYFunctionParameter>,
     CYThing
 {
-    CYIdentifier *name_;
+    CYForInInitialiser *initialiser_;
 
-    CYFunctionParameter(CYIdentifier *name, CYFunctionParameter *next = NULL) :
+    CYFunctionParameter(CYForInInitialiser *initialiser, CYFunctionParameter *next = NULL) :
         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 :
@@ -697,13 +682,13 @@ struct CYForInComprehension :
     virtual void Output(CYOutput &out) const;
 };
 
-struct CYForEachInComprehension :
+struct CYForOfComprehension :
     CYComprehension
 {
     CYIdentifier *name_;
     CYExpression *set_;
 
-    CYForEachInComprehension(CYIdentifier *name, CYExpression *set) :
+    CYForOfComprehension(CYIdentifier *name, CYExpression *set) :
         name_(name),
         set_(set)
     {
@@ -1079,7 +1064,7 @@ struct CYArgument :
     {
     }
 
-    void Replace(CYContext &context);
+    CYArgument *Replace(CYContext &context);
     void Output(CYOutput &out) const;
 };
 
@@ -1170,20 +1155,19 @@ struct CYDeclaration :
     }
 
     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 CYAssignment *Assignment(CYContext &context);
+    CYVariable *Variable(CYContext &context);
 
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYDeclarations :
     CYNext<CYDeclarations>,
-    CYThing,
-    CYForInitialiser
+    CYThing
 {
     CYDeclaration *declaration_;
 
@@ -1193,15 +1177,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);
+    CYArgument *Argument(CYContext &context);
+    CYFunctionParameter *Parameter(CYContext &context);
 
     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
 {
@@ -1216,15 +1216,15 @@ struct CYVar :
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
-struct CYLet :
+struct CYLetStatement :
     CYStatement
 {
     CYDeclarations *declarations_;
-    CYBlock code_;
+    CYStatement *code_;
 
-    CYLet(CYDeclarations *declarations, CYStatement *statements) :
+    CYLetStatement(CYDeclarations *declarations, CYStatement *code) :
         declarations_(declarations),
-        code_(statements)
+        code_(code)
     {
     }
 
@@ -1270,14 +1270,14 @@ struct CYForIn :
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
-struct CYForEachIn :
+struct CYForOf :
     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)
@@ -1317,8 +1317,6 @@ struct CYMember :
     void SetLeft(CYExpression *object) {
         object_ = object;
     }
-
-    void Replace_(CYContext &context);
 };
 
 struct CYDirectMember :
@@ -1551,7 +1549,6 @@ struct CYExpress :
             throw;
     }
 
-    virtual CYStatement *Collapse(CYContext &context);
     virtual CYStatement *Replace(CYContext &context);
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
@@ -1601,7 +1598,6 @@ struct CYReturn :
 struct CYEmpty :
     CYStatement
 {
-    virtual CYStatement *Collapse(CYContext &context);
     virtual CYStatement *Replace(CYContext &context);
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
@@ -1705,6 +1701,17 @@ struct CYSwitch :
     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
 {
@@ -1873,4 +1880,4 @@ CYAssignment_("&=", BitwiseAnd)
 CYAssignment_("^=", BitwiseXOr)
 CYAssignment_("|=", BitwiseOr)
 
-#endif/*CYPARSER_HPP*/
+#endif/*CYCRIPT_PARSER_HPP*/