Absyn.H

/* File generated by the BNF Converter (bnfc 2.9.4). */

#ifndef ABSYN_HEADER
#define ABSYN_HEADER

#include<string>
#include<vector>

//C++ Abstract Syntax Interface.

/********************   TypeDef Section    ********************/

typedef int Integer;
typedef char Char;
typedef double Double;
typedef std::string String;
typedef std::string Ident;




/********************   Forward Declarations    ********************/

class Prog;
class TopDef;
class FnDef;
class EVal;
class Arg;
class BType;
class OType;
class AType;
class Type;
class BracketsOpt;
class SBlk;
class CBlk;
class MemItem;
class Memdef;
class CMemdef;
class Blk;
class Stmt;
class Item;
class Expr;
class DimExpr;
class AddOp;
class MulOp;
class RelOp;
class Program;
class Struct;
class TypeDef;
class TypeDefWS;
class Enum;
class Class;
class ClassWE;
class GFuncDef;
class FuncDef;
class EnumValue;
class Argument;
class Int;
class Doub;
class Bool;
class Void;
class ObjT;
class Array;
class BaseType;
class ObjType;
class ArrType;
class BracketsEmpty;
class SBlock;
class CBlock;
class MemberItem;
class MemberDef;
class CVarDef;
class CFuncDef;
class Block;
class Empty;
class BStmt;
class Decl;
class NoInit;
class Init;
class SExp;
class Ass;
class Ret;
class VRet;
class Cond;
class CondElse;
class While;
class ForLoop;
class Ecast;
class ELitNull;
class ELitInt;
class ELitDoub;
class ELitTrue;
class ELitFalse;
class EString;
class EVar;
class EApp;
class ENewObj;
class EArrow;
class Epropety;
class EFunc;
class Dim;
class ENewBArr;
class ENewOArr;
class EAcc;
class EInc;
class EDecr;
class ENeg;
class ENot;
class EMul;
class EAdd;
class ERel;
class EAnd;
class EOr;
class Plus;
class Minus;
class Times;
class Div;
class Mod;
class LTH;
class LE;
class GTH;
class GE;
class EQU;
class NE;
class ListEVal;
class ListArg;
class ListTopDef;
class ListBracketsOpt;
class ListType;
class ListMemItem;
class ListMemdef;
class ListCMemdef;
class ListStmt;
class ListItem;
class ListDimExpr;
class ListExpr;


