stree.cpp

Go to the documentation of this file.

#include "stree.h"
#include "streeconstant.h"

bool stringToBool(string value) { 
  if (value=="0") return false; else return true; 
};
string boolToString(bool value) { 
  if (value) return "1"; else return "0"; 
};
int stringToInt(string value){
  if (value=="")
    return 0;
  else {
    istringstream str(value);
    int i;
    str >> i;
    return i;
  }
};
string intToString(int value){
  ostringstream str;
  str << value;
  return str.str();
};


StatementList::StatementList() : NamedList(CStatementList){};

StatementList::StatementList(Node *statement) : NamedList(CStatementList,statement){};

ostream& StatementList::php(ostream &os) const{
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      os << (*it);
      it++;
    };
    return os;
};  

Node* StatementList::copy() const{
    return copyContent(new StatementList());
};

InlineHTMLList::InlineHTMLList() : NamedList(CInlineHTMLList){};

InlineHTMLList::InlineHTMLList(Node *statement) : NamedList(CInlineHTMLList,statement){};

ostream& InlineHTMLList::php(ostream &os) const{
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      os << (*it);
      it++;
    };
    return os;
};  

Node* InlineHTMLList::copy() const{
    return copyContent(new InlineHTMLList());
};

TemplateList::TemplateList() : NamedList(CTemplateList){};

TemplateList::TemplateList(Node *statement) : NamedList(CTemplateList,statement){};

ostream& TemplateList::php(ostream &os) const{
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      os << (*it);
      it++;
      if (it!=eit) os << ",";
    };
    return os;
};  

Node* TemplateList::copy() const{
    return copyContent(new TemplateList());
};

ExpressionList::ExpressionList() : NamedList(CExpressionList){};

ExpressionList::ExpressionList(Node *statement) : NamedList(CExpressionList,statement){};

ostream& ExpressionList::php(ostream &os) const{
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      (*it)->php(os);
      it++;
      if (it!=eit) os << ",";
    };
    return os;
};

Node* ExpressionList::copy() const{
    return copyContent(new ExpressionList());
};

ArrayPairList::ArrayPairList() : NamedList(CArrayPairList){};

ArrayPairList::ArrayPairList(Node *statement) : NamedList(CArrayPairList,statement){};

ostream& ArrayPairList::php(ostream &os) const{
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      (*it)->php(os);
      it++;
      if (it!=eit) os << ",";
    };
    return os;
  };

Node* ArrayPairList::copy() const{
    return copyContent(new ArrayPairList());
};


DeclareList::DeclareList() : NamedList(CDeclareList){};

DeclareList::DeclareList(Node *statement) : NamedList(CDeclareList,statement){};

ostream& DeclareList::php(ostream &os) const{
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      (*it)->php(os);
      it++;
      if (it!=eit) os<< ",";
    };
    return os;
};  

Node* DeclareList::copy() const{
    return copyContent(new DeclareList());
};

CaseList::CaseList() : NamedList(CCaseList){};

CaseList::CaseList(Node *statement) : NamedList(CCaseList,statement){};

ostream& CaseList::php(ostream &os) const{
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      (*it)->php(os);
      it++;
    };
    return os;
};  

Node* CaseList::copy() const{
    return copyContent(new CaseList());
};

EncapsList::EncapsList() : NamedList(CEncapsList){};

EncapsList::EncapsList(Node *statement) : NamedList(CEncapsList,statement){};

ostream& EncapsList::php(ostream &os) const{
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      (*it)->php(os);
      it++;
    };
    return os;
};  

Node* EncapsList::copy() const{
    return copyContent(new EncapsList());
};

string EncapsList::evaluate(const NameSpace &nameSpace) const{
  return toString();
};

AssignmentList::AssignmentList() : NamedList(CAssignmentList){};

AssignmentList::AssignmentList(Node *statement) : NamedList(CAssignmentList,statement){};

