Drastically improve pretty printed code structure.

[cycript.git] / Parser.hpp

diff --git a/Parser.hpp b/Parser.hpp
index de8d5a5c0156f43dd5b7556ddea9e4aa4557ce08..028ea0cc222dca3b10713805640eee10805e1a57 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>


@@ -47,10 +46,13 @@ struct CYThing {
 };
 
 struct CYOutput {
 };
 
 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 +63,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 +77,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);
 


@@ -145,17 +167,33 @@ _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 :
 struct CYStatement :

-    CYNext<CYStatement>
+    CYNext<CYStatement>,
+    CYThing

 {
     virtual ~CYStatement() {
     }
 
 {
     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;
     void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;

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


@@ -256,6 +294,8 @@ struct CYComment :
     {
     }
 
     {
     }
 

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


@@ -272,6 +312,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;
 };


@@ -313,33 +355,26 @@ typedef std::vector<CYIdentifierUsage> CYIdentifierUsageVector;
 
 struct CYScope {
     bool transparent_;
 
 struct CYScope {
     bool transparent_;

-
-    CYContext &context_;
-    CYStatement *&statements_;
-

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

-    CYScope(bool transparent, CYContext &context, CYStatement *&statements);
-    virtual ~CYScope();
-
-    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 :
     CYThing
 {
 };
 
 struct CYProgram :
     CYThing
 {

-    CYStatement *statements_;
+    CYStatement *code_;

 
 

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

     {
     }
 
     {
     }
 


@@ -375,14 +410,18 @@ struct CYContext {
     virtual ~CYContext() {
     }
 
     virtual ~CYContext() {
     }
 

-    template <typename Type_>
-    void ReplaceAll(Type_ *&values) {
-        Type_ **last(&values);
-        CYForEach (next, values) {
-            Replace(*last = next);
-            if (*last != NULL)
-                last = &(*last)->next_;
-        }
+    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_>


@@ -436,29 +475,22 @@ struct CYThisScope :
 };
 
 struct CYBlock :
 };
 
 struct CYBlock :

-    CYStatement,
-    CYThing
+    CYStatement

 {
 {

-    CYStatement *statements_;
+    CYStatement *code_;

 
 

-    CYBlock(CYStatement *statements) :
-        statements_(statements)
+    CYBlock(CYStatement *code) :
+        code_(code)

     {
     }
 
     {
     }
 

-    operator CYStatement *() const {
-        return statements_;
-    }
-
-    void AddPrev(CYStatement *statement) {
-        CYSetLast(statement) = statements_;
-        statements_ = statement;
-    }
+    CYCompact(Short)

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

-    virtual void Output(CYOutput &out) const;

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

+
+    virtual CYStatement *Return();

 };
 
 struct CYForInitialiser {
 };
 
 struct CYForInitialiser {


@@ -519,7 +551,6 @@ struct CYExpression :
     }
 
     virtual CYFunctionParameter *Parameter() const;
     }
 
     virtual CYFunctionParameter *Parameter() const;

-    virtual CYFunctionParameter *Parameters() const;

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


@@ -556,13 +587,12 @@ struct CYCompound :
     CYExpression *expression_;
     CYExpression *next_;
 
     CYExpression *expression_;
     CYExpression *next_;
 

-    CYCompound(CYExpression *expression, CYExpression *next = NULL) :
+    CYCompound(CYExpression *expression, CYExpression *next) :

         expression_(expression),
         next_(next)
     {
         expression_(expression),
         next_(next)
     {

-        if (expression_ == NULL)
-            throw;

         _assert(expression_ != NULL);
         _assert(expression_ != NULL);

+        _assert(next != NULL);

     }
 
     CYPrecedence(17)
     }
 
     CYPrecedence(17)


@@ -570,8 +600,23 @@ struct CYCompound :
     virtual CYExpression *Replace(CYContext &context);
     void Output(CYOutput &out, CYFlags flags) const;
 
     virtual CYExpression *Replace(CYContext &context);
     void Output(CYOutput &out, CYFlags flags) const;
 

-    virtual CYExpression *Primitive(CYContext &context);
-    virtual CYFunctionParameter *Parameters() const;
+    virtual CYFunctionParameter *Parameter() const;
+};
+
+struct CYParenthetical :
+    CYExpression
+{
+    CYExpression *expression_;
+
+    CYParenthetical(CYExpression *expression) :
+        expression_(expression)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual CYExpression *Replace(CYContext &context);
+    void Output(CYOutput &out, CYFlags flags) const;

 };
 
 struct CYDeclaration;
 };
 
 struct CYDeclaration;


@@ -588,7 +633,7 @@ struct CYFunctionParameter :
     {
     }
 
     {
     }
 

-    void Replace(CYContext &context, CYBlock &code);
+    void Replace(CYContext &context, CYStatement *&statements);

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


@@ -1044,11 +1089,11 @@ struct CYClause :
     CYNext<CYClause>
 {
     CYExpression *case_;
     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)

     {
     }
 
     {
     }
 


@@ -1141,7 +1186,7 @@ struct CYDeclarations :
 
     void Replace(CYContext &context);
 
 
     void Replace(CYContext &context);
 

-    CYCompound *Compound(CYContext &context);
+    CYExpression *Expression(CYContext &context);

     CYProperty *Property(CYContext &context);
     CYArgument *Argument(CYContext &context);
     CYFunctionParameter *Parameter(CYContext &context);
     CYProperty *Property(CYContext &context);
     CYArgument *Argument(CYContext &context);
     CYFunctionParameter *Parameter(CYContext &context);


@@ -1160,7 +1205,7 @@ struct CYForDeclarations :
     {
     }
 
     {
     }
 

-    virtual CYCompound *Replace(CYContext &context);
+    virtual CYExpression *Replace(CYContext &context);

     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 


@@ -1174,6 +1219,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;
 };


@@ -1190,6 +1237,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;
 };


