Absyn.C

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

//C++ Abstract Syntax Implementation.
#include <algorithm>
#include <string>
#include <vector>
#include "Absyn.H"

/********************   Program    ********************/
Program::Program(ListTopDef *p1)
{
  listtopdef_ = p1;

}

Program::Program(const Program & other)
{
  listtopdef_ = other.listtopdef_->clone();

}

Program &Program::operator=(const Program & other)
{
  Program tmp(other);
  swap(tmp);
  return *this;
}

void Program::swap(Program & other)
{
  std::swap(listtopdef_, other.listtopdef_);

}

Program::~Program()
{
  delete(listtopdef_);

}

void Program::accept(Visitor *v)
{
  v->visitProgram(this);
}

Program *Program::clone() const
{
  return new Program(*this);
}



/********************   Struct    ********************/
Struct::Struct(Ident p1, SBlk *p2)
{
  ident_ = p1;
  sblk_ = p2;

}

Struct::Struct(const Struct & other)
{
  ident_ = other.ident_;
  sblk_ = other.sblk_->clone();

}

Struct &Struct::operator=(const Struct & other)
{
  Struct tmp(other);
  swap(tmp);
  return *this;
}

void Struct::swap(Struct & other)
{
  std::swap(ident_, other.ident_);
  std::swap(sblk_, other.sblk_);

}

Struct::~Struct()
{
  delete(sblk_);

}

void Struct::accept(Visitor *v)
{
  v->visitStruct(this);
}

Struct *Struct::clone() const
{
  return new Struct(*this);
}



/********************   TypeDef    ********************/
TypeDef::TypeDef(Ident p1, Ident p2)
{
  ident_1 = p1;
  ident_2 = p2;

}

TypeDef::TypeDef(const TypeDef & other)
{
  ident_1 = other.ident_1;
  ident_2 = other.ident_2;

}

TypeDef &TypeDef::operator=(const TypeDef & other)
{
  TypeDef tmp(other);
  swap(tmp);
  return *this;
}

void TypeDef::swap(TypeDef & other)
{
  std::swap(ident_1, other.ident_1);
  std::swap(ident_2, other.ident_2);

}

TypeDef::~TypeDef()
{

}

void TypeDef::accept(Visitor *v)
{
  v->visitTypeDef(this);
}

TypeDef *TypeDef::clone() const
{
  return new TypeDef(*this);
}



/********************   TypeDefWS    ********************/
TypeDefWS::TypeDefWS(Ident p1, SBlk *p2, Ident p3)
{
  ident_1 = p1;
  sblk_ = p2;
  ident_2 = p3;

}

TypeDefWS::TypeDefWS(const TypeDefWS & other)
{
  ident_1 = other.ident_1;
  sblk_ = other.sblk_->clone();
  ident_2 = other.ident_2;

}

TypeDefWS &TypeDefWS::operator=(const TypeDefWS & other)
{
  TypeDefWS tmp(other);
  swap(tmp);
  return *this;
}

void TypeDefWS::swap(TypeDefWS & other)
{
  std::swap(ident_1, other.ident_1);
  std::swap(sblk_, other.sblk_);
  std::swap(ident_2, other.ident_2);

}

TypeDefWS::~TypeDefWS()
{
  delete(sblk_);

}

void TypeDefWS::accept(Visitor *v)
{
  v->visitTypeDefWS(this);
}

TypeDefWS *TypeDefWS::clone() const
{
  return new TypeDefWS(*this);
}



/********************   Enum    ********************/
Enum::Enum(Ident p1, ListEVal *p2)
{
  ident_ = p1;
  listeval_ = p2;

}

Enum::Enum(const Enum & other)
{
  ident_ = other.ident_;
  listeval_ = other.listeval_->clone();

}

Enum &Enum::operator=(const Enum & other)
{
  Enum tmp(other);
  swap(tmp);
  return *this;
}

void Enum::swap(Enum & other)
{
  std::swap(ident_, other.ident_);
  std::swap(listeval_, other.listeval_);

}

Enum::~Enum()
{
  delete(listeval_);

}

void Enum::accept(Visitor *v)
{
  v->visitEnum(this);
}

Enum *Enum::clone() const
{
  return new Enum(*this);
}



/********************   Class    ********************/
Class::Class(Ident p1, CBlk *p2)
{
  ident_ = p1;
  cblk_ = p2;

}

Class::Class(const Class & other)
{
  ident_ = other.ident_;
  cblk_ = other.cblk_->clone();

}

Class &Class::operator=(const Class & other)
{
  Class tmp(other);
  swap(tmp);
  return *this;
}

void Class::swap(Class & other)
{
  std::swap(ident_, other.ident_);
  std::swap(cblk_, other.cblk_);

}

Class::~Class()
{
  delete(cblk_);

}

void Class::accept(Visitor *v)
{
  v->visitClass(this);
}

Class *Class::clone() const
{
  return new Class(*this);
}



/********************   ClassWE    ********************/
ClassWE::ClassWE(Ident p1, Ident p2, CBlk *p3)
{
  ident_1 = p1;
  ident_2 = p2;
  cblk_ = p3;

}

ClassWE::ClassWE(const ClassWE & other)
{
  ident_1 = other.ident_1;
  ident_2 = other.ident_2;
  cblk_ = other.cblk_->clone();

}

ClassWE &ClassWE::operator=(const ClassWE & other)
{
  ClassWE tmp(other);
  swap(tmp);
  return *this;
}

void ClassWE::swap(ClassWE & other)
{
  std::swap(ident_1, other.ident_1);
  std::swap(ident_2, other.ident_2);
  std::swap(cblk_, other.cblk_);

}

ClassWE::~ClassWE()
{
  delete(cblk_);

}

void ClassWE::accept(Visitor *v)
{
  v->visitClassWE(this);
}

ClassWE *ClassWE::clone() const
{
  return new ClassWE(*this);
}



/********************   GFuncDef    ********************/
GFuncDef::GFuncDef(FnDef *p1)
{
  fndef_ = p1;

}

GFuncDef::GFuncDef(const GFuncDef & other)
{
  fndef_ = other.fndef_->clone();

}

GFuncDef &GFuncDef::operator=(const GFuncDef & other)
{
  GFuncDef tmp(other);
  swap(tmp);
  return *this;
}

void GFuncDef::swap(GFuncDef & other)
{
  std::swap(fndef_, other.fndef_);

}

GFuncDef::~GFuncDef()
{
  delete(fndef_);

}

void GFuncDef::accept(Visitor *v)
{
  v->visitGFuncDef(this);
}

GFuncDef *GFuncDef::clone() const
{
  return new GFuncDef(*this);
}



/********************   FuncDef    ********************/
FuncDef::FuncDef(Type *p1, Ident p2, ListArg *p3, Blk *p4)
{
  type_ = p1;
  ident_ = p2;
  listarg_ = p3;
  blk_ = p4;

}

FuncDef::FuncDef(const FuncDef & other)
{
  type_ = other.type_->clone();
  ident_ = other.ident_;
  listarg_ = other.listarg_->clone();
  blk_ = other.blk_->clone();

}

FuncDef &FuncDef::operator=(const FuncDef & other)
{
  FuncDef tmp(other);
  swap(tmp);
  return *this;
}