ostream& AssignmentList::php(ostream &os) const{
    const_iterator it = begin();
    const_iterator eit = end();
    while (it!=eit){
      (*it)->php(os);
      it++;
      if (it!=eit) os<< ",";
    };
    return os;
};  

Node* AssignmentList::copy() const{
    return copyContent(new AssignmentList());
};


PHP::PHP(Node *statement) : Unary(CPHP,statement) {};

ostream& PHP::php(ostream &os) const{
    os << "<?\n" << getStatement1() << "?>\n";
    return os;
};    

Node* PHP::copy() const{
    return new PHP(getStatement1()->copy());
};

EchoPHP::EchoPHP(Node *statement) : Unary(CEchoPHP,statement) {};

ostream& EchoPHP::php(ostream &os) const{
    os << "<?=\n" << getStatement1() << "?>\n";
    return os;
};    

Node* EchoPHP::copy() const{
    return new EchoPHP(getStatement1()->copy());
};

CurlyBraces::CurlyBraces(Node *statement) : Unary(CCurlyBraces,statement) {};

ostream& CurlyBraces::php(ostream &os) const{
    os << "{\n" << getStatement1() << "}\n";
    return os;
};    

Node* CurlyBraces::copy() const{
    return new CurlyBraces(getStatement1()->copy());
};

SmartyBraces::SmartyBraces(Node *statement) : Unary(CSmartyBraces,statement) {};

ostream& SmartyBraces::php(ostream &os) const{
    os << "{" << getStatement1() << "}";
    return os;
};    

Node* SmartyBraces::copy() const{
    return new SmartyBraces(getStatement1()->copy());
};

DoubleQuote::DoubleQuote(Node *statement) : Unary(CDoubleQuote,statement) {};

ostream& DoubleQuote::php(ostream &os) const{
    os << "\"" << getStatement1() << "\"";
    return os;
};    

Node* DoubleQuote::copy() const{
    return new DoubleQuote(getStatement1()->copy());
};

string DoubleQuote::evaluate(const NameSpace &nameSpace) const{
  return getStatement1()->evaluate(nameSpace);
};


If::If(Node* statement1, Node* statement2, Node* statement3) 
    : Ternary(CIf,statement1,statement2,statement3){};

ostream& If::php(ostream &os) const{
    os << "if" << "(" << getStatement1() << ")" << getStatement2();
    if (getStatement3()->getType()!=SPin) os << "else" << getStatement3();
    return os;
};  

Node* If::copy() const{
    return new If(getStatement1()->copy(),getStatement2()->copy(),getStatement3()->copy());
};

For::For(Node* statement1, Node* statement2, Node* statement3, Node* statement4) 
    : Quadary(CFor,statement1,statement2,statement3,statement4){};

ostream& For::php(ostream &os) const{
    os << "for" << "(" << getStatement1() << ";" << getStatement2() << ";" 
       << getStatement3() << ")" << endl << getStatement4();
    return os;
};  

Node* For::copy() const{
    return new For(getStatement1()->copy(),getStatement2()->copy(),getStatement3()->copy(),getStatement4()->copy());
};

While::While(Node* statement1, Node* statement2) 
    : Binary(CWhile,statement1,statement2){};

ostream& While::php(ostream &os) const{
    os << "while" << "(" << getStatement1() <<  ")" << getStatement2();
    return os;
  };    

Node* While::copy() const{
    return new While(getStatement1()->copy(),getStatement2()->copy());
};

Do::Do(Node* statement1, Node* statement2) 
    : Binary(CDo,statement1,statement2){};

ostream& Do::php(ostream &os) const{
    os << "do" << getStatement1() <<  "while(" << getStatement2() << ");\n";
    return os;
};    

Node* Do::copy() const{
    return new Do(getStatement1()->copy(),getStatement2()->copy());
};

Switch::Switch(Node* statement1, Node* statement2) 
    : Binary(CSwitch,statement1,statement2){};

