Peel away CYCompound layers to fix tab completion.

[cycript.git] / Parser.hpp

diff --git a/Parser.hpp b/Parser.hpp
index 0b9099adfa8059009323d8f016a7451e68a40c49..7197428bfe112e27d83b4b26ef43205005670f63 100644 (file)
--- a/Parser.hpp
+++ b/Parser.hpp
@@ -1,5 +1,5 @@
 /* Cycript - Optimizing JavaScript Compiler/Runtime
 /* 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 {{{ */
 */
 
 /* 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 <iostream>
 

+#include <stack>

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


@@ -33,45 +34,13 @@
 #include <cstdlib>
 
 #include "location.hh"
 #include <cstdlib>
 
 #include "location.hh"

+
+#include "List.hpp"

 #include "Pooling.hpp"
 #include "Options.hpp"
 
 class CYContext;
 
 #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() {
     }
 struct CYThing {
     virtual ~CYThing() {
     }


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

+struct CYAssignment;

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


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


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


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


@@ -334,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();
 


@@ -386,8 +377,9 @@ struct CYContext {
     void ReplaceAll(Type_ *&values) {
         Type_ **last(&values);
         CYForEach (next, values) {
     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:
 
 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_;


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


@@ -562,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);
 


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


@@ -631,37 +627,26 @@ 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);

 };
 
 };
 

+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 :


@@ -697,13 +682,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)
     {


@@ -1079,7 +1064,7 @@ struct CYArgument :
     {
     }
 
     {
     }
 

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

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


@@ -1170,20 +1155,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_;
 


@@ -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);
     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,15 +1216,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)

     {
     }
 
     {
     }
 


@@ -1270,14 +1270,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)


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

-
-    void Replace_(CYContext &context);

 };
 
 struct CYDirectMember :
 };
 
 struct CYDirectMember :


@@ -1551,7 +1549,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;
 };


@@ -1601,7 +1598,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;
 };


@@ -1705,6 +1701,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
 {


@@ -1873,4 +1880,4 @@ CYAssignment_("&=", BitwiseAnd)
 CYAssignment_("^=", BitwiseXOr)
 CYAssignment_("|=", BitwiseOr)
 
 CYAssignment_("^=", BitwiseXOr)
 CYAssignment_("|=", BitwiseOr)
 

-#endif/*CYPARSER_HPP*/
+#endif/*CYCRIPT_PARSER_HPP*/