void FuncDef::swap(FuncDef & other)
{
  std::swap(type_, other.type_);
  std::swap(ident_, other.ident_);
  std::swap(listarg_, other.listarg_);
  std::swap(blk_, other.blk_);

}

FuncDef::~FuncDef()
{
  delete(type_);
  delete(listarg_);
  delete(blk_);

}

void FuncDef::accept(Visitor *v)
{
  v->visitFuncDef(this);
}

FuncDef *FuncDef::clone() const
{
  return new FuncDef(*this);
}



/********************   EnumValue    ********************/
EnumValue::EnumValue(Ident p1)
{
  ident_ = p1;

}

EnumValue::EnumValue(const EnumValue & other)
{
  ident_ = other.ident_;

}

EnumValue &EnumValue::operator=(const EnumValue & other)
{
  EnumValue tmp(other);
  swap(tmp);
  return *this;
}

void EnumValue::swap(EnumValue & other)
{
  std::swap(ident_, other.ident_);

}

EnumValue::~EnumValue()
{

}

void EnumValue::accept(Visitor *v)
{
  v->visitEnumValue(this);
}

EnumValue *EnumValue::clone() const
{
  return new EnumValue(*this);
}



/********************   Argument    ********************/
Argument::Argument(Type *p1, Ident p2)
{
  type_ = p1;
  ident_ = p2;

}

Argument::Argument(const Argument & other)
{
  type_ = other.type_->clone();
  ident_ = other.ident_;

}

Argument &Argument::operator=(const Argument & other)
{
  Argument tmp(other);
  swap(tmp);
  return *this;
}

void Argument::swap(Argument & other)
{
  std::swap(type_, other.type_);
  std::swap(ident_, other.ident_);

}

Argument::~Argument()
{
  delete(type_);

}

void Argument::accept(Visitor *v)
{
  v->visitArgument(this);
}

Argument *Argument::clone() const
{
  return new Argument(*this);
}



/********************   Int    ********************/
Int::Int()
{

}

Int::Int(const Int & other)
{

}

Int &Int::operator=(const Int & other)
{
  Int tmp(other);
  swap(tmp);
  return *this;
}

void Int::swap(Int & other)
{

}

Int::~Int()
{

}

void Int::accept(Visitor *v)
{
  v->visitInt(this);
}

Int *Int::clone() const
{
  return new Int(*this);
}



/********************   Doub    ********************/
Doub::Doub()
{

}

Doub::Doub(const Doub & other)
{

}

Doub &Doub::operator=(const Doub & other)
{
  Doub tmp(other);
  swap(tmp);
  return *this;
}

void Doub::swap(Doub & other)
{

}

Doub::~Doub()
{

}

void Doub::accept(Visitor *v)
{
  v->visitDoub(this);
}

Doub *Doub::clone() const
{
  return new Doub(*this);
}



/********************   Bool    ********************/
Bool::Bool()
{

}

Bool::Bool(const Bool & other)
{

}

Bool &Bool::operator=(const Bool & other)
{
  Bool tmp(other);
  swap(tmp);
  return *this;
}

void Bool::swap(Bool & other)
{

}

Bool::~Bool()
{

}

void Bool::accept(Visitor *v)
{
  v->visitBool(this);
}

Bool *Bool::clone() const
{
  return new Bool(*this);
}



/********************   Void    ********************/
Void::Void()
{

}

Void::Void(const Void & other)
{

}

Void &Void::operator=(const Void & other)
{
  Void tmp(other);
  swap(tmp);
  return *this;
}

void Void::swap(Void & other)
{

}

Void::~Void()
{

}

void Void::accept(Visitor *v)
{
  v->visitVoid(this);
}

Void *Void::clone() const
{
  return new Void(*this);
}



/********************   ObjT    ********************/
ObjT::ObjT(Ident p1)
{
  ident_ = p1;

}

ObjT::ObjT(const ObjT & other)
{
  ident_ = other.ident_;

}

ObjT &ObjT::operator=(const ObjT & other)
{
  ObjT tmp(other);
  swap(tmp);
  return *this;
}

void ObjT::swap(ObjT & other)
{
  std::swap(ident_, other.ident_);

}

ObjT::~ObjT()
{

}

void ObjT::accept(Visitor *v)
{
  v->visitObjT(this);
}

ObjT *ObjT::clone() const
{
  return new ObjT(*this);
}



/********************   Array    ********************/
Array::Array(Type *p1, BracketsOpt *p2)
{
  type_ = p1;
  bracketsopt_ = p2;

}

Array::Array(const Array & other)
{
  type_ = other.type_->clone();
  bracketsopt_ = other.bracketsopt_->clone();

}

Array &Array::operator=(const Array & other)
{
  Array tmp(other);
  swap(tmp);
  return *this;
}

void Array::swap(Array & other)
{
  std::swap(type_, other.type_);
  std::swap(bracketsopt_, other.bracketsopt_);

}

Array::~Array()
{
  delete(type_);
  delete(bracketsopt_);

}

void Array::accept(Visitor *v)
{
  v->visitArray(this);
}

Array *Array::clone() const
{
  return new Array(*this);
}



/********************   BaseType    ********************/
BaseType::BaseType(BType *p1)
{
  btype_ = p1;

}

BaseType::BaseType(const BaseType & other)
{
  btype_ = other.btype_->clone();

}

BaseType &BaseType::operator=(const BaseType & other)
{
  BaseType tmp(other);
  swap(tmp);
  return *this;
}

void BaseType::swap(BaseType & other)
{
  std::swap(btype_, other.btype_);

}

BaseType::~BaseType()
{
  delete(btype_);

}

void BaseType::accept(Visitor *v)
{
  v->visitBaseType(this);
}

BaseType *BaseType::clone() const
{
  return new BaseType(*this);
}



/********************   ObjType    ********************/
ObjType::ObjType(OType *p1)
{
  otype_ = p1;

}

ObjType::ObjType(const ObjType & other)
{
  otype_ = other.otype_->clone();

}

ObjType &ObjType::operator=(const ObjType & other)
{
  ObjType tmp(other);
  swap(tmp);
  return *this;
}

void ObjType::swap(ObjType & other)
{
  std::swap(otype_, other.otype_);

}

ObjType::~ObjType()
{
  delete(otype_);

}

void ObjType::accept(Visitor *v)
{
  v->visitObjType(this);
}

ObjType *ObjType::clone() const
{
  return new ObjType(*this);
}



/********************   ArrType    ********************/
ArrType::ArrType(AType *p1)
{
  atype_ = p1;

}

ArrType::ArrType(const ArrType & other)
{
  atype_ = other.atype_->clone();

}

ArrType &ArrType::operator=(const ArrType & other)
{
  ArrType tmp(other);
  swap(tmp);
  return *this;
}

void ArrType::swap(ArrType & other)
{
  std::swap(atype_, other.atype_);

}

ArrType::~ArrType()
{
  delete(atype_);

}

void ArrType::accept(Visitor *v)
{
  v->visitArrType(this);
}

ArrType *ArrType::clone() const
{
  return new ArrType(*this);
}



