/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"
#include "svx/EnhancedCustomShape2d.hxx"
#include <rtl/ustring.hxx>
#include <tools/fract.hxx>

// Makes parser a static resource,
// we're synchronized externally.
// But watch out, the parser might have
// state not visible to this code!

#define BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE
#if defined(VERBOSE) && defined(DBG_UTIL)
#include <typeinfo>
#define BOOST_SPIRIT_DEBUG
#endif
#include <boost/spirit/include/classic_core.hpp>

#if (OSL_DEBUG_LEVEL > 0)
#include <iostream>
#endif
#include <functional>
#include <algorithm>
#include <stack>

#include <math.h> // fabs, sqrt, sin, cos, tan, atan, atan2
using namespace EnhancedCustomShape;
using namespace com::sun::star;
using namespace com::sun::star::drawing;

void EnhancedCustomShape::FillEquationParameter( const EnhancedCustomShapeParameter& rSource, const sal_Int32 nDestPara, EnhancedCustomShapeEquation& rDest )
{
	sal_Int32 nValue = 0;
	if ( rSource.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
	{
		double fValue;
		if ( rSource.Value >>= fValue )
			nValue = (sal_Int32)fValue;
	}
	else
		rSource.Value >>= nValue;

	switch( rSource.Type )
	{
		case com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION :
		{
			if ( nValue & 0x40000000 )
			{
				nValue ^= 0x40000000;
				rDest.nOperation |= 0x20000000 << nDestPara;	// the bit is indicating that this value has to be adjusted later
			}
			nValue |= 0x400;
		}
		break;
		case com::sun::star::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT : nValue += DFF_Prop_adjustValue; break;
		case com::sun::star::drawing::EnhancedCustomShapeParameterType::BOTTOM : nValue = DFF_Prop_geoBottom; break;
		case com::sun::star::drawing::EnhancedCustomShapeParameterType::RIGHT : nValue = DFF_Prop_geoRight; break;
		case com::sun::star::drawing::EnhancedCustomShapeParameterType::TOP : nValue = DFF_Prop_geoTop;	break;
		case com::sun::star::drawing::EnhancedCustomShapeParameterType::LEFT : nValue = DFF_Prop_geoLeft; break;
	}
	if ( rSource.Type != com::sun::star::drawing::EnhancedCustomShapeParameterType::NORMAL )
		rDest.nOperation |= ( 0x2000 << nDestPara );
	rDest.nPara[ nDestPara ] = nValue;
}

ExpressionNode::~ExpressionNode()
{}

namespace
{

//////////////////////
//////////////////////
// EXPRESSION NODES
//////////////////////
//////////////////////
class ConstantValueExpression : public ExpressionNode
{
    double	maValue;

public:

	ConstantValueExpression( double rValue ) :
        maValue( rValue )
    {
    }
    virtual double operator()() const
    {
        return maValue;
    }
    virtual bool isConstant() const
    {
        return true;
    }
	virtual ExpressionFunct getType() const
	{
		return FUNC_CONST;
	}
	virtual EnhancedCustomShapeParameter fillNode( std::vector< EnhancedCustomShapeEquation >& rEquations, ExpressionNode* /* pOptionalArg */, sal_uInt32 /* nFlags */ )
	{
		EnhancedCustomShapeParameter aRet;
		Fraction aFract( maValue );
		if ( aFract.GetDenominator() == 1 )
		{
			aRet.Type = EnhancedCustomShapeParameterType::NORMAL;
			aRet.Value <<= (sal_Int32)aFract.GetNumerator();
		}
		else
		{
			EnhancedCustomShapeEquation aEquation;
			aEquation.nOperation = 1;
			aEquation.nPara[ 0 ] = 1;
			aEquation.nPara[ 1 ] = (sal_Int16)aFract.GetNumerator();
			aEquation.nPara[ 2 ] = (sal_Int16)aFract.GetDenominator();
			aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
			aRet.Value <<= (sal_Int32)rEquations.size();
			rEquations.push_back( aEquation );
		}
		return aRet;
	}
};

class AdjustmentExpression : public ExpressionNode
{
    sal_Int32						mnIndex;
	const EnhancedCustomShape2d&	mrCustoShape;

public:

	AdjustmentExpression( const EnhancedCustomShape2d& rCustoShape, sal_Int32 nIndex )
	: mnIndex		( nIndex )
	, mrCustoShape( rCustoShape )

    {
    }
    virtual double operator()() const
    {
		return mrCustoShape.GetAdjustValueAsDouble( mnIndex );
    }
    virtual bool isConstant() const
    {
        return false;
    }
	virtual ExpressionFunct getType() const
	{
		return ENUM_FUNC_ADJUSTMENT;
	}
	virtual EnhancedCustomShapeParameter fillNode( std::vector< EnhancedCustomShapeEquation >& /*rEquations*/, ExpressionNode* /*pOptionalArg*/, sal_uInt32 /*nFlags*/ )
	{
		EnhancedCustomShapeParameter aRet;
		aRet.Type = EnhancedCustomShapeParameterType::ADJUSTMENT;
		aRet.Value <<= mnIndex;
		return aRet;
	}
};

class EquationExpression : public ExpressionNode
{
    sal_Int32						mnIndex;
	const EnhancedCustomShape2d&	mrCustoShape;

public:

	EquationExpression( const EnhancedCustomShape2d& rCustoShape, sal_Int32 nIndex )
		: mnIndex		( nIndex )
        , mrCustoShape( rCustoShape )
    {
    }
    virtual double operator()() const
    {
		return mrCustoShape.GetEquationValueAsDouble( mnIndex );
    }
    virtual bool isConstant() const
    {
        return false;
    }
	virtual ExpressionFunct getType() const
	{
		return ENUM_FUNC_EQUATION;
	}
	virtual EnhancedCustomShapeParameter fillNode( std::vector< EnhancedCustomShapeEquation >& /*rEquations*/, ExpressionNode* /*pOptionalArg*/, sal_uInt32 /*nFlags*/ )
	{
		EnhancedCustomShapeParameter aRet;
		aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
		aRet.Value <<= mnIndex | 0x40000000;						// the bit is indicating that this equation needs to be adjusted later
		return aRet;
	}
};

class EnumValueExpression : public ExpressionNode
{
    const ExpressionFunct			meFunct;
	const EnhancedCustomShape2d&	mrCustoShape;

public:

	EnumValueExpression( const EnhancedCustomShape2d& rCustoShape, const ExpressionFunct eFunct )
		: meFunct		( eFunct )
		, mrCustoShape	( rCustoShape )
    {
    }
	static double getValue( const EnhancedCustomShape2d& rCustoShape, const ExpressionFunct eFunc )
	{
		EnhancedCustomShape2d::EnumFunc eF;
		switch( eFunc )
		{
			case ENUM_FUNC_PI :			eF = EnhancedCustomShape2d::ENUM_FUNC_PI; break;
			case ENUM_FUNC_LEFT :		eF = EnhancedCustomShape2d::ENUM_FUNC_LEFT; break;
			case ENUM_FUNC_TOP :		eF = EnhancedCustomShape2d::ENUM_FUNC_TOP; break;
			case ENUM_FUNC_RIGHT :		eF = EnhancedCustomShape2d::ENUM_FUNC_RIGHT; break;
			case ENUM_FUNC_BOTTOM :		eF = EnhancedCustomShape2d::ENUM_FUNC_BOTTOM; break;
			case ENUM_FUNC_XSTRETCH :	eF = EnhancedCustomShape2d::ENUM_FUNC_XSTRETCH; break;
			case ENUM_FUNC_YSTRETCH :	eF = EnhancedCustomShape2d::ENUM_FUNC_YSTRETCH; break;
			case ENUM_FUNC_HASSTROKE :	eF = EnhancedCustomShape2d::ENUM_FUNC_HASSTROKE; break;
			case ENUM_FUNC_HASFILL :	eF = EnhancedCustomShape2d::ENUM_FUNC_HASFILL; break;
			case ENUM_FUNC_WIDTH :		eF = EnhancedCustomShape2d::ENUM_FUNC_WIDTH; break;
			case ENUM_FUNC_HEIGHT :		eF = EnhancedCustomShape2d::ENUM_FUNC_HEIGHT; break;
			case ENUM_FUNC_LOGWIDTH :	eF = EnhancedCustomShape2d::ENUM_FUNC_LOGWIDTH; break;
			case ENUM_FUNC_LOGHEIGHT :	eF = EnhancedCustomShape2d::ENUM_FUNC_LOGHEIGHT; break;

			default :
				return 0.0;
		}
		return rCustoShape.GetEnumFunc( eF );
	}
    virtual double operator()() const
    {
		return getValue( mrCustoShape, meFunct );
    }
    virtual bool isConstant() const
    {
		return false;
    }
	virtual ExpressionFunct getType() const
	{
		return meFunct;
	}
	virtual EnhancedCustomShapeParameter fillNode( std::vector< EnhancedCustomShapeEquation >& rEquations, ExpressionNode* /*pOptionalArg*/, sal_uInt32 nFlags )
	{
		EnhancedCustomShapeParameter aRet;

		sal_Int32 nDummy = 1;
		aRet.Value <<= nDummy;

		switch( meFunct )
		{
			case ENUM_FUNC_WIDTH :	// TODO: do not use this as constant value
			case ENUM_FUNC_HEIGHT :
			case ENUM_FUNC_LOGWIDTH :
			case ENUM_FUNC_LOGHEIGHT :
			case ENUM_FUNC_PI :
			{
				ConstantValueExpression aConstantValue( getValue( mrCustoShape, meFunct ) );
				aRet = aConstantValue.fillNode( rEquations, NULL, nFlags );
			}
			break;
			case ENUM_FUNC_LEFT :	aRet.Type = EnhancedCustomShapeParameterType::LEFT; break;
			case ENUM_FUNC_TOP :	aRet.Type = EnhancedCustomShapeParameterType::TOP; break;
			case ENUM_FUNC_RIGHT :	aRet.Type = EnhancedCustomShapeParameterType::RIGHT; break;
			case ENUM_FUNC_BOTTOM :	aRet.Type = EnhancedCustomShapeParameterType::BOTTOM; break;

			// not implemented so far
			case ENUM_FUNC_XSTRETCH :
			case ENUM_FUNC_YSTRETCH :
			case ENUM_FUNC_HASSTROKE :
			case ENUM_FUNC_HASFILL : aRet.Type = EnhancedCustomShapeParameterType::NORMAL; break;

			default:
				break;
		}
		return aRet;
	}
};

/** ExpressionNode implementation for unary
    function over one ExpressionNode
    */
class UnaryFunctionExpression : public ExpressionNode
{
    const ExpressionFunct	meFunct;
    ExpressionNodeSharedPtr	mpArg;

public:
    UnaryFunctionExpression( const ExpressionFunct eFunct, const ExpressionNodeSharedPtr& rArg ) :
        meFunct( eFunct ),
        mpArg( rArg )
    {
    }
	static double getValue( const ExpressionFunct eFunct, const ExpressionNodeSharedPtr& rArg )
	{
		double fRet = 0;
		switch( eFunct )
		{
			case UNARY_FUNC_ABS : fRet = fabs( (*rArg)() ); break;
			case UNARY_FUNC_SQRT: fRet = sqrt( (*rArg)() ); break;
			case UNARY_FUNC_SIN : fRet = sin( (*rArg)() );  break;
			case UNARY_FUNC_COS : fRet = cos( (*rArg)() );  break;
			case UNARY_FUNC_TAN : fRet = tan( (*rArg)() );  break;
			case UNARY_FUNC_ATAN: fRet = atan( (*rArg)() ); break;
			case UNARY_FUNC_NEG : fRet = ::std::negate<double>()( (*rArg)() ); break;
			default:
				break;
		}
		return fRet;
	}
    virtual double operator()() const
    {
		return getValue( meFunct, mpArg );
    }
    virtual bool isConstant() const
    {
        return mpArg->isConstant();
    }
	virtual ExpressionFunct getType() const
	{
		return meFunct;
	}
	virtual EnhancedCustomShapeParameter fillNode( std::vector< EnhancedCustomShapeEquation >& rEquations, ExpressionNode* pOptionalArg, sal_uInt32 nFlags )
	{
		EnhancedCustomShapeParameter aRet;
		switch( meFunct )
		{
			case UNARY_FUNC_ABS :
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 3;
				FillEquationParameter( mpArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			case UNARY_FUNC_SQRT:
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 13;
				FillEquationParameter( mpArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			case UNARY_FUNC_SIN :
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 9;
				if ( pOptionalArg )
					FillEquationParameter( pOptionalArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				else
					aEquation.nPara[ 0 ] = 1;

				EnhancedCustomShapeParameter aSource( mpArg->fillNode( rEquations, NULL, nFlags | EXPRESSION_FLAG_SUMANGLE_MODE ) );
				if ( aSource.Type == EnhancedCustomShapeParameterType::NORMAL )
				{	// sumangle needed :-(
					EnhancedCustomShapeEquation	_aEquation;
					_aEquation.nOperation |= 0xe;	// sumangle
					FillEquationParameter( aSource, 1, _aEquation );
					aSource.Type = EnhancedCustomShapeParameterType::EQUATION;
					aSource.Value <<= (sal_Int32)rEquations.size();
					rEquations.push_back( _aEquation );
				}
				FillEquationParameter( aSource, 1, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			case UNARY_FUNC_COS :
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 10;
				if ( pOptionalArg )
					FillEquationParameter( pOptionalArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				else
					aEquation.nPara[ 0 ] = 1;

				EnhancedCustomShapeParameter aSource( mpArg->fillNode( rEquations, NULL, nFlags | EXPRESSION_FLAG_SUMANGLE_MODE ) );
				if ( aSource.Type == EnhancedCustomShapeParameterType::NORMAL )
				{	// sumangle needed :-(
					EnhancedCustomShapeEquation	aTmpEquation;
					aTmpEquation.nOperation |= 0xe;	// sumangle
					FillEquationParameter( aSource, 1, aTmpEquation );
					aSource.Type = EnhancedCustomShapeParameterType::EQUATION;
					aSource.Value <<= (sal_Int32)rEquations.size();
					rEquations.push_back( aTmpEquation );
				}
				FillEquationParameter( aSource, 1, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			case UNARY_FUNC_TAN :
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 16;
				if ( pOptionalArg )
					FillEquationParameter( pOptionalArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				else
					aEquation.nPara[ 0 ] = 1;

				EnhancedCustomShapeParameter aSource( mpArg->fillNode( rEquations, NULL, nFlags | EXPRESSION_FLAG_SUMANGLE_MODE ) );
				if ( aSource.Type == EnhancedCustomShapeParameterType::NORMAL )
				{	// sumangle needed :-(
					EnhancedCustomShapeEquation	aTmpEquation;
					aTmpEquation.nOperation |= 0xe;	// sumangle
					FillEquationParameter( aSource, 1, aTmpEquation );
					aSource.Type = EnhancedCustomShapeParameterType::EQUATION;
					aSource.Value <<= (sal_Int32)rEquations.size();
					rEquations.push_back( aTmpEquation );
				}
				FillEquationParameter( aSource, 1, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			case UNARY_FUNC_ATAN:
			{
// TODO:
				aRet.Type = EnhancedCustomShapeParameterType::NORMAL;
			}
			break;
			case UNARY_FUNC_NEG:
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 1;
				aEquation.nPara[ 1 ] = -1;
				aEquation.nPara[ 2 ] = 1;
				FillEquationParameter( mpArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			default:
				break;
		}
		return aRet;
	}
};

/** ExpressionNode implementation for unary
    function over two ExpressionNodes
    */
class BinaryFunctionExpression : public ExpressionNode
{
    const ExpressionFunct	meFunct;
    ExpressionNodeSharedPtr	mpFirstArg;
    ExpressionNodeSharedPtr	mpSecondArg;

public:

    BinaryFunctionExpression( const ExpressionFunct eFunct, const ExpressionNodeSharedPtr& rFirstArg, const ExpressionNodeSharedPtr& rSecondArg ) :
        meFunct( eFunct ),
        mpFirstArg( rFirstArg ),
        mpSecondArg( rSecondArg )
    {
    }
	static double getValue( const ExpressionFunct eFunct, const ExpressionNodeSharedPtr& rFirstArg, const ExpressionNodeSharedPtr& rSecondArg )
	{
		double fRet = 0;
		switch( eFunct )
		{
			case BINARY_FUNC_PLUS : fRet = (*rFirstArg)() + (*rSecondArg)(); break;
			case BINARY_FUNC_MINUS: fRet = (*rFirstArg)() - (*rSecondArg)(); break;
			case BINARY_FUNC_MUL :  fRet = (*rFirstArg)() * (*rSecondArg)(); break;
			case BINARY_FUNC_DIV :  fRet = (*rFirstArg)() / (*rSecondArg)(); break;
			case BINARY_FUNC_MIN :  fRet = ::std::min( (*rFirstArg)(), (*rSecondArg)() ); break;
			case BINARY_FUNC_MAX :  fRet = ::std::max( (*rFirstArg)(), (*rSecondArg)() ); break;
			case BINARY_FUNC_ATAN2: fRet = atan2( (*rFirstArg)(), (*rSecondArg)() ); break;
			default:
				break;
		}
		return fRet;
	}
    virtual double operator()() const
    {
		return getValue( meFunct, mpFirstArg, mpSecondArg );
    }
    virtual bool isConstant() const
    {
		return mpFirstArg->isConstant() && mpSecondArg->isConstant();
    }
	virtual ExpressionFunct getType() const
	{
		return meFunct;
	}
	virtual EnhancedCustomShapeParameter fillNode( std::vector< EnhancedCustomShapeEquation >& rEquations, ExpressionNode* /*pOptionalArg*/, sal_uInt32 nFlags )
	{
		EnhancedCustomShapeParameter aRet;
		switch( meFunct )
		{
			case BINARY_FUNC_PLUS :
			{
				if ( nFlags & EXPRESSION_FLAG_SUMANGLE_MODE )
				{
					if ( mpFirstArg->getType() == ENUM_FUNC_ADJUSTMENT )
					{
						EnhancedCustomShapeEquation	aEquation;
						aEquation.nOperation |= 0xe;	// sumangle
						FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
						FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags ), 1, aEquation );
						aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
						aRet.Value <<= (sal_Int32)rEquations.size();
						rEquations.push_back( aEquation );
					}
					else if ( mpSecondArg->getType() == ENUM_FUNC_ADJUSTMENT )
					{
						EnhancedCustomShapeEquation	aEquation;
						aEquation.nOperation |= 0xe;	// sumangle
						FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
						FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags ), 1, aEquation );
						aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
						aRet.Value <<= (sal_Int32)rEquations.size();
						rEquations.push_back( aEquation );
					}
					else
					{
						EnhancedCustomShapeEquation	aSumangle1;
						aSumangle1.nOperation |= 0xe;	// sumangle
						FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags &~EXPRESSION_FLAG_SUMANGLE_MODE ), 1, aSumangle1 );
						aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
						aRet.Value <<= (sal_Int32)rEquations.size();
						rEquations.push_back( aSumangle1 );

						EnhancedCustomShapeEquation	aSumangle2;
						aSumangle2.nOperation |= 0xe;	// sumangle
						FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags &~EXPRESSION_FLAG_SUMANGLE_MODE ), 1, aSumangle2 );
						aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
						aRet.Value <<= (sal_Int32)rEquations.size();
						rEquations.push_back( aSumangle2 );

						EnhancedCustomShapeEquation	aEquation;
						aEquation.nOperation |= 0;
						aEquation.nPara[ 0 ] = ( rEquations.size() - 2 ) | 0x400;
						aEquation.nPara[ 1 ] = ( rEquations.size() - 1 ) | 0x400;
						aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
						aRet.Value <<= (sal_Int32)rEquations.size();
						rEquations.push_back( aEquation );
					}
				}
				else
				{
					sal_Bool bFirstIsEmpty = mpFirstArg->isConstant() && ( (*mpFirstArg)() == 0 );
					sal_Bool bSecondIsEmpty = mpSecondArg->isConstant() && ( (*mpSecondArg)() == 0 );

					if ( bFirstIsEmpty )
						aRet = mpSecondArg->fillNode( rEquations, NULL, nFlags );
					else if ( bSecondIsEmpty )
						aRet = mpFirstArg->fillNode( rEquations, NULL, nFlags );
					else
					{
						EnhancedCustomShapeEquation	aEquation;
						aEquation.nOperation |= 0;
						FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
						FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags ), 1, aEquation );
						aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
						aRet.Value <<= (sal_Int32)rEquations.size();
						rEquations.push_back( aEquation );
					}
				}
			}
			break;
			case BINARY_FUNC_MINUS:
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 0;
				FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags ), 2, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			case BINARY_FUNC_MUL :
			{
				// in the dest. format the cos function is using integer as result :-(
				// so we can't use the generic algorithm
				if ( ( mpFirstArg->getType() == UNARY_FUNC_SIN ) || ( mpFirstArg->getType() == UNARY_FUNC_COS ) || ( mpFirstArg->getType() == UNARY_FUNC_TAN ) )
					aRet = mpFirstArg->fillNode( rEquations, mpSecondArg.get(), nFlags );
				else if ( ( mpSecondArg->getType() == UNARY_FUNC_SIN ) || ( mpSecondArg->getType() == UNARY_FUNC_COS ) || ( mpSecondArg->getType() == UNARY_FUNC_TAN ) )
					aRet = mpSecondArg->fillNode( rEquations, mpFirstArg.get(), nFlags );
				else
				{
					if ( mpFirstArg->isConstant() && (*mpFirstArg)() == 1 )
						aRet = mpSecondArg->fillNode( rEquations, NULL, nFlags );
					else if ( mpSecondArg->isConstant() && (*mpSecondArg)() == 1 )
						aRet = mpFirstArg->fillNode( rEquations, NULL, nFlags );
					else if ( ( mpFirstArg->getType() == BINARY_FUNC_DIV )		// don't care of (pi/180)
						&& ( ((BinaryFunctionExpression*)((BinaryFunctionExpression*)mpFirstArg.get())->mpFirstArg.get())->getType() == ENUM_FUNC_PI )
						&& ( ((BinaryFunctionExpression*)((BinaryFunctionExpression*)mpFirstArg.get())->mpSecondArg.get())->getType() == FUNC_CONST ) )
					{
						aRet = mpSecondArg->fillNode( rEquations, NULL, nFlags );
					}
					else if ( ( mpSecondArg->getType() == BINARY_FUNC_DIV )		// don't care of (pi/180)
						&& ( ((BinaryFunctionExpression*)((BinaryFunctionExpression*)mpSecondArg.get())->mpFirstArg.get())->getType() == ENUM_FUNC_PI )
						&& ( ((BinaryFunctionExpression*)((BinaryFunctionExpression*)mpSecondArg.get())->mpSecondArg.get())->getType() == FUNC_CONST ) )
					{
						aRet = mpFirstArg->fillNode( rEquations, NULL, nFlags );
					}
					else
					{
						EnhancedCustomShapeEquation	aEquation;
						aEquation.nOperation |= 1;
						FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
						FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags ), 1, aEquation );
						aEquation.nPara[ 2 ] = 1;
						aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
						aRet.Value <<= (sal_Int32)rEquations.size();
						rEquations.push_back( aEquation );
					}
				}
			}
			break;
			case BINARY_FUNC_DIV :
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 1;
				FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				aEquation.nPara[ 1 ] = 1;
				FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags ), 2, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			case BINARY_FUNC_MIN :
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 4;
				FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags ), 1, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			case BINARY_FUNC_MAX :
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 5;
				FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags ), 1, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			case BINARY_FUNC_ATAN2:
			{
				EnhancedCustomShapeEquation	aEquation;
				aEquation.nOperation |= 8;
				FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
				FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags ), 1, aEquation );
				aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
				aRet.Value <<= (sal_Int32)rEquations.size();
				rEquations.push_back( aEquation );
			}
			break;
			default:
				break;
		}
		return aRet;
	}
};

class IfExpression : public ExpressionNode
{
    ExpressionNodeSharedPtr	mpFirstArg;
    ExpressionNodeSharedPtr mpSecondArg;
    ExpressionNodeSharedPtr mpThirdArg;

public:

	IfExpression( const ExpressionNodeSharedPtr& rFirstArg,
				  const ExpressionNodeSharedPtr& rSecondArg,
				  const ExpressionNodeSharedPtr& rThirdArg ) :
        mpFirstArg(  rFirstArg ),
        mpSecondArg( rSecondArg ),
		mpThirdArg(  rThirdArg )
    {
    }
    virtual bool isConstant() const
    {
        return
            mpFirstArg->isConstant() &&
            mpSecondArg->isConstant() &&
			mpThirdArg->isConstant();
    }
    virtual double operator()() const
    {
		return (*mpFirstArg)() > 0 ? (*mpSecondArg)() : (*mpThirdArg)();
    }
	virtual ExpressionFunct getType() const
	{
		return TERNARY_FUNC_IF;
	}
	virtual EnhancedCustomShapeParameter fillNode( std::vector< EnhancedCustomShapeEquation >& rEquations, ExpressionNode* /*pOptionalArg*/, sal_uInt32 nFlags )
	{
		EnhancedCustomShapeParameter aRet;
		aRet.Type = EnhancedCustomShapeParameterType::EQUATION;
		aRet.Value <<= (sal_Int32)rEquations.size();
		{
			EnhancedCustomShapeEquation	aEquation;
			aEquation.nOperation |= 6;
			FillEquationParameter( mpFirstArg->fillNode( rEquations, NULL, nFlags ), 0, aEquation );
			FillEquationParameter( mpSecondArg->fillNode( rEquations, NULL, nFlags  ), 1, aEquation );
			FillEquationParameter( mpThirdArg->fillNode( rEquations, NULL, nFlags ), 2, aEquation );
			rEquations.push_back( aEquation );
		}
		return aRet;
	}
};

