Absyn.C.bak

//C++ Abstract Syntax Implementation generated by the BNF Converter.
#include <algorithm>
#include <string>
#include <iostream>
#include <vector>
#include "Absyn.H"

/********************   PDefs    ********************/
PDefs::PDefs(ListDef *p1)
{
  listdef_ = p1;

}

PDefs::PDefs(const PDefs & other)
{
  listdef_ = other.listdef_->clone();

}

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

void PDefs::swap(PDefs & other)
{
  std::swap(listdef_, other.listdef_);

}

PDefs::~PDefs()
{
  delete(listdef_);

}

void PDefs::accept(Visitor *v)
{
  v->visitPDefs(this);
}

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



/********************   DFun    ********************/
DFun::DFun(Id p1, ListArg *p2, ListStm *p3)
{
  id_ = p1;
  listarg_ = p2;
  liststm_ = p3;

}

DFun::DFun(const DFun & other)
{
  id_ = other.id_;
  listarg_ = other.listarg_->clone();
  liststm_ = other.liststm_->clone();

}

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

void DFun::swap(DFun & other)
{
  std::swap(id_, other.id_);
  std::swap(listarg_, other.listarg_);
  std::swap(liststm_, other.liststm_);

}

DFun::~DFun()
{
  delete(listarg_);
  delete(liststm_);

}

void DFun::accept(Visitor *v)
{
  v->visitDFun(this);
}

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



/********************   DMember    ********************/
DMember::DMember(Id p1)
{
  id_ = p1;

}

DMember::DMember(const DMember & other)
{
  id_ = other.id_;

}

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

void DMember::swap(DMember & other)
{
  std::swap(id_, other.id_);

}

DMember::~DMember()
{

}

void DMember::accept(Visitor *v)
{
  v->visitDMember(this);
}

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



/********************   DClass    ********************/
DClass::DClass(Id p1, Id p2, ListDmem *p3, ListDfn *p4)
{
  id_1 = p1;
  id_2 = p2;
  listdmem_ = p3;
  listdfn_ = p4;

}

DClass::DClass(const DClass & other)
{
  id_1 = other.id_1;
  id_2 = other.id_2;
  listdmem_ = other.listdmem_->clone();
  listdfn_ = other.listdfn_->clone();

}

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

void DClass::swap(DClass & other)
{
  std::swap(id_1, other.id_1);
  std::swap(id_2, other.id_2);
  std::swap(listdmem_, other.listdmem_);
  std::swap(listdfn_, other.listdfn_);

}

DClass::~DClass()
{
  delete(listdmem_);
  delete(listdfn_);

}

void DClass::accept(Visitor *v)
{
  v->visitDClass(this);
}

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



/********************   ADecl    ********************/
ADecl::ADecl(Id p1)
{
  id_ = p1;

}

ADecl::ADecl(const ADecl & other)
{
  id_ = other.id_;

}

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

void ADecl::swap(ADecl & other)
{
  std::swap(id_, other.id_);

}

ADecl::~ADecl()
{

}

void ADecl::accept(Visitor *v)
{
  v->visitADecl(this);
}

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



/********************   SExp    ********************/
SExp::SExp(Exp *p1)
{
  exp_ = p1;

}

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

}

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

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

}

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

}

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

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



/********************   SInit    ********************/
SInit::SInit(Id p1, Exp *p2)
{
  id_ = p1;
  exp_ = p2;

}

SInit::SInit(const SInit & other)
{
  id_ = other.id_;
  exp_ = other.exp_->clone();

}

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

void SInit::swap(SInit & other)
{
  std::swap(id_, other.id_);
  std::swap(exp_, other.exp_);

}

SInit::~SInit()
{
  delete(exp_);

}

void SInit::accept(Visitor *v)
{
  v->visitSInit(this);
}

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



/********************   SMemInit    ********************/
SMemInit::SMemInit(Id p1, Id p2, Exp *p3)
{
  id_1 = p1;
  id_2 = p2;
  exp_ = p3;

}

SMemInit::SMemInit(const SMemInit & other)
{
  id_1 = other.id_1;
  id_2 = other.id_2;
  exp_ = other.exp_->clone();

}

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

void SMemInit::swap(SMemInit & other)
{
  std::swap(id_1, other.id_1);
  std::swap(id_2, other.id_2);
  std::swap(exp_, other.exp_);

}

SMemInit::~SMemInit()
{
  delete(exp_);

}

void SMemInit::accept(Visitor *v)
{
  v->visitSMemInit(this);
}

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



/********************   SReturn    ********************/
SReturn::SReturn(Exp *p1)
{
  exp_ = p1;

}

SReturn::SReturn(const SReturn & other)
{
  exp_ = other.exp_->clone();

}

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

void SReturn::swap(SReturn & other)
{
  std::swap(exp_, other.exp_);

}

SReturn::~SReturn()
{
  delete(exp_);

}

void SReturn::accept(Visitor *v)
{
  v->visitSReturn(this);
}

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



/********************   SWhile    ********************/
SWhile::SWhile(Exp *p1, ListStm *p2)
{
  exp_ = p1;
  liststm_ = p2;

}

SWhile::SWhile(const SWhile & other)
{
  exp_ = other.exp_->clone();
  liststm_ = other.liststm_->clone();

}

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

void SWhile::swap(SWhile & other)
{
  std::swap(exp_, other.exp_);
  std::swap(liststm_, other.liststm_);

}

SWhile::~SWhile()
{
  delete(exp_);
  delete(liststm_);

}

void SWhile::accept(Visitor *v)
{
  v->visitSWhile(this);
}

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



/********************   SIfElse    ********************/
SIfElse::SIfElse(Exp *p1, ListStm *p2, ListStm *p3)
{
  exp_ = p1;
  liststm_1 = p2;
  liststm_2 = p3;

}

SIfElse::SIfElse(const SIfElse & other)
{
  exp_ = other.exp_->clone();
  liststm_1 = other.liststm_1->clone();
  liststm_2 = other.liststm_2->clone();

}

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

void SIfElse::swap(SIfElse & other)
{
  std::swap(exp_, other.exp_);
  std::swap(liststm_1, other.liststm_1);
  std::swap(liststm_2, other.liststm_2);

}

SIfElse::~SIfElse()
{
  delete(exp_);
  delete(liststm_1);
  delete(liststm_2);

}

void SIfElse::accept(Visitor *v)
{
  v->visitSIfElse(this);
}

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



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

}

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

}

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

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

}

EInt::~EInt()
{

}

void EInt::accept(Visitor *v)
{
  v->visitEInt(this);
}

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



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

}

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

}

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

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

}

EDouble::~EDouble()
{

}

void EDouble::accept(Visitor *v)
{
  v->visitEDouble(this);
}

EDouble *EDouble::clone() const
{
  return new EDouble(*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);
}



/********************   EId    ********************/
EId::EId(Id p1)
{
  id_ = p1;

}

EId::EId(const EId & other)
{
  id_ = other.id_;

}

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

void EId::swap(EId & other)
{
  std::swap(id_, other.id_);

}

EId::~EId()
{

}

void EId::accept(Visitor *v)
{
  v->visitEId(this);
}

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



/********************   EApp    ********************/
EApp::EApp(Id p1, ListExp *p2)
{
  id_ = p1;
  listexp_ = p2;

}

EApp::EApp(const EApp & other)
{
  id_ = other.id_;
  listexp_ = other.listexp_->clone();

}

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

void EApp::swap(EApp & other)
{
  std::swap(id_, other.id_);
  std::swap(listexp_, other.listexp_);

}

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

}

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

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



/********************   SNewClass    ********************/
SNewClass::SNewClass(Id p1)
{
  id_ = p1;

}

SNewClass::SNewClass(const SNewClass & other)
{
  id_ = other.id_;

}

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

void SNewClass::swap(SNewClass & other)
{
  std::swap(id_, other.id_);

}

