simple_non_terminal.h

/***************************************************************************
 *   Copyright (C) 2005 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_PARSERBASIC_SIMPLE_NON_TERMINAL_H
#define GRAMMAR_TO_PARSERBASIC_SIMPLE_NON_TERMINAL_H

#include "parser.h"


namespace grammar_to_parser {

const char* SIMPLE_NON_TERMINAL = "NonTerminal";
template< typename E >
class basic_simple_non_terminal : public basic_parser<E>
{
public:
typedef typename basic_parser<E>::parser_list parser_list;
typedef typename basic_parser<E>::parser_list_iterator parser_list_iterator;
        
        basic_simple_non_terminal() : basic_parser<E>(SIMPLE_NON_TERMINAL) {};
        virtual void push_parsers( parser_list& l ) = 0;
        virtual void invalidate() 
        { 
                m_parser_list.clear();
        }
        virtual bool is_valid() const
        {
                return !m_parser_list.empty();
        }

        unsigned long parse( const E* buf, const unsigned long buf_length )
        {
                prepare_for_parsing();
                parser_list_iterator it = m_parser_list.begin();

                m_is_parsed = true;
                while( it != m_parser_list.end() && m_is_parsed )
                {
                        (*it)->parse( buf + m_parsed_size, buf_length - m_parsed_size );
                        if( (*it)->is_parsed() ) 
                        {
                                m_parsed_size += (*it)->parsed_size();
                                it++;
                        }
                        else
                        {
                                m_is_parsed = false;
                                m_parsed_size = 0;
                        }
                }
                return m_parsed_size;
        }
        virtual std::basic_istream<E>& parse( std::basic_istream<E>& is )
        {
                prepare_for_parsing();
                parser_list_iterator it = m_parser_list.begin();
                std::streampos pos = is.tellg();

                m_is_parsed = true;
                while( it != m_parser_list.end() && m_is_parsed )
                {
                        (*it)->parse( is );
                        if( (*it)->is_parsed() ) 
                        {
                                m_parsed_size += (*it)->parsed_size();
                                it++;
                        }
                        else
                        {
                                m_is_parsed = false;
                                m_parsed_size = 0;
                                is.clear();
                                is.seekg( pos );
                        }
                }
                return is;
        }
    virtual std::basic_ostream<E>& format( std::basic_ostream<E>& os )
        {
                prepare_for_parsing();
                parser_list_iterator it = m_parser_list.begin();
                std::streampos pos = os.tellp();
                if( (std::streamoff) pos < 0 ) pos  = 0;

                m_is_formatted = true;
                while( it != m_parser_list.end() && m_is_formatted )
                {
                        if( (*it)->is_valid() )
                        {
                                (*it)->format( os );
                                m_formatted_size += (*it)->formatted_size();
                                m_is_formatted = (*it)->is_formatted();
                        }
                        it++;
                }
                if( !m_is_formatted )
                {
                        m_formatted_size = 0;
                        os.clear();
                        os.seekp( pos );
                }
                return os;
        }
protected:
        parser_list                     m_parser_list;
        virtual void prepare_for_parsing()
        {
                basic_parser<wchar_t>::prepare_for_parsing();
                if( m_parser_list.empty() ) push_parsers( m_parser_list );
        }
        virtual void prepare_for_formatting()
        {
                basic_parser<wchar_t>::prepare_for_formatting();
                if( m_parser_list.empty() ) push_parsers( m_parser_list );
        }

};

typedef basic_simple_non_terminal<char> simple_non_terminal;
typedef basic_simple_non_terminal<wchar_t> wsimple_non_terminal;

};

#endif

---