/********************   Visitor Interfaces    ********************/
class Visitor
{
public:
  virtual ~Visitor() {}
  virtual void visitProg(Prog *p) = 0;
  virtual void visitTopDef(TopDef *p) = 0;
  virtual void visitFnDef(FnDef *p) = 0;
  virtual void visitEVal(EVal *p) = 0;
  virtual void visitArg(Arg *p) = 0;
  virtual void visitBType(BType *p) = 0;
  virtual void visitOType(OType *p) = 0;
  virtual void visitAType(AType *p) = 0;
  virtual void visitType(Type *p) = 0;
  virtual void visitBracketsOpt(BracketsOpt *p) = 0;
  virtual void visitSBlk(SBlk *p) = 0;
  virtual void visitCBlk(CBlk *p) = 0;
  virtual void visitMemItem(MemItem *p) = 0;
  virtual void visitMemdef(Memdef *p) = 0;
  virtual void visitCMemdef(CMemdef *p) = 0;
  virtual void visitBlk(Blk *p) = 0;
  virtual void visitStmt(Stmt *p) = 0;
  virtual void visitItem(Item *p) = 0;
  virtual void visitExpr(Expr *p) = 0;
  virtual void visitDimExpr(DimExpr *p) = 0;
  virtual void visitAddOp(AddOp *p) = 0;
  virtual void visitMulOp(MulOp *p) = 0;
  virtual void visitRelOp(RelOp *p) = 0;
  virtual void visitProgram(Program *p) = 0;
  virtual void visitStruct(Struct *p) = 0;
  virtual void visitTypeDef(TypeDef *p) = 0;
  virtual void visitTypeDefWS(TypeDefWS *p) = 0;
  virtual void visitEnum(Enum *p) = 0;
  virtual void visitClass(Class *p) = 0;
  virtual void visitClassWE(ClassWE *p) = 0;
  virtual void visitGFuncDef(GFuncDef *p) = 0;
  virtual void visitFuncDef(FuncDef *p) = 0;
  virtual void visitEnumValue(EnumValue *p) = 0;
  virtual void visitArgument(Argument *p) = 0;
  virtual void visitInt(Int *p) = 0;
  virtual void visitDoub(Doub *p) = 0;
  virtual void visitBool(Bool *p) = 0;
  virtual void visitVoid(Void *p) = 0;
  virtual void visitObjT(ObjT *p) = 0;
  virtual void visitArray(Array *p) = 0;
  virtual void visitBaseType(BaseType *p) = 0;
  virtual void visitObjType(ObjType *p) = 0;
  virtual void visitArrType(ArrType *p) = 0;
  virtual void visitBracketsEmpty(BracketsEmpty *p) = 0;
  virtual void visitSBlock(SBlock *p) = 0;
  virtual void visitCBlock(CBlock *p) = 0;
  virtual void visitMemberItem(MemberItem *p) = 0;
  virtual void visitMemberDef(MemberDef *p) = 0;
  virtual void visitCVarDef(CVarDef *p) = 0;
  virtual void visitCFuncDef(CFuncDef *p) = 0;
  virtual void visitBlock(Block *p) = 0;
  virtual void visitEmpty(Empty *p) = 0;
  virtual void visitBStmt(BStmt *p) = 0;
  virtual void visitDecl(Decl *p) = 0;
  virtual void visitNoInit(NoInit *p) = 0;
  virtual void visitInit(Init *p) = 0;
  virtual void visitSExp(SExp *p) = 0;
  virtual void visitAss(Ass *p) = 0;
  virtual void visitRet(Ret *p) = 0;
  virtual void visitVRet(VRet *p) = 0;
  virtual void visitCond(Cond *p) = 0;
  virtual void visitCondElse(CondElse *p) = 0;
  virtual void visitWhile(While *p) = 0;
  virtual void visitForLoop(ForLoop *p) = 0;
  virtual void visitEcast(Ecast *p) = 0;
  virtual void visitELitNull(ELitNull *p) = 0;
  virtual void visitELitInt(ELitInt *p) = 0;
  virtual void visitELitDoub(ELitDoub *p) = 0;
  virtual void visitELitTrue(ELitTrue *p) = 0;
  virtual void visitELitFalse(ELitFalse *p) = 0;
  virtual void visitEString(EString *p) = 0;
  virtual void visitEVar(EVar *p) = 0;
  virtual void visitEApp(EApp *p) = 0;
  virtual void visitENewObj(ENewObj *p) = 0;
  virtual void visitEArrow(EArrow *p) = 0;
  virtual void visitEpropety(Epropety *p) = 0;
  virtual void visitEFunc(EFunc *p) = 0;
  virtual void visitDim(Dim *p) = 0;
  virtual void visitENewBArr(ENewBArr *p) = 0;
  virtual void visitENewOArr(ENewOArr *p) = 0;
  virtual void visitEAcc(EAcc *p) = 0;
  virtual void visitEInc(EInc *p) = 0;
  virtual void visitEDecr(EDecr *p) = 0;
  virtual void visitENeg(ENeg *p) = 0;
  virtual void visitENot(ENot *p) = 0;
  virtual void visitEMul(EMul *p) = 0;
  virtual void visitEAdd(EAdd *p) = 0;
  virtual void visitERel(ERel *p) = 0;
  virtual void visitEAnd(EAnd *p) = 0;
  virtual void visitEOr(EOr *p) = 0;
  virtual void visitPlus(Plus *p) = 0;
  virtual void visitMinus(Minus *p) = 0;
  virtual void visitTimes(Times *p) = 0;
  virtual void visitDiv(Div *p) = 0;
  virtual void visitMod(Mod *p) = 0;
  virtual void visitLTH(LTH *p) = 0;
  virtual void visitLE(LE *p) = 0;
  virtual void visitGTH(GTH *p) = 0;
  virtual void visitGE(GE *p) = 0;
  virtual void visitEQU(EQU *p) = 0;
  virtual void visitNE(NE *p) = 0;
  virtual void visitListEVal(ListEVal *p) = 0;
  virtual void visitListArg(ListArg *p) = 0;
  virtual void visitListTopDef(ListTopDef *p) = 0;
  virtual void visitListBracketsOpt(ListBracketsOpt *p) = 0;
  virtual void visitListType(ListType *p) = 0;
  virtual void visitListMemItem(ListMemItem *p) = 0;
  virtual void visitListMemdef(ListMemdef *p) = 0;
  virtual void visitListCMemdef(ListCMemdef *p) = 0;
  virtual void visitListStmt(ListStmt *p) = 0;
  virtual void visitListItem(ListItem *p) = 0;
  virtual void visitListDimExpr(ListDimExpr *p) = 0;
  virtual void visitListExpr(ListExpr *p) = 0;


  virtual void visitInteger(Integer x) = 0;
  virtual void visitChar(Char x) = 0;
  virtual void visitDouble(Double x) = 0;
  virtual void visitString(String x) = 0;
  virtual void visitIdent(Ident x) = 0;

};


class Visitable
{
 public:
  virtual ~Visitable() {}
  virtual void accept(Visitor *v) = 0;
};


/********************   Abstract Syntax Classes    ********************/

class Prog : public Visitable
{
public:
  virtual Prog *clone() const = 0;

};

class TopDef : public Visitable
{
public:
  virtual TopDef *clone() const = 0;

};

