parser.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_PARSERPARSER_H
#define GRAMMAR_TO_PARSERPARSER_H

#include <sstream>
#include <string>
#include <iostream>
#include <list>


namespace grammar_to_parser {

//template< typename E > class basic_parser;

template< typename E >
class basic_parser
{
public:
typedef std::list< basic_parser<E> * > parser_list;
typedef typename parser_list::iterator parser_list_iterator;

        enum e_symbol_type {  terminal_type,
                                                non_terminal_type, 
                                                choice_type, 
                                                undefined_type 
                                        };
        typedef e_symbol_type symbol_type;
        
        basic_parser(const char* name, symbol_type type = terminal_type) :
                        m_is_parsed(false), 
                        m_is_formatted(false), 
                        m_parsed_size(0),
                        m_formatted_size(0),
                        m_type(type),
                        m_name(name) {};
                        
        basic_parser( const basic_parser& rhs ) :
                m_is_parsed( rhs.m_is_parsed ),
                m_is_formatted( rhs.m_is_formatted ),
                m_parsed_size( rhs.m_parsed_size ),
                m_formatted_size( rhs.m_formatted_size ),
                m_type( rhs.m_type ),
                m_name( rhs.m_name ) {};
                                
        virtual ~basic_parser()
        {       }               
        
        
        symbol_type get_symbol_type() { return m_type; }

        virtual bool is_valid() const = 0;
        virtual void invalidate() = 0;

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

        virtual unsigned long parse( const E *buf, 
                                                                const unsigned long buf_length,  
                                                                basic_parser_strategy<E>& strategy )
        {
                return parse( buf, buf_length );
        }
        
        virtual std::basic_istream<E>& parse( std::basic_istream<E>& is ) = 0;
        
        virtual std::basic_ostream<E>& format( std::basic_ostream<E>& os ) = 0;

        unsigned long parsed_size() const { return m_parsed_size; }
        unsigned long formatted_size() const { return m_formatted_size; }

        bool is_parsed() const { return m_is_parsed; }
        bool is_formatted() const { return m_is_formatted; }

        virtual void push_parsers( std::list< basic_parser<E> * >& the_parser_list )
        { 
                the_parser_list.push_back(this);
        }

        bool change_parsed_flag( const bool the_parsed_flag = true ) 
        { 
                bool b = m_is_parsed; 
                m_is_parsed= the_parsed_flag; 
                return b;
        }
        
        virtual const char* get_name() { return m_name; }
        
        virtual bool try_next() {m_is_parsed=false;return false;}
        virtual void set_to_begin() {};
        
protected:
        bool                                            m_is_parsed;
        bool                                            m_is_formatted;
        unsigned long                           m_parsed_size;
        unsigned long                           m_formatted_size;
        const char*                                     m_name;


        symbol_type             m_type;         
        
        virtual void prepare_for_parsing()
        {
                // cout << get_name() << endl;
                m_is_parsed = false;
                m_parsed_size = 0;
#ifdef TRACE
                cout << get_name() << endl;
#endif
        }
        
        virtual void trace_on_fly() {};
        
        virtual void prepare_for_formatting() 
        {
                m_is_formatted = false;
                m_formatted_size = 0;
        };
        bool change_formatted_flag( const bool the_formatted_flag = true ) 
        { 
                bool b = m_is_formatted; 
                m_is_formatted = the_formatted_flag; 
                return b;
        }
        unsigned long change_parsed_size( const unsigned long the_parsed_size )
        {
                unsigned long size = m_parsed_size;
                m_parsed_size = the_parsed_size;
                return size;
        }
        unsigned long change_formatted_size( const unsigned long the_formatted_size )
        {
                unsigned long size = m_formatted_size;
                m_formatted_size = the_formatted_size;
                return size;
        }
        
        void set_name( const char* name ) { m_name = name; }    
};


template< typename E >
std::basic_ostream<E>& operator <<( std::basic_ostream<E>& os, 
                                                                        basic_parser<E>& parser )
{
        return parser.format(os);
}
        
template< typename E >
inline std::basic_istream<E>& operator >>( std::basic_istream<E>& is,
                                                                                  basic_parser<E>& parser )
{
        return parser.parse( is );
}

typedef basic_parser<char>::parser_list parsers;
typedef basic_parser<wchar_t>::parser_list wparsers;


};


#endif

---