/********************   BracketsEmpty    ********************/
BracketsEmpty::BracketsEmpty()
{

}

BracketsEmpty::BracketsEmpty(const BracketsEmpty & other)
{

}

BracketsEmpty &BracketsEmpty::operator=(const BracketsEmpty & other)
{
  BracketsEmpty tmp(other);
  swap(tmp);
  return *this;
}

void BracketsEmpty::swap(BracketsEmpty & other)
{

}

BracketsEmpty::~BracketsEmpty()
{

}

void BracketsEmpty::accept(Visitor *v)
{
  v->visitBracketsEmpty(this);
}

BracketsEmpty *BracketsEmpty::clone() const
{
  return new BracketsEmpty(*this);
}



/********************   SBlock    ********************/
SBlock::SBlock(ListMemdef *p1)
{
  listmemdef_ = p1;

}

SBlock::SBlock(const SBlock & other)
{
  listmemdef_ = other.listmemdef_->clone();

}

SBlock &SBlock::operator=(const SBlock & other)
{
  SBlock tmp(other);
  swap(tmp);
  return *this;
}

void SBlock::swap(SBlock & other)
{
  std::swap(listmemdef_, other.listmemdef_);

}

SBlock::~SBlock()
{
  delete(listmemdef_);

}

void SBlock::accept(Visitor *v)
{
  v->visitSBlock(this);
}

SBlock *SBlock::clone() const
{
  return new SBlock(*this);
}



/********************   CBlock    ********************/
CBlock::CBlock(ListCMemdef *p1)
{
  listcmemdef_ = p1;

}

CBlock::CBlock(const CBlock & other)
{
  listcmemdef_ = other.listcmemdef_->clone();

}

CBlock &CBlock::operator=(const CBlock & other)
{
  CBlock tmp(other);
  swap(tmp);
  return *this;
}

void CBlock::swap(CBlock & other)
{
  std::swap(listcmemdef_, other.listcmemdef_);

}

CBlock::~CBlock()
{
  delete(listcmemdef_);

}

void CBlock::accept(Visitor *v)
{
  v->visitCBlock(this);
}

CBlock *CBlock::clone() const
{
  return new CBlock(*this);
}



/********************   MemberItem    ********************/
MemberItem::MemberItem(Ident p1)
{
  ident_ = p1;

}

MemberItem::MemberItem(const MemberItem & other)
{
  ident_ = other.ident_;

}

MemberItem &MemberItem::operator=(const MemberItem & other)
{
  MemberItem tmp(other);
  swap(tmp);
  return *this;
}

void MemberItem::swap(MemberItem & other)
{
  std::swap(ident_, other.ident_);

}

MemberItem::~MemberItem()
{

}

void MemberItem::accept(Visitor *v)
{
  v->visitMemberItem(this);
}

MemberItem *MemberItem::clone() const
{
  return new MemberItem(*this);
}



/********************   MemberDef    ********************/
MemberDef::MemberDef(Type *p1, ListMemItem *p2)
{
  type_ = p1;
  listmemitem_ = p2;

}

MemberDef::MemberDef(const MemberDef & other)
{
  type_ = other.type_->clone();
  listmemitem_ = other.listmemitem_->clone();

}

MemberDef &MemberDef::operator=(const MemberDef & other)
{
  MemberDef tmp(other);
  swap(tmp);
  return *this;
}

void MemberDef::swap(MemberDef & other)
{
  std::swap(type_, other.type_);
  std::swap(listmemitem_, other.listmemitem_);

}

MemberDef::~MemberDef()
{
  delete(type_);
  delete(listmemitem_);

}

void MemberDef::accept(Visitor *v)
{
  v->visitMemberDef(this);
}

MemberDef *MemberDef::clone() const
{
  return new MemberDef(*this);
}



/********************   CVarDef    ********************/
CVarDef::CVarDef(Memdef *p1)
{
  memdef_ = p1;

}

CVarDef::CVarDef(const CVarDef & other)
{
  memdef_ = other.memdef_->clone();

}

CVarDef &CVarDef::operator=(const CVarDef & other)
{
  CVarDef tmp(other);
  swap(tmp);
  return *this;
}

void CVarDef::swap(CVarDef & other)
{
  std::swap(memdef_, other.memdef_);

}

CVarDef::~CVarDef()
{
  delete(memdef_);

}

void CVarDef::accept(Visitor *v)
{
  v->visitCVarDef(this);
}

CVarDef *CVarDef::clone() const
{
  return new CVarDef(*this);
}



/********************   CFuncDef    ********************/
CFuncDef::CFuncDef(FnDef *p1)
{
  fndef_ = p1;

}

CFuncDef::CFuncDef(const CFuncDef & other)
{
  fndef_ = other.fndef_->clone();

}

CFuncDef &CFuncDef::operator=(const CFuncDef & other)
{
  CFuncDef tmp(other);
  swap(tmp);
  return *this;
}

void CFuncDef::swap(CFuncDef & other)
{
  std::swap(fndef_, other.fndef_);

}

CFuncDef::~CFuncDef()
{
  delete(fndef_);

}

void CFuncDef::accept(Visitor *v)
{
  v->visitCFuncDef(this);
}

CFuncDef *CFuncDef::clone() const
{
  return new CFuncDef(*this);
}



/********************   Block    ********************/
Block::Block(ListStmt *p1)
{
  liststmt_ = p1;

}

Block::Block(const Block & other)
{
  liststmt_ = other.liststmt_->clone();

}

Block &Block::operator=(const Block & other)
{
  Block tmp(other);
  swap(tmp);
  return *this;
}

void Block::swap(Block & other)
{
  std::swap(liststmt_, other.liststmt_);

}

Block::~Block()
{
  delete(liststmt_);

}

void Block::accept(Visitor *v)
{
  v->visitBlock(this);
}

Block *Block::clone() const
{
  return new Block(*this);
}



/********************   Empty    ********************/
Empty::Empty()
{

}

Empty::Empty(const Empty & other)
{

}

Empty &Empty::operator=(const Empty & other)
{
  Empty tmp(other);
  swap(tmp);
  return *this;
}

void Empty::swap(Empty & other)
{

}

Empty::~Empty()
{

}

void Empty::accept(Visitor *v)
{
  v->visitEmpty(this);
}

Empty *Empty::clone() const
{
  return new Empty(*this);
}



/********************   BStmt    ********************/
BStmt::BStmt(Blk *p1)
{
  blk_ = p1;

}

BStmt::BStmt(const BStmt & other)
{
  blk_ = other.blk_->clone();

}

BStmt &BStmt::operator=(const BStmt & other)
{
  BStmt tmp(other);
  swap(tmp);
  return *this;
}

void BStmt::swap(BStmt & other)
{
  std::swap(blk_, other.blk_);

}

BStmt::~BStmt()
{
  delete(blk_);

}

void BStmt::accept(Visitor *v)
{
  v->visitBStmt(this);
}

BStmt *BStmt::clone() const
{
  return new BStmt(*this);
}



/********************   Decl    ********************/
Decl::Decl(Type *p1, ListItem *p2)
{
  type_ = p1;
  listitem_ = p2;

}

Decl::Decl(const Decl & other)
{
  type_ = other.type_->clone();
  listitem_ = other.listitem_->clone();

}

