expression.h

/***************************************************************************
 *   Copyright (C) 2004-2006 by Radko Mihal                                *
 *   rmihal@pobox.sk                                                       *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
 ***************************************************************************/
#ifndef EXPRESSION_H
#define EXPRESSION_H

template< class Type >
class expression
{       
        enum priorities { plus_minus=0, multiply_divide = 1, fnc_value_parenthesis = 2 };
        
typedef std::string std_string; 
        class subexpression
        {
                class parentheses
                {
                        grammar_to_parser::pattern_parser                                       m_left;
                        grammar_to_parser::choice< expression<Type> >           m_e;
                        grammar_to_parser::pattern_parser                                       m_right;
                public:
                        parentheses() : 
                                m_left(std_string(1,'(') ), m_right(std_string(1,')') ) {};
                        void push_parsers( grammar_to_parser::parsers& l )
                        {
                                l.push_back( &m_left );
                                l.push_back( &m_e );
                                l.push_back( &m_right );
                        }
                        Type evaluate()
                        {
                                return m_e->evaluate();
                        }
                };

                grammar_to_parser::non_terminal<parentheses>    m_para;
                grammar_to_parser::choice< functions<Type> >    m_fnc;
                grammar_to_parser::choice< values<Type> >               m_val;
        public:
                void push_parsers( grammar_to_parser::parsers& l )
                {
                        l.push_back( &m_para );
                        l.push_back( &m_fnc );
                        l.push_back( &m_val );
                }
                int get_priority() { return fnc_value_parenthesis; }
                Type evaluate()
                {
                        if( m_para.is_parsed() ) return m_para->evaluate();
                        if( m_fnc.is_parsed() ) return m_fnc->evaluate();
                        if( m_val.is_parsed() ) return m_val->evaluate();
                        return 0;
                }
        };
        
        class add
        {
                grammar_to_parser::choice< subexpression >              m_subexpr;
                grammar_to_parser::pattern_parser                               m_plus;
                grammar_to_parser::choice< expression<Type> >   m_expr;
        public:
                add() : m_plus( std_string(1,'+') ) {}
                
                void push_parsers( grammar_to_parser::parsers& l )
                {
                        l.push_back( &m_subexpr );
                        l.push_back( &m_plus );
                        l.push_back( &m_expr );
                }

                Type evaluate()
                {
                        return m_subexpr->evaluate() + m_expr->evaluate();
                }
                
                // this method is called for example in this case: 5-4+3, at first 
                // must be evaluated 5-4 - which is the left_result, 
                // then the 4 is added
                Type evaluate( Type left_result )
                {
                        return left_result + m_expr->evaluate();
                }
                
                // this method is called for example in this case: 5-4+3, first must be 
                // evaluated 5-4 ... the 4 value for 'left' 
                // expression is obtained using get_left_value() call
                Type get_left_value()
                {
                        return m_subexpr->evaluate();
                }
                int get_priority() { return plus_minus; }
        };

        class substract
        {
                grammar_to_parser::choice< subexpression >              m_subexpr;
                grammar_to_parser::pattern_parser                               m_minus;
                grammar_to_parser::choice< expression<Type> >   m_expr;
        public:
                substract() : m_minus( std_string(1,'-') ) {};
                void push_parsers( grammar_to_parser::parsers& l )
                {
                        l.push_back( &m_subexpr );
                        l.push_back( &m_minus );
                        l.push_back( &m_expr );
                }

                Type evaluate()
                {
                        if( m_expr->get_priority() <= get_priority() )
                        {
                                // first the left value from expression must be 
                                // substracted from 5, then evaluate of the 
                                // expression with result
                                return m_expr->evaluate( 
                                                        m_subexpr->evaluate() - m_expr->get_left_value() );
                        }
                        else
                        {
                                return m_subexpr->evaluate() - m_expr->evaluate();
                        }
                }
                
                Type evaluate( Type left_result )
                {
                        // !!ERR!! - BEGIN (in 1.6)    5-4-3-2 returned wrong result (0)
                        if( m_expr->get_priority() <= get_priority() )
                        {
                                // first the left value from expression must be 
                                // substracted from 5, then evaluate of the 
                                // expression with result
                                return m_expr->evaluate( left_result - m_expr->get_left_value() );
                        }
                        else
                        {
                                return left_result - m_expr->evaluate();
                        }
                        //return left_result - m_expr->evaluate();
                        // !!ERR!! - end
                }
                
                Type get_left_value()
                {
                        return m_subexpr->evaluate();
                }
                
                int get_priority() { return plus_minus; }
        };
        