////////////////////////
////////////////////////
// FUNCTION PARSER
////////////////////////
////////////////////////

typedef const sal_Char* StringIteratorT;

struct ParserContext
{
    typedef ::std::stack< ExpressionNodeSharedPtr > OperandStack;

    // stores a stack of not-yet-evaluated operands. This is used
    // by the operators (i.e. '+', '*', 'sin' etc.) to pop their
    // arguments from. If all arguments to an operator are constant,
    // the operator pushes a precalculated result on the stack, and
    // a composite ExpressionNode otherwise.
    OperandStack				maOperandStack;

	const EnhancedCustomShape2d* mpCustoShape;

};

typedef ::boost::shared_ptr< ParserContext > ParserContextSharedPtr;

/** Generate apriori constant value
    */

class ConstantFunctor
{
    const double					mnValue;
    ParserContextSharedPtr			mpContext;

public:

	ConstantFunctor( double rValue, const ParserContextSharedPtr& rContext ) :
        mnValue( rValue ),
        mpContext( rContext )
	{
	}
    void operator()( StringIteratorT /*rFirst*/, StringIteratorT /*rSecond*/ ) const
    {
        mpContext->maOperandStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( mnValue ) ) );
    }
};

/** Generate parse-dependent-but-then-constant value
    */
