/* gramm: cmm.g -> cmm_data.hpp */

#ifndef __PROG_CMM_DATA_HPP__
#define __PROG_CMM_DATA_HPP__

#include <cassert>
#include <string>
#include "std.h"
using std::string;

OPEN_NAMESPACE

class CmmBasic;
class CmmDecl;
class CmmMemberVisibility;
class CmmBaseItem;
class CmmExpr;
class CmmName;
class CmmContName;
class CmmDeclarator;
class CmmContSpecifier;
class CmmFunctionSpecifier;
class CmmNumValue;
class CmmCharValue;
class CmmStringCont;
class CmmStringValue;
class CmmThisExpr;
class CmmSubexprExpr;
class CmmModernCastExpr;
class CmmTypeidExpr;
class CmmTypenameExpr;
class CmmTypechangeExpr;
class CmmIndexExpr;
class CmmCallExpr;
class CmmFieldExpr;
class CmmPtrFieldExpr;
class CmmPostIncExpr;
class CmmPostDecExpr;
class CmmExprList;
class CmmUnaryExpr;
class CmmSizeofExp;
class CmmNewExpr;
class CmmNewPlacement;
class CmmNewTypeId;
class CmmNewArrayLimit;
class CmmDeleteExpr;
class CmmCastFormula;
class CmmBinaryExpr;
class CmmCondExpr;
class CmmStat;
class CmmStatSect;
class CmmDeclStat;
class CmmLabeledStat;
class CmmCaseStat;
class CmmDefaultStat;
class CmmExprStat;
class CmmEmptyStat;
class CmmCompoundStat;
class CmmCondition;
class CmmIfStat;
class CmmSwitchStat;
class CmmWhileStat;
class CmmDoStat;
class CmmForStat;
class CmmBreakStat;
class CmmContinueStat;
class CmmReturnStat;
class CmmGotoStat;
class CmmDeclSect;
class CmmSimpleDecl;
class CmmComplexDecl;
class CmmCtorDecl;
class CmmCtorHead;
class CmmContSpecifierSect;
class CmmFunctionBody;
class CmmEnumDecl;
class CmmClassDecl;
class CmmNamespaceDecl;
class CmmUsingDecl;
class CmmExternDecl;
class CmmAsmDecl;
class CmmEmptyDecl;
class CmmDeclSpec;
class CmmTypenameSpec;
class CmmEnumSect;
class CmmEnumItem;
class CmmTypeId;
class CmmPtrSpecifierSect;
class CmmPtrSpecifier;
class CmmArraySpecifier;
class CmmParamSect;
class CmmParamItem;
class CmmInitializer;
class CmmInitItem;
class CmmInitEmpty;
class CmmInitSimple;
class CmmInitList;
class CmmBaseSect;
class CmmCtorInitializer;
class CmmMemberInitializer;
class CmmSpecialFuction;
class CmmTemplateDecl;
class CmmExxternTemplateDecl;
class CmmTemplateParamSect;
class CmmTemplateParam;
class CmmTemplateTypeParam;
class CmmTemplateValueParam;
class CmmTemplateArgSect;
class CmmTemplateArg;
class CmmTemplateTypeArg;
class CmmTemplateValueArg;
class CmmTryStat;
class CmmHandlerSect;
class CmmHandlerItem;
class CmmThrowExpr;
class CmmExceptionSect;
class CmmTypeDecl;
class CmmExceptionItem;

class CmmProduct;
class TInputItem;
typedef TInputItem * CmmMark;
typedef TInputItem * CmmLocation;
class CttItem;
class CttFunctionParams;
class CttTemplateParams;
class CttEval;
class CmmParser;

enum CmmAccess
{
   NoAccess,
   PrivateAccess,
   ProtectedAccess,
   PublicAccess
};

enum CmmModernCastExpr_kind
{
   DynamicCast,
   StaticCast,
   ConstCast,
   ReinterpreterCast
};

enum CmmUnaryExpr_kind
{
   IncExp,
   DecExp,
   DerexExp,
   AddrExp,
   PlusExp,
   MinusExp,
   BitNotExp,
   LogNotExp,
   ScopeExp
};

enum CmmBinaryExpr_kind
{
   DotMemberExp,
   ArrowMemverExp,
   MulExp,
   DivExp,
   ModExp,
   AddExp,
   SubExp,
   ShlExp,
   ShrExp,
   LtExp,
   GtExp,
   LeExp,
   GeExp,
   EqExp,
   NeExp,
   BitAndExp,
   BitXorExp,
   BitOrExp,
   LogAndExp,
   LogOrExp,
   AssignExp,
   AddAssignExp,
   SubAssignExp,
   MulAssignExp,
   DivAssignExp,
   ModAssignExp,
   ShlAssignExp,
   ShrAssignExp,
   AndAssignExp,
   XorAssignExp,
   OrAssignExp,
   CommaExp
};

enum CmmClassDecl_style
{
   ClassStyle,
   StructStyle,
   UnionStyle
};

class CmmBasic
{
   public:
      CmmBasic * next_usage;

   // code
   public:
      virtual bool isUnary (CmmUnaryExpr_kind p_value) { return false; }
      virtual bool isBinary (CmmBinaryExpr_kind p_value) { return false; }

   public:

   public:
      virtual ~ CmmBasic ();
      CmmBasic ();
};

class CmmDecl : public CmmBasic
{
   // list item
   public:
      CmmDecl * prev;
      CmmDecl * next;
      CmmDeclSect * up;
      CmmDecl * getPrev () { return prev; }
      CmmDecl * getNext () { return next; }
      CmmDeclSect * getUp () { return up; }
      void insertBefore (CmmDecl * item);
      void insertAfter (CmmDecl * item);
      void remove ();

   // conversion functions
   public:
      virtual CmmExternDecl * conv_CmmExternDecl () { return NULL; }
      virtual CmmExxternTemplateDecl * conv_CmmExxternTemplateDecl () { return NULL; }
      virtual CmmCtorDecl * conv_CmmCtorDecl () { return NULL; }
      virtual CmmComplexDecl * conv_CmmComplexDecl () { return NULL; }
      virtual CmmEmptyDecl * conv_CmmEmptyDecl () { return NULL; }
      virtual CmmNamespaceDecl * conv_CmmNamespaceDecl () { return NULL; }
      virtual CmmUsingDecl * conv_CmmUsingDecl () { return NULL; }
      virtual CmmAsmDecl * conv_CmmAsmDecl () { return NULL; }
      virtual CmmTemplateDecl * conv_CmmTemplateDecl () { return NULL; }
      virtual CmmMemberVisibility * conv_CmmMemberVisibility () { return NULL; }
      virtual CmmClassDecl * conv_CmmClassDecl () { return NULL; }
      virtual CmmEnumDecl * conv_CmmEnumDecl () { return NULL; }
      virtual CmmSimpleDecl * conv_CmmSimpleDecl () { return NULL; }

   public:
      virtual ~ CmmDecl ();
      CmmDecl ();

