FormulaGrammar.h

Go to the documentation of this file.

//
// Date:      13 November 2005   
//
// Copyright (c) Sergey Satskiy 2003 - 2005
//               <sergesatsky@yahoo.com>
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//


#ifndef FORMULAGRAMMAR_H
#define FORMULAGRAMMAR_H


#include <math.h>

#include <vector>
#include <string>
using namespace std;


#include <boost/spirit/core.hpp>
using namespace boost;
using namespace boost::spirit;



struct PushDouble
{
    PushDouble( vector< string > &  code ) :
        Code( code )
    {
    }

    void operator() ( char const *  Start, char const * End ) const
    {
        Code.push_back( "PUSH " + string( Start, End - Start ) );
    }
    
    vector< string > &     Code;   
};



struct PushOperation
{
    PushOperation( const string &  cop, vector< string > &  code ) :
        COP( cop ), Code( code )
    {
    }
    
    void operator() ( char const *  Unused, char const *  End ) const
    {
        Code.push_back( COP );
    }
    
    string              COP;    
    vector< string > &  Code;   
};





struct SFormulaGrammar : public grammar< SFormulaGrammar >
{
    SFormulaGrammar( vector< string > &  code ) : 
        Code( code ) 
    {
    }

    template < typename  ScannerT >
    struct definition
    {
        definition( SFormulaGrammar const &  Self )
        {
            Function = 
                ( str_p( "sin" ) >> '(' >> Expression >> ')' )
                    [ PushOperation( "SIN", Self.Code ) ]      |
                ( str_p( "cos" ) >> '(' >> Expression >> ')' )
                    [ PushOperation( "COS", Self.Code ) ];
                    
            Double =
                lexeme_d[ (+ureal_p)[ PushDouble( Self.Code ) ] ]       |
                str_p( "value" )[ PushOperation( "VALUE", Self.Code ) ];

            Factor =
                Double | Function | '(' >> Expression >> ')'            |   
                ('-' >> Factor)[ PushOperation( "NEGATE", Self.Code ) ] |
                ('+' >> Factor);

            Term =
                Factor
                >> *(   ('*' >> Factor)[ PushOperation( "MULT", Self.Code ) ]
                    |   ('/' >> Factor)[ PushOperation( "DIV", Self.Code ) ]
                    );

            Expression =
                Term
                >> *(   ('+' >> Term)[ PushOperation( "ADD", Self.Code ) ]
                    |   ('-' >> Term)[ PushOperation( "SUB", Self.Code ) ]
                    );
        }


            // Subrules storage
        rule< ScannerT >     Expression;
        rule< ScannerT >     Term;
        rule< ScannerT >     Factor;
        rule< ScannerT >     Double;
        rule< ScannerT >     Function;

            // Executes the scanner
        rule< ScannerT > const &  start( void ) const
        { 
            return Expression; 
        }
    };

    vector< string > &     Code;   
};


#endif

---