class DoubleConstantFunctor
{
    ParserContextSharedPtr	mpContext;

public:
    DoubleConstantFunctor( const ParserContextSharedPtr& rContext ) :
        mpContext( rContext )
    {
    }
    void operator()( double n ) const
    {
        mpContext->maOperandStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( n ) ) );
	}
};

class EnumFunctor
{
	const ExpressionFunct			meFunct;
    double							mnValue;
    ParserContextSharedPtr			mpContext;

public:

	EnumFunctor( const ExpressionFunct eFunct, const ParserContextSharedPtr& rContext )
	: meFunct( eFunct )
	, mnValue( 0 )
	, mpContext( rContext )
	{
	}
    void operator()( StringIteratorT rFirst, StringIteratorT rSecond ) const
    {
		/*double nVal = mnValue;*/
		switch( meFunct )
		{
			case ENUM_FUNC_ADJUSTMENT :
			{
				rtl::OUString aVal( rFirst + 1, rSecond - rFirst, RTL_TEXTENCODING_UTF8 );
				mpContext->maOperandStack.push( ExpressionNodeSharedPtr( new AdjustmentExpression( *mpContext->mpCustoShape, aVal.toInt32() ) ) );
			}
			break;
			case ENUM_FUNC_EQUATION :
				{
				rtl::OUString aVal( rFirst + 1, rSecond - rFirst, RTL_TEXTENCODING_UTF8 );
				mpContext->maOperandStack.push( ExpressionNodeSharedPtr( new EquationExpression( *mpContext->mpCustoShape, aVal.toInt32() ) ) );
			}
			break;
			default:
				mpContext->maOperandStack.push( ExpressionNodeSharedPtr( new EnumValueExpression( *mpContext->mpCustoShape, meFunct ) ) );
		}
    }
};

