pattern_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_PARSERPATTERN_PARSER_H
#define GRAMMAR_TO_PARSERPATTERN_PARSER_H

#include "default_type_parser.h"
#include "ctype.h"

namespace grammar_to_parser {

const char* PATTERN_PARSER = "PatternParser";
template< typename E >
class basic_pattern_parser : 
        public basic_default_type_parser< E, std::basic_string<E> >
{
public:
typedef std::basic_string<E>    string_type;
    basic_pattern_parser() : 
                        basic_default_type_parser< E, string_type >(PATTERN_PARSER) {};
        basic_pattern_parser( const std::basic_string<E>& pattern, 
                                        int comparison_type = IGNORE_CASE | IGNORE_SPACE ) :
                basic_default_type_parser< E, string_type >(pattern,PATTERN_PARSER),
                comparison_type_(comparison_type) {};
                                
        basic_pattern_parser( const char *pattern, 
                                        int comparison_type = IGNORE_CASE | IGNORE_SPACE ) :
                basic_default_type_parser< E, string_type >(widen(pattern),PATTERN_PARSER),
                comparison_type_(comparison_type) {};
        
    ~basic_pattern_parser() {};
        virtual unsigned long parse( const E *buf, const unsigned long buf_length );

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

        std::basic_string<E> widen( const char* pattern )
        {
                // TODO - use constructor with input of pattern, as it must be stored 
                // the while pattern including spaces
                std::basic_stringstream<E> ss;
                ss << pattern;
                return ss.str();
                /*std::string str_pattern = pattern;
                E* dest = new E[str_pattern.length()];
                // std::use_facet< std::ctype<E> >().widen( pattern, pattern+str_pattern.length(), dest );
                std::basic_string<E> ret = dest;
                delete[] dest;
                return ret;*/
        }
protected:
        enum comparison_type
        {
                IGNORE_SPACE = 1, 
                IGNORE_CASE = 2 
        };
        int comparison_type_;

private:
        // TODO  - use ctype<E> locale to compare national specific letters
        bool is_capital( const char cr ) {return cr >= 'A' && cr <= 'Z';}
        bool is_space( const char cr ) {return cr == ' ' || cr == '\t' || cr == '\n';}
        bool compare( typename string_type::iterator& it, const E cr )
        {
                if( (*it) == cr || 
                        ( (comparison_type_ & IGNORE_CASE ) &&
                        ( is_capital(cr) && (cr-'A') == ((*it)-'a') ||
                                is_capital(*it) && ((*it)-'A') == (cr-'a') ) ) )
                {
                        it++;
                        return true;
                }
                else if( is_space(cr) && ( comparison_type_ & IGNORE_SPACE ) ) 
                {
                        return true;
                }
                else 
                {
                        return false;
                }
        }

};


template< typename E >
unsigned long basic_pattern_parser<E>::parse( const E *buf, const unsigned long buf_length )
{
        prepare_for_parsing();
        typename string_type::iterator it = get_valid().begin();

        while( m_parsed_size < buf_length && 
                        it != get_valid().end() && 
                        compare( it, buf[m_parsed_size] ) )
        {
                m_parsed_size++;
                // it++;
        }
        if( it == get_valid().end() )
                m_is_parsed = true;
        else 
                m_parsed_size = 0;

        return m_parsed_size;
}

template< typename E >
std::basic_istream<E>& basic_pattern_parser<E>::parse( std::basic_istream<E>& is )
{
        prepare_for_parsing();
        typename string_type::iterator it = get_valid().begin();

        std::streampos str_pos = is.tellg();
        E input = 0;
        bool match = true;

        while( is.good()  &&  it != get_valid().end()  &&  match )
        {
                m_parsed_size++;
                is.read( &input, 1 );
                match = compare( it, input );
        }
        if( it == get_valid().end() )
        {
                m_is_parsed = true;
        }
        else 
        {
                m_parsed_size = 0;
                is.clear();
                is.seekg( str_pos );
        }
        return is;
}

typedef basic_pattern_parser<char> pattern_parser;
typedef basic_pattern_parser<wchar_t> wpattern_parser;

};

#endif

---