class FnDef : public Visitable
{
public:
  virtual FnDef *clone() const = 0;

};

class EVal : public Visitable
{
public:
  virtual EVal *clone() const = 0;

};

class Arg : public Visitable
{
public:
  virtual Arg *clone() const = 0;

};

class BType : public Visitable
{
public:
  virtual BType *clone() const = 0;

};

class OType : public Visitable
{
public:
  virtual OType *clone() const = 0;

};

class AType : public Visitable
{
public:
  virtual AType *clone() const = 0;

};

class Type : public Visitable
{
public:
  virtual Type *clone() const = 0;

};

class BracketsOpt : public Visitable
{
public:
  virtual BracketsOpt *clone() const = 0;

};

class SBlk : public Visitable
{
public:
  virtual SBlk *clone() const = 0;

};

class CBlk : public Visitable
{
public:
  virtual CBlk *clone() const = 0;

};

class MemItem : public Visitable
{
public:
  virtual MemItem *clone() const = 0;

};

class Memdef : public Visitable
{
public:
  virtual Memdef *clone() const = 0;

};

class CMemdef : public Visitable
{
public:
  virtual CMemdef *clone() const = 0;

};

class Blk : public Visitable
{
public:
  virtual Blk *clone() const = 0;

};

class Stmt : public Visitable
{
public:
  virtual Stmt *clone() const = 0;

};

class Item : public Visitable
{
public:
  virtual Item *clone() const = 0;

};

class Expr : public Visitable
{
public:
  virtual Expr *clone() const = 0;

};

class DimExpr : public Visitable
{
public:
  virtual DimExpr *clone() const = 0;

};

class AddOp : public Visitable
{
public:
  virtual AddOp *clone() const = 0;

};

class MulOp : public Visitable
{
public:
  virtual MulOp *clone() const = 0;

};

class RelOp : public Visitable
{
public:
  virtual RelOp *clone() const = 0;

};



class Program : public Prog
{
public:
  ListTopDef *listtopdef_;

  Program(const Program &);
  Program &operator=(const Program &);
  Program(ListTopDef *p1);
  ~Program();
  virtual void accept(Visitor *v);
  virtual Program *clone() const;
  void swap(Program &);
};

class Struct : public TopDef
{
public:
  Ident ident_;
  SBlk *sblk_;

  Struct(const Struct &);
  Struct &operator=(const Struct &);
  Struct(Ident p1, SBlk *p2);
  ~Struct();
  virtual void accept(Visitor *v);
  virtual Struct *clone() const;
  void swap(Struct &);
};

class TypeDef : public TopDef
{
public:
  Ident ident_1;
  Ident ident_2;

  TypeDef(const TypeDef &);
  TypeDef &operator=(const TypeDef &);
  TypeDef(Ident p1, Ident p2);
  ~TypeDef();
  virtual void accept(Visitor *v);
  virtual TypeDef *clone() const;
  void swap(TypeDef &);
};

class TypeDefWS : public TopDef
{
public:
  Ident ident_1;
  SBlk *sblk_;
  Ident ident_2;

  TypeDefWS(const TypeDefWS &);
  TypeDefWS &operator=(const TypeDefWS &);
  TypeDefWS(Ident p1, SBlk *p2, Ident p3);
  ~TypeDefWS();
  virtual void accept(Visitor *v);
  virtual TypeDefWS *clone() const;
  void swap(TypeDefWS &);
};

class Enum : public TopDef
{
public:
  Ident ident_;
  ListEVal *listeval_;

  Enum(const Enum &);
  Enum &operator=(const Enum &);
  Enum(Ident p1, ListEVal *p2);
  ~Enum();
  virtual void accept(Visitor *v);
  virtual Enum *clone() const;
  void swap(Enum &);
};

class Class : public TopDef
{
public:
  Ident ident_;
  CBlk *cblk_;

  Class(const Class &);
  Class &operator=(const Class &);
  Class(Ident p1, CBlk *p2);
  ~Class();
  virtual void accept(Visitor *v);
  virtual Class *clone() const;
  void swap(Class &);
};

class ClassWE : public TopDef
{
public:
  Ident ident_1;
  Ident ident_2;
  CBlk *cblk_;

  ClassWE(const ClassWE &);
  ClassWE &operator=(const ClassWE &);
  ClassWE(Ident p1, Ident p2, CBlk *p3);
  ~ClassWE();
  virtual void accept(Visitor *v);
  virtual ClassWE *clone() const;
  void swap(ClassWE &);
};

class GFuncDef : public TopDef
{
public:
  FnDef *fndef_;

  GFuncDef(const GFuncDef &);
  GFuncDef &operator=(const GFuncDef &);
  GFuncDef(FnDef *p1);
  ~GFuncDef();
  virtual void accept(Visitor *v);
  virtual GFuncDef *clone() const;
  void swap(GFuncDef &);
};