class UnaryFunctionFunctor
{
    const ExpressionFunct	meFunct;
    ParserContextSharedPtr	mpContext;

public :

	UnaryFunctionFunctor( const ExpressionFunct eFunct, const ParserContextSharedPtr& rContext ) :
		meFunct( eFunct ),
		mpContext( rContext )
	{
	}
	void operator()( StringIteratorT, StringIteratorT ) const
	{
		ParserContext::OperandStack& rNodeStack( mpContext->maOperandStack );

		if( rNodeStack.size() < 1 )
			throw ParseError( "Not enough arguments for unary operator" );

		// retrieve arguments
		ExpressionNodeSharedPtr pArg( rNodeStack.top() );
		rNodeStack.pop();

		if( pArg->isConstant() )	// check for constness
			rNodeStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( UnaryFunctionExpression::getValue( meFunct, pArg ) ) ) );
		else						// push complex node, that calcs the value on demand
			rNodeStack.push( ExpressionNodeSharedPtr( new UnaryFunctionExpression( meFunct, pArg ) ) );
	}
};

/** Implements a binary function over two ExpressionNodes

    @tpl Generator
    Generator functor, to generate an ExpressionNode of
    appropriate type

    */
class BinaryFunctionFunctor
{
    const ExpressionFunct	meFunct;
    ParserContextSharedPtr	mpContext;

public:

	BinaryFunctionFunctor( const ExpressionFunct eFunct, const ParserContextSharedPtr& rContext ) :
        meFunct( eFunct ),
        mpContext( rContext )
    {
    }

    void operator()( StringIteratorT, StringIteratorT ) const
    {
        ParserContext::OperandStack& rNodeStack( mpContext->maOperandStack );

		if( rNodeStack.size() < 2 )
			throw ParseError( "Not enough arguments for binary operator" );

        // retrieve arguments
        ExpressionNodeSharedPtr pSecondArg( rNodeStack.top() );
        rNodeStack.pop();
        ExpressionNodeSharedPtr pFirstArg( rNodeStack.top() );
        rNodeStack.pop();

        // create combined ExpressionNode
		ExpressionNodeSharedPtr pNode = ExpressionNodeSharedPtr( new BinaryFunctionExpression( meFunct, pFirstArg, pSecondArg ) );
        // check for constness
        if( pFirstArg->isConstant() && pSecondArg->isConstant() )	// call the operator() at pNode, store result in constant value ExpressionNode.
            rNodeStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( (*pNode)() ) ) );
        else														// push complex node, that calcs the value on demand
            rNodeStack.push( pNode );
    }
};

class IfFunctor
{
    ParserContextSharedPtr	mpContext;

public :

	IfFunctor( const ParserContextSharedPtr& rContext ) :
        mpContext( rContext )
    {
    }
    void operator()( StringIteratorT, StringIteratorT ) const
    {
        ParserContext::OperandStack& rNodeStack( mpContext->maOperandStack );

		if( rNodeStack.size() < 3 )
			throw ParseError( "Not enough arguments for ternary operator" );

        // retrieve arguments
        ExpressionNodeSharedPtr pThirdArg( rNodeStack.top() );
        rNodeStack.pop();
        ExpressionNodeSharedPtr pSecondArg( rNodeStack.top() );
        rNodeStack.pop();
        ExpressionNodeSharedPtr pFirstArg( rNodeStack.top() );
        rNodeStack.pop();

        // create combined ExpressionNode
        ExpressionNodeSharedPtr pNode( new IfExpression( pFirstArg, pSecondArg, pThirdArg ) );
        // check for constness
        if( pFirstArg->isConstant() && pSecondArg->isConstant() && pThirdArg->isConstant() )
            rNodeStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( (*pNode)() ) ) );	// call the operator() at pNode, store result in constant value ExpressionNode.
        else
            rNodeStack.push( pNode );										// push complex node, that calcs the value on demand
    }
};

// Workaround for MSVC compiler anomaly (stack trashing)
//
// The default ureal_parser_policies implementation of parse_exp
// triggers a really weird error in MSVC7 (Version 13.00.9466), in
// that the real_parser_impl::parse_main() call of parse_exp()
// overwrites the frame pointer _on the stack_ (EBP of the calling
// function gets overwritten while lying on the stack).
//
// For the time being, our parser thus can only read the 1.0E10
// notation, not the 1.0e10 one.
//
// TODO(F1): Also handle the 1.0e10 case here.
template< typename T > struct custom_real_parser_policies : public ::boost::spirit::ureal_parser_policies<T>
{
    template< typename ScannerT >
	    static typename ::boost::spirit::parser_result< ::boost::spirit::chlit<>, ScannerT >::type
    parse_exp(ScannerT& scan)
    {
        // as_lower_d somehow breaks MSVC7
        return ::boost::spirit::ch_p('E').parse(scan);
    }
};