ostream& Switch::php(ostream &os) const{
    os << "switch(" << getStatement1() <<  ")" << getStatement2();
    return os;
};    

Node* Switch::copy() const{
    return new Switch(getStatement1()->copy(),getStatement2()->copy());
};

Break::Break(Node *statement) : Unary(CBreak,statement) {};

ostream& Break::php(ostream &os) const{
    os << "break " << getStatement1();
    return os << ";\n";
  };    

Node* Break::copy() const{
    return new Break(getStatement1()->copy());
};

Continue::Continue(Node *statement) : Unary(CContinue,statement) {};

ostream& Continue::php(ostream &os) const{
    os << "continue " << getStatement1();
    return os << ";\n";
};    

Node* Continue::copy() const{
    return new Continue(getStatement1()->copy());
};

Return::Return(Node *statement) : Unary(CReturn,statement) {};

ostream& Return::php(ostream &os) const{
    os << "return " << getStatement1();
    return os << ";\n";
};    

Node* Return::copy() const{
    return new Return(getStatement1()->copy());
};

Global::Global(Node *statement) : Unary(CGlobal,statement) {};

ostream& Global::php(ostream &os) const{
    os << "global " << getStatement1() << ";\n";
    return os;
};    

Node* Global::copy() const{
    return new Global(getStatement1()->copy());
};

Static::Static(Node *statement) : Unary(CStatic,statement) {};

ostream& Static::php(ostream &os) const{
    os << "static " << getStatement1() << ";\n";
    return os;
};    

Node* Static::copy() const{
    return new Static(getStatement1()->copy());
};

Echo::Echo(Node *statement) : Unary(CEcho,statement) {};

ostream& Echo::php(ostream &os) const{
    os << "echo " << getStatement1() << ";\n";
    return os;
};    

Node* Echo::copy() const{
    return new Echo(getStatement1()->copy());
};

Template::Template(Node *statement) : Unary(CTemplate,statement) {};

ostream& Template::php(ostream &os) const{
    os << getStatement1() << "\n";
    return os;
};    

Node* Template::copy() const{
    return new Template(getStatement1()->copy());
};

SmartyAssign::SmartyAssign(Node* statement1, Node* statement2) 
    : Binary(CSmartyAssign,statement1,statement2){};

SmartyAssign::SmartyAssign(Node* statement1, Node* statement2, string iphpOut) 
    : Binary(CSmartyAssign,statement1,statement2), phpOut(iphpOut) {};

ostream& SmartyAssign::php(ostream &os) const{
    os << phpOut;//"SmartyAssign" << "(" << getVariable() <<  "," << getAssignment() << ");";
    return os;
};    

const Node* SmartyAssign::getVariable() const{
    return getStatement1();
};

const Node* SmartyAssign::getAssignment() const{
    return getStatement2();
};

void SmartyAssign::setPHPOut(string iphpOut) {
    phpOut = iphpOut;
};

Node* SmartyAssign::copy() const{
    return new SmartyAssign(getStatement1()->copy(),getStatement2()->copy(), phpOut);
};

InlineHTML::InlineHTML(Node *statement) : Unary(CInlineHTML,statement) {};

ostream& InlineHTML::php(ostream &os) const{
    os << getStatement1();
    return os;
};    

Node* InlineHTML::copy() const{
    return new InlineHTML(getStatement1()->copy());
};

string InlineHTML::getHTML() const{
    return dynamic_cast<const Constant *>(getStatement1())->getValue();
};

void InlineHTML::setHTML(const string &html){
    delete *begin();
    *begin() = new Constant(html);
};


Expression::Expression(Node *statement) : Unary(CExpression,statement) {};

ostream& Expression::php(ostream &os) const{
    os << getStatement1() << ";\n";
    return os;
};    

Node* Expression::copy() const{
    return new Expression(getStatement1()->copy());
};