Decl &Decl::operator=(const Decl & other)
{
  Decl tmp(other);
  swap(tmp);
  return *this;
}

void Decl::swap(Decl & other)
{
  std::swap(type_, other.type_);
  std::swap(listitem_, other.listitem_);

}

Decl::~Decl()
{
  delete(type_);
  delete(listitem_);

}

void Decl::accept(Visitor *v)
{
  v->visitDecl(this);
}

Decl *Decl::clone() const
{
  return new Decl(*this);
}



/********************   SExp    ********************/
SExp::SExp(Expr *p1)
{
  expr_ = p1;

}

SExp::SExp(const SExp & other)
{
  expr_ = other.expr_->clone();

}

SExp &SExp::operator=(const SExp & other)
{
  SExp tmp(other);
  swap(tmp);
  return *this;
}

void SExp::swap(SExp & other)
{
  std::swap(expr_, other.expr_);

}

SExp::~SExp()
{
  delete(expr_);

}

void SExp::accept(Visitor *v)
{
  v->visitSExp(this);
}

SExp *SExp::clone() const
{
  return new SExp(*this);
}



/********************   Ass    ********************/
Ass::Ass(Expr *p1, Expr *p2)
{
  expr_1 = p1;
  expr_2 = p2;

}

Ass::Ass(const Ass & other)
{
  expr_1 = other.expr_1->clone();
  expr_2 = other.expr_2->clone();

}

Ass &Ass::operator=(const Ass & other)
{
  Ass tmp(other);
  swap(tmp);
  return *this;
}

void Ass::swap(Ass & other)
{
  std::swap(expr_1, other.expr_1);
  std::swap(expr_2, other.expr_2);

}

Ass::~Ass()
{
  delete(expr_1);
  delete(expr_2);

}

void Ass::accept(Visitor *v)
{
  v->visitAss(this);
}

Ass *Ass::clone() const
{
  return new Ass(*this);
}



/********************   Ret    ********************/
Ret::Ret(Expr *p1)
{
  expr_ = p1;

}

Ret::Ret(const Ret & other)
{
  expr_ = other.expr_->clone();

}

Ret &Ret::operator=(const Ret & other)
{
  Ret tmp(other);
  swap(tmp);
  return *this;
}

void Ret::swap(Ret & other)
{
  std::swap(expr_, other.expr_);

}

Ret::~Ret()
{
  delete(expr_);

}

void Ret::accept(Visitor *v)
{
  v->visitRet(this);
}

Ret *Ret::clone() const
{
  return new Ret(*this);
}



/********************   VRet    ********************/
VRet::VRet()
{

}

VRet::VRet(const VRet & other)
{

}

VRet &VRet::operator=(const VRet & other)
{
  VRet tmp(other);
  swap(tmp);
  return *this;
}

void VRet::swap(VRet & other)
{

}

VRet::~VRet()
{

}

void VRet::accept(Visitor *v)
{
  v->visitVRet(this);
}

VRet *VRet::clone() const
{
  return new VRet(*this);
}



/********************   Cond    ********************/
Cond::Cond(Expr *p1, Stmt *p2)
{
  expr_ = p1;
  stmt_ = p2;

}

Cond::Cond(const Cond & other)
{
  expr_ = other.expr_->clone();
  stmt_ = other.stmt_->clone();

}

Cond &Cond::operator=(const Cond & other)
{
  Cond tmp(other);
  swap(tmp);
  return *this;
}

void Cond::swap(Cond & other)
{
  std::swap(expr_, other.expr_);
  std::swap(stmt_, other.stmt_);

}

Cond::~Cond()
{
  delete(expr_);
  delete(stmt_);

}

void Cond::accept(Visitor *v)
{
  v->visitCond(this);
}

Cond *Cond::clone() const
{
  return new Cond(*this);
}



/********************   CondElse    ********************/
CondElse::CondElse(Expr *p1, Stmt *p2, Stmt *p3)
{
  expr_ = p1;
  stmt_1 = p2;
  stmt_2 = p3;

}

CondElse::CondElse(const CondElse & other)
{
  expr_ = other.expr_->clone();
  stmt_1 = other.stmt_1->clone();
  stmt_2 = other.stmt_2->clone();

}

CondElse &CondElse::operator=(const CondElse & other)
{
  CondElse tmp(other);
  swap(tmp);
  return *this;
}

void CondElse::swap(CondElse & other)
{
  std::swap(expr_, other.expr_);
  std::swap(stmt_1, other.stmt_1);
  std::swap(stmt_2, other.stmt_2);

}

CondElse::~CondElse()
{
  delete(expr_);
  delete(stmt_1);
  delete(stmt_2);

}

void CondElse::accept(Visitor *v)
{
  v->visitCondElse(this);
}

CondElse *CondElse::clone() const
{
  return new CondElse(*this);
}



/********************   While    ********************/
While::While(Expr *p1, Stmt *p2)
{
  expr_ = p1;
  stmt_ = p2;

}

While::While(const While & other)
{
  expr_ = other.expr_->clone();
  stmt_ = other.stmt_->clone();

}

While &While::operator=(const While & other)
{
  While tmp(other);
  swap(tmp);
  return *this;
}

void While::swap(While & other)
{
  std::swap(expr_, other.expr_);
  std::swap(stmt_, other.stmt_);

}

While::~While()
{
  delete(expr_);
  delete(stmt_);

}

void While::accept(Visitor *v)
{
  v->visitWhile(this);
}

While *While::clone() const
{
  return new While(*this);
}



/********************   ForLoop    ********************/
ForLoop::ForLoop(Type *p1, Ident p2, Expr *p3, Stmt *p4)
{
  type_ = p1;
  ident_ = p2;
  expr_ = p3;
  stmt_ = p4;

}

ForLoop::ForLoop(const ForLoop & other)
{
  type_ = other.type_->clone();
  ident_ = other.ident_;
  expr_ = other.expr_->clone();
  stmt_ = other.stmt_->clone();

}

ForLoop &ForLoop::operator=(const ForLoop & other)
{
  ForLoop tmp(other);
  swap(tmp);
  return *this;
}

void ForLoop::swap(ForLoop & other)
{
  std::swap(type_, other.type_);
  std::swap(ident_, other.ident_);
  std::swap(expr_, other.expr_);
  std::swap(stmt_, other.stmt_);

}

ForLoop::~ForLoop()
{
  delete(type_);
  delete(expr_);
  delete(stmt_);

}

void ForLoop::accept(Visitor *v)
{
  v->visitForLoop(this);
}

ForLoop *ForLoop::clone() const
{
  return new ForLoop(*this);
}



/********************   NoInit    ********************/
NoInit::NoInit(Ident p1)
{
  ident_ = p1;

}

NoInit::NoInit(const NoInit & other)
{
  ident_ = other.ident_;

}

NoInit &NoInit::operator=(const NoInit & other)
{
  NoInit tmp(other);
  swap(tmp);
  return *this;
}

void NoInit::swap(NoInit & other)
{
  std::swap(ident_, other.ident_);

}

NoInit::~NoInit()
{

}

void NoInit::accept(Visitor *v)
{
  v->visitNoInit(this);
}