/* This class implements the following grammar (more or
    less literally written down below, only slightly
    obfuscated by the parser actions):

    identifier = '$'|'pi'|'e'|'X'|'Y'|'Width'|'Height'

    function = 'abs'|'sqrt'|'sin'|'cos'|'tan'|'atan'|'acos'|'asin'|'exp'|'log'

    basic_expression =
               		number |
               		identifier |
               		function '(' additive_expression ')' |
               		'(' additive_expression ')'

    unary_expression =
               		'-' basic_expression |
                    basic_expression

    multiplicative_expression =
               		unary_expression ( ( '*' unary_expression )* |
                                		( '/' unary_expression )* )

    additive_expression =
               		multiplicative_expression ( ( '+' multiplicative_expression )* |
               									( '-' multiplicative_expression )* )

    */

class ExpressionGrammar : public ::boost::spirit::grammar< ExpressionGrammar >
{
public:
    /** Create an arithmetic expression grammar

        @param rParserContext
        Contains context info for the parser
        */
    ExpressionGrammar( const ParserContextSharedPtr& rParserContext ) :
        mpParserContext( rParserContext )
    {
    }

    template< typename ScannerT > class definition
    {
    public:
        // grammar definition
        definition( const ExpressionGrammar& self )
        {
            using ::boost::spirit::str_p;
            using ::boost::spirit::range_p;
            using ::boost::spirit::lexeme_d;
            using ::boost::spirit::real_parser;
            using ::boost::spirit::chseq_p;

            identifier =
							str_p( "pi"			)[ EnumFunctor(ENUM_FUNC_PI,		self.getContext() ) ]
					|		str_p( "left"		)[ EnumFunctor(ENUM_FUNC_LEFT,		self.getContext() ) ]
                    |		str_p( "top"		)[ EnumFunctor(ENUM_FUNC_TOP,		self.getContext() ) ]
                    |		str_p( "right"		)[ EnumFunctor(ENUM_FUNC_RIGHT,		self.getContext() ) ]
                    |		str_p( "bottom"		)[ EnumFunctor(ENUM_FUNC_BOTTOM,	self.getContext() ) ]
                    |		str_p( "xstretch"	)[ EnumFunctor(ENUM_FUNC_XSTRETCH,	self.getContext() ) ]
                    |		str_p( "ystretch"	)[ EnumFunctor(ENUM_FUNC_YSTRETCH,	self.getContext() ) ]
                    |		str_p( "hasstroke"	)[ EnumFunctor(ENUM_FUNC_HASSTROKE,	self.getContext() ) ]
                    |		str_p( "hasfill"	)[ EnumFunctor(ENUM_FUNC_HASFILL,	self.getContext() ) ]
                    |		str_p( "width"		)[ EnumFunctor(ENUM_FUNC_WIDTH,		self.getContext() ) ]
                    |		str_p( "height"		)[ EnumFunctor(ENUM_FUNC_HEIGHT,	self.getContext() ) ]
                    |		str_p( "logwidth"	)[ EnumFunctor(ENUM_FUNC_LOGWIDTH,	self.getContext() ) ]
                    |		str_p( "logheight"	)[ EnumFunctor(ENUM_FUNC_LOGHEIGHT,	self.getContext() ) ]
                    ;

            unaryFunction =
                    (str_p( "abs"  ) >> '(' >> additiveExpression >> ')' )[ UnaryFunctionFunctor( UNARY_FUNC_ABS,  self.getContext()) ]
                |	(str_p( "sqrt" ) >> '(' >> additiveExpression >> ')' )[ UnaryFunctionFunctor( UNARY_FUNC_SQRT, self.getContext()) ]
                |	(str_p( "sin"  ) >> '(' >> additiveExpression >> ')' )[ UnaryFunctionFunctor( UNARY_FUNC_SIN,  self.getContext()) ]
                |	(str_p( "cos"  ) >> '(' >> additiveExpression >> ')' )[ UnaryFunctionFunctor( UNARY_FUNC_COS,  self.getContext()) ]
                |	(str_p( "tan"  ) >> '(' >> additiveExpression >> ')' )[ UnaryFunctionFunctor( UNARY_FUNC_TAN,  self.getContext()) ]
                |	(str_p( "atan" ) >> '(' >> additiveExpression >> ')' )[ UnaryFunctionFunctor( UNARY_FUNC_ATAN, self.getContext()) ]
                ;

            binaryFunction =
	                (str_p( "min"  ) >> '(' >> additiveExpression >> ',' >> additiveExpression >> ')' )[ BinaryFunctionFunctor( BINARY_FUNC_MIN,  self.getContext()) ]
                |	(str_p( "max"  ) >> '(' >> additiveExpression >> ',' >> additiveExpression >> ')' )[ BinaryFunctionFunctor( BINARY_FUNC_MAX,  self.getContext()) ]
                |	(str_p( "atan2") >> '(' >> additiveExpression >> ',' >> additiveExpression >> ')' )[ BinaryFunctionFunctor( BINARY_FUNC_ATAN2,self.getContext()) ]
                ;

            ternaryFunction =
	                (str_p( "if"  ) >> '(' >> additiveExpression >> ',' >> additiveExpression >> ',' >> additiveExpression >> ')' )[ IfFunctor( self.getContext() ) ]
                ;

			funcRef_decl =
				lexeme_d[ +( range_p('a','z') | range_p('A','Z') | range_p('0','9') ) ];

			functionReference =
				(str_p( "?" ) >> funcRef_decl )[ EnumFunctor( ENUM_FUNC_EQUATION, self.getContext() ) ];

			modRef_decl =
				lexeme_d[ +( range_p('0','9') ) ];

			modifierReference =
				(str_p( "$" ) >> modRef_decl )[ EnumFunctor( ENUM_FUNC_ADJUSTMENT, self.getContext() ) ];

			basicExpression =
                    real_parser<double, custom_real_parser_policies<double> >()[ DoubleConstantFunctor(self.getContext()) ]
                |	identifier
				|	functionReference
				|	modifierReference
                |	unaryFunction
                |	binaryFunction
				|	ternaryFunction
                |	'(' >> additiveExpression >> ')'
                ;

			unaryExpression =
                    ('-' >> basicExpression)[ UnaryFunctionFunctor( UNARY_FUNC_NEG, self.getContext()) ]
                |	basicExpression
                ;

            multiplicativeExpression =
                    unaryExpression
                >> *( ('*' >> unaryExpression)[ BinaryFunctionFunctor( BINARY_FUNC_MUL, self.getContext()) ]
                    | ('/' >> unaryExpression)[ BinaryFunctionFunctor( BINARY_FUNC_DIV, self.getContext()) ]
                    )
                ;

            additiveExpression =
                    multiplicativeExpression
                >> *( ('+' >> multiplicativeExpression)[ BinaryFunctionFunctor( BINARY_FUNC_PLUS,  self.getContext()) ]
                    | ('-' >> multiplicativeExpression)[ BinaryFunctionFunctor( BINARY_FUNC_MINUS, self.getContext()) ]
                    )
                ;

            BOOST_SPIRIT_DEBUG_RULE(additiveExpression);
            BOOST_SPIRIT_DEBUG_RULE(multiplicativeExpression);
	        BOOST_SPIRIT_DEBUG_RULE(unaryExpression);
            BOOST_SPIRIT_DEBUG_RULE(basicExpression);
            BOOST_SPIRIT_DEBUG_RULE(unaryFunction);
            BOOST_SPIRIT_DEBUG_RULE(binaryFunction);
            BOOST_SPIRIT_DEBUG_RULE(ternaryFunction);
            BOOST_SPIRIT_DEBUG_RULE(identifier);
        }

        const ::boost::spirit::rule< ScannerT >& start() const
        {
            return additiveExpression;
        }

    private:
        // the constituents of the Spirit arithmetic expression grammar.
        // For the sake of readability, without 'ma' prefix.
        ::boost::spirit::rule< ScannerT >	additiveExpression;
		::boost::spirit::rule< ScannerT >	multiplicativeExpression;
		::boost::spirit::rule< ScannerT >	unaryExpression;
		::boost::spirit::rule< ScannerT >	basicExpression;
		::boost::spirit::rule< ScannerT >	unaryFunction;
		::boost::spirit::rule< ScannerT >	binaryFunction;
		::boost::spirit::rule< ScannerT >	ternaryFunction;
		::boost::spirit::rule< ScannerT >	funcRef_decl;
		::boost::spirit::rule< ScannerT >	functionReference;
		::boost::spirit::rule< ScannerT >	modRef_decl;
		::boost::spirit::rule< ScannerT >	modifierReference;
		::boost::spirit::rule< ScannerT >	identifier;
    };

