reimpl2.h

vsstylemanager1.0.4希望对大家有用啊,

                if( first )
                    str.replace( itstrpos, itstrlen, itsubpos1, itsublen1 );
                else
                    str.insert( itstrpos, itsubpos1, itsublen1 );
                sublen = std::distance( itsubpos1, itsublen1 );
                break;

            case subst_node::SUBST_OP:
                switch( isubst->m_op )
                {
                case subst_node::UPPER_ON:
                    rest = UPPER;
                    break;
                case subst_node::UPPER_NEXT:
                    next = UPPER;
                    break;
                case subst_node::LOWER_ON:
                    rest = LOWER;
                    break;
                case subst_node::LOWER_NEXT:
                    next = LOWER;
                    break;
                case subst_node::ALL_OFF:
                    rest = NIL;
                    break;
                default:
                    REGEX_ASSERT(false);
                    break;
                }
                continue; // jump to the next item in the list

            default:
                REGEX_ASSERT(false);
                break;
            }

            first = false;

            // Are we upper- or lower-casing this string?
            if( rest )
            {
                typename std::basic_string<CharT, TraitsT, AllocT>::iterator ibegin = str.begin();
                std::advance( ibegin, strpos );
                typename std::basic_string<CharT, TraitsT, AllocT>::const_iterator iend = ibegin;
                std::advance( iend, sublen );
                switch( rest )
                {
                case UPPER:
                    regex_toupper( ibegin, iend );
                    break;
                case LOWER:
                    regex_tolower( ibegin, iend );
                    break;
                default:
                    REGEX_ASSERT(false);
                    break;
                }
            }

            // Are we upper- or lower-casing the next character?
            if( next )
            {
                switch( next )
                {
                case UPPER:
                    traits_type::assign( str[strpos], regex_toupper( str[strpos] ) );
                    break;
                case LOWER:
                    traits_type::assign( str[strpos], regex_tolower( str[strpos] ) );
                    break;
                default:
                    REGEX_ASSERT(false);
                    break;
                }
                next = NIL;
            }

            strpos += sublen;
        }

        // If *first* is still true, then we never called str.replace, and the substitution
        // string is empty. Erase the part of the string that the pattern matched.
        if( first )
            str.erase( strpos, strlen );

        // return length of the substitution
        return strpos - old_strpos;
    }

    template< typename CharT, typename TraitsT, typename AllocT >
    static size_t _do_subst
    (
        rpattern_type const & pat,
        std::basic_string<CharT, TraitsT, AllocT> & str,
        basic_subst_results<CharT, TraitsT, AllocT> & results,
        size_type pos,
        size_type len
    )
    {
        typedef std::basic_string<CharT, TraitsT, AllocT> string_type;
        typedef typename basic_subst_results<CharT, TraitsT, AllocT>::backref_vector backref_vector;

        results.m_pbackref_str = pat._save_backrefs() ? &( results.m_backref_str = str ) : &str;
        results.m_ibegin = results.m_pbackref_str->begin();

        size_t csubst = 0;
        size_type stop_offset = results.m_pbackref_str->size();
        if( len != rpattern_type::npos )
            stop_offset = regex_min( size_t( pos + len ), stop_offset );

        match_param<IterT> param( results.m_ibegin, results.m_ibegin, results.m_ibegin, 0, 0 );

        std::advance( param.m_imatchbegin, pos );
        std::advance( param.m_iend, stop_offset );
        param.m_ibufferbegin = param.m_imatchbegin;

        if( GLOBAL & pat.flags() )
        {
            bool const fAll   = ( ALLBACKREFS   == ( ALLBACKREFS   & pat.flags() ) );
            bool const fFirst = ( FIRSTBACKREFS == ( FIRSTBACKREFS & pat.flags() ) );
            backref_vector rgtempbackrefs( results.m_rgbackrefs.get_allocator() ); // temporary vector used if fsave_backrefs

            size_type pos_offset = 0; // keep track of how much the backref_str and
                                      // the current string are out of sync

            while( _do_try_match( pat, param, results.m_rgbackrefs, false ) )
            {
                backref_type const & br = param.m_prgbackrefs[0];
                ++csubst;
                size_type match_length = std::distance( br.first, br.second );
                pos = std::distance( results.m_ibegin, br.first );
                size_type subst_length = _do_subst_internal( str, results, pat, pos + pos_offset, match_length );

                if( pat._save_backrefs() )
                {
                    pos += match_length;
                    pos_offset += ( subst_length - match_length );

                    // Handle specially the backref flags
                    if( fFirst )
                    {
                        rgtempbackrefs.push_back( br );
                    }
                    else if( fAll )
                    {
                        rgtempbackrefs.insert(
                            rgtempbackrefs.end(),
                            results.m_rgbackrefs.begin(),
                            results.m_rgbackrefs.end() );
                    }
                    else
                    {
                        rgtempbackrefs.swap( results.m_rgbackrefs );
                    }
                }
                else
                {
                    pos += subst_length;
                    stop_offset += ( subst_length - match_length );
                    results.m_ibegin = results.m_pbackref_str->begin();

                    // we're not saving backref information, so we don't
                    // need to do any special backref maintenance here
                }

                // prevent a pattern that matches 0 characters from matching
                // again at the same point in the string
                param.m_no0len = ( 0 == match_length );

                param.m_imatchbegin = results.m_ibegin;
                std::advance( param.m_imatchbegin, pos ); // ineffecient for bidirectional iterators.

                param.m_iend = results.m_ibegin;
                std::advance( param.m_iend, stop_offset ); // ineffecient for bidirectional iterators.
            }

            // If we did special backref handling, swap the backref vectors
            if( pat._save_backrefs() )
            {
                results.m_rgbackrefs.swap( rgtempbackrefs );
            }
            else if( ! results.m_rgbackrefs[0].matched )
            {
                results.m_rgbackrefs.clear();
            }
        }
        else if( _do_try_match( pat, param, results.m_rgbackrefs, false ) )
        {
            backref_type const & br = param.m_prgbackrefs[0];
            ++csubst;
            _do_subst_internal(
                str, results, pat,
                std::distance( results.m_ibegin, br.first ),
                std::distance( br.first, br.second ) );
            results.m_ibegin = results.m_pbackref_str->begin();
        }

        if( NOBACKREFS == ( pat.flags() & NOBACKREFS ) )
        {
            results.m_rgbackrefs.clear();
        }

        return csubst;
    }

    static instantiator instantiate()
    {
        return instantiator_helper
        (
            &regex_access::_do_match_iterative_helper_s,
            &regex_access::_do_match_iterative_helper_c,
            &regex_access::_do_match_recursive_s,
            &regex_access::_do_match_recursive_c,
            &regex_access::_do_match_with_stack,
            &regex_access::_do_match_impl
        );
    }
};