class FuncDef : public FnDef
{
public:
  Type *type_;
  Ident ident_;
  ListArg *listarg_;
  Blk *blk_;

  FuncDef(const FuncDef &);
  FuncDef &operator=(const FuncDef &);
  FuncDef(Type *p1, Ident p2, ListArg *p3, Blk *p4);
  ~FuncDef();
  virtual void accept(Visitor *v);
  virtual FuncDef *clone() const;
  void swap(FuncDef &);
};

class EnumValue : public EVal
{
public:
  Ident ident_;

  EnumValue(const EnumValue &);
  EnumValue &operator=(const EnumValue &);
  EnumValue(Ident p1);
  ~EnumValue();
  virtual void accept(Visitor *v);
  virtual EnumValue *clone() const;
  void swap(EnumValue &);
};

class Argument : public Arg
{
public:
  Type *type_;
  Ident ident_;

  Argument(const Argument &);
  Argument &operator=(const Argument &);
  Argument(Type *p1, Ident p2);
  ~Argument();
  virtual void accept(Visitor *v);
  virtual Argument *clone() const;
  void swap(Argument &);
};

class Int : public BType
{
public:

  Int(const Int &);
  Int &operator=(const Int &);
  Int();
  ~Int();
  virtual void accept(Visitor *v);
  virtual Int *clone() const;
  void swap(Int &);
};

class Doub : public BType
{
public:

  Doub(const Doub &);
  Doub &operator=(const Doub &);
  Doub();
  ~Doub();
  virtual void accept(Visitor *v);
  virtual Doub *clone() const;
  void swap(Doub &);
};

class Bool : public BType
{
public:

  Bool(const Bool &);
  Bool &operator=(const Bool &);
  Bool();
  ~Bool();
  virtual void accept(Visitor *v);
  virtual Bool *clone() const;
  void swap(Bool &);
};

class Void : public BType
{
public:

  Void(const Void &);
  Void &operator=(const Void &);
  Void();
  ~Void();
  virtual void accept(Visitor *v);
  virtual Void *clone() const;
  void swap(Void &);
};

class ObjT : public OType
{
public:
  Ident ident_;

  ObjT(const ObjT &);
  ObjT &operator=(const ObjT &);
  ObjT(Ident p1);
  ~ObjT();
  virtual void accept(Visitor *v);
  virtual ObjT *clone() const;
  void swap(ObjT &);
};

class Array : public AType
{
public:
  Type *type_;
  BracketsOpt *bracketsopt_;

  Array(const Array &);
  Array &operator=(const Array &);
  Array(Type *p1, BracketsOpt *p2);
  ~Array();
  virtual void accept(Visitor *v);
  virtual Array *clone() const;
  void swap(Array &);
};

class BaseType : public Type
{
public:
  BType *btype_;

  BaseType(const BaseType &);
  BaseType &operator=(const BaseType &);
  BaseType(BType *p1);
  ~BaseType();
  virtual void accept(Visitor *v);
  virtual BaseType *clone() const;
  void swap(BaseType &);
};

class ObjType : public Type
{
public:
  OType *otype_;

  ObjType(const ObjType &);
  ObjType &operator=(const ObjType &);
  ObjType(OType *p1);
  ~ObjType();
  virtual void accept(Visitor *v);
  virtual ObjType *clone() const;
  void swap(ObjType &);
};

class ArrType : public Type
{
public:
  AType *atype_;

  ArrType(const ArrType &);
  ArrType &operator=(const ArrType &);
  ArrType(AType *p1);
  ~ArrType();
  virtual void accept(Visitor *v);
  virtual ArrType *clone() const;
  void swap(ArrType &);
};

class BracketsEmpty : public BracketsOpt
{
public:

  BracketsEmpty(const BracketsEmpty &);
  BracketsEmpty &operator=(const BracketsEmpty &);
  BracketsEmpty();
  ~BracketsEmpty();
  virtual void accept(Visitor *v);
  virtual BracketsEmpty *clone() const;
  void swap(BracketsEmpty &);
};

class SBlock : public SBlk
{
public:
  ListMemdef *listmemdef_;

  SBlock(const SBlock &);
  SBlock &operator=(const SBlock &);
  SBlock(ListMemdef *p1);
  ~SBlock();
  virtual void accept(Visitor *v);
  virtual SBlock *clone() const;
  void swap(SBlock &);
};

class CBlock : public CBlk
{
public:
  ListCMemdef *listcmemdef_;

  CBlock(const CBlock &);
  CBlock &operator=(const CBlock &);
  CBlock(ListCMemdef *p1);
  ~CBlock();
  virtual void accept(Visitor *v);
  virtual CBlock *clone() const;
  void swap(CBlock &);
};

class MemberItem : public MemItem
{
public:
  Ident ident_;

  MemberItem(const MemberItem &);
  MemberItem &operator=(const MemberItem &);
  MemberItem(Ident p1);
  ~MemberItem();
  virtual void accept(Visitor *v);
  virtual MemberItem *clone() const;
  void swap(MemberItem &);
};

