Flex drove me crazy with "you just got jammed" :/.

[cycript.git] / Parser.hpp

diff --git a/Parser.hpp b/Parser.hpp
index 8773619990066e94baba5a1afc36a4242a7ec830..02b08ebee8b448a9b1c78ce2f19b7910ab6837be 100644 (file)
--- a/Parser.hpp
+++ b/Parser.hpp
@@ -1,50 +1,28 @@
-/* Cycript - Inlining/Optimizing JavaScript Compiler
- * Copyright (C) 2009  Jay Freeman (saurik)
+/* Cycript - Optimizing JavaScript Compiler/Runtime
+ * Copyright (C) 2009-2015  Jay Freeman (saurik)

 */
 
 */
 

-/* Modified BSD License {{{ */
+/* GNU Affero General Public License, Version 3 {{{ */

 /*
 /*

- *        Redistribution and use in source and binary
- * forms, with or without modification, are permitted
- * provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the
- *    above copyright notice, this list of conditions
- *    and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the
- *    above copyright notice, this list of conditions
- *    and the following disclaimer in the documentation
- *    and/or other materials provided with the
- *    distribution.
- * 3. The name of the author may not be used to endorse
- *    or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
- * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
- * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+**/

 /* }}} */
 
 /* }}} */
 

-#ifndef CYPARSER_HPP
-#define CYPARSER_HPP
-
-// XXX: wtf is this here?!
-#define CYPA 16
-
-#include <iostream>
+#ifndef CYCRIPT_PARSER_HPP
+#define CYCRIPT_PARSER_HPP

 
 

+#include <streambuf>

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


@@ -53,43 +31,25 @@
 #include <cstdio>
 #include <cstdlib>
 
 #include <cstdio>
 #include <cstdlib>
 

-#include "location.hh"
+#include "List.hpp"
+#include "Location.hpp"

 #include "Pooling.hpp"
 #include "Options.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;
-    }
-};
+struct CYContext;

 
 struct CYThing {
 
 struct CYThing {

-    virtual ~CYThing() {
-    }
-

     virtual void Output(struct CYOutput &out) const = 0;
 };
 
 struct CYOutput {
     virtual void Output(struct CYOutput &out) const = 0;
 };
 
 struct CYOutput {

-    std::ostream &out_;
+    std::streambuf &out_;
+    CYPosition position_;
+

     CYOptions &options_;
     bool pretty_;
     unsigned indent_;
     CYOptions &options_;
     bool pretty_;
     unsigned indent_;

+    unsigned recent_;

     bool right_;
 
     enum {
     bool right_;
 
     enum {


@@ -100,11 +60,12 @@ struct CYOutput {
         Terminated
     } mode_;
 
         Terminated
     } mode_;
 

-    CYOutput(std::ostream &out, CYOptions &options) :
+    CYOutput(std::streambuf &out, CYOptions &options) :

         out_(out),
         options_(options),
         pretty_(false),
         indent_(0),
         out_(out),
         options_(options),
         pretty_(false),
         indent_(0),

+        recent_(0),

         right_(false),
         mode_(NoMode)
     {
         right_(false),
         mode_(NoMode)
     {


@@ -113,6 +74,25 @@ struct CYOutput {
     void Check(char value);
     void Terminate();
 
     void Check(char value);
     void Terminate();
 

+    _finline void operator ()(char value) {
+        _assert(out_.sputc(value) != EOF);
+        recent_ = indent_;
+        if (value == '\n')
+            position_.lines(1);
+        else
+            position_.columns(1);
+    }
+
+    _finline void operator ()(const char *data, std::streamsize size) {
+        _assert(out_.sputn(data, size) == size);
+        recent_ = indent_;
+        position_.columns(size);
+    }
+
+    _finline void operator ()(const char *data) {
+        return operator ()(data, strlen(data));
+    }
+

     CYOutput &operator <<(char rhs);
     CYOutput &operator <<(const char *rhs);
 
     CYOutput &operator <<(char rhs);
     CYOutput &operator <<(const char *rhs);
 


@@ -130,12 +110,10 @@ struct CYOutput {
 
 struct CYPropertyName {
     virtual void PropertyName(CYOutput &out) const = 0;
 
 struct CYPropertyName {
     virtual void PropertyName(CYOutput &out) const = 0;

-
-    virtual ~CYPropertyName() {
-    }

 };
 
 struct CYExpression;
 };
 
 struct CYExpression;

+struct CYAssignment;

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


@@ -155,20 +133,58 @@ enum CYFlags {
     CYNoBF =         (CYNoBrace | CYNoFunction),
 };
 
     CYNoBF =         (CYNoBrace | CYNoFunction),
 };
 

-struct CYStatement :
-    CYNext<CYStatement>
-{
-    virtual ~CYStatement() {
+_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));
+}
+
+enum CYCompactType {
+    CYCompactNone,
+    CYCompactLong,
+    CYCompactShort,
+};
+
+#define CYCompact(type) \
+    virtual CYCompactType Compact() const { \
+        return CYCompact ## type; \

     }
 
     }
 

-    void Single(CYOutput &out, CYFlags flags) const;
+struct CYStatement :
+    CYNext<CYStatement>,
+    CYThing
+{
+    void Single(CYOutput &out, CYFlags flags, CYCompactType request) const;

     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;

-
-    CYStatement *ReplaceAll(CYContext &context);
-    virtual CYStatement *Collapse(CYContext &context);
+    virtual void Output(CYOutput &out) const;

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

+    virtual CYCompactType Compact() const = 0;
+    virtual CYStatement *Return();
+

   private:
     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 };
   private:
     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 };


@@ -203,9 +219,6 @@ struct CYStatements {
 };
 
 struct CYClassName {
 };
 
 struct CYClassName {

-    virtual ~CYClassName() {
-    }
-

     virtual CYExpression *ClassName(CYContext &context, bool object) = 0;
     virtual void ClassName(CYOutput &out, bool object) const = 0;
 };
     virtual CYExpression *ClassName(CYContext &context, bool object) = 0;
     virtual void ClassName(CYOutput &out, bool object) const = 0;
 };


@@ -259,20 +272,6 @@ struct CYIdentifier :
     CYIdentifier *Replace(CYContext &context);
 };
 
     CYIdentifier *Replace(CYContext &context);
 };
 

