Implementing Semantic Actions in the Boost Spirit Parser Framework

#include "StdAfx.h"
#include "expressiontree.h"

#include <sstream>
#include <assert.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

using namespace std;
using namespace Calculator;
using namespace Types;

////////////////////////////////////////////////////////////////////////////////
///	Definitions for root of expression tree
///
////////////////////////////////////////////////////////////////////////////////
CExpressionTree::CExpressionTree()
{
}

CExpressionTree::~CExpressionTree()
{
}

CExpressionTree::CExpressionTree( const CExpressionTree &src ) :
CGenericTree<CExpressionTree>( src )
{
}

CExpressionTree &
CExpressionTree::operator=( const CExpressionTree &rhs )
{
	if ( this != &rhs )
	{
		CGenericTree<CExpressionTree>::operator=( rhs );
	}
	return *this;
}

////////////////////////////////////////////////////////////////////////////////
///	Definitions for root node
///
////////////////////////////////////////////////////////////////////////////////
CTreeRoot::CTreeRoot()
{
}

CTreeRoot::~CTreeRoot()
{
}

CTreeRoot::CTreeRoot( const CTreeRoot &src ) :
CExpressionTree( src )
{
}

CTreeRoot &
CTreeRoot::operator=( const CTreeRoot &rhs )
{
	if ( this != &rhs )
	{
		CExpressionTree::operator=( rhs );
	}
	return *this;
}

CTreeRoot *
CTreeRoot::Clone()
{
	return new CTreeRoot( *this );
}

CExpressionTree *
CTreeRoot::Create()
{
	return new CTreeRoot();
}

void
CTreeRoot::AddChild( CExpressionTree *node )
{
	// Simply push the node onto the tree
	push_back( node );
}

void
CTreeRoot::AddParent( CExpressionTree *node )
{
	// Take the last 2 children from the root, add them to the new node
	CExpressionTree *last1 = NULL, *last2 = NULL;
	shallow_iterator iter = begin_shallow();
	for ( ; iter != end_shallow(); ++iter )
	{
		last2 = last1;
		last1 = *iter;
	}
	if ( last1 == NULL || last2 == NULL )
	{
		assert( false );
		delete node;
		return;
	}
	node->push_back( remove( last2 ) );
	node->push_back( remove( last1 ) );
	// Now add the new node to the tree
	push_back( node );
}

string
CTreeRoot::GetValue() const
{
	return string( "" );
}

////////////////////////////////////////////////////////////////////////////////
///	Definitions for plus operator
///
////////////////////////////////////////////////////////////////////////////////
COperatorPlus::COperatorPlus()
{
}

COperatorPlus::~COperatorPlus()
{
}

COperatorPlus::COperatorPlus( const COperatorPlus &src ) :
CExpressionTree( src )
{
}

COperatorPlus &
COperatorPlus::operator=( const COperatorPlus &rhs )
{
	if ( this != &rhs )
	{
		CExpressionTree::operator=( rhs );
	}
	return *this;
}

COperatorPlus *
COperatorPlus::Clone()
{
	return new COperatorPlus( *this );
}

CExpressionTree *
COperatorPlus::Create()
{
	return new COperatorPlus();
}

string
COperatorPlus::GetValue() const
{
	return string( "+" );
}

////////////////////////////////////////////////////////////////////////////////
///	Definitions for minus operator
///
////////////////////////////////////////////////////////////////////////////////
COperatorMinus::COperatorMinus()
{
}

COperatorMinus::~COperatorMinus()
{
}

COperatorMinus::COperatorMinus( const COperatorMinus &src ) :
CExpressionTree( src )
{
}

COperatorMinus &
COperatorMinus::operator=( const COperatorMinus &rhs )
{
	if ( this != &rhs )
	{
		CExpressionTree::operator=( rhs );
	}
	return *this;
}

COperatorMinus *
COperatorMinus::Clone()
{
	return new COperatorMinus( *this );
}

CExpressionTree *
COperatorMinus::Create()
{
	return new COperatorMinus();
}

string
COperatorMinus::GetValue() const
{
	return string( "-" );
}

////////////////////////////////////////////////////////////////////////////////
///	Definitions for multiply operator
///
////////////////////////////////////////////////////////////////////////////////
COperatorMultiply::COperatorMultiply()
{
}