class MemberDef : public Memdef
{
public:
  Type *type_;
  ListMemItem *listmemitem_;

  MemberDef(const MemberDef &);
  MemberDef &operator=(const MemberDef &);
  MemberDef(Type *p1, ListMemItem *p2);
  ~MemberDef();
  virtual void accept(Visitor *v);
  virtual MemberDef *clone() const;
  void swap(MemberDef &);
};

class CVarDef : public CMemdef
{
public:
  Memdef *memdef_;

  CVarDef(const CVarDef &);
  CVarDef &operator=(const CVarDef &);
  CVarDef(Memdef *p1);
  ~CVarDef();
  virtual void accept(Visitor *v);
  virtual CVarDef *clone() const;
  void swap(CVarDef &);
};

class CFuncDef : public CMemdef
{
public:
  FnDef *fndef_;

  CFuncDef(const CFuncDef &);
  CFuncDef &operator=(const CFuncDef &);
  CFuncDef(FnDef *p1);
  ~CFuncDef();
  virtual void accept(Visitor *v);
  virtual CFuncDef *clone() const;
  void swap(CFuncDef &);
};

class Block : public Blk
{
public:
  ListStmt *liststmt_;

  Block(const Block &);
  Block &operator=(const Block &);
  Block(ListStmt *p1);
  ~Block();
  virtual void accept(Visitor *v);
  virtual Block *clone() const;
  void swap(Block &);
};

class Empty : public Stmt
{
public:

  Empty(const Empty &);
  Empty &operator=(const Empty &);
  Empty();
  ~Empty();
  virtual void accept(Visitor *v);
  virtual Empty *clone() const;
  void swap(Empty &);
};

class BStmt : public Stmt
{
public:
  Blk *blk_;

  BStmt(const BStmt &);
  BStmt &operator=(const BStmt &);
  BStmt(Blk *p1);
  ~BStmt();
  virtual void accept(Visitor *v);
  virtual BStmt *clone() const;
  void swap(BStmt &);
};

class Decl : public Stmt
{
public:
  Type *type_;
  ListItem *listitem_;

  Decl(const Decl &);
  Decl &operator=(const Decl &);
  Decl(Type *p1, ListItem *p2);
  ~Decl();
  virtual void accept(Visitor *v);
  virtual Decl *clone() const;
  void swap(Decl &);
};

class SExp : public Stmt
{
public:
  Expr *expr_;

  SExp(const SExp &);
  SExp &operator=(const SExp &);
  SExp(Expr *p1);
  ~SExp();
  virtual void accept(Visitor *v);
  virtual SExp *clone() const;
  void swap(SExp &);
};

class Ass : public Stmt
{
public:
  Expr *expr_1;
  Expr *expr_2;

  Ass(const Ass &);
  Ass &operator=(const Ass &);
  Ass(Expr *p1, Expr *p2);
  ~Ass();
  virtual void accept(Visitor *v);
  virtual Ass *clone() const;
  void swap(Ass &);
};

class Ret : public Stmt
{
public:
  Expr *expr_;

  Ret(const Ret &);
  Ret &operator=(const Ret &);
  Ret(Expr *p1);
  ~Ret();
  virtual void accept(Visitor *v);
  virtual Ret *clone() const;
  void swap(Ret &);
};

class VRet : public Stmt
{
public:

  VRet(const VRet &);
  VRet &operator=(const VRet &);
  VRet();
  ~VRet();
  virtual void accept(Visitor *v);
  virtual VRet *clone() const;
  void swap(VRet &);
};

class Cond : public Stmt
{
public:
  Expr *expr_;
  Stmt *stmt_;

  Cond(const Cond &);
  Cond &operator=(const Cond &);
  Cond(Expr *p1, Stmt *p2);
  ~Cond();
  virtual void accept(Visitor *v);
  virtual Cond *clone() const;
  void swap(Cond &);
};

class CondElse : public Stmt
{
public:
  Expr *expr_;
  Stmt *stmt_1;
  Stmt *stmt_2;

  CondElse(const CondElse &);
  CondElse &operator=(const CondElse &);
  CondElse(Expr *p1, Stmt *p2, Stmt *p3);
  ~CondElse();
  virtual void accept(Visitor *v);
  virtual CondElse *clone() const;
  void swap(CondElse &);
};

class While : public Stmt
{
public:
  Expr *expr_;
  Stmt *stmt_;

  While(const While &);
  While &operator=(const While &);
  While(Expr *p1, Stmt *p2);
  ~While();
  virtual void accept(Visitor *v);
  virtual While *clone() const;
  void swap(While &);
};

class ForLoop : public Stmt
{
public:
  Type *type_;
  Ident ident_;
  Expr *expr_;
  Stmt *stmt_;

