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_PARSERTERMINAL_H
#define GRAMMAR_TO_PARSERTERMINAL_H

namespace grammar_to_parser {

const char* TERMINAL = "terminal";
template< typename E, E value >
class basic_terminal : public basic_object_parser< E, E >
{
typedef std::auto_ptr<E> std_auto_ptr;
public:
    basic_terminal();
    virtual ~basic_terminal();
        
        virtual unsigned long parse( const E *buf, 
                                                        const unsigned long buf_length )
        {
                prepare_for_parsing();
                
#ifdef TRACE 
                if( buf_length > 0 )
                {
                        cout << "terminal " << std::string(1,value).c_str();
                        cout << ", input=" << std::string(1,buf[0]).c_str() << endl;
                }
#endif

                if( buf_length > 0 && 
                        (E)buf[0] == get_valid() )
                {
                        m_is_parsed = true;
                        m_parsed_size = 1;//sizeof(value);
                }
                return m_parsed_size;
        }    
        virtual std::basic_istream<E>& parse( std::basic_istream<E>& is );
                        
        virtual std::basic_ostream<E>& format( std::basic_ostream<E>& os );    

        // during allocation the value is assigned to unsigned char - for 
        // comparison during parsing
        E& get_valid()
        {
                if( !is_valid() ) 
                {
                        std_auto_ptr::operator=( std_auto_ptr(new E(value)) );
                }
                return std_auto_ptr::operator *();

        }
};

template< char value >
class terminal : public basic_terminal<char,value>
{
public:
        terminal() : basic_terminal<char,value>() {};
        ~terminal() {};
};

template< wchar_t value >
class wterminal : public basic_terminal<wchar_t,value>
{
public:
        wterminal() : basic_terminal<wchar_t,value> () {};
        ~wterminal() {};
};


template< class E, E value >
basic_terminal<E,value>::basic_terminal() : basic_object_parser<E,E>(TERMINAL) 
{
}

template< typename E, E value >
basic_terminal<E,value>::~basic_terminal()
{
}

template< typename E, E value >
std::basic_ostream<E>& basic_terminal<E,value>::format( std::basic_ostream<E>& os )
{
        prepare_for_formatting();

        std::streampos strPos = os.tellp();
        if( (std::streamoff)strPos < 0 ) strPos = 0;

        E out = get_valid();
        if( os.good() ) 
        {
                os.write( (E*)&out,sizeof(E) );
                m_formatted_size = sizeof(E);
                m_is_formatted = true;
        }
        else 
        {
                os.clear();
                os.seekp( strPos );
        }
        return os;
}

template< typename E, E value >
std::basic_istream<E>& basic_terminal<E,value>::parse( std::basic_istream<E>& is )
{
typedef std::basic_istream<E> std_is;
        
        prepare_for_parsing();
        if( !is.good() )
        {
                return is;
        }
        E input = get_valid();
        std::streampos str_pos = is.tellg();

        is.read( &input, 1 );
        
#ifdef TRACE 
        cout << "terminal " << std::string(1,value).c_str();
        cout << ", input=" << std::string(1,input).c_str() << endl;
#endif

        if( is.good() && get_valid() == input )
        {
                m_parsed_size = 1;
                m_is_parsed = true;
        }
        else 
        {
                is.clear();
                is.seekg( str_pos );
        }
        return is;
}

};

#endif

---