-struct CYComment :
-    CYStatement
-{
-    const char *value_;
-
-    CYComment(const char *value) :
-        value_(value)
-    {
-    }
-
-    virtual CYStatement *Replace(CYContext &context);
-    virtual void Output(CYOutput &out, CYFlags flags) const;
-};
-

 struct CYLabel :
     CYStatement
 {
 struct CYLabel :
     CYStatement
 {


@@ -285,6 +284,8 @@ struct CYLabel :
     {
     }
 
     {
     }
 

+    CYCompact(Short)
+

     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;
 };


@@ -324,41 +325,28 @@ 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_;
-
-    CYContext &context_;
-    CYStatement *&statements_;
-
+    bool transparent_;

     CYScope *parent_;
 
     CYIdentifierAddressFlagsMap internal_;
     CYIdentifierValueSet identifiers_;
 
     CYScope *parent_;
 
     CYIdentifierAddressFlagsMap internal_;
     CYIdentifierValueSet identifiers_;
 

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

 
     void Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags);
     virtual CYIdentifier *Lookup(CYContext &context, CYIdentifier *identifier);
     void Merge(CYContext &context, CYIdentifier *identifier);
 
     void Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags);
     virtual CYIdentifier *Lookup(CYContext &context, CYIdentifier *identifier);
     void Merge(CYContext &context, CYIdentifier *identifier);

-    void Scope(CYContext &context, CYStatement *&statements);
+    void Close(CYContext &context, CYStatement *&statements);

 };
 
 };
 

-struct CYProgram :
+struct CYScript :

     CYThing
 {
     CYThing
 {

-    CYStatement *statements_;
+    CYStatement *code_;

 
 

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

     {
     }
 
     {
     }
 


@@ -367,11 +355,14 @@ struct CYProgram :
 };
 
 struct CYNonLocal;
 };
 
 struct CYNonLocal;