NoInit *NoInit::clone() const
{
  return new NoInit(*this);
}



/********************   Init    ********************/
Init::Init(Ident p1, Expr *p2)
{
  ident_ = p1;
  expr_ = p2;

}

Init::Init(const Init & other)
{
  ident_ = other.ident_;
  expr_ = other.expr_->clone();

}

Init &Init::operator=(const Init & other)
{
  Init tmp(other);
  swap(tmp);
  return *this;
}

void Init::swap(Init & other)
{
  std::swap(ident_, other.ident_);
  std::swap(expr_, other.expr_);

}

Init::~Init()
{
  delete(expr_);

}

void Init::accept(Visitor *v)
{
  v->visitInit(this);
}

Init *Init::clone() const
{
  return new Init(*this);
}



/********************   Ecast    ********************/
Ecast::Ecast(Type *p1, Expr *p2)
{
  type_ = p1;
  expr_ = p2;

}

Ecast::Ecast(const Ecast & other)
{
  type_ = other.type_->clone();
  expr_ = other.expr_->clone();

}

Ecast &Ecast::operator=(const Ecast & other)
{
  Ecast tmp(other);
  swap(tmp);
  return *this;
}

void Ecast::swap(Ecast & other)
{
  std::swap(type_, other.type_);
  std::swap(expr_, other.expr_);

}

Ecast::~Ecast()
{
  delete(type_);
  delete(expr_);

}

void Ecast::accept(Visitor *v)
{
  v->visitEcast(this);
}

Ecast *Ecast::clone() const
{
  return new Ecast(*this);
}



/********************   ELitNull    ********************/
ELitNull::ELitNull()
{

}

ELitNull::ELitNull(const ELitNull & other)
{

}

ELitNull &ELitNull::operator=(const ELitNull & other)
{
  ELitNull tmp(other);
  swap(tmp);
  return *this;
}

void ELitNull::swap(ELitNull & other)
{

}

ELitNull::~ELitNull()
{

}

void ELitNull::accept(Visitor *v)
{
  v->visitELitNull(this);
}

ELitNull *ELitNull::clone() const
{
  return new ELitNull(*this);
}



/********************   ELitInt    ********************/
ELitInt::ELitInt(Integer p1)
{
  integer_ = p1;

}

ELitInt::ELitInt(const ELitInt & other)
{
  integer_ = other.integer_;

}

ELitInt &ELitInt::operator=(const ELitInt & other)
{
  ELitInt tmp(other);
  swap(tmp);
  return *this;
}

void ELitInt::swap(ELitInt & other)
{
  std::swap(integer_, other.integer_);

}

ELitInt::~ELitInt()
{

}

void ELitInt::accept(Visitor *v)
{
  v->visitELitInt(this);
}

ELitInt *ELitInt::clone() const
{
  return new ELitInt(*this);
}



/********************   ELitDoub    ********************/
ELitDoub::ELitDoub(Double p1)
{
  double_ = p1;

}

ELitDoub::ELitDoub(const ELitDoub & other)
{
  double_ = other.double_;

}

ELitDoub &ELitDoub::operator=(const ELitDoub & other)
{
  ELitDoub tmp(other);
  swap(tmp);
  return *this;
}

void ELitDoub::swap(ELitDoub & other)
{
  std::swap(double_, other.double_);

}

ELitDoub::~ELitDoub()
{

}

void ELitDoub::accept(Visitor *v)
{
  v->visitELitDoub(this);
}

ELitDoub *ELitDoub::clone() const
{
  return new ELitDoub(*this);
}



/********************   ELitTrue    ********************/
ELitTrue::ELitTrue()
{

}

ELitTrue::ELitTrue(const ELitTrue & other)
{

}

ELitTrue &ELitTrue::operator=(const ELitTrue & other)
{
  ELitTrue tmp(other);
  swap(tmp);
  return *this;
}

void ELitTrue::swap(ELitTrue & other)
{

}

ELitTrue::~ELitTrue()
{

}

void ELitTrue::accept(Visitor *v)
{
  v->visitELitTrue(this);
}

ELitTrue *ELitTrue::clone() const
{
  return new ELitTrue(*this);
}



/********************   ELitFalse    ********************/
ELitFalse::ELitFalse()
{

}

ELitFalse::ELitFalse(const ELitFalse & other)
{

}

ELitFalse &ELitFalse::operator=(const ELitFalse & other)
{
  ELitFalse tmp(other);
  swap(tmp);
  return *this;
}

void ELitFalse::swap(ELitFalse & other)
{

}

ELitFalse::~ELitFalse()
{

}

void ELitFalse::accept(Visitor *v)
{
  v->visitELitFalse(this);
}

ELitFalse *ELitFalse::clone() const
{
  return new ELitFalse(*this);
}



/********************   EString    ********************/
EString::EString(String p1)
{
  string_ = p1;

}

EString::EString(const EString & other)
{
  string_ = other.string_;

}

EString &EString::operator=(const EString & other)
{
  EString tmp(other);
  swap(tmp);
  return *this;
}

void EString::swap(EString & other)
{
  std::swap(string_, other.string_);

}

EString::~EString()
{

}

void EString::accept(Visitor *v)
{
  v->visitEString(this);
}

EString *EString::clone() const
{
  return new EString(*this);
}



/********************   EVar    ********************/
EVar::EVar(Ident p1)
{
  ident_ = p1;

}

EVar::EVar(const EVar & other)
{
  ident_ = other.ident_;

}

EVar &EVar::operator=(const EVar & other)
{
  EVar tmp(other);
  swap(tmp);
  return *this;
}

void EVar::swap(EVar & other)
{
  std::swap(ident_, other.ident_);

}

EVar::~EVar()
{

}

void EVar::accept(Visitor *v)
{
  v->visitEVar(this);
}

EVar *EVar::clone() const
{
  return new EVar(*this);
}



/********************   EApp    ********************/
EApp::EApp(Ident p1, ListExpr *p2)
{
  ident_ = p1;
  listexpr_ = p2;

}

EApp::EApp(const EApp & other)
{
  ident_ = other.ident_;
  listexpr_ = other.listexpr_->clone();

}

EApp &EApp::operator=(const EApp & other)
{
  EApp tmp(other);
  swap(tmp);
  return *this;
}

void EApp::swap(EApp & other)
{
  std::swap(ident_, other.ident_);
  std::swap(listexpr_, other.listexpr_);

}

EApp::~EApp()
{
  delete(listexpr_);

}

void EApp::accept(Visitor *v)
{
  v->visitEApp(this);
}

EApp *EApp::clone() const
{
  return new EApp(*this);
}



/********************   ENewObj    ********************/
ENewObj::ENewObj(OType *p1)
{
  otype_ = p1;

}

ENewObj::ENewObj(const ENewObj & other)
{
  otype_ = other.otype_->clone();

}

ENewObj &ENewObj::operator=(const ENewObj & other)
{
  ENewObj tmp(other);
  swap(tmp);
  return *this;
}

void ENewObj::swap(ENewObj & other)
{
  std::swap(otype_, other.otype_);

}

ENewObj::~ENewObj()
{
  delete(otype_);

}

