| /************************************************************** | |
| * | |
| * 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_slideshow.hxx" | |
| // must be first | |
| #include <canvas/debug.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include <rtl/math.hxx> | |
| #include <smilfunctionparser.hxx> | |
| #include <expressionnodefactory.hxx> | |
| #include <rtl/ustring.hxx> | |
| #include <canvas/verbosetrace.hxx> | |
| #include <basegfx/matrix/b2dhommatrix.hxx> | |
| #include <basegfx/point/b2dpoint.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> | |
| /* Implementation of SmilFunctionParser class */ | |
| namespace slideshow | |
| { | |
| namespace internal | |
| { | |
| namespace | |
| { | |
| 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; | |
| // bounds of the shape this expression is associated with | |
| ::basegfx::B2DRectangle maShapeBounds; | |
| // when true, enable usage of time-dependent variable '$' | |
| // in expressions | |
| bool mbParseAnimationFunction; | |
| }; | |
| typedef ::boost::shared_ptr< ParserContext > ParserContextSharedPtr; | |
| template< typename Generator > class ShapeBoundsFunctor | |
| { | |
| public: | |
| ShapeBoundsFunctor( Generator aGenerator, | |
| const ParserContextSharedPtr& rContext ) : | |
| maGenerator( aGenerator ), | |
| mpContext( rContext ) | |
| { | |
| ENSURE_OR_THROW( mpContext, | |
| "ShapeBoundsFunctor::ShapeBoundsFunctor(): Invalid context" ); | |
| } | |
| void operator()( StringIteratorT, StringIteratorT ) const | |
| { | |
| mpContext->maOperandStack.push( | |
| ExpressionNodeFactory::createConstantValueExpression( | |
| maGenerator( mpContext->maShapeBounds ) ) ); | |
| } | |
| private: | |
| Generator maGenerator; | |
| ParserContextSharedPtr mpContext; | |
| }; | |
| template< typename Generator > ShapeBoundsFunctor< Generator > | |
| makeShapeBoundsFunctor( const Generator& rGenerator, | |
| const ParserContextSharedPtr& rContext ) | |
| { | |
| return ShapeBoundsFunctor<Generator>(rGenerator, rContext); | |
| } | |
| /** Generate apriori constant value | |
| */ | |
| class ConstantFunctor | |
| { | |
| public: | |
| ConstantFunctor( double rValue, | |
| const ParserContextSharedPtr& rContext ) : | |
| mnValue( rValue ), | |
| mpContext( rContext ) | |
| { | |
| ENSURE_OR_THROW( mpContext, | |
| "ConstantFunctor::ConstantFunctor(): Invalid context" ); | |
| } | |
| void operator()( StringIteratorT, StringIteratorT ) const | |
| { | |
| mpContext->maOperandStack.push( | |
| ExpressionNodeFactory::createConstantValueExpression( mnValue ) ); | |
| } | |
| private: | |
| const double mnValue; | |
| ParserContextSharedPtr mpContext; | |
| }; | |
| /** Generate parse-dependent-but-then-constant value | |
| */ | |
| class DoubleConstantFunctor | |
| { | |
| public: | |
| DoubleConstantFunctor( const ParserContextSharedPtr& rContext ) : | |
| mpContext( rContext ) | |
| { | |
| ENSURE_OR_THROW( mpContext, | |
| "DoubleConstantFunctor::DoubleConstantFunctor(): Invalid context" ); | |
| } | |
| void operator()( double n ) const | |
| { | |
| // push constant value expression to the stack | |
| mpContext->maOperandStack.push( | |
| ExpressionNodeFactory::createConstantValueExpression( n ) ); | |
| } | |
| private: | |
| ParserContextSharedPtr mpContext; | |
| }; | |
| /** Generate special t value expression node | |
| */ | |
| class ValueTFunctor | |
| { | |
| public: | |
| ValueTFunctor( const ParserContextSharedPtr& rContext ) : | |
| mpContext( rContext ) | |
| { | |
| ENSURE_OR_THROW( mpContext, | |
| "ValueTFunctor::ValueTFunctor(): Invalid context" ); | |
| } | |
| void operator()( StringIteratorT, StringIteratorT ) const | |
| { | |
| if( !mpContext->mbParseAnimationFunction ) | |
| { | |
| OSL_ENSURE( false, | |
| "ValueTFunctor::operator(): variable encountered, but we're not parsing a function here" ); | |
| throw ParseError(); | |
| } | |
| // push special t value expression to the stack | |
| mpContext->maOperandStack.push( | |
| ExpressionNodeFactory::createValueTExpression() ); | |
| } | |
| private: | |
| ParserContextSharedPtr mpContext; | |
| }; | |
| template< typename Functor > class UnaryFunctionFunctor | |
| { | |
| private: | |
| /** ExpressionNode implementation for unary | |
| function over one ExpressionNode | |
| */ | |
| class UnaryFunctionExpression : public ExpressionNode | |
| { | |
| public: | |
| UnaryFunctionExpression( const Functor& rFunctor, | |
| const ExpressionNodeSharedPtr& rArg ) : | |
| maFunctor( rFunctor ), | |
| mpArg( rArg ) | |
| { | |
| } | |
| virtual double operator()( double t ) const | |
| { | |
| return maFunctor( (*mpArg)(t) ); | |
| } | |
| virtual bool isConstant() const | |
| { | |
| return mpArg->isConstant(); | |
| } | |
| private: | |
| Functor maFunctor; | |
| ExpressionNodeSharedPtr mpArg; | |
| }; | |
| public: | |
| UnaryFunctionFunctor( const Functor& rFunctor, | |
| const ParserContextSharedPtr& rContext ) : | |
| maFunctor( rFunctor ), | |
| mpContext( rContext ) | |
| { | |
| ENSURE_OR_THROW( mpContext, | |
| "UnaryFunctionFunctor::UnaryFunctionFunctor(): Invalid context" ); | |
| } | |
| 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(); | |
| // check for constness | |
| if( pArg->isConstant() ) | |
| { | |
| rNodeStack.push( | |
| ExpressionNodeFactory::createConstantValueExpression( | |
| maFunctor( (*pArg)(0.0) ) ) ); | |
| } | |
| else | |
| { | |
| // push complex node, that calcs the value on demand | |
| rNodeStack.push( | |
| ExpressionNodeSharedPtr( | |
| new UnaryFunctionExpression( | |
| maFunctor, | |
| pArg ) ) ); | |
| } | |
| } | |
| private: | |
| Functor maFunctor; | |
| ParserContextSharedPtr mpContext; | |
| }; | |
| // TODO(Q2): Refactor makeUnaryFunctionFunctor, | |
| // makeBinaryFunctionFunctor and the whole | |
| // ExpressionNodeFactory, to use a generic | |
| // makeFunctionFunctor template, which is overloaded for | |
| // unary, binary, ternary, etc. function pointers. | |
| template< typename Functor > UnaryFunctionFunctor<Functor> | |
| makeUnaryFunctionFunctor( const Functor& rFunctor, | |
| const ParserContextSharedPtr& rContext ) | |
| { | |
| return UnaryFunctionFunctor<Functor>( rFunctor, rContext ); | |
| } | |
| // MSVC has problems instantiating above template function with plain function | |
| // pointers (doesn't like the const reference there). Thus, provide it with | |
| // a dedicated overload here. | |
| UnaryFunctionFunctor< double (*)(double) > | |
| makeUnaryFunctionFunctor( double (*pFunc)(double), | |
| const ParserContextSharedPtr& rContext ) | |
| { | |
| return UnaryFunctionFunctor< double (*)(double) >( pFunc, rContext ); | |
| } | |
| /** Implements a binary function over two ExpressionNodes | |
| @tpl Generator | |
| Generator functor, to generate an ExpressionNode of | |
| appropriate type | |
| */ | |
| template< class Generator > class BinaryFunctionFunctor | |
| { | |
| public: | |
| BinaryFunctionFunctor( const Generator& rGenerator, | |
| const ParserContextSharedPtr& rContext ) : | |
| maGenerator( rGenerator ), | |
| mpContext( rContext ) | |
| { | |
| ENSURE_OR_THROW( mpContext, | |
| "BinaryFunctionFunctor::BinaryFunctionFunctor(): Invalid context" ); | |
| } | |
| 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( maGenerator( pFirstArg, | |
| pSecondArg ) ); | |
| // check for constness | |
| if( pFirstArg->isConstant() && | |
| pSecondArg->isConstant() ) | |
| { | |
| // call the operator() at pNode, store result | |
| // in constant value ExpressionNode. | |
| rNodeStack.push( | |
| ExpressionNodeFactory::createConstantValueExpression( | |
| (*pNode)( 0.0 ) ) ); | |
| } | |
| else | |
| { | |
| // push complex node, that calcs the value on demand | |
| rNodeStack.push( pNode ); | |
| } | |
| } | |
| private: | |
| Generator maGenerator; | |
| ParserContextSharedPtr mpContext; | |
| }; | |
| template< typename Generator > BinaryFunctionFunctor<Generator> | |
| makeBinaryFunctionFunctor( const Generator& rGenerator, | |
| const ParserContextSharedPtr& rContext ) | |
| { | |
| return BinaryFunctionFunctor<Generator>( rGenerator, rContext ); | |
| } | |
| // 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::real_parser; | |
| identifier = | |
| str_p( "$" )[ ValueTFunctor( self.getContext()) ] | |
| | str_p( "pi" )[ ConstantFunctor(M_PI, self.getContext()) ] | |
| | str_p( "e" )[ ConstantFunctor(M_E, self.getContext()) ] | |
| | str_p( "x" )[ makeShapeBoundsFunctor(::std::mem_fun_ref(&::basegfx::B2DRange::getCenterX),self.getContext()) ] | |
| | str_p( "y" )[ makeShapeBoundsFunctor(::std::mem_fun_ref(&::basegfx::B2DRange::getCenterY),self.getContext()) ] | |
| | str_p( "width" )[ makeShapeBoundsFunctor(::std::mem_fun_ref(&::basegfx::B2DRange::getWidth), self.getContext()) ] | |
| | str_p( "height" )[ makeShapeBoundsFunctor(::std::mem_fun_ref(&::basegfx::B2DRange::getHeight), self.getContext()) ] | |
| ; | |
| unaryFunction = | |
| (str_p( "abs" ) >> '(' >> additiveExpression >> ')' )[ makeUnaryFunctionFunctor(&fabs, self.getContext()) ] | |
| | (str_p( "sqrt" ) >> '(' >> additiveExpression >> ')' )[ makeUnaryFunctionFunctor(&sqrt, self.getContext()) ] | |
| | (str_p( "sin" ) >> '(' >> additiveExpression >> ')' )[ makeUnaryFunctionFunctor(&sin, self.getContext()) ] | |
| | (str_p( "cos" ) >> '(' >> additiveExpression >> ')' )[ makeUnaryFunctionFunctor(&cos, self.getContext()) ] | |
| | (str_p( "tan" ) >> '(' >> additiveExpression >> ')' )[ makeUnaryFunctionFunctor(&tan, self.getContext()) ] | |
| | (str_p( "atan" ) >> '(' >> additiveExpression >> ')' )[ makeUnaryFunctionFunctor(&atan, self.getContext()) ] | |
| | (str_p( "acos" ) >> '(' >> additiveExpression >> ')' )[ makeUnaryFunctionFunctor(&acos, self.getContext()) ] | |
| | (str_p( "asin" ) >> '(' >> additiveExpression >> ')' )[ makeUnaryFunctionFunctor(&asin, self.getContext()) ] | |
| | (str_p( "exp" ) >> '(' >> additiveExpression >> ')' )[ makeUnaryFunctionFunctor(&exp, self.getContext()) ] | |
| | (str_p( "log" ) >> '(' >> additiveExpression >> ')' )[ makeUnaryFunctionFunctor(&log, self.getContext()) ] | |
| ; | |
| binaryFunction = | |
| (str_p( "min" ) >> '(' >> additiveExpression >> ',' >> additiveExpression >> ')' )[ makeBinaryFunctionFunctor(&ExpressionNodeFactory::createMinExpression, self.getContext()) ] | |
| | (str_p( "max" ) >> '(' >> additiveExpression >> ',' >> additiveExpression >> ')' )[ makeBinaryFunctionFunctor(&ExpressionNodeFactory::createMaxExpression, self.getContext()) ] | |
| ; | |
| basicExpression = | |
| real_parser<double, custom_real_parser_policies<double> >()[ DoubleConstantFunctor(self.getContext()) ] | |
| | identifier | |
| | unaryFunction | |
| | binaryFunction | |
| | '(' >> additiveExpression >> ')' | |
| ; | |
| unaryExpression = | |
| ('-' >> basicExpression)[ makeUnaryFunctionFunctor(::std::negate<double>(), self.getContext()) ] | |
| | basicExpression | |
| ; | |
| multiplicativeExpression = | |
| unaryExpression | |
| >> *( ('*' >> unaryExpression)[ makeBinaryFunctionFunctor(&ExpressionNodeFactory::createMultipliesExpression, self.getContext()) ] | |
| | ('/' >> unaryExpression)[ makeBinaryFunctionFunctor(&ExpressionNodeFactory::createDividesExpression, self.getContext()) ] | |
| ) | |
| ; | |
| additiveExpression = | |
| multiplicativeExpression | |
| >> *( ('+' >> multiplicativeExpression)[ makeBinaryFunctionFunctor(&ExpressionNodeFactory::createPlusExpression, self.getContext()) ] | |
| | ('-' >> multiplicativeExpression)[ makeBinaryFunctionFunctor(&ExpressionNodeFactory::createMinusExpression, 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(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 > 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 | |
| } | |
| ExpressionNodeSharedPtr SmilFunctionParser::parseSmilValue( const ::rtl::OUString& rSmilValue, | |
| const ::basegfx::B2DRectangle& rRelativeShapeBounds ) | |
| { | |
| // 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& rAsciiSmilValue( | |
| rtl::OUStringToOString( rSmilValue, RTL_TEXTENCODING_ASCII_US ) ); | |
| StringIteratorT aStart( rAsciiSmilValue.getStr() ); | |
| StringIteratorT aEnd( rAsciiSmilValue.getStr()+rAsciiSmilValue.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->maShapeBounds = rRelativeShapeBounds; | |
| pContext->mbParseAnimationFunction = false; // parse with '$' disabled | |
| ExpressionGrammar aExpressionGrammer( pContext ); | |
| const ::boost::spirit::parse_info<StringIteratorT> aParseInfo( | |
| ::boost::spirit::parse( aStart, | |
| aEnd, | |
| aExpressionGrammer, | |
| ::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( "SmilFunctionParser::parseSmilValue(): 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( "SmilFunctionParser::parseSmilValue(): incomplete or empty expression" ); | |
| return pContext->maOperandStack.top(); | |
| } | |
| ExpressionNodeSharedPtr SmilFunctionParser::parseSmilFunction( const ::rtl::OUString& rSmilFunction, | |
| const ::basegfx::B2DRectangle& rRelativeShapeBounds ) | |
| { | |
| // 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& rAsciiSmilFunction( | |
| rtl::OUStringToOString( rSmilFunction, RTL_TEXTENCODING_ASCII_US ) ); | |
| StringIteratorT aStart( rAsciiSmilFunction.getStr() ); | |
| StringIteratorT aEnd( rAsciiSmilFunction.getStr()+rAsciiSmilFunction.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->maShapeBounds = rRelativeShapeBounds; | |
| pContext->mbParseAnimationFunction = true; // parse with '$' enabled | |
| 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( "SmilFunctionParser::parseSmilFunction(): 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( "SmilFunctionParser::parseSmilFunction(): incomplete or empty expression" ); | |
| return pContext->maOperandStack.top(); | |
| } | |
| } | |
| } |