   public:
      friend class CmmDeclSect;
};

class CmmMemberVisibility : public CmmDecl
{
   public:
      CmmAccess access;

   // location and notes
   public:
      CmmLocation location [4];

   // conversion functions
   public:
      virtual CmmMemberVisibility * conv_CmmMemberVisibility () { return this; }

   public:
      CmmMemberVisibility ();
};

class CmmBaseItem : public CmmBasic
{
   public:
      CmmAccess access;
      bool a_virtual;
      CmmName * from;

   // list item
   public:
      CmmBaseItem * prev;
      CmmBaseItem * next;
      CmmBaseSect * up;
      CmmBaseItem * getPrev () { return prev; }
      CmmBaseItem * getNext () { return next; }
      CmmBaseSect * getUp () { return up; }
      void insertBefore (CmmBaseItem * item);
      void insertAfter (CmmBaseItem * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [10];

   public:
      CmmBaseItem ();
      virtual ~ CmmBaseItem ();

   public:
      friend class CmmBaseSect;
};

class CmmExpr : public CmmBasic
{
   // list item
   public:
      CmmExpr * prev;
      CmmExpr * next;
      CmmExprList * up;
      CmmExpr * getPrev () { return prev; }
      CmmExpr * getNext () { return next; }
      CmmExprList * getUp () { return up; }
      void insertBefore (CmmExpr * item);
      void insertAfter (CmmExpr * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmNumValue * conv_CmmNumValue () { return NULL; }
      virtual CmmCharValue * conv_CmmCharValue () { return NULL; }
      virtual CmmStringValue * conv_CmmStringValue () { return NULL; }
      virtual CmmThisExpr * conv_CmmThisExpr () { return NULL; }
      virtual CmmSubexprExpr * conv_CmmSubexprExpr () { return NULL; }
      virtual CmmName * conv_CmmName () { return NULL; }
      virtual CmmModernCastExpr * conv_CmmModernCastExpr () { return NULL; }
      virtual CmmTypeidExpr * conv_CmmTypeidExpr () { return NULL; }
      virtual CmmTypenameExpr * conv_CmmTypenameExpr () { return NULL; }
      virtual CmmTypechangeExpr * conv_CmmTypechangeExpr () { return NULL; }
      virtual CmmIndexExpr * conv_CmmIndexExpr () { return NULL; }
      virtual CmmCallExpr * conv_CmmCallExpr () { return NULL; }
      virtual CmmFieldExpr * conv_CmmFieldExpr () { return NULL; }
      virtual CmmPtrFieldExpr * conv_CmmPtrFieldExpr () { return NULL; }
      virtual CmmPostIncExpr * conv_CmmPostIncExpr () { return NULL; }
      virtual CmmPostDecExpr * conv_CmmPostDecExpr () { return NULL; }
      virtual CmmUnaryExpr * conv_CmmUnaryExpr () { return NULL; }
      virtual CmmSizeofExp * conv_CmmSizeofExp () { return NULL; }
      virtual CmmNewExpr * conv_CmmNewExpr () { return NULL; }
      virtual CmmDeleteExpr * conv_CmmDeleteExpr () { return NULL; }
      virtual CmmCastFormula * conv_CmmCastFormula () { return NULL; }
      virtual CmmBinaryExpr * conv_CmmBinaryExpr () { return NULL; }
      virtual CmmCondExpr * conv_CmmCondExpr () { return NULL; }
      virtual CmmThrowExpr * conv_CmmThrowExpr () { return NULL; }

   public:
      CmmExpr ();
      virtual ~ CmmExpr ();

   public:
      friend class CmmExprList;
};

class CmmName : public CmmExpr
{
   public:
      CttItem * name_ref;
      CttItem * base_ref;
      string replace;
      string id;
      CmmSpecialFuction * spec;
      CmmTemplateArgSect * template_args;
      bool a_global;

   // list item
   public:
      CmmContName * first;
      CmmContName * last;
   protected:
      void link_item (CmmContName * item, CmmContName * bef, CmmContName * aft);
   public:
      CmmContName * getFirst () { return first; }
      CmmContName * getLast () { return last; }
      void insertFirst (CmmContName * item);
      void add (CmmContName * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmName * conv_CmmName () { return this; }

   public:
      CmmName ();
      virtual ~ CmmName ();

   public:
      friend class CmmContName;
};

class CmmContName : public CmmBasic
{
   public:
      CttItem * cont_ref;
      string id;
      bool a_destructor;
      bool a_template;
      CmmSpecialFuction * spec;
      CmmTemplateArgSect * template_args;

   // list item
   public:
      CmmContName * prev;
      CmmContName * next;
      CmmName * up;
      CmmContName * getPrev () { return prev; }
      CmmContName * getNext () { return next; }
      CmmName * getUp () { return up; }
      void insertBefore (CmmContName * item);
      void insertAfter (CmmContName * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [4];

   public:
      CmmContName ();
      virtual ~ CmmContName ();

   public:
      friend class CmmName;
};

class CmmDeclarator : public CmmBasic
{
   public:
      CmmDeclarator * save;
      CmmAccess access_val;
      bool separate_decl;
      CmmSimpleDecl * actual_decl;
      string short_name;
      CmmName * long_name;
      CttFunctionParams * function_param_ref;
      CmmName * name;
      CmmContSpecifierSect * cont;
      CmmPtrSpecifierSect * ptr;
      CmmDeclarator * inner;
      bool empty_branch;
      CmmExpr * width;
      CmmInitializer * init;

   // list item
   public:
      CmmDeclarator * prev;
      CmmDeclarator * next;
      CmmSimpleDecl * up;
      CmmDeclarator * getPrev () { return prev; }
      CmmDeclarator * getNext () { return next; }
      CmmSimpleDecl * getUp () { return up; }
      void insertBefore (CmmDeclarator * item);
      void insertAfter (CmmDeclarator * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [7];

   public:
      CmmDeclarator ();
      virtual ~ CmmDeclarator ();

   public:
      friend class CmmSimpleDecl;
};

class CmmContSpecifier : public CmmBasic
{
   // list item
   public:
      CmmContSpecifier * prev;
      CmmContSpecifier * next;
      CmmContSpecifierSect * up;
      CmmContSpecifier * getPrev () { return prev; }
      CmmContSpecifier * getNext () { return next; }
      CmmContSpecifierSect * getUp () { return up; }
      void insertBefore (CmmContSpecifier * item);
      void insertAfter (CmmContSpecifier * item);
      void remove ();

   // conversion functions
   public:
      virtual CmmFunctionSpecifier * conv_CmmFunctionSpecifier () { return NULL; }
      virtual CmmArraySpecifier * conv_CmmArraySpecifier () { return NULL; }

   public:
      virtual ~ CmmContSpecifier ();
      CmmContSpecifier ();

   public:
      friend class CmmContSpecifierSect;
};

class CmmFunctionSpecifier : public CmmContSpecifier
{
   public:
      CttFunctionParams * param_ref;
      CmmParamSect * parameters;
      bool cv_const;
      bool cv_volatile;
      CmmExceptionSect * exception_spec;

   // location and notes
   public:
      CmmLocation location [4];

   // conversion functions
   public:
      virtual CmmFunctionSpecifier * conv_CmmFunctionSpecifier () { return this; }

   public:
      CmmFunctionSpecifier ();
};

class CmmNumValue : public CmmExpr
{
   public:
      string value;

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmNumValue * conv_CmmNumValue () { return this; }

   public:
      CmmNumValue ();
};

class CmmCharValue : public CmmExpr
{
   public:
      string value;

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmCharValue * conv_CmmCharValue () { return this; }

   public:
      CmmCharValue ();
};

class CmmStringCont : public CmmBasic
{
   public:
      string value;

   // list item
   public:
      CmmStringCont * prev;
      CmmStringCont * next;
      CmmStringValue * up;
      CmmStringCont * getPrev () { return prev; }
      CmmStringCont * getNext () { return next; }
      CmmStringValue * getUp () { return up; }
      void insertBefore (CmmStringCont * item);
      void insertAfter (CmmStringCont * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [1];

   public:
      CmmStringCont ();
      virtual ~ CmmStringCont ();

   public:
      friend class CmmStringValue;
};

class CmmStringValue : public CmmExpr
{
   public:
      string value;

   // list item
   public:
      CmmStringCont * first;
      CmmStringCont * last;
   protected:
      void link_item (CmmStringCont * item, CmmStringCont * bef, CmmStringCont * aft);
   public:
      CmmStringCont * getFirst () { return first; }
      CmmStringCont * getLast () { return last; }
      void insertFirst (CmmStringCont * item);
      void add (CmmStringCont * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmStringValue * conv_CmmStringValue () { return this; }

   public:
      CmmStringValue ();
      virtual ~ CmmStringValue ();

   public:
      friend class CmmStringCont;
};

class CmmThisExpr : public CmmExpr
{
   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmThisExpr * conv_CmmThisExpr () { return this; }

   public:
      CmmThisExpr ();
};

class CmmSubexprExpr : public CmmExpr
{
   public:
      CmmExpr * param;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmSubexprExpr * conv_CmmSubexprExpr () { return this; }

   public:
      CmmSubexprExpr ();
};

class CmmModernCastExpr : public CmmExpr
{
   public:
      CmmModernCastExpr_kind kind;
      CmmTypeId * type;
      CmmExpr * param;

   // location and notes
   public:
      CmmLocation location [8];

   // conversion functions
   public:
      virtual CmmModernCastExpr * conv_CmmModernCastExpr () { return this; }

   public:
      CmmModernCastExpr ();
};

class CmmTypeidExpr : public CmmExpr
{
   public:
      CmmTypeId * param1;
      CmmExpr * param2;

   // location and notes
   public:
      CmmLocation location [3];

   // conversion functions
   public:
      virtual CmmTypeidExpr * conv_CmmTypeidExpr () { return this; }

   public:
      CmmTypeidExpr ();
};

class CmmTypenameExpr : public CmmExpr
{
   public:
      CmmName * name;
      CmmExprList * list;

   // location and notes
   public:
      CmmLocation location [3];

   // conversion functions
   public:
      virtual CmmTypenameExpr * conv_CmmTypenameExpr () { return this; }

   public:
      CmmTypenameExpr ();
};

class CmmTypechangeExpr : public CmmExpr
{
   public:
      bool a_signed;
      bool a_unsigned;
      bool a_short;
      bool a_long;
      bool a_long_long;
      bool a_bool;
      bool a_char;
      bool a_wchar;
      bool a_int;
      bool a_float;
      bool a_double;
      bool a_void;
      CmmExprList * list;

   // location and notes
   public:
      CmmLocation location [14];

   // conversion functions
   public:
      virtual CmmTypechangeExpr * conv_CmmTypechangeExpr () { return this; }

   public:
      CmmTypechangeExpr ();
};

class CmmIndexExpr : public CmmExpr
{
   public:
      CmmExpr * left;
      CmmExpr * right;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmIndexExpr * conv_CmmIndexExpr () { return this; }

   public:
      CmmIndexExpr ();
};

class CmmCallExpr : public CmmExpr
{
   public:
      CmmExpr * param;
      CmmExprList * list;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmCallExpr * conv_CmmCallExpr () { return this; }

   public:
      CmmCallExpr ();
};

class CmmFieldExpr : public CmmExpr
{
   public:
      CmmExpr * param;
      bool destructor_name;
      bool template_name;
      CmmName * name;

   // location and notes
   public:
      CmmLocation location [3];

   // conversion functions
   public:
      virtual CmmFieldExpr * conv_CmmFieldExpr () { return this; }

   public:
      CmmFieldExpr ();
};

class CmmPtrFieldExpr : public CmmExpr
{
   public:
      CmmExpr * param;
      bool destructor_name;
      bool template_name;
      CmmName * name;

   // location and notes
   public:
      CmmLocation location [3];

   // conversion functions
   public:
      virtual CmmPtrFieldExpr * conv_CmmPtrFieldExpr () { return this; }

   public:
      CmmPtrFieldExpr ();
};

class CmmPostIncExpr : public CmmExpr
{
   public:
      CmmExpr * param;

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmPostIncExpr * conv_CmmPostIncExpr () { return this; }

   public:
      CmmPostIncExpr ();
};

class CmmPostDecExpr : public CmmExpr
{
   public:
      CmmExpr * param;

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmPostDecExpr * conv_CmmPostDecExpr () { return this; }

   public:
      CmmPostDecExpr ();
};

class CmmExprList : public CmmBasic
{
   // list item
   public:
      CmmExpr * first;
      CmmExpr * last;
   protected:
      void link_item (CmmExpr * item, CmmExpr * bef, CmmExpr * aft);
   public:
      CmmExpr * getFirst () { return first; }
      CmmExpr * getLast () { return last; }
      void insertFirst (CmmExpr * item);
      void add (CmmExpr * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [1];

   public:
      CmmExprList ();
      virtual ~ CmmExprList ();

   public:
      friend class CmmExpr;
};

class CmmUnaryExpr : public CmmExpr
{
   public:
      CmmUnaryExpr_kind kind;
      CmmExpr * param;

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmUnaryExpr * conv_CmmUnaryExpr () { return this; }

   // code
   public:
      virtual bool isUnary (CmmUnaryExpr_kind p_value) { return p_value == kind; }

   public:
      CmmUnaryExpr ();
};

class CmmSizeofExp : public CmmExpr
{
   public:
      CmmTypeId * param1;
      CmmExpr * param2;

   // location and notes
   public:
      CmmLocation location [3];

   // conversion functions
   public:
      virtual CmmSizeofExp * conv_CmmSizeofExp () { return this; }

   public:
      CmmSizeofExp ();
};

class CmmNewExpr : public CmmExpr
{
   public:
      CmmNewPlacement * placement;
      CmmNewTypeId * type1;
      CmmTypeId * type2;
      CmmExprList * init;

   // location and notes
   public:
      CmmLocation location [5];

   // conversion functions
   public:
      virtual CmmNewExpr * conv_CmmNewExpr () { return this; }

   public:
      CmmNewExpr ();
};

class CmmNewPlacement : public CmmBasic
{
   public:
      CmmExprList * list;

   // location and notes
   public:
      CmmLocation location [2];

   public:
      CmmNewPlacement ();
};

class CmmNewTypeId : public CmmBasic
{
   public:
      CmmDeclSpec * spec;
      CmmPtrSpecifierSect * ptr;

   // list item
   public:
      CmmNewArrayLimit * first;
      CmmNewArrayLimit * last;
   protected:
      void link_item (CmmNewArrayLimit * item, CmmNewArrayLimit * bef, CmmNewArrayLimit * aft);
   public:
      CmmNewArrayLimit * getFirst () { return first; }
      CmmNewArrayLimit * getLast () { return last; }
      void insertFirst (CmmNewArrayLimit * item);
      void add (CmmNewArrayLimit * item);
      void removeAll ();

   public:
      virtual ~ CmmNewTypeId ();
      CmmNewTypeId ();

   public:
      friend class CmmNewArrayLimit;
};

class CmmNewArrayLimit : public CmmBasic
{
   public:
      CmmExpr * value;

   // list item
   public:
      CmmNewArrayLimit * prev;
      CmmNewArrayLimit * next;
      CmmNewTypeId * up;
      CmmNewArrayLimit * getPrev () { return prev; }
      CmmNewArrayLimit * getNext () { return next; }
      CmmNewTypeId * getUp () { return up; }
      void insertBefore (CmmNewArrayLimit * item);
      void insertAfter (CmmNewArrayLimit * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [2];

   public:
      CmmNewArrayLimit ();
      virtual ~ CmmNewArrayLimit ();

   public:
      friend class CmmNewTypeId;
};

class CmmDeleteExpr : public CmmExpr
{
   public:
      bool a_array;
      CmmExpr * param;

   // location and notes
   public:
      CmmLocation location [3];

   // conversion functions
   public:
      virtual CmmDeleteExpr * conv_CmmDeleteExpr () { return this; }

   public:
      CmmDeleteExpr ();
};

class CmmCastFormula : public CmmExpr
{
   public:
      CmmTypeId * type;
      CmmExpr * param;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmCastFormula * conv_CmmCastFormula () { return this; }

   public:
      CmmCastFormula ();
};

class CmmBinaryExpr : public CmmExpr
{
   public:
      CmmBinaryExpr_kind kind;
      CmmExpr * left;
      CmmExpr * right;

   // conversion functions
   public:
      virtual CmmBinaryExpr * conv_CmmBinaryExpr () { return this; }

   // code
   public:
      virtual bool isBinary (CmmBinaryExpr_kind p_value) { return p_value == kind; }

   public:
      CmmBinaryExpr ();
};

class CmmCondExpr : public CmmExpr
{
   public:
      CmmExpr * cond_expr;
      CmmExpr * then_expr;
      CmmExpr * else_expr;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmCondExpr * conv_CmmCondExpr () { return this; }

   public:
      CmmCondExpr ();
};

class CmmStat : public CmmBasic
{
   // list item
   public:
      CmmStat * prev;
      CmmStat * next;
      CmmStatSect * up;
      CmmStat * getPrev () { return prev; }
      CmmStat * getNext () { return next; }
      CmmStatSect * getUp () { return up; }
      void insertBefore (CmmStat * item);
      void insertAfter (CmmStat * item);
      void remove ();

   // conversion functions
   public:
      virtual CmmLabeledStat * conv_CmmLabeledStat () { return NULL; }
      virtual CmmDeclStat * conv_CmmDeclStat () { return NULL; }
      virtual CmmExprStat * conv_CmmExprStat () { return NULL; }
      virtual CmmCompoundStat * conv_CmmCompoundStat () { return NULL; }
      virtual CmmCaseStat * conv_CmmCaseStat () { return NULL; }
      virtual CmmDefaultStat * conv_CmmDefaultStat () { return NULL; }
      virtual CmmIfStat * conv_CmmIfStat () { return NULL; }
      virtual CmmSwitchStat * conv_CmmSwitchStat () { return NULL; }
      virtual CmmWhileStat * conv_CmmWhileStat () { return NULL; }
      virtual CmmDoStat * conv_CmmDoStat () { return NULL; }
      virtual CmmForStat * conv_CmmForStat () { return NULL; }
      virtual CmmBreakStat * conv_CmmBreakStat () { return NULL; }
      virtual CmmContinueStat * conv_CmmContinueStat () { return NULL; }
      virtual CmmReturnStat * conv_CmmReturnStat () { return NULL; }
      virtual CmmGotoStat * conv_CmmGotoStat () { return NULL; }
      virtual CmmTryStat * conv_CmmTryStat () { return NULL; }
      virtual CmmEmptyStat * conv_CmmEmptyStat () { return NULL; }

   public:
      virtual ~ CmmStat ();
      CmmStat ();

   public:
      friend class CmmStatSect;
};

class CmmStatSect : public CmmBasic
{
   // list item
   public:
      CmmStat * first;
      CmmStat * last;
   protected:
      void link_item (CmmStat * item, CmmStat * bef, CmmStat * aft);
   public:
      CmmStat * getFirst () { return first; }
      CmmStat * getLast () { return last; }
      void insertFirst (CmmStat * item);
      void add (CmmStat * item);
      void removeAll ();

   public:
      virtual ~ CmmStatSect ();
      CmmStatSect ();

   public:
      friend class CmmStat;
};

class CmmDeclStat : public CmmStat
{
   public:
      CmmDecl * decl;

   // conversion functions
   public:
      virtual CmmDeclStat * conv_CmmDeclStat () { return this; }

   public:
      CmmDeclStat ();
};

class CmmLabeledStat : public CmmStat
{
   public:
      string lab;
      CmmStat * body;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmLabeledStat * conv_CmmLabeledStat () { return this; }

   public:
      CmmLabeledStat ();
};

class CmmCaseStat : public CmmStat
{
   public:
      CmmExpr * case_expr;
      CmmStat * body;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmCaseStat * conv_CmmCaseStat () { return this; }

   public:
      CmmCaseStat ();
};

class CmmDefaultStat : public CmmStat
{
   public:
      CmmStat * body;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmDefaultStat * conv_CmmDefaultStat () { return this; }

   public:
      CmmDefaultStat ();
};

class CmmExprStat : public CmmStat
{
   public:
      CmmExpr * inner_expr;

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmExprStat * conv_CmmExprStat () { return this; }

   public:
      CmmExprStat ();
};

class CmmEmptyStat : public CmmStat
{
   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmEmptyStat * conv_CmmEmptyStat () { return this; }

   public:
      CmmEmptyStat ();
};

class CmmCompoundStat : public CmmStat
{
   public:
      CmmStatSect * body;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmCompoundStat * conv_CmmCompoundStat () { return this; }

   public:
      CmmCompoundStat ();
};

class CmmCondition : public CmmBasic
{
   public:
      CmmSimpleDecl * cond_decl;
      CmmExpr * cond_expr;

   public:
      CmmCondition ();
};

class CmmIfStat : public CmmStat
{
   public:
      CmmCondition * cond;
      CmmStat * then_stat;
      CmmStat * else_stat;

   // location and notes
   public:
      CmmLocation location [4];

   // conversion functions
   public:
      virtual CmmIfStat * conv_CmmIfStat () { return this; }

   public:
      CmmIfStat ();
};

class CmmSwitchStat : public CmmStat
{
   public:
      CmmCondition * cond;
      CmmStat * body;

   // location and notes
   public:
      CmmLocation location [3];

   // conversion functions
   public:
      virtual CmmSwitchStat * conv_CmmSwitchStat () { return this; }

   public:
      CmmSwitchStat ();
};

class CmmWhileStat : public CmmStat
{
   public:
      CmmCondition * cond;
      CmmStat * body;

   // location and notes
   public:
      CmmLocation location [3];

   // conversion functions
   public:
      virtual CmmWhileStat * conv_CmmWhileStat () { return this; }

   public:
      CmmWhileStat ();
};

class CmmDoStat : public CmmStat
{
   public:
      CmmStat * body;
      CmmExpr * cond_expr;

   // location and notes
   public:
      CmmLocation location [5];

   // conversion functions
   public:
      virtual CmmDoStat * conv_CmmDoStat () { return this; }

   public:
      CmmDoStat ();
};

class CmmForStat : public CmmStat
{
   public:
      CmmCondition * from_expr;
      CmmExpr * to_expr;
      CmmExpr * cond_expr;
      CmmStat * body;

   // location and notes
   public:
      CmmLocation location [5];

   // conversion functions
   public:
      virtual CmmForStat * conv_CmmForStat () { return this; }

   public:
      CmmForStat ();
};

class CmmBreakStat : public CmmStat
{
   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmBreakStat * conv_CmmBreakStat () { return this; }

   public:
      CmmBreakStat ();
};

class CmmContinueStat : public CmmStat
{
   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmContinueStat * conv_CmmContinueStat () { return this; }

   public:
      CmmContinueStat ();
};

class CmmReturnStat : public CmmStat
{
   public:
      CmmExpr * return_expr;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmReturnStat * conv_CmmReturnStat () { return this; }

   public:
      CmmReturnStat ();
};

class CmmGotoStat : public CmmStat
{
   public:
      string goto_lab;

   // location and notes
   public:
      CmmLocation location [3];

   // conversion functions
   public:
      virtual CmmGotoStat * conv_CmmGotoStat () { return this; }

   public:
      CmmGotoStat ();
};

class CmmDeclSect : public CmmBasic
{
   // list item
   public:
      CmmDecl * first;
      CmmDecl * last;
   protected:
      void link_item (CmmDecl * item, CmmDecl * bef, CmmDecl * aft);
   public:
      CmmDecl * getFirst () { return first; }
      CmmDecl * getLast () { return last; }
      void insertFirst (CmmDecl * item);
      void add (CmmDecl * item);
      void removeAll ();

   public:
      virtual ~ CmmDeclSect ();
      CmmDeclSect ();

   public:
      friend class CmmDecl;
};

class CmmSimpleDecl : public CmmDecl
{
   public:
      CmmDeclSpec * spec;

   // list item
   public:
      CmmDeclarator * first;
      CmmDeclarator * last;
   protected:
      void link_item (CmmDeclarator * item, CmmDeclarator * bef, CmmDeclarator * aft);
   public:
      CmmDeclarator * getFirst () { return first; }
      CmmDeclarator * getLast () { return last; }
      void insertFirst (CmmDeclarator * item);
      void add (CmmDeclarator * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmSimpleDecl * conv_CmmSimpleDecl () { return this; }

   public:
      CmmSimpleDecl ();
      virtual ~ CmmSimpleDecl ();

   public:
      friend class CmmDeclarator;
};

class CmmComplexDecl : public CmmSimpleDecl
{
   public:
      CmmExpr * empty_width;
      bool empty;
      CmmFunctionBody * func_body;

   // location and notes
   public:
      CmmLocation location [5];

   // conversion functions
   public:
      virtual CmmComplexDecl * conv_CmmComplexDecl () { return this; }

   public:
      CmmComplexDecl ();
};

class CmmCtorDecl : public CmmComplexDecl
{
   public:
      bool destructor;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmCtorDecl * conv_CmmCtorDecl () { return this; }

   public:
      CmmCtorDecl ();
};

class CmmCtorHead : public CmmCtorDecl
{
   public:
      bool destructor;
      bool init_values;
      bool body;
      bool try_block;

   // location and notes
   public:
      CmmLocation location [5];

   public:
      CmmCtorHead ();
};

class CmmContSpecifierSect : public CmmBasic
{
   // list item
   public:
      CmmContSpecifier * first;
      CmmContSpecifier * last;
   protected:
      void link_item (CmmContSpecifier * item, CmmContSpecifier * bef, CmmContSpecifier * aft);
   public:
      CmmContSpecifier * getFirst () { return first; }
      CmmContSpecifier * getLast () { return last; }
      void insertFirst (CmmContSpecifier * item);
      void add (CmmContSpecifier * item);
      void removeAll ();

   public:
      virtual ~ CmmContSpecifierSect ();
      CmmContSpecifierSect ();

   public:
      friend class CmmContSpecifier;
};

class CmmFunctionBody : public CmmBasic
{
   public:
      CmmCtorInitializer * ctor_init;
      CmmCompoundStat * statements;
      CmmHandlerSect * handlers;

   // location and notes
   public:
      CmmLocation location [3];

   public:
      CmmFunctionBody ();
};

class CmmEnumDecl : public CmmDecl
{
   public:
      CmmName * name;
      bool with_body;
      CmmEnumSect * items;

   // location and notes
   public:
      CmmLocation location [5];

   // conversion functions
   public:
      virtual CmmEnumDecl * conv_CmmEnumDecl () { return this; }

   public:
      CmmEnumDecl ();
};

class CmmClassDecl : public CmmDecl
{
   public:
      CmmClassDecl_style style;
      CmmName * name;
      bool with_body;
      CmmBaseSect * base_list;
      CmmDeclSect * members;

   // location and notes
   public:
      CmmLocation location [10];

   // conversion functions
   public:
      virtual CmmClassDecl * conv_CmmClassDecl () { return this; }

   public:
      CmmClassDecl ();
};

class CmmNamespaceDecl : public CmmDecl
{
   public:
      CmmName * name;
      CmmName * value;
      CmmDeclSect * body;

   // location and notes
   public:
      CmmLocation location [5];