Unset::Unset(Node *statement) : Unary(CUnset,statement) {};

ostream& Unset::php(ostream &os) const{
    os << "unset (" << getStatement1() << ");\n";
    return os;
};    

Node* Unset::copy() const{
    return new Unset(getStatement1()->copy());
};

Use::Use(Node *statement) : Unary(CUse,statement) {};

ostream& Use::php(ostream &os) const{
    os << "use " << getStatement1() << ";\n";
    return os;
};    

Node* Use::copy() const{
    return new Use(getStatement1()->copy());
};

Foreach::Foreach(Node* statement1, Node* statement2, Node* statement3, Node* statement4) 
    : Quadary(CForeach,statement1,statement2,statement3,statement4){};

ostream& Foreach::php(ostream &os) const{
    os << "foreach" << "(" << getStatement1() << "as" << getStatement2();
    if (getStatement3()->getType()!=SPin) os << "=>" << getStatement3();
    os << ")" << getStatement4();
    return os;
};  

Node* Foreach::copy() const{
    return new Foreach(getStatement1()->copy(),getStatement2()->copy(),getStatement3()->copy(),getStatement4()->copy());
};

Declare::Declare(Node* statement1, Node* statement2) 
    : Binary(CDeclare,statement1,statement2){};

ostream& Declare::php(ostream &os) const{
    os << "declare(" << getStatement1() <<  ")" << getStatement2();
    return os;
};    

Node* Declare::copy() const{
    return new Declare(getStatement1()->copy(),getStatement2()->copy());
};

EmptyStatement::EmptyStatement() : Nullary(CEmptyStatement) {};

ostream& EmptyStatement::php(ostream &os) const{
    return os << ";\n";
};    

Node* EmptyStatement::copy() const{
    return new EmptyStatement();
};

Function::Function(Node* statement1, Node* statement2, Node* statement3, Node* statement4) 
    : Quadary(CFunction,statement1,statement2,statement3,statement4){};

ostream& Function::php(ostream &os) const{
    os << "function " << getStatement1() << getStatement2() << "(" 
       << getStatement3() << ")" << endl << "{" << endl << getStatement4() << "}" << endl;
    return os;
};  

Node* Function::copy() const{
    return new Function(getStatement1()->copy(),getStatement2()->copy(),getStatement3()->copy(),getStatement4()->copy());
};

Class::Class(Node* statement1, Node* statement2, Node* statement3) 
    : Ternary(CClass,statement1,statement2,statement3){};
 
ostream& Class::php(ostream &os) const{
    os << "class" << getStatement1();
    if (getStatement2()->getType()!=SPin) os << "extends" << getStatement2();
    os << "{" << getStatement3() << "}";
    return os;
};  

Node* Class::copy() const{
    return new Class(getStatement1()->copy(),getStatement2()->copy(),getStatement3()->copy());
};

Const::Const(Node* statement1, Node* statement2) 
    : Binary(CConst,statement1,statement2){};

ostream& Const::php(ostream &os) const{
    os << getStatement1() <<  "=" << getStatement2();
    return os;
};    

Node* Const::copy() const{
    return new Const(getStatement1()->copy(),getStatement2()->copy());
};

Case::Case(Node* statement1, Node* statement2) 
    : Binary(CCase,statement1,statement2){};

ostream& Case::php(ostream &os) const{
    if (getStatement1()->getType()!=SPin){
      os << "case" << getStatement1() << ":" << getStatement2();
    } else {
      os << "default :" << getStatement2();
    }
    return os;
};    

Node* Case::copy() const{
    return new Case(getStatement1()->copy(),getStatement2()->copy());
};

Parameter::Parameter(Node* statement1, Node* statement2, Node* statement3) 
    : Ternary(CParameter,statement1,statement2,statement3){};