@@ -1210,6 +1259,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;
 };


@@ -1228,6 +1279,8 @@ struct CYForIn :
     {
     }
 
     {
     }
 

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


@@ -1246,6 +1299,8 @@ struct CYForOf :
     {
     }
 
     {
     }
 

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


@@ -1396,8 +1451,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 :


@@ -1412,6 +1471,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;
 };


@@ -1428,6 +1489,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;
 };


@@ -1436,16 +1499,18 @@ 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_;
 
     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)

     {
     }
 
     {
     }
 


@@ -1462,8 +1527,8 @@ 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)

     {
     }
 
     {
     }
 


@@ -1479,8 +1544,8 @@ struct CYFatArrow :
     CYFunction,
     CYExpression
 {
     CYFunction,
     CYExpression
 {

-    CYFatArrow(CYFunctionParameter *parameters, CYStatement *statements) :
-        CYFunction(NULL, parameters, statements)
+    CYFatArrow(CYFunctionParameter *parameters, CYStatement *code) :
+        CYFunction(NULL, parameters, code)

     {
     }
 
     {
     }
 


@@ -1495,8 +1560,8 @@ struct CYFatArrow :
 struct CYRubyProc :
     CYFunctionExpression
 {
 struct CYRubyProc :
     CYFunctionExpression
 {

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

     {
     }
 
     {
     }
 


@@ -1509,11 +1574,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;
 };


@@ -1530,8 +1597,12 @@ 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;

+
+    virtual CYStatement *Return();

 };
 
 struct CYContinue :
 };
 
 struct CYContinue :


@@ -1544,6 +1615,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;
 };


@@ -1558,6 +1631,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;
 };


@@ -1572,6 +1647,8 @@ 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;
 };


@@ -1579,6 +1656,8 @@ struct CYReturn :
 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;
 };


@@ -1586,10 +1665,10 @@ struct CYEmpty :
 struct CYFinally :
     CYThing
 {
 struct CYFinally :
     CYThing
 {

-    CYBlock code_;
+    CYStatement *code_;

 
 

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

     {
     }
 
     {
     }
 


@@ -1853,12 +1932,12 @@ struct CYLambda :
 {
     CYTypedIdentifier *typed_;
     CYTypedParameter *parameters_;
 {
     CYTypedIdentifier *typed_;
     CYTypedParameter *parameters_;

-    CYStatement *statements_;
+    CYStatement *code_;

 
 

-    CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *statements) :
+    CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *code) :

         typed_(typed),
         parameters_(parameters),
         typed_(typed),
         parameters_(parameters),

-        statements_(statements)
+        code_(code)

     {
     }
 
     {
     }
 


@@ -1894,6 +1973,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;
 };


@@ -1910,6 +1991,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;
 };


@@ -1924,6 +2007,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;
 };


@@ -1971,11 +2056,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)

     {
     }
 
     {
     }
 


@@ -1986,17 +2071,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;
 };


@@ -2011,6 +2098,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;
 };


@@ -2029,6 +2118,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;
 };


@@ -2045,6 +2136,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;
 };


@@ -2056,6 +2149,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;
 };