  ForLoop(const ForLoop &);
  ForLoop &operator=(const ForLoop &);
  ForLoop(Type *p1, Ident p2, Expr *p3, Stmt *p4);
  ~ForLoop();
  virtual void accept(Visitor *v);
  virtual ForLoop *clone() const;
  void swap(ForLoop &);
};

class NoInit : public Item
{
public:
  Ident ident_;

  NoInit(const NoInit &);
  NoInit &operator=(const NoInit &);
  NoInit(Ident p1);
  ~NoInit();
  virtual void accept(Visitor *v);
  virtual NoInit *clone() const;
  void swap(NoInit &);
};

class Init : public Item
{
public:
  Ident ident_;
  Expr *expr_;

  Init(const Init &);
  Init &operator=(const Init &);
  Init(Ident p1, Expr *p2);
  ~Init();
  virtual void accept(Visitor *v);
  virtual Init *clone() const;
  void swap(Init &);
};

class Ecast : public Expr
{
public:
  Type *type_;
  Expr *expr_;

  Ecast(const Ecast &);
  Ecast &operator=(const Ecast &);
  Ecast(Type *p1, Expr *p2);
  ~Ecast();
  virtual void accept(Visitor *v);
  virtual Ecast *clone() const;
  void swap(Ecast &);
};

class ELitNull : public Expr
{
public:

  ELitNull(const ELitNull &);
  ELitNull &operator=(const ELitNull &);
  ELitNull();
  ~ELitNull();
  virtual void accept(Visitor *v);
  virtual ELitNull *clone() const;
  void swap(ELitNull &);
};

class ELitInt : public Expr
{
public:
  Integer integer_;

  ELitInt(const ELitInt &);
  ELitInt &operator=(const ELitInt &);
  ELitInt(Integer p1);
  ~ELitInt();
  virtual void accept(Visitor *v);
  virtual ELitInt *clone() const;
  void swap(ELitInt &);
};

class ELitDoub : public Expr
{
public:
  Double double_;

  ELitDoub(const ELitDoub &);
  ELitDoub &operator=(const ELitDoub &);
  ELitDoub(Double p1);
  ~ELitDoub();
  virtual void accept(Visitor *v);
  virtual ELitDoub *clone() const;
  void swap(ELitDoub &);
};

class ELitTrue : public Expr
{
public:

  ELitTrue(const ELitTrue &);
  ELitTrue &operator=(const ELitTrue &);
  ELitTrue();
  ~ELitTrue();
  virtual void accept(Visitor *v);
  virtual ELitTrue *clone() const;
  void swap(ELitTrue &);
};

class ELitFalse : public Expr
{
public:

  ELitFalse(const ELitFalse &);
  ELitFalse &operator=(const ELitFalse &);
  ELitFalse();
  ~ELitFalse();
  virtual void accept(Visitor *v);
  virtual ELitFalse *clone() const;
  void swap(ELitFalse &);
};

class EString : public Expr
{
public:
  String string_;

  EString(const EString &);
  EString &operator=(const EString &);
  EString(String p1);
  ~EString();
  virtual void accept(Visitor *v);
  virtual EString *clone() const;
  void swap(EString &);
};

class EVar : public Expr
{
public:
  Ident ident_;

  EVar(const EVar &);
  EVar &operator=(const EVar &);
  EVar(Ident p1);
  ~EVar();
  virtual void accept(Visitor *v);
  virtual EVar *clone() const;
  void swap(EVar &);
};

class EApp : public Expr
{
public:
  Ident ident_;
  ListExpr *listexpr_;

  EApp(const EApp &);
  EApp &operator=(const EApp &);
  EApp(Ident p1, ListExpr *p2);
  ~EApp();
  virtual void accept(Visitor *v);
  virtual EApp *clone() const;
  void swap(EApp &);
};

class ENewObj : public Expr
{
public:
  OType *otype_;

  ENewObj(const ENewObj &);
  ENewObj &operator=(const ENewObj &);
  ENewObj(OType *p1);
  ~ENewObj();
  virtual void accept(Visitor *v);
  virtual ENewObj *clone() const;
  void swap(ENewObj &);
};

class EArrow : public Expr
{
public:
  Expr *expr_;
  Ident ident_;

  EArrow(const EArrow &);
  EArrow &operator=(const EArrow &);
  EArrow(Expr *p1, Ident p2);
  ~EArrow();
  virtual void accept(Visitor *v);
  virtual EArrow *clone() const;
  void swap(EArrow &);
};

class Epropety : public Expr
{
public:
  Expr *expr_;
  Ident ident_;

  Epropety(const Epropety &);
  Epropety &operator=(const Epropety &);
  Epropety(Expr *p1, Ident p2);
  ~Epropety();
  virtual void accept(Visitor *v);
  virtual Epropety *clone() const;
  void swap(Epropety &);
};

class EFunc : public Expr
{
public:
  Expr *expr_;
  Ident ident_;
  ListExpr *listexpr_;

