Re-added final output to script execution, implemented unary affirmation operator...

[cycript.git] / Parser.hpp

diff --git a/Parser.hpp b/Parser.hpp
index d7cc5fdc0b3fdd154594f9da54806ff7fd9eeece..a9a881296312c5dc9b520601c428861ed10ac2ab 100644 (file)
--- a/Parser.hpp
+++ b/Parser.hpp
@@ -67,28 +67,54 @@ struct CYNext {
 };
 
 struct CYThing {
-    virtual void Output(std::ostream &out) const = 0;
-};
+    virtual void Output(struct CYOutput &out) const = 0;
+};
+
+struct CYOutput {
+    std::ostream &out_;
+    bool pretty_;
+    unsigned indent_;
+
+    enum {
+        NoMode,
+        NoLetter,
+        NoPlus,
+        NoHyphen,
+        Terminated
+    } mode_;
+
+    CYOutput(std::ostream &out) :
+        out_(out),
+        pretty_(false),
+        indent_(0),
+        mode_(NoMode)
+    {
+    }
 
-_finline std::ostream &operator <<(std::ostream &out, const CYThing &rhs) {
-    rhs.Output(out);
-    return out;
-}
+    void Check(char value);
+    void Terminate();
 
-struct CYSource :
-    CYNext<CYSource>
-{
-    virtual void Show(std::ostream &out) const;
-    virtual void Output(std::ostream &out) const = 0;
-    virtual void Output(std::ostream &out, bool block) const;
+    CYOutput &operator <<(char rhs);
+    CYOutput &operator <<(const char *rhs);
+
+    _finline CYOutput &operator <<(const CYThing *rhs) {
+        if (rhs != NULL)
+            rhs->Output(*this);
+        return *this;
+    }
+
+    _finline CYOutput &operator <<(const CYThing &rhs) {
+        rhs.Output(*this);
+        return *this;
+    }
 };
 
 struct CYPropertyName {
-    virtual void PropertyName(std::ostream &out) const = 0;
+    virtual void PropertyName(CYOutput &out) const = 0;
 };
 
 struct CYClassName {
-    virtual void ClassName(std::ostream &out) const = 0;
+    virtual void ClassName(CYOutput &out, bool object) const = 0;
 };
 
 struct CYWord :
@@ -107,12 +133,16 @@ struct CYWord :
         return word_;
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out) const;
 
-    virtual void ClassName(std::ostream &out) const;
-    virtual void PropertyName(std::ostream &out) const;
+    virtual void ClassName(CYOutput &out, bool object) const;
+    virtual void PropertyName(CYOutput &out) const;
 };
 