+struct CYThisScope;

 
 struct CYContext {
     CYOptions &options_;
 
     CYScope *scope_;
 
 struct CYContext {
     CYOptions &options_;
 
     CYScope *scope_;

+    CYThisScope *this_;
+

     CYIdentifierUsageVector rename_;
 
     CYNonLocal *nonlocal_;
     CYIdentifierUsageVector rename_;
 
     CYNonLocal *nonlocal_;


@@ -381,13 +372,25 @@ struct CYContext {
     CYContext(CYOptions &options) :
         options_(options),
         scope_(NULL),
     CYContext(CYOptions &options) :
         options_(options),
         scope_(NULL),

+        this_(NULL),

         nonlocal_(NULL),
         nextlocal_(NULL),
         unique_(0)
     {
     }
 
         nonlocal_(NULL),
         nextlocal_(NULL),
         unique_(0)
     {
     }
 

-    virtual ~CYContext() {
+    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_>


@@ -421,172 +424,97 @@ struct CYNonLocal {
     }
 };
 
     }
 };
 

-struct CYBlock :
-    CYStatement,
-    CYThing
+struct CYThisScope :
+    CYNext<CYThisScope>

 {
 {

-    CYStatement *statements_;
+    CYIdentifier *identifier_;

 
 

-    CYBlock(CYStatement *statements) :
-        statements_(statements)
+    CYThisScope() :
+        identifier_(NULL)

     {
     }
 
     {
     }
 

-    operator CYStatement *() const {
-        return statements_;
-    }
-
-    void AddPrev(CYStatement *statement) {
-        CYStatement *last(statement);
-        while (last->next_ != NULL)
-            last = last->next_;
-        last->SetNext(statements_);
-        statements_ = statement;
+    CYIdentifier *Identifier(CYContext &context) {
+        if (next_ != NULL)
+            return next_->Identifier(context);
+        if (identifier_ == NULL)
+            identifier_ = context.Unique();
+        return identifier_;

     }
     }

-
-    virtual CYStatement *Replace(CYContext &context);
-
-    virtual void Output(CYOutput &out) const;
-    virtual void Output(CYOutput &out, CYFlags flags) const;
-};
-
-enum CYState {
-    CYClear,
-    CYRestricted,
-    CYNewLine

 };
 
 };
 

-class CYDriver {
-  public:
-    CYState state_;
-    void *scanner_;
-
-    const char *data_;
-    size_t size_;
-    FILE *file_;
-
-    bool strict_;
-
-    enum Condition {
-        RegExpCondition,
-        XMLContentCondition,
-        XMLTagCondition,
-    };
-
-    std::string filename_;
-
-    struct Error {
-        bool warning_;
-        cy::location location_;
-        std::string message_;
-    };
-
-    typedef std::vector<Error> Errors;
-
-    CYProgram *program_;
-    Errors errors_;
-
-    bool auto_;
-
-    struct Context {
-        CYExpression *context_;
-
-        Context(CYExpression *context) :
-            context_(context)
-        {
-        }
-
-        typedef std::vector<CYWord *> Words;
-        Words words_;
-    };
-
-    typedef std::vector<Context> Contexts;
-    Contexts contexts_;
-
-    CYExpression *context_;
-
-    enum Mode {
-        AutoNone,
-        AutoPrimary,
-        AutoDirect,
-        AutoIndirect,
-        AutoMessage
-    } mode_;
+struct CYBlock :
+    CYStatement
+{
+    CYStatement *code_;

 
 

-  private:
-    void ScannerInit();
-    void ScannerDestroy();
+    CYBlock(CYStatement *code) :
+        code_(code)
+    {
+    }

 
 

-  public:
-    CYDriver(const std::string &filename = "");
-    ~CYDriver();
+    CYCompact(Short)

 
 

-    Condition GetCondition();
-    void SetCondition(Condition condition);
+    virtual CYStatement *Replace(CYContext &context);

 
 

-    void PushCondition(Condition condition);
-    void PopCondition();
+    virtual void Output(CYOutput &out, CYFlags flags) const;

 
 

-    void Warning(const cy::location &location, const char *message);
+    virtual CYStatement *Return();

 };
 
 };
 

-struct CYForInitialiser {
-    virtual ~CYForInitialiser() {
-    }
-
-    virtual void For(CYOutput &out) const = 0;
+struct CYForInitializer {

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

+    virtual void Output(CYOutput &out, CYFlags flags) const = 0;

 };
 
 };
 

-struct CYForInInitialiser {
-    virtual ~CYForInInitialiser() {
-    }
-
+struct CYForInInitializer {

     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 CYFunctionParameter;
+

 struct CYNumber;
 struct CYString;
 
 struct CYExpression :
 struct CYNumber;
 struct CYString;
 
 struct CYExpression :

-    CYNext<CYExpression>,
-    CYForInitialiser,
-    CYForInInitialiser,
+    CYForInitializer,
+    CYForInInitializer,

     CYClassName,
     CYThing
 {
     CYClassName,
     CYThing
 {

-    virtual unsigned Precedence() const = 0;
+    virtual int Precedence() const = 0;

 
     virtual bool RightHand() const {
         return true;
     }
 
 
     virtual bool RightHand() const {
         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 void Output(CYOutput &out) const;
     virtual void Output(CYOutput &out, CYFlags flags) const = 0;
 
     virtual CYExpression *AddArgument(CYContext &context, CYExpression *value);
 
     virtual void Output(CYOutput &out) const;
     virtual void Output(CYOutput &out, CYFlags flags) const = 0;

-    void Output(CYOutput &out, unsigned precedence, CYFlags flags) const;
+    void Output(CYOutput &out, int precedence, CYFlags flags) const;

 
     virtual CYExpression *ClassName(CYContext &context, bool object);
     virtual void ClassName(CYOutput &out, bool object) const;
 
 
     virtual CYExpression *ClassName(CYContext &context, bool object);
     virtual void ClassName(CYOutput &out, bool object) const;
 

-    CYExpression *ReplaceAll(CYContext &context);
-

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

+    virtual CYAssignment *Assignment(CYContext &context);

 
     virtual CYExpression *Primitive(CYContext &context) {
 
     virtual CYExpression *Primitive(CYContext &context) {

-        return this;
+        return NULL;

     }
 
     }
 

+    virtual CYFunctionParameter *Parameter() const;
+

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


@@ -606,8 +534,9 @@ struct CYExpression :
     }
 
 #define CYPrecedence(value) \
     }
 
 #define CYPrecedence(value) \

-    virtual unsigned Precedence() const { \
-        return value; \
+    static const int Precedence_ = value; \
+    virtual int Precedence() const { \
+        return Precedence_; \

     }
 
 #define CYRightHand(value) \
     }
 
 #define CYRightHand(value) \


@@ -618,62 +547,73 @@ struct CYExpression :
 struct CYCompound :
     CYExpression
 {
 struct CYCompound :
     CYExpression
 {

-    CYExpression *expressions_;
+    CYExpression *expression_;
+    CYExpression *next_;

 
 

-    CYCompound(CYExpression *expressions = NULL) :
-        expressions_(expressions)
+    CYCompound(CYExpression *expression, CYExpression *next) :
+        expression_(expression),
+        next_(next)

     {
     {

-    }
-
-    void AddPrev(CYExpression *expression) {
-        CYExpression *last(expression);
-        while (last->next_ != NULL)
-            last = last->next_;
-        last->SetNext(expressions_);
-        expressions_ = expression;
+        _assert(expression_ != NULL);
+        _assert(next != NULL);

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

+
+    virtual CYFunctionParameter *Parameter() const;

 };
 
 };
 

-struct CYFunctionParameter :
-    CYNext<CYFunctionParameter>,
-    CYThing
+struct CYParenthetical :
+    CYExpression

 {
 {

-    CYIdentifier *name_;
+    CYExpression *expression_;

 
 

-    CYFunctionParameter(CYIdentifier *name, CYFunctionParameter *next = NULL) :
-        CYNext<CYFunctionParameter>(next),
-        name_(name)
+    CYParenthetical(CYExpression *expression) :
+        expression_(expression)

     {
     }
 
     {
     }
 

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

 };
 
 };
 

-struct CYOptionalFunctionParameter :
-    CYFunctionParameter
+struct CYDeclaration;
+
+struct CYFunctionParameter :
+    CYNext<CYFunctionParameter>,
+    CYThing

 {
 {

-    CYExpression *initializer_;
+    CYForInInitializer *initialiser_;

 
 

-    CYOptionalFunctionParameter(CYIdentifier *name, CYExpression *initializer, CYFunctionParameter *next = NULL) :
-        CYFunctionParameter(name, next),
-        initializer_(initializer)
+    CYFunctionParameter(CYForInInitializer *initialiser, CYFunctionParameter *next = NULL) :
+        CYNext<CYFunctionParameter>(next),
+        initialiser_(initialiser)

     {
     }
 
     {
     }
 

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

 };
 
 struct CYComprehension :
     CYNext<CYComprehension>,
     CYThing
 {
 };
 
 struct CYComprehension :
     CYNext<CYComprehension>,
     CYThing
 {

+    CYComprehension(CYComprehension *next = NULL) :
+        CYNext<CYComprehension>(next)
+    {
+    }
+
+    CYComprehension *Modify(CYComprehension *next) {
+        next_ = next;
+        return this;
+    }
+

     virtual const char *Name() const = 0;
 
     virtual CYFunctionParameter *Parameter(CYContext &context) const = 0;
     virtual const char *Name() const = 0;
 
     virtual CYFunctionParameter *Parameter(CYContext &context) const = 0;


@@ -688,7 +628,8 @@ struct CYForInComprehension :
     CYIdentifier *name_;
     CYExpression *set_;
 
     CYIdentifier *name_;
     CYExpression *set_;
 

-    CYForInComprehension(CYIdentifier *name, CYExpression *set) :
+    CYForInComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) :
+        CYComprehension(next),

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


@@ -703,13 +644,14 @@ 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, CYComprehension *next = NULL) :
+        CYComprehension(next),

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


@@ -729,7 +671,8 @@ struct CYIfComprehension :
 {
     CYExpression *test_;
 
 {
     CYExpression *test_;
 

-    CYIfComprehension(CYExpression *test) :
+    CYIfComprehension(CYExpression *test, CYComprehension *next = NULL) :
+        CYComprehension(next),

         test_(test)
     {
     }
         test_(test)
     {
     }


@@ -766,6 +709,10 @@ struct CYLiteral :
 {
     CYPrecedence(0)
     CYRightHand(false)
 {
     CYPrecedence(0)
     CYRightHand(false)

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

 };
 
 struct CYTrivial :
 };
 
 struct CYTrivial :


@@ -850,6 +797,43 @@ struct CYString :
     virtual void PropertyName(CYOutput &out) const;
 };
 
     virtual void PropertyName(CYOutput &out) const;
 };
 

+struct CYElementValue;
+
+struct CYSpan :
+    CYNext<CYSpan>
+{
+    CYExpression *expression_;
+    CYString *string_;
+
+    CYSpan(CYExpression *expression, CYString *string, CYSpan *next) :
+        CYNext<CYSpan>(next),
+        expression_(expression),
+        string_(string)
+    {
+    }
+
+    CYElementValue *Replace(CYContext &context);
+};
+
+struct CYTemplate :
+    CYExpression
+{
+    CYString *string_;
+    CYSpan *spans_;
+
+    CYTemplate(CYString *string, CYSpan *spans) :
+        string_(string),
+        spans_(spans)
+    {
+    }
+
+    CYPrecedence(0)
+    CYRightHand(false)
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+

 struct CYNumber :
     CYTrivial,
     CYPropertyName
 struct CYNumber :
     CYTrivial,
     CYPropertyName


@@ -876,9 +860,11 @@ struct CYRegEx :
     CYTrivial
 {
     const char *value_;
     CYTrivial
 {
     const char *value_;

+    size_t size_;

 
 

-    CYRegEx(const char *value) :
-        value_(value)
+    CYRegEx(const char *value, size_t size) :
+        value_(value),
+        size_(size)

     {
     }
 
     {
     }
 


@@ -890,14 +876,8 @@ struct CYRegEx :
 };
 
 struct CYNull :
 };
 
 struct CYNull :

-    CYWord,

     CYTrivial
 {
     CYTrivial
 {

-    CYNull() :
-        CYWord("null")
-    {
-    }
-

     virtual CYNumber *Number(CYContext &context);
     virtual CYString *String(CYContext &context);
 
     virtual CYNumber *Number(CYContext &context);
     virtual CYString *String(CYContext &context);
 


@@ -905,14 +885,8 @@ struct CYNull :
 };
 
 struct CYThis :
 };
 
 struct CYThis :

-    CYWord,

     CYMagic
 {
     CYMagic
 {

-    CYThis() :
-        CYWord("this")
-    {
-    }
-

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


@@ -925,14 +899,8 @@ struct CYBoolean :
 };
 
 struct CYFalse :
 };
 
 struct CYFalse :

-    CYWord,

     CYBoolean
 {
     CYBoolean
 {

-    CYFalse() :
-        CYWord("false")
-    {
-    }
-

     virtual bool Value() const {
         return false;
     }
     virtual bool Value() const {
         return false;
     }


@@ -942,14 +910,8 @@ struct CYFalse :
 };
 
 struct CYTrue :
 };
 
 struct CYTrue :

-    CYWord,

     CYBoolean
 {
     CYBoolean
 {

-    CYTrue() :
-        CYWord("true")
-    {
-    }
-

     virtual bool Value() const {
         return true;
     }
     virtual bool Value() const {
         return true;
     }


@@ -978,6 +940,8 @@ struct CYVariable :
 
     virtual CYExpression *Replace(CYContext &context);
     virtual void Output(CYOutput &out, CYFlags flags) const;
 
     virtual CYExpression *Replace(CYContext &context);
     virtual void Output(CYOutput &out, CYFlags flags) const;

+
+    virtual CYFunctionParameter *Parameter() const;

 };
 
 struct CYPrefix :
 };
 
 struct CYPrefix :


@@ -1085,29 +1049,20 @@ struct CYArgument :
     {
     }
 
     {
     }
 

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

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

-struct CYBlank :
-    public CYWord
-{
-    CYBlank() :
-        CYWord("")
-    {
-    }
-};
-

 struct CYClause :
     CYThing,
     CYNext<CYClause>
 {
     CYExpression *case_;
 struct CYClause :
     CYThing,
     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)

     {
     }
 
     {
     }
 


@@ -1116,19 +1071,49 @@ struct CYClause :
 };
 
 struct CYElement :
 };
 
 struct CYElement :

-    CYNext<CYElement>,

     CYThing
     CYThing

+{
+    virtual bool Elision() const = 0;
+
+    virtual void Replace(CYContext &context) = 0;
+};
+
+struct CYElementValue :
+    CYNext<CYElement>,
+    CYElement

 {
     CYExpression *value_;
 
 {
     CYExpression *value_;
 

-    CYElement(CYExpression *value, CYElement *next) :
+    CYElementValue(CYExpression *value, CYElement *next) :

         CYNext<CYElement>(next),
         value_(value)
     {
     }
 
         CYNext<CYElement>(next),
         value_(value)
     {
     }
 

-    void Replace(CYContext &context);
-    void Output(CYOutput &out) const;
+    virtual bool Elision() const {
+        return value_ == NULL;
+    }
+
+    virtual void Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;
+};
+
+struct CYElementSpread :
+    CYElement
+{
+    CYExpression *value_;
+
+    CYElementSpread(CYExpression *value) :
+        value_(value)
+    {
+    }
+
+    virtual bool Elision() const {
+        return false;
+    }
+
+    virtual void Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;

 };
 
 struct CYArray :
 };
 
 struct CYArray :


@@ -1164,7 +1149,7 @@ struct CYProperty :
 };
 
 struct CYDeclaration :
 };
 
 struct CYDeclaration :

-    CYForInInitialiser
+    CYForInInitializer

 {
     CYIdentifier *identifier_;
     CYExpression *initialiser_;
 {
     CYIdentifier *identifier_;
     CYExpression *initialiser_;


@@ -1176,20 +1161,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_;
 


@@ -1199,15 +1183,31 @@ struct CYDeclarations :
     {
     }
 
     {
     }
 

-    virtual void For(CYOutput &out) const;
+    void Replace(CYContext &context);

 
 

-    virtual CYCompound *Replace(CYContext &context);
+    CYExpression *Expression(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 :
+    CYForInitializer
+{
+    CYDeclarations *declarations_;
+
+    CYForDeclarations(CYDeclarations *declarations) :
+        declarations_(declarations)
+    {
+    }
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+

 struct CYVar :
     CYStatement
 {
 struct CYVar :
     CYStatement
 {


@@ -1218,22 +1218,26 @@ struct CYVar :
     {
     }
 
     {
     }
 

+    CYCompact(None)
+

     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;
 };
 

-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)

     {
     }
 
     {
     }
 

+    CYCompact(Long)
+

     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;
 };


@@ -1241,12 +1245,12 @@ struct CYLet :
 struct CYFor :
     CYStatement
 {
 struct CYFor :
     CYStatement
 {

-    CYForInitialiser *initialiser_;
+    CYForInitializer *initialiser_;

     CYExpression *test_;
     CYExpression *increment_;
     CYStatement *code_;
 
     CYExpression *test_;
     CYExpression *increment_;
     CYStatement *code_;
 

-    CYFor(CYForInitialiser *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) :
+    CYFor(CYForInitializer *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) :

         initialiser_(initialiser),
         test_(test),
         increment_(increment),
         initialiser_(initialiser),
         test_(test),
         increment_(increment),


@@ -1254,6 +1258,8 @@ struct CYFor :
     {
     }
 
     {
     }
 

+    CYCompact(Long)
+

     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;
 };


@@ -1261,35 +1267,39 @@ struct CYFor :
 struct CYForIn :
     CYStatement
 {
 struct CYForIn :
     CYStatement
 {

-    CYForInInitialiser *initialiser_;
+    CYForInInitializer *initialiser_;

     CYExpression *set_;
     CYStatement *code_;
 
     CYExpression *set_;
     CYStatement *code_;
 

-    CYForIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
+    CYForIn(CYForInInitializer *initialiser, CYExpression *set, CYStatement *code) :

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

+    CYCompact(Long)
+

     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;
 };
 

-struct CYForEachIn :
+struct CYForOf :

     CYStatement
 {
     CYStatement
 {

-    CYForInInitialiser *initialiser_;
+    CYForInInitializer *initialiser_;

     CYExpression *set_;
     CYStatement *code_;
 
     CYExpression *set_;
     CYStatement *code_;
 

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

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

+    CYCompact(Long)
+

     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;
 };


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

-
-    void Replace_(CYContext &context);

 };
 
 struct CYDirectMember :
 };
 
 struct CYDirectMember :


@@ -1372,7 +1380,7 @@ struct New :
     {
     }
 
     {
     }
 

-    virtual unsigned Precedence() const {
+    virtual int Precedence() const {

         return arguments_ == NULL ? 2 : 1;
     }
 
         return arguments_ == NULL ? 2 : 1;
     }
 


@@ -1442,8 +1450,12 @@ struct CYIf :
     {
     }
 
     {
     }
 

+    CYCompact(Long)
+

     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;

+
+    virtual CYStatement *Return();

 };
 
 struct CYDoWhile :
 };
 
 struct CYDoWhile :


@@ -1458,6 +1470,8 @@ struct CYDoWhile :
     {
     }
 
     {
     }
 

+    CYCompact(None)
+

     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;
 };


@@ -1474,6 +1488,8 @@ struct CYWhile :
     {
     }
 
     {
     }
 

+    CYCompact(Long)
+

     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;
 };


@@ -1482,20 +1498,21 @@ struct CYWhile :
 struct CYFunction {
     CYIdentifier *name_;
     CYFunctionParameter *parameters_;
 struct CYFunction {
     CYIdentifier *name_;
     CYFunctionParameter *parameters_;

-    CYBlock code_;
+    CYStatement *code_;
+

     CYNonLocal *nonlocal_;
     CYNonLocal *nonlocal_;

+    bool implicit_;
+    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),
-        nonlocal_(NULL)
+        code_(code),
+        nonlocal_(NULL),
+        implicit_(false)

     {
     }
 
     {
     }
 

-    virtual ~CYFunction() {
-    }
-

     void Inject(CYContext &context);
     virtual void Replace_(CYContext &context, bool outer);
     virtual void Output(CYOutput &out, CYFlags flags) const;
     void Inject(CYContext &context);
     virtual void Replace_(CYContext &context, bool outer);
     virtual void Output(CYOutput &out, CYFlags flags) const;


@@ -1506,8 +1523,25 @@ 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)
+    {
+    }
+
+    CYPrecedence(0)
+    CYRightHand(false)
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+// XXX: this should derive from CYAnonymousFunction
+struct CYFatArrow :
+    CYFunction,
+    CYExpression
+{
+    CYFatArrow(CYFunctionParameter *parameters, CYStatement *code) :
+        CYFunction(NULL, parameters, code)

     {
     }
 
     {
     }
 


@@ -1522,8 +1556,8 @@ struct CYFunctionExpression :
 struct CYRubyProc :
     CYFunctionExpression
 {
 struct CYRubyProc :
     CYFunctionExpression
 {

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

     {
     }
 
     {
     }
 


@@ -1536,11 +1570,13 @@ 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)

     {
     }
 
     {
     }
 

+    CYCompact(None)
+

     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;
 };


@@ -1553,13 +1589,16 @@ struct CYExpress :
     CYExpress(CYExpression *expression) :
         expression_(expression)
     {
     CYExpress(CYExpression *expression) :
         expression_(expression)
     {

-        if (expression == NULL)
+        if (expression_ == NULL)

             throw;
     }
 
             throw;
     }
 

-    virtual CYStatement *Collapse(CYContext &context);
+    CYCompact(None)
+

     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;

+
+    virtual CYStatement *Return();

 };
 
 struct CYContinue :
 };
 
 struct CYContinue :


@@ -1572,6 +1611,8 @@ struct CYContinue :
     {
     }
 
     {
     }
 

+    CYCompact(Short)
+

     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;
 };


@@ -1586,6 +1627,8 @@ struct CYBreak :
     {
     }
 
     {
     }
 

+    CYCompact(Short)
+

     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;
 };