COperatorMultiply::~COperatorMultiply()
{
}

COperatorMultiply::COperatorMultiply( const COperatorMultiply &src ) :
CExpressionTree( src )
{
}

COperatorMultiply &
COperatorMultiply::operator=( const COperatorMultiply &rhs )
{
	if ( this != &rhs )
	{
		CExpressionTree::operator=( rhs );
	}
	return *this;
}

COperatorMultiply *
COperatorMultiply::Clone()
{
	return new COperatorMultiply( *this );
}

CExpressionTree *
COperatorMultiply::Create()
{
	return new COperatorMultiply();
}

string
COperatorMultiply::GetValue() const
{
	return string( "*" );
}

////////////////////////////////////////////////////////////////////////////////
///	Definitions for divide operator
///
////////////////////////////////////////////////////////////////////////////////
COperatorDivide::COperatorDivide()
{
}

COperatorDivide::~COperatorDivide()
{
}

COperatorDivide::COperatorDivide( const COperatorDivide &src ) :
CExpressionTree( src )
{
}

COperatorDivide &
COperatorDivide::operator=( const COperatorDivide &rhs )
{
	if ( this != &rhs )
	{
		CExpressionTree::operator=( rhs );
	}
	return *this;
}

COperatorDivide *
COperatorDivide::Clone()
{
	return new COperatorDivide( *this );
}

CExpressionTree *
COperatorDivide::Create()
{
	return new COperatorDivide();
}

string
COperatorDivide::GetValue() const
{
	return string( "/" );
}

////////////////////////////////////////////////////////////////////////////////
///	Definitions for unary minus operator
///
////////////////////////////////////////////////////////////////////////////////
COperatorUnaryMinus::COperatorUnaryMinus()
{
}

COperatorUnaryMinus::~COperatorUnaryMinus()
{
}

COperatorUnaryMinus::COperatorUnaryMinus( const COperatorUnaryMinus &src ) :
CExpressionTree( src )
{
}

COperatorUnaryMinus &
COperatorUnaryMinus::operator=( const COperatorUnaryMinus &rhs )
{
	if ( this != &rhs )
	{
		CExpressionTree::operator=( rhs );
	}
	return *this;
}

COperatorUnaryMinus *
COperatorUnaryMinus::Clone()
{
	return new COperatorUnaryMinus( *this );
}

CExpressionTree *
COperatorUnaryMinus::Create()
{
	return new COperatorUnaryMinus();
}

string
COperatorUnaryMinus::GetValue() const
{
	return string( "-" );
}

////////////////////////////////////////////////////////////////////////////////
///	Definitions for value node
///
////////////////////////////////////////////////////////////////////////////////
CValue::CValue() :
m_value( 0 )
{
}

CValue::~CValue()
{
}

CValue::CValue( int value ) :
m_value( value )
{
}

CValue::CValue( const CValue &src ) :
CExpressionTree( src ),
m_value( src.m_value )
{
}

CValue &
CValue::operator=( const CValue &rhs )
{
	if ( this != &rhs )
	{
		CExpressionTree::operator=( rhs );
		m_value = rhs.m_value;
	}
	return *this;
}

CValue *
CValue::Clone()
{
	return new CValue( *this );
}

CExpressionTree *
CValue::Create()
{
	return new CValue();
}

void
CValue::SetNumber( int value )
{
	m_value = value;
}

int
CValue::GetNumber() const
{
	return m_value;
}

string
CValue::GetValue() const
{
	ostringstream str;
	str << m_value;
	return str.str();
}

////////////////////////////////////////////////////////////////////////////////
///	Definitions for empty node
///
////////////////////////////////////////////////////////////////////////////////
CEmpty::CEmpty()
{
}

CEmpty::~CEmpty()
{
}

CEmpty::CEmpty( const CEmpty &src ) :
CExpressionTree( src )
{
}

CEmpty &
CEmpty::operator=( const CEmpty &rhs )
{
	if ( this != &rhs )
	{
		CExpressionTree::operator=( rhs );
	}
	return *this;
}

CEmpty *
CEmpty::Clone()
{
	return new CEmpty( *this );
}

CExpressionTree *
CEmpty::Create()
{
	return new CEmpty();
}

string
CEmpty::GetValue() const
{
	return string();
}