ostream& Parameter::php(ostream &os) const{
    if (getStatement1()->getType()!=SPin) os << getStatement1();
    os << getStatement2();
    if (getStatement3()->getType()!=SPin) os << "=" << getStatement3();
    return os;
};  

Node* Parameter::copy() const{
    return new Parameter(getStatement1()->copy(),getStatement2()->copy(),getStatement3()->copy());
};


ClassVariable::ClassVariable(Node *statement) : Unary(CClassVariable,statement) {};

ostream& ClassVariable::php(ostream &os) const{
    os << "var " << getStatement1() << ";\n";
    return os;
};    

Node* ClassVariable::copy() const{
    return new ClassVariable(getStatement1()->copy());
};

UnaryOperator::UnaryOperator(string oname, Node* statement2) 
    : Binary(CUnaryOperator,new Constant(oname),statement2) {};

ostream& UnaryOperator::php(ostream &os) const{
    os << getStatement1() << getStatement2();
    return os;
};    

Node* UnaryOperator::copy() const{
    return new UnaryOperator(dynamic_cast<const Constant*>(getStatement1())->getValue(),getStatement2()->copy());
};

string UnaryOperator::evaluate(const NameSpace &nameSpace) const{
  string o = dynamic_cast<const Constant*>(getStatement1())->getValue();
  if (o == "++")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace))+1);
  else if (o == "--")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace))-1);
  else if (o == "+")
    return getStatement2()->evaluate(nameSpace);
  else if (o == "-")
    return intToString(-stringToInt(getStatement2()->evaluate(nameSpace)));
  else if (o == "!")
    return boolToString(!stringToBool(getStatement2()->evaluate(nameSpace)));
  else throw "ERROR: UnaryOperator::evaluate - operation " + o + " not implemented";
}

PostUnaryOperator::PostUnaryOperator(string oname, Node* statement2) 
    : Binary(CPostUnaryOperator,new Constant(oname),statement2){};

ostream& PostUnaryOperator::php(ostream &os) const{
    os << getStatement2() << getStatement1();
    return os;
};    

Node* PostUnaryOperator::copy() const{
    return new PostUnaryOperator(dynamic_cast<const Constant*>(getStatement1())->getValue(),getStatement2()->copy());
};

string PostUnaryOperator::evaluate(const NameSpace &nameSpace) const{
  string o = dynamic_cast<const Constant*>(getStatement1())->getValue();
  if (o == "++")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace))+1);
  else if (o == "--")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace))-1);
  else throw "ERROR: PostUnaryOperator::evaluate - operation " + o + " not implemented";
}

BinaryOperator::BinaryOperator(string oname, Node* statement2, Node* statement3) 
  : Ternary(CBinaryOperator,new Constant(oname),statement2,statement3){};
BinaryOperator::BinaryOperator(Node* ioperator, Node* statement2, Node* statement3) 
  : Ternary(CBinaryOperator, ioperator ,statement2,statement3){};

ostream& BinaryOperator::php(ostream &os) const{
  os << getStatement2() << " "<< getStatement1() << " " << getStatement3();
    return os;
};  

Node* BinaryOperator::copy() const{
    return new BinaryOperator(dynamic_cast<const Constant*>(getStatement1())->getValue(),getStatement2()->copy(),getStatement3()->copy());
};