SNewClass::~SNewClass()
{

}

void SNewClass::accept(Visitor *v)
{
  v->visitSNewClass(this);
}

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



/********************   SClassMember    ********************/
SClassMember::SClassMember(Id p1, Id p2, ListExp *p3)
{
  id_1 = p1;
  id_2 = p2;
  listexp_ = p3;

}

SClassMember::SClassMember(const SClassMember & other)
{
  id_1 = other.id_1;
  id_2 = other.id_2;
  listexp_ = other.listexp_->clone();

}

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

void SClassMember::swap(SClassMember & other)
{
  std::swap(id_1, other.id_1);
  std::swap(id_2, other.id_2);
  std::swap(listexp_, other.listexp_);

}

SClassMember::~SClassMember()
{
  delete(listexp_);

}

void SClassMember::accept(Visitor *v)
{
  v->visitSClassMember(this);
}

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



/********************   SClassMemberVar    ********************/
SClassMemberVar::SClassMemberVar(Id p1, Id p2)
{
  id_1 = p1;
  id_2 = p2;

}

SClassMemberVar::SClassMemberVar(const SClassMemberVar & other)
{
  id_1 = other.id_1;
  id_2 = other.id_2;

}

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

void SClassMemberVar::swap(SClassMemberVar & other)
{
  std::swap(id_1, other.id_1);
  std::swap(id_2, other.id_2);

}

SClassMemberVar::~SClassMemberVar()
{

}

void SClassMemberVar::accept(Visitor *v)
{
  v->visitSClassMemberVar(this);
}

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



/********************   ETimes    ********************/
ETimes::ETimes(Exp *p1, Exp *p2)
{
  exp_1 = p1;
  exp_2 = p2;

}

ETimes::ETimes(const ETimes & other)
{
  exp_1 = other.exp_1->clone();
  exp_2 = other.exp_2->clone();

}

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

void ETimes::swap(ETimes & other)
{
  std::swap(exp_1, other.exp_1);
  std::swap(exp_2, other.exp_2);

}

ETimes::~ETimes()
{
  delete(exp_1);
  delete(exp_2);

}

void ETimes::accept(Visitor *v)
{
  v->visitETimes(this);
}

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



/********************   EDiv    ********************/
EDiv::EDiv(Exp *p1, Exp *p2)
{
  exp_1 = p1;
  exp_2 = p2;

}

EDiv::EDiv(const EDiv & other)
{
  exp_1 = other.exp_1->clone();
  exp_2 = other.exp_2->clone();

}

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

void EDiv::swap(EDiv & other)
{
  std::swap(exp_1, other.exp_1);
  std::swap(exp_2, other.exp_2);

}

EDiv::~EDiv()
{
  delete(exp_1);
  delete(exp_2);

}

void EDiv::accept(Visitor *v)
{
  v->visitEDiv(this);
}

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



/********************   EPlus    ********************/
EPlus::EPlus(Exp *p1, Exp *p2)
{
  exp_1 = p1;
  exp_2 = p2;

}

EPlus::EPlus(const EPlus & other)
{
  exp_1 = other.exp_1->clone();
  exp_2 = other.exp_2->clone();

}

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

void EPlus::swap(EPlus & other)
{
  std::swap(exp_1, other.exp_1);
  std::swap(exp_2, other.exp_2);

}

EPlus::~EPlus()
{
  delete(exp_1);
  delete(exp_2);

}

void EPlus::accept(Visitor *v)
{
  v->visitEPlus(this);
}

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



/********************   EMinus    ********************/
EMinus::EMinus(Exp *p1, Exp *p2)
{
  exp_1 = p1;
  exp_2 = p2;

}

EMinus::EMinus(const EMinus & other)
{
  exp_1 = other.exp_1->clone();
  exp_2 = other.exp_2->clone();

}

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

void EMinus::swap(EMinus & other)
{
  std::swap(exp_1, other.exp_1);
  std::swap(exp_2, other.exp_2);

}

EMinus::~EMinus()
{
  delete(exp_1);
  delete(exp_2);

}

