MachineGrammar.h

Go to the documentation of this file.

//
// Date:      20 August   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 MACHINEGRAMMAR_H
#define MACHINEGRAMMAR_H


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

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



struct SaveStartState
{
    SaveStartState( string &  name ) : Name( name )
    {}

    void operator()( const char* const&  Start, const char* const& End ) const
    {
        Name = string( Start, End - Start );
    }  

    private:
        string &        Name;       // Reference to the start state
};




struct SStartStateGrammar: public grammar< SStartStateGrammar >
{
    string &        Name;       // Reference to the start name
    
    SStartStateGrammar( string &  name ) : Name( name )
    {}

    template < typename  ScannerT >
    struct definition
    {
        definition( SStartStateGrammar const &  Self )
        {
            Identifier 
                =   lexeme_d
                    [
                        (
                            ( alpha_p | '_' | '$' )
                            >> * ( alnum_p | '_' | '$' )
                        )
                    ]
                ;
            
            StartStateLine
                =   str_p( "start" ) >> (Identifier[ SaveStartState( Self.Name ) ])
                ;
        }

        rule< ScannerT >    Identifier;
        rule< ScannerT >    StartStateLine;


        rule< ScannerT > const &  start( void ) const
        {
            return StartStateLine;
        }
    };
};



struct SaveState
{
    SaveState( SStatesListProxy< string > &   states ) : States( states )
    {}

    void operator()( const char* const&  Start, const char* const& End ) const
    {
        States << string( Start, End - Start );
    }  

    private:
        SStatesListProxy< string > &      States;
};



struct SStatesGrammar: public grammar< SStatesGrammar >
{
    SStatesListProxy< string > &      States;   // Reference to the states list
    
    SStatesGrammar( SStatesListProxy< string > &  states ) : States( states )
    {}

    template < typename  ScannerT >
    struct definition
    {
        definition( SStatesGrammar const &  Self )
        {
            Identifier 
                =   lexeme_d
                    [
                        (
                            ( alpha_p | '_' | '$' )
                            >> * ( alnum_p | '_' | '$' )
                        )
                    ]
                ;
            
            StatesLine
                =   str_p( "states" ) >> Identifier[ SaveState( Self.States ) ] 
                                      >> * ( ',' >> Identifier[ SaveState( Self.States ) ] )
                ;
        }

        rule< ScannerT >    Identifier;
        rule< ScannerT >    StatesLine;


        rule< ScannerT > const &  start( void ) const
        {
            return StatesLine;
        }
    };
};




struct SaveID
{
    SaveID( vector< string > &   states ) : States( states )
    {}

    void operator()( const char* const&  Start, const char* const& End ) const
    {
        States.push_back( string( Start, End - Start ) );
    }  

    private:
        vector< string > &          States;
};


struct SEventsGrammar: public grammar< SEventsGrammar >
{
    vector< string > &          Transitions;    // Reference to the IDs' list
    
    SEventsGrammar( vector< string > &  transitions ) : Transitions( transitions )
    {}

    template < typename  ScannerT >
    struct definition
    {
        definition( SEventsGrammar const &  Self )
        {
            Identifier 
                =   lexeme_d
                    [
                        (
                            ( alpha_p | '_' | '$' )
                            >> * ( alnum_p | '_' | '$' )
                        )
                    ]
                ;
            
            EventLine
                =   str_p( "event" ) >> '(' >> Identifier[ SaveID( Self.Transitions ) ] >> ')' >>
                    Identifier[ SaveID( Self.Transitions ) ] >> 
                    * ( ',' >> Identifier[ SaveID( Self.Transitions ) ] )
                ;
        }

        rule< ScannerT >    Identifier;
        rule< ScannerT >    EventLine;


        rule< ScannerT > const &  start( void ) const
        {
            return EventLine;
        }
    };
};

#endif
            

---