regexp_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_PARSERREGEXP_PARSER_H
#define GRAMMAR_TO_PARSERREGEXP_PARSER_H

#include "extended_regular_expression.h"

namespace grammar_to_parser {

const char* REGEXP_PARSER = "regexpParser";

template< typename E >
class basic_regexp_parser : public basic_object_parser< E, std::basic_string<E> >
{
public:
        basic_regexp_parser( std::basic_string<E> regular_expression ) : 
                basic_object_parser< E, std::basic_string<E> >(REGEXP_PARSER),
                m_regular_expression( regular_expression ) {};

        ~basic_regexp_parser() {};
        
        bool is_pattern_valid()
        {
                if( !m_regexp.is_parsed() )
                {
                        m_regexp.parse( m_regular_expression.c_str(), 
                                                        m_regular_expression.length() );
                }
                return m_regexp.is_parsed();
        }
                

        virtual unsigned long parse( const E *buf, const unsigned long buf_length )
        {
                prepare_for_parsing();
                
                if( is_valid() )
                {
                         m_parsed_size = m_regexp->recognize( buf, buf_length );
                }
                else
                {
                        return 0;
                }
                if( m_regexp->is_recognized() )
                {
                        std_auto_ptr::operator = 
                                ( std_auto_ptr( new std::basic_string<E>( buf, m_parsed_size ) ) );
                        m_is_parsed = true;
                }
                return m_parsed_size;
        }
        

        virtual std::basic_istream<E>& parse( std::basic_istream<E>& is )
        {
                prepare_for_parsing();

                // TODO - implement to pass istream to regexp - now limited to input in one line
                std::basic_stringbuf<E> buf;
                std::streampos pos = is.tellg();
                if( is.good() )
                {
                        is.get( buf );
                        unsigned long length = buf.str().length();
                        if( is_valid() )
                        {
                                 m_regexp->recognize( buf.str().c_str(), length );
                        }
                        else
                        {
                                return is;
                        }
                        if( m_regexp->is_recognized() )
                        {
                                m_parsed_size = m_regexp->recognized_position() + m_regexp->recognized_size();
                                std_auto_ptr::operator = 
                                        ( std_auto_ptr( new std::basic_string<E>( buf.str().c_str(), m_parsed_size ) ) );
                                m_is_parsed = true;
                                pos += m_parsed_size;
                                is.clear();
                                is.seekg(pos);
                        }
                        else
                        {
                                is.clear();
                                is.seekg(pos);
                        }
                }
                return is;
        }
        
        unsigned long recognized_position()
        {
                if( is_pattern_valid() && m_regexp->is_recognized() )
                {
                        return m_regexp->recognized_position();
                }
                else
                {
                        return 0;
                }
        }

        unsigned long recognized_size()
        {
                if( is_pattern_valid() && m_regexp->is_recognized() )
                {
                        return m_regexp->recognized_size();
                }
                else
                {
                        return 0;
                }
        }
        

        void assign_matches( extended_regular_expression::matches& m )
        {
                if( is_pattern_valid() && m_regexp->is_recognized() )
                {
                        m_regexp->assign_matches(m);
                }
        }
        
        virtual std::basic_ostream<E>& format( std::basic_ostream<E> &os )
        {
                os << get_valid();
                return os;
        }
        
        operator std::basic_string<E>()
        {
        return get_valid();
        }       
        
protected:
        std::basic_string<E>                                                            m_regular_expression;
        basic_non_terminal< E, extended_regular_expression::ere<E> >    m_regexp;

protected:
    void prepare_for_parsing()
        {
                basic_object_parser< E,std::basic_string<E> >::prepare_for_parsing();
                if( !m_regexp.is_parsed() )
                {
                        m_regexp.parse( m_regular_expression.c_str(), 
                                                        m_regular_expression.length() );
                }
        }
        
};

typedef basic_regexp_parser<char> regexp_parser;
typedef basic_regexp_parser<wchar_t> wregexp_parser;

};

#endif

---