subset.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_PARSERSUBSET_H
#define GRAMMAR_TO_PARSERSUBSET_H

#include "non_terminal.h"

namespace grammar_to_parser {

template <typename E,typename A>
class basic_subset : 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_subset();
    ~basic_subset();
    virtual unsigned long parse( const E *buf, const unsigned long buf_lenght );
        virtual std::basic_istream<E>& parse( std::basic_istream<E>& is );
};





template< typename E, typename A >
basic_subset<E,A>::basic_subset()
 : basic_non_terminal<E,A>()
{
}


template< typename E, typename A >
basic_subset<E,A>::~basic_subset()
{
}


template< typename E, typename A >
unsigned long basic_subset<E,A>::parse( const E *buf, 
                                                                                        const unsigned long buf_length )
{
        prepare_for_parsing();

        bool is_parsed = true;
        parser_list symbols;
        parser_list_iterator parse_iterator = m_symbols.begin();

        // copy symbols to temporary list seems to be best to me
        while( parse_iterator != m_symbols.end() ) 
                symbols.push_back( *(parse_iterator++) );
        while( !symbols.empty() && is_parsed )
        {
                parse_iterator = symbols.begin();
                is_parsed = false;
                while( parse_iterator != symbols.end() && !is_parsed )
                {
                        (*parse_iterator)->change_strategy( m_strategy );
                        (*parse_iterator)->parse( buf+m_parsed_size, 
                                                                        buf_length-m_parsed_size );
                        if( is_parsed = (*parse_iterator)->is_parsed() ) 
                        {
                                m_parsed_size += (*parse_iterator)->parsed_size();
                                 // exclude from parsing
                                parse_iterator = symbols.erase(parse_iterator);
                        }
                        else parse_iterator++; // continue with next
                }
        }
        for( parse_iterator = symbols.begin(); 
                parse_iterator != symbols.end(); 
                parse_iterator++ )
        {
                (*parse_iterator)->change_parsed_flag(false);
        }

        m_is_parsed = true; // always parsed

        return m_parsed_size;
}

template <typename E, typename A >
std::basic_istream<E>& basic_subset<E,A>::parse( std::basic_istream<E>& is )
{
        prepare_for_parsing();

        bool is_parsed = true;
        parser_list symbols;
        parser_list_iterator parse_iterator = m_symbols.begin();

        // copy symbols to temporary list seems to be best to me
        while( parse_iterator != m_symbols.end() ) 
                symbols.push_back( *(parse_iterator++) );
        while( !symbols.empty() && is_parsed )
        {
                parse_iterator = symbols.begin();
                is_parsed = false;
                while( parse_iterator != symbols.end() && !is_parsed && is.good() )
                {
                        (*parse_iterator)->change_strategy( m_strategy );
                        (*parse_iterator)->parse( is );
                        if( is_parsed = (*parse_iterator)->is_parsed() ) 
                        {
                                m_parsed_size += (*parse_iterator)->parsed_size();
                                 // exclude from parsing
                                parse_iterator = symbols.erase(parse_iterator);
                        }
                        else parse_iterator++; // continue with next
                }
        }
        for( parse_iterator = symbols.begin(); 
                parse_iterator != symbols.end(); 
                parse_iterator++ )
        {
                (*parse_iterator)->change_parsed_flag(false);
        }

        m_is_parsed = true; // always parsed

        return is;
}

template <typename A>
class subset : public basic_subset<char, A>
{
public:
    subset() : basic_subset<char,A>() {};
    ~subset() {};
};

template <typename A>
class wsubset : public basic_subset<wchar_t, A>
{
public:
    wsubset() : basic_subset<wchar_t,A>() {};
    ~wsubset() {};
};


};

#endif

---