void ENewObj::accept(Visitor *v)
{
  v->visitENewObj(this);
}

ENewObj *ENewObj::clone() const
{
  return new ENewObj(*this);
}



/********************   EArrow    ********************/
EArrow::EArrow(Expr *p1, Ident p2)
{
  expr_ = p1;
  ident_ = p2;

}

EArrow::EArrow(const EArrow & other)
{
  expr_ = other.expr_->clone();
  ident_ = other.ident_;

}

EArrow &EArrow::operator=(const EArrow & other)
{
  EArrow tmp(other);
  swap(tmp);
  return *this;
}

void EArrow::swap(EArrow & other)
{
  std::swap(expr_, other.expr_);
  std::swap(ident_, other.ident_);

}

EArrow::~EArrow()
{
  delete(expr_);

}

void EArrow::accept(Visitor *v)
{
  v->visitEArrow(this);
}

EArrow *EArrow::clone() const
{
  return new EArrow(*this);
}



/********************   Epropety    ********************/
Epropety::Epropety(Expr *p1, Ident p2)
{
  expr_ = p1;
  ident_ = p2;

}

Epropety::Epropety(const Epropety & other)
{
  expr_ = other.expr_->clone();
  ident_ = other.ident_;

}

Epropety &Epropety::operator=(const Epropety & other)
{
  Epropety tmp(other);
  swap(tmp);
  return *this;
}

void Epropety::swap(Epropety & other)
{
  std::swap(expr_, other.expr_);
  std::swap(ident_, other.ident_);

}

Epropety::~Epropety()
{
  delete(expr_);

}

void Epropety::accept(Visitor *v)
{
  v->visitEpropety(this);
}

Epropety *Epropety::clone() const
{
  return new Epropety(*this);
}



/********************   EFunc    ********************/
EFunc::EFunc(Expr *p1, Ident p2, ListExpr *p3)
{
  expr_ = p1;
  ident_ = p2;
  listexpr_ = p3;

}

EFunc::EFunc(const EFunc & other)
{
  expr_ = other.expr_->clone();
  ident_ = other.ident_;
  listexpr_ = other.listexpr_->clone();

}

EFunc &EFunc::operator=(const EFunc & other)
{
  EFunc tmp(other);
  swap(tmp);
  return *this;
}

void EFunc::swap(EFunc & other)
{
  std::swap(expr_, other.expr_);
  std::swap(ident_, other.ident_);
  std::swap(listexpr_, other.listexpr_);

}

EFunc::~EFunc()
{
  delete(expr_);
  delete(listexpr_);

}

void EFunc::accept(Visitor *v)
{
  v->visitEFunc(this);
}

EFunc *EFunc::clone() const
{
  return new EFunc(*this);
}



/********************   ENewBArr    ********************/
ENewBArr::ENewBArr(BType *p1, ListDimExpr *p2)
{
  btype_ = p1;
  listdimexpr_ = p2;

}

ENewBArr::ENewBArr(const ENewBArr & other)
{
  btype_ = other.btype_->clone();
  listdimexpr_ = other.listdimexpr_->clone();

}

ENewBArr &ENewBArr::operator=(const ENewBArr & other)
{
  ENewBArr tmp(other);
  swap(tmp);
  return *this;
}

void ENewBArr::swap(ENewBArr & other)
{
  std::swap(btype_, other.btype_);
  std::swap(listdimexpr_, other.listdimexpr_);

}

ENewBArr::~ENewBArr()
{
  delete(btype_);
  delete(listdimexpr_);

}

void ENewBArr::accept(Visitor *v)
{
  v->visitENewBArr(this);
}

ENewBArr *ENewBArr::clone() const
{
  return new ENewBArr(*this);
}



/********************   ENewOArr    ********************/
ENewOArr::ENewOArr(OType *p1, ListDimExpr *p2)
{
  otype_ = p1;
  listdimexpr_ = p2;

}

ENewOArr::ENewOArr(const ENewOArr & other)
{
  otype_ = other.otype_->clone();
  listdimexpr_ = other.listdimexpr_->clone();

}

ENewOArr &ENewOArr::operator=(const ENewOArr & other)
{
  ENewOArr tmp(other);
  swap(tmp);
  return *this;
}

void ENewOArr::swap(ENewOArr & other)
{
  std::swap(otype_, other.otype_);
  std::swap(listdimexpr_, other.listdimexpr_);

}

ENewOArr::~ENewOArr()
{
  delete(otype_);
  delete(listdimexpr_);

}

void ENewOArr::accept(Visitor *v)
{
  v->visitENewOArr(this);
}

ENewOArr *ENewOArr::clone() const
{
  return new ENewOArr(*this);
}



/********************   EAcc    ********************/
EAcc::EAcc(Expr *p1, ListDimExpr *p2)
{
  expr_ = p1;
  listdimexpr_ = p2;

}

EAcc::EAcc(const EAcc & other)
{
  expr_ = other.expr_->clone();
  listdimexpr_ = other.listdimexpr_->clone();

}

EAcc &EAcc::operator=(const EAcc & other)
{
  EAcc tmp(other);
  swap(tmp);
  return *this;
}

void EAcc::swap(EAcc & other)
{
  std::swap(expr_, other.expr_);
  std::swap(listdimexpr_, other.listdimexpr_);

}

EAcc::~EAcc()
{
  delete(expr_);
  delete(listdimexpr_);

}

void EAcc::accept(Visitor *v)
{
  v->visitEAcc(this);
}

EAcc *EAcc::clone() const
{
  return new EAcc(*this);
}



/********************   EInc    ********************/
EInc::EInc(Expr *p1)
{
  expr_ = p1;

}

EInc::EInc(const EInc & other)
{
  expr_ = other.expr_->clone();

}

EInc &EInc::operator=(const EInc & other)
{
  EInc tmp(other);
  swap(tmp);
  return *this;
}

void EInc::swap(EInc & other)
{
  std::swap(expr_, other.expr_);

}

EInc::~EInc()
{
  delete(expr_);

}

void EInc::accept(Visitor *v)
{
  v->visitEInc(this);
}

EInc *EInc::clone() const
{
  return new EInc(*this);
}



/********************   EDecr    ********************/
EDecr::EDecr(Expr *p1)
{
  expr_ = p1;

}

EDecr::EDecr(const EDecr & other)
{
  expr_ = other.expr_->clone();

}

EDecr &EDecr::operator=(const EDecr & other)
{
  EDecr tmp(other);
  swap(tmp);
  return *this;
}

void EDecr::swap(EDecr & other)
{
  std::swap(expr_, other.expr_);

}

EDecr::~EDecr()
{
  delete(expr_);

}

void EDecr::accept(Visitor *v)
{
  v->visitEDecr(this);
}

EDecr *EDecr::clone() const
{
  return new EDecr(*this);
}



/********************   ENeg    ********************/
ENeg::ENeg(Expr *p1)
{
  expr_ = p1;

}

ENeg::ENeg(const ENeg & other)
{
  expr_ = other.expr_->clone();

}

ENeg &ENeg::operator=(const ENeg & other)
{
  ENeg tmp(other);
  swap(tmp);
  return *this;
}

void ENeg::swap(ENeg & other)
{
  std::swap(expr_, other.expr_);

}