string BinaryOperator::evaluate(const NameSpace &nameSpace) const{
  string o = dynamic_cast<const Constant*>(getStatement1())->getValue();
  if (o == "OR")
    return boolToString(stringToBool(getStatement2()->evaluate(nameSpace)) || stringToBool(getStatement3()->evaluate(nameSpace)));
  else if (o == "AND")
    return boolToString(stringToBool(getStatement2()->evaluate(nameSpace)) && stringToBool(getStatement3()->evaluate(nameSpace)));
  else if (o == "XOR")
    return boolToString(stringToBool(getStatement2()->evaluate(nameSpace)) xor stringToBool(getStatement3()->evaluate(nameSpace)));
  else if (o == ".")
    return getStatement2()->evaluate(nameSpace) + getStatement3()->evaluate(nameSpace);
  else if (o == "+")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace)) + stringToInt(getStatement3()->evaluate(nameSpace)));
  else if (o == "-")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace)) - stringToInt(getStatement3()->evaluate(nameSpace)));
  else if (o == "*")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace)) * stringToInt(getStatement3()->evaluate(nameSpace)));
  else if (o == "%")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace)) % stringToInt(getStatement3()->evaluate(nameSpace)));
  else if (o == "/")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace)) / stringToInt(getStatement3()->evaluate(nameSpace)));
  else if (o == "==")
    return boolToString(getStatement2()->evaluate(nameSpace) == getStatement3()->evaluate(nameSpace));
  else if (o == "!=")
    return boolToString(getStatement2()->evaluate(nameSpace) != getStatement3()->evaluate(nameSpace));
  else if (o == "<")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace)) < stringToInt(getStatement3()->evaluate(nameSpace)));
  else if (o == "<=")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace)) <= stringToInt(getStatement3()->evaluate(nameSpace)));
  else if (o == ">")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace)) > stringToInt(getStatement3()->evaluate(nameSpace)));
  else if (o == ">=")
    return intToString(stringToInt(getStatement2()->evaluate(nameSpace)) >= stringToInt(getStatement3()->evaluate(nameSpace)));
  else throw "ERROR: BinaryOperator::evaluate - operation " + o + " not implemented";
};


AList::AList(Node *statement) : Unary(CAList,statement) {};

ostream& AList::php(ostream &os) const{
    os << "list(" << getStatement1() << ")";
    return os;
};    

Node* AList::copy() const{
    return new AList(getStatement1()->copy());
};


EncapsExpr::EncapsExpr(string ebegin, Node *statement, string eend) : Ternary(CEncapsExpr,new Constant(ebegin),statement, new Constant(eend)) {};

ostream& EncapsExpr::php(ostream &os) const{
    os << getStatement1() << getStatement2() << getStatement3();
    return os;
};    

Node* EncapsExpr::copy() const{
    return new EncapsExpr(dynamic_cast<const Constant*>(getStatement1())->getValue(),
                          getStatement2()->copy(),
                          dynamic_cast<const Constant*>(getStatement3())->getValue());
};

string EncapsExpr::evaluate(const NameSpace &nameSpace) const{
  return getStatement2()->evaluate(nameSpace);
};


AskOperator::AskOperator(Node* statement1, Node* statement2, Node* statement3) 
    : Ternary(CAskOperator,statement1,statement2,statement3){};

ostream& AskOperator::php(ostream &os) const{
    os << getStatement1() << "?" << getStatement2() << ":" << getStatement3();
    return os;
};  

Node* AskOperator::copy() const{
    return new AskOperator(getStatement1()->copy(),getStatement2()->copy(),getStatement3()->copy());
};

string AskOperator::evaluate(const NameSpace &nameSpace) const{
  return (getStatement1()->evaluate(nameSpace)=="0") ? getStatement2()->evaluate(nameSpace) : getStatement3()->evaluate(nameSpace);
};


Exit::Exit(Node *statement) : Unary(CExit,statement) {};

ostream& Exit::php(ostream &os) const{
    os << "exit(" << getStatement1() << ")";
    return os;
};    

Node* Exit::copy() const{
    return new Exit(getStatement1()->copy());
};

Print::Print(Node *statement) : Unary(CPrint,statement) {};

ostream& Print::php(ostream &os) const{
    os << "print " << getStatement1();
    return os;
};    

Node* Print::copy() const{
    return new Print(getStatement1()->copy());
};

Array::Array(Node *statement) : Unary(CArray,statement) {};

ostream& Array::php(ostream &os) const{
    os << "array(" << getStatement1() << ")";
    return os;
};    