//
// Some helper functions needed by process_escapes
//
template< typename CharT >
inline bool regex_isxdigit( CharT ch )
{
    return ( REGEX_CHAR(CharT,'0') <= ch && REGEX_CHAR(CharT,'9') >= ch )
        || ( REGEX_CHAR(CharT,'a') <= ch && REGEX_CHAR(CharT,'f') >= ch )
        || ( REGEX_CHAR(CharT,'A') <= ch && REGEX_CHAR(CharT,'F') >= ch );
}

template< typename CharT >
inline int regex_xdigit2int( CharT ch )
{
    if( REGEX_CHAR(CharT,'a') <= ch && REGEX_CHAR(CharT,'f') >= ch )
        return ch - REGEX_CHAR(CharT,'a') + 10;
    if( REGEX_CHAR(CharT,'A') <= ch && REGEX_CHAR(CharT,'F') >= ch )
        return ch - REGEX_CHAR(CharT,'A') + 10;
    return ch - REGEX_CHAR(CharT,'0');
}

} // namespace detail

// --------------------------------------------------------------------------
//
// Function:    process_escapes
//
// Description: Turn the escape sequnces \f \n \r \t \v \\ into their
//              ASCII character equivalents. Also, optionally process
//              perl escape sequences.
//
// Returns:     void
//
// Arguments:   str      - the string to process
//              fPattern - true if the string is to be processed as a regex
//
// Notes:       When fPattern is true, the perl escape sequences are not
//              processed.  If there is an octal or hex excape sequence, we
//              don't want to turn it into a regex metacharacter here.  We
//              leave it unescaped so the regex parser correctly interprests
//              it as a character literal.
//
// History:     8/1/2001 - ericne - Created
//
// --------------------------------------------------------------------------
template< typename CharT, typename TraitsT, typename AllocT >
inline void process_escapes( std::basic_string<CharT, TraitsT, AllocT> & str, bool fPattern ) //throw()
{
    typedef typename std::basic_string<CharT, TraitsT, AllocT>::size_type size_type;

    size_type i = 0;
    size_type const npos = std::basic_string<CharT, TraitsT, AllocT>::npos;

    if( str.empty() )
        return;

    while( npos != ( i = str.find( REGEX_CHAR(CharT,'\\'), i ) ) )
    {
        if( str.size() - 1 == i )
            return;

        switch( str[i+1] )
        {
        case REGEX_CHAR(CharT,'a'):
            str.replace( i, 2, 1, REGEX_CHAR(CharT,'\a') );
            break;
        case REGEX_CHAR(CharT,'b'):
            if( ! fPattern )
                str.replace( i, 2, 1, REGEX_CHAR(CharT,'\b') );
            else
                ++i;
            break;
        case REGEX_CHAR(CharT,'e'):
            str.replace( i, 2, 1, CharT( 27 ) );
            break;
        case REGEX_CHAR(CharT,'f'):
            str.replace( i, 2, 1, REGEX_CHAR(CharT,'\f') );
            break;
        case REGEX_CHAR(CharT,'n'):
            str.replace( i, 2, 1, REGEX_CHAR(CharT,'\n') );
            break;
        case REGEX_CHAR(CharT,'r'):
            str.replace( i, 2, 1, REGEX_CHAR(CharT,'\r') );
            break;
        case REGEX_CHAR(CharT,'t'):
            str.replace( i, 2, 1, REGEX_CHAR(CharT,'\t') );
            break;
        case REGEX_CHAR(CharT,'v'):
            str.replace( i, 2, 1, REGEX_CHAR(CharT,'\v') );
            break;
        case REGEX_CHAR(CharT,'\\'):
            if( fPattern )
            {
                if( i+3 < str.size() && REGEX_CHAR(CharT,'\\') == str[i+2] && REGEX_CHAR(CharT,'\\') == str[i+3] )
                    str.erase( i, 2 );
                ++i;
            }
            else
                str.erase( i, 1 );
            break;
        case REGEX_CHAR(CharT,'0'): case REGEX_CHAR(CharT,'1'): case REGEX_CHAR(CharT,'2'): case REGEX_CHAR(CharT,'3'):
        case REGEX_CHAR(CharT,'4'): case REGEX_CHAR(CharT,'5'): case REGEX_CHAR(CharT,'6'): case REGEX_CHAR(CharT,'7'):
            if( ! fPattern )
            {
                size_t j=i+2;
                CharT ch = CharT( str[i+1] - REGEX_CHAR(CharT,'0') );
                for( ; j-i < 4 && j < str.size() && REGEX_CHAR(CharT,'0') <= str[j] && REGEX_CHAR(CharT,'7') >= str[j]; ++j )
                    ch = CharT( ch * 8 + ( str[j] - REGEX_CHAR(CharT,'0') ) );
                str.replace( i, j-i, 1, ch );
            }
            break;
        case REGEX_CHAR(CharT,'x'):
            if( ! fPattern )
            {
                CharT ch = 0;
                size_t j=i+2;
                for( ; j-i < 4 && j < str.size() && detail::regex_isxdigit( str[j] ); ++j )
                    ch = CharT( ch * 16 + detail::regex_xdigit2int( str[j] ) );
                str.replace( i, j-i, 1, ch );
            }
            break;
        case REGEX_CHAR(CharT,'c'):
            if( ! fPattern && i+2 < str.size() )
            {
                CharT ch = str[i+2];
                if( REGEX_CHAR(CharT,'a') <= ch && REGEX_CHAR(CharT,'z') >= ch )
                    ch = detail::regex_toupper( ch );
                str.replace( i, 3, 1, CharT( ch ^ 0x40 ) );
            }
            break;
        default:
            if( fPattern )
                ++i;
            else
                str.erase( i, 1 );
            break;
        }
        ++i;
        if( str.size() <= i )
            return;
    }
}

#endif