   // conversion functions
   public:
      virtual CmmNamespaceDecl * conv_CmmNamespaceDecl () { return this; }

   public:
      CmmNamespaceDecl ();
};

class CmmUsingDecl : public CmmDecl
{
   public:
      bool a_namespace;
      bool a_typename;
      CmmName * name;

   // location and notes
   public:
      CmmLocation location [4];

   // conversion functions
   public:
      virtual CmmUsingDecl * conv_CmmUsingDecl () { return this; }

   public:
      CmmUsingDecl ();
};

class CmmExternDecl : public CmmDecl
{
   public:
      string language;
      CmmDeclSect * decl_list;
      CmmDecl * inner_decl;

   // location and notes
   public:
      CmmLocation location [4];

   // conversion functions
   public:
      virtual CmmExternDecl * conv_CmmExternDecl () { return this; }

   public:
      CmmExternDecl ();
};

class CmmAsmDecl : public CmmDecl
{
   public:
      string instruction;

   // location and notes
   public:
      CmmLocation location [5];

   // conversion functions
   public:
      virtual CmmAsmDecl * conv_CmmAsmDecl () { return this; }

   public:
      CmmAsmDecl ();
};

class CmmEmptyDecl : public CmmDecl
{
   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmEmptyDecl * conv_CmmEmptyDecl () { return this; }

   public:
      CmmEmptyDecl ();
};

class CmmDeclSpec : public CmmBasic
{
   public:
      CmmName * basic_name;
      CmmClassDecl * class_spec;
      CmmEnumDecl * enum_spec;
      CmmTypenameSpec * typename_spec;
      bool a_register;
      bool a_typedef;
      bool a_friend;
      bool a_inline;
      bool a_virtual;
      bool a_explicit;
      bool a_mutable;
      bool a_extern;
      bool a_static;
      bool a_auto;
      bool a_const;
      bool a_volatile;
      bool a_signed;
      bool a_unsigned;
      bool a_short;
      bool a_long;
      bool a_long_long;
      bool a_bool;
      bool a_char;
      bool a_wchar;
      bool a_int;
      bool a_float;
      bool a_double;
      bool a_void;
      CmmPtrSpecifierSect * ptr;

   // location and notes
   public:
      CmmLocation location [30];

   public:
      CmmDeclSpec ();
};

class CmmTypenameSpec : public CmmBasic
{
   public:
      CmmName * name;

   // location and notes
   public:
      CmmLocation location [1];

   public:
      CmmTypenameSpec ();
};

class CmmEnumSect : public CmmBasic
{
   // list item
   public:
      CmmEnumItem * first;
      CmmEnumItem * last;
   protected:
      void link_item (CmmEnumItem * item, CmmEnumItem * bef, CmmEnumItem * aft);
   public:
      CmmEnumItem * getFirst () { return first; }
      CmmEnumItem * getLast () { return last; }
      void insertFirst (CmmEnumItem * item);
      void add (CmmEnumItem * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [1];

   public:
      CmmEnumSect ();
      virtual ~ CmmEnumSect ();

   public:
      friend class CmmEnumItem;
};

class CmmEnumItem : public CmmBasic
{
   public:
      CmmName * name;
      CmmExpr * init;

   // list item
   public:
      CmmEnumItem * prev;
      CmmEnumItem * next;
      CmmEnumSect * up;
      CmmEnumItem * getPrev () { return prev; }
      CmmEnumItem * getNext () { return next; }
      CmmEnumSect * getUp () { return up; }
      void insertBefore (CmmEnumItem * item);
      void insertAfter (CmmEnumItem * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [2];

   public:
      CmmEnumItem ();
      virtual ~ CmmEnumItem ();

   public:
      friend class CmmEnumSect;
};

class CmmTypeId : public CmmBasic
{
   public:
      CmmDeclSpec * spec;
      CmmDeclarator * decl;

   public:
      CmmTypeId ();
};

class CmmPtrSpecifierSect : public CmmBasic
{
   // list item
   public:
      CmmPtrSpecifier * first;
      CmmPtrSpecifier * last;
   protected:
      void link_item (CmmPtrSpecifier * item, CmmPtrSpecifier * bef, CmmPtrSpecifier * aft);
   public:
      CmmPtrSpecifier * getFirst () { return first; }
      CmmPtrSpecifier * getLast () { return last; }
      void insertFirst (CmmPtrSpecifier * item);
      void add (CmmPtrSpecifier * item);
      void removeAll ();

   public:
      virtual ~ CmmPtrSpecifierSect ();
      CmmPtrSpecifierSect ();

   public:
      friend class CmmPtrSpecifier;
};

class CmmPtrSpecifier : public CmmBasic
{
   public:
      bool pointer;
      bool reference;
      CmmName * area;
      bool member_pointer;
      bool cv_const;
      bool cv_volatile;

   // list item
   public:
      CmmPtrSpecifier * prev;
      CmmPtrSpecifier * next;
      CmmPtrSpecifierSect * up;
      CmmPtrSpecifier * getPrev () { return prev; }
      CmmPtrSpecifier * getNext () { return next; }
      CmmPtrSpecifierSect * getUp () { return up; }
      void insertBefore (CmmPtrSpecifier * item);
      void insertAfter (CmmPtrSpecifier * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [6];

   public:
      CmmPtrSpecifier ();
      virtual ~ CmmPtrSpecifier ();

   public:
      friend class CmmPtrSpecifierSect;
};

class CmmArraySpecifier : public CmmContSpecifier
{
   public:
      CmmExpr * lim;

   // location and notes
   public:
      CmmLocation location [2];

   // conversion functions
   public:
      virtual CmmArraySpecifier * conv_CmmArraySpecifier () { return this; }

   public:
      CmmArraySpecifier ();
};

class CmmParamSect : public CmmBasic
{
   // list item
   public:
      CmmParamItem * first;
      CmmParamItem * last;
   protected:
      void link_item (CmmParamItem * item, CmmParamItem * bef, CmmParamItem * aft);
   public:
      CmmParamItem * getFirst () { return first; }
      CmmParamItem * getLast () { return last; }
      void insertFirst (CmmParamItem * item);
      void add (CmmParamItem * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [1];

   public:
      CmmParamSect ();
      virtual ~ CmmParamSect ();

   public:
      friend class CmmParamItem;
};

class CmmParamItem : public CmmBasic
{
   public:
      CmmTypeId * type;
      bool following_dots;
      CmmExpr * value;
      bool dots;
      CmmExpr * init;

   // list item
   public:
      CmmParamItem * prev;
      CmmParamItem * next;
      CmmParamSect * up;
      CmmParamItem * getPrev () { return prev; }
      CmmParamItem * getNext () { return next; }
      CmmParamSect * getUp () { return up; }
      void insertBefore (CmmParamItem * item);
      void insertAfter (CmmParamItem * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [3];

   public:
      CmmParamItem ();
      virtual ~ CmmParamItem ();

   public:
      friend class CmmParamSect;
};

class CmmInitializer : public CmmBasic
{
   public:
      CmmInitItem * value;