@@ -1600,14 +1643,49 @@ struct CYReturn :
     {
     }
 
     {
     }
 

+    CYCompact(None)
+

     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;
 };
 

+struct CYYieldGenerator :
+    CYExpression
+{
+    CYExpression *value_;
+
+    CYYieldGenerator(CYExpression *value) :
+        value_(value)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYYieldValue :
+    CYExpression
+{
+    CYExpression *value_;
+
+    CYYieldValue(CYExpression *value) :
+        value_(value)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+

 struct CYEmpty :
     CYStatement
 {
 struct CYEmpty :
     CYStatement
 {

-    virtual CYStatement *Collapse(CYContext &context);
+    CYCompact(Short)
+

     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;
 };


@@ -1615,10 +1693,10 @@ struct CYEmpty :
 struct CYFinally :
     CYThing
 {
 struct CYFinally :
     CYThing
 {

-    CYBlock code_;
+    CYStatement *code_;

 
 

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

     {
     }
 
     {
     }
 


@@ -1626,6 +1704,379 @@ struct CYFinally :
     virtual void Output(CYOutput &out) const;
 };
 
     virtual void Output(CYOutput &out) const;
 };
 

+struct CYTypeSpecifier :
+    CYThing
+{
+    virtual CYExpression *Replace(CYContext &context) = 0;
+};
+
+struct CYTypeError :
+    CYTypeSpecifier
+{
+    CYTypeError() {
+    }
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;
+};
+
+struct CYTypeVoid :
+    CYTypeSpecifier
+{
+    CYTypeVoid() {
+    }
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;
+};
+
+struct CYTypeVariable :
+    CYTypeSpecifier
+{
+    CYIdentifier *name_;
+
+    CYTypeVariable(CYIdentifier *name) :
+        name_(name)
+    {
+    }
+
+    CYTypeVariable(const char *name) :
+        name_(new($pool) CYIdentifier(name))
+    {
+    }
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;
+};
+
+struct CYTypeUnsigned :
+    CYTypeSpecifier
+{
+    CYTypeSpecifier *specifier_;
+
+    CYTypeUnsigned(CYTypeSpecifier *specifier) :
+        specifier_(specifier)
+    {
+    }
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;
+};
+
+struct CYTypeSigned :
+    CYTypeSpecifier
+{
+    CYTypeSpecifier *specifier_;
+
+    CYTypeSigned(CYTypeSpecifier *specifier) :
+        specifier_(specifier)
+    {
+    }
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;
+};
+
+struct CYTypeLong :
+    CYTypeSpecifier
+{
+    CYTypeSpecifier *specifier_;
+
+    CYTypeLong(CYTypeSpecifier *specifier) :
+        specifier_(specifier)
+    {
+    }
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;
+};
+
+struct CYTypeShort :
+    CYTypeSpecifier
+{
+    CYTypeSpecifier *specifier_;
+
+    CYTypeShort(CYTypeSpecifier *specifier) :
+        specifier_(specifier)
+    {
+    }
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;
+};
+
+struct CYTypeFunctionWith;
+
+struct CYTypeModifier :
+    CYNext<CYTypeModifier>
+{
+    CYTypeModifier(CYTypeModifier *next) :
+        CYNext<CYTypeModifier>(next)
+    {
+    }
+
+    virtual int Precedence() const = 0;
+
+    virtual CYExpression *Replace_(CYContext &context, CYExpression *type) = 0;
+    CYExpression *Replace(CYContext &context, CYExpression *type);
+
+    virtual void Output(CYOutput &out, CYIdentifier *identifier) const = 0;
+    void Output(CYOutput &out, int precedence, CYIdentifier *identifier) const;
+
+    virtual CYTypeFunctionWith *Function() { return NULL; }
+};
+
+struct CYTypeArrayOf :
+    CYTypeModifier
+{
+    CYExpression *size_;
+
+    CYTypeArrayOf(CYExpression *size, CYTypeModifier *next = NULL) :
+        CYTypeModifier(next),
+        size_(size)
+    {
+    }
+
+    CYPrecedence(1)
+
+    virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
+    virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
+};
+
+struct CYTypeConstant :
+    CYTypeModifier
+{
+    CYTypeConstant(CYTypeModifier *next = NULL) :
+        CYTypeModifier(next)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
+    virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
+};
+
+struct CYTypePointerTo :
+    CYTypeModifier
+{
+    CYTypePointerTo(CYTypeModifier *next = NULL) :
+        CYTypeModifier(next)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
+    virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
+};
+
+struct CYTypeVolatile :
+    CYTypeModifier
+{
+    CYTypeVolatile(CYTypeModifier *next = NULL) :
+        CYTypeModifier(next)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
+    virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
+};
+
+struct CYTypedIdentifier :
+    CYNext<CYTypedIdentifier>,
+    CYThing
+{
+    CYLocation location_;
+    CYIdentifier *identifier_;
+    CYTypeSpecifier *specifier_;
+    CYTypeModifier *modifier_;
+
+    CYTypedIdentifier(const CYLocation &location, CYIdentifier *identifier = NULL) :
+        location_(location),
+        identifier_(identifier),
+        specifier_(NULL),
+        modifier_(NULL)
+    {
+    }
+
+    CYTypedIdentifier(CYTypeSpecifier *specifier, CYTypeModifier *modifier = NULL) :
+        identifier_(NULL),
+        specifier_(specifier),
+        modifier_(modifier)
+    {
+    }
+
+    inline CYTypedIdentifier *Modify(CYTypeModifier *modifier) {
+        CYSetLast(modifier_) = modifier;
+        return this;
+    }
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;
+
+    CYTypeFunctionWith *Function();
+};
+
+struct CYEncodedType :
+    CYExpression
+{
+    CYTypedIdentifier *typed_;
+
+    CYEncodedType(CYTypedIdentifier *typed) :
+        typed_(typed)
+    {
+    }
+
+    CYPrecedence(1)
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYTypedParameter :
+    CYNext<CYTypedParameter>,
+    CYThing
+{
+    CYTypedIdentifier *typed_;
+
+    CYTypedParameter(CYTypedIdentifier *typed, CYTypedParameter *next) :
+        CYNext<CYTypedParameter>(next),
+        typed_(typed)
+    {
+    }
+
+    CYArgument *Argument(CYContext &context);
+    CYFunctionParameter *Parameters(CYContext &context);
+    CYExpression *TypeSignature(CYContext &context, CYExpression *prefix);
+
+    virtual void Output(CYOutput &out) const;
+};
+
+struct CYLambda :
+    CYExpression
+{
+    CYTypedIdentifier *typed_;
+    CYTypedParameter *parameters_;
+    CYStatement *code_;
+
+    CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *code) :
+        typed_(typed),
+        parameters_(parameters),
+        code_(code)
+    {
+    }
+
+    CYPrecedence(1)
+
+    virtual CYExpression *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYModule :
+    CYNext<CYModule>,
+    CYThing
+{
+    CYWord *part_;
+
+    CYModule(CYWord *part, CYModule *next = NULL) :
+        CYNext<CYModule>(next),
+        part_(part)
+    {
+    }
+
+    CYString *Replace(CYContext &context, const char *separator) const;
+    void Output(CYOutput &out) const;
+};
+
+struct CYImport :
+    CYStatement
+{
+    CYModule *module_;
+
+    CYImport(CYModule *module) :
+        module_(module)
+    {
+    }
+
+    CYCompact(None)
+
+    virtual CYStatement *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYExternal :
+    CYStatement
+{
+    CYString *abi_;
+    CYTypedIdentifier *typed_;
+
+    CYExternal(CYString *abi, CYTypedIdentifier *typed) :
+        abi_(abi),
+        typed_(typed)
+    {
+    }
+
+    CYCompact(None)
+
+    virtual CYStatement *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYTypeDefinition :
+    CYStatement
+{
+    CYTypedIdentifier *typed_;
+
+    CYTypeDefinition(CYTypedIdentifier *typed) :
+        typed_(typed)
+    {
+    }
+
+    CYCompact(None)
+
+    virtual CYStatement *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYTypeBlockWith :
+    CYTypeModifier
+{
+    CYTypedParameter *parameters_;
+
+    CYTypeBlockWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) :
+        CYTypeModifier(next),
+        parameters_(parameters)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
+    virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
+};
+
+struct CYTypeFunctionWith :
+    CYTypeModifier
+{
+    CYTypedParameter *parameters_;
+
+    CYTypeFunctionWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) :
+        CYTypeModifier(next),
+        parameters_(parameters)
+    {
+    }
+
+    CYPrecedence(1)
+
+    virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
+    virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
+
+    virtual CYTypeFunctionWith *Function() { return this; }
+};
+

 namespace cy {
 namespace Syntax {
 
 namespace cy {
 namespace Syntax {
 


@@ -1633,11 +2084,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)

     {
     }
 
     {
     }
 


@@ -1648,17 +2099,19 @@ 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)
     {
     }
 

+    CYCompact(Short)
+

     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 +2126,8 @@ struct Throw :
     {
     }
 
     {
     }
 

+    CYCompact(None)
+

     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;
 };


@@ -1691,6 +2146,8 @@ struct CYWith :
     {
     }
 
     {
     }
 

+    CYCompact(Long)
+

     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;
 };


@@ -1707,6 +2164,21 @@ struct CYSwitch :
     {
     }
 
     {
     }
 

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

     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;
 };


@@ -1842,7 +2314,7 @@ CYPrefix_(false, "-", Negate)
 CYPrefix_(false, "~", BitwiseNot)
 CYPrefix_(false, "!", LogicalNot)
 
 CYPrefix_(false, "~", BitwiseNot)
 CYPrefix_(false, "!", LogicalNot)
 

-CYInfix_(false, 5, "*", Multiply)
+CYInfix_(false, 5, "*", Multiply, CYReplace)

 CYInfix_(false, 5, "/", Divide)
 CYInfix_(false, 5, "%", Modulus)
 CYInfix_(false, 6, "+", Add, CYReplace)
 CYInfix_(false, 5, "/", Divide)
 CYInfix_(false, 5, "%", Modulus)
 CYInfix_(false, 6, "+", Add, CYReplace)


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

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