void EMinus::accept(Visitor *v)
{
  v->visitEMinus(this);
}

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



/********************   ELt    ********************/
ELt::ELt(Exp *p1, Exp *p2)
{
  exp_1 = p1;
  exp_2 = p2;

}

ELt::ELt(const ELt & other)
{
  exp_1 = other.exp_1->clone();
  exp_2 = other.exp_2->clone();

}

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

void ELt::swap(ELt & other)
{
  std::swap(exp_1, other.exp_1);
  std::swap(exp_2, other.exp_2);

}

ELt::~ELt()
{
  delete(exp_1);
  delete(exp_2);

}

void ELt::accept(Visitor *v)
{
  v->visitELt(this);
}

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



/********************   EGt    ********************/
EGt::EGt(Exp *p1, Exp *p2)
{
  exp_1 = p1;
  exp_2 = p2;

}

EGt::EGt(const EGt & other)
{
  exp_1 = other.exp_1->clone();
  exp_2 = other.exp_2->clone();

}

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

void EGt::swap(EGt & other)
{
  std::swap(exp_1, other.exp_1);
  std::swap(exp_2, other.exp_2);

}

EGt::~EGt()
{
  delete(exp_1);
  delete(exp_2);

}

void EGt::accept(Visitor *v)
{
  v->visitEGt(this);
}

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



/********************   EEq    ********************/
EEq::EEq(Exp *p1, Exp *p2)
{
  exp_1 = p1;
  exp_2 = p2;

}

EEq::EEq(const EEq & other)
{
  exp_1 = other.exp_1->clone();
  exp_2 = other.exp_2->clone();

}

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

void EEq::swap(EEq & other)
{
  std::swap(exp_1, other.exp_1);
  std::swap(exp_2, other.exp_2);

}

EEq::~EEq()
{
  delete(exp_1);
  delete(exp_2);

}

void EEq::accept(Visitor *v)
{
  v->visitEEq(this);
}

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



/********************   ENEq    ********************/
ENEq::ENEq(Exp *p1, Exp *p2)
{
  exp_1 = p1;
  exp_2 = p2;

}

ENEq::ENEq(const ENEq & other)
{
  exp_1 = other.exp_1->clone();
  exp_2 = other.exp_2->clone();

}

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

void ENEq::swap(ENEq & other)
{
  std::swap(exp_1, other.exp_1);
  std::swap(exp_2, other.exp_2);

}

ENEq::~ENEq()
{
  delete(exp_1);
  delete(exp_2);

}

void ENEq::accept(Visitor *v)
{
  v->visitENEq(this);
}

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



/********************   EAss    ********************/
EAss::EAss(Exp *p1, Exp *p2)
{
  exp_1 = p1;
  exp_2 = p2;

}

EAss::EAss(const EAss & other)
{
  exp_1 = other.exp_1->clone();
  exp_2 = other.exp_2->clone();

}

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

void EAss::swap(EAss & other)
{
  std::swap(exp_1, other.exp_1);
  std::swap(exp_2, other.exp_2);

}

EAss::~EAss()
{
  delete(exp_1);
  delete(exp_2);

}

void EAss::accept(Visitor *v)
{
  v->visitEAss(this);
}

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




/********************   ListDef    ********************/

void ListDef::accept(Visitor *v)
{
  v->visitListDef(this);
}


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


/********************   ListDfn    ********************/

void ListDfn::accept(Visitor *v)
{
  v->visitListDfn(this);
}


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


/********************   ListDmem    ********************/

void ListDmem::accept(Visitor *v)
{
  v->visitListDmem(this);
}


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


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

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


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


/********************   ListStm    ********************/

void ListStm::accept(Visitor *v)
{
  v->visitListStm(this);
}


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


/********************   ListExp    ********************/

void ListExp::accept(Visitor *v)
{
  v->visitListExp(this);
}


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


/********************   ListId    ********************/

void ListId::accept(Visitor *v)
{
  v->visitListId(this);
}


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