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

[cycript.git] / Parser.hpp

diff --git a/Parser.hpp b/Parser.hpp
index 2c534cce50f150d70e6941625a4f8162b2275f29..02b08ebee8b448a9b1c78ce2f19b7910ab6837be 100644 (file)
--- a/Parser.hpp
+++ b/Parser.hpp
@@ -22,8 +22,7 @@
 #ifndef CYCRIPT_PARSER_HPP
 #define CYCRIPT_PARSER_HPP
 
 #ifndef CYCRIPT_PARSER_HPP
 #define CYCRIPT_PARSER_HPP
 

-#include <iostream>
-
+#include <streambuf>

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


@@ -40,17 +39,17 @@
 struct CYContext;
 
 struct CYThing {
 struct CYContext;
 
 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 {


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


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


@@ -91,9 +110,6 @@ 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;


@@ -145,19 +161,28 @@ _finline CYFlags CYCenter(CYFlags flags) {
     return CYLeft(CYRight(flags));
 }
 
     return CYLeft(CYRight(flags));
 }
 

+enum CYCompactType {
+    CYCompactNone,
+    CYCompactLong,
+    CYCompactShort,
+};
+
+#define CYCompact(type) \
+    virtual CYCompactType Compact() const { \
+        return CYCompact ## type; \
+    }
+

 struct CYStatement :
     CYNext<CYStatement>,
     CYThing
 {
 struct CYStatement :
     CYNext<CYStatement>,
     CYThing
 {

-    virtual ~CYStatement() {
-    }
-
-    void Single(CYOutput &out, CYFlags flags) const;
+    void Single(CYOutput &out, CYFlags flags, CYCompactType request) const;

     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
     virtual void Output(CYOutput &out) const;
 
     virtual CYStatement *Replace(CYContext &context) = 0;
 
     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
     virtual void Output(CYOutput &out) const;
 
     virtual CYStatement *Replace(CYContext &context) = 0;
 

+    virtual CYCompactType Compact() const = 0;

     virtual CYStatement *Return();
 
   private:
     virtual CYStatement *Return();
 
   private:


@@ -194,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;
 };


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


@@ -276,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;
 };


@@ -330,12 +340,12 @@ struct CYScope {
     void Close(CYContext &context, CYStatement *&statements);
 };
 
     void Close(CYContext &context, CYStatement *&statements);
 };
 

-struct CYProgram :
+struct CYScript :

     CYThing
 {
     CYStatement *code_;
 
     CYThing
 {
     CYStatement *code_;
 

-    CYProgram(CYStatement *code) :
+    CYScript(CYStatement *code) :

         code_(code)
     {
     }
         code_(code)
     {
     }


@@ -369,9 +379,6 @@ struct CYContext {
     {
     }
 
     {
     }
 

-    virtual ~CYContext() {
-    }
-

     void ReplaceAll(CYStatement *&statement) {
         if (statement == NULL)
             return;
     void ReplaceAll(CYStatement *&statement) {
         if (statement == NULL)
             return;


@@ -446,6 +453,8 @@ struct CYBlock :
     {
     }
 
     {
     }
 

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


@@ -453,18 +462,12 @@ struct CYBlock :
     virtual CYStatement *Return();
 };
 
     virtual CYStatement *Return();
 };
 

-struct CYForInitialiser {
-    virtual ~CYForInitialiser() {
-    }
-
+struct CYForInitializer {

     virtual CYExpression *Replace(CYContext &context) = 0;
     virtual void Output(CYOutput &out, CYFlags flags) const = 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 CYStatement *ForEachIn(CYContext &out, CYExpression *value) = 0;
 
     virtual void ForIn(CYOutput &out, CYFlags flags) const = 0;
     virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value) = 0;
 


@@ -480,8 +483,8 @@ struct CYNumber;
 struct CYString;
 
 struct CYExpression :
 struct CYString;
 
 struct CYExpression :

-    CYForInitialiser,
-    CYForInInitialiser,
+    CYForInitializer,
+    CYForInInitializer,

     CYClassName,
     CYThing
 {
     CYClassName,
     CYThing
 {


@@ -585,9 +588,9 @@ struct CYFunctionParameter :
     CYNext<CYFunctionParameter>,
     CYThing
 {
     CYNext<CYFunctionParameter>,
     CYThing
 {

-    CYForInInitialiser *initialiser_;
+    CYForInInitializer *initialiser_;

 
 

-    CYFunctionParameter(CYForInInitialiser *initialiser, CYFunctionParameter *next = NULL) :
+    CYFunctionParameter(CYForInInitializer *initialiser, CYFunctionParameter *next = NULL) :

         CYNext<CYFunctionParameter>(next),
         initialiser_(initialiser)
     {
         CYNext<CYFunctionParameter>(next),
         initialiser_(initialiser)
     {


@@ -794,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


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

     {
     }
 
     {
     }
 


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


@@ -849,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;
 };


@@ -869,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;
     }


@@ -886,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;
     }


@@ -1035,15 +1053,6 @@ struct CYArgument :
     void Output(CYOutput &out) const;
 };
 
     void Output(CYOutput &out) const;
 };
 

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

 struct CYClause :
     CYThing,
     CYNext<CYClause>
 struct CYClause :
     CYThing,
     CYNext<CYClause>


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


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

-    CYForInInitialiser
+    CYForInInitializer

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


@@ -1156,7 +1195,7 @@ struct CYDeclarations :
 };
 
 struct CYForDeclarations :
 };
 
 struct CYForDeclarations :

-    CYForInitialiser
+    CYForInitializer

 {
     CYDeclarations *declarations_;
 
 {
     CYDeclarations *declarations_;
 


@@ -1179,6 +1218,8 @@ 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;
 };


@@ -1195,6 +1236,8 @@ struct CYLetStatement :
     {
     }
 
     {
     }
 

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


@@ -1202,12 +1245,12 @@ struct CYLetStatement :
 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),


@@ -1215,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;
 };


@@ -1222,17 +1267,19 @@ 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;
 };


@@ -1240,17 +1287,19 @@ struct CYForIn :
 struct CYForOf :
     CYStatement
 {
 struct CYForOf :
     CYStatement
 {

-    CYForInInitialiser *initialiser_;
+    CYForInInitializer *initialiser_;

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

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


@@ -1401,6 +1450,8 @@ 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;
 


@@ -1419,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;
 };


@@ -1435,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;
 };


@@ -1458,9 +1513,6 @@ struct CYFunction {
     {
     }
 
     {
     }
 

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


@@ -1523,6 +1575,8 @@ struct CYFunctionStatement :
     {
     }
 
     {
     }
 

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


@@ -1539,6 +1593,8 @@ struct CYExpress :
             throw;
     }
 
             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;
 


@@ -1555,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;
 };


@@ -1569,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;
 };


@@ -1583,13 +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
 {

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


@@ -1905,6 +2001,8 @@ struct CYImport :
     {
     }
 
     {
     }
 

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


@@ -1921,6 +2019,8 @@ struct CYExternal :
     {
     }
 
     {
     }
 

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


@@ -1935,6 +2035,8 @@ struct CYTypeDefinition :
     {
     }
 
     {
     }
 

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


@@ -2008,6 +2110,8 @@ struct Try :
     {
     }
 
     {
     }
 

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


@@ -2022,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;
 };


@@ -2040,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;
 };


@@ -2056,6 +2164,8 @@ struct CYSwitch :
     {
     }
 
     {
     }
 

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


@@ -2067,6 +2177,8 @@ struct 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;
 };