ENeg::~ENeg()
{
  delete(expr_);

}

void ENeg::accept(Visitor *v)
{
  v->visitENeg(this);
}

ENeg *ENeg::clone() const
{
  return new ENeg(*this);
}



/********************   ENot    ********************/
ENot::ENot(Expr *p1)
{
  expr_ = p1;

}

ENot::ENot(const ENot & other)
{
  expr_ = other.expr_->clone();

}

ENot &ENot::operator=(const ENot & other)
{
  ENot tmp(other);
  swap(tmp);
  return *this;
}

void ENot::swap(ENot & other)
{
  std::swap(expr_, other.expr_);

}

ENot::~ENot()
{
  delete(expr_);

}

void ENot::accept(Visitor *v)
{
  v->visitENot(this);
}

ENot *ENot::clone() const
{
  return new ENot(*this);
}



/********************   EMul    ********************/
EMul::EMul(Expr *p1, MulOp *p2, Expr *p3)
{
  expr_1 = p1;
  mulop_ = p2;
  expr_2 = p3;

}

EMul::EMul(const EMul & other)
{
  expr_1 = other.expr_1->clone();
  mulop_ = other.mulop_->clone();
  expr_2 = other.expr_2->clone();

}

EMul &EMul::operator=(const EMul & other)
{
  EMul tmp(other);
  swap(tmp);
  return *this;
}

void EMul::swap(EMul & other)
{
  std::swap(expr_1, other.expr_1);
  std::swap(mulop_, other.mulop_);
  std::swap(expr_2, other.expr_2);

}

EMul::~EMul()
{
  delete(expr_1);
  delete(mulop_);
  delete(expr_2);

}

void EMul::accept(Visitor *v)
{
  v->visitEMul(this);
}

EMul *EMul::clone() const
{
  return new EMul(*this);
}



/********************   EAdd    ********************/
EAdd::EAdd(Expr *p1, AddOp *p2, Expr *p3)
{
  expr_1 = p1;
  addop_ = p2;
  expr_2 = p3;

}

EAdd::EAdd(const EAdd & other)
{
  expr_1 = other.expr_1->clone();
  addop_ = other.addop_->clone();
  expr_2 = other.expr_2->clone();

}

EAdd &EAdd::operator=(const EAdd & other)
{
  EAdd tmp(other);
  swap(tmp);
  return *this;
}

void EAdd::swap(EAdd & other)
{
  std::swap(expr_1, other.expr_1);
  std::swap(addop_, other.addop_);
  std::swap(expr_2, other.expr_2);

}

EAdd::~EAdd()
{
  delete(expr_1);
  delete(addop_);
  delete(expr_2);

}

void EAdd::accept(Visitor *v)
{
  v->visitEAdd(this);
}

EAdd *EAdd::clone() const
{
  return new EAdd(*this);
}



/********************   ERel    ********************/
ERel::ERel(Expr *p1, RelOp *p2, Expr *p3)
{
  expr_1 = p1;
  relop_ = p2;
  expr_2 = p3;

}

ERel::ERel(const ERel & other)
{
  expr_1 = other.expr_1->clone();
  relop_ = other.relop_->clone();
  expr_2 = other.expr_2->clone();

}

ERel &ERel::operator=(const ERel & other)
{
  ERel tmp(other);
  swap(tmp);
  return *this;
}

void ERel::swap(ERel & other)
{
  std::swap(expr_1, other.expr_1);
  std::swap(relop_, other.relop_);
  std::swap(expr_2, other.expr_2);

}

ERel::~ERel()
{
  delete(expr_1);
  delete(relop_);
  delete(expr_2);

}

void ERel::accept(Visitor *v)
{
  v->visitERel(this);
}

ERel *ERel::clone() const
{
  return new ERel(*this);
}



/********************   EAnd    ********************/
EAnd::EAnd(Expr *p1, Expr *p2)
{
  expr_1 = p1;
  expr_2 = p2;

}

EAnd::EAnd(const EAnd & other)
{
  expr_1 = other.expr_1->clone();
  expr_2 = other.expr_2->clone();

}

EAnd &EAnd::operator=(const EAnd & other)
{
  EAnd tmp(other);
  swap(tmp);
  return *this;
}

void EAnd::swap(EAnd & other)
{
  std::swap(expr_1, other.expr_1);
  std::swap(expr_2, other.expr_2);

}

EAnd::~EAnd()
{
  delete(expr_1);
  delete(expr_2);

}

void EAnd::accept(Visitor *v)
{
  v->visitEAnd(this);
}

EAnd *EAnd::clone() const
{
  return new EAnd(*this);
}



/********************   EOr    ********************/
EOr::EOr(Expr *p1, Expr *p2)
{
  expr_1 = p1;
  expr_2 = p2;

}

EOr::EOr(const EOr & other)
{
  expr_1 = other.expr_1->clone();
  expr_2 = other.expr_2->clone();

}

EOr &EOr::operator=(const EOr & other)
{
  EOr tmp(other);
  swap(tmp);
  return *this;
}

void EOr::swap(EOr & other)
{
  std::swap(expr_1, other.expr_1);
  std::swap(expr_2, other.expr_2);

}

EOr::~EOr()
{
  delete(expr_1);
  delete(expr_2);

}

void EOr::accept(Visitor *v)
{
  v->visitEOr(this);
}

EOr *EOr::clone() const
{
  return new EOr(*this);
}



/********************   Dim    ********************/
Dim::Dim(Expr *p1)
{
  expr_ = p1;

}

Dim::Dim(const Dim & other)
{
  expr_ = other.expr_->clone();

}

Dim &Dim::operator=(const Dim & other)
{
  Dim tmp(other);
  swap(tmp);
  return *this;
}

void Dim::swap(Dim & other)
{
  std::swap(expr_, other.expr_);

}

Dim::~Dim()
{
  delete(expr_);

}

void Dim::accept(Visitor *v)
{
  v->visitDim(this);
}

Dim *Dim::clone() const
{
  return new Dim(*this);
}



/********************   Plus    ********************/
Plus::Plus()
{

}

Plus::Plus(const Plus & other)
{

}

Plus &Plus::operator=(const Plus & other)
{
  Plus tmp(other);
  swap(tmp);
  return *this;
}

void Plus::swap(Plus & other)
{

}

Plus::~Plus()
{

}

void Plus::accept(Visitor *v)
{
  v->visitPlus(this);
}

Plus *Plus::clone() const
{
  return new Plus(*this);
}



/********************   Minus    ********************/
Minus::Minus()
{

}

Minus::Minus(const Minus & other)
{

}

Minus &Minus::operator=(const Minus & other)
{
  Minus tmp(other);
  swap(tmp);
  return *this;
}

void Minus::swap(Minus & other)
{

}

Minus::~Minus()
{

}

void Minus::accept(Visitor *v)
{
  v->visitMinus(this);
}

Minus *Minus::clone() const
{
  return new Minus(*this);
}



/********************   Times    ********************/
Times::Times()
{

}

Times::Times(const Times & other)
{

}

Times &Times::operator=(const Times & other)
{
  Times tmp(other);
  swap(tmp);
  return *this;
}

void Times::swap(Times & other)
{

}