   // location and notes
   public:
      CmmLocation location [1];

   public:
      CmmInitializer ();
};

class CmmInitItem : public CmmBasic
{
   // list item
   public:
      CmmInitItem * prev;
      CmmInitItem * next;
      CmmInitList * up;
      CmmInitItem * getPrev () { return prev; }
      CmmInitItem * getNext () { return next; }
      CmmInitList * getUp () { return up; }
      void insertBefore (CmmInitItem * item);
      void insertAfter (CmmInitItem * item);
      void remove ();

   // conversion functions
   public:
      virtual CmmInitSimple * conv_CmmInitSimple () { return NULL; }
      virtual CmmInitList * conv_CmmInitList () { return NULL; }
      virtual CmmInitEmpty * conv_CmmInitEmpty () { return NULL; }

   public:
      virtual ~ CmmInitItem ();
      CmmInitItem ();

   public:
      friend class CmmInitList;
};

class CmmInitEmpty : public CmmInitItem
{
   // conversion functions
   public:
      virtual CmmInitEmpty * conv_CmmInitEmpty () { return this; }

   public:
      CmmInitEmpty ();
};

class CmmInitSimple : public CmmInitItem
{
   public:
      CmmExpr * expr;

   // conversion functions
   public:
      virtual CmmInitSimple * conv_CmmInitSimple () { return this; }

   public:
      CmmInitSimple ();
};

class CmmInitList : public CmmInitItem
{
   // list item
   public:
      CmmInitItem * first;
      CmmInitItem * last;
   protected:
      void link_item (CmmInitItem * item, CmmInitItem * bef, CmmInitItem * aft);
   public:
      CmmInitItem * getFirst () { return first; }
      CmmInitItem * getLast () { return last; }
      void insertFirst (CmmInitItem * item);
      void add (CmmInitItem * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [3];

   // conversion functions
   public:
      virtual CmmInitList * conv_CmmInitList () { return this; }

   public:
      CmmInitList ();
      virtual ~ CmmInitList ();

   public:
      friend class CmmInitItem;
};

class CmmBaseSect : public CmmBasic
{
   // list item
   public:
      CmmBaseItem * first;
      CmmBaseItem * last;
   protected:
      void link_item (CmmBaseItem * item, CmmBaseItem * bef, CmmBaseItem * aft);
   public:
      CmmBaseItem * getFirst () { return first; }
      CmmBaseItem * getLast () { return last; }
      void insertFirst (CmmBaseItem * item);
      void add (CmmBaseItem * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [1];

   public:
      CmmBaseSect ();
      virtual ~ CmmBaseSect ();

   public:
      friend class CmmBaseItem;
};

class CmmCtorInitializer : public CmmBasic
{
   // list item
   public:
      CmmMemberInitializer * first;
      CmmMemberInitializer * last;
   protected:
      void link_item (CmmMemberInitializer * item, CmmMemberInitializer * bef, CmmMemberInitializer * aft);
   public:
      CmmMemberInitializer * getFirst () { return first; }
      CmmMemberInitializer * getLast () { return last; }
      void insertFirst (CmmMemberInitializer * item);
      void add (CmmMemberInitializer * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [1];

   public:
      CmmCtorInitializer ();
      virtual ~ CmmCtorInitializer ();

   public:
      friend class CmmMemberInitializer;
};

class CmmMemberInitializer : public CmmBasic
{
   public:
      CmmName * name;
      CmmExprList * params;

   // list item
   public:
      CmmMemberInitializer * prev;
      CmmMemberInitializer * next;
      CmmCtorInitializer * up;
      CmmMemberInitializer * getPrev () { return prev; }
      CmmMemberInitializer * getNext () { return next; }
      CmmCtorInitializer * getUp () { return up; }
      void insertBefore (CmmMemberInitializer * item);
      void insertAfter (CmmMemberInitializer * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [2];

   public:
      CmmMemberInitializer ();
      virtual ~ CmmMemberInitializer ();

   public:
      friend class CmmCtorInitializer;
};

class CmmSpecialFuction : public CmmBasic
{
   public:
      CmmDeclSpec * conv;
      bool spec_new;
      bool spec_new_array;
      bool spec_delete;
      bool spec_delete_array;
      bool spec_add;
      bool spec_sub;
      bool spec_mul;
      bool spec_div;
      bool spec_mod;
      bool spec_xor;
      bool spec_and;
      bool spec_or;
      bool spec_not;
      bool spec_log_not;
      bool spec_assign;
      bool spec_lt;
      bool spec_gt;
      bool spec_add_assign;
      bool spec_sub_assign;
      bool spec_mul_assign;
      bool spec_div_assign;
      bool spec_mod_assign;
      bool spec_xor_assign;
      bool spec_and_assign;
      bool spec_or_assign;
      bool spec_shl;
      bool spec_shr;
      bool spec_shl_assign;
      bool spec_shr_assign;
      bool spec_eq;
      bool spec_ne;
      bool spec_le;
      bool spec_ge;
      bool spec_log_and;
      bool spec_log_or;
      bool spec_inc;
      bool spec_dec;
      bool spec_comma;
      bool spec_member_deref;
      bool spec_deref;
      bool spec_call;
      bool spec_index;

   // location and notes
   public:
      CmmLocation location [47];

   public:
      CmmSpecialFuction ();
};

class CmmTemplateDecl : public CmmDecl
{
   public:
      CmmDecl * inner_decl;
      bool export_template;
      CmmTemplateParamSect * params;
      bool explicit_specialization;
      bool parameter_block;
      bool explicit_instatiation;

   // location and notes
   public:
      CmmLocation location [4];

   // conversion functions
   public:
      virtual CmmTemplateDecl * conv_CmmTemplateDecl () { return this; }
      virtual CmmExxternTemplateDecl * conv_CmmExxternTemplateDecl () { return NULL; }

   public:
      CmmTemplateDecl ();
};

class CmmExxternTemplateDecl : public CmmTemplateDecl
{
   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmExxternTemplateDecl * conv_CmmExxternTemplateDecl () { return this; }

   public:
      CmmExxternTemplateDecl ();
};

class CmmTemplateParamSect : public CmmBasic
{
   // list item
   public:
      CmmTemplateParam * first;
      CmmTemplateParam * last;
   protected:
      void link_item (CmmTemplateParam * item, CmmTemplateParam * bef, CmmTemplateParam * aft);
   public:
      CmmTemplateParam * getFirst () { return first; }
      CmmTemplateParam * getLast () { return last; }
      void insertFirst (CmmTemplateParam * item);
      void add (CmmTemplateParam * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [1];

   public:
      CmmTemplateParamSect ();
      virtual ~ CmmTemplateParamSect ();

   public:
      friend class CmmTemplateParam;
};

class CmmTemplateParam : public CmmBasic
{
   // list item
   public:
      CmmTemplateParam * prev;
      CmmTemplateParam * next;
      CmmTemplateParamSect * up;
      CmmTemplateParam * getPrev () { return prev; }
      CmmTemplateParam * getNext () { return next; }
      CmmTemplateParamSect * getUp () { return up; }
      void insertBefore (CmmTemplateParam * item);
      void insertAfter (CmmTemplateParam * item);
      void remove ();