    const ParserContextSharedPtr& getContext() const
    {
        return mpParserContext;
    }

private:
    ParserContextSharedPtr			mpParserContext; // might get modified during parsing
};

#ifdef BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE
const ParserContextSharedPtr& getParserContext()
{
    static ParserContextSharedPtr lcl_parserContext( new ParserContext() );

    // clear node stack (since we reuse the static object, that's
    // the whole point here)
    while( !lcl_parserContext->maOperandStack.empty() )
        lcl_parserContext->maOperandStack.pop();

    return lcl_parserContext;
}
#endif

}

namespace EnhancedCustomShape  {


ExpressionNodeSharedPtr FunctionParser::parseFunction( const ::rtl::OUString& rFunction, const EnhancedCustomShape2d& rCustoShape )
{
    // TODO(Q1): Check if a combination of the RTL_UNICODETOTEXT_FLAGS_*
    // gives better conversion robustness here (we might want to map space
    // etc. to ASCII space here)
    const ::rtl::OString& rAsciiFunction(
        rtl::OUStringToOString( rFunction, RTL_TEXTENCODING_ASCII_US ) );

    StringIteratorT aStart( rAsciiFunction.getStr() );
    StringIteratorT aEnd( rAsciiFunction.getStr()+rAsciiFunction.getLength() );

    ParserContextSharedPtr pContext;

#ifdef BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE
    // static parser context, because the actual
    // Spirit parser is also a static object
    pContext = getParserContext();
#else
    pContext.reset( new ParserContext() );
#endif
	pContext->mpCustoShape = &rCustoShape;

    ExpressionGrammar aExpressionGrammer( pContext );
    const ::boost::spirit::parse_info<StringIteratorT> aParseInfo(
            ::boost::spirit::parse( aStart,
                                    aEnd,
                                    aExpressionGrammer >> ::boost::spirit::end_p,
                                    ::boost::spirit::space_p ) );
    OSL_DEBUG_ONLY(::std::cout.flush()); // needed to keep stdout and cout in sync


    // input fully congested by the parser?
	if( !aParseInfo.full )
		throw ParseError( "EnhancedCustomShapeFunctionParser::parseFunction(): string not fully parseable" );

    // parser's state stack now must contain exactly _one_ ExpressionNode,
    // which represents our formula.
	if( pContext->maOperandStack.size() != 1 )
		throw ParseError( "EnhancedCustomShapeFunctionParser::parseFunction(): incomplete or empty expression" );


    return pContext->maOperandStack.top();
}


}