  EFunc(const EFunc &);
  EFunc &operator=(const EFunc &);
  EFunc(Expr *p1, Ident p2, ListExpr *p3);
  ~EFunc();
  virtual void accept(Visitor *v);
  virtual EFunc *clone() const;
  void swap(EFunc &);
};

class ENewBArr : public Expr
{
public:
  BType *btype_;
  ListDimExpr *listdimexpr_;

  ENewBArr(const ENewBArr &);
  ENewBArr &operator=(const ENewBArr &);
  ENewBArr(BType *p1, ListDimExpr *p2);
  ~ENewBArr();
  virtual void accept(Visitor *v);
  virtual ENewBArr *clone() const;
  void swap(ENewBArr &);
};

class ENewOArr : public Expr
{
public:
  OType *otype_;
  ListDimExpr *listdimexpr_;

  ENewOArr(const ENewOArr &);
  ENewOArr &operator=(const ENewOArr &);
  ENewOArr(OType *p1, ListDimExpr *p2);
  ~ENewOArr();
  virtual void accept(Visitor *v);
  virtual ENewOArr *clone() const;
  void swap(ENewOArr &);
};

class EAcc : public Expr
{
public:
  Expr *expr_;
  ListDimExpr *listdimexpr_;

  EAcc(const EAcc &);
  EAcc &operator=(const EAcc &);
  EAcc(Expr *p1, ListDimExpr *p2);
  ~EAcc();
  virtual void accept(Visitor *v);
  virtual EAcc *clone() const;
  void swap(EAcc &);
};

class EInc : public Expr
{
public:
  Expr *expr_;

  EInc(const EInc &);
  EInc &operator=(const EInc &);
  EInc(Expr *p1);
  ~EInc();
  virtual void accept(Visitor *v);
  virtual EInc *clone() const;
  void swap(EInc &);
};

class EDecr : public Expr
{
public:
  Expr *expr_;

  EDecr(const EDecr &);
  EDecr &operator=(const EDecr &);
  EDecr(Expr *p1);
  ~EDecr();
  virtual void accept(Visitor *v);
  virtual EDecr *clone() const;
  void swap(EDecr &);
};

class ENeg : public Expr
{
public:
  Expr *expr_;

  ENeg(const ENeg &);
  ENeg &operator=(const ENeg &);
  ENeg(Expr *p1);
  ~ENeg();
  virtual void accept(Visitor *v);
  virtual ENeg *clone() const;
  void swap(ENeg &);
};

class ENot : public Expr
{
public:
  Expr *expr_;

  ENot(const ENot &);
  ENot &operator=(const ENot &);
  ENot(Expr *p1);
  ~ENot();
  virtual void accept(Visitor *v);
  virtual ENot *clone() const;
  void swap(ENot &);
};

class EMul : public Expr
{
public:
  Expr *expr_1;
  MulOp *mulop_;
  Expr *expr_2;

  EMul(const EMul &);
  EMul &operator=(const EMul &);
  EMul(Expr *p1, MulOp *p2, Expr *p3);
  ~EMul();
  virtual void accept(Visitor *v);
  virtual EMul *clone() const;
  void swap(EMul &);
};

class EAdd : public Expr
{
public:
  Expr *expr_1;
  AddOp *addop_;
  Expr *expr_2;

  EAdd(const EAdd &);
  EAdd &operator=(const EAdd &);
  EAdd(Expr *p1, AddOp *p2, Expr *p3);
  ~EAdd();
  virtual void accept(Visitor *v);
  virtual EAdd *clone() const;
  void swap(EAdd &);
};

class ERel : public Expr
{
public:
  Expr *expr_1;
  RelOp *relop_;
  Expr *expr_2;

  ERel(const ERel &);
  ERel &operator=(const ERel &);
  ERel(Expr *p1, RelOp *p2, Expr *p3);
  ~ERel();
  virtual void accept(Visitor *v);
  virtual ERel *clone() const;
  void swap(ERel &);
};

class EAnd : public Expr
{
public:
  Expr *expr_1;
  Expr *expr_2;

  EAnd(const EAnd &);
  EAnd &operator=(const EAnd &);
  EAnd(Expr *p1, Expr *p2);
  ~EAnd();
  virtual void accept(Visitor *v);
  virtual EAnd *clone() const;
  void swap(EAnd &);
};

class EOr : public Expr
{
public:
  Expr *expr_1;
  Expr *expr_2;

  EOr(const EOr &);
  EOr &operator=(const EOr &);
  EOr(Expr *p1, Expr *p2);
  ~EOr();
  virtual void accept(Visitor *v);
  virtual EOr *clone() const;
  void swap(EOr &);
};

class Dim : public DimExpr
{
public:
  Expr *expr_;

  Dim(const Dim &);
  Dim &operator=(const Dim &);
  Dim(Expr *p1);
  ~Dim();
  virtual void accept(Visitor *v);
  virtual Dim *clone() const;
  void swap(Dim &);
};