Node* Array::copy() const{
    return new Array(getStatement1()->copy());
};

FunctionCall::FunctionCall(Node* statement1, Node* statement2, Node* statement3) 
    : Ternary(CFunctionCall,statement1,statement2,statement3){};

ostream& FunctionCall::php(ostream &os) const{
    if (getStatement1()->getType()!=SPin)
      os << getStatement1() << "::";
    os << getStatement2() << "(" << getStatement3() << ")";
    return os;
};  

Node* FunctionCall::copy() const{
    return new FunctionCall(getStatement1()->copy(),getStatement2()->copy(),getStatement3()->copy());
};


ArrayPair::ArrayPair(Node* statement1, Node* statement2) 
    : Binary(CArrayPair,statement1,statement2){};

ostream& ArrayPair::php(ostream &os) const{

    if (getStatement1()->getType()!=SPin)
      os << getStatement1() << "=>";

    os << getStatement2();
    
    return os;
};    

Node* ArrayPair::copy() const{
    return new ArrayPair(getStatement1()->copy(),getStatement2()->copy());
};

ObjectOperator::ObjectOperator(Node* statement1, Node* statement2) 
    : Binary(CObjectOperator,statement1,statement2){};

ostream& ObjectOperator::php(ostream &os) const{
    os << getStatement1() << "->" << getStatement2();    
    return os;
};    

Node* ObjectOperator::copy() const{
    return new ObjectOperator(getStatement1()->copy(),getStatement2()->copy());
};

ArrayOperator::ArrayOperator(Node* statement1, Node* statement2) 
    : Binary(CArrayOperator,statement1,statement2){};

ostream& ArrayOperator::php(ostream &os) const{
    os << getStatement1() << "[" << getStatement2() << "]";
    return os;
};    

Node* ArrayOperator::copy() const{
    return new ArrayOperator(getStatement1()->copy(),getStatement2()->copy());
};

MapOperator::MapOperator(Node* statement1, Node* statement2) 
    : Binary(CMapOperator,statement1,statement2){};

ostream& MapOperator::php(ostream &os) const{
    os << getStatement1() << "{" << getStatement2() << "}"; 
    return os;
};    

Node* MapOperator::copy() const{
    return new MapOperator(getStatement1()->copy(),getStatement2()->copy());
};

Ref::Ref(Node* statement) 
    : UnaryOperator(OpRef,statement){};
 

Isset::Isset(Node *statement) : Unary(CIsset,statement) {};

ostream& Isset::php(ostream &os) const{
    os << "isset(" << getStatement1() << ")";
    return os;
};    

Node* Isset::copy() const{
    return new Isset(getStatement1()->copy());
};

ConstantEncapsedString::ConstantEncapsedString(Node *statement) : Unary(CConstantEncapsedString,statement) {};

ostream& ConstantEncapsedString::php(ostream &os) const{
  os << "'" << getStatement1() << "'";
  return os;
};    

Node* ConstantEncapsedString::copy() const{
    return new ConstantEncapsedString(getStatement1()->copy());
};

string ConstantEncapsedString::evaluate(const NameSpace &nameSpace) const{
  return getStatement1()->evaluate(nameSpace);
};

PHPVariable::PHPVariable(Node *statement) : Unary(CPHPVariable,statement) {};

ostream& PHPVariable::php(ostream &os) const{
    os  << getStatement1();
    return os;
};    

Node* PHPVariable::copy() const{
    return new PHPVariable(getStatement1()->copy());
};

ConstantString::ConstantString(Node *statement) : Unary(CConstantString,statement) {};

ostream& ConstantString::php(ostream &os) const{
  os << getStatement1();
  return os;
};    

Node* ConstantString::copy() const{
    return new ConstantString(getStatement1()->copy());
};

string ConstantString::evaluate(const NameSpace &nameSpace) const{
  return getStatement1()->evaluate(nameSpace);
};

---