ere_dupl_symbol.h

/***************************************************************************
 *   Copyright (C) 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 EXTENDED_REGULAR_EXPRESSIONERE_DUPL_SYMBOL_H
#define EXTENDED_REGULAR_EXPRESSIONERE_DUPL_SYMBOL_H

namespace extended_regular_expression {

template<typename E>
class ere_dupl_symbol
{
typedef typename grammar_to_parser::basic_parser<E>::parser_list
                                                                                                                                parser_list;
        
        class dup_count
        {
        protected:
                grammar_to_parser::basic_terminal<E,'{'>                                m_left_bracket;
                grammar_to_parser::basic_value_parser<E,unsigned long>  m_repeat_min;
                grammar_to_parser::basic_terminal<E,'}'>                                m_right_bracket;
        public:
                void push_parsers( parser_list &l )
                {
                        l.push_back(&m_left_bracket);
                        l.push_back(&m_repeat_min);
                        l.push_back(&m_right_bracket);
                }
                virtual unsigned long get_min()
                {
                        return m_repeat_min.get_valid();
                }
                virtual unsigned long get_max()
                {
                        return m_repeat_min.get_valid();
                }
        };
        
        class dup_count_unbound : public dup_count
        {
        protected:
                grammar_to_parser::basic_terminal<E,','>        m_sep;
        public:
                void push_parsers( parser_list &l )
                {
                        l.push_back(&m_left_bracket);
                        l.push_back(&m_repeat_min);
                        l.push_back(&m_sep);
                        l.push_back(&m_right_bracket);
                }
                unsigned long get_max()
                {
                        // TODO - find the maximum integer
                        long i = -1;
                        return (unsigned long)i;
                        // return MAX_INT;
                }
                
        };
        
        class dup_count_max : public dup_count_unbound
        {
        protected:
                grammar_to_parser::basic_value_parser<E,unsigned long>
                                                                                                        m_repeat_max;
        public:
                void push_parsers( parser_list &l )
                {
                        l.push_back(&m_left_bracket);
                        l.push_back(&m_repeat_min);
                        l.push_back(&m_sep);
                        l.push_back(&m_repeat_max);
                        l.push_back(&m_right_bracket);
                }
                unsigned long get_max()
                {
                        return m_repeat_max.get_valid();
                }
                
        };
        
        class lazy_star
        {
                grammar_to_parser::basic_terminal<E, '*'>               m_star;
                grammar_to_parser::basic_terminal<E, '?'>               m_lazy;
        public:
                void push_parsers( parser_list& l )
                {
                        l.push_back( &m_star );
                        l.push_back( &m_lazy );
                }
        };
                
        class lazy_plus
        {
                grammar_to_parser::basic_terminal<E, '*'>               m_plus;
                grammar_to_parser::basic_terminal<E, '?'>               m_lazy;
        public:
                void push_parsers( parser_list& l )
                {
                        l.push_back( &m_plus );
                        l.push_back( &m_lazy );
                }
        };      
        
        grammar_to_parser::basic_non_terminal<E, lazy_star>     m_lazy_star;
        grammar_to_parser::basic_non_terminal<E, lazy_plus>     m_lazy_plus;
        grammar_to_parser::basic_terminal<E,'*'>                        m_star;
        grammar_to_parser::basic_terminal<E,'+'>                        m_plus;
        grammar_to_parser::basic_terminal<E,'?'>                        m_question_mark;
        grammar_to_parser::basic_non_terminal<E,dup_count>      m_dup;
        grammar_to_parser::basic_non_terminal<E,dup_count_unbound>
                                                                                                                m_dup_unbound;
        grammar_to_parser::basic_non_terminal<E,dup_count_max>
                                                                                                                m_dup_max;
        
        unsigned long                                                           m_rep;
public:
    
        ere_dupl_symbol() : 
                m_lazy_star(),
                m_lazy_plus(),
                m_dup(),
                m_dup_unbound(),
                m_dup_max() {};
    ~ere_dupl_symbol() {};
        
        bool is_lazy()
        {
                return m_lazy_star.is_parsed() || m_lazy_plus.is_parsed();
        }
                
        unsigned long get_min()
        {
                
                if( m_star.is_parsed() ) return 0;
                else if( m_plus.is_parsed() ) return 1;
                else if( m_lazy_star.is_parsed() ) return 0;
                else if( m_lazy_plus.is_parsed() ) return 1;
                else if( m_question_mark.is_parsed() ) return 0;
                else if( m_dup.is_parsed() ) return m_dup->get_min();
                else if( m_dup_unbound.is_parsed() ) return m_dup_unbound->get_min();
                else return m_dup_max->get_min();
        }
        
        unsigned long get_max()
        {
                if( m_star.is_parsed() ) return INT_MAX;
                else if( m_plus.is_parsed() ) return INT_MAX;
                else if( m_lazy_star.is_parsed() ) return INT_MAX;
                else if( m_lazy_plus.is_parsed() ) return INT_MAX;
                else if( m_question_mark.is_parsed() ) return 1;
                else if( m_dup.is_parsed() ) return m_dup->get_max();
                else if( m_dup_unbound.is_parsed() ) return m_dup_unbound->get_max();
                else return m_dup_max->get_max();
        }
        
        void set_recognized_dup( unsigned long rec_dup )
        {
                m_rep = rec_dup;
        }
        
        unsigned long get_recognized_dup()
        {
                return m_rep;
        }
        
        void push_parsers( parser_list &l )
        {
                l.push_back(&m_lazy_star);
                l.push_back(&m_lazy_plus);
                l.push_back(&m_star);
                l.push_back(&m_plus);
                l.push_back(&m_question_mark);
                l.push_back(&m_dup);
                l.push_back(&m_dup_unbound);
                l.push_back(&m_dup_max);
        }
};

};

#endif

---