Times::~Times()
{

}

void Times::accept(Visitor *v)
{
  v->visitTimes(this);
}

Times *Times::clone() const
{
  return new Times(*this);
}



/********************   Div    ********************/
Div::Div()
{

}

Div::Div(const Div & other)
{

}

Div &Div::operator=(const Div & other)
{
  Div tmp(other);
  swap(tmp);
  return *this;
}

void Div::swap(Div & other)
{

}

Div::~Div()
{

}

void Div::accept(Visitor *v)
{
  v->visitDiv(this);
}

Div *Div::clone() const
{
  return new Div(*this);
}



/********************   Mod    ********************/
Mod::Mod()
{

}

Mod::Mod(const Mod & other)
{

}

Mod &Mod::operator=(const Mod & other)
{
  Mod tmp(other);
  swap(tmp);
  return *this;
}

void Mod::swap(Mod & other)
{

}

Mod::~Mod()
{

}

void Mod::accept(Visitor *v)
{
  v->visitMod(this);
}

Mod *Mod::clone() const
{
  return new Mod(*this);
}



/********************   LTH    ********************/
LTH::LTH()
{

}

LTH::LTH(const LTH & other)
{

}

LTH &LTH::operator=(const LTH & other)
{
  LTH tmp(other);
  swap(tmp);
  return *this;
}

void LTH::swap(LTH & other)
{

}

LTH::~LTH()
{

}

void LTH::accept(Visitor *v)
{
  v->visitLTH(this);
}

LTH *LTH::clone() const
{
  return new LTH(*this);
}



/********************   LE    ********************/
LE::LE()
{

}

LE::LE(const LE & other)
{

}

LE &LE::operator=(const LE & other)
{
  LE tmp(other);
  swap(tmp);
  return *this;
}

void LE::swap(LE & other)
{

}

LE::~LE()
{

}

void LE::accept(Visitor *v)
{
  v->visitLE(this);
}

LE *LE::clone() const
{
  return new LE(*this);
}



/********************   GTH    ********************/
GTH::GTH()
{

}

GTH::GTH(const GTH & other)
{

}

GTH &GTH::operator=(const GTH & other)
{
  GTH tmp(other);
  swap(tmp);
  return *this;
}

void GTH::swap(GTH & other)
{

}

GTH::~GTH()
{

}

void GTH::accept(Visitor *v)
{
  v->visitGTH(this);
}

GTH *GTH::clone() const
{
  return new GTH(*this);
}



/********************   GE    ********************/
GE::GE()
{

}

GE::GE(const GE & other)
{

}

GE &GE::operator=(const GE & other)
{
  GE tmp(other);
  swap(tmp);
  return *this;
}

void GE::swap(GE & other)
{

}

GE::~GE()
{

}

void GE::accept(Visitor *v)
{
  v->visitGE(this);
}

GE *GE::clone() const
{
  return new GE(*this);
}



/********************   EQU    ********************/
EQU::EQU()
{

}

EQU::EQU(const EQU & other)
{

}

EQU &EQU::operator=(const EQU & other)
{
  EQU tmp(other);
  swap(tmp);
  return *this;
}

void EQU::swap(EQU & other)
{

}

EQU::~EQU()
{

}

void EQU::accept(Visitor *v)
{
  v->visitEQU(this);
}

EQU *EQU::clone() const
{
  return new EQU(*this);
}



/********************   NE    ********************/
NE::NE()
{

}

NE::NE(const NE & other)
{

}

NE &NE::operator=(const NE & other)
{
  NE tmp(other);
  swap(tmp);
  return *this;
}

void NE::swap(NE & other)
{

}

NE::~NE()
{

}

void NE::accept(Visitor *v)
{
  v->visitNE(this);
}

NE *NE::clone() const
{
  return new NE(*this);
}




/********************   ListEVal    ********************/

void ListEVal::accept(Visitor *v)
{
  v->visitListEVal(this);
}

ListEVal *ListEVal::clone() const
{
  return new ListEVal(*this);
}

ListEVal* consListEVal(EVal* x, ListEVal* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListArg    ********************/

void ListArg::accept(Visitor *v)
{
  v->visitListArg(this);
}

ListArg *ListArg::clone() const
{
  return new ListArg(*this);
}

ListArg* consListArg(Arg* x, ListArg* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListTopDef    ********************/

void ListTopDef::accept(Visitor *v)
{
  v->visitListTopDef(this);
}

ListTopDef *ListTopDef::clone() const
{
  return new ListTopDef(*this);
}

ListTopDef* consListTopDef(TopDef* x, ListTopDef* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListBracketsOpt    ********************/

void ListBracketsOpt::accept(Visitor *v)
{
  v->visitListBracketsOpt(this);
}

ListBracketsOpt *ListBracketsOpt::clone() const
{
  return new ListBracketsOpt(*this);
}

ListBracketsOpt* consListBracketsOpt(BracketsOpt* x, ListBracketsOpt* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListType    ********************/

void ListType::accept(Visitor *v)
{
  v->visitListType(this);
}

ListType *ListType::clone() const
{
  return new ListType(*this);
}

ListType* consListType(Type* x, ListType* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListMemItem    ********************/

void ListMemItem::accept(Visitor *v)
{
  v->visitListMemItem(this);
}

ListMemItem *ListMemItem::clone() const
{
  return new ListMemItem(*this);
}

ListMemItem* consListMemItem(MemItem* x, ListMemItem* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListMemdef    ********************/

void ListMemdef::accept(Visitor *v)
{
  v->visitListMemdef(this);
}

ListMemdef *ListMemdef::clone() const
{
  return new ListMemdef(*this);
}

ListMemdef* consListMemdef(Memdef* x, ListMemdef* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListCMemdef    ********************/

void ListCMemdef::accept(Visitor *v)
{
  v->visitListCMemdef(this);
}

ListCMemdef *ListCMemdef::clone() const
{
  return new ListCMemdef(*this);
}

ListCMemdef* consListCMemdef(CMemdef* x, ListCMemdef* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListStmt    ********************/

void ListStmt::accept(Visitor *v)
{
  v->visitListStmt(this);
}

ListStmt *ListStmt::clone() const
{
  return new ListStmt(*this);
}

ListStmt* consListStmt(Stmt* x, ListStmt* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListItem    ********************/

void ListItem::accept(Visitor *v)
{
  v->visitListItem(this);
}

ListItem *ListItem::clone() const
{
  return new ListItem(*this);
}

ListItem* consListItem(Item* x, ListItem* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListDimExpr    ********************/

void ListDimExpr::accept(Visitor *v)
{
  v->visitListDimExpr(this);
}

ListDimExpr *ListDimExpr::clone() const
{
  return new ListDimExpr(*this);
}

ListDimExpr* consListDimExpr(DimExpr* x, ListDimExpr* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}


/********************   ListExpr    ********************/

void ListExpr::accept(Visitor *v)
{
  v->visitListExpr(this);
}

ListExpr *ListExpr::clone() const
{
  return new ListExpr(*this);
}

ListExpr* consListExpr(Expr* x, ListExpr* xs) {
  xs->insert(xs->begin(), x);
  return xs;
}