   // conversion functions
   public:
      virtual CmmTemplateTypeParam * conv_CmmTemplateTypeParam () { return NULL; }
      virtual CmmTemplateValueParam * conv_CmmTemplateValueParam () { return NULL; }

   public:
      virtual ~ CmmTemplateParam ();
      CmmTemplateParam ();

   public:
      friend class CmmTemplateParamSect;
};

class CmmTemplateTypeParam : public CmmTemplateParam
{
   public:
      CmmTemplateParamSect * params;
      bool a_class;
      bool a_typename;
      CmmName * name;
      CmmTypeId * value;

   // location and notes
   public:
      CmmLocation location [6];

   // conversion functions
   public:
      virtual CmmTemplateTypeParam * conv_CmmTemplateTypeParam () { return this; }

   public:
      CmmTemplateTypeParam ();
};

class CmmTemplateValueParam : public CmmTemplateParam
{
   public:
      CmmTypeId * type;
      CmmExpr * init;

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmTemplateValueParam * conv_CmmTemplateValueParam () { return this; }

   public:
      CmmTemplateValueParam ();
};

class CmmTemplateArgSect : public CmmBasic
{
   // list item
   public:
      CmmTemplateArg * first;
      CmmTemplateArg * last;
   protected:
      void link_item (CmmTemplateArg * item, CmmTemplateArg * bef, CmmTemplateArg * aft);
   public:
      CmmTemplateArg * getFirst () { return first; }
      CmmTemplateArg * getLast () { return last; }
      void insertFirst (CmmTemplateArg * item);
      void add (CmmTemplateArg * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [3];

   public:
      CmmTemplateArgSect ();
      virtual ~ CmmTemplateArgSect ();

   public:
      friend class CmmTemplateArg;
};

class CmmTemplateArg : public CmmBasic
{
   // list item
   public:
      CmmTemplateArg * prev;
      CmmTemplateArg * next;
      CmmTemplateArgSect * up;
      CmmTemplateArg * getPrev () { return prev; }
      CmmTemplateArg * getNext () { return next; }
      CmmTemplateArgSect * getUp () { return up; }
      void insertBefore (CmmTemplateArg * item);
      void insertAfter (CmmTemplateArg * item);
      void remove ();

   // conversion functions
   public:
      virtual CmmTemplateTypeArg * conv_CmmTemplateTypeArg () { return NULL; }
      virtual CmmTemplateValueArg * conv_CmmTemplateValueArg () { return NULL; }

   public:
      virtual ~ CmmTemplateArg ();
      CmmTemplateArg ();

   public:
      friend class CmmTemplateArgSect;
};

class CmmTemplateTypeArg : public CmmTemplateArg
{
   public:
      CmmTypeId * type;

   // conversion functions
   public:
      virtual CmmTemplateTypeArg * conv_CmmTemplateTypeArg () { return this; }

   public:
      CmmTemplateTypeArg ();
};

class CmmTemplateValueArg : public CmmTemplateArg
{
   public:
      CmmExpr * value;

   // conversion functions
   public:
      virtual CmmTemplateValueArg * conv_CmmTemplateValueArg () { return this; }

   public:
      CmmTemplateValueArg ();
};

class CmmTryStat : public CmmStat
{
   public:
      CmmCompoundStat * body;
      CmmHandlerSect * handlers;

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmTryStat * conv_CmmTryStat () { return this; }

   public:
      CmmTryStat ();
};

class CmmHandlerSect : public CmmBasic
{
   // list item
   public:
      CmmHandlerItem * first;
      CmmHandlerItem * last;
   protected:
      void link_item (CmmHandlerItem * item, CmmHandlerItem * bef, CmmHandlerItem * aft);
   public:
      CmmHandlerItem * getFirst () { return first; }
      CmmHandlerItem * getLast () { return last; }
      void insertFirst (CmmHandlerItem * item);
      void add (CmmHandlerItem * item);
      void removeAll ();

   public:
      virtual ~ CmmHandlerSect ();
      CmmHandlerSect ();

   public:
      friend class CmmHandlerItem;
};

class CmmHandlerItem : public CmmBasic
{
   public:
      CmmTypeId * type;
      bool dots;
      CmmCompoundStat * body;

   // list item
   public:
      CmmHandlerItem * prev;
      CmmHandlerItem * next;
      CmmHandlerSect * up;
      CmmHandlerItem * getPrev () { return prev; }
      CmmHandlerItem * getNext () { return next; }
      CmmHandlerSect * getUp () { return up; }
      void insertBefore (CmmHandlerItem * item);
      void insertAfter (CmmHandlerItem * item);
      void remove ();

   // location and notes
   public:
      CmmLocation location [4];

   public:
      CmmHandlerItem ();
      virtual ~ CmmHandlerItem ();

   public:
      friend class CmmHandlerSect;
};

class CmmThrowExpr : public CmmExpr
{
   public:
      CmmExpr * expr;

   // location and notes
   public:
      CmmLocation location [1];

   // conversion functions
   public:
      virtual CmmThrowExpr * conv_CmmThrowExpr () { return this; }

   public:
      CmmThrowExpr ();
};

class CmmExceptionSect : public CmmBasic
{
   // list item
   public:
      CmmExceptionItem * first;
      CmmExceptionItem * last;
   protected:
      void link_item (CmmExceptionItem * item, CmmExceptionItem * bef, CmmExceptionItem * aft);
   public:
      CmmExceptionItem * getFirst () { return first; }
      CmmExceptionItem * getLast () { return last; }
      void insertFirst (CmmExceptionItem * item);
      void add (CmmExceptionItem * item);
      void removeAll ();

   // location and notes
   public:
      CmmLocation location [4];

   public:
      CmmExceptionSect ();
      virtual ~ CmmExceptionSect ();

   public:
      friend class CmmExceptionItem;
};

class CmmTypeDecl : public CmmBasic
{
   public:
      CmmTypeDecl ();
};

class CmmExceptionItem : public CmmTypeDecl
{
   public:
      CmmTypeId * type;

   // list item
   public:
      CmmExceptionItem * prev;
      CmmExceptionItem * next;
      CmmExceptionSect * up;
      CmmExceptionItem * getPrev () { return prev; }
      CmmExceptionItem * getNext () { return next; }
      CmmExceptionSect * getUp () { return up; }
      void insertBefore (CmmExceptionItem * item);
      void insertAfter (CmmExceptionItem * item);
      void remove ();

   public:
      virtual ~ CmmExceptionItem ();
      CmmExceptionItem ();

   public:
      friend class CmmExceptionSect;
};

CLOSE_NAMESPACE

#endif /* __PROG_CMM_DATA_HPP__ */