non_terminal.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_PARSERNON_TERMINAL_H
#define GRAMMAR_TO_PARSERNON_TERMINAL_H


namespace grammar_to_parser {

const char* NONTERMINAL = "non-terminal";
template<typename E, typename A >
class basic_non_terminal : public basic_object_parser<E,A>
{
public: 
typedef typename basic_parser<E>::parser_list parser_list;
typedef typename basic_parser<E>::parser_list_iterator parser_list_iterator;

    basic_non_terminal();
        basic_non_terminal( const A& obj );
        basic_non_terminal( const basic_non_terminal& rhs );
    ~basic_non_terminal();
        
    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 );

    virtual std::basic_ostream<E>& format( std::basic_ostream<E>& os );

        void invalidate() 
        { 
                m_symbols.clear();
                m_symbols_valid = false;
                basic_object_parser<E,A>::invalidate();
        }


protected:
        parser_list                     m_symbols;
        bool                            m_symbols_valid;

        virtual void prepare_symbols() 
        { 
                if( !m_symbols_valid ) 
                {
                        get_valid().push_parsers( m_symbols );
                        m_symbols_valid = true;
                }
        }
        
        void prepare_for_parsing()
        {
                basic_object_parser<E,A>::prepare_for_parsing();
                prepare_symbols();
                parser_list_iterator it = m_symbols.begin();

        }
        
        void prepare_for_formatting()
        {
                basic_object_parser<E,A>::prepare_for_formatting();
                prepare_symbols();
        }
};

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

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


template< typename E, typename A >
basic_non_terminal<E,A>::basic_non_terminal()
 : basic_object_parser<E,A>(NONTERMINAL,basic_parser<E>::non_terminal_type),
  m_symbols_valid(false)
{
}

template< typename E, typename A >
basic_non_terminal<E,A>::basic_non_terminal( const A& obj  )
 :      basic_object_parser<E,A>(NONTERMINAL,obj, basic_parser<E>::non_terminal_type ), 
        m_symbols_valid(false)
{
};

template< typename E, typename A >
basic_non_terminal<E,A>::basic_non_terminal(
                                                                         const basic_non_terminal& rhs )
 :      basic_object_parser<E,A>(rhs),
        m_symbols_valid(false)
{
};
        
template< typename E, typename A>
basic_non_terminal<E,A>::~basic_non_terminal()
{
}

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

        while(  parse_iterator != m_symbols.end() &&
                        !is.bad() && 
                        is_parsed )
        {
                (*parse_iterator)->parse( is );
                m_parsed_size += (*parse_iterator)->parsed_size();
                is_parsed = (*parse_iterator)->is_parsed();
                parse_iterator++;
        }
        // reset the starting os buf possition in case of error
        if( parse_iterator != m_symbols.end() || !is_parsed)
        {
                is.clear();
                is.seekg( stream_pos );
                m_parsed_size = 0;
        }
        else m_is_parsed = true;
        return is;
}

template< typename E, typename A >
std::basic_ostream<E>& basic_non_terminal<E,A>
 ::format( std::basic_ostream<E>& os )
{
        prepare_for_formatting();
        parser_list_iterator format_iterator = m_symbols.begin();
        
        bool is_formatted = true;
        std::streampos streamPos = os.tellp();
        if( (std::streamoff)streamPos < 0 ) streamPos = 0;

        while(  format_iterator != m_symbols.end() &&
                        !os.bad() && 
                        is_formatted )
        {
                if( (*format_iterator)->is_valid() )
                {
                        (*format_iterator)->format( os );
                        m_formatted_size += (*format_iterator)->formatted_size();
                        is_formatted = (*format_iterator)->is_formatted();
                }
                format_iterator++;
        }
        // reset the starting os buf possition in case of error
        if( format_iterator != m_symbols.end() || !is_formatted)
        {
                os.clear();
                os.seekp( streamPos );
                m_formatted_size = 0;
        }
        else m_is_formatted = true;
        return os;
}

template< typename E, typename A >
unsigned long basic_non_terminal<E,A>
 ::parse( const E *buf, const unsigned long buf_length )
{
        prepare_for_parsing();
        parser_list_iterator parse_iterator = m_symbols.begin();
        
        bool is_parsed = true;

        while(  parse_iterator != m_symbols.end() && is_parsed )
        {
                (*parse_iterator)->parse( buf+m_parsed_size, buf_length-m_parsed_size );
                m_parsed_size += (*parse_iterator)->parsed_size();
                is_parsed = (*parse_iterator)->is_parsed();
                parse_iterator++;
        }
        // reset the starting os buf possition in case of error
        if( !is_parsed )
        {
                m_parsed_size = 0;
        }
        else
        {
                m_is_parsed = true;
        }
        return m_parsed_size;
}

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

};

#endif

---