class Plus : public AddOp
{
public:

  Plus(const Plus &);
  Plus &operator=(const Plus &);
  Plus();
  ~Plus();
  virtual void accept(Visitor *v);
  virtual Plus *clone() const;
  void swap(Plus &);
};

class Minus : public AddOp
{
public:

  Minus(const Minus &);
  Minus &operator=(const Minus &);
  Minus();
  ~Minus();
  virtual void accept(Visitor *v);
  virtual Minus *clone() const;
  void swap(Minus &);
};

class Times : public MulOp
{
public:

  Times(const Times &);
  Times &operator=(const Times &);
  Times();
  ~Times();
  virtual void accept(Visitor *v);
  virtual Times *clone() const;
  void swap(Times &);
};

class Div : public MulOp
{
public:

  Div(const Div &);
  Div &operator=(const Div &);
  Div();
  ~Div();
  virtual void accept(Visitor *v);
  virtual Div *clone() const;
  void swap(Div &);
};

class Mod : public MulOp
{
public:

  Mod(const Mod &);
  Mod &operator=(const Mod &);
  Mod();
  ~Mod();
  virtual void accept(Visitor *v);
  virtual Mod *clone() const;
  void swap(Mod &);
};

class LTH : public RelOp
{
public:

  LTH(const LTH &);
  LTH &operator=(const LTH &);
  LTH();
  ~LTH();
  virtual void accept(Visitor *v);
  virtual LTH *clone() const;
  void swap(LTH &);
};

class LE : public RelOp
{
public:

  LE(const LE &);
  LE &operator=(const LE &);
  LE();
  ~LE();
  virtual void accept(Visitor *v);
  virtual LE *clone() const;
  void swap(LE &);
};

class GTH : public RelOp
{
public:

  GTH(const GTH &);
  GTH &operator=(const GTH &);
  GTH();
  ~GTH();
  virtual void accept(Visitor *v);
  virtual GTH *clone() const;
  void swap(GTH &);
};

class GE : public RelOp
{
public:

  GE(const GE &);
  GE &operator=(const GE &);
  GE();
  ~GE();
  virtual void accept(Visitor *v);
  virtual GE *clone() const;
  void swap(GE &);
};

class EQU : public RelOp
{
public:

  EQU(const EQU &);
  EQU &operator=(const EQU &);
  EQU();
  ~EQU();
  virtual void accept(Visitor *v);
  virtual EQU *clone() const;
  void swap(EQU &);
};

class NE : public RelOp
{
public:

  NE(const NE &);
  NE &operator=(const NE &);
  NE();
  ~NE();
  virtual void accept(Visitor *v);
  virtual NE *clone() const;
  void swap(NE &);
};



class ListEVal : public Visitable, public std::vector<EVal*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListEVal *clone() const;
};

ListEVal* consListEVal(EVal* x, ListEVal* xs);

class ListArg : public Visitable, public std::vector<Arg*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListArg *clone() const;
};

ListArg* consListArg(Arg* x, ListArg* xs);

class ListTopDef : public Visitable, public std::vector<TopDef*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListTopDef *clone() const;
};

ListTopDef* consListTopDef(TopDef* x, ListTopDef* xs);

class ListBracketsOpt : public Visitable, public std::vector<BracketsOpt*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListBracketsOpt *clone() const;
};

ListBracketsOpt* consListBracketsOpt(BracketsOpt* x, ListBracketsOpt* xs);

class ListType : public Visitable, public std::vector<Type*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListType *clone() const;
};

ListType* consListType(Type* x, ListType* xs);

class ListMemItem : public Visitable, public std::vector<MemItem*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListMemItem *clone() const;
};

ListMemItem* consListMemItem(MemItem* x, ListMemItem* xs);

class ListMemdef : public Visitable, public std::vector<Memdef*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListMemdef *clone() const;
};

ListMemdef* consListMemdef(Memdef* x, ListMemdef* xs);

class ListCMemdef : public Visitable, public std::vector<CMemdef*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListCMemdef *clone() const;
};

ListCMemdef* consListCMemdef(CMemdef* x, ListCMemdef* xs);

class ListStmt : public Visitable, public std::vector<Stmt*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListStmt *clone() const;
};

ListStmt* consListStmt(Stmt* x, ListStmt* xs);

class ListItem : public Visitable, public std::vector<Item*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListItem *clone() const;
};

ListItem* consListItem(Item* x, ListItem* xs);

class ListDimExpr : public Visitable, public std::vector<DimExpr*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListDimExpr *clone() const;
};

ListDimExpr* consListDimExpr(DimExpr* x, ListDimExpr* xs);

class ListExpr : public Visitable, public std::vector<Expr*>
{
public:
  virtual void accept(Visitor *v);
  virtual ListExpr *clone() const;
};

ListExpr* consListExpr(Expr* x, ListExpr* xs);





#endif