        class multiply
        {
                grammar_to_parser::choice< subexpression >              m_subexpr;
                grammar_to_parser::pattern_parser                               m_multiply;
                grammar_to_parser::choice< expression<Type> >   m_expr;
        public:
                multiply() : m_multiply(std_string(1,'*') ) {};
                void push_parsers( grammar_to_parser::parsers& l )
                {
                        l.push_back( &m_subexpr );
                        l.push_back( &m_multiply );
                        l.push_back( &m_expr );
                }

                Type evaluate()
                {
                        if( m_expr->get_priority() <= get_priority() )
                        {
                                return m_expr->evaluate( 
                                                        m_subexpr->evaluate() * m_expr->get_left_value() );
                        }
                        else
                        {
                                return m_subexpr->evaluate() * m_expr->evaluate();
                        }
                }
                
                Type evaluate( Type left_result )
                {
                        return left_result * m_expr->evaluate();
                }
                
                Type get_left_value()
                {
                        return m_subexpr->evaluate();
                }
                
                int get_priority() { return multiply_divide; }
        };
        
        class divide
        {
                grammar_to_parser::choice< subexpression >              m_subexpr;
                grammar_to_parser::pattern_parser                               m_div;
                grammar_to_parser::choice< expression<Type> >   m_expr;
        public:
                divide() : m_div( std_string(1,'/') ) {};
                void push_parsers( grammar_to_parser::parsers& l )
                {
                        l.push_back( &m_subexpr );
                        l.push_back( &m_div );
                        l.push_back( &m_expr );
                }

                Type evaluate()
                {
                        if( m_expr->get_priority() <= get_priority() )
                        {
                                return m_expr->evaluate( 
                                                        m_subexpr->evaluate() / m_expr->get_left_value() );
                        }
                        else
                        {
                                return m_subexpr->evaluate() / m_expr->evaluate();
                        }
                }
                
                Type evaluate( Type left_result )
                {
                        // !!ERR!! - BEGIN (in 1.6)
                        if( m_expr->get_priority() <= get_priority() )
                        {
                                return m_expr->evaluate( left_result / m_expr->get_left_value() );
                        }
                        else
                        {
                                return left_result / m_expr->evaluate();
                        }                       
                        // return left_result / m_expr->evaluate();
                        // !!ERR!! - END
                }
                
                Type get_left_value()
                {
                        return m_subexpr->evaluate();
                }
                
                int get_priority() { return multiply_divide; }
        };

protected:
        grammar_to_parser::non_terminal<add>                    m_add;
        grammar_to_parser::non_terminal<substract>              m_substract;
        grammar_to_parser::non_terminal<multiply>               m_multiply;
        grammar_to_parser::non_terminal<divide>                 m_divide;
        grammar_to_parser::choice<subexpression>                m_subexpr;
public:
        
        expression() {};
        ~expression() {};
                        
        void push_parsers( grammar_to_parser::parsers& l )
        {
                l.push_back( &m_add );
                l.push_back( &m_substract );
                l.push_back( &m_multiply );
                l.push_back( &m_divide );
                l.push_back( &m_subexpr );
        }

        Type evaluate()
        {
                if( m_subexpr.is_parsed() ) return m_subexpr->evaluate();
                if( m_divide.is_parsed() ) return m_divide->evaluate();
                if( m_multiply.is_parsed() ) return m_multiply->evaluate();
                if( m_add.is_parsed() ) return m_add->evaluate();
                if( m_substract.is_parsed() ) return m_substract->evaluate();
                return 0;
        }
        
        Type evaluate( Type left_result )
        {
                if( m_divide.is_parsed() ) return m_divide->evaluate(left_result);
                if( m_multiply.is_parsed() ) return m_multiply->evaluate(left_result);
                if( m_add.is_parsed() ) return m_add->evaluate(left_result);
                if( m_substract.is_parsed() ) return m_substract->evaluate(left_result);
        }
        
        Type get_left_value()
        {
                // this has only left value - thus call evaluate directly
                if( m_subexpr.is_parsed() ) return m_subexpr->evaluate();
                // following have alse left side = left value
                if( m_divide.is_parsed() ) return m_divide->get_left_value();
                if( m_multiply.is_parsed() ) return m_multiply->get_left_value();
                if( m_add.is_parsed() ) return m_add->get_left_value();
                if( m_substract.is_parsed() ) return m_substract->get_left_value();
        }
        
        int get_priority()
        {
                if( m_subexpr.is_parsed() ) return m_subexpr->get_priority();
                if( m_divide.is_parsed() ) return m_divide->get_priority();
                if( m_multiply.is_parsed() ) return m_multiply->get_priority();
                if( m_add.is_parsed() ) return m_add->get_priority();
                if( m_substract.is_parsed() ) return m_substract->get_priority();
        }
}; // expression

#endif

---