choice.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 GRAMMAR_TO_PARSERCHOICE_H
#define GRAMMAR_TO_PARSERCHOICE_H

#include "non_terminal.h"

namespace grammar_to_parser {

const char* CHOICE = "Choice";

template <typename E, typename A>
class basic_choice : 
        public basic_non_terminal<E,A>
{
public:
typedef typename basic_parser<E>::parser_list parser_list;
typedef typename basic_parser<E>::parser_list_iterator parser_list_iterator;

    basic_choice();
        
        basic_choice( const basic_choice& rhs );
        
        basic_choice( const A& obj );
        
        
    virtual ~basic_choice();

    virtual unsigned long parse( const E *buf, const unsigned long buf_length );

    virtual unsigned long parse( const E *buf, 
                                                                const unsigned long buf_length,
                                                                basic_parser_strategy<E>& strategy);

        virtual std::basic_istream<E>& parse( std::basic_istream<E>& is );      
};

template <typename A>
class choice : public basic_choice<char,A>
{
public:
    
        choice() : basic_choice<char,A>() {};
        choice(const choice& rhs) : 
                basic_choice<char,A>( rhs ) {};
        choice(const A& obj) : 
                basic_choice<char,A>(obj) {};
    virtual ~choice() {};
};

template <typename A>
class wchoice : public basic_choice<wchar_t,A>
{       
public: 
        
    wchoice() : basic_choice<wchar_t,A>() {};
        wchoice(const wchoice& rhs) : 
                basic_choice<wchar_t,A>( rhs ) {};
        wchoice(const A& obj) : 
                basic_choice<wchar_t,A>(obj) {};
        virtual ~wchoice() {};
};

// IMPLEMENTATION
template< typename E, typename A >
basic_choice<E,A>::basic_choice()
 : basic_non_terminal<E,A>()
{
        set_name( CHOICE );
}

template< typename E, typename A >
basic_choice<E,A>::basic_choice( const basic_choice& rhs )
 : basic_non_terminal<E,A>(rhs)
{
        set_name( CHOICE );
};

template< typename E, typename A >
basic_choice<E,A>::basic_choice( const A& obj )
 : basic_non_terminal<E,A>(obj)
{
        set_name( CHOICE );
};

template< typename E, typename A >
basic_choice<E,A>::~basic_choice()
{
        set_name( CHOICE );
}

template< typename E, typename A >
unsigned long basic_choice<E,A>::parse( const E *buf, 
                                                                                const unsigned long buf_length )
{
        prepare_for_parsing();
        
        parser_list_iterator parse_iterator = m_symbols.begin();
        while( parse_iterator != m_symbols.end() && !m_is_parsed )
        {
                // try to parse any of the symbols, stop when
                // found the first successive parser
                m_parsed_size = (*parse_iterator)->parse(buf, buf_length);
                m_is_parsed = (*parse_iterator)->is_parsed();
                if( !m_is_parsed )  
                {
                        (*parse_iterator)->invalidate();
                }
                parse_iterator++;
        }
        // unset 'parsed' flag for rest (for parser reuse)
        while( parse_iterator != m_symbols.end() )
        {
                (*parse_iterator++)->invalidate();
        }
        return m_parsed_size;
}

template< typename E, typename A >
std::basic_istream<E>& basic_choice<E,A>::parse( std::basic_istream<E>& is )
{
        prepare_for_parsing();
        parser_list_iterator parse_iterator = m_symbols.begin();
        
        std::streampos stream_pos = is.tellg();
        if( (std::streamoff)stream_pos < 0 ) stream_pos = 0;

        while(  parse_iterator != m_symbols.end() &&
                        !is.bad() && 
                        !m_is_parsed )
        {
                (*parse_iterator)->parse( is );
                m_parsed_size = (*parse_iterator)->parsed_size();
                m_is_parsed = (*parse_iterator)->is_parsed();
                if( !m_is_parsed )  
                {
                        (*parse_iterator)->invalidate();
                }
                parse_iterator++;
        }


        // unset 'parsed' flag for rest (for parser reuse)
        while( parse_iterator != m_symbols.end() )
        {
                (*parse_iterator++)->invalidate();
        }

        // reset the starting os buf possition in case of error
        if( parse_iterator != m_symbols.end() )
        {
                is.clear();
                is.seekg( stream_pos );
                m_parsed_size = 0;
        }
        return is;
}

template< typename E, typename A >
unsigned long basic_choice<E,A>::parse( const E *buf, 
                                                                                const unsigned long buf_length,
                                                                                basic_parser_strategy<E>& strategy )
{
        prepare_for_parsing();
        m_is_parsed = strategy.parse_choice( m_symbols.begin(),
                                                                        m_symbols.end(), 
                                                                        buf, 
                                                                        buf_length, 
                                                                        m_parsed_size );
        return m_parsed_size;
}

};

#endif

---