+_finline std::ostream &operator <<(std::ostream &lhs, const CYWord &rhs) {
+    return lhs << rhs.Value();
+}
+
 struct CYIdentifier :
     CYWord
 {
@@ -125,23 +155,64 @@ struct CYIdentifier :
 struct CYLabel :
     CYNext<CYLabel>
 {
-    CYIdentifier *identifier_;
+    CYIdentifier *name_;
 
-    CYLabel(CYIdentifier *identifier, CYLabel *next) :
+    CYLabel(CYIdentifier *name, CYLabel *next) :
         CYNext<CYLabel>(next),
-        identifier_(identifier)
+        name_(name)
     {
     }
 };
 
+enum CYNeeded {
+    CYNever     = -1,
+    CYSometimes =  0,
+    CYAlways    =  1,
+};
+
+enum CYFlags {
+    CYNoFlags =      0,
+    CYNoBrace =      (1 << 0),
+    CYNoFunction =   (1 << 1),
+    CYNoIn =         (1 << 2),
+    CYNoCall =       (1 << 3),
+    CYNoRightHand =  (1 << 4),
+    CYNoDangle =     (1 << 5),
+    CYNoBF =         (CYNoBrace | CYNoFunction),
+};
+
 struct CYStatement :
-    CYSource
+    CYNext<CYStatement>
 {
-    CYLabel *label_;
+    CYLabel *labels_;
+
+    CYStatement() :
+        labels_(NULL)
+    {
+    }
 
     void AddLabel(CYIdentifier *identifier) {
-        label_ = new CYLabel(identifier, label_);
+        labels_ = new CYLabel(identifier, labels_);
+    }
+
+    bool Single(CYOutput &out, CYFlags flags) const;
+    void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
+
+  private:
+    virtual void Output(CYOutput &out, CYFlags flags) const = 0;
+};
+
+struct CYBlock :
+    CYStatement
+{
+    CYStatement *statements_;
+
+    CYBlock(CYStatement *statements) :
+        statements_(statements)
+    {
     }
+
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 enum CYState {
@@ -159,17 +230,26 @@ class CYDriver {
 
     const char *data_;
     size_t size_;
+    FILE *file_;
+
+    bool strict_;
+
+    enum Condition {
+        RegExStart,
+        RegExRest
+    };
 
     std::string filename_;
 
     struct Error {
+        bool warning_;
         cy::location location_;
         std::string message_;
     };
 
     typedef std::vector<Error> Errors;
 
-    CYSource *source_;
+    CYStatement *program_;
     Errors errors_;
 
   private:
@@ -179,43 +259,46 @@ class CYDriver {
   public:
     CYDriver(const std::string &filename);
     ~CYDriver();
-};
 
-struct CYPart {
-    virtual void Part(std::ostream &out) const = 0;
-};
+    void SetCondition(Condition condition);
 
-struct CYForInitialiser :
-    CYPart
-{
+    void Warning(const cy::location &location, const char *message);
 };
 
-struct CYForInInitialiser :
-    CYPart
-{
+struct CYForInitialiser {
+    virtual void For(CYOutput &out) const = 0;
 };
 
-enum CYFlags {
-    CYNoFlags =    0,
-    CYNoBrace =    (1 << 0),
-    CYNoFunction = (1 << 1),
-    CYNoLeader =   (1 << 2),
-    CYNoTrailer =  (1 << 3),
-    CYNoIn =       (1 << 4),
+struct CYForInInitialiser {
+    virtual void ForIn(CYOutput &out, CYFlags flags) const = 0;
+    virtual const char *ForEachIn() const = 0;
+    virtual void ForEachIn(CYOutput &out) const = 0;
 };
 
 struct CYExpression :
     CYNext<CYExpression>,
     CYForInitialiser,
     CYForInInitialiser,
-    CYClassName
+    CYClassName,
+    CYThing
 {
     virtual unsigned Precedence() const = 0;
-    virtual void Part(std::ostream &out) const;
-    virtual void Output(std::ostream &out, CYFlags flags) const = 0;
-    void Output(std::ostream &out, unsigned precedence, CYFlags flags) const;
 
-    virtual void ClassName(std::ostream &out) const;
+    virtual bool RightHand() const {
+        return true;
+    }
+
+    virtual void For(CYOutput &out) const;
+    virtual void ForIn(CYOutput &out, CYFlags flags) const;
+
+    virtual const char *ForEachIn() const;
+    virtual void ForEachIn(CYOutput &out) const;
+
+    virtual void Output(CYOutput &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const = 0;
+    void Output(CYOutput &out, unsigned precedence, CYFlags flags) const;
+
+    virtual void ClassName(CYOutput &out, bool object) const;
 
     virtual const char *Word() const {
         return NULL;
@@ -232,6 +315,11 @@ struct CYExpression :
         return value; \
     }
 
+#define CYRightHand(value) \
+    virtual bool RightHand() const { \
+        return value; \
+    }
+
 struct CYCompound :
     CYExpression
 {
@@ -252,23 +340,112 @@ struct CYCompound :
 
     CYPrecedence(17)
 
-    void Output(std::ostream &out, CYFlags flags) const;
+    void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYComprehension :
+    CYNext<CYComprehension>,
+    CYThing
+{
+    void Output(CYOutput &out) const;
+    virtual const char *Name() const = 0;
+
+    virtual void Begin_(CYOutput &out) const = 0;
+
+    virtual void End_(CYOutput &out) const {
+    }
+};
+
+struct CYForInComprehension :
+    CYComprehension
+{
+    CYIdentifier *name_;
+    CYExpression *set_;
+
+    CYForInComprehension(CYIdentifier *name, CYExpression *set) :
+        name_(name),
+        set_(set)
+    {
+    }
+
+    virtual const char *Name() const {
+        return name_->Value();
+    }
+
+    virtual void Begin_(CYOutput &out) const;
+};
+
+struct CYForEachInComprehension :
+    CYComprehension
+{
+    CYIdentifier *name_;
+    CYExpression *set_;
+
+    CYForEachInComprehension(CYIdentifier *name, CYExpression *set) :
+        name_(name),
+        set_(set)
+    {
+    }
+
+    virtual const char *Name() const {
+        return name_->Value();
+    }
+
+    virtual void Begin_(CYOutput &out) const;
+    virtual void End_(CYOutput &out) const;
+};
+
+struct CYIfComprehension :
+    CYComprehension
+{
+    CYExpression *test_;
+
+    CYIfComprehension(CYExpression *test) :
+        test_(test)
+    {
+    }
+
+    virtual const char *Name() const {
+        return NULL;
+    }
+
+    virtual void Begin_(CYOutput &out) const;
+};
+
+struct CYArrayComprehension :
+    CYExpression
+{
+    CYExpression *expression_;
+    CYComprehension *comprehensions_;
+
+    CYArrayComprehension(CYExpression *expression, CYComprehension *comprehensions) :
+        expression_(expression),
+        comprehensions_(comprehensions)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYLiteral :
     CYExpression
 {
     CYPrecedence(0)
+    CYRightHand(false)
 };
 
 struct CYMagic :
     CYExpression
 {
     CYPrecedence(0)
+    CYRightHand(false)
 };
 
 struct CYSelectorPart :
-    CYNext<CYSelectorPart>
+    CYNext<CYSelectorPart>,
+    CYThing
 {
     CYWord *name_;
     bool value_;
@@ -280,7 +457,7 @@ struct CYSelectorPart :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out) const;
 };
 
 struct CYSelector :
@@ -295,7 +472,7 @@ struct CYSelector :
 
     CYPrecedence(1)
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYRange {
@@ -345,21 +522,10 @@ struct CYString :
         return value_;
     }
 
-    virtual const char *Word() const {
-        if (size_ == 0 || !WordStartRange_[value_[0]])
-            return NULL;
-        for (size_t i(1); i != size_; ++i)
-            if (!WordEndRange_[value_[i]])
-                return NULL;
-        return Value();
-    }
-
-    virtual void Output(std::ostream &out) const {
-        return Output(out, CYNoFlags);
-    }
+    virtual const char *Word() const;
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
-    virtual void PropertyName(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+    virtual void PropertyName(CYOutput &out) const;
 };
 
 struct CYNumber :
@@ -377,12 +543,25 @@ struct CYNumber :
         return value_;
     }
 
-    virtual void Output(std::ostream &out) const {
-        return Output(out, CYNoFlags);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+    virtual void PropertyName(CYOutput &out) const;
+};
+
+struct CYRegEx :
+    CYLiteral
+{
+    const char *value_;
+
+    CYRegEx(const char *value) :
+        value_(value)
+    {
+    }
+
+    const char *Value() const {
+        return value_;
     }
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
-    virtual void PropertyName(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYNull :
@@ -394,7 +573,7 @@ struct CYNull :
     {
     }
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYThis :
@@ -406,14 +585,14 @@ struct CYThis :
     {
     }
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYBoolean :
     CYLiteral
 {
     virtual bool Value() const = 0;
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYFalse :
@@ -425,7 +604,9 @@ struct CYFalse :
     {
     }
 
-    virtual bool Value() const;
+    virtual bool Value() const {
+        return false;
+    }
 };
 
 struct CYTrue :
@@ -437,7 +618,9 @@ struct CYTrue :
     {
     }
 
-    virtual bool Value() const;
+    virtual bool Value() const {
+        return true;
+    }
 };
 
 struct CYVariable :
@@ -451,8 +634,9 @@ struct CYVariable :
     }
 
     CYPrecedence(0)
+    CYRightHand(false)
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYPrefix :
@@ -468,7 +652,7 @@ struct CYPrefix :
     virtual bool Alphabetic() const = 0;
     virtual const char *Operator() const = 0;
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYInfix :
@@ -490,7 +674,7 @@ struct CYInfix :
     virtual bool Alphabetic() const = 0;
     virtual const char *Operator() const = 0;
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYPostfix :
@@ -505,7 +689,7 @@ struct CYPostfix :
 
     virtual const char *Operator() const = 0;
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYAssignment :
@@ -526,11 +710,12 @@ struct CYAssignment :
 
     virtual const char *Operator() const = 0;
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYArgument :
-    CYNext<CYArgument>
+    CYNext<CYArgument>,
+    CYThing
 {
     CYWord *name_;
     CYExpression *value_;
@@ -542,7 +727,7 @@ struct CYArgument :
     {
     }
 
-    void Output(std::ostream &out) const;
+    void Output(CYOutput &out) const;
 };
 
 struct CYBlank :
@@ -567,11 +752,12 @@ struct CYClause :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out) const;
 };
 
 struct CYElement :
-    CYNext<CYElement>
+    CYNext<CYElement>,
+    CYThing
 {
     CYExpression *value_;
 
@@ -581,7 +767,7 @@ struct CYElement :
     {
     }
 
-    void Output(std::ostream &out) const;
+    void Output(CYOutput &out) const;
 };
 
 struct CYArray :
@@ -594,11 +780,10 @@ struct CYArray :
     {
     }
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYDeclaration :
-    CYThing,
     CYForInInitialiser
 {
     CYIdentifier *identifier_;
@@ -610,31 +795,65 @@ struct CYDeclaration :
     {
     }
 
-    virtual void Part(std::ostream &out) const;
-    virtual void Output(std::ostream &out) const;
+    virtual void ForIn(CYOutput &out, CYFlags flags) const;
+
+    virtual const char *ForEachIn() const;
+    virtual void ForEachIn(CYOutput &out) const;
+
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYDeclarations :
-    CYStatement,
-    CYForInitialiser
+    CYNext<CYDeclarations>,
+    CYForInitialiser,
+    CYThing
 {
     CYDeclaration *declaration_;
-    CYDeclarations *next_;
 
     CYDeclarations(CYDeclaration *declaration, CYDeclarations *next) :
-        declaration_(declaration),
-        next_(next)
+        CYNext<CYDeclarations>(next),
+        declaration_(declaration)
+    {
+    }
+
+    virtual void For(CYOutput &out) const;
+
+    virtual void Output(CYOutput &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYVar :
+    CYStatement
+{
+    CYDeclarations *declarations_;
+
+    CYVar(CYDeclarations *declarations) :
+        declarations_(declarations)
     {
     }
 
-    virtual void Part(std::ostream &out) const;
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYLet :
+    CYStatement
+{
+    CYDeclarations *declarations_;
+    CYStatement *statements_;
+
+    CYLet(CYDeclarations *declarations, CYStatement *statements) :
+        declarations_(declarations),
+        statements_(statements)
+    {
+    }
+
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYField :
     CYNext<CYField>
 {
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out) const;
 };
 
 struct CYMessageParameter :
@@ -658,9 +877,9 @@ struct CYMessage :
     bool instance_;
     CYExpression *type_;
     CYMessageParameter *parameter_;
-    CYSource *body_;
+    CYStatement *body_;
 
-    CYMessage(bool instance, CYExpression *type, CYMessageParameter *parameter, CYSource *body) :
+    CYMessage(bool instance, CYExpression *type, CYMessageParameter *parameter, CYStatement *body) :
         instance_(instance),
         type_(type),
         parameter_(parameter),
@@ -668,18 +887,16 @@ struct CYMessage :
     {
     }
 
-    virtual void Output(std::ostream &out, bool replace) const;
+    virtual void Output(CYOutput &out, bool replace) const;
 };
 
-struct CYClass :
-    CYSource
-{
-    CYIdentifier *name_;
+struct CYClass {
+    CYClassName *name_;
     CYExpression *super_;
     CYField *fields_;
     CYMessage *messages_;
 
-    CYClass(CYIdentifier *name, CYExpression *super, CYField *fields, CYMessage *messages) :
+    CYClass(CYClassName *name, CYExpression *super, CYField *fields, CYMessage *messages) :
         name_(name),
         super_(super),
         fields_(fields),
@@ -687,11 +904,37 @@ struct CYClass :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYClassExpression :
+    CYClass,
+    CYExpression
+{
+    CYClassExpression(CYClassName *name, CYExpression *super, CYField *fields, CYMessage *messages) :
+        CYClass(name, super, fields, messages)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYClassStatement :
+    CYClass,
+    CYStatement
+{
+    CYClassStatement(CYClassName *name, CYExpression *super, CYField *fields, CYMessage *messages) :
+        CYClass(name, super, fields, messages)
+    {
+    }
+
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYCategory :
-    CYSource
+    CYStatement
 {
     CYClassName *name_;
     CYMessage *messages_;
@@ -702,7 +945,7 @@ struct CYCategory :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYFunctionParameter :
@@ -717,7 +960,7 @@ struct CYFunctionParameter :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out) const;
 };
 
 struct CYFor :
@@ -736,7 +979,7 @@ struct CYFor :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYForIn :
@@ -753,11 +996,29 @@ struct CYForIn :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYForEachIn :
+    CYStatement
+{
+    CYForInInitialiser *initialiser_;
+    CYExpression *set_;
+    CYStatement *code_;
+
+    CYForEachIn(CYForInInitialiser *initialiser, CYExpression *set, CYStatement *code) :
+        initialiser_(initialiser),
+        set_(set),
+        code_(code)
+    {
+    }
+
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYProperty :
-    CYNext<CYProperty>
+    CYNext<CYProperty>,
+    CYThing
 {
     CYPropertyName *name_;
     CYExpression *value_;
@@ -769,7 +1030,7 @@ struct CYProperty :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out) const;
 };
 
 struct CYObject :
@@ -782,7 +1043,7 @@ struct CYObject :
     {
     }
 
-    void Output(std::ostream &out, CYFlags flags) const;
+    void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYCatch :
@@ -797,7 +1058,7 @@ struct CYCatch :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out) const;
 };
 
 struct CYSend :
@@ -814,7 +1075,7 @@ struct CYSend :
 
     CYPrecedence(0)
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYMember :
@@ -829,9 +1090,37 @@ struct CYMember :
     {
     }
 
+    void SetLeft(CYExpression *object) {
+        object_ = object;
+    }
+};
+
+struct CYDirectMember :
+    CYMember
+{
+    CYDirectMember(CYExpression *object, CYExpression *property) :
+        CYMember(object, property)
+    {
+    }
+
+    CYPrecedence(1)
+    CYRightHand(false)
+
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYIndirectMember :
+    CYMember
+{
+    CYIndirectMember(CYExpression *object, CYExpression *property) :
+        CYMember(object, property)
+    {
+    }
+
     CYPrecedence(1)
+    CYRightHand(false)
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYNew :
@@ -846,9 +1135,13 @@ struct CYNew :
     {
     }
 
-    CYPrecedence(1)
+    virtual unsigned Precedence() const {
+        return arguments_ == NULL ? 2 : 1;
+    }
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    CYRightHand(false)
+
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYCall :
@@ -863,9 +1156,10 @@ struct CYCall :
     {
     }
 
-    CYPrecedence(2)
+    CYPrecedence(1)
+    CYRightHand(false)
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYIf :
@@ -882,7 +1176,7 @@ struct CYIf :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYDoWhile :
@@ -897,7 +1191,7 @@ struct CYDoWhile :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYWhile :
@@ -912,38 +1206,49 @@ struct CYWhile :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
-struct CYLambda :
-    CYExpression
-{
+struct CYFunction {
     CYIdentifier *name_;
     CYFunctionParameter *parameters_;
-    CYSource *body_;
+    CYStatement *body_;
 
-    CYLambda(CYIdentifier *name, CYFunctionParameter *parameters, CYSource *body) :
+    CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *body) :
         name_(name),
         parameters_(parameters),
         body_(body)
     {
     }
 
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYFunctionExpression :
+    CYFunction,
+    CYExpression
+{
+    CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *body) :
+        CYFunction(name, parameters, body)
+    {
+    }
+
     CYPrecedence(0)
+    CYRightHand(false)
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
-struct CYFunction :
-    CYLambda,
-    CYSource
+struct CYFunctionStatement :
+    CYFunction,
+    CYStatement
 {
-    CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYSource *body) :
-        CYLambda(name, parameters, body)
+    CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *body) :
+        CYFunction(name, parameters, body)
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYExpress :
@@ -956,7 +1261,7 @@ struct CYExpress :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYContinue :
@@ -969,7 +1274,7 @@ struct CYContinue :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYBreak :
@@ -982,7 +1287,7 @@ struct CYBreak :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYReturn :
@@ -995,31 +1300,43 @@ struct CYReturn :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYEmpty :
     CYStatement
 {
-    virtual void Output(std::ostream &out) const;
-    virtual void Output(std::ostream &out, bool block) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
+struct CYFinally :
+    CYThing
+{
+    CYStatement *code_;
+
+    CYFinally(CYStatement *code) :
+        code_(code)
+    {
+    }
+
+    virtual void Output(CYOutput &out) const;
 };
 
 struct CYTry :
     CYStatement
 {
-    CYStatement *try_;
+    CYStatement *code_;
     CYCatch *catch_;
-    CYStatement *finally_;
+    CYFinally *finally_;
 
-    CYTry(CYStatement *_try, CYCatch *_catch, CYStatement *finally) :
-        try_(_try),
+    CYTry(CYStatement *code, CYCatch *_catch, CYFinally *finally) :
+        code_(code),
         catch_(_catch),
         finally_(finally)
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYThrow :
@@ -1032,7 +1349,7 @@ struct CYThrow :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYWith :
@@ -1047,7 +1364,7 @@ struct CYWith :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYSwitch :
@@ -1062,7 +1379,7 @@ struct CYSwitch :
     {
     }
 
-    virtual void Output(std::ostream &out) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYCondition :
@@ -1081,7 +1398,7 @@ struct CYCondition :
 
     CYPrecedence(15)
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYAddressOf :
@@ -1099,7 +1416,7 @@ struct CYAddressOf :
     CYAlphabetic(false)
     CYPrecedence(2)
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 struct CYIndirect :
@@ -1117,7 +1434,7 @@ struct CYIndirect :
     CYAlphabetic(false)
     CYPrecedence(1)
 
-    virtual void Output(std::ostream &out, CYFlags flags) const;
+    virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
 #define CYPostfix_(op, name) \
@@ -1194,6 +1511,7 @@ CYPrefix_(true, "void", Void)
 CYPrefix_(true, "typeof", TypeOf)
 CYPrefix_(false, "++", PreIncrement)
 CYPrefix_(false, "--", PreDecrement)
+CYPrefix_(false, "+", Affirm)
 CYPrefix_(false, "-", Negate)
 CYPrefix_(false, "~", BitwiseNot)
 CYPrefix_(false, "!", LogicalNot)