source: translator/SynTree/Statement.cc @ ad8e062

#include <functional>
#include <algorithm>
#include <iostream>
#include <list>
#include <cassert>

#include "Statement.h"
#include "Expression.h"
#include "Declaration.h"
#include "Common/SemanticError.h"

using std::string;
using std::endl;


// *** Statement
Statement::Statement(std::list<Label> _labels):
    labels(_labels) {}

void Statement::print(std::ostream &, int indent) {}

Statement::~Statement() {}

//*** ExprStmt
ExprStmt::ExprStmt( std::list<Label> _labels, Expression *_expr ):
    Statement(_labels), expr(_expr) {}

ExprStmt::~ExprStmt() {}

void ExprStmt::print( std::ostream &os, int indent ) {
    os << "\r" << string(indent, ' ') << "Expression Statement:" << endl;
    expr->print(os, indent + 2);
} 

//*** BranchStmt
const char *BranchStmt::brType[] = { "Goto", "Break", "Continue" };

BranchStmt::BranchStmt( std::list<Label> labels, Label _target, Type _type ) 
    throw (SemanticError) :
    Statement(labels), target(_target), type(_type)
{
    //actually this is a syntactic error signaled by the parser
    if(type == BranchStmt::Goto && target.size() == 0)
        throw SemanticError("goto without target");
}

BranchStmt::BranchStmt( std::list<Label> labels, Expression *_computedTarget, Type _type)
    throw (SemanticError) :
    Statement(labels), computedTarget(_computedTarget), type(_type)
{
    if(type != BranchStmt::Goto || computedTarget == 0)
        throw SemanticError("Computed target not valid in branch statement");
}

void BranchStmt::print( std::ostream &os, int indent ){
    os << "\r" << string(indent, ' ') << "Branch (" << brType[type] << ")" << endl ;
}

//*** ReturnStmt
ReturnStmt::ReturnStmt( std::list<Label> labels, Expression *_expr, bool throwP ) :
    Statement( labels ), expr( _expr ), isThrow( throwP ) {}

ReturnStmt::~ReturnStmt() {
    delete expr;
}

void ReturnStmt::print( std::ostream &os, int indent ){
    os << "\r" << std::string(indent, ' ') << string ( isThrow? "Throw":"Return" ) << " Statement, returning: ";
    if(expr != 0) expr->print(os);
    os << endl;
}


// *** IfStmt
IfStmt::IfStmt( std::list<Label> _labels, Expression *_condition, Statement *_thenPart, Statement *_elsePart ):
    Statement(_labels), condition(_condition), thenPart(_thenPart), elsePart(_elsePart) {}

IfStmt::~IfStmt() {}

void IfStmt::print( std::ostream &os, int indent ){
    os << "\r" << string(indent, ' ') << "If on condition: " << endl ;
    condition->print(os, indent + 4);

    os << string(indent, ' ') << ".... and branches: " << endl;

    thenPart->print(os, indent + 4);

    if(elsePart != 0){
        elsePart->print(os, indent + 4);
    }
}

// *** SwitchStmt
SwitchStmt::SwitchStmt(std::list<Label> _labels, Expression * _condition, std::list<Statement *> &_branches):
    Statement(_labels), condition(_condition), branches(_branches)
{ }

SwitchStmt::~SwitchStmt() {
    delete condition;
    // destroy branches
}

void SwitchStmt::add_case(CaseStmt *c) {}

void SwitchStmt::print(std::ostream &os, int indent) {
    os << "\r" << string(indent, ' ') << "Switch on condition: ";
    condition->print(os);
    os << endl;

    // branches
    std::list<Statement *>::iterator i;
    for(i = branches.begin(); i != branches.end(); i++)
        (*i)->print(os, indent + 4);

    //for_each(branches.begin(), branches.end(), mem_fun(bind1st(&Statement::print), os));
}

// *** CaseStmt
CaseStmt::CaseStmt( std::list<Label> _labels, Expression *_condition,
                                        std::list<Statement *> &_statements, bool deflt )
    throw (SemanticError) : 
    Statement(_labels), condition(_condition), stmts(_statements), _isDefault(deflt)
{
    if(isDefault() && condition != 0)
        throw SemanticError("default with conditions");
}

CaseStmt::~CaseStmt() {
    delete condition;
}

void CaseStmt::print(std::ostream &os, int indent) {
    os << "\r" << string(indent, ' ');

    if(isDefault())
        os << "Default ";
    else {
        os << "Case ";
        condition->print(os);
    }

    os << endl;

    std::list<Statement *>::iterator i;
    for(i = stmts.begin(); i != stmts.end(); i++)
        (*i)->print(os, indent + 4);
}

//*** ChooseStmt
//ChooseStmt::ChooseStmt( std::list<Label> labels, Expression *condition, Statement *body ) {}
ChooseStmt::ChooseStmt(std::list<Label> _labels, Expression * _condition, std::list<Statement *> &_branches):
    Statement(_labels), condition(_condition), branches(_branches)
{ }

ChooseStmt::~ChooseStmt() {
    delete condition;
}

void ChooseStmt::add_case(CaseStmt *c) {}

void ChooseStmt::print(std::ostream &os, int indent) {
    os << "\r" << string(indent, ' ') << "Choose on condition: ";
    condition->print(os);
    os << endl;

    // branches
    std::list<Statement *>::iterator i;
    for(i = branches.begin(); i != branches.end(); i++)
        (*i)->print(os, indent + 4);

    //for_each(branches.begin(), branches.end(), mem_fun(bind1st(&Statement::print), os));
}

//*** FallthruStmt
void FallthruStmt::print(std::ostream &os, int indent) {
    os << "\r" << string(indent, ' ') << "Fall-through statement" << endl;
}

//*** WhileStmt
WhileStmt::WhileStmt( std::list<Label> labels, Expression *condition_,
                                            Statement *body_, bool isDoWhile_ ):
    Statement( labels ), condition(condition_), body(body_), isDoWhile(isDoWhile_)
{}

WhileStmt::~WhileStmt(){
    delete body;
}

void WhileStmt::print( std::ostream &os, int indent ){
    os << "\r" << string(indent, ' ') << "While on condition: " << endl ;
    condition->print(os, indent + 4);

    os << string(indent, ' ') << ".... with body: " << endl;

    if(body != 0) body->print(os, indent + 4);
}

//*** ForStmt
ForStmt::ForStmt( std::list<Label> labels, Statement *initialization_,
                                    Expression *condition_, Expression *increment_, Statement *body_ ):
    Statement( labels ), initialization( initialization_ ),
    condition( condition_ ), increment( increment_ ), body( body_ )
{ }


ForStmt::~ForStmt() {
    delete initialization;
    delete condition;
    delete increment;
    delete body;
}

void ForStmt::print( std::ostream &os, int indent ){
    os << "\r" << string(indent, ' ') << "For Statement" << endl ;

    os << "\r" << string(indent + 2, ' ') << "initialization: \n"; 
    if (initialization != 0)
        initialization->print(os, indent + 4);

    os << "\n\r" << string(indent + 2, ' ') << "condition: \n"; 
    if (condition != 0)
        condition->print(os, indent + 4);

    os << "\n\r" << string(indent + 2, ' ') << "increment: \n"; 
    if (increment != 0)
        increment->print(os, indent + 4);

    os << "\n\r" << string(indent + 2, ' ') << "statement block: \n"; 
    if(body != 0)
        body->print(os, indent + 4);

    os << endl;
}

//*** TryStmt
TryStmt::TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<Statement *> &_handlers, FinallyStmt *_finallyBlock ) :
    Statement( labels ), block( tryBlock ),  handlers( _handlers ), finallyBlock( _finallyBlock )
{ }

TryStmt::TryStmt( const TryStmt &other) : Statement( other.labels ) {
    block = other.block;
    std::copy( other.handlers.begin(), other.handlers.end(), back_inserter(handlers) );
    finallyBlock = other.finallyBlock;
}

TryStmt::~TryStmt(){
    delete block;
}

void TryStmt::print( std::ostream &os, int indent ) {
    os << "\r" << string(indent, ' ') << "Try Statement" << endl;
    os << string(indent + 2, ' ') << "with block: " << endl;
    block->print(os, indent + 4);

    // handlers
    os << string(indent + 2, ' ') << "and handlers: " << endl;
    std::list<Statement *>::iterator i;
    for(i = handlers.begin(); i != handlers.end(); i++)
        (*i)->print(os, indent + 4);

    // finally block
    if ( finallyBlock != 0 ) {
        os << string(indent + 2, ' ') << "Finally block: " << endl;
        finallyBlock->print(os, indent + 4 );
    }
}

//*** CatchStmt
CatchStmt::CatchStmt( std::list<Label> labels, Declaration *_decl, Statement *_body, bool isCatchRest ) :
    Statement( labels ), decl ( _decl ), body( _body ), catchRest ( isCatchRest )
{ }

CatchStmt::~CatchStmt(){
    delete decl;
    delete body;
}

void CatchStmt::print( std::ostream &os, int indent ) {
    os << "\r" << string(indent, ' ') << "Catch Statement" << endl;

    os << "\r" << string(indent, ' ') << "... catching" << endl;
    if( decl ) {
        decl->printShort( os, indent + 4 );
        os << endl;
    } else if ( catchRest )
        os << "\r" << string(indent + 4 , ' ') << "the rest" << endl;
    else
        os << "\r" << string(indent + 4 , ' ') << ">>> Error:  this catch clause must have a declaration <<<" << endl;
}


//*** FinallyStmt
FinallyStmt::FinallyStmt( std::list<Label> labels, CompoundStmt *_block ) :
    Statement( labels ), block( _block )
{
    assert( labels.empty() ); // finally statement cannot be labeled
}

FinallyStmt::~FinallyStmt(){
    delete block;
}

void FinallyStmt::print( std::ostream &os, int indent ) {
    os << "\r" << string(indent, ' ') << "Finally Statement" << endl;
    os << string(indent + 2, ' ') << "with block: " << endl;
    block->print(os, indent + 4);
}

//*** NullStmt
NullStmt::NullStmt( std::list<Label> labels ) : CompoundStmt( labels ) {}
NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}
NullStmt::~NullStmt() {}

void NullStmt::print( std::ostream &os, int indent ) {
    os << "\r" << string(indent, ' ') << "Null Statement" << endl ;
}



/*
Local Variables:
compile-command: "cd ..; gmake"
End:
*/