Skip to content

L
latte
Commit 8072a075 authored by zygzagZ's avatar zygzagZ
Browse files
Options

Convert to tabs

parent 0df5b04c
Hide whitespace changes
Inline Side-by-side
Showing with 4468 additions and 4472 deletions
Absyn.cpp
View file @ 8072a075
......@@ -7,29 +7,29 @@
/******************** PIdent ********************/
PIdent::PIdent(String p1, Integer p2)
{
string_ = p1;
integer_ = p2;
string_ = p1;
integer_ = p2;
}
PIdent::PIdent(const PIdent & other)
{
string_ = other.string_;
integer_ = other.integer_;
string_ = other.string_;
integer_ = other.integer_;
}
PIdent &PIdent::operator=(const PIdent & other)
{
PIdent tmp(other);
swap(tmp);
return *this;
PIdent tmp(other);
swap(tmp);
return *this;
}
void PIdent::swap(PIdent & other)
{
std::swap(string_, other.string_);
std::swap(integer_, other.integer_);
std::swap(string_, other.string_);
std::swap(integer_, other.integer_);
}
......@@ -40,12 +40,12 @@ PIdent::~PIdent()
void PIdent::accept(Visitor *v)
{
v->visitPIdent(this);
v->visitPIdent(this);
}
PIdent *PIdent::clone() const
{
return new PIdent(*this);
return new PIdent(*this);
}
......@@ -53,43 +53,43 @@ PIdent *PIdent::clone() const
/******************** Prog ********************/
Prog::Prog(ListTopDef *p1)
{
listtopdef_ = p1;
listtopdef_ = p1;
}
Prog::Prog(const Prog & other)
{
listtopdef_ = other.listtopdef_->clone();
listtopdef_ = other.listtopdef_->clone();
}
Prog &Prog::operator=(const Prog & other)
{
Prog tmp(other);
swap(tmp);
return *this;
Prog tmp(other);
swap(tmp);
return *this;
}
void Prog::swap(Prog & other)
{
std::swap(listtopdef_, other.listtopdef_);
std::swap(listtopdef_, other.listtopdef_);
}
Prog::~Prog()
{
delete(listtopdef_);
delete(listtopdef_);
}
void Prog::accept(Visitor *v)
{
v->visitProg(this);
v->visitProg(this);
}
Prog *Prog::clone() const
{
return new Prog(*this);
return new Prog(*this);
}
......@@ -97,43 +97,43 @@ Prog *Prog::clone() const
/******************** FnDef ********************/
FnDef::FnDef(FunDef *p1)
{
fundef_ = p1;
fundef_ = p1;
}
FnDef::FnDef(const FnDef & other)
{
fundef_ = other.fundef_->clone();
fundef_ = other.fundef_->clone();
}
FnDef &FnDef::operator=(const FnDef & other)
{
FnDef tmp(other);
swap(tmp);
return *this;
FnDef tmp(other);
swap(tmp);
return *this;
}
void FnDef::swap(FnDef & other)
{
std::swap(fundef_, other.fundef_);
std::swap(fundef_, other.fundef_);
}
FnDef::~FnDef()
{
delete(fundef_);
delete(fundef_);
}
void FnDef::accept(Visitor *v)
{
v->visitFnDef(this);
v->visitFnDef(this);
}
FnDef *FnDef::clone() const
{
return new FnDef(*this);
return new FnDef(*this);
}
......@@ -141,43 +141,43 @@ FnDef *FnDef::clone() const
/******************** ClDef ********************/
ClDef::ClDef(ClassDef *p1)
{
classdef_ = p1;
classdef_ = p1;
}
ClDef::ClDef(const ClDef & other)
{
classdef_ = other.classdef_->clone();
classdef_ = other.classdef_->clone();
}
ClDef &ClDef::operator=(const ClDef & other)
{
ClDef tmp(other);
swap(tmp);
return *this;
ClDef tmp(other);
swap(tmp);
return *this;
}
void ClDef::swap(ClDef & other)
{
std::swap(classdef_, other.classdef_);
std::swap(classdef_, other.classdef_);
}
ClDef::~ClDef()
{
delete(classdef_);
delete(classdef_);
}
void ClDef::accept(Visitor *v)
{
v->visitClDef(this);
v->visitClDef(this);
}
ClDef *ClDef::clone() const
{
return new ClDef(*this);
return new ClDef(*this);
}
......@@ -185,55 +185,55 @@ ClDef *ClDef::clone() const
/******************** FuncDef ********************/
FuncDef::FuncDef(Type *p1, PIdent *p2, ListArg *p3, Block *p4)
{
type_ = p1;
pident_ = p2;
listarg_ = p3;
block_ = p4;
type_ = p1;
pident_ = p2;
listarg_ = p3;
block_ = p4;
}
FuncDef::FuncDef(const FuncDef & other)
{
type_ = other.type_->clone();
pident_ = other.pident_->clone();
listarg_ = other.listarg_->clone();
block_ = other.block_->clone();
type_ = other.type_->clone();
pident_ = other.pident_->clone();
listarg_ = other.listarg_->clone();
block_ = other.block_->clone();
}
FuncDef &FuncDef::operator=(const FuncDef & other)
{
FuncDef tmp(other);
swap(tmp);
return *this;
FuncDef tmp(other);
swap(tmp);
return *this;
}
void FuncDef::swap(FuncDef & other)
{
std::swap(type_, other.type_);
std::swap(pident_, other.pident_);
std::swap(listarg_, other.listarg_);
std::swap(block_, other.block_);
std::swap(type_, other.type_);
std::swap(pident_, other.pident_);
std::swap(listarg_, other.listarg_);
std::swap(block_, other.block_);
}
FuncDef::~FuncDef()
{
delete(type_);
delete(pident_);
delete(listarg_);
delete(block_);
delete(type_);
delete(pident_);
delete(listarg_);
delete(block_);
}
void FuncDef::accept(Visitor *v)
{
v->visitFuncDef(this);
v->visitFuncDef(this);
}
FuncDef *FuncDef::clone() const
{
return new FuncDef(*this);
return new FuncDef(*this);
}
......@@ -241,47 +241,47 @@ FuncDef *FuncDef::clone() const
/******************** Ar ********************/
Ar::Ar(Type *p1, PIdent *p2)
{
type_ = p1;
pident_ = p2;
type_ = p1;
pident_ = p2;
}
Ar::Ar(const Ar & other)
{
type_ = other.type_->clone();
pident_ = other.pident_->clone();
type_ = other.type_->clone();
pident_ = other.pident_->clone();
}
Ar &Ar::operator=(const Ar & other)
{
Ar tmp(other);
swap(tmp);
return *this;
Ar tmp(other);
swap(tmp);
return *this;
}
void Ar::swap(Ar & other)
{
std::swap(type_, other.type_);
std::swap(pident_, other.pident_);
std::swap(type_, other.type_);
std::swap(pident_, other.pident_);
}
Ar::~Ar()
{
delete(type_);
delete(pident_);
delete(type_);
delete(pident_);
}
void Ar::accept(Visitor *v)
{
v->visitAr(this);
v->visitAr(this);
}
Ar *Ar::clone() const
{
return new Ar(*this);
return new Ar(*this);
}
......@@ -289,47 +289,47 @@ Ar *Ar::clone() const
/******************** ClassDefN ********************/
ClassDefN::ClassDefN(PIdent *p1, ClassBlock *p2)
{
pident_ = p1;
classblock_ = p2;
pident_ = p1;
classblock_ = p2;
}
ClassDefN::ClassDefN(const ClassDefN & other)
{
pident_ = other.pident_->clone();
classblock_ = other.classblock_->clone();
pident_ = other.pident_->clone();
classblock_ = other.classblock_->clone();
}
ClassDefN &ClassDefN::operator=(const ClassDefN & other)
{
ClassDefN tmp(other);
swap(tmp);
return *this;
ClassDefN tmp(other);
swap(tmp);
return *this;
}
void ClassDefN::swap(ClassDefN & other)
{
std::swap(pident_, other.pident_);
std::swap(classblock_, other.classblock_);
std::swap(pident_, other.pident_);
std::swap(classblock_, other.classblock_);
}
ClassDefN::~ClassDefN()
{
delete(pident_);
delete(classblock_);
delete(pident_);
delete(classblock_);
}
void ClassDefN::accept(Visitor *v)
{
v->visitClassDefN(this);
v->visitClassDefN(this);
}
ClassDefN *ClassDefN::clone() const
{
return new ClassDefN(*this);
return new ClassDefN(*this);
}
......@@ -337,51 +337,51 @@ ClassDefN *ClassDefN::clone() const
/******************** ClassDefE ********************/
ClassDefE::ClassDefE(PIdent *p1, PIdent *p2, ClassBlock *p3)
{
pident_1 = p1;
pident_2 = p2;
classblock_ = p3;
pident_1 = p1;
pident_2 = p2;
classblock_ = p3;
}
ClassDefE::ClassDefE(const ClassDefE & other)
{
pident_1 = other.pident_1->clone();
pident_2 = other.pident_2->clone();
classblock_ = other.classblock_->clone();
pident_1 = other.pident_1->clone();
pident_2 = other.pident_2->clone();
classblock_ = other.classblock_->clone();
}
ClassDefE &ClassDefE::operator=(const ClassDefE & other)
{
ClassDefE tmp(other);
swap(tmp);
return *this;
ClassDefE tmp(other);
swap(tmp);
return *this;
}
void ClassDefE::swap(ClassDefE & other)
{
std::swap(pident_1, other.pident_1);
std::swap(pident_2, other.pident_2);
std::swap(classblock_, other.classblock_);
std::swap(pident_1, other.pident_1);
std::swap(pident_2, other.pident_2);
std::swap(classblock_, other.classblock_);
}
ClassDefE::~ClassDefE()
{
delete(pident_1);
delete(pident_2);
delete(classblock_);
delete(pident_1);
delete(pident_2);
delete(classblock_);
}
void ClassDefE::accept(Visitor *v)
{
v->visitClassDefE(this);
v->visitClassDefE(this);
}
ClassDefE *ClassDefE::clone() const
{
return new ClassDefE(*this);
return new ClassDefE(*this);
}
......@@ -389,43 +389,43 @@ ClassDefE *ClassDefE::clone() const
/******************** ClassBl ********************/
ClassBl::ClassBl(ListClassBlockDef *p1)
{
listclassblockdef_ = p1;
listclassblockdef_ = p1;
}
ClassBl::ClassBl(const ClassBl & other)
{
listclassblockdef_ = other.listclassblockdef_->clone();
listclassblockdef_ = other.listclassblockdef_->clone();
}
ClassBl &ClassBl::operator=(const ClassBl & other)
{
ClassBl tmp(other);
swap(tmp);
return *this;
ClassBl tmp(other);
swap(tmp);
return *this;
}
void ClassBl::swap(ClassBl & other)
{
std::swap(listclassblockdef_, other.listclassblockdef_);
std::swap(listclassblockdef_, other.listclassblockdef_);
}
ClassBl::~ClassBl()
{
delete(listclassblockdef_);
delete(listclassblockdef_);
}
void ClassBl::accept(Visitor *v)
{
v->visitClassBl(this);
v->visitClassBl(this);
}
ClassBl *ClassBl::clone() const
{
return new ClassBl(*this);
return new ClassBl(*this);
}
......@@ -433,43 +433,43 @@ ClassBl *ClassBl::clone() const
/******************** ClassMthd ********************/
ClassMthd::ClassMthd(FunDef *p1)
{
fundef_ = p1;
fundef_ = p1;
}
ClassMthd::ClassMthd(const ClassMthd & other)
{
fundef_ = other.fundef_->clone();
fundef_ = other.fundef_->clone();
}
ClassMthd &ClassMthd::operator=(const ClassMthd & other)
{
ClassMthd tmp(other);
swap(tmp);
return *this;
ClassMthd tmp(other);
swap(tmp);
return *this;
}
void ClassMthd::swap(ClassMthd & other)
{
std::swap(fundef_, other.fundef_);
std::swap(fundef_, other.fundef_);
}
ClassMthd::~ClassMthd()
{
delete(fundef_);
delete(fundef_);
}
void ClassMthd::accept(Visitor *v)
{
v->visitClassMthd(this);
v->visitClassMthd(this);
}
ClassMthd *ClassMthd::clone() const
{
return new ClassMthd(*this);
return new ClassMthd(*this);
}
......@@ -477,47 +477,47 @@ ClassMthd *ClassMthd::clone() const
/******************** ClassFld ********************/
ClassFld::ClassFld(Type *p1, ListItem *p2)
{
type_ = p1;
listitem_ = p2;
type_ = p1;
listitem_ = p2;
}
ClassFld::ClassFld(const ClassFld & other)
{
type_ = other.type_->clone();
listitem_ = other.listitem_->clone();
type_ = other.type_->clone();
listitem_ = other.listitem_->clone();
}
ClassFld &ClassFld::operator=(const ClassFld & other)
{
ClassFld tmp(other);
swap(tmp);
return *this;
ClassFld tmp(other);
swap(tmp);
return *this;
}
void ClassFld::swap(ClassFld & other)
{
std::swap(type_, other.type_);
std::swap(listitem_, other.listitem_);
std::swap(type_, other.type_);
std::swap(listitem_, other.listitem_);
}
ClassFld::~ClassFld()
{
delete(type_);
delete(listitem_);
delete(type_);
delete(listitem_);
}
void ClassFld::accept(Visitor *v)
{
v->visitClassFld(this);
v->visitClassFld(this);
}
ClassFld *ClassFld::clone() const
{
return new ClassFld(*this);
return new ClassFld(*this);
}
......@@ -525,43 +525,43 @@ ClassFld *ClassFld::clone() const
/******************** Blk ********************/
Blk::Blk(ListStmt *p1)
{
liststmt_ = p1;
liststmt_ = p1;
}
Blk::Blk(const Blk & other)
{
liststmt_ = other.liststmt_->clone();
liststmt_ = other.liststmt_->clone();
}
Blk &Blk::operator=(const Blk & other)
{
Blk tmp(other);
swap(tmp);
return *this;
Blk tmp(other);
swap(tmp);
return *this;
}
void Blk::swap(Blk & other)
{
std::swap(liststmt_, other.liststmt_);
std::swap(liststmt_, other.liststmt_);
}
Blk::~Blk()
{
delete(liststmt_);
delete(liststmt_);
}
void Blk::accept(Visitor *v)
{
v->visitBlk(this);
v->visitBlk(this);
}
Blk *Blk::clone() const
{
return new Blk(*this);
return new Blk(*this);
}
......@@ -579,9 +579,9 @@ Empty::Empty(const Empty & other)
Empty &Empty::operator=(const Empty & other)
{
Empty tmp(other);
swap(tmp);
return *this;
Empty tmp(other);
swap(tmp);
return *this;
}
void Empty::swap(Empty & other)
......@@ -596,12 +596,12 @@ Empty::~Empty()
void Empty::accept(Visitor *v)
{
v->visitEmpty(this);
v->visitEmpty(this);
}
Empty *Empty::clone() const
{
return new Empty(*this);
return new Empty(*this);
}
......@@ -609,43 +609,43 @@ Empty *Empty::clone() const
/******************** BStmt ********************/
BStmt::BStmt(Block *p1)
{
block_ = p1;
block_ = p1;
}
BStmt::BStmt(const BStmt & other)
{
block_ = other.block_->clone();
block_ = other.block_->clone();
}
BStmt &BStmt::operator=(const BStmt & other)
{
BStmt tmp(other);
swap(tmp);
return *this;
BStmt tmp(other);
swap(tmp);
return *this;
}
void BStmt::swap(BStmt & other)
{
std::swap(block_, other.block_);
std::swap(block_, other.block_);
}
BStmt::~BStmt()
{
delete(block_);
delete(block_);
}
void BStmt::accept(Visitor *v)
{
v->visitBStmt(this);
v->visitBStmt(this);
}
BStmt *BStmt::clone() const
{
return new BStmt(*this);
return new BStmt(*this);
}
......@@ -653,47 +653,47 @@ BStmt *BStmt::clone() const
/******************** Decl ********************/
Decl::Decl(Type *p1, ListItem *p2)
{
type_ = p1;
listitem_ = p2;
type_ = p1;
listitem_ = p2;
}
Decl::Decl(const Decl & other)
{
type_ = other.type_->clone();
listitem_ = other.listitem_->clone();
type_ = other.type_->clone();
listitem_ = other.listitem_->clone();
}
Decl &Decl::operator=(const Decl & other)
{
Decl tmp(other);
swap(tmp);
return *this;
Decl tmp(other);
swap(tmp);
return *this;
}
void Decl::swap(Decl & other)
{
std::swap(type_, other.type_);
std::swap(listitem_, other.listitem_);
std::swap(type_, other.type_);
std::swap(listitem_, other.listitem_);
}
Decl::~Decl()
{
delete(type_);
delete(listitem_);
delete(type_);
delete(listitem_);
}
void Decl::accept(Visitor *v)
{
v->visitDecl(this);
v->visitDecl(this);
}
Decl *Decl::clone() const
{
return new Decl(*this);
return new Decl(*this);
}
......@@ -701,47 +701,47 @@ Decl *Decl::clone() const
/******************** Ass ********************/
Ass::Ass(Expr *p1, Expr *p2)
{
expr_1 = p1;
expr_2 = p2;
expr_1 = p1;
expr_2 = p2;
}
Ass::Ass(const Ass & other)
{
expr_1 = other.expr_1->clone();
expr_2 = other.expr_2->clone();
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;
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);
std::swap(expr_1, other.expr_1);
std::swap(expr_2, other.expr_2);
}
Ass::~Ass()
{
delete(expr_1);
delete(expr_2);
delete(expr_1);
delete(expr_2);
}
void Ass::accept(Visitor *v)
{
v->visitAss(this);
v->visitAss(this);
}
Ass *Ass::clone() const
{
return new Ass(*this);
return new Ass(*this);
}
......@@ -749,51 +749,51 @@ Ass *Ass::clone() const
/******************** TableAss ********************/
TableAss::TableAss(PIdent *p1, Expr *p2, Expr *p3)
{
pident_ = p1;
expr_1 = p2;
expr_2 = p3;
pident_ = p1;
expr_1 = p2;
expr_2 = p3;
}
TableAss::TableAss(const TableAss & other)
{
pident_ = other.pident_->clone();
expr_1 = other.expr_1->clone();
expr_2 = other.expr_2->clone();
pident_ = other.pident_->clone();
expr_1 = other.expr_1->clone();
expr_2 = other.expr_2->clone();
}
TableAss &TableAss::operator=(const TableAss & other)
{
TableAss tmp(other);
swap(tmp);
return *this;
TableAss tmp(other);
swap(tmp);
return *this;
}
void TableAss::swap(TableAss & other)
{
std::swap(pident_, other.pident_);
std::swap(expr_1, other.expr_1);
std::swap(expr_2, other.expr_2);
std::swap(pident_, other.pident_);
std::swap(expr_1, other.expr_1);
std::swap(expr_2, other.expr_2);
}
TableAss::~TableAss()
{
delete(pident_);
delete(expr_1);
delete(expr_2);
delete(pident_);
delete(expr_1);
delete(expr_2);
}
void TableAss::accept(Visitor *v)
{
v->visitTableAss(this);
v->visitTableAss(this);
}
TableAss *TableAss::clone() const
{
return new TableAss(*this);
return new TableAss(*this);
}
......@@ -801,47 +801,47 @@ TableAss *TableAss::clone() const
/******************** TableIncr ********************/
TableIncr::TableIncr(PIdent *p1, Expr *p2)
{
pident_ = p1;
expr_ = p2;
pident_ = p1;
expr_ = p2;
}
TableIncr::TableIncr(const TableIncr & other)
{
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
}
TableIncr &TableIncr::operator=(const TableIncr & other)
{
TableIncr tmp(other);
swap(tmp);
return *this;
TableIncr tmp(other);
swap(tmp);
return *this;
}
void TableIncr::swap(TableIncr & other)
{
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
}
TableIncr::~TableIncr()
{
delete(pident_);
delete(expr_);
delete(pident_);
delete(expr_);
}
void TableIncr::accept(Visitor *v)
{
v->visitTableIncr(this);
v->visitTableIncr(this);
}
TableIncr *TableIncr::clone() const
{
return new TableIncr(*this);
return new TableIncr(*this);
}
......@@ -849,47 +849,47 @@ TableIncr *TableIncr::clone() const
/******************** TableDecr ********************/
TableDecr::TableDecr(PIdent *p1, Expr *p2)
{
pident_ = p1;
expr_ = p2;
pident_ = p1;
expr_ = p2;
}
TableDecr::TableDecr(const TableDecr & other)
{
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
}
TableDecr &TableDecr::operator=(const TableDecr & other)
{
TableDecr tmp(other);
swap(tmp);
return *this;
TableDecr tmp(other);
swap(tmp);
return *this;
}
void TableDecr::swap(TableDecr & other)
{
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
}
TableDecr::~TableDecr()
{
delete(pident_);
delete(expr_);
delete(pident_);
delete(expr_);
}
void TableDecr::accept(Visitor *v)
{
v->visitTableDecr(this);
v->visitTableDecr(this);
}
TableDecr *TableDecr::clone() const
{
return new TableDecr(*this);
return new TableDecr(*this);
}
......@@ -897,43 +897,43 @@ TableDecr *TableDecr::clone() const
/******************** Incr ********************/
Incr::Incr(PIdent *p1)
{
pident_ = p1;
pident_ = p1;
}
Incr::Incr(const Incr & other)
{
pident_ = other.pident_->clone();
pident_ = other.pident_->clone();
}
Incr &Incr::operator=(const Incr & other)
{
Incr tmp(other);
swap(tmp);
return *this;
Incr tmp(other);
swap(tmp);
return *this;
}
void Incr::swap(Incr & other)
{
std::swap(pident_, other.pident_);
std::swap(pident_, other.pident_);
}
Incr::~Incr()
{
delete(pident_);
delete(pident_);
}
void Incr::accept(Visitor *v)
{
v->visitIncr(this);
v->visitIncr(this);
}
Incr *Incr::clone() const
{
return new Incr(*this);
return new Incr(*this);
}
......@@ -941,43 +941,43 @@ Incr *Incr::clone() const
/******************** Decr ********************/
Decr::Decr(PIdent *p1)
{
pident_ = p1;
pident_ = p1;
}
Decr::Decr(const Decr & other)
{
pident_ = other.pident_->clone();
pident_ = other.pident_->clone();
}
Decr &Decr::operator=(const Decr & other)
{
Decr tmp(other);
swap(tmp);
return *this;
Decr tmp(other);
swap(tmp);
return *this;
}
void Decr::swap(Decr & other)
{
std::swap(pident_, other.pident_);
std::swap(pident_, other.pident_);
}
Decr::~Decr()
{
delete(pident_);
delete(pident_);
}
void Decr::accept(Visitor *v)
{
v->visitDecr(this);
v->visitDecr(this);
}
Decr *Decr::clone() const
{
return new Decr(*this);
return new Decr(*this);
}
......@@ -985,43 +985,43 @@ Decr *Decr::clone() const
/******************** Ret ********************/
Ret::Ret(Expr *p1)
{
expr_ = p1;
expr_ = p1;
}
Ret::Ret(const Ret & other)
{
expr_ = other.expr_->clone();
expr_ = other.expr_->clone();
}
Ret &Ret::operator=(const Ret & other)
{
Ret tmp(other);
swap(tmp);
return *this;
Ret tmp(other);
swap(tmp);
return *this;
}
void Ret::swap(Ret & other)
{
std::swap(expr_, other.expr_);
std::swap(expr_, other.expr_);
}
Ret::~Ret()
{
delete(expr_);
delete(expr_);
}
void Ret::accept(Visitor *v)
{
v->visitRet(this);
v->visitRet(this);
}
Ret *Ret::clone() const
{
return new Ret(*this);
return new Ret(*this);
}
......@@ -1039,9 +1039,9 @@ VRet::VRet(const VRet & other)
VRet &VRet::operator=(const VRet & other)
{
VRet tmp(other);
swap(tmp);
return *this;
VRet tmp(other);
swap(tmp);
return *this;
}
void VRet::swap(VRet & other)
......@@ -1056,12 +1056,12 @@ VRet::~VRet()
void VRet::accept(Visitor *v)
{
v->visitVRet(this);
v->visitVRet(this);
}
VRet *VRet::clone() const
{
return new VRet(*this);
return new VRet(*this);
}
......@@ -1069,47 +1069,47 @@ VRet *VRet::clone() const
/******************** Cond ********************/
Cond::Cond(Expr *p1, Stmt *p2)
{
expr_ = p1;
stmt_ = p2;
expr_ = p1;
stmt_ = p2;
}
Cond::Cond(const Cond & other)
{
expr_ = other.expr_->clone();
stmt_ = other.stmt_->clone();
expr_ = other.expr_->clone();
stmt_ = other.stmt_->clone();
}
Cond &Cond::operator=(const Cond & other)
{
Cond tmp(other);
swap(tmp);
return *this;
Cond tmp(other);
swap(tmp);
return *this;
}
void Cond::swap(Cond & other)
{
std::swap(expr_, other.expr_);
std::swap(stmt_, other.stmt_);
std::swap(expr_, other.expr_);
std::swap(stmt_, other.stmt_);
}
Cond::~Cond()
{
delete(expr_);
delete(stmt_);
delete(expr_);
delete(stmt_);
}
void Cond::accept(Visitor *v)
{
v->visitCond(this);
v->visitCond(this);
}
Cond *Cond::clone() const
{
return new Cond(*this);
return new Cond(*this);
}
......@@ -1117,51 +1117,51 @@ Cond *Cond::clone() const
/******************** CondElse ********************/
CondElse::CondElse(Expr *p1, Stmt *p2, Stmt *p3)
{
expr_ = p1;
stmt_1 = p2;
stmt_2 = 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();
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;
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);
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);
delete(expr_);
delete(stmt_1);
delete(stmt_2);
}
void CondElse::accept(Visitor *v)
{
v->visitCondElse(this);
v->visitCondElse(this);
}
CondElse *CondElse::clone() const
{
return new CondElse(*this);
return new CondElse(*this);
}
......@@ -1169,47 +1169,47 @@ CondElse *CondElse::clone() const
/******************** While ********************/
While::While(Expr *p1, Stmt *p2)
{
expr_ = p1;
stmt_ = p2;
expr_ = p1;
stmt_ = p2;
}
While::While(const While & other)
{
expr_ = other.expr_->clone();
stmt_ = other.stmt_->clone();
expr_ = other.expr_->clone();
stmt_ = other.stmt_->clone();
}
While &While::operator=(const While & other)
{
While tmp(other);
swap(tmp);
return *this;
While tmp(other);
swap(tmp);
return *this;
}
void While::swap(While & other)
{
std::swap(expr_, other.expr_);
std::swap(stmt_, other.stmt_);
std::swap(expr_, other.expr_);
std::swap(stmt_, other.stmt_);
}
While::~While()
{
delete(expr_);
delete(stmt_);
delete(expr_);
delete(stmt_);
}
void While::accept(Visitor *v)
{
v->visitWhile(this);
v->visitWhile(this);
}
While *While::clone() const
{
return new While(*this);
return new While(*this);
}
......@@ -1217,43 +1217,43 @@ While *While::clone() const
/******************** SExp ********************/
SExp::SExp(Expr *p1)
{
expr_ = p1;
expr_ = p1;
}
SExp::SExp(const SExp & other)
{
expr_ = other.expr_->clone();
expr_ = other.expr_->clone();
}
SExp &SExp::operator=(const SExp & other)
{
SExp tmp(other);
swap(tmp);
return *this;
SExp tmp(other);
swap(tmp);
return *this;
}
void SExp::swap(SExp & other)
{
std::swap(expr_, other.expr_);
std::swap(expr_, other.expr_);
}
SExp::~SExp()
{
delete(expr_);
delete(expr_);
}
void SExp::accept(Visitor *v)
{
v->visitSExp(this);
v->visitSExp(this);
}
SExp *SExp::clone() const
{
return new SExp(*this);
return new SExp(*this);
}
......@@ -1261,55 +1261,55 @@ SExp *SExp::clone() const
/******************** ForEach ********************/
ForEach::ForEach(Type *p1, PIdent *p2, Expr *p3, Stmt *p4)
{
type_ = p1;
pident_ = p2;
expr_ = p3;
stmt_ = p4;
type_ = p1;
pident_ = p2;
expr_ = p3;
stmt_ = p4;
}
ForEach::ForEach(const ForEach & other)
{
type_ = other.type_->clone();
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
stmt_ = other.stmt_->clone();
type_ = other.type_->clone();
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
stmt_ = other.stmt_->clone();
}
ForEach &ForEach::operator=(const ForEach & other)
{
ForEach tmp(other);
swap(tmp);
return *this;
ForEach tmp(other);
swap(tmp);
return *this;
}
void ForEach::swap(ForEach & other)
{
std::swap(type_, other.type_);
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
std::swap(stmt_, other.stmt_);
std::swap(type_, other.type_);
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
std::swap(stmt_, other.stmt_);
}
ForEach::~ForEach()
{
delete(type_);
delete(pident_);
delete(expr_);
delete(stmt_);
delete(type_);
delete(pident_);
delete(expr_);
delete(stmt_);
}
void ForEach::accept(Visitor *v)
{
v->visitForEach(this);
v->visitForEach(this);
}
ForEach *ForEach::clone() const
{
return new ForEach(*this);
return new ForEach(*this);
}
......@@ -1317,43 +1317,43 @@ ForEach *ForEach::clone() const
/******************** NoInit ********************/
NoInit::NoInit(PIdent *p1)
{
pident_ = p1;
pident_ = p1;
}
NoInit::NoInit(const NoInit & other)
{
pident_ = other.pident_->clone();
pident_ = other.pident_->clone();
}
NoInit &NoInit::operator=(const NoInit & other)
{
NoInit tmp(other);
swap(tmp);
return *this;
NoInit tmp(other);
swap(tmp);
return *this;
}
void NoInit::swap(NoInit & other)
{
std::swap(pident_, other.pident_);
std::swap(pident_, other.pident_);
}
NoInit::~NoInit()
{
delete(pident_);
delete(pident_);
}
void NoInit::accept(Visitor *v)
{
v->visitNoInit(this);
v->visitNoInit(this);
}
NoInit *NoInit::clone() const
{
return new NoInit(*this);
return new NoInit(*this);
}
......@@ -1361,47 +1361,47 @@ NoInit *NoInit::clone() const
/******************** Init ********************/
Init::Init(PIdent *p1, Expr *p2)
{
pident_ = p1;
expr_ = p2;
pident_ = p1;
expr_ = p2;
}
Init::Init(const Init & other)
{
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
}
Init &Init::operator=(const Init & other)
{
Init tmp(other);
swap(tmp);
return *this;
Init tmp(other);
swap(tmp);
return *this;
}
void Init::swap(Init & other)
{
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
}
Init::~Init()
{
delete(pident_);
delete(expr_);
delete(pident_);
delete(expr_);
}
void Init::accept(Visitor *v)
{
v->visitInit(this);
v->visitInit(this);
}
Init *Init::clone() const
{
return new Init(*this);
return new Init(*this);
}
......@@ -1419,9 +1419,9 @@ Int::Int(const Int & other)
Int &Int::operator=(const Int & other)
{
Int tmp(other);
swap(tmp);
return *this;
Int tmp(other);
swap(tmp);
return *this;
}
void Int::swap(Int & other)
......@@ -1436,12 +1436,12 @@ Int::~Int()
void Int::accept(Visitor *v)
{
v->visitInt(this);
v->visitInt(this);
}
Int *Int::clone() const
{
return new Int(*this);
return new Int(*this);
}
......@@ -1459,9 +1459,9 @@ Str::Str(const Str & other)
Str &Str::operator=(const Str & other)
{
Str tmp(other);
swap(tmp);
return *this;
Str tmp(other);
swap(tmp);
return *this;
}
void Str::swap(Str & other)
......@@ -1476,12 +1476,12 @@ Str::~Str()
void Str::accept(Visitor *v)
{
v->visitStr(this);
v->visitStr(this);
}
Str *Str::clone() const
{
return new Str(*this);
return new Str(*this);
}
......@@ -1499,9 +1499,9 @@ Bool::Bool(const Bool & other)
Bool &Bool::operator=(const Bool & other)
{
Bool tmp(other);
swap(tmp);
return *this;
Bool tmp(other);
swap(tmp);
return *this;
}
void Bool::swap(Bool & other)
......@@ -1516,12 +1516,12 @@ Bool::~Bool()
void Bool::accept(Visitor *v)
{
v->visitBool(this);
v->visitBool(this);
}
Bool *Bool::clone() const
{
return new Bool(*this);
return new Bool(*this);
}
......@@ -1539,9 +1539,9 @@ Void::Void(const Void & other)
Void &Void::operator=(const Void & other)
{
Void tmp(other);
swap(tmp);
return *this;
Void tmp(other);
swap(tmp);
return *this;
}
void Void::swap(Void & other)
......@@ -1556,12 +1556,12 @@ Void::~Void()
void Void::accept(Visitor *v)
{
v->visitVoid(this);
v->visitVoid(this);
}
Void *Void::clone() const
{
return new Void(*this);
return new Void(*this);
}
......@@ -1569,43 +1569,43 @@ Void *Void::clone() const
/******************** Array ********************/
Array::Array(Type *p1)
{
type_ = p1;
type_ = p1;
}
Array::Array(const Array & other)
{
type_ = other.type_->clone();
type_ = other.type_->clone();
}
Array &Array::operator=(const Array & other)
{
Array tmp(other);
swap(tmp);
return *this;
Array tmp(other);
swap(tmp);
return *this;
}
void Array::swap(Array & other)
{
std::swap(type_, other.type_);
std::swap(type_, other.type_);
}
Array::~Array()
{
delete(type_);
delete(type_);
}
void Array::accept(Visitor *v)
{
v->visitArray(this);
v->visitArray(this);
}
Array *Array::clone() const
{
return new Array(*this);
return new Array(*this);
}
......@@ -1613,43 +1613,43 @@ Array *Array::clone() const
/******************** ClassT ********************/
ClassT::ClassT(PIdent *p1)
{
pident_ = p1;
pident_ = p1;
}
ClassT::ClassT(const ClassT & other)
{
pident_ = other.pident_->clone();
pident_ = other.pident_->clone();
}
ClassT &ClassT::operator=(const ClassT & other)
{
ClassT tmp(other);
swap(tmp);
return *this;
ClassT tmp(other);
swap(tmp);
return *this;
}
void ClassT::swap(ClassT & other)
{
std::swap(pident_, other.pident_);
std::swap(pident_, other.pident_);
}
ClassT::~ClassT()
{
delete(pident_);
delete(pident_);
}
void ClassT::accept(Visitor *v)
{
v->visitClassT(this);
v->visitClassT(this);
}
ClassT *ClassT::clone() const
{
return new ClassT(*this);
return new ClassT(*this);
}
......@@ -1657,47 +1657,47 @@ ClassT *ClassT::clone() const
/******************** Fun ********************/
Fun::Fun(Type *p1, ListType *p2)
{
type_ = p1;
listtype_ = p2;
type_ = p1;
listtype_ = p2;
}
Fun::Fun(const Fun & other)
{
type_ = other.type_->clone();
listtype_ = other.listtype_->clone();
type_ = other.type_->clone();
listtype_ = other.listtype_->clone();
}
Fun &Fun::operator=(const Fun & other)
{
Fun tmp(other);
swap(tmp);
return *this;
Fun tmp(other);
swap(tmp);
return *this;
}
void Fun::swap(Fun & other)
{
std::swap(type_, other.type_);
std::swap(listtype_, other.listtype_);
std::swap(type_, other.type_);
std::swap(listtype_, other.listtype_);
}
Fun::~Fun()
{
delete(type_);
delete(listtype_);
delete(type_);
delete(listtype_);
}
void Fun::accept(Visitor *v)
{
v->visitFun(this);
v->visitFun(this);
}
Fun *Fun::clone() const
{
return new Fun(*this);
return new Fun(*this);
}
......@@ -1705,43 +1705,43 @@ Fun *Fun::clone() const
/******************** EVar ********************/
EVar::EVar(PIdent *p1)
{
pident_ = p1;
pident_ = p1;
}
EVar::EVar(const EVar & other)
{
pident_ = other.pident_->clone();
pident_ = other.pident_->clone();
}
EVar &EVar::operator=(const EVar & other)
{
EVar tmp(other);
swap(tmp);
return *this;
EVar tmp(other);
swap(tmp);
return *this;
}
void EVar::swap(EVar & other)
{
std::swap(pident_, other.pident_);
std::swap(pident_, other.pident_);
}
EVar::~EVar()
{
delete(pident_);
delete(pident_);
}
void EVar::accept(Visitor *v)
{
v->visitEVar(this);
v->visitEVar(this);
}
EVar *EVar::clone() const
{
return new EVar(*this);
return new EVar(*this);
}
......@@ -1749,26 +1749,26 @@ EVar *EVar::clone() const
/******************** ELitInt ********************/
ELitInt::ELitInt(Integer p1)
{
integer_ = p1;
integer_ = p1;
}
ELitInt::ELitInt(const ELitInt & other)
{
integer_ = other.integer_;
integer_ = other.integer_;
}
ELitInt &ELitInt::operator=(const ELitInt & other)
{
ELitInt tmp(other);
swap(tmp);
return *this;
ELitInt tmp(other);
swap(tmp);
return *this;
}
void ELitInt::swap(ELitInt & other)
{
std::swap(integer_, other.integer_);
std::swap(integer_, other.integer_);
}
......@@ -1779,12 +1779,12 @@ ELitInt::~ELitInt()
void ELitInt::accept(Visitor *v)
{
v->visitELitInt(this);
v->visitELitInt(this);
}
ELitInt *ELitInt::clone() const
{
return new ELitInt(*this);
return new ELitInt(*this);
}
......@@ -1802,9 +1802,9 @@ ELitTrue::ELitTrue(const ELitTrue & other)
ELitTrue &ELitTrue::operator=(const ELitTrue & other)
{
ELitTrue tmp(other);
swap(tmp);
return *this;
ELitTrue tmp(other);
swap(tmp);
return *this;
}
void ELitTrue::swap(ELitTrue & other)
......@@ -1819,12 +1819,12 @@ ELitTrue::~ELitTrue()
void ELitTrue::accept(Visitor *v)
{
v->visitELitTrue(this);
v->visitELitTrue(this);
}
ELitTrue *ELitTrue::clone() const
{
return new ELitTrue(*this);
return new ELitTrue(*this);
}
......@@ -1842,9 +1842,9 @@ ELitFalse::ELitFalse(const ELitFalse & other)
ELitFalse &ELitFalse::operator=(const ELitFalse & other)
{
ELitFalse tmp(other);
swap(tmp);
return *this;
ELitFalse tmp(other);
swap(tmp);
return *this;
}
void ELitFalse::swap(ELitFalse & other)
......@@ -1859,12 +1859,12 @@ ELitFalse::~ELitFalse()
void ELitFalse::accept(Visitor *v)
{
v->visitELitFalse(this);
v->visitELitFalse(this);
}
ELitFalse *ELitFalse::clone() const
{
return new ELitFalse(*this);
return new ELitFalse(*this);
}
......@@ -1872,47 +1872,47 @@ ELitFalse *ELitFalse::clone() const
/******************** EApp ********************/
EApp::EApp(PIdent *p1, ListExpr *p2)
{
pident_ = p1;
listexpr_ = p2;
pident_ = p1;
listexpr_ = p2;
}
EApp::EApp(const EApp & other)
{
pident_ = other.pident_->clone();
listexpr_ = other.listexpr_->clone();
pident_ = other.pident_->clone();
listexpr_ = other.listexpr_->clone();
}
EApp &EApp::operator=(const EApp & other)
{
EApp tmp(other);
swap(tmp);
return *this;
EApp tmp(other);
swap(tmp);
return *this;
}
void EApp::swap(EApp & other)
{
std::swap(pident_, other.pident_);
std::swap(listexpr_, other.listexpr_);
std::swap(pident_, other.pident_);
std::swap(listexpr_, other.listexpr_);
}
EApp::~EApp()
{
delete(pident_);
delete(listexpr_);
delete(pident_);
delete(listexpr_);
}
void EApp::accept(Visitor *v)
{
v->visitEApp(this);
v->visitEApp(this);
}
EApp *EApp::clone() const
{
return new EApp(*this);
return new EApp(*this);
}
......@@ -1920,26 +1920,26 @@ EApp *EApp::clone() const
/******************** EString ********************/
EString::EString(String p1)
{
string_ = p1;
string_ = p1;
}
EString::EString(const EString & other)
{
string_ = other.string_;
string_ = other.string_;
}
EString &EString::operator=(const EString & other)
{
EString tmp(other);
swap(tmp);
return *this;
EString tmp(other);
swap(tmp);
return *this;
}
void EString::swap(EString & other)
{
std::swap(string_, other.string_);
std::swap(string_, other.string_);
}
......@@ -1950,12 +1950,12 @@ EString::~EString()
void EString::accept(Visitor *v)
{
v->visitEString(this);
v->visitEString(this);
}
EString *EString::clone() const
{
return new EString(*this);
return new EString(*this);
}
......@@ -1963,47 +1963,47 @@ EString *EString::clone() const
/******************** ENewArray ********************/
ENewArray::ENewArray(Type *p1, Expr *p2)
{
type_ = p1;
expr_ = p2;
type_ = p1;
expr_ = p2;
}
ENewArray::ENewArray(const ENewArray & other)
{
type_ = other.type_->clone();
expr_ = other.expr_->clone();
type_ = other.type_->clone();
expr_ = other.expr_->clone();
}
ENewArray &ENewArray::operator=(const ENewArray & other)
{
ENewArray tmp(other);
swap(tmp);
return *this;
ENewArray tmp(other);
swap(tmp);
return *this;
}
void ENewArray::swap(ENewArray & other)
{
std::swap(type_, other.type_);
std::swap(expr_, other.expr_);
std::swap(type_, other.type_);
std::swap(expr_, other.expr_);
}
ENewArray::~ENewArray()
{
delete(type_);
delete(expr_);
delete(type_);
delete(expr_);
}
void ENewArray::accept(Visitor *v)
{
v->visitENewArray(this);
v->visitENewArray(this);
}
ENewArray *ENewArray::clone() const
{
return new ENewArray(*this);
return new ENewArray(*this);
}
......@@ -2011,43 +2011,43 @@ ENewArray *ENewArray::clone() const
/******************** ENewClass ********************/
ENewClass::ENewClass(PIdent *p1)
{
pident_ = p1;
pident_ = p1;
}
ENewClass::ENewClass(const ENewClass & other)
{
pident_ = other.pident_->clone();
pident_ = other.pident_->clone();
}
ENewClass &ENewClass::operator=(const ENewClass & other)
{
ENewClass tmp(other);
swap(tmp);
return *this;
ENewClass tmp(other);
swap(tmp);
return *this;
}
void ENewClass::swap(ENewClass & other)
{
std::swap(pident_, other.pident_);
std::swap(pident_, other.pident_);
}
ENewClass::~ENewClass()
{
delete(pident_);
delete(pident_);
}
void ENewClass::accept(Visitor *v)
{
v->visitENewClass(this);
v->visitENewClass(this);
}
ENewClass *ENewClass::clone() const
{
return new ENewClass(*this);
return new ENewClass(*this);
}
......@@ -2055,47 +2055,47 @@ ENewClass *ENewClass::clone() const
/******************** EClsMmbr ********************/
EClsMmbr::EClsMmbr(Expr *p1, PIdent *p2)
{
expr_ = p1;
pident_ = p2;
expr_ = p1;
pident_ = p2;
}
EClsMmbr::EClsMmbr(const EClsMmbr & other)
{
expr_ = other.expr_->clone();
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
pident_ = other.pident_->clone();
}
EClsMmbr &EClsMmbr::operator=(const EClsMmbr & other)
{
EClsMmbr tmp(other);
swap(tmp);
return *this;
EClsMmbr tmp(other);
swap(tmp);
return *this;
}
void EClsMmbr::swap(EClsMmbr & other)
{
std::swap(expr_, other.expr_);
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
std::swap(pident_, other.pident_);
}
EClsMmbr::~EClsMmbr()
{
delete(expr_);
delete(pident_);
delete(expr_);
delete(pident_);
}
void EClsMmbr::accept(Visitor *v)
{
v->visitEClsMmbr(this);
v->visitEClsMmbr(this);
}
EClsMmbr *EClsMmbr::clone() const
{
return new EClsMmbr(*this);
return new EClsMmbr(*this);
}
......@@ -2103,51 +2103,51 @@ EClsMmbr *EClsMmbr::clone() const
/******************** EClsMthd ********************/
EClsMthd::EClsMthd(Expr *p1, PIdent *p2, ListExpr *p3)
{
expr_ = p1;
pident_ = p2;
listexpr_ = p3;
expr_ = p1;
pident_ = p2;
listexpr_ = p3;
}
EClsMthd::EClsMthd(const EClsMthd & other)
{
expr_ = other.expr_->clone();
pident_ = other.pident_->clone();
listexpr_ = other.listexpr_->clone();
expr_ = other.expr_->clone();
pident_ = other.pident_->clone();
listexpr_ = other.listexpr_->clone();
}
EClsMthd &EClsMthd::operator=(const EClsMthd & other)
{
EClsMthd tmp(other);
swap(tmp);
return *this;
EClsMthd tmp(other);
swap(tmp);
return *this;
}
void EClsMthd::swap(EClsMthd & other)
{
std::swap(expr_, other.expr_);
std::swap(pident_, other.pident_);
std::swap(listexpr_, other.listexpr_);
std::swap(expr_, other.expr_);
std::swap(pident_, other.pident_);
std::swap(listexpr_, other.listexpr_);
}
EClsMthd::~EClsMthd()
{
delete(expr_);
delete(pident_);
delete(listexpr_);
delete(expr_);
delete(pident_);
delete(listexpr_);
}
void EClsMthd::accept(Visitor *v)
{
v->visitEClsMthd(this);
v->visitEClsMthd(this);
}
EClsMthd *EClsMthd::clone() const
{
return new EClsMthd(*this);
return new EClsMthd(*this);
}
......@@ -2165,9 +2165,9 @@ Null::Null(const Null & other)
Null &Null::operator=(const Null & other)
{
Null tmp(other);
swap(tmp);
return *this;
Null tmp(other);
swap(tmp);
return *this;
}
void Null::swap(Null & other)
......@@ -2182,12 +2182,12 @@ Null::~Null()
void Null::accept(Visitor *v)
{
v->visitNull(this);
v->visitNull(this);
}
Null *Null::clone() const
{
return new Null(*this);
return new Null(*this);
}
......@@ -2195,47 +2195,47 @@ Null *Null::clone() const
/******************** EIndexAcc ********************/
EIndexAcc::EIndexAcc(PIdent *p1, Expr *p2)
{
pident_ = p1;
expr_ = p2;
pident_ = p1;
expr_ = p2;
}
EIndexAcc::EIndexAcc(const EIndexAcc & other)
{
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
}
EIndexAcc &EIndexAcc::operator=(const EIndexAcc & other)
{
EIndexAcc tmp(other);
swap(tmp);
return *this;
EIndexAcc tmp(other);
swap(tmp);
return *this;
}
void EIndexAcc::swap(EIndexAcc & other)
{
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
}
EIndexAcc::~EIndexAcc()
{
delete(pident_);
delete(expr_);
delete(pident_);
delete(expr_);
}
void EIndexAcc::accept(Visitor *v)
{
v->visitEIndexAcc(this);
v->visitEIndexAcc(this);
}
EIndexAcc *EIndexAcc::clone() const
{
return new EIndexAcc(*this);
return new EIndexAcc(*this);
}
......@@ -2243,47 +2243,47 @@ EIndexAcc *EIndexAcc::clone() const
/******************** ECast ********************/
ECast::ECast(PIdent *p1, Expr *p2)
{
pident_ = p1;
expr_ = p2;
pident_ = p1;
expr_ = p2;
}
ECast::ECast(const ECast & other)
{
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
pident_ = other.pident_->clone();
expr_ = other.expr_->clone();
}
ECast &ECast::operator=(const ECast & other)
{
ECast tmp(other);
swap(tmp);
return *this;
ECast tmp(other);
swap(tmp);
return *this;
}
void ECast::swap(ECast & other)
{
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
std::swap(pident_, other.pident_);
std::swap(expr_, other.expr_);
}
ECast::~ECast()
{
delete(pident_);
delete(expr_);
delete(pident_);
delete(expr_);
}
void ECast::accept(Visitor *v)
{
v->visitECast(this);
v->visitECast(this);
}
ECast *ECast::clone() const
{
return new ECast(*this);
return new ECast(*this);
}
......@@ -2291,43 +2291,43 @@ ECast *ECast::clone() const
/******************** Neg ********************/
Neg::Neg(Expr *p1)
{
expr_ = p1;
expr_ = p1;
}
Neg::Neg(const Neg & other)
{
expr_ = other.expr_->clone();
expr_ = other.expr_->clone();
}
Neg &Neg::operator=(const Neg & other)
{
Neg tmp(other);
swap(tmp);
return *this;
Neg tmp(other);
swap(tmp);
return *this;
}
void Neg::swap(Neg & other)
{
std::swap(expr_, other.expr_);
std::swap(expr_, other.expr_);
}
Neg::~Neg()
{
delete(expr_);
delete(expr_);
}
void Neg::accept(Visitor *v)
{
v->visitNeg(this);
v->visitNeg(this);
}
Neg *Neg::clone() const
{
return new Neg(*this);
return new Neg(*this);
}
......@@ -2335,43 +2335,43 @@ Neg *Neg::clone() const
/******************** Not ********************/
Not::Not(Expr *p1)
{
expr_ = p1;
expr_ = p1;
}
Not::Not(const Not & other)
{
expr_ = other.expr_->clone();
expr_ = other.expr_->clone();
}
Not &Not::operator=(const Not & other)
{
Not tmp(other);
swap(tmp);
return *this;
Not tmp(other);
swap(tmp);
return *this;
}
void Not::swap(Not & other)
{
std::swap(expr_, other.expr_);
std::swap(expr_, other.expr_);
}
Not::~Not()
{
delete(expr_);
delete(expr_);
}
void Not::accept(Visitor *v)
{
v->visitNot(this);
v->visitNot(this);
}
Not *Not::clone() const
{
return new Not(*this);
return new Not(*this);
}
......@@ -2379,51 +2379,51 @@ Not *Not::clone() const
/******************** EMul ********************/
EMul::EMul(Expr *p1, MulOp *p2, Expr *p3)
{
expr_1 = p1;
mulop_ = p2;
expr_2 = 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();
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;
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);
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);
delete(expr_1);
delete(mulop_);
delete(expr_2);
}
void EMul::accept(Visitor *v)
{
v->visitEMul(this);
v->visitEMul(this);
}
EMul *EMul::clone() const
{
return new EMul(*this);
return new EMul(*this);
}
......@@ -2431,51 +2431,51 @@ EMul *EMul::clone() const
/******************** EAdd ********************/
EAdd::EAdd(Expr *p1, AddOp *p2, Expr *p3)
{
expr_1 = p1;
addop_ = p2;
expr_2 = 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();
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;
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);
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);
delete(expr_1);
delete(addop_);
delete(expr_2);
}
void EAdd::accept(Visitor *v)
{
v->visitEAdd(this);
v->visitEAdd(this);
}
EAdd *EAdd::clone() const
{
return new EAdd(*this);
return new EAdd(*this);
}
......@@ -2483,51 +2483,51 @@ EAdd *EAdd::clone() const
/******************** ERel ********************/
ERel::ERel(Expr *p1, RelOp *p2, Expr *p3)
{
expr_1 = p1;
relop_ = p2;
expr_2 = 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();
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;
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);
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);
delete(expr_1);
delete(relop_);
delete(expr_2);
}
void ERel::accept(Visitor *v)
{
v->visitERel(this);
v->visitERel(this);
}
ERel *ERel::clone() const
{
return new ERel(*this);
return new ERel(*this);
}
......@@ -2535,47 +2535,47 @@ ERel *ERel::clone() const
/******************** EAnd ********************/
EAnd::EAnd(Expr *p1, Expr *p2)
{
expr_1 = p1;
expr_2 = p2;
expr_1 = p1;
expr_2 = p2;
}
EAnd::EAnd(const EAnd & other)
{
expr_1 = other.expr_1->clone();
expr_2 = other.expr_2->clone();
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;
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);
std::swap(expr_1, other.expr_1);
std::swap(expr_2, other.expr_2);
}
EAnd::~EAnd()
{
delete(expr_1);
delete(expr_2);
delete(expr_1);
delete(expr_2);
}
void EAnd::accept(Visitor *v)
{
v->visitEAnd(this);
v->visitEAnd(this);
}
EAnd *EAnd::clone() const
{
return new EAnd(*this);
return new EAnd(*this);
}
......@@ -2583,47 +2583,47 @@ EAnd *EAnd::clone() const
/******************** EOr ********************/
EOr::EOr(Expr *p1, Expr *p2)
{
expr_1 = p1;
expr_2 = p2;
expr_1 = p1;
expr_2 = p2;
}
EOr::EOr(const EOr & other)
{
expr_1 = other.expr_1->clone();
expr_2 = other.expr_2->clone();
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;
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);
std::swap(expr_1, other.expr_1);
std::swap(expr_2, other.expr_2);
}
EOr::~EOr()
{
delete(expr_1);
delete(expr_2);
delete(expr_1);
delete(expr_2);
}
void EOr::accept(Visitor *v)
{
v->visitEOr(this);
v->visitEOr(this);
}
EOr *EOr::clone() const
{
return new EOr(*this);
return new EOr(*this);
}
......@@ -2641,9 +2641,9 @@ Plus::Plus(const Plus & other)
Plus &Plus::operator=(const Plus & other)
{
Plus tmp(other);
swap(tmp);
return *this;
Plus tmp(other);
swap(tmp);
return *this;
}
void Plus::swap(Plus & other)
......@@ -2658,12 +2658,12 @@ Plus::~Plus()
void Plus::accept(Visitor *v)
{
v->visitPlus(this);
v->visitPlus(this);
}
Plus *Plus::clone() const
{
return new Plus(*this);
return new Plus(*this);
}
......@@ -2681,9 +2681,9 @@ Minus::Minus(const Minus & other)
Minus &Minus::operator=(const Minus & other)
{
Minus tmp(other);
swap(tmp);
return *this;
Minus tmp(other);
swap(tmp);
return *this;
}
void Minus::swap(Minus & other)
......@@ -2698,12 +2698,12 @@ Minus::~Minus()
void Minus::accept(Visitor *v)
{
v->visitMinus(this);
v->visitMinus(this);
}
Minus *Minus::clone() const
{
return new Minus(*this);
return new Minus(*this);
}
......@@ -2721,9 +2721,9 @@ Times::Times(const Times & other)
Times &Times::operator=(const Times & other)
{
Times tmp(other);
swap(tmp);
return *this;
Times tmp(other);
swap(tmp);
return *this;
}
void Times::swap(Times & other)
......@@ -2738,12 +2738,12 @@ Times::~Times()
void Times::accept(Visitor *v)
{
v->visitTimes(this);
v->visitTimes(this);
}
Times *Times::clone() const
{
return new Times(*this);
return new Times(*this);
}
......@@ -2761,9 +2761,9 @@ Div::Div(const Div & other)
Div &Div::operator=(const Div & other)
{
Div tmp(other);
swap(tmp);
return *this;
Div tmp(other);
swap(tmp);
return *this;
}
void Div::swap(Div & other)
......@@ -2778,12 +2778,12 @@ Div::~Div()
void Div::accept(Visitor *v)
{
v->visitDiv(this);
v->visitDiv(this);
}
Div *Div::clone() const
{
return new Div(*this);
return new Div(*this);
}
......@@ -2801,9 +2801,9 @@ Mod::Mod(const Mod & other)
Mod &Mod::operator=(const Mod & other)
{
Mod tmp(other);
swap(tmp);
return *this;
Mod tmp(other);
swap(tmp);
return *this;
}
void Mod::swap(Mod & other)
......@@ -2818,12 +2818,12 @@ Mod::~Mod()
void Mod::accept(Visitor *v)
{
v->visitMod(this);
v->visitMod(this);
}
Mod *Mod::clone() const
{
return new Mod(*this);
return new Mod(*this);
}
......@@ -2841,9 +2841,9 @@ LTH::LTH(const LTH & other)
LTH &LTH::operator=(const LTH & other)
{
LTH tmp(other);
swap(tmp);
return *this;
LTH tmp(other);
swap(tmp);
return *this;
}
void LTH::swap(LTH & other)
......@@ -2858,12 +2858,12 @@ LTH::~LTH()
void LTH::accept(Visitor *v)
{
v->visitLTH(this);
v->visitLTH(this);
}
LTH *LTH::clone() const
{
return new LTH(*this);
return new LTH(*this);
}
......@@ -2881,9 +2881,9 @@ LE::LE(const LE & other)
LE &LE::operator=(const LE & other)
{
LE tmp(other);
swap(tmp);
return *this;
LE tmp(other);
swap(tmp);
return *this;
}
void LE::swap(LE & other)
......@@ -2898,12 +2898,12 @@ LE::~LE()
void LE::accept(Visitor *v)
{
v->visitLE(this);
v->visitLE(this);
}
LE *LE::clone() const
{
return new LE(*this);
return new LE(*this);
}
......@@ -2921,9 +2921,9 @@ GTH::GTH(const GTH & other)
GTH &GTH::operator=(const GTH & other)
{
GTH tmp(other);
swap(tmp);
return *this;
GTH tmp(other);
swap(tmp);
return *this;
}
void GTH::swap(GTH & other)
......@@ -2938,12 +2938,12 @@ GTH::~GTH()
void GTH::accept(Visitor *v)
{
v->visitGTH(this);
v->visitGTH(this);
}
GTH *GTH::clone() const
{
return new GTH(*this);
return new GTH(*this);
}
......@@ -2961,9 +2961,9 @@ GE::GE(const GE & other)
GE &GE::operator=(const GE & other)
{
GE tmp(other);
swap(tmp);
return *this;
GE tmp(other);
swap(tmp);
return *this;
}
void GE::swap(GE & other)
......@@ -2978,12 +2978,12 @@ GE::~GE()
void GE::accept(Visitor *v)
{
v->visitGE(this);
v->visitGE(this);
}
GE *GE::clone() const
{
return new GE(*this);
return new GE(*this);
}
......@@ -3001,9 +3001,9 @@ EQU::EQU(const EQU & other)
EQU &EQU::operator=(const EQU & other)
{
EQU tmp(other);
swap(tmp);
return *this;
EQU tmp(other);
swap(tmp);
return *this;
}
void EQU::swap(EQU & other)
......@@ -3018,12 +3018,12 @@ EQU::~EQU()
void EQU::accept(Visitor *v)
{
v->visitEQU(this);
v->visitEQU(this);
}
EQU *EQU::clone() const
{
return new EQU(*this);
return new EQU(*this);
}
......@@ -3041,9 +3041,9 @@ NE::NE(const NE & other)
NE &NE::operator=(const NE & other)
{
NE tmp(other);
swap(tmp);
return *this;
NE tmp(other);
swap(tmp);
return *this;
}
void NE::swap(NE & other)
......@@ -3058,12 +3058,12 @@ NE::~NE()
void NE::accept(Visitor *v)
{
v->visitNE(this);
v->visitNE(this);
}
NE *NE::clone() const
{
return new NE(*this);
return new NE(*this);
}
......@@ -3073,13 +3073,13 @@ NE *NE::clone() const
void ListTopDef::accept(Visitor *v)
{
v->visitListTopDef(this);
v->visitListTopDef(this);
}
ListTopDef *ListTopDef::clone() const
{
return new ListTopDef(*this);
return new ListTopDef(*this);
}
......@@ -3087,13 +3087,13 @@ ListTopDef *ListTopDef::clone() const
void ListArg::accept(Visitor *v)
{
v->visitListArg(this);
v->visitListArg(this);
}
ListArg *ListArg::clone() const
{
return new ListArg(*this);
return new ListArg(*this);
}
......@@ -3101,13 +3101,13 @@ ListArg *ListArg::clone() const
void ListClassBlockDef::accept(Visitor *v)
{
v->visitListClassBlockDef(this);
v->visitListClassBlockDef(this);
}
ListClassBlockDef *ListClassBlockDef::clone() const
{
return new ListClassBlockDef(*this);
return new ListClassBlockDef(*this);
}
......@@ -3115,13 +3115,13 @@ ListClassBlockDef *ListClassBlockDef::clone() const
void ListStmt::accept(Visitor *v)
{
v->visitListStmt(this);
v->visitListStmt(this);
}
ListStmt *ListStmt::clone() const
{
return new ListStmt(*this);
return new ListStmt(*this);
}
......@@ -3129,13 +3129,13 @@ ListStmt *ListStmt::clone() const
void ListItem::accept(Visitor *v)
{
v->visitListItem(this);
v->visitListItem(this);
}
ListItem *ListItem::clone() const
{
return new ListItem(*this);
return new ListItem(*this);
}
......@@ -3143,13 +3143,13 @@ ListItem *ListItem::clone() const
void ListType::accept(Visitor *v)
{
v->visitListType(this);
v->visitListType(this);
}
ListType *ListType::clone() const
{
return new ListType(*this);
return new ListType(*this);
}
......@@ -3157,15 +3157,11 @@ ListType *ListType::clone() const
void ListExpr::accept(Visitor *v)
{
v->visitListExpr(this);
v->visitListExpr(this);
}
ListExpr *ListExpr::clone() const
{
return new ListExpr(*this);
return new ListExpr(*this);
}
Absyn.h
View file @ 8072a075
......@@ -115,104 +115,104 @@ class PIdent;
class Visitor
{
public:
virtual ~Visitor() {}
virtual void visitProgram(Program *p) = 0;
virtual void visitTopDef(TopDef *p) = 0;
virtual void visitFunDef(FunDef *p) = 0;
virtual void visitArg(Arg *p) = 0;
virtual void visitClassDef(ClassDef *p) = 0;
virtual void visitClassBlock(ClassBlock *p) = 0;
virtual void visitClassBlockDef(ClassBlockDef *p) = 0;
virtual void visitBlock(Block *p) = 0;
virtual void visitStmt(Stmt *p) = 0;
virtual void visitItem(Item *p) = 0;
virtual void visitType(Type *p) = 0;
virtual void visitExpr(Expr *p) = 0;
virtual void visitAddOp(AddOp *p) = 0;
virtual void visitMulOp(MulOp *p) = 0;
virtual void visitRelOp(RelOp *p) = 0;
virtual void visitProg(Prog *p) = 0;
virtual void visitFnDef(FnDef *p) = 0;
virtual void visitClDef(ClDef *p) = 0;
virtual void visitFuncDef(FuncDef *p) = 0;
virtual void visitAr(Ar *p) = 0;
virtual void visitClassDefN(ClassDefN *p) = 0;
virtual void visitClassDefE(ClassDefE *p) = 0;
virtual void visitClassBl(ClassBl *p) = 0;
virtual void visitClassMthd(ClassMthd *p) = 0;
virtual void visitClassFld(ClassFld *p) = 0;
virtual void visitBlk(Blk *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 visitAss(Ass *p) = 0;
virtual void visitTableAss(TableAss *p) = 0;
virtual void visitTableIncr(TableIncr *p) = 0;
virtual void visitTableDecr(TableDecr *p) = 0;
virtual void visitIncr(Incr *p) = 0;
virtual void visitDecr(Decr *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 visitSExp(SExp *p) = 0;
virtual void visitForEach(ForEach *p) = 0;
virtual void visitInt(Int *p) = 0;
virtual void visitStr(Str *p) = 0;
virtual void visitBool(Bool *p) = 0;
virtual void visitVoid(Void *p) = 0;
virtual void visitArray(Array *p) = 0;
virtual void visitClassT(ClassT *p) = 0;
virtual void visitFun(Fun *p) = 0;
virtual void visitEVar(EVar *p) = 0;
virtual void visitELitInt(ELitInt *p) = 0;
virtual void visitELitTrue(ELitTrue *p) = 0;
virtual void visitELitFalse(ELitFalse *p) = 0;
virtual void visitEApp(EApp *p) = 0;
virtual void visitEString(EString *p) = 0;
virtual void visitENewArray(ENewArray *p) = 0;
virtual void visitENewClass(ENewClass *p) = 0;
virtual void visitEClsMmbr(EClsMmbr *p) = 0;
virtual void visitEClsMthd(EClsMthd *p) = 0;
virtual void visitNull(Null *p) = 0;
virtual void visitEIndexAcc(EIndexAcc *p) = 0;
virtual void visitECast(ECast *p) = 0;
virtual void visitNeg(Neg *p) = 0;
virtual void visitNot(Not *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 visitListTopDef(ListTopDef *p) = 0;
virtual void visitListArg(ListArg *p) = 0;
virtual void visitListClassBlockDef(ListClassBlockDef *p) = 0;
virtual void visitListStmt(ListStmt *p) = 0;
virtual void visitListItem(ListItem *p) = 0;
virtual void visitListType(ListType *p) = 0;
virtual void visitListExpr(ListExpr *p) = 0;
virtual void visitPIdent(PIdent *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;
virtual ~Visitor() {}
virtual void visitProgram(Program *p) = 0;
virtual void visitTopDef(TopDef *p) = 0;
virtual void visitFunDef(FunDef *p) = 0;
virtual void visitArg(Arg *p) = 0;
virtual void visitClassDef(ClassDef *p) = 0;
virtual void visitClassBlock(ClassBlock *p) = 0;
virtual void visitClassBlockDef(ClassBlockDef *p) = 0;
virtual void visitBlock(Block *p) = 0;
virtual void visitStmt(Stmt *p) = 0;
virtual void visitItem(Item *p) = 0;
virtual void visitType(Type *p) = 0;
virtual void visitExpr(Expr *p) = 0;
virtual void visitAddOp(AddOp *p) = 0;
virtual void visitMulOp(MulOp *p) = 0;
virtual void visitRelOp(RelOp *p) = 0;
virtual void visitProg(Prog *p) = 0;
virtual void visitFnDef(FnDef *p) = 0;
virtual void visitClDef(ClDef *p) = 0;
virtual void visitFuncDef(FuncDef *p) = 0;
virtual void visitAr(Ar *p) = 0;
virtual void visitClassDefN(ClassDefN *p) = 0;
virtual void visitClassDefE(ClassDefE *p) = 0;
virtual void visitClassBl(ClassBl *p) = 0;
virtual void visitClassMthd(ClassMthd *p) = 0;
virtual void visitClassFld(ClassFld *p) = 0;
virtual void visitBlk(Blk *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 visitAss(Ass *p) = 0;
virtual void visitTableAss(TableAss *p) = 0;
virtual void visitTableIncr(TableIncr *p) = 0;
virtual void visitTableDecr(TableDecr *p) = 0;
virtual void visitIncr(Incr *p) = 0;
virtual void visitDecr(Decr *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 visitSExp(SExp *p) = 0;
virtual void visitForEach(ForEach *p) = 0;
virtual void visitInt(Int *p) = 0;
virtual void visitStr(Str *p) = 0;
virtual void visitBool(Bool *p) = 0;
virtual void visitVoid(Void *p) = 0;
virtual void visitArray(Array *p) = 0;
virtual void visitClassT(ClassT *p) = 0;
virtual void visitFun(Fun *p) = 0;
virtual void visitEVar(EVar *p) = 0;
virtual void visitELitInt(ELitInt *p) = 0;
virtual void visitELitTrue(ELitTrue *p) = 0;
virtual void visitELitFalse(ELitFalse *p) = 0;
virtual void visitEApp(EApp *p) = 0;
virtual void visitEString(EString *p) = 0;
virtual void visitENewArray(ENewArray *p) = 0;
virtual void visitENewClass(ENewClass *p) = 0;
virtual void visitEClsMmbr(EClsMmbr *p) = 0;
virtual void visitEClsMthd(EClsMthd *p) = 0;
virtual void visitNull(Null *p) = 0;
virtual void visitEIndexAcc(EIndexAcc *p) = 0;
virtual void visitECast(ECast *p) = 0;
virtual void visitNeg(Neg *p) = 0;
virtual void visitNot(Not *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 visitListTopDef(ListTopDef *p) = 0;
virtual void visitListArg(ListArg *p) = 0;
virtual void visitListClassBlockDef(ListClassBlockDef *p) = 0;
virtual void visitListStmt(ListStmt *p) = 0;
virtual void visitListItem(ListItem *p) = 0;
virtual void visitListType(ListType *p) = 0;
virtual void visitListExpr(ListExpr *p) = 0;
virtual void visitPIdent(PIdent *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;
};
......@@ -220,8 +220,8 @@ public:
class Visitable
{
public:
virtual ~Visitable() {}
virtual void accept(Visitor *v) = 0;
virtual ~Visitable() {}
virtual void accept(Visitor *v) = 0;
};
......@@ -230,108 +230,108 @@ class Visitable
class Program : public Visitable
{
public:
virtual Program *clone() const = 0;
virtual Program *clone() const = 0;
};
class TopDef : public Visitable
{
public:
virtual TopDef *clone() const = 0;
virtual TopDef *clone() const = 0;
};
class FunDef : public Visitable
{
public:
virtual FunDef *clone() const = 0;
virtual FunDef *clone() const = 0;
};
class Arg : public Visitable
{
public:
virtual Arg *clone() const = 0;
virtual Arg *clone() const = 0;
};
class ClassDef : public Visitable
{
public:
virtual PIdent *getName() const = 0;
virtual PIdent *getParent() const = 0;
virtual ClassBlock *getBlock() const = 0;
virtual ClassDef *clone() const = 0;
virtual PIdent *getName() const = 0;
virtual PIdent *getParent() const = 0;
virtual ClassBlock *getBlock() const = 0;
virtual ClassDef *clone() const = 0;
};
class ClassBlock : public Visitable
{
public:
virtual ClassBlock *clone() const = 0;
virtual ClassBlock *clone() const = 0;
};
class ClassBlockDef : public Visitable
{
public:
virtual ClassBlockDef *clone() const = 0;
virtual ClassBlockDef *clone() const = 0;
};
class Block : public Visitable
{
public:
virtual Block *clone() const = 0;
virtual Block *clone() const = 0;
};
class Stmt : public Visitable
{
public:
virtual Stmt *clone() const = 0;
virtual Stmt *clone() const = 0;
};
class Item : public Visitable
{
public:
virtual Item *clone() const = 0;
virtual Item *clone() const = 0;
};
class Type : public Visitable
{
public:
virtual Type *clone() const = 0;
virtual Type *clone() const = 0;
};
class Expr : public Visitable
{
public:
virtual Expr *clone() const = 0;
virtual Expr *clone() const = 0;
};
class AddOp : public Visitable
{
public:
virtual AddOp *clone() const = 0;
virtual AddOp *clone() const = 0;
};
class MulOp : public Visitable
{
public:
virtual MulOp *clone() const = 0;
virtual MulOp *clone() const = 0;
};
class RelOp : public Visitable
{
public:
virtual RelOp *clone() const = 0;
virtual RelOp *clone() const = 0;
};
......@@ -340,980 +340,980 @@ public:
class PIdent : public Visitable
{
public:
String string_;
Integer integer_;
String string_;
Integer integer_;
PIdent(const PIdent &);
PIdent &operator=(const PIdent &);
PIdent(String p1, Integer p2);
~PIdent();
virtual void accept(Visitor *v);
virtual PIdent *clone() const;
void swap(PIdent &);
PIdent(const PIdent &);
PIdent &operator=(const PIdent &);
PIdent(String p1, Integer p2);
~PIdent();
virtual void accept(Visitor *v);
virtual PIdent *clone() const;
void swap(PIdent &);
};
class Prog : public Program
{
public:
ListTopDef *listtopdef_;
ListTopDef *listtopdef_;
Prog(const Prog &);
Prog &operator=(const Prog &);
Prog(ListTopDef *p1);
~Prog();
virtual void accept(Visitor *v);
virtual Prog *clone() const;
void swap(Prog &);
Prog(const Prog &);
Prog &operator=(const Prog &);
Prog(ListTopDef *p1);
~Prog();
virtual void accept(Visitor *v);
virtual Prog *clone() const;
void swap(Prog &);
};
class FnDef : public TopDef
{
public:
FunDef *fundef_;
FunDef *fundef_;
FnDef(const FnDef &);
FnDef &operator=(const FnDef &);
FnDef(FunDef *p1);
~FnDef();
virtual void accept(Visitor *v);
virtual FnDef *clone() const;
void swap(FnDef &);
FnDef(const FnDef &);
FnDef &operator=(const FnDef &);
FnDef(FunDef *p1);
~FnDef();
virtual void accept(Visitor *v);
virtual FnDef *clone() const;
void swap(FnDef &);
};
class ClDef : public TopDef
{
public:
ClassDef *classdef_;
ClassDef *classdef_;
ClDef(const ClDef &);
ClDef &operator=(const ClDef &);
ClDef(ClassDef *p1);
~ClDef();
virtual void accept(Visitor *v);
virtual ClDef *clone() const;
void swap(ClDef &);
ClDef(const ClDef &);
ClDef &operator=(const ClDef &);
ClDef(ClassDef *p1);
~ClDef();
virtual void accept(Visitor *v);
virtual ClDef *clone() const;
void swap(ClDef &);
};
class FuncDef : public FunDef
{
public:
Type *type_;
PIdent *pident_;
ListArg *listarg_;
Block *block_;
Type *type_;
PIdent *pident_;
ListArg *listarg_;
Block *block_;
FuncDef(const FuncDef &);
FuncDef &operator=(const FuncDef &);
FuncDef(Type *p1, PIdent *p2, ListArg *p3, Block *p4);
~FuncDef();
virtual void accept(Visitor *v);
virtual FuncDef *clone() const;
void swap(FuncDef &);
FuncDef(const FuncDef &);
FuncDef &operator=(const FuncDef &);
FuncDef(Type *p1, PIdent *p2, ListArg *p3, Block *p4);
~FuncDef();
virtual void accept(Visitor *v);
virtual FuncDef *clone() const;
void swap(FuncDef &);
};
class Ar : public Arg
{
public:
Type *type_;
PIdent *pident_;
Type *type_;
PIdent *pident_;
Ar(const Ar &);
Ar &operator=(const Ar &);
Ar(Type *p1, PIdent *p2);
~Ar();
virtual void accept(Visitor *v);
virtual Ar *clone() const;
void swap(Ar &);
Ar(const Ar &);
Ar &operator=(const Ar &);
Ar(Type *p1, PIdent *p2);
~Ar();
virtual void accept(Visitor *v);
virtual Ar *clone() const;
void swap(Ar &);
};
class ClassDefN : public ClassDef
{
public:
PIdent *pident_;
ClassBlock *classblock_;
PIdent *pident_;
ClassBlock *classblock_;
ClassDefN(const ClassDefN &);
ClassDefN &operator=(const ClassDefN &);
ClassDefN(PIdent *p1, ClassBlock *p2);
~ClassDefN();
virtual void accept(Visitor *v);
virtual ClassDefN *clone() const;
void swap(ClassDefN &);
ClassDefN(const ClassDefN &);
ClassDefN &operator=(const ClassDefN &);
ClassDefN(PIdent *p1, ClassBlock *p2);
~ClassDefN();
virtual void accept(Visitor *v);
virtual ClassDefN *clone() const;
void swap(ClassDefN &);
virtual PIdent *getName() const { return pident_; };
virtual PIdent *getParent() const { return NULL; };
virtual ClassBlock *getBlock() const { return classblock_; };
virtual PIdent *getName() const { return pident_; };
virtual PIdent *getParent() const { return NULL; };
virtual ClassBlock *getBlock() const { return classblock_; };
};
class ClassDefE : public ClassDef
{
public:
PIdent *pident_1;
PIdent *pident_2;
ClassBlock *classblock_;
PIdent *pident_1;
PIdent *pident_2;
ClassBlock *classblock_;
ClassDefE(const ClassDefE &);
ClassDefE &operator=(const ClassDefE &);
ClassDefE(PIdent *p1, PIdent *p2, ClassBlock *p3);
~ClassDefE();
virtual void accept(Visitor *v);
virtual ClassDefE *clone() const;
void swap(ClassDefE &);
ClassDefE(const ClassDefE &);
ClassDefE &operator=(const ClassDefE &);
ClassDefE(PIdent *p1, PIdent *p2, ClassBlock *p3);
~ClassDefE();
virtual void accept(Visitor *v);
virtual ClassDefE *clone() const;
void swap(ClassDefE &);
virtual PIdent *getName() const { return pident_1; };
virtual PIdent *getParent() const { return pident_2; };
virtual ClassBlock *getBlock() const { return classblock_; };
virtual PIdent *getName() const { return pident_1; };
virtual PIdent *getParent() const { return pident_2; };
virtual ClassBlock *getBlock() const { return classblock_; };
};
class ClassBl : public ClassBlock
{
public:
ListClassBlockDef *listclassblockdef_;
ListClassBlockDef *listclassblockdef_;
ClassBl(const ClassBl &);
ClassBl &operator=(const ClassBl &);
ClassBl(ListClassBlockDef *p1);
~ClassBl();
virtual void accept(Visitor *v);
virtual ClassBl *clone() const;
void swap(ClassBl &);
ClassBl(const ClassBl &);
ClassBl &operator=(const ClassBl &);
ClassBl(ListClassBlockDef *p1);
~ClassBl();
virtual void accept(Visitor *v);
virtual ClassBl *clone() const;
void swap(ClassBl &);
};
class ClassMthd : public ClassBlockDef
{
public:
FunDef *fundef_;
FunDef *fundef_;
ClassMthd(const ClassMthd &);
ClassMthd &operator=(const ClassMthd &);
ClassMthd(FunDef *p1);
~ClassMthd();
virtual void accept(Visitor *v);
virtual ClassMthd *clone() const;
void swap(ClassMthd &);
ClassMthd(const ClassMthd &);
ClassMthd &operator=(const ClassMthd &);
ClassMthd(FunDef *p1);
~ClassMthd();
virtual void accept(Visitor *v);
virtual ClassMthd *clone() const;
void swap(ClassMthd &);
};
class ClassFld : public ClassBlockDef
{
public:
Type *type_;
ListItem *listitem_;
Type *type_;
ListItem *listitem_;
ClassFld(const ClassFld &);
ClassFld &operator=(const ClassFld &);
ClassFld(Type *p1, ListItem *p2);
~ClassFld();
virtual void accept(Visitor *v);
virtual ClassFld *clone() const;
void swap(ClassFld &);
ClassFld(const ClassFld &);
ClassFld &operator=(const ClassFld &);
ClassFld(Type *p1, ListItem *p2);
~ClassFld();
virtual void accept(Visitor *v);
virtual ClassFld *clone() const;
void swap(ClassFld &);
};
class Blk : public Block
{
public:
ListStmt *liststmt_;
ListStmt *liststmt_;
Blk(const Blk &);
Blk &operator=(const Blk &);
Blk(ListStmt *p1);
~Blk();
virtual void accept(Visitor *v);
virtual Blk *clone() const;
void swap(Blk &);
Blk(const Blk &);
Blk &operator=(const Blk &);
Blk(ListStmt *p1);
~Blk();
virtual void accept(Visitor *v);
virtual Blk *clone() const;
void swap(Blk &);
};
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 &);
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:
Block *block_;
Block *block_;
BStmt(const BStmt &);
BStmt &operator=(const BStmt &);
BStmt(Block *p1);
~BStmt();
virtual void accept(Visitor *v);
virtual BStmt *clone() const;
void swap(BStmt &);
BStmt(const BStmt &);
BStmt &operator=(const BStmt &);
BStmt(Block *p1);
~BStmt();
virtual void accept(Visitor *v);
virtual BStmt *clone() const;
void swap(BStmt &);
};
class Decl : public Stmt
{
public:
Type *type_;
ListItem *listitem_;
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 &);
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 Ass : public Stmt
{
public:
Expr *expr_1;
Expr *expr_2;
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 &);
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 TableAss : public Stmt
{
public:
PIdent *pident_;
Expr *expr_1;
Expr *expr_2;
PIdent *pident_;
Expr *expr_1;
Expr *expr_2;
TableAss(const TableAss &);
TableAss &operator=(const TableAss &);
TableAss(PIdent *p1, Expr *p2, Expr *p3);
~TableAss();
virtual void accept(Visitor *v);
virtual TableAss *clone() const;
void swap(TableAss &);
TableAss(const TableAss &);
TableAss &operator=(const TableAss &);
TableAss(PIdent *p1, Expr *p2, Expr *p3);
~TableAss();
virtual void accept(Visitor *v);
virtual TableAss *clone() const;
void swap(TableAss &);
};
class TableIncr : public Stmt
{
public:
PIdent *pident_;
Expr *expr_;
PIdent *pident_;
Expr *expr_;
TableIncr(const TableIncr &);
TableIncr &operator=(const TableIncr &);
TableIncr(PIdent *p1, Expr *p2);
~TableIncr();
virtual void accept(Visitor *v);
virtual TableIncr *clone() const;
void swap(TableIncr &);
TableIncr(const TableIncr &);
TableIncr &operator=(const TableIncr &);
TableIncr(PIdent *p1, Expr *p2);
~TableIncr();
virtual void accept(Visitor *v);
virtual TableIncr *clone() const;
void swap(TableIncr &);
};
class TableDecr : public Stmt
{
public:
PIdent *pident_;
Expr *expr_;
PIdent *pident_;
Expr *expr_;
TableDecr(const TableDecr &);
TableDecr &operator=(const TableDecr &);
TableDecr(PIdent *p1, Expr *p2);
~TableDecr();
virtual void accept(Visitor *v);
virtual TableDecr *clone() const;
void swap(TableDecr &);
TableDecr(const TableDecr &);
TableDecr &operator=(const TableDecr &);
TableDecr(PIdent *p1, Expr *p2);
~TableDecr();
virtual void accept(Visitor *v);
virtual TableDecr *clone() const;
void swap(TableDecr &);
};
class Incr : public Stmt
{
public:
PIdent *pident_;
PIdent *pident_;
Incr(const Incr &);
Incr &operator=(const Incr &);
Incr(PIdent *p1);
~Incr();
virtual void accept(Visitor *v);
virtual Incr *clone() const;
void swap(Incr &);
Incr(const Incr &);
Incr &operator=(const Incr &);
Incr(PIdent *p1);
~Incr();
virtual void accept(Visitor *v);
virtual Incr *clone() const;
void swap(Incr &);
};
class Decr : public Stmt
{
public:
PIdent *pident_;
PIdent *pident_;
Decr(const Decr &);
Decr &operator=(const Decr &);
Decr(PIdent *p1);
~Decr();
virtual void accept(Visitor *v);
virtual Decr *clone() const;
void swap(Decr &);
Decr(const Decr &);
Decr &operator=(const Decr &);
Decr(PIdent *p1);
~Decr();
virtual void accept(Visitor *v);
virtual Decr *clone() const;
void swap(Decr &);
};
class Ret : public Stmt
{
public:
Expr *expr_;
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 &);
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 &);
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_;
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 &);
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;
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 &);
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_;
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 &);
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 SExp : public Stmt
{
public:
Expr *expr_;
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 &);
SExp(const SExp &);
SExp &operator=(const SExp &);
SExp(Expr *p1);
~SExp();
virtual void accept(Visitor *v);
virtual SExp *clone() const;
void swap(SExp &);
};
class ForEach : public Stmt
{
public:
Type *type_;
PIdent *pident_;
Expr *expr_;
Stmt *stmt_;
Type *type_;
PIdent *pident_;
Expr *expr_;
Stmt *stmt_;
ForEach(const ForEach &);
ForEach &operator=(const ForEach &);
ForEach(Type *p1, PIdent *p2, Expr *p3, Stmt *p4);
~ForEach();
virtual void accept(Visitor *v);
virtual ForEach *clone() const;
void swap(ForEach &);
ForEach(const ForEach &);
ForEach &operator=(const ForEach &);
ForEach(Type *p1, PIdent *p2, Expr *p3, Stmt *p4);
~ForEach();
virtual void accept(Visitor *v);
virtual ForEach *clone() const;
void swap(ForEach &);
};
class NoInit : public Item
{
public:
PIdent *pident_;
PIdent *pident_;
NoInit(const NoInit &);
NoInit &operator=(const NoInit &);
NoInit(PIdent *p1);
~NoInit();
virtual void accept(Visitor *v);
virtual NoInit *clone() const;
void swap(NoInit &);
NoInit(const NoInit &);
NoInit &operator=(const NoInit &);
NoInit(PIdent *p1);
~NoInit();
virtual void accept(Visitor *v);
virtual NoInit *clone() const;
void swap(NoInit &);
};
class Init : public Item
{
public:
PIdent *pident_;
Expr *expr_;
PIdent *pident_;
Expr *expr_;
Init(const Init &);
Init &operator=(const Init &);
Init(PIdent *p1, Expr *p2);
~Init();
virtual void accept(Visitor *v);
virtual Init *clone() const;
void swap(Init &);
Init(const Init &);
Init &operator=(const Init &);
Init(PIdent *p1, Expr *p2);
~Init();
virtual void accept(Visitor *v);
virtual Init *clone() const;
void swap(Init &);
};
class Int : public Type
{
public:
Int(const Int &);
Int &operator=(const Int &);
Int();
~Int();
virtual void accept(Visitor *v);
virtual Int *clone() const;
void swap(Int &);
Int(const Int &);
Int &operator=(const Int &);
Int();
~Int();
virtual void accept(Visitor *v);
virtual Int *clone() const;
void swap(Int &);
};
class Str : public Type
{
public:
Str(const Str &);
Str &operator=(const Str &);
Str();
~Str();
virtual void accept(Visitor *v);
virtual Str *clone() const;
void swap(Str &);
Str(const Str &);
Str &operator=(const Str &);
Str();
~Str();
virtual void accept(Visitor *v);
virtual Str *clone() const;
void swap(Str &);
};
class Bool : public Type
{
public:
Bool(const Bool &);
Bool &operator=(const Bool &);
Bool();
~Bool();
virtual void accept(Visitor *v);
virtual Bool *clone() const;
void swap(Bool &);
Bool(const Bool &);
Bool &operator=(const Bool &);
Bool();
~Bool();
virtual void accept(Visitor *v);
virtual Bool *clone() const;
void swap(Bool &);
};
class Void : public Type
{
public:
Void(const Void &);
Void &operator=(const Void &);
Void();
~Void();
virtual void accept(Visitor *v);
virtual Void *clone() const;
void swap(Void &);
Void(const Void &);
Void &operator=(const Void &);
Void();
~Void();
virtual void accept(Visitor *v);
virtual Void *clone() const;
void swap(Void &);
};
class Array : public Type
{
public:
Type *type_;
Type *type_;
Array(const Array &);
Array &operator=(const Array &);
Array(Type *p1);
~Array();
virtual void accept(Visitor *v);
virtual Array *clone() const;
void swap(Array &);
Array(const Array &);
Array &operator=(const Array &);
Array(Type *p1);
~Array();
virtual void accept(Visitor *v);
virtual Array *clone() const;
void swap(Array &);
};
class ClassT : public Type
{
public:
PIdent *pident_;
PIdent *pident_;
ClassT(const ClassT &);
ClassT &operator=(const ClassT &);
ClassT(PIdent *p1);
~ClassT();
virtual void accept(Visitor *v);
virtual ClassT *clone() const;
void swap(ClassT &);
ClassT(const ClassT &);
ClassT &operator=(const ClassT &);
ClassT(PIdent *p1);
~ClassT();
virtual void accept(Visitor *v);
virtual ClassT *clone() const;
void swap(ClassT &);
};
class Fun : public Type
{
public:
Type *type_;
ListType *listtype_;
Type *type_;
ListType *listtype_;
Fun(const Fun &);
Fun &operator=(const Fun &);
Fun(Type *p1, ListType *p2);
~Fun();
virtual void accept(Visitor *v);
virtual Fun *clone() const;
void swap(Fun &);
Fun(const Fun &);
Fun &operator=(const Fun &);
Fun(Type *p1, ListType *p2);
~Fun();
virtual void accept(Visitor *v);
virtual Fun *clone() const;
void swap(Fun &);
};
class EVar : public Expr
{
public:
PIdent *pident_;
PIdent *pident_;
EVar(const EVar &);
EVar &operator=(const EVar &);
EVar(PIdent *p1);
~EVar();
virtual void accept(Visitor *v);
virtual EVar *clone() const;
void swap(EVar &);
EVar(const EVar &);
EVar &operator=(const EVar &);
EVar(PIdent *p1);
~EVar();
virtual void accept(Visitor *v);
virtual EVar *clone() const;
void swap(EVar &);
};
class ELitInt : public Expr
{
public:
Integer integer_;
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 &);
ELitInt(const ELitInt &);
ELitInt &operator=(const ELitInt &);
ELitInt(Integer p1);
~ELitInt();
virtual void accept(Visitor *v);
virtual ELitInt *clone() const;
void swap(ELitInt &);
};
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 &);
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 &);
ELitFalse(const ELitFalse &);
ELitFalse &operator=(const ELitFalse &);
ELitFalse();
~ELitFalse();
virtual void accept(Visitor *v);
virtual ELitFalse *clone() const;
void swap(ELitFalse &);
};
class EApp : public Expr
{
public:
PIdent *pident_;
ListExpr *listexpr_;
PIdent *pident_;
ListExpr *listexpr_;
EApp(const EApp &);
EApp &operator=(const EApp &);
EApp(PIdent *p1, ListExpr *p2);
~EApp();
virtual void accept(Visitor *v);
virtual EApp *clone() const;
void swap(EApp &);
EApp(const EApp &);
EApp &operator=(const EApp &);
EApp(PIdent *p1, ListExpr *p2);
~EApp();
virtual void accept(Visitor *v);
virtual EApp *clone() const;
void swap(EApp &);
};
class EString : public Expr
{
public:
String string_;
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 &);
EString(const EString &);
EString &operator=(const EString &);
EString(String p1);
~EString();
virtual void accept(Visitor *v);
virtual EString *clone() const;
void swap(EString &);
};
class ENewArray : public Expr
{
public:
Type *type_;
Expr *expr_;
Type *type_;
Expr *expr_;
ENewArray(const ENewArray &);
ENewArray &operator=(const ENewArray &);
ENewArray(Type *p1, Expr *p2);
~ENewArray();
virtual void accept(Visitor *v);
virtual ENewArray *clone() const;
void swap(ENewArray &);
ENewArray(const ENewArray &);
ENewArray &operator=(const ENewArray &);
ENewArray(Type *p1, Expr *p2);
~ENewArray();
virtual void accept(Visitor *v);
virtual ENewArray *clone() const;
void swap(ENewArray &);
};
class ENewClass : public Expr
{
public:
PIdent *pident_;
PIdent *pident_;
ENewClass(const ENewClass &);
ENewClass &operator=(const ENewClass &);
ENewClass(PIdent *p1);
~ENewClass();
virtual void accept(Visitor *v);
virtual ENewClass *clone() const;
void swap(ENewClass &);
ENewClass(const ENewClass &);
ENewClass &operator=(const ENewClass &);
ENewClass(PIdent *p1);
~ENewClass();
virtual void accept(Visitor *v);
virtual ENewClass *clone() const;
void swap(ENewClass &);
};
class EClsMmbr : public Expr
{
public:
Expr *expr_;
PIdent *pident_;
Expr *expr_;
PIdent *pident_;
EClsMmbr(const EClsMmbr &);
EClsMmbr &operator=(const EClsMmbr &);
EClsMmbr(Expr *p1, PIdent *p2);
~EClsMmbr();
virtual void accept(Visitor *v);
virtual EClsMmbr *clone() const;
void swap(EClsMmbr &);
EClsMmbr(const EClsMmbr &);
EClsMmbr &operator=(const EClsMmbr &);
EClsMmbr(Expr *p1, PIdent *p2);
~EClsMmbr();
virtual void accept(Visitor *v);
virtual EClsMmbr *clone() const;
void swap(EClsMmbr &);
};
class EClsMthd : public Expr
{
public:
Expr *expr_;
PIdent *pident_;
ListExpr *listexpr_;
Expr *expr_;
PIdent *pident_;
ListExpr *listexpr_;
EClsMthd(const EClsMthd &);
EClsMthd &operator=(const EClsMthd &);
EClsMthd(Expr *p1, PIdent *p2, ListExpr *p3);
~EClsMthd();
virtual void accept(Visitor *v);
virtual EClsMthd *clone() const;
void swap(EClsMthd &);
EClsMthd(const EClsMthd &);
EClsMthd &operator=(const EClsMthd &);
EClsMthd(Expr *p1, PIdent *p2, ListExpr *p3);
~EClsMthd();
virtual void accept(Visitor *v);
virtual EClsMthd *clone() const;
void swap(EClsMthd &);
};
class Null : public Expr
{
public:
Null(const Null &);
Null &operator=(const Null &);
Null();
~Null();
virtual void accept(Visitor *v);
virtual Null *clone() const;
void swap(Null &);
Null(const Null &);
Null &operator=(const Null &);
Null();
~Null();
virtual void accept(Visitor *v);
virtual Null *clone() const;
void swap(Null &);
};
class EIndexAcc : public Expr
{
public:
PIdent *pident_;
Expr *expr_;
PIdent *pident_;
Expr *expr_;
EIndexAcc(const EIndexAcc &);
EIndexAcc &operator=(const EIndexAcc &);
EIndexAcc(PIdent *p1, Expr *p2);
~EIndexAcc();
virtual void accept(Visitor *v);
virtual EIndexAcc *clone() const;
void swap(EIndexAcc &);
EIndexAcc(const EIndexAcc &);
EIndexAcc &operator=(const EIndexAcc &);
EIndexAcc(PIdent *p1, Expr *p2);
~EIndexAcc();
virtual void accept(Visitor *v);
virtual EIndexAcc *clone() const;
void swap(EIndexAcc &);
};
class ECast : public Expr
{
public:
PIdent *pident_;
Expr *expr_;
PIdent *pident_;
Expr *expr_;
ECast(const ECast &);
ECast &operator=(const ECast &);
ECast(PIdent *p1, Expr *p2);
~ECast();
virtual void accept(Visitor *v);
virtual ECast *clone() const;
void swap(ECast &);
ECast(const ECast &);
ECast &operator=(const ECast &);
ECast(PIdent *p1, Expr *p2);
~ECast();
virtual void accept(Visitor *v);
virtual ECast *clone() const;
void swap(ECast &);
};
class Neg : public Expr
{
public:
Expr *expr_;
Expr *expr_;
Neg(const Neg &);
Neg &operator=(const Neg &);
Neg(Expr *p1);
~Neg();
virtual void accept(Visitor *v);
virtual Neg *clone() const;
void swap(Neg &);
Neg(const Neg &);
Neg &operator=(const Neg &);
Neg(Expr *p1);
~Neg();
virtual void accept(Visitor *v);
virtual Neg *clone() const;
void swap(Neg &);
};
class Not : public Expr
{
public:
Expr *expr_;
Expr *expr_;
Not(const Not &);
Not &operator=(const Not &);
Not(Expr *p1);
~Not();
virtual void accept(Visitor *v);
virtual Not *clone() const;
void swap(Not &);
Not(const Not &);
Not &operator=(const Not &);
Not(Expr *p1);
~Not();
virtual void accept(Visitor *v);
virtual Not *clone() const;
void swap(Not &);
};
class EMul : public Expr
{
public:
Expr *expr_1;
MulOp *mulop_;
Expr *expr_2;
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 &);
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;
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 &);
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;
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 &);
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;
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 &);
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;
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 &);
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 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 &);
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 &);
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 &);
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 &);
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 &);
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 &);
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 &);
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 &);
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 &);
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 &);
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 &);
NE(const NE &);
NE &operator=(const NE &);
NE();
~NE();
virtual void accept(Visitor *v);
virtual NE *clone() const;
void swap(NE &);
};
......@@ -1321,50 +1321,50 @@ public:
class ListTopDef : public Visitable, public std::vector<TopDef*>
{
public:
virtual void accept(Visitor *v);
virtual ListTopDef *clone() const;
virtual void accept(Visitor *v);
virtual ListTopDef *clone() const;
};
class ListArg : public Visitable, public std::vector<Arg*>
{
public:
virtual void accept(Visitor *v);
virtual ListArg *clone() const;
virtual void accept(Visitor *v);
virtual ListArg *clone() const;
};
class ListClassBlockDef : public Visitable, public std::vector<ClassBlockDef*>
{
public:
virtual void accept(Visitor *v);
virtual ListClassBlockDef *clone() const;
virtual void accept(Visitor *v);
virtual ListClassBlockDef *clone() const;
};
class ListStmt : public Visitable, public std::vector<Stmt*>
{
public:
virtual void accept(Visitor *v);
virtual ListStmt *clone() const;
virtual void accept(Visitor *v);
virtual ListStmt *clone() const;
};
class ListItem : public Visitable, public std::vector<Item*>
{
public:
virtual void accept(Visitor *v);
virtual ListItem *clone() const;
virtual void accept(Visitor *v);
virtual ListItem *clone() const;
};
class ListType : public Visitable, public std::vector<Type*>
{
public:
virtual void accept(Visitor *v);
virtual ListType *clone() const;
virtual void accept(Visitor *v);
virtual ListType *clone() const;
};
class ListExpr : public Visitable, public std::vector<Expr*>
{
public:
virtual void accept(Visitor *v);
virtual ListExpr *clone() const;
virtual void accept(Visitor *v);
virtual ListExpr *clone() const;
};
......
Parser.cpp
View file @ 8072a075
This source diff could not be displayed because it is too large. You can view the blob instead.
Parser.h
View file @ 8072a075
......@@ -30,32 +30,32 @@ class RelOp;
typedef union
{
int int_;
char char_;
double double_;
char* string_;
Program* program_;
TopDef* topdef_;
ListTopDef* listtopdef_;
FunDef* fundef_;
Arg* arg_;
ListArg* listarg_;
ClassDef* classdef_;
ClassBlock* classblock_;
ClassBlockDef* classblockdef_;
ListClassBlockDef* listclassblockdef_;
Block* block_;
ListStmt* liststmt_;
Stmt* stmt_;
Item* item_;
ListItem* listitem_;
Type* type_;
ListType* listtype_;
Expr* expr_;
ListExpr* listexpr_;
AddOp* addop_;
MulOp* mulop_;
RelOp* relop_;
int int_;
char char_;
double double_;
char* string_;
Program* program_;
TopDef* topdef_;
ListTopDef* listtopdef_;
FunDef* fundef_;
Arg* arg_;
ListArg* listarg_;
ClassDef* classdef_;
ClassBlock* classblock_;
ClassBlockDef* classblockdef_;
ListClassBlockDef* listclassblockdef_;
Block* block_;
ListStmt* liststmt_;
Stmt* stmt_;
Item* item_;
ListItem* listitem_;
Type* type_;
ListType* listtype_;
Expr* expr_;
ListExpr* listexpr_;
AddOp* addop_;
MulOp* mulop_;
RelOp* relop_;
} YYSTYPE;
Program* pProgram(FILE *inp);
......
Printer.cpp
View file @ 8072a075
......@@ -8,97 +8,97 @@
//You may wish to change render
void PrintAbsyn::render(Char c)
{
if (c == '{')
{
bufAppend('\n');
indent();
bufAppend(c);
_n_ = _n_ + INDENT_WIDTH;
bufAppend('\n');
indent();
}
else if (c == '(' || c == '[')
bufAppend(c);
else if (c == ')' || c == ']')
{
backup();
bufAppend(c);
}
else if (c == '}')
{
int t;
_n_ = _n_ - INDENT_WIDTH;
for (t=0; t<INDENT_WIDTH; t++) {
backup();
}
bufAppend(c);
bufAppend('\n');
indent();
}
else if (c == ',')
{
backup();
bufAppend(c);
bufAppend(' ');
}
else if (c == ';')
{
backup();
bufAppend(c);
bufAppend('\n');
indent();
}
else if (c == 0) return;
else
{
bufAppend(' ');
bufAppend(c);
bufAppend(' ');
}
if (c == '{')
{
bufAppend('\n');
indent();
bufAppend(c);
_n_ = _n_ + INDENT_WIDTH;
bufAppend('\n');
indent();
}
else if (c == '(' || c == '[')
bufAppend(c);
else if (c == ')' || c == ']')
{
backup();
bufAppend(c);
}
else if (c == '}')
{
int t;
_n_ = _n_ - INDENT_WIDTH;
for (t=0; t<INDENT_WIDTH; t++) {
backup();
}
bufAppend(c);
bufAppend('\n');
indent();
}
else if (c == ',')
{
backup();
bufAppend(c);
bufAppend(' ');
}
else if (c == ';')
{
backup();
bufAppend(c);
bufAppend('\n');
indent();
}
else if (c == 0) return;
else
{
bufAppend(' ');
bufAppend(c);
bufAppend(' ');
}
}
void PrintAbsyn::render(String s_)
{
const char *s = s_.c_str() ;
if(strlen(s) > 0)
{
bufAppend(s);
bufAppend(' ');
}
const char *s = s_.c_str() ;
if(strlen(s) > 0)
{
bufAppend(s);
bufAppend(' ');
}
}
void PrintAbsyn::render(const char *s)
{
if(strlen(s) > 0)
{
bufAppend(s);
bufAppend(' ');
}
if(strlen(s) > 0)
{
bufAppend(s);
bufAppend(' ');
}
}
void PrintAbsyn::indent()
{
int n = _n_;
while (n > 0)
{
bufAppend(' ');
n--;
}
int n = _n_;
while (n > 0)
{
bufAppend(' ');
n--;
}
}
void PrintAbsyn::backup()
{
if (buf_[cur_ - 1] == ' ')
{
buf_[cur_ - 1] = 0;
cur_--;
}
if (buf_[cur_ - 1] == ' ')
{
buf_[cur_ - 1] = 0;
cur_--;
}
}
PrintAbsyn::PrintAbsyn(void)
{
_i_ = 0; _n_ = 0;
buf_ = 0;
bufReset();
_i_ = 0; _n_ = 0;
buf_ = 0;
bufReset();
}
PrintAbsyn::~PrintAbsyn(void)
......@@ -107,1053 +107,1053 @@ PrintAbsyn::~PrintAbsyn(void)
char *PrintAbsyn::print(Visitable *v)
{
_i_ = 0; _n_ = 0;
bufReset();
v->accept(this);
return buf_;
_i_ = 0; _n_ = 0;
bufReset();
v->accept(this);
return buf_;
}
void PrintAbsyn::visitPIdent(PIdent *p)
{
visitIdent(p->string_);
visitIdent(p->string_);
}
void PrintAbsyn::visitProgram(Program *p) {} //abstract class
void PrintAbsyn::visitProg(Prog *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
if(p->listtopdef_) {_i_ = 0; p->listtopdef_->accept(this);}
if(p->listtopdef_) {_i_ = 0; p->listtopdef_->accept(this);}
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitTopDef(TopDef *p) {} //abstract class
void PrintAbsyn::visitFnDef(FnDef *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->fundef_->accept(this);
_i_ = 0; p->fundef_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitClDef(ClDef *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->classdef_->accept(this);
_i_ = 0; p->classdef_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitListTopDef(ListTopDef *listtopdef)
{
for (ListTopDef::const_iterator i = listtopdef->begin() ; i != listtopdef->end() ; ++i)
{
(*i)->accept(this);
if (i != listtopdef->end() - 1) render("");
}
for (ListTopDef::const_iterator i = listtopdef->begin() ; i != listtopdef->end() ; ++i)
{
(*i)->accept(this);
if (i != listtopdef->end() - 1) render("");
}
}void PrintAbsyn::visitFunDef(FunDef *p) {} //abstract class
void PrintAbsyn::visitFuncDef(FuncDef *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->type_->accept(this);
visitPIdent(p->pident_);
render('(');
if(p->listarg_) {_i_ = 0; p->listarg_->accept(this);}
render(')');
_i_ = 0; p->block_->accept(this);
_i_ = 0; p->type_->accept(this);
visitPIdent(p->pident_);
render('(');
if(p->listarg_) {_i_ = 0; p->listarg_->accept(this);}
render(')');
_i_ = 0; p->block_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitArg(Arg *p) {} //abstract class
void PrintAbsyn::visitAr(Ar *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->type_->accept(this);
visitPIdent(p->pident_);
_i_ = 0; p->type_->accept(this);
visitPIdent(p->pident_);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitListArg(ListArg *listarg)
{
for (ListArg::const_iterator i = listarg->begin() ; i != listarg->end() ; ++i)
{
(*i)->accept(this);
if (i != listarg->end() - 1) render(',');
}
for (ListArg::const_iterator i = listarg->begin() ; i != listarg->end() ; ++i)
{
(*i)->accept(this);
if (i != listarg->end() - 1) render(',');
}
}void PrintAbsyn::visitClassDef(ClassDef *p) {} //abstract class
void PrintAbsyn::visitClassDefN(ClassDefN *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("class");
visitPIdent(p->pident_);
_i_ = 0; p->classblock_->accept(this);
render("class");
visitPIdent(p->pident_);
_i_ = 0; p->classblock_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitClassDefE(ClassDefE *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("class");
visitPIdent(p->pident_1);
render("extends");
visitPIdent(p->pident_2);
_i_ = 0; p->classblock_->accept(this);
render("class");
visitPIdent(p->pident_1);
render("extends");
visitPIdent(p->pident_2);
_i_ = 0; p->classblock_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitClassBlock(ClassBlock *p) {} //abstract class
void PrintAbsyn::visitClassBl(ClassBl *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render('{');
if(p->listclassblockdef_) {_i_ = 0; p->listclassblockdef_->accept(this);}
render('}');
render('{');
if(p->listclassblockdef_) {_i_ = 0; p->listclassblockdef_->accept(this);}
render('}');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitClassBlockDef(ClassBlockDef *p) {} //abstract class
void PrintAbsyn::visitClassMthd(ClassMthd *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->fundef_->accept(this);
_i_ = 0; p->fundef_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitClassFld(ClassFld *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->type_->accept(this);
if(p->listitem_) {_i_ = 0; p->listitem_->accept(this);}
render(';');
_i_ = 0; p->type_->accept(this);
if(p->listitem_) {_i_ = 0; p->listitem_->accept(this);}
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitListClassBlockDef(ListClassBlockDef *listclassblockdef)
{
for (ListClassBlockDef::const_iterator i = listclassblockdef->begin() ; i != listclassblockdef->end() ; ++i)
{
(*i)->accept(this);
render("");
}
for (ListClassBlockDef::const_iterator i = listclassblockdef->begin() ; i != listclassblockdef->end() ; ++i)
{
(*i)->accept(this);
render("");
}
}void PrintAbsyn::visitBlock(Block *p) {} //abstract class
void PrintAbsyn::visitBlk(Blk *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render('{');
if(p->liststmt_) {_i_ = 0; p->liststmt_->accept(this);}
render('}');
render('{');
if(p->liststmt_) {_i_ = 0; p->liststmt_->accept(this);}
render('}');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitListStmt(ListStmt *liststmt)
{
for (ListStmt::const_iterator i = liststmt->begin() ; i != liststmt->end() ; ++i)
{
(*i)->accept(this);
render("");
}
for (ListStmt::const_iterator i = liststmt->begin() ; i != liststmt->end() ; ++i)
{
(*i)->accept(this);
render("");
}
}void PrintAbsyn::visitStmt(Stmt *p) {} //abstract class
void PrintAbsyn::visitEmpty(Empty *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render(';');
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitBStmt(BStmt *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->block_->accept(this);
_i_ = 0; p->block_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitDecl(Decl *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->type_->accept(this);
if(p->listitem_) {_i_ = 0; p->listitem_->accept(this);}
render(';');
_i_ = 0; p->type_->accept(this);
if(p->listitem_) {_i_ = 0; p->listitem_->accept(this);}
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitAss(Ass *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->expr_1->accept(this);
render('=');
_i_ = 0; p->expr_2->accept(this);
render(';');
_i_ = 0; p->expr_1->accept(this);
render('=');
_i_ = 0; p->expr_2->accept(this);
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitTableAss(TableAss *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
visitPIdent(p->pident_);
render('[');
_i_ = 0; p->expr_1->accept(this);
render(']');
render('=');
_i_ = 0; p->expr_2->accept(this);
render(';');
visitPIdent(p->pident_);
render('[');
_i_ = 0; p->expr_1->accept(this);
render(']');
render('=');
_i_ = 0; p->expr_2->accept(this);
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitTableIncr(TableIncr *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
visitPIdent(p->pident_);
render('[');
_i_ = 0; p->expr_->accept(this);
render(']');
render("++");
render(';');
visitPIdent(p->pident_);
render('[');
_i_ = 0; p->expr_->accept(this);
render(']');
render("++");
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitTableDecr(TableDecr *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
visitPIdent(p->pident_);
render('[');
_i_ = 0; p->expr_->accept(this);
render(']');
render("--");
render(';');
visitPIdent(p->pident_);
render('[');
_i_ = 0; p->expr_->accept(this);
render(']');
render("--");
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitIncr(Incr *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
visitPIdent(p->pident_);
render("++");
render(';');
visitPIdent(p->pident_);
render("++");
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitDecr(Decr *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
visitPIdent(p->pident_);
render("--");
render(';');
visitPIdent(p->pident_);
render("--");
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitRet(Ret *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("return");
_i_ = 0; p->expr_->accept(this);
render(';');
render("return");
_i_ = 0; p->expr_->accept(this);
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitVRet(VRet *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("return");
render(';');
render("return");
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitCond(Cond *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("if");
render('(');
_i_ = 0; p->expr_->accept(this);
render(')');
_i_ = 0; p->stmt_->accept(this);
render("if");
render('(');
_i_ = 0; p->expr_->accept(this);
render(')');
_i_ = 0; p->stmt_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitCondElse(CondElse *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("if");
render('(');
_i_ = 0; p->expr_->accept(this);
render(')');
_i_ = 0; p->stmt_1->accept(this);
render("else");
_i_ = 0; p->stmt_2->accept(this);
render("if");
render('(');
_i_ = 0; p->expr_->accept(this);
render(')');
_i_ = 0; p->stmt_1->accept(this);
render("else");
_i_ = 0; p->stmt_2->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitWhile(While *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("while");
render('(');
_i_ = 0; p->expr_->accept(this);
render(')');
_i_ = 0; p->stmt_->accept(this);
render("while");
render('(');
_i_ = 0; p->expr_->accept(this);
render(')');
_i_ = 0; p->stmt_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitSExp(SExp *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->expr_->accept(this);
render(';');
_i_ = 0; p->expr_->accept(this);
render(';');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitForEach(ForEach *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("for");
render('(');
_i_ = 0; p->type_->accept(this);
visitPIdent(p->pident_);
render(':');
_i_ = 0; p->expr_->accept(this);
render(')');
_i_ = 0; p->stmt_->accept(this);
render("for");
render('(');
_i_ = 0; p->type_->accept(this);
visitPIdent(p->pident_);
render(':');
_i_ = 0; p->expr_->accept(this);
render(')');
_i_ = 0; p->stmt_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitItem(Item *p) {} //abstract class
void PrintAbsyn::visitNoInit(NoInit *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
visitPIdent(p->pident_);
visitPIdent(p->pident_);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitInit(Init *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
visitPIdent(p->pident_);
render('=');
_i_ = 0; p->expr_->accept(this);
visitPIdent(p->pident_);
render('=');
_i_ = 0; p->expr_->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitListItem(ListItem *listitem)
{
for (ListItem::const_iterator i = listitem->begin() ; i != listitem->end() ; ++i)
{
(*i)->accept(this);
if (i != listitem->end() - 1) render(',');
}
for (ListItem::const_iterator i = listitem->begin() ; i != listitem->end() ; ++i)
{
(*i)->accept(this);
if (i != listitem->end() - 1) render(',');
}
}void PrintAbsyn::visitType(Type *p) {} //abstract class
void PrintAbsyn::visitInt(Int *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("int");
render("int");
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitStr(Str *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("string");
render("string");
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitBool(Bool *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("boolean");
render("boolean");
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitVoid(Void *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("void");
render("void");
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitArray(Array *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 0; p->type_->accept(this);
render('[');
render(']');
_i_ = 0; p->type_->accept(this);
render('[');
render(']');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitClassT(ClassT *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
visitPIdent(p->pident_);
visitPIdent(p->pident_);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitFun(Fun *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
/* Internal Category */
/* Internal Category */
_i_ = 0; p->type_->accept(this);
render('(');
if(p->listtype_) {_i_ = 0; p->listtype_->accept(this);}
render(')');
_i_ = 0; p->type_->accept(this);
render('(');
if(p->listtype_) {_i_ = 0; p->listtype_->accept(this);}
render(')');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitListType(ListType *listtype)
{
for (ListType::const_iterator i = listtype->begin() ; i != listtype->end() ; ++i)
{
(*i)->accept(this);
if (i != listtype->end() - 1) render(',');
}
for (ListType::const_iterator i = listtype->begin() ; i != listtype->end() ; ++i)
{
(*i)->accept(this);
if (i != listtype->end() - 1) render(',');
}
}void PrintAbsyn::visitExpr(Expr *p) {} //abstract class
void PrintAbsyn::visitEVar(EVar *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
visitPIdent(p->pident_);
visitPIdent(p->pident_);
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitELitInt(ELitInt *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
visitInteger(p->integer_);
visitInteger(p->integer_);
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitELitTrue(ELitTrue *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
render("true");
render("true");
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitELitFalse(ELitFalse *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
render("false");
render("false");
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitEApp(EApp *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
visitPIdent(p->pident_);
render('(');
if(p->listexpr_) {_i_ = 0; p->listexpr_->accept(this);}
render(')');
visitPIdent(p->pident_);
render('(');
if(p->listexpr_) {_i_ = 0; p->listexpr_->accept(this);}
render(')');
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitEString(EString *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
visitString(p->string_);
visitString(p->string_);
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitENewArray(ENewArray *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
render("new");
_i_ = 0; p->type_->accept(this);
render('[');
_i_ = 0; p->expr_->accept(this);
render(']');
render("new");
_i_ = 0; p->type_->accept(this);
render('[');
_i_ = 0; p->expr_->accept(this);
render(']');
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitENewClass(ENewClass *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
render("new");
visitPIdent(p->pident_);
render("new");
visitPIdent(p->pident_);
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitEClsMmbr(EClsMmbr *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
_i_ = 6; p->expr_->accept(this);
render('.');
visitPIdent(p->pident_);
_i_ = 6; p->expr_->accept(this);
render('.');
visitPIdent(p->pident_);
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitEClsMthd(EClsMthd *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
_i_ = 6; p->expr_->accept(this);
render('.');
visitPIdent(p->pident_);
render('(');
if(p->listexpr_) {_i_ = 0; p->listexpr_->accept(this);}
render(')');
_i_ = 6; p->expr_->accept(this);
render('.');
visitPIdent(p->pident_);
render('(');
if(p->listexpr_) {_i_ = 0; p->listexpr_->accept(this);}
render(')');
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitNull(Null *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
render("null");
render("null");
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitEIndexAcc(EIndexAcc *p)
{
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
int oldi = _i_;
if (oldi > 6) render(_L_PAREN);
visitPIdent(p->pident_);
render('[');
_i_ = 0; p->expr_->accept(this);
render(']');
visitPIdent(p->pident_);
render('[');
_i_ = 0; p->expr_->accept(this);
render(']');
if (oldi > 6) render(_R_PAREN);
if (oldi > 6) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitECast(ECast *p)
{
int oldi = _i_;
if (oldi > 5) render(_L_PAREN);
int oldi = _i_;
if (oldi > 5) render(_L_PAREN);
render('(');
visitPIdent(p->pident_);
render(')');
_i_ = 5; p->expr_->accept(this);
render('(');
visitPIdent(p->pident_);
render(')');
_i_ = 5; p->expr_->accept(this);
if (oldi > 5) render(_R_PAREN);
if (oldi > 5) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitNeg(Neg *p)
{
int oldi = _i_;
if (oldi > 5) render(_L_PAREN);
int oldi = _i_;
if (oldi > 5) render(_L_PAREN);
render('-');
_i_ = 6; p->expr_->accept(this);
render('-');
_i_ = 6; p->expr_->accept(this);
if (oldi > 5) render(_R_PAREN);
if (oldi > 5) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitNot(Not *p)
{
int oldi = _i_;
if (oldi > 5) render(_L_PAREN);
int oldi = _i_;
if (oldi > 5) render(_L_PAREN);
render('!');
_i_ = 6; p->expr_->accept(this);
render('!');
_i_ = 6; p->expr_->accept(this);
if (oldi > 5) render(_R_PAREN);
if (oldi > 5) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitEMul(EMul *p)
{
int oldi = _i_;
if (oldi > 4) render(_L_PAREN);
int oldi = _i_;
if (oldi > 4) render(_L_PAREN);
_i_ = 4; p->expr_1->accept(this);
_i_ = 0; p->mulop_->accept(this);
_i_ = 5; p->expr_2->accept(this);
_i_ = 4; p->expr_1->accept(this);
_i_ = 0; p->mulop_->accept(this);
_i_ = 5; p->expr_2->accept(this);
if (oldi > 4) render(_R_PAREN);
if (oldi > 4) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitEAdd(EAdd *p)
{
int oldi = _i_;
if (oldi > 3) render(_L_PAREN);
int oldi = _i_;
if (oldi > 3) render(_L_PAREN);
_i_ = 3; p->expr_1->accept(this);
_i_ = 0; p->addop_->accept(this);
_i_ = 4; p->expr_2->accept(this);
_i_ = 3; p->expr_1->accept(this);
_i_ = 0; p->addop_->accept(this);
_i_ = 4; p->expr_2->accept(this);
if (oldi > 3) render(_R_PAREN);
if (oldi > 3) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitERel(ERel *p)
{
int oldi = _i_;
if (oldi > 2) render(_L_PAREN);
int oldi = _i_;
if (oldi > 2) render(_L_PAREN);
_i_ = 2; p->expr_1->accept(this);
_i_ = 0; p->relop_->accept(this);
_i_ = 3; p->expr_2->accept(this);
_i_ = 2; p->expr_1->accept(this);
_i_ = 0; p->relop_->accept(this);
_i_ = 3; p->expr_2->accept(this);
if (oldi > 2) render(_R_PAREN);
if (oldi > 2) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitEAnd(EAnd *p)
{
int oldi = _i_;
if (oldi > 1) render(_L_PAREN);
int oldi = _i_;
if (oldi > 1) render(_L_PAREN);
_i_ = 2; p->expr_1->accept(this);
render("&&");
_i_ = 1; p->expr_2->accept(this);
_i_ = 2; p->expr_1->accept(this);
render("&&");
_i_ = 1; p->expr_2->accept(this);
if (oldi > 1) render(_R_PAREN);
if (oldi > 1) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitEOr(EOr *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
_i_ = 1; p->expr_1->accept(this);
render("||");
_i_ = 0; p->expr_2->accept(this);
_i_ = 1; p->expr_1->accept(this);
render("||");
_i_ = 0; p->expr_2->accept(this);
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitListExpr(ListExpr *listexpr)
{
for (ListExpr::const_iterator i = listexpr->begin() ; i != listexpr->end() ; ++i)
{
(*i)->accept(this);
if (i != listexpr->end() - 1) render(',');
}
for (ListExpr::const_iterator i = listexpr->begin() ; i != listexpr->end() ; ++i)
{
(*i)->accept(this);
if (i != listexpr->end() - 1) render(',');
}
}void PrintAbsyn::visitAddOp(AddOp *p) {} //abstract class
void PrintAbsyn::visitPlus(Plus *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render('+');
render('+');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitMinus(Minus *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render('-');
render('-');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitMulOp(MulOp *p) {} //abstract class
void PrintAbsyn::visitTimes(Times *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render('*');
render('*');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitDiv(Div *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render('/');
render('/');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitMod(Mod *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render('%');
render('%');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitRelOp(RelOp *p) {} //abstract class
void PrintAbsyn::visitLTH(LTH *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render('<');
render('<');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitLE(LE *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("<=");
render("<=");
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitGTH(GTH *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render('>');
render('>');
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitGE(GE *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render(">=");
render(">=");
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitEQU(EQU *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("==");
render("==");
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitNE(NE *p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render("!=");
render("!=");
if (oldi > 0) render(_R_PAREN);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
_i_ = oldi;
}
void PrintAbsyn::visitInteger(Integer i)
{
char tmp[16];
sprintf(tmp, "%d", i);
bufAppend(tmp);
char tmp[16];
sprintf(tmp, "%d", i);
bufAppend(tmp);
}
void PrintAbsyn::visitDouble(Double d)
{
char tmp[16];
sprintf(tmp, "%g", d);
bufAppend(tmp);
char tmp[16];
sprintf(tmp, "%g", d);
bufAppend(tmp);
}
void PrintAbsyn::visitChar(Char c)
{
bufAppend('\'');
bufAppend(c);
bufAppend('\'');
bufAppend('\'');
bufAppend(c);
bufAppend('\'');
}
void PrintAbsyn::visitString(String s)
{
bufAppend('\"');
bufAppend(s);
bufAppend('\"');
bufAppend('\"');
bufAppend(s);
bufAppend('\"');
}
void PrintAbsyn::visitIdent(String s)
{
render(s);
render(s);
}
void PrintAbsyn::visitPIdent(String s)
{
render(s);
render(s);
}
ShowAbsyn::ShowAbsyn(void)
{
buf_ = 0;
bufReset();
buf_ = 0;
bufReset();
}
ShowAbsyn::~ShowAbsyn(void)
......@@ -1162,794 +1162,794 @@ ShowAbsyn::~ShowAbsyn(void)
char *ShowAbsyn::show(Visitable *v)
{
bufReset();
v->accept(this);
return buf_;
bufReset();
v->accept(this);
return buf_;
}
void ShowAbsyn::visitPIdent(PIdent *p)
{
bufAppend('(');
bufAppend("PIdent");
bufAppend(' ');
visitString(p->string_);
bufAppend(' ');
visitInteger(p->integer_);
bufAppend(')');
bufAppend('(');
bufAppend("PIdent");
bufAppend(' ');
visitString(p->string_);
bufAppend(' ');
visitInteger(p->integer_);
bufAppend(')');
}
void ShowAbsyn::visitProgram(Program *p) {} //abstract class
void ShowAbsyn::visitProg(Prog *p)
{
bufAppend('(');
bufAppend("Prog");
bufAppend(' ');
bufAppend('[');
if (p->listtopdef_) p->listtopdef_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("Prog");
bufAppend(' ');
bufAppend('[');
if (p->listtopdef_) p->listtopdef_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitTopDef(TopDef *p) {} //abstract class
void ShowAbsyn::visitFnDef(FnDef *p)
{
bufAppend('(');
bufAppend("FnDef");
bufAppend(' ');
bufAppend('[');
if (p->fundef_) p->fundef_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("FnDef");
bufAppend(' ');
bufAppend('[');
if (p->fundef_) p->fundef_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitClDef(ClDef *p)
{
bufAppend('(');
bufAppend("ClDef");
bufAppend(' ');
bufAppend('[');
if (p->classdef_) p->classdef_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("ClDef");
bufAppend(' ');
bufAppend('[');
if (p->classdef_) p->classdef_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitListTopDef(ListTopDef *listtopdef)
{
for (ListTopDef::const_iterator i = listtopdef->begin() ; i != listtopdef->end() ; ++i)
{
(*i)->accept(this);
if (i != listtopdef->end() - 1) bufAppend(", ");
}
for (ListTopDef::const_iterator i = listtopdef->begin() ; i != listtopdef->end() ; ++i)
{
(*i)->accept(this);
if (i != listtopdef->end() - 1) bufAppend(", ");
}
}
void ShowAbsyn::visitFunDef(FunDef *p) {} //abstract class
void ShowAbsyn::visitFuncDef(FuncDef *p)
{
bufAppend('(');
bufAppend("FuncDef");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->listarg_) p->listarg_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->block_) p->block_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("FuncDef");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->listarg_) p->listarg_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->block_) p->block_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitArg(Arg *p) {} //abstract class
void ShowAbsyn::visitAr(Ar *p)
{
bufAppend('(');
bufAppend("Ar");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
bufAppend('(');
bufAppend("Ar");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
}
void ShowAbsyn::visitListArg(ListArg *listarg)
{
for (ListArg::const_iterator i = listarg->begin() ; i != listarg->end() ; ++i)
{
(*i)->accept(this);
if (i != listarg->end() - 1) bufAppend(", ");
}
for (ListArg::const_iterator i = listarg->begin() ; i != listarg->end() ; ++i)
{
(*i)->accept(this);
if (i != listarg->end() - 1) bufAppend(", ");
}
}
void ShowAbsyn::visitClassDef(ClassDef *p) {} //abstract class
void ShowAbsyn::visitClassDefN(ClassDefN *p)
{
bufAppend('(');
bufAppend("ClassDefN");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->classblock_) p->classblock_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("ClassDefN");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->classblock_) p->classblock_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitClassDefE(ClassDefE *p)
{
bufAppend('(');
bufAppend("ClassDefE");
bufAppend(' ');
visitPIdent(p->pident_1);
bufAppend(' ');
visitPIdent(p->pident_2);
bufAppend(' ');
bufAppend('[');
if (p->classblock_) p->classblock_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("ClassDefE");
bufAppend(' ');
visitPIdent(p->pident_1);
bufAppend(' ');
visitPIdent(p->pident_2);
bufAppend(' ');
bufAppend('[');
if (p->classblock_) p->classblock_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitClassBlock(ClassBlock *p) {} //abstract class
void ShowAbsyn::visitClassBl(ClassBl *p)
{
bufAppend('(');
bufAppend("ClassBl");
bufAppend(' ');
bufAppend('[');
if (p->listclassblockdef_) p->listclassblockdef_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("ClassBl");
bufAppend(' ');
bufAppend('[');
if (p->listclassblockdef_) p->listclassblockdef_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitClassBlockDef(ClassBlockDef *p) {} //abstract class
void ShowAbsyn::visitClassMthd(ClassMthd *p)
{
bufAppend('(');
bufAppend("ClassMthd");
bufAppend(' ');
bufAppend('[');
if (p->fundef_) p->fundef_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("ClassMthd");
bufAppend(' ');
bufAppend('[');
if (p->fundef_) p->fundef_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitClassFld(ClassFld *p)
{
bufAppend('(');
bufAppend("ClassFld");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->listitem_) p->listitem_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("ClassFld");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->listitem_) p->listitem_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitListClassBlockDef(ListClassBlockDef *listclassblockdef)
{
for (ListClassBlockDef::const_iterator i = listclassblockdef->begin() ; i != listclassblockdef->end() ; ++i)
{
(*i)->accept(this);
if (i != listclassblockdef->end() - 1) bufAppend(", ");
}
for (ListClassBlockDef::const_iterator i = listclassblockdef->begin() ; i != listclassblockdef->end() ; ++i)
{
(*i)->accept(this);
if (i != listclassblockdef->end() - 1) bufAppend(", ");
}
}
void ShowAbsyn::visitBlock(Block *p) {} //abstract class
void ShowAbsyn::visitBlk(Blk *p)
{
bufAppend('(');
bufAppend("Blk");
bufAppend(' ');
bufAppend('[');
if (p->liststmt_) p->liststmt_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("Blk");
bufAppend(' ');
bufAppend('[');
if (p->liststmt_) p->liststmt_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitListStmt(ListStmt *liststmt)
{
for (ListStmt::const_iterator i = liststmt->begin() ; i != liststmt->end() ; ++i)
{
(*i)->accept(this);
if (i != liststmt->end() - 1) bufAppend(", ");
}
for (ListStmt::const_iterator i = liststmt->begin() ; i != liststmt->end() ; ++i)
{
(*i)->accept(this);
if (i != liststmt->end() - 1) bufAppend(", ");
}
}
void ShowAbsyn::visitStmt(Stmt *p) {} //abstract class
void ShowAbsyn::visitEmpty(Empty *p)
{
bufAppend("Empty");
bufAppend("Empty");
}
void ShowAbsyn::visitBStmt(BStmt *p)
{
bufAppend('(');
bufAppend("BStmt");
bufAppend(' ');
bufAppend('[');
if (p->block_) p->block_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("BStmt");
bufAppend(' ');
bufAppend('[');
if (p->block_) p->block_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitDecl(Decl *p)
{
bufAppend('(');
bufAppend("Decl");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->listitem_) p->listitem_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("Decl");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->listitem_) p->listitem_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitAss(Ass *p)
{
bufAppend('(');
bufAppend("Ass");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("Ass");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitTableAss(TableAss *p)
{
bufAppend('(');
bufAppend("TableAss");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("TableAss");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitTableIncr(TableIncr *p)
{
bufAppend('(');
bufAppend("TableIncr");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("TableIncr");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitTableDecr(TableDecr *p)
{
bufAppend('(');
bufAppend("TableDecr");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("TableDecr");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitIncr(Incr *p)
{
bufAppend('(');
bufAppend("Incr");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("Incr");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitDecr(Decr *p)
{
bufAppend('(');
bufAppend("Decr");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("Decr");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitRet(Ret *p)
{
bufAppend('(');
bufAppend("Ret");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("Ret");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitVRet(VRet *p)
{
bufAppend("VRet");
bufAppend("VRet");
}
void ShowAbsyn::visitCond(Cond *p)
{
bufAppend('(');
bufAppend("Cond");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->stmt_) p->stmt_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("Cond");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->stmt_) p->stmt_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitCondElse(CondElse *p)
{
bufAppend('(');
bufAppend("CondElse");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
p->stmt_1->accept(this);
bufAppend(' ');
p->stmt_2->accept(this);
bufAppend(')');
bufAppend('(');
bufAppend("CondElse");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
p->stmt_1->accept(this);
bufAppend(' ');
p->stmt_2->accept(this);
bufAppend(')');
}
void ShowAbsyn::visitWhile(While *p)
{
bufAppend('(');
bufAppend("While");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->stmt_) p->stmt_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("While");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->stmt_) p->stmt_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitSExp(SExp *p)
{
bufAppend('(');
bufAppend("SExp");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("SExp");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitForEach(ForEach *p)
{
bufAppend('(');
bufAppend("ForEa.h");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->stmt_) p->stmt_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("ForEa.h");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->stmt_) p->stmt_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitItem(Item *p) {} //abstract class
void ShowAbsyn::visitNoInit(NoInit *p)
{
bufAppend('(');
bufAppend("NoInit");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
bufAppend('(');
bufAppend("NoInit");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
}
void ShowAbsyn::visitInit(Init *p)
{
bufAppend('(');
bufAppend("Init");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("Init");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitListItem(ListItem *listitem)
{
for (ListItem::const_iterator i = listitem->begin() ; i != listitem->end() ; ++i)
{
(*i)->accept(this);
if (i != listitem->end() - 1) bufAppend(", ");
}
for (ListItem::const_iterator i = listitem->begin() ; i != listitem->end() ; ++i)
{
(*i)->accept(this);
if (i != listitem->end() - 1) bufAppend(", ");
}
}
void ShowAbsyn::visitType(Type *p) {} //abstract class
void ShowAbsyn::visitInt(Int *p)
{
bufAppend("Int");
bufAppend("Int");
}
void ShowAbsyn::visitStr(Str *p)
{
bufAppend("Str");
bufAppend("Str");
}
void ShowAbsyn::visitBool(Bool *p)
{
bufAppend("Bool");
bufAppend("Bool");
}
void ShowAbsyn::visitVoid(Void *p)
{
bufAppend("Void");
bufAppend("Void");
}
void ShowAbsyn::visitArray(Array *p)
{
bufAppend('(');
bufAppend("Array");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("Array");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitClassT(ClassT *p)
{
bufAppend('(');
bufAppend("ClassT");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
bufAppend('(');
bufAppend("ClassT");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
}
void ShowAbsyn::visitFun(Fun *p)
{
bufAppend('(');
bufAppend("Fun");
bufAppend(' ');
bufAppend('(');
bufAppend("Fun");
bufAppend(' ');
/* Internal Category */
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->listtype_) p->listtype_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->listtype_) p->listtype_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitListType(ListType *listtype)
{
for (ListType::const_iterator i = listtype->begin() ; i != listtype->end() ; ++i)
{
(*i)->accept(this);
if (i != listtype->end() - 1) bufAppend(", ");
}
for (ListType::const_iterator i = listtype->begin() ; i != listtype->end() ; ++i)
{
(*i)->accept(this);
if (i != listtype->end() - 1) bufAppend(", ");
}
}
void ShowAbsyn::visitExpr(Expr *p) {} //abstract class
void ShowAbsyn::visitEVar(EVar *p)
{
bufAppend('(');
bufAppend("EVar");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
bufAppend('(');
bufAppend("EVar");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
}
void ShowAbsyn::visitELitInt(ELitInt *p)
{
bufAppend('(');
bufAppend("ELitInt");
bufAppend(' ');
visitInteger(p->integer_);
bufAppend(')');
bufAppend('(');
bufAppend("ELitInt");
bufAppend(' ');
visitInteger(p->integer_);
bufAppend(')');
}
void ShowAbsyn::visitELitTrue(ELitTrue *p)
{
bufAppend("ELitTrue");
bufAppend("ELitTrue");
}
void ShowAbsyn::visitELitFalse(ELitFalse *p)
{
bufAppend("ELitFalse");
bufAppend("ELitFalse");
}
void ShowAbsyn::visitEApp(EApp *p)
{
bufAppend('(');
bufAppend("EApp");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->listexpr_) p->listexpr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("EApp");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->listexpr_) p->listexpr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitEString(EString *p)
{
bufAppend('(');
bufAppend("EString");
bufAppend(' ');
visitString(p->string_);
bufAppend(')');
bufAppend('(');
bufAppend("EString");
bufAppend(' ');
visitString(p->string_);
bufAppend(')');
}
void ShowAbsyn::visitENewArray(ENewArray *p)
{
bufAppend('(');
bufAppend("ENewArray");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("ENewArray");
bufAppend(' ');
bufAppend('[');
if (p->type_) p->type_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitENewClass(ENewClass *p)
{
bufAppend('(');
bufAppend("ENewClass");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
bufAppend('(');
bufAppend("ENewClass");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
}
void ShowAbsyn::visitEClsMmbr(EClsMmbr *p)
{
bufAppend('(');
bufAppend("EClsMmbr");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
bufAppend('(');
bufAppend("EClsMmbr");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(')');
}
void ShowAbsyn::visitEClsMthd(EClsMthd *p)
{
bufAppend('(');
bufAppend("EClsMthd");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->listexpr_) p->listexpr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("EClsMthd");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->listexpr_) p->listexpr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitNull(Null *p)
{
bufAppend("Null");
bufAppend("Null");
}
void ShowAbsyn::visitEIndexAcc(EIndexAcc *p)
{
bufAppend('(');
bufAppend("EIndexAcc");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
bufAppend('(');
bufAppend("EIndexAcc");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(' ');
bufAppend(')');
}
void ShowAbsyn::visitECast(ECast *p)
{
bufAppend('(');
bufAppend("ECast");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("ECast");
bufAppend(' ');
visitPIdent(p->pident_);
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitNeg(Neg *p)
{
bufAppend('(');
bufAppend("Neg");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("Neg");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitNot(Not *p)
{
bufAppend('(');
bufAppend("Not");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(')');
bufAppend('(');
bufAppend("Not");
bufAppend(' ');
bufAppend('[');
if (p->expr_) p->expr_->accept(this);
bufAppend(']');
bufAppend(')');
}
void ShowAbsyn::visitEMul(EMul *p)
{
bufAppend('(');
bufAppend("EMul");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
bufAppend('[');
if (p->mulop_) p->mulop_->accept(this);
bufAppend(']');
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(')');
bufAppend('(');
bufAppend("EMul");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
bufAppend('[');
if (p->mulop_) p->mulop_->accept(this);
bufAppend(']');
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(')');
}
void ShowAbsyn::visitEAdd(EAdd *p)
{
bufAppend('(');
bufAppend("EAdd");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
bufAppend('[');
if (p->addop_) p->addop_->accept(this);
bufAppend(']');
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(')');
bufAppend('(');
bufAppend("EAdd");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
bufAppend('[');
if (p->addop_) p->addop_->accept(this);
bufAppend(']');
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(')');
}
void ShowAbsyn::visitERel(ERel *p)
{
bufAppend('(');
bufAppend("ERel");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
bufAppend('[');
if (p->relop_) p->relop_->accept(this);
bufAppend(']');
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(')');
bufAppend('(');
bufAppend("ERel");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
bufAppend('[');
if (p->relop_) p->relop_->accept(this);
bufAppend(']');
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(')');
}
void ShowAbsyn::visitEAnd(EAnd *p)
{
bufAppend('(');
bufAppend("EAnd");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(')');
bufAppend('(');
bufAppend("EAnd");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(')');
}
void ShowAbsyn::visitEOr(EOr *p)
{
bufAppend('(');
bufAppend("EOr");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(')');
bufAppend('(');
bufAppend("EOr");
bufAppend(' ');
p->expr_1->accept(this);
bufAppend(' ');
p->expr_2->accept(this);
bufAppend(')');
}
void ShowAbsyn::visitListExpr(ListExpr *listexpr)
{
for (ListExpr::const_iterator i = listexpr->begin() ; i != listexpr->end() ; ++i)
{
(*i)->accept(this);
if (i != listexpr->end() - 1) bufAppend(", ");
}
for (ListExpr::const_iterator i = listexpr->begin() ; i != listexpr->end() ; ++i)
{
(*i)->accept(this);
if (i != listexpr->end() - 1) bufAppend(", ");
}
}
void ShowAbsyn::visitAddOp(AddOp *p) {} //abstract class
void ShowAbsyn::visitPlus(Plus *p)
{
bufAppend("Plus");
bufAppend("Plus");
}
void ShowAbsyn::visitMinus(Minus *p)
{
bufAppend("Minus");
bufAppend("Minus");
}
void ShowAbsyn::visitMulOp(MulOp *p) {} //abstract class
void ShowAbsyn::visitTimes(Times *p)
{
bufAppend("Times");
bufAppend("Times");
}
void ShowAbsyn::visitDiv(Div *p)
{
bufAppend("Div");
bufAppend("Div");
}
void ShowAbsyn::visitMod(Mod *p)
{
bufAppend("Mod");
bufAppend("Mod");
}
void ShowAbsyn::visitRelOp(RelOp *p) {} //abstract class
void ShowAbsyn::visitLTH(LTH *p)
{
bufAppend("L.h");
bufAppend("L.h");
}
void ShowAbsyn::visitLE(LE *p)
{
bufAppend("LE");
bufAppend("LE");
}
void ShowAbsyn::visitGTH(GTH *p)
{
bufAppend("G.h");
bufAppend("G.h");
}
void ShowAbsyn::visitGE(GE *p)
{
bufAppend("GE");
bufAppend("GE");
}
void ShowAbsyn::visitEQU(EQU *p)
{
bufAppend("EQU");
bufAppend("EQU");
}
void ShowAbsyn::visitNE(NE *p)
{
bufAppend("NE");
bufAppend("NE");
}
void ShowAbsyn::visitInteger(Integer i)
{
char tmp[16];
sprintf(tmp, "%d", i);
bufAppend(tmp);
char tmp[16];
sprintf(tmp, "%d", i);
bufAppend(tmp);
}
void ShowAbsyn::visitDouble(Double d)
{
char tmp[16];
sprintf(tmp, "%g", d);
bufAppend(tmp);
char tmp[16];
sprintf(tmp, "%g", d);
bufAppend(tmp);
}
void ShowAbsyn::visitChar(Char c)
{
bufAppend('\'');
bufAppend(c);
bufAppend('\'');
bufAppend('\'');
bufAppend(c);
bufAppend('\'');
}
void ShowAbsyn::visitString(String s)
{
bufAppend('\"');
bufAppend(s);
bufAppend('\"');
bufAppend('\"');
bufAppend(s);
bufAppend('\"');
}
void ShowAbsyn::visitIdent(String s)
{
bufAppend('\"');
bufAppend(s);
bufAppend('\"');
bufAppend('\"');
bufAppend(s);
bufAppend('\"');
}
void ShowAbsyn::visitPIdent(String s)
{
bufAppend('\"');
bufAppend(s);
bufAppend('\"');
bufAppend('\"');
bufAppend(s);
bufAppend('\"');
}
......
Printer.h
View file @ 8072a075
......@@ -16,181 +16,181 @@
class PrintAbsyn : public Visitor
{
protected:
int _n_, _i_;
/* The following are simple heuristics for rendering terminals */
/* You may wish to change them */
void render(Char c);
void render(String s);
void render(const char *s);
void indent(void);
void backup(void);
int _n_, _i_;
/* The following are simple heuristics for rendering terminals */
/* You may wish to change them */
void render(Char c);
void render(String s);
void render(const char *s);
void indent(void);
void backup(void);
public:
PrintAbsyn(void);
~PrintAbsyn(void);
char *print(Visitable *v);
PrintAbsyn(void);
~PrintAbsyn(void);
char *print(Visitable *v);
void visitPIdent(PIdent *p);
void visitProgram(Program *p); /* abstract class */
void visitProg(Prog *p);
void visitTopDef(TopDef *p); /* abstract class */
void visitFnDef(FnDef *p);
void visitClDef(ClDef *p);
void visitListTopDef(ListTopDef *p);
void visitFunDef(FunDef *p); /* abstract class */
void visitFuncDef(FuncDef *p);
void visitArg(Arg *p); /* abstract class */
void visitAr(Ar *p);
void visitListArg(ListArg *p);
void visitClassDef(ClassDef *p); /* abstract class */
void visitClassDefN(ClassDefN *p);
void visitClassDefE(ClassDefE *p);
void visitClassBlock(ClassBlock *p); /* abstract class */
void visitClassBl(ClassBl *p);
void visitClassBlockDef(ClassBlockDef *p); /* abstract class */
void visitClassMthd(ClassMthd *p);
void visitClassFld(ClassFld *p);
void visitListClassBlockDef(ListClassBlockDef *p);
void visitBlock(Block *p); /* abstract class */
void visitBlk(Blk *p);
void visitListStmt(ListStmt *p);
void visitStmt(Stmt *p); /* abstract class */
void visitEmpty(Empty *p);
void visitBStmt(BStmt *p);
void visitDecl(Decl *p);
void visitAss(Ass *p);
void visitTableAss(TableAss *p);
void visitTableIncr(TableIncr *p);
void visitTableDecr(TableDecr *p);
void visitIncr(Incr *p);
void visitDecr(Decr *p);
void visitRet(Ret *p);
void visitVRet(VRet *p);
void visitCond(Cond *p);
void visitCondElse(CondElse *p);
void visitWhile(While *p);
void visitSExp(SExp *p);
void visitForEach(ForEach *p);
void visitItem(Item *p); /* abstract class */
void visitNoInit(NoInit *p);
void visitInit(Init *p);
void visitListItem(ListItem *p);
void visitType(Type *p); /* abstract class */
void visitInt(Int *p);
void visitStr(Str *p);
void visitBool(Bool *p);
void visitVoid(Void *p);
void visitArray(Array *p);
void visitClassT(ClassT *p);
void visitFun(Fun *p);
void visitListType(ListType *p);
void visitExpr(Expr *p); /* abstract class */
void visitEVar(EVar *p);
void visitELitInt(ELitInt *p);
void visitELitTrue(ELitTrue *p);
void visitELitFalse(ELitFalse *p);
void visitEApp(EApp *p);
void visitEString(EString *p);
void visitENewArray(ENewArray *p);
void visitENewClass(ENewClass *p);
void visitEClsMmbr(EClsMmbr *p);
void visitEClsMthd(EClsMthd *p);
void visitNull(Null *p);
void visitEIndexAcc(EIndexAcc *p);
void visitECast(ECast *p);
void visitNeg(Neg *p);
void visitNot(Not *p);
void visitEMul(EMul *p);
void visitEAdd(EAdd *p);
void visitERel(ERel *p);
void visitEAnd(EAnd *p);
void visitEOr(EOr *p);
void visitListExpr(ListExpr *p);
void visitAddOp(AddOp *p); /* abstract class */
void visitPlus(Plus *p);
void visitMinus(Minus *p);
void visitMulOp(MulOp *p); /* abstract class */
void visitTimes(Times *p);
void visitDiv(Div *p);
void visitMod(Mod *p);
void visitRelOp(RelOp *p); /* abstract class */
void visitLTH(LTH *p);
void visitLE(LE *p);
void visitGTH(GTH *p);
void visitGE(GE *p);
void visitEQU(EQU *p);
void visitNE(NE *p);
void visitPIdent(PIdent *p);
void visitProgram(Program *p); /* abstract class */
void visitProg(Prog *p);
void visitTopDef(TopDef *p); /* abstract class */
void visitFnDef(FnDef *p);
void visitClDef(ClDef *p);
void visitListTopDef(ListTopDef *p);
void visitFunDef(FunDef *p); /* abstract class */
void visitFuncDef(FuncDef *p);
void visitArg(Arg *p); /* abstract class */
void visitAr(Ar *p);
void visitListArg(ListArg *p);
void visitClassDef(ClassDef *p); /* abstract class */
void visitClassDefN(ClassDefN *p);
void visitClassDefE(ClassDefE *p);
void visitClassBlock(ClassBlock *p); /* abstract class */
void visitClassBl(ClassBl *p);
void visitClassBlockDef(ClassBlockDef *p); /* abstract class */
void visitClassMthd(ClassMthd *p);
void visitClassFld(ClassFld *p);
void visitListClassBlockDef(ListClassBlockDef *p);
void visitBlock(Block *p); /* abstract class */
void visitBlk(Blk *p);
void visitListStmt(ListStmt *p);
void visitStmt(Stmt *p); /* abstract class */
void visitEmpty(Empty *p);
void visitBStmt(BStmt *p);
void visitDecl(Decl *p);
void visitAss(Ass *p);
void visitTableAss(TableAss *p);
void visitTableIncr(TableIncr *p);
void visitTableDecr(TableDecr *p);
void visitIncr(Incr *p);
void visitDecr(Decr *p);
void visitRet(Ret *p);
void visitVRet(VRet *p);
void visitCond(Cond *p);
void visitCondElse(CondElse *p);
void visitWhile(While *p);
void visitSExp(SExp *p);
void visitForEach(ForEach *p);
void visitItem(Item *p); /* abstract class */
void visitNoInit(NoInit *p);
void visitInit(Init *p);
void visitListItem(ListItem *p);
void visitType(Type *p); /* abstract class */
void visitInt(Int *p);
void visitStr(Str *p);
void visitBool(Bool *p);
void visitVoid(Void *p);
void visitArray(Array *p);
void visitClassT(ClassT *p);
void visitFun(Fun *p);
void visitListType(ListType *p);
void visitExpr(Expr *p); /* abstract class */
void visitEVar(EVar *p);
void visitELitInt(ELitInt *p);
void visitELitTrue(ELitTrue *p);
void visitELitFalse(ELitFalse *p);
void visitEApp(EApp *p);
void visitEString(EString *p);
void visitENewArray(ENewArray *p);
void visitENewClass(ENewClass *p);
void visitEClsMmbr(EClsMmbr *p);
void visitEClsMthd(EClsMthd *p);
void visitNull(Null *p);
void visitEIndexAcc(EIndexAcc *p);
void visitECast(ECast *p);
void visitNeg(Neg *p);
void visitNot(Not *p);
void visitEMul(EMul *p);
void visitEAdd(EAdd *p);
void visitERel(ERel *p);
void visitEAnd(EAnd *p);
void visitEOr(EOr *p);
void visitListExpr(ListExpr *p);
void visitAddOp(AddOp *p); /* abstract class */
void visitPlus(Plus *p);
void visitMinus(Minus *p);
void visitMulOp(MulOp *p); /* abstract class */
void visitTimes(Times *p);
void visitDiv(Div *p);
void visitMod(Mod *p);
void visitRelOp(RelOp *p); /* abstract class */
void visitLTH(LTH *p);
void visitLE(LE *p);
void visitGTH(GTH *p);
void visitGE(GE *p);
void visitEQU(EQU *p);
void visitNE(NE *p);
void visitInteger(Integer i);
void visitDouble(Double d);
void visitChar(Char c);
void visitString(String s);
void visitIdent(String s);
void visitPIdent(String s);
void visitInteger(Integer i);
void visitDouble(Double d);
void visitChar(Char c);
void visitString(String s);
void visitIdent(String s);
void visitPIdent(String s);
protected:
char *buf_;
int cur_, buf_size;
char *buf_;
int cur_, buf_size;
void inline bufAppend(const char *s)
{
int len = strlen(s);
while (cur_ + len >= buf_size)
{
buf_size *= 2; /* Double the buffer size */
}
resizeBuffer();
for(int n = 0; n < len; n++)
{
buf_[cur_ + n] = s[n];
}
cur_ += len;
buf_[cur_] = 0;
}
void inline bufAppend(const char *s)
{
int len = strlen(s);
while (cur_ + len >= buf_size)
{
buf_size *= 2; /* Double the buffer size */
}
resizeBuffer();
for(int n = 0; n < len; n++)
{
buf_[cur_ + n] = s[n];
}
cur_ += len;
buf_[cur_] = 0;
}
void inline bufAppend(const char c)
{
if (cur_ >= buf_size)
{
buf_size *= 2; /* Double the buffer size */
resizeBuffer();
}
buf_[cur_] = c;
cur_++;
buf_[cur_] = 0;
}
void inline bufAppend(const char c)
{
if (cur_ >= buf_size)
{
buf_size *= 2; /* Double the buffer size */
resizeBuffer();
}
buf_[cur_] = c;
cur_++;
buf_[cur_] = 0;
}
void inline bufAppend(String str)
{
const char *s = str.c_str();
bufAppend(s);
}
void inline bufReset(void)
{
if (buf_) free(buf_);
buf_size = BUFFER_INITIAL;
buf_ = (char *) malloc(buf_size);
if (!buf_) {
fprintf(stderr, "Error: Out of memory while allocating buffer!\n");
exit(1);
}
memset(buf_, 0, buf_size);
cur_ = 0;
}
void inline bufAppend(String str)
{
const char *s = str.c_str();
bufAppend(s);
}
void inline bufReset(void)
{
if (buf_) free(buf_);
buf_size = BUFFER_INITIAL;
buf_ = (char *) malloc(buf_size);
if (!buf_) {
fprintf(stderr, "Error: Out of memory while allocating buffer!\n");
exit(1);
}
memset(buf_, 0, buf_size);
cur_ = 0;
}
void inline resizeBuffer(void)
{
char *temp = (char *) malloc(buf_size);
if (!temp)
{
fprintf(stderr, "Error: Out of memory while attempting to grow buffer!\n");
exit(1);
}
if (buf_)
{
strcpy(temp, buf_);
free(buf_);
}
buf_ = temp;
}
void inline resizeBuffer(void)
{
char *temp = (char *) malloc(buf_size);
if (!temp)
{
fprintf(stderr, "Error: Out of memory while attempting to grow buffer!\n");
exit(1);
}
if (buf_)
{
strcpy(temp, buf_);
free(buf_);
}
buf_ = temp;
}
};
......@@ -198,172 +198,172 @@ class PrintAbsyn : public Visitor
class ShowAbsyn : public Visitor
{
public:
ShowAbsyn(void);
~ShowAbsyn(void);
char *show(Visitable *v);
ShowAbsyn(void);
~ShowAbsyn(void);
char *show(Visitable *v);
void visitPIdent(PIdent *p);
void visitProgram(Program *p); /* abstract class */
void visitProg(Prog *p);
void visitTopDef(TopDef *p); /* abstract class */
void visitFnDef(FnDef *p);
void visitClDef(ClDef *p);
void visitListTopDef(ListTopDef *p);
void visitFunDef(FunDef *p); /* abstract class */
void visitFuncDef(FuncDef *p);
void visitArg(Arg *p); /* abstract class */
void visitAr(Ar *p);
void visitListArg(ListArg *p);
void visitClassDef(ClassDef *p); /* abstract class */
void visitClassDefN(ClassDefN *p);
void visitClassDefE(ClassDefE *p);
void visitClassBlock(ClassBlock *p); /* abstract class */
void visitClassBl(ClassBl *p);
void visitClassBlockDef(ClassBlockDef *p); /* abstract class */
void visitClassMthd(ClassMthd *p);
void visitClassFld(ClassFld *p);
void visitListClassBlockDef(ListClassBlockDef *p);
void visitBlock(Block *p); /* abstract class */
void visitBlk(Blk *p);
void visitListStmt(ListStmt *p);
void visitStmt(Stmt *p); /* abstract class */
void visitEmpty(Empty *p);
void visitBStmt(BStmt *p);
void visitDecl(Decl *p);
void visitAss(Ass *p);
void visitTableAss(TableAss *p);
void visitTableIncr(TableIncr *p);
void visitTableDecr(TableDecr *p);
void visitIncr(Incr *p);
void visitDecr(Decr *p);
void visitRet(Ret *p);
void visitVRet(VRet *p);
void visitCond(Cond *p);
void visitCondElse(CondElse *p);
void visitWhile(While *p);
void visitSExp(SExp *p);
void visitForEach(ForEach *p);
void visitItem(Item *p); /* abstract class */
void visitNoInit(NoInit *p);
void visitInit(Init *p);
void visitListItem(ListItem *p);
void visitType(Type *p); /* abstract class */
void visitInt(Int *p);
void visitStr(Str *p);
void visitBool(Bool *p);
void visitVoid(Void *p);
void visitArray(Array *p);
void visitClassT(ClassT *p);
void visitFun(Fun *p);
void visitListType(ListType *p);
void visitExpr(Expr *p); /* abstract class */
void visitEVar(EVar *p);
void visitELitInt(ELitInt *p);
void visitELitTrue(ELitTrue *p);
void visitELitFalse(ELitFalse *p);
void visitEApp(EApp *p);
void visitEString(EString *p);
void visitENewArray(ENewArray *p);
void visitENewClass(ENewClass *p);
void visitEClsMmbr(EClsMmbr *p);
void visitEClsMthd(EClsMthd *p);
void visitNull(Null *p);
void visitEIndexAcc(EIndexAcc *p);
void visitECast(ECast *p);
void visitNeg(Neg *p);
void visitNot(Not *p);
void visitEMul(EMul *p);
void visitEAdd(EAdd *p);
void visitERel(ERel *p);
void visitEAnd(EAnd *p);
void visitEOr(EOr *p);
void visitListExpr(ListExpr *p);
void visitAddOp(AddOp *p); /* abstract class */
void visitPlus(Plus *p);
void visitMinus(Minus *p);
void visitMulOp(MulOp *p); /* abstract class */
void visitTimes(Times *p);
void visitDiv(Div *p);
void visitMod(Mod *p);
void visitRelOp(RelOp *p); /* abstract class */
void visitLTH(LTH *p);
void visitLE(LE *p);
void visitGTH(GTH *p);
void visitGE(GE *p);
void visitEQU(EQU *p);
void visitNE(NE *p);
void visitPIdent(PIdent *p);
void visitProgram(Program *p); /* abstract class */
void visitProg(Prog *p);
void visitTopDef(TopDef *p); /* abstract class */
void visitFnDef(FnDef *p);
void visitClDef(ClDef *p);
void visitListTopDef(ListTopDef *p);
void visitFunDef(FunDef *p); /* abstract class */
void visitFuncDef(FuncDef *p);
void visitArg(Arg *p); /* abstract class */
void visitAr(Ar *p);
void visitListArg(ListArg *p);
void visitClassDef(ClassDef *p); /* abstract class */
void visitClassDefN(ClassDefN *p);
void visitClassDefE(ClassDefE *p);
void visitClassBlock(ClassBlock *p); /* abstract class */
void visitClassBl(ClassBl *p);
void visitClassBlockDef(ClassBlockDef *p); /* abstract class */
void visitClassMthd(ClassMthd *p);
void visitClassFld(ClassFld *p);
void visitListClassBlockDef(ListClassBlockDef *p);
void visitBlock(Block *p); /* abstract class */
void visitBlk(Blk *p);
void visitListStmt(ListStmt *p);
void visitStmt(Stmt *p); /* abstract class */
void visitEmpty(Empty *p);
void visitBStmt(BStmt *p);
void visitDecl(Decl *p);
void visitAss(Ass *p);
void visitTableAss(TableAss *p);
void visitTableIncr(TableIncr *p);
void visitTableDecr(TableDecr *p);
void visitIncr(Incr *p);
void visitDecr(Decr *p);
void visitRet(Ret *p);
void visitVRet(VRet *p);
void visitCond(Cond *p);
void visitCondElse(CondElse *p);
void visitWhile(While *p);
void visitSExp(SExp *p);
void visitForEach(ForEach *p);
void visitItem(Item *p); /* abstract class */
void visitNoInit(NoInit *p);
void visitInit(Init *p);
void visitListItem(ListItem *p);
void visitType(Type *p); /* abstract class */
void visitInt(Int *p);
void visitStr(Str *p);
void visitBool(Bool *p);
void visitVoid(Void *p);
void visitArray(Array *p);
void visitClassT(ClassT *p);
void visitFun(Fun *p);
void visitListType(ListType *p);
void visitExpr(Expr *p); /* abstract class */
void visitEVar(EVar *p);
void visitELitInt(ELitInt *p);
void visitELitTrue(ELitTrue *p);
void visitELitFalse(ELitFalse *p);
void visitEApp(EApp *p);
void visitEString(EString *p);
void visitENewArray(ENewArray *p);
void visitENewClass(ENewClass *p);
void visitEClsMmbr(EClsMmbr *p);
void visitEClsMthd(EClsMthd *p);
void visitNull(Null *p);
void visitEIndexAcc(EIndexAcc *p);
void visitECast(ECast *p);
void visitNeg(Neg *p);
void visitNot(Not *p);
void visitEMul(EMul *p);
void visitEAdd(EAdd *p);
void visitERel(ERel *p);
void visitEAnd(EAnd *p);
void visitEOr(EOr *p);
void visitListExpr(ListExpr *p);
void visitAddOp(AddOp *p); /* abstract class */
void visitPlus(Plus *p);
void visitMinus(Minus *p);
void visitMulOp(MulOp *p); /* abstract class */
void visitTimes(Times *p);
void visitDiv(Div *p);
void visitMod(Mod *p);
void visitRelOp(RelOp *p); /* abstract class */
void visitLTH(LTH *p);
void visitLE(LE *p);
void visitGTH(GTH *p);
void visitGE(GE *p);
void visitEQU(EQU *p);
void visitNE(NE *p);
void visitInteger(Integer i);
void visitDouble(Double d);
void visitChar(Char c);
void visitString(String s);
void visitIdent(String s);
void visitPIdent(String s);
void visitInteger(Integer i);
void visitDouble(Double d);
void visitChar(Char c);
void visitString(String s);
void visitIdent(String s);
void visitPIdent(String s);
protected:
char *buf_;
int cur_, buf_size;
char *buf_;
int cur_, buf_size;
void inline bufAppend(const char *s)
{
int len = strlen(s);
while (cur_ + len >= buf_size)
{
buf_size *= 2; /* Double the buffer size */
}
resizeBuffer();
for(int n = 0; n < len; n++)
{
buf_[cur_ + n] = s[n];
}
cur_ += len;
buf_[cur_] = 0;
}
void inline bufAppend(const char *s)
{
int len = strlen(s);
while (cur_ + len >= buf_size)
{
buf_size *= 2; /* Double the buffer size */
}
resizeBuffer();
for(int n = 0; n < len; n++)
{
buf_[cur_ + n] = s[n];
}
cur_ += len;
buf_[cur_] = 0;
}
void inline bufAppend(const char c)
{
if (cur_ >= buf_size)
{
buf_size *= 2; /* Double the buffer size */
resizeBuffer();
}
buf_[cur_] = c;
cur_++;
buf_[cur_] = 0;
}
void inline bufAppend(const char c)
{
if (cur_ >= buf_size)
{
buf_size *= 2; /* Double the buffer size */
resizeBuffer();
}
buf_[cur_] = c;
cur_++;
buf_[cur_] = 0;
}
void inline bufAppend(String str)
{
const char *s = str.c_str();
bufAppend(s);
}
void inline bufReset(void)
{
if (buf_) free(buf_);
buf_size = BUFFER_INITIAL;
buf_ = (char *) malloc(buf_size);
if (!buf_) {
fprintf(stderr, "Error: Out of memory while allocating buffer!\n");
exit(1);
}
memset(buf_, 0, buf_size);
cur_ = 0;
}
void inline bufAppend(String str)
{
const char *s = str.c_str();
bufAppend(s);
}
void inline bufReset(void)
{
if (buf_) free(buf_);
buf_size = BUFFER_INITIAL;
buf_ = (char *) malloc(buf_size);
if (!buf_) {
fprintf(stderr, "Error: Out of memory while allocating buffer!\n");
exit(1);
}
memset(buf_, 0, buf_size);
cur_ = 0;
}
void inline resizeBuffer(void)
{
char *temp = (char *) malloc(buf_size);
if (!temp)
{
fprintf(stderr, "Error: Out of memory while attempting to grow buffer!\n");
exit(1);
}
if (buf_)
{
strcpy(temp, buf_);
free(buf_);
}
buf_ = temp;
}
void inline resizeBuffer(void)
{
char *temp = (char *) malloc(buf_size);
if (!temp)
{
fprintf(stderr, "Error: Out of memory while attempting to grow buffer!\n");
exit(1);
}
if (buf_)
{
strcpy(temp, buf_);
free(buf_);
}
buf_ = temp;
}
};
......
Skeleton.cpp
View file @ 8072a075
/*** BNFC-Generated Visitor Design Pattern Skeleton. ***/
/* This implements the common visitor design pattern.
Note that this method uses Visitor-traversal of lists, so
List->accept() does NOT traverse the list. This allows different
algorithms to use context information differently. */
Note that this method uses Visitor-traversal of lists, so
List->accept() does NOT traverse the list. This allows different
algorithms to use context information differently. */
#include "Skeleton.h"
......@@ -26,563 +26,563 @@ void Skeleton::visitRelOp(RelOp *t) {} //abstract class
void Skeleton::visitPIdent(PIdent *p_ident)
{
/* Code For PIdent Goes Here */
/* Code For PIdent Goes Here */
visitString(p_ident->string_);
visitInteger(p_ident->integer_);
visitString(p_ident->string_);
visitInteger(p_ident->integer_);
}
void Skeleton::visitProg(Prog *prog)
{
/* Code For Prog Goes Here */
/* Code For Prog Goes Here */
prog->listtopdef_->accept(this);
prog->listtopdef_->accept(this);
}
void Skeleton::visitFnDef(FnDef *fn_def)
{
/* Code For FnDef Goes Here */
/* Code For FnDef Goes Here */
fn_def->fundef_->accept(this);
fn_def->fundef_->accept(this);
}
void Skeleton::visitClDef(ClDef *cl_def)
{
/* Code For ClDef Goes Here */
/* Code For ClDef Goes Here */
cl_def->classdef_->accept(this);
cl_def->classdef_->accept(this);
}
void Skeleton::visitFuncDef(FuncDef *func_def)
{
/* Code For FuncDef Goes Here */
/* Code For FuncDef Goes Here */
func_def->type_->accept(this);
func_def->pident_->accept(this);
func_def->listarg_->accept(this);
func_def->block_->accept(this);
func_def->type_->accept(this);
func_def->pident_->accept(this);
func_def->listarg_->accept(this);
func_def->block_->accept(this);
}
void Skeleton::visitAr(Ar *ar)
{
/* Code For Ar Goes Here */
/* Code For Ar Goes Here */
ar->type_->accept(this);
ar->pident_->accept(this);
ar->type_->accept(this);
ar->pident_->accept(this);
}
void Skeleton::visitClassDefN(ClassDefN *class_def_n)
{
/* Code For ClassDefN Goes Here */
/* Code For ClassDefN Goes Here */
class_def_n->pident_->accept(this);
class_def_n->classblock_->accept(this);
class_def_n->pident_->accept(this);
class_def_n->classblock_->accept(this);
}
void Skeleton::visitClassDefE(ClassDefE *class_def_e)
{
/* Code For ClassDefE Goes Here */
/* Code For ClassDefE Goes Here */
class_def_e->pident_1->accept(this);
class_def_e->pident_2->accept(this);
class_def_e->classblock_->accept(this);
class_def_e->pident_1->accept(this);
class_def_e->pident_2->accept(this);
class_def_e->classblock_->accept(this);
}
void Skeleton::visitClassBl(ClassBl *class_bl)
{
/* Code For ClassBl Goes Here */
/* Code For ClassBl Goes Here */
class_bl->listclassblockdef_->accept(this);
class_bl->listclassblockdef_->accept(this);
}
void Skeleton::visitClassMthd(ClassMthd *class_mthd)
{
/* Code For ClassMthd Goes Here */
/* Code For ClassMthd Goes Here */
class_mthd->fundef_->accept(this);
class_mthd->fundef_->accept(this);
}
void Skeleton::visitClassFld(ClassFld *class_fld)
{
/* Code For ClassFld Goes Here */
/* Code For ClassFld Goes Here */
class_fld->type_->accept(this);
class_fld->listitem_->accept(this);
class_fld->type_->accept(this);
class_fld->listitem_->accept(this);
}
void Skeleton::visitBlk(Blk *blk)
{
/* Code For Blk Goes Here */
/* Code For Blk Goes Here */
blk->liststmt_->accept(this);
blk->liststmt_->accept(this);
}
void Skeleton::visitEmpty(Empty *empty)
{
/* Code For Empty Goes Here */
/* Code For Empty Goes Here */
}
void Skeleton::visitBStmt(BStmt *b_stmt)
{
/* Code For BStmt Goes Here */
/* Code For BStmt Goes Here */
b_stmt->block_->accept(this);
b_stmt->block_->accept(this);
}
void Skeleton::visitDecl(Decl *decl)
{
/* Code For Decl Goes Here */
/* Code For Decl Goes Here */
decl->type_->accept(this);
decl->listitem_->accept(this);
decl->type_->accept(this);
decl->listitem_->accept(this);
}
void Skeleton::visitAss(Ass *ass)
{
/* Code For Ass Goes Here */
/* Code For Ass Goes Here */
ass->expr_1->accept(this);
ass->expr_2->accept(this);
ass->expr_1->accept(this);
ass->expr_2->accept(this);
}
void Skeleton::visitTableAss(TableAss *table_ass)
{
/* Code For TableAss Goes Here */
/* Code For TableAss Goes Here */
table_ass->pident_->accept(this);
table_ass->expr_1->accept(this);
table_ass->expr_2->accept(this);
table_ass->pident_->accept(this);
table_ass->expr_1->accept(this);
table_ass->expr_2->accept(this);
}
void Skeleton::visitTableIncr(TableIncr *table_incr)
{
/* Code For TableIncr Goes Here */
/* Code For TableIncr Goes Here */
table_incr->pident_->accept(this);
table_incr->expr_->accept(this);
table_incr->pident_->accept(this);
table_incr->expr_->accept(this);
}
void Skeleton::visitTableDecr(TableDecr *table_decr)
{
/* Code For TableDecr Goes Here */
/* Code For TableDecr Goes Here */
table_decr->pident_->accept(this);
table_decr->expr_->accept(this);
table_decr->pident_->accept(this);
table_decr->expr_->accept(this);
}
void Skeleton::visitIncr(Incr *incr)
{
/* Code For Incr Goes Here */
/* Code For Incr Goes Here */
incr->pident_->accept(this);
incr->pident_->accept(this);
}
void Skeleton::visitDecr(Decr *decr)
{
/* Code For Decr Goes Here */
/* Code For Decr Goes Here */
decr->pident_->accept(this);
decr->pident_->accept(this);
}
void Skeleton::visitRet(Ret *ret)
{
/* Code For Ret Goes Here */
/* Code For Ret Goes Here */
ret->expr_->accept(this);
ret->expr_->accept(this);
}
void Skeleton::visitVRet(VRet *v_ret)
{
/* Code For VRet Goes Here */
/* Code For VRet Goes Here */
}
void Skeleton::visitCond(Cond *cond)
{
/* Code For Cond Goes Here */
/* Code For Cond Goes Here */
cond->expr_->accept(this);
cond->stmt_->accept(this);
cond->expr_->accept(this);
cond->stmt_->accept(this);
}
void Skeleton::visitCondElse(CondElse *cond_else)
{
/* Code For CondElse Goes Here */
/* Code For CondElse Goes Here */
cond_else->expr_->accept(this);
cond_else->stmt_1->accept(this);
cond_else->stmt_2->accept(this);
cond_else->expr_->accept(this);
cond_else->stmt_1->accept(this);
cond_else->stmt_2->accept(this);
}
void Skeleton::visitWhile(While *while_)
{
/* Code For While Goes Here */
/* Code For While Goes Here */
while_->expr_->accept(this);
while_->stmt_->accept(this);
while_->expr_->accept(this);
while_->stmt_->accept(this);
}
void Skeleton::visitSExp(SExp *s_exp)
{
/* Code For SExp Goes Here */
/* Code For SExp Goes Here */
s_exp->expr_->accept(this);
s_exp->expr_->accept(this);
}
void Skeleton::visitForEach(ForEach *for_each)
{
/* Code For ForEach Goes Here */
/* Code For ForEach Goes Here */
for_each->type_->accept(this);
for_each->pident_->accept(this);
for_each->expr_->accept(this);
for_each->stmt_->accept(this);
for_each->type_->accept(this);
for_each->pident_->accept(this);
for_each->expr_->accept(this);
for_each->stmt_->accept(this);
}
void Skeleton::visitNoInit(NoInit *no_init)
{
/* Code For NoInit Goes Here */
/* Code For NoInit Goes Here */
no_init->pident_->accept(this);
no_init->pident_->accept(this);
}
void Skeleton::visitInit(Init *init)
{
/* Code For Init Goes Here */
/* Code For Init Goes Here */
init->pident_->accept(this);
init->expr_->accept(this);
init->pident_->accept(this);
init->expr_->accept(this);
}
void Skeleton::visitInt(Int *int_)
{
/* Code For Int Goes Here */
/* Code For Int Goes Here */
}
void Skeleton::visitStr(Str *str)
{
/* Code For Str Goes Here */
/* Code For Str Goes Here */
}
void Skeleton::visitBool(Bool *bool_)
{
/* Code For Bool Goes Here */
/* Code For Bool Goes Here */
}
void Skeleton::visitVoid(Void *void_)
{
/* Code For Void Goes Here */
/* Code For Void Goes Here */
}
void Skeleton::visitArray(Array *array)
{
/* Code For Array Goes Here */
/* Code For Array Goes Here */
array->type_->accept(this);
array->type_->accept(this);
}
void Skeleton::visitClassT(ClassT *class_t)
{
/* Code For ClassT Goes Here */
/* Code For ClassT Goes Here */
class_t->pident_->accept(this);
class_t->pident_->accept(this);
}
void Skeleton::visitFun(Fun *fun)
{
/* Code For Fun Goes Here */
/* Code For Fun Goes Here */
fun->type_->accept(this);
fun->listtype_->accept(this);
fun->type_->accept(this);
fun->listtype_->accept(this);
}
void Skeleton::visitEVar(EVar *e_var)
{
/* Code For EVar Goes Here */
/* Code For EVar Goes Here */
e_var->pident_->accept(this);
e_var->pident_->accept(this);
}
void Skeleton::visitELitInt(ELitInt *e_lit_int)
{
/* Code For ELitInt Goes Here */
/* Code For ELitInt Goes Here */
visitInteger(e_lit_int->integer_);
visitInteger(e_lit_int->integer_);
}
void Skeleton::visitELitTrue(ELitTrue *e_lit_true)
{
/* Code For ELitTrue Goes Here */
/* Code For ELitTrue Goes Here */
}
void Skeleton::visitELitFalse(ELitFalse *e_lit_false)
{
/* Code For ELitFalse Goes Here */
/* Code For ELitFalse Goes Here */
}
void Skeleton::visitEApp(EApp *e_app)
{
/* Code For EApp Goes Here */
/* Code For EApp Goes Here */
e_app->pident_->accept(this);
e_app->listexpr_->accept(this);
e_app->pident_->accept(this);
e_app->listexpr_->accept(this);
}
void Skeleton::visitEString(EString *e_string)
{
/* Code For EString Goes Here */
/* Code For EString Goes Here */
visitString(e_string->string_);
visitString(e_string->string_);
}
void Skeleton::visitENewArray(ENewArray *e_new_array)
{
/* Code For ENewArray Goes Here */
/* Code For ENewArray Goes Here */
e_new_array->type_->accept(this);
e_new_array->expr_->accept(this);
e_new_array->type_->accept(this);
e_new_array->expr_->accept(this);
}
void Skeleton::visitENewClass(ENewClass *e_new_class)
{
/* Code For ENewClass Goes Here */
/* Code For ENewClass Goes Here */
e_new_class->pident_->accept(this);
e_new_class->pident_->accept(this);
}
void Skeleton::visitEClsMmbr(EClsMmbr *e_cls_mmbr)
{
/* Code For EClsMmbr Goes Here */
/* Code For EClsMmbr Goes Here */
e_cls_mmbr->expr_->accept(this);
e_cls_mmbr->pident_->accept(this);
e_cls_mmbr->expr_->accept(this);
e_cls_mmbr->pident_->accept(this);
}
void Skeleton::visitEClsMthd(EClsMthd *e_cls_mthd)
{
/* Code For EClsMthd Goes Here */
/* Code For EClsMthd Goes Here */
e_cls_mthd->expr_->accept(this);
e_cls_mthd->pident_->accept(this);
e_cls_mthd->listexpr_->accept(this);
e_cls_mthd->expr_->accept(this);
e_cls_mthd->pident_->accept(this);
e_cls_mthd->listexpr_->accept(this);
}
void Skeleton::visitNull(Null *null)
{
/* Code For Null Goes Here */
/* Code For Null Goes Here */
}
void Skeleton::visitEIndexAcc(EIndexAcc *e_index_acc)
{
/* Code For EIndexAcc Goes Here */
/* Code For EIndexAcc Goes Here */
e_index_acc->pident_->accept(this);
e_index_acc->expr_->accept(this);
e_index_acc->pident_->accept(this);
e_index_acc->expr_->accept(this);
}
void Skeleton::visitECast(ECast *e_cast)
{
/* Code For ECast Goes Here */
/* Code For ECast Goes Here */
e_cast->pident_->accept(this);
e_cast->expr_->accept(this);
e_cast->pident_->accept(this);
e_cast->expr_->accept(this);
}
void Skeleton::visitNeg(Neg *neg)
{
/* Code For Neg Goes Here */
/* Code For Neg Goes Here */
neg->expr_->accept(this);
neg->expr_->accept(this);
}
void Skeleton::visitNot(Not *not_)
{
/* Code For Not Goes Here */
/* Code For Not Goes Here */
not_->expr_->accept(this);
not_->expr_->accept(this);
}
void Skeleton::visitEMul(EMul *e_mul)
{
/* Code For EMul Goes Here */
/* Code For EMul Goes Here */
e_mul->expr_1->accept(this);
e_mul->mulop_->accept(this);
e_mul->expr_2->accept(this);
e_mul->expr_1->accept(this);
e_mul->mulop_->accept(this);
e_mul->expr_2->accept(this);
}
void Skeleton::visitEAdd(EAdd *e_add)
{
/* Code For EAdd Goes Here */
/* Code For EAdd Goes Here */
e_add->expr_1->accept(this);
e_add->addop_->accept(this);
e_add->expr_2->accept(this);
e_add->expr_1->accept(this);
e_add->addop_->accept(this);
e_add->expr_2->accept(this);
}
void Skeleton::visitERel(ERel *e_rel)
{
/* Code For ERel Goes Here */
/* Code For ERel Goes Here */
e_rel->expr_1->accept(this);
e_rel->relop_->accept(this);
e_rel->expr_2->accept(this);
e_rel->expr_1->accept(this);
e_rel->relop_->accept(this);
e_rel->expr_2->accept(this);
}
void Skeleton::visitEAnd(EAnd *e_and)
{
/* Code For EAnd Goes Here */
/* Code For EAnd Goes Here */
e_and->expr_1->accept(this);
e_and->expr_2->accept(this);
e_and->expr_1->accept(this);
e_and->expr_2->accept(this);
}
void Skeleton::visitEOr(EOr *e_or)
{
/* Code For EOr Goes Here */
/* Code For EOr Goes Here */
e_or->expr_1->accept(this);
e_or->expr_2->accept(this);
e_or->expr_1->accept(this);
e_or->expr_2->accept(this);
}
void Skeleton::visitPlus(Plus *plus)
{
/* Code For Plus Goes Here */
/* Code For Plus Goes Here */
}
void Skeleton::visitMinus(Minus *minus)
{
/* Code For Minus Goes Here */
/* Code For Minus Goes Here */
}
void Skeleton::visitTimes(Times *times)
{
/* Code For Times Goes Here */
/* Code For Times Goes Here */
}
void Skeleton::visitDiv(Div *div)
{
/* Code For Div Goes Here */
/* Code For Div Goes Here */
}
void Skeleton::visitMod(Mod *mod)
{
/* Code For Mod Goes Here */
/* Code For Mod Goes Here */
}
void Skeleton::visitLTH(LTH *lth)
{
/* Code For LTH Goes Here */
/* Code For LTH Goes Here */
}
void Skeleton::visitLE(LE *le)
{
/* Code For LE Goes Here */
/* Code For LE Goes Here */
}
void Skeleton::visitGTH(GTH *gth)
{
/* Code For GTH Goes Here */
/* Code For GTH Goes Here */
}
void Skeleton::visitGE(GE *ge)
{
/* Code For GE Goes Here */
/* Code For GE Goes Here */
}
void Skeleton::visitEQU(EQU *equ)
{
/* Code For EQU Goes Here */
/* Code For EQU Goes Here */
}
void Skeleton::visitNE(NE *ne)
{
/* Code For NE Goes Here */
/* Code For NE Goes Here */
}
......@@ -590,84 +590,84 @@ void Skeleton::visitNE(NE *ne)
void Skeleton::visitListTopDef(ListTopDef *list_top_def)
{
for (ListTopDef::iterator i = list_top_def->begin() ; i != list_top_def->end() ; ++i)
{
(*i)->accept(this);
}
for (ListTopDef::iterator i = list_top_def->begin() ; i != list_top_def->end() ; ++i)
{
(*i)->accept(this);
}
}
void Skeleton::visitListArg(ListArg *list_arg)
{
for (ListArg::iterator i = list_arg->begin() ; i != list_arg->end() ; ++i)
{
(*i)->accept(this);
}
for (ListArg::iterator i = list_arg->begin() ; i != list_arg->end() ; ++i)
{
(*i)->accept(this);
}
}
void Skeleton::visitListClassBlockDef(ListClassBlockDef *list_class_block_def)
{
for (ListClassBlockDef::iterator i = list_class_block_def->begin() ; i != list_class_block_def->end() ; ++i)
{
(*i)->accept(this);
}
for (ListClassBlockDef::iterator i = list_class_block_def->begin() ; i != list_class_block_def->end() ; ++i)
{
(*i)->accept(this);
}
}
void Skeleton::visitListStmt(ListStmt *list_stmt)
{
for (ListStmt::iterator i = list_stmt->begin() ; i != list_stmt->end() ; ++i)
{
(*i)->accept(this);
}
for (ListStmt::iterator i = list_stmt->begin() ; i != list_stmt->end() ; ++i)
{
(*i)->accept(this);
}
}
void Skeleton::visitListItem(ListItem *list_item)
{
for (ListItem::iterator i = list_item->begin() ; i != list_item->end() ; ++i)
{
(*i)->accept(this);
}
for (ListItem::iterator i = list_item->begin() ; i != list_item->end() ; ++i)
{
(*i)->accept(this);
}
}
void Skeleton::visitListType(ListType *list_type)
{
for (ListType::iterator i = list_type->begin() ; i != list_type->end() ; ++i)
{
(*i)->accept(this);
}
for (ListType::iterator i = list_type->begin() ; i != list_type->end() ; ++i)
{
(*i)->accept(this);
}
}
void Skeleton::visitListExpr(ListExpr *list_expr)
{
for (ListExpr::iterator i = list_expr->begin() ; i != list_expr->end() ; ++i)
{
(*i)->accept(this);
}
for (ListExpr::iterator i = list_expr->begin() ; i != list_expr->end() ; ++i)
{
(*i)->accept(this);
}
}
void Skeleton::visitInteger(Integer x)
{
/* Code for Integer Goes Here */
/* Code for Integer Goes Here */
}
void Skeleton::visitChar(Char x)
{
/* Code for Char Goes Here */
/* Code for Char Goes Here */
}
void Skeleton::visitDouble(Double x)
{
/* Code for Double Goes Here */
/* Code for Double Goes Here */
}
void Skeleton::visitString(String x)
{
/* Code for String Goes Here */
/* Code for String Goes Here */
}
void Skeleton::visitIdent(Ident x)
{
/* Code for Ident Goes Here */
/* Code for Ident Goes Here */
}
......
Skeleton.h
View file @ 8072a075
......@@ -8,102 +8,102 @@
class Skeleton : public Visitor
{
public:
void visitProgram(Program *p);
void visitTopDef(TopDef *p);
void visitFunDef(FunDef *p);
void visitArg(Arg *p);
void visitClassDef(ClassDef *p);
void visitClassBlock(ClassBlock *p);
void visitClassBlockDef(ClassBlockDef *p);
void visitBlock(Block *p);
void visitStmt(Stmt *p);
void visitItem(Item *p);
void visitType(Type *p);
void visitExpr(Expr *p);
void visitAddOp(AddOp *p);
void visitMulOp(MulOp *p);
void visitRelOp(RelOp *p);
void visitProg(Prog *p);
void visitFnDef(FnDef *p);
void visitClDef(ClDef *p);
void visitFuncDef(FuncDef *p);
void visitAr(Ar *p);
void visitClassDefN(ClassDefN *p);
void visitClassDefE(ClassDefE *p);
void visitClassBl(ClassBl *p);
void visitClassMthd(ClassMthd *p);
void visitClassFld(ClassFld *p);
void visitBlk(Blk *p);
void visitEmpty(Empty *p);
void visitBStmt(BStmt *p);
void visitDecl(Decl *p);
void visitNoInit(NoInit *p);
void visitInit(Init *p);
void visitAss(Ass *p);
void visitTableAss(TableAss *p);
void visitTableIncr(TableIncr *p);
void visitTableDecr(TableDecr *p);
void visitIncr(Incr *p);
void visitDecr(Decr *p);
void visitRet(Ret *p);
void visitVRet(VRet *p);
void visitCond(Cond *p);
void visitCondElse(CondElse *p);
void visitWhile(While *p);
void visitSExp(SExp *p);
void visitForEach(ForEach *p);
void visitInt(Int *p);
void visitStr(Str *p);
void visitBool(Bool *p);
void visitVoid(Void *p);
void visitArray(Array *p);
void visitClassT(ClassT *p);
void visitFun(Fun *p);
void visitEVar(EVar *p);
void visitELitInt(ELitInt *p);
void visitELitTrue(ELitTrue *p);
void visitELitFalse(ELitFalse *p);
void visitEApp(EApp *p);
void visitEString(EString *p);
void visitENewArray(ENewArray *p);
void visitENewClass(ENewClass *p);
void visitEClsMmbr(EClsMmbr *p);
void visitEClsMthd(EClsMthd *p);
void visitNull(Null *p);
void visitEIndexAcc(EIndexAcc *p);
void visitECast(ECast *p);
void visitNeg(Neg *p);
void visitNot(Not *p);
void visitEMul(EMul *p);
void visitEAdd(EAdd *p);
void visitERel(ERel *p);
void visitEAnd(EAnd *p);
void visitEOr(EOr *p);
void visitPlus(Plus *p);
void visitMinus(Minus *p);
void visitTimes(Times *p);
void visitDiv(Div *p);
void visitMod(Mod *p);
void visitLTH(LTH *p);
void visitLE(LE *p);
void visitGTH(GTH *p);
void visitGE(GE *p);
void visitEQU(EQU *p);
void visitNE(NE *p);
void visitListTopDef(ListTopDef *p);
void visitListArg(ListArg *p);
void visitListClassBlockDef(ListClassBlockDef *p);
void visitListStmt(ListStmt *p);
void visitListItem(ListItem *p);
void visitListType(ListType *p);
void visitListExpr(ListExpr *p);
void visitPIdent(PIdent *p);
void visitProgram(Program *p);
void visitTopDef(TopDef *p);
void visitFunDef(FunDef *p);
void visitArg(Arg *p);
void visitClassDef(ClassDef *p);
void visitClassBlock(ClassBlock *p);
void visitClassBlockDef(ClassBlockDef *p);
void visitBlock(Block *p);
void visitStmt(Stmt *p);
void visitItem(Item *p);
void visitType(Type *p);
void visitExpr(Expr *p);
void visitAddOp(AddOp *p);
void visitMulOp(MulOp *p);
void visitRelOp(RelOp *p);
void visitProg(Prog *p);
void visitFnDef(FnDef *p);
void visitClDef(ClDef *p);
void visitFuncDef(FuncDef *p);
void visitAr(Ar *p);
void visitClassDefN(ClassDefN *p);
void visitClassDefE(ClassDefE *p);
void visitClassBl(ClassBl *p);
void visitClassMthd(ClassMthd *p);
void visitClassFld(ClassFld *p);
void visitBlk(Blk *p);
void visitEmpty(Empty *p);
void visitBStmt(BStmt *p);
void visitDecl(Decl *p);
void visitNoInit(NoInit *p);
void visitInit(Init *p);
void visitAss(Ass *p);
void visitTableAss(TableAss *p);
void visitTableIncr(TableIncr *p);
void visitTableDecr(TableDecr *p);
void visitIncr(Incr *p);
void visitDecr(Decr *p);
void visitRet(Ret *p);
void visitVRet(VRet *p);
void visitCond(Cond *p);
void visitCondElse(CondElse *p);
void visitWhile(While *p);
void visitSExp(SExp *p);
void visitForEach(ForEach *p);
void visitInt(Int *p);
void visitStr(Str *p);
void visitBool(Bool *p);
void visitVoid(Void *p);
void visitArray(Array *p);
void visitClassT(ClassT *p);
void visitFun(Fun *p);
void visitEVar(EVar *p);
void visitELitInt(ELitInt *p);
void visitELitTrue(ELitTrue *p);
void visitELitFalse(ELitFalse *p);
void visitEApp(EApp *p);
void visitEString(EString *p);
void visitENewArray(ENewArray *p);
void visitENewClass(ENewClass *p);
void visitEClsMmbr(EClsMmbr *p);
void visitEClsMthd(EClsMthd *p);
void visitNull(Null *p);
void visitEIndexAcc(EIndexAcc *p);
void visitECast(ECast *p);
void visitNeg(Neg *p);
void visitNot(Not *p);
void visitEMul(EMul *p);
void visitEAdd(EAdd *p);
void visitERel(ERel *p);
void visitEAnd(EAnd *p);
void visitEOr(EOr *p);
void visitPlus(Plus *p);
void visitMinus(Minus *p);
void visitTimes(Times *p);
void visitDiv(Div *p);
void visitMod(Mod *p);
void visitLTH(LTH *p);
void visitLE(LE *p);
void visitGTH(GTH *p);
void visitGE(GE *p);
void visitEQU(EQU *p);
void visitNE(NE *p);
void visitListTopDef(ListTopDef *p);
void visitListArg(ListArg *p);
void visitListClassBlockDef(ListClassBlockDef *p);
void visitListStmt(ListStmt *p);
void visitListItem(ListItem *p);
void visitListType(ListType *p);
void visitListExpr(ListExpr *p);
void visitPIdent(PIdent *p);
void visitInteger(Integer x);
void visitChar(Char x);
void visitDouble(Double x);
void visitString(String x);
void visitIdent(Ident x);
void visitInteger(Integer x);
void visitChar(Char x);
void visitDouble(Double x);
void visitString(String x);
void visitIdent(Ident x);
};
......
TypeCheck.cpp
View file @ 8072a075
......@@ -6,10 +6,10 @@ void TypeCheck::visitTopDef(TopDef *t) {} //abstract class
void TypeCheck::visitFunDef(FunDef *t) {} //abstract class
void TypeCheck::visitArg(Arg *t) {} //abstract class
void TypeCheck::visitClassDef(ClassDef *t) {
t->getName()->accept(this);
if (t->getParent())
t->getParent()->accept(this);
t->getBlock()->accept(this);
t->getName()->accept(this);
if (t->getParent())
t->getParent()->accept(this);
t->getBlock()->accept(this);
}
void TypeCheck::visitClassBlock(ClassBlock *t) {} //abstract class
......@@ -25,554 +25,554 @@ void TypeCheck::visitRelOp(RelOp *t) {} //abstract class
void TypeCheck::visitPIdent(PIdent *p_ident)
{
/* Code For PIdent Goes Here */
/* Code For PIdent Goes Here */
visitString(p_ident->string_);
visitInteger(p_ident->integer_);
visitString(p_ident->string_);
visitInteger(p_ident->integer_);
}
void TypeCheck::visitProg(Prog *prog)
{
/* Code For Prog Goes Here */
/* Code For Prog Goes Here */
prog->listtopdef_->accept(this);
prog->listtopdef_->accept(this);
}
void TypeCheck::visitFnDef(FnDef *fn_def)
{
/* Code For FnDef Goes Here */
/* Code For FnDef Goes Here */
fn_def->fundef_->accept(this);
fn_def->fundef_->accept(this);
}
void TypeCheck::visitClDef(ClDef *cl_def)
{
/* Code For ClDef Goes Here */
/* Code For ClDef Goes Here */
cl_def->classdef_->accept(this);
cl_def->classdef_->accept(this);
}
void TypeCheck::visitFuncDef(FuncDef *func_def)
{
/* Code For FuncDef Goes Here */
/* Code For FuncDef Goes Here */
func_def->type_->accept(this);
func_def->pident_->accept(this);
func_def->listarg_->accept(this);
func_def->block_->accept(this);
func_def->type_->accept(this);
func_def->pident_->accept(this);
func_def->listarg_->accept(this);
func_def->block_->accept(this);
}
void TypeCheck::visitAr(Ar *ar)
{
/* Code For Ar Goes Here */
/* Code For Ar Goes Here */
ar->type_->accept(this);
ar->pident_->accept(this);
ar->type_->accept(this);
ar->pident_->accept(this);
}
void TypeCheck::visitClassDefN(ClassDefN *class_def_n)
{
visitClassDef(class_def_n);
visitClassDef(class_def_n);
}
void TypeCheck::visitClassDefE(ClassDefE *class_def_e)
{
visitClassDef(class_def_e);
visitClassDef(class_def_e);
}
void TypeCheck::visitClassBl(ClassBl *class_bl)
{
/* Code For ClassBl Goes Here */
/* Code For ClassBl Goes Here */
class_bl->listclassblockdef_->accept(this);
class_bl->listclassblockdef_->accept(this);
}
void TypeCheck::visitClassMthd(ClassMthd *class_mthd)
{
/* Code For ClassMthd Goes Here */
/* Code For ClassMthd Goes Here */
class_mthd->fundef_->accept(this);
class_mthd->fundef_->accept(this);
}
void TypeCheck::visitClassFld(ClassFld *class_fld)
{
/* Code For ClassFld Goes Here */
/* Code For ClassFld Goes Here */
class_fld->type_->accept(this);
class_fld->listitem_->accept(this);
class_fld->type_->accept(this);
class_fld->listitem_->accept(this);
}
void TypeCheck::visitBlk(Blk *blk)
{
/* Code For Blk Goes Here */
/* Code For Blk Goes Here */
blk->liststmt_->accept(this);
blk->liststmt_->accept(this);
}
void TypeCheck::visitEmpty(Empty *empty)
{
/* Code For Empty Goes Here */
/* Code For Empty Goes Here */
}
void TypeCheck::visitBStmt(BStmt *b_stmt)
{
/* Code For BStmt Goes Here */
/* Code For BStmt Goes Here */
b_stmt->block_->accept(this);
b_stmt->block_->accept(this);
}
void TypeCheck::visitDecl(Decl *decl)
{
/* Code For Decl Goes Here */
/* Code For Decl Goes Here */
decl->type_->accept(this);
decl->listitem_->accept(this);
decl->type_->accept(this);
decl->listitem_->accept(this);
}
void TypeCheck::visitAss(Ass *ass)
{
/* Code For Ass Goes Here */
/* Code For Ass Goes Here */
ass->expr_1->accept(this);
ass->expr_2->accept(this);
ass->expr_1->accept(this);
ass->expr_2->accept(this);
}
void TypeCheck::visitTableAss(TableAss *table_ass)
{
/* Code For TableAss Goes Here */
/* Code For TableAss Goes Here */
table_ass->pident_->accept(this);
table_ass->expr_1->accept(this);
table_ass->expr_2->accept(this);
table_ass->pident_->accept(this);
table_ass->expr_1->accept(this);
table_ass->expr_2->accept(this);
}
void TypeCheck::visitTableIncr(TableIncr *table_incr)
{
/* Code For TableIncr Goes Here */
/* Code For TableIncr Goes Here */
table_incr->pident_->accept(this);
table_incr->expr_->accept(this);
table_incr->pident_->accept(this);
table_incr->expr_->accept(this);
}
void TypeCheck::visitTableDecr(TableDecr *table_decr)
{
/* Code For TableDecr Goes Here */
/* Code For TableDecr Goes Here */
table_decr->pident_->accept(this);
table_decr->expr_->accept(this);
table_decr->pident_->accept(this);
table_decr->expr_->accept(this);
}
void TypeCheck::visitIncr(Incr *incr)
{
/* Code For Incr Goes Here */
/* Code For Incr Goes Here */
incr->pident_->accept(this);
incr->pident_->accept(this);
}
void TypeCheck::visitDecr(Decr *decr)
{
/* Code For Decr Goes Here */
/* Code For Decr Goes Here */
decr->pident_->accept(this);
decr->pident_->accept(this);
}
void TypeCheck::visitRet(Ret *ret)
{
/* Code For Ret Goes Here */
/* Code For Ret Goes Here */
ret->expr_->accept(this);
ret->expr_->accept(this);
}
void TypeCheck::visitVRet(VRet *v_ret)
{
/* Code For VRet Goes Here */
/* Code For VRet Goes Here */
}
void TypeCheck::visitCond(Cond *cond)
{
/* Code For Cond Goes Here */
/* Code For Cond Goes Here */
cond->expr_->accept(this);
cond->stmt_->accept(this);
cond->expr_->accept(this);
cond->stmt_->accept(this);
}
void TypeCheck::visitCondElse(CondElse *cond_else)
{
/* Code For CondElse Goes Here */
/* Code For CondElse Goes Here */
cond_else->expr_->accept(this);
cond_else->stmt_1->accept(this);
cond_else->stmt_2->accept(this);
cond_else->expr_->accept(this);
cond_else->stmt_1->accept(this);
cond_else->stmt_2->accept(this);
}
void TypeCheck::visitWhile(While *while_)
{
/* Code For While Goes Here */
/* Code For While Goes Here */
while_->expr_->accept(this);
while_->stmt_->accept(this);
while_->expr_->accept(this);
while_->stmt_->accept(this);
}
void TypeCheck::visitSExp(SExp *s_exp)
{
/* Code For SExp Goes Here */
/* Code For SExp Goes Here */
s_exp->expr_->accept(this);
s_exp->expr_->accept(this);
}
void TypeCheck::visitForEach(ForEach *for_each)
{
/* Code For ForEach Goes Here */
/* Code For ForEach Goes Here */
for_each->type_->accept(this);
for_each->pident_->accept(this);
for_each->expr_->accept(this);
for_each->stmt_->accept(this);
for_each->type_->accept(this);
for_each->pident_->accept(this);
for_each->expr_->accept(this);
for_each->stmt_->accept(this);
}
void TypeCheck::visitNoInit(NoInit *no_init)
{
/* Code For NoInit Goes Here */
/* Code For NoInit Goes Here */
no_init->pident_->accept(this);
no_init->pident_->accept(this);
}
void TypeCheck::visitInit(Init *init)
{
/* Code For Init Goes Here */
/* Code For Init Goes Here */
init->pident_->accept(this);
init->expr_->accept(this);
init->pident_->accept(this);
init->expr_->accept(this);
}
void TypeCheck::visitInt(Int *int_)
{
/* Code For Int Goes Here */
/* Code For Int Goes Here */
}
void TypeCheck::visitStr(Str *str)
{
/* Code For Str Goes Here */
/* Code For Str Goes Here */
}
void TypeCheck::visitBool(Bool *bool_)
{
/* Code For Bool Goes Here */
/* Code For Bool Goes Here */
}
void TypeCheck::visitVoid(Void *void_)
{
/* Code For Void Goes Here */
/* Code For Void Goes Here */
}
void TypeCheck::visitArray(Array *array)
{
/* Code For Array Goes Here */
/* Code For Array Goes Here */
array->type_->accept(this);
array->type_->accept(this);
}
void TypeCheck::visitClassT(ClassT *class_t)
{
/* Code For ClassT Goes Here */
/* Code For ClassT Goes Here */
class_t->pident_->accept(this);
class_t->pident_->accept(this);
}
void TypeCheck::visitFun(Fun *fun)
{
/* Code For Fun Goes Here */
/* Code For Fun Goes Here */
fun->type_->accept(this);
fun->listtype_->accept(this);
fun->type_->accept(this);
fun->listtype_->accept(this);
}
void TypeCheck::visitEVar(EVar *e_var)
{
/* Code For EVar Goes Here */
/* Code For EVar Goes Here */
e_var->pident_->accept(this);
e_var->pident_->accept(this);
}
void TypeCheck::visitELitInt(ELitInt *e_lit_int)
{
/* Code For ELitInt Goes Here */
/* Code For ELitInt Goes Here */
visitInteger(e_lit_int->integer_);
visitInteger(e_lit_int->integer_);
}
void TypeCheck::visitELitTrue(ELitTrue *e_lit_true)
{
/* Code For ELitTrue Goes Here */
/* Code For ELitTrue Goes Here */
}
void TypeCheck::visitELitFalse(ELitFalse *e_lit_false)
{
/* Code For ELitFalse Goes Here */
/* Code For ELitFalse Goes Here */
}
void TypeCheck::visitEApp(EApp *e_app)
{
/* Code For EApp Goes Here */
/* Code For EApp Goes Here */
e_app->pident_->accept(this);
e_app->listexpr_->accept(this);
e_app->pident_->accept(this);
e_app->listexpr_->accept(this);
}
void TypeCheck::visitEString(EString *e_string)
{
/* Code For EString Goes Here */
/* Code For EString Goes Here */
visitString(e_string->string_);
visitString(e_string->string_);
}
void TypeCheck::visitENewArray(ENewArray *e_new_array)
{
/* Code For ENewArray Goes Here */
/* Code For ENewArray Goes Here */
e_new_array->type_->accept(this);
e_new_array->expr_->accept(this);
e_new_array->type_->accept(this);
e_new_array->expr_->accept(this);
}
void TypeCheck::visitENewClass(ENewClass *e_new_class)
{
/* Code For ENewClass Goes Here */
/* Code For ENewClass Goes Here */
e_new_class->pident_->accept(this);
e_new_class->pident_->accept(this);
}
void TypeCheck::visitEClsMmbr(EClsMmbr *e_cls_mmbr)
{
/* Code For EClsMmbr Goes Here */
/* Code For EClsMmbr Goes Here */
e_cls_mmbr->expr_->accept(this);
e_cls_mmbr->pident_->accept(this);
e_cls_mmbr->expr_->accept(this);
e_cls_mmbr->pident_->accept(this);
}
void TypeCheck::visitEClsMthd(EClsMthd *e_cls_mthd)
{
/* Code For EClsMthd Goes Here */
/* Code For EClsMthd Goes Here */
e_cls_mthd->expr_->accept(this);
e_cls_mthd->pident_->accept(this);
e_cls_mthd->listexpr_->accept(this);
e_cls_mthd->expr_->accept(this);
e_cls_mthd->pident_->accept(this);
e_cls_mthd->listexpr_->accept(this);
}
void TypeCheck::visitNull(Null *null)
{
/* Code For Null Goes Here */
/* Code For Null Goes Here */
}
void TypeCheck::visitEIndexAcc(EIndexAcc *e_index_acc)
{
/* Code For EIndexAcc Goes Here */
/* Code For EIndexAcc Goes Here */
e_index_acc->pident_->accept(this);
e_index_acc->expr_->accept(this);
e_index_acc->pident_->accept(this);
e_index_acc->expr_->accept(this);
}
void TypeCheck::visitECast(ECast *e_cast)
{
/* Code For ECast Goes Here */
/* Code For ECast Goes Here */
e_cast->pident_->accept(this);
e_cast->expr_->accept(this);
e_cast->pident_->accept(this);
e_cast->expr_->accept(this);
}
void TypeCheck::visitNeg(Neg *neg)
{
/* Code For Neg Goes Here */
/* Code For Neg Goes Here */
neg->expr_->accept(this);
neg->expr_->accept(this);
}
void TypeCheck::visitNot(Not *not_)
{
/* Code For Not Goes Here */
/* Code For Not Goes Here */
not_->expr_->accept(this);
not_->expr_->accept(this);
}
void TypeCheck::visitEMul(EMul *e_mul)
{
/* Code For EMul Goes Here */
/* Code For EMul Goes Here */
e_mul->expr_1->accept(this);
e_mul->mulop_->accept(this);
e_mul->expr_2->accept(this);
e_mul->expr_1->accept(this);
e_mul->mulop_->accept(this);
e_mul->expr_2->accept(this);
}
void TypeCheck::visitEAdd(EAdd *e_add)
{
/* Code For EAdd Goes Here */
/* Code For EAdd Goes Here */
e_add->expr_1->accept(this);
e_add->addop_->accept(this);
e_add->expr_2->accept(this);
e_add->expr_1->accept(this);
e_add->addop_->accept(this);
e_add->expr_2->accept(this);
}
void TypeCheck::visitERel(ERel *e_rel)
{
/* Code For ERel Goes Here */
/* Code For ERel Goes Here */
e_rel->expr_1->accept(this);
e_rel->relop_->accept(this);
e_rel->expr_2->accept(this);
e_rel->expr_1->accept(this);
e_rel->relop_->accept(this);
e_rel->expr_2->accept(this);
}
void TypeCheck::visitEAnd(EAnd *e_and)
{
/* Code For EAnd Goes Here */
/* Code For EAnd Goes Here */
e_and->expr_1->accept(this);
e_and->expr_2->accept(this);
e_and->expr_1->accept(this);
e_and->expr_2->accept(this);
}
void TypeCheck::visitEOr(EOr *e_or)
{
/* Code For EOr Goes Here */
/* Code For EOr Goes Here */
e_or->expr_1->accept(this);
e_or->expr_2->accept(this);
e_or->expr_1->accept(this);
e_or->expr_2->accept(this);
}
void TypeCheck::visitPlus(Plus *plus)
{
/* Code For Plus Goes Here */
/* Code For Plus Goes Here */
}
void TypeCheck::visitMinus(Minus *minus)
{
/* Code For Minus Goes Here */
/* Code For Minus Goes Here */
}
void TypeCheck::visitTimes(Times *times)
{
/* Code For Times Goes Here */
/* Code For Times Goes Here */
}
void TypeCheck::visitDiv(Div *div)
{
/* Code For Div Goes Here */
/* Code For Div Goes Here */
}
void TypeCheck::visitMod(Mod *mod)
{
/* Code For Mod Goes Here */
/* Code For Mod Goes Here */
}
void TypeCheck::visitLTH(LTH *lth)
{
/* Code For LTH Goes Here */
/* Code For LTH Goes Here */
}
void TypeCheck::visitLE(LE *le)
{
/* Code For LE Goes Here */
/* Code For LE Goes Here */
}
void TypeCheck::visitGTH(GTH *gth)
{
/* Code For GTH Goes Here */
/* Code For GTH Goes Here */
}
void TypeCheck::visitGE(GE *ge)
{
/* Code For GE Goes Here */
/* Code For GE Goes Here */
}
void TypeCheck::visitEQU(EQU *equ)
{
/* Code For EQU Goes Here */
/* Code For EQU Goes Here */
}
void TypeCheck::visitNE(NE *ne)
{
/* Code For NE Goes Here */
/* Code For NE Goes Here */
}
......@@ -580,84 +580,84 @@ void TypeCheck::visitNE(NE *ne)
void TypeCheck::visitListTopDef(ListTopDef *list_top_def)
{
for (ListTopDef::iterator i = list_top_def->begin() ; i != list_top_def->end() ; ++i)
{
(*i)->accept(this);
}
for (ListTopDef::iterator i = list_top_def->begin() ; i != list_top_def->end() ; ++i)
{
(*i)->accept(this);
}
}
void TypeCheck::visitListArg(ListArg *list_arg)
{
for (ListArg::iterator i = list_arg->begin() ; i != list_arg->end() ; ++i)
{
(*i)->accept(this);
}
for (ListArg::iterator i = list_arg->begin() ; i != list_arg->end() ; ++i)
{
(*i)->accept(this);
}
}
void TypeCheck::visitListClassBlockDef(ListClassBlockDef *list_class_block_def)
{
for (ListClassBlockDef::iterator i = list_class_block_def->begin() ; i != list_class_block_def->end() ; ++i)
{
(*i)->accept(this);
}
for (ListClassBlockDef::iterator i = list_class_block_def->begin() ; i != list_class_block_def->end() ; ++i)
{
(*i)->accept(this);
}
}
void TypeCheck::visitListStmt(ListStmt *list_stmt)
{
for (ListStmt::iterator i = list_stmt->begin() ; i != list_stmt->end() ; ++i)
{
(*i)->accept(this);
}
for (ListStmt::iterator i = list_stmt->begin() ; i != list_stmt->end() ; ++i)
{
(*i)->accept(this);
}
}
void TypeCheck::visitListItem(ListItem *list_item)
{
for (ListItem::iterator i = list_item->begin() ; i != list_item->end() ; ++i)
{
(*i)->accept(this);
}
for (ListItem::iterator i = list_item->begin() ; i != list_item->end() ; ++i)
{
(*i)->accept(this);
}
}
void TypeCheck::visitListType(ListType *list_type)
{
for (ListType::iterator i = list_type->begin() ; i != list_type->end() ; ++i)
{
(*i)->accept(this);
}
for (ListType::iterator i = list_type->begin() ; i != list_type->end() ; ++i)
{
(*i)->accept(this);
}
}
void TypeCheck::visitListExpr(ListExpr *list_expr)
{
for (ListExpr::iterator i = list_expr->begin() ; i != list_expr->end() ; ++i)
{
(*i)->accept(this);
}
for (ListExpr::iterator i = list_expr->begin() ; i != list_expr->end() ; ++i)
{
(*i)->accept(this);
}
}
void TypeCheck::visitInteger(Integer x)
{
/* Code for Integer Goes Here */
/* Code for Integer Goes Here */
}
void TypeCheck::visitChar(Char x)
{
/* Code for Char Goes Here */
/* Code for Char Goes Here */
}
void TypeCheck::visitDouble(Double x)
{
/* Code for Double Goes Here */
/* Code for Double Goes Here */
}
void TypeCheck::visitString(String x)
{
/* Code for String Goes Here */
/* Code for String Goes Here */
}
void TypeCheck::visitIdent(Ident x)
{
/* Code for Ident Goes Here */
/* Code for Ident Goes Here */
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment