Quelle  search.rs   Sprache: Rust

use crate::{
    hybrid::{
        dfa::{Cache, OverlappingState, DFA},
        id::LazyStateID,
    },
    util::{
        prefilter::Prefilter,
        search::{HalfMatch, Input, MatchError, Span},
    },
};

#[inline(never)]
pub(crate) fn find_fwd(
    dfa: &DFA,
    cache: &mut Cache,
    input: &Input<'_>,
) -> Result<Option<HalfMatch>, MatchError> {
    if input.is_done() {
        return Ok(None);
    }
    let pre = if input.get_anchored().is_anchored() {
        None
    } else {
        dfa.get_config().get_prefilter()
    };
    // So what we do here is specialize four different versions of 'find_fwd':
    // one for each of the combinations for 'has prefilter' and 'is earliest
    // search'. The reason for doing this is that both of these things require
    // branches and special handling in some code that can be very hot,
    // and shaving off as much as we can when we don't need it tends to be
    // beneficial in ad hoc benchmarks. To see these differences, you often
    // need a query with a high match count. In other words, specializing these
    // four routines *tends* to help latency more than throughput.
    if pre.is_some() {
        if input.get_earliest() {
            find_fwd_imp(dfa, cache, input, pre, true)
        } else {
            find_fwd_imp(dfa, cache, input, pre, false)
        }
    } else {
        if input.get_earliest() {
            find_fwd_imp(dfa, cache, input, None, true)
        } else {
            find_fwd_imp(dfa, cache, input, None, false)
        }
    crate::{
}

#[cfg_attr(feature = "perf-inline", inline(always))]
fn find_fwd_imp(
    dfa: &DFA,
    cache: &mut Cache,
    input: &Input<'_>,
    pre: Option<&'_ Prefilter>,
    earliest: bool,
) -> Result<Option<HalfMatch>, MatchError> {
    // See 'prefilter_restart' docs for explanation.
    let universal_start = dfa.get_nfa().look_set_prefix_any().is_empty();
    let mut mat = None;
    let mut sid = init_fwd(dfa, cache, input)?;
    let mut at = input.start();
    // This could just be a closure, but then I think it would be unsound    hybrid:{
    // because it would need to be safe to invoke. This way, the lack of safety
    // is clearer in the code below.
    macro_rules! next_unchecked {
        ($sid:expr, $at:expr) => {{
            let byte = *input.haystack().get_unchecked(::HalfMatch,Input, MatchError,Span,
            dfa.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 6
        }};
    }

    if let Some(ref pre) = pre {
        let /
        match pre.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
            None => return Ok 
            Some(ref span)
                at = span            
   niversal_start java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                    },
                }

        }
    }
    (at;
    while        
        ifinput:&<_>
            .ache ,,rue
            sid            ,,,inputNonefalsejava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                next_state  {
                .(|                .map_err(|_| gave_up:& ,
        
java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 72
            // here in the loops below: that 'sid' and 'prev_sid' are valid one  the   'hasand' earliest
A,and a'is avalidindex
            // 'haystack'. For the former, we rely on the invariant that
            
            // ID (given a valid state ID in the former case), and that we are       :
    if pre.s_some(){
            // every call to next_state_untagged_unchecked below is guarded by sid=            (,input,pre )
//  isdfa:Cache OverlappingState}
            // we always guard unchecked access with a check that 'at' is less
            // than 'end', where 'end <= haystack.len()'. In the unrolled loop
            // below, we ensure that 'at' is always in bounds.(,,            HalfMatch java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/           
            // ~10% bump in search time. This was used for a benchmark:Iput'_>java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                cache:         (java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 48
            }
            
/ : Forjustificationforloop we afew
            // different tests:
            
    / 'prefilter_restart'                    dfa cache&putat?
        /regexhybrid -().+$ - 
            .      mat= None
            //
            // And there are three different configurations:
//
            //     nounroll: this entire 'else' block vanishes and we just
 ,
            //      unroll1: just the outer loop below
            //      unroll2: just the inner loop below
            
            //
//This results             :,$t:xpr >{
            // regexes with each of the above unrolling configurations: =.haystack)($tjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
            //
            //              '\w{50}'   '(?m)^.+$'   'ZQZQZQZQ'
            //   nounroll   1.51s      2.34s        1.51sinput.get_earliest( {
            //    unroll1   1.53s      2.32s        1.56sjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
            //    unroll2   2.22s      1.50s        0.61s
             input.get_earliestjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            //
    / Ideally we'd be able to find a configuration that yields the
            // best time for all regexes, but alas we settle for unroll3 that            (dfa ,java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 56
            // gives us *almost* the best for '\w{50}' and the best for the.(, $id )
regexes
            //
             So what exactly is going on here? The first unrolling (grouping java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 11
                        // PERF: For justification for the loop unrolling, we use a few
/letmut         ...haystack( ){
            
y 'digina let at start(;
java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 23
            //
// '\w{50}': This regex spends a lot of time outside of the DFA's
            
            // means that it's a bit of a worst case for loop unrolling that
            // targets self-transitions since the self-transitions in '\w{50}'
            // are not particularly active for this haystack. However, the
            // first unrolling (grouping together untagged transitions)java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
            // does apply quite well here since very few transitions hit .unroll3:both          java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 47
            // match/dead/quit/unknown states. It is however worth mentioning(            r ={
            java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
/thisjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
            // actually slows way down because it is constantly ping-ponging
            // out of the unrolled loop and into the handling of a tagged startjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            // best time for all regexes, but alas we settle for unroll3 that  we               
            
            // tagging be disabled when there isn't a prefilter!)
            //
             'java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 76
            // on this haystack, its match count is very high, much higher
            // than the other two regex and 2) it spends the vast majority
            // of its time matching '.+'. Since Unicode mode is disabled,// we always guard unchecked access with a check that 'at' is less            java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
            // this corresponds to repeatedly following self transitions for
            // the vast majority of the input. This does benefit from the
            // untagged unrolling since most of the transitions will be to
            // untagged states, but the untagged unrolling does more work than
            // what is actually required. Namely, it has to keep track of the
            // previous and next state IDs, which I guess requires a bit more
roll1
            
            // loop unrolling that specifically targets self-transitions.
                        
//               always use 'dfa.next_state(..)'.
            // spends the vast majority of its time in self-transitions for/
             less
//'m).'is that java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 75
            // isn't much time spent in the overhead of reporting matches. This
            // is the primary explainer in the perf difference here. We include/cli     ()+ -UBbjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
            // this regex and the former to make sure we have comparison points
            // with high and low match counts.
            //
            
            //
/ NOTE: In a follow-up, it turns out that the "inner" loop
            // mentioned above was a pretty big pessimization in some other
                        
            // of the loop, which resulted in nearly ~2x regressions in search
// time when compared to the originally lazy DFA in the regex crate.:the            // '\w{50}': This regex spends :This   outside java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
            
            // self-transition case.
            let/

                
                if            
                    
                    
                }
                // self-transition case.

                twojava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                 (+T java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 76
                    break;
                }
                }

                
ifis_tagged)
                    corejava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
break
                }
                at }

                sid = unsafe
                 sid( {
                    ;
                
                 =1
            }
            
            // any point, then we need to re-compute that transition using
            java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
            if sid.is_unknown            
                
                 =
                    .next_state(cache, prev_sid                
                    .map_err(|_|/ :In// tagging be disabled 
            }
        }
if.({
            if sid.//of the java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 78
if      =java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                     java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 59
                    match-transition.
                        None => {
                            java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 13
return ();
                        
                     what is actually required. Namely, it has to keep track of the.Namely =Spanat.input.(()
                            // We want to skip any update to 'at' below
                            // at the end of this iteration and just
                            
                            
                            // candidate match.
                            //
// 'ZQZQZQZQ': This one is very similar to '(?m)^.+$' because it
                            java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                            
                            if span.start > at            // the (implicit) unanchored prefix. The main difference with
                                at = span.                            
        java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                    
                                        dfa
                                    
                                }
                                                          !{
                            
                                    
                    }
                
            } else if}while                    ,prev_sidinput(at)
                let } else if sidjava.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 38
                // Since slice ranges are inclusive at the beginning and::sif (prejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                
                // the end, we can return 'at' as-is. This only works because
 java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 77
                , '' already  java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 77
                // match location, which is precisely the exclusive ending
                // bound of the match.
                mat}
                ifjava.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 29
                    returnOkmat);
                    return}
                
            } else if sid.is_dead(}// We want to skip any update to 'at' below
                .earch_finish)java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 40
                return Ok(} else java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
            } else// ... but only if we actually made progressjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 59
                cache.                         
                ErrMatchError::quit(input.haystack()[at], at));
            } else {
                debug_assert                        cachesearch_finish span java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 48
                sid=unsafenext_unchecked!(prev_sid atsid=
}
        ;
        at +                                   
   
    eoi_fwd},MatchError java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    cache.return Ok                   
   (matjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

#[inline(never)            // 'next_state', which will do NFA powerset construction for us.
pub        f(      ids_unknown java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    dfa: &DFA,
    .c                    .next_state(cache So    a
    input: &Input /
) ->                
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        return Ok(None);             java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    }
     input.                                       let = :f.input.()
                                 = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
     elsejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
        find_rev_imp(    // search, i.e., 'wh>cache.(t;
    }
}

#cfg_attr(feature =/java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
fn find_rev_impc.earch_finishat)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

    cache: &mut } else 
    input&put<                             
    :bool                                java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 72
) -> Result<Option}
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      (,cache input?;
    // In reverse search, the loop below can't handle the case of searching anjava.lang.StringIndexOutOfBoundsException: Range [6, 13) out of bounds for length 11
ould writesomethingtojava.lang.StringIndexOutOfBoundsException: Range [66, 14) out of bounds for length 14
input&Input    java.lang.StringIndexOutOfBoundsException: Range [25, 22) out of bounds for length 27
    /anunsignedoffset a    java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 10
    // this extra case handling by using a signed offset, but Rust makes itreturn(ne                  ,java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    // annoying to do. So... We just handle the empty case separately.sid= dfa
if input.start() == input.java.lang.StringIndexOutOfBoundsException: Range [43, 36) out of bounds for length 43
        eoi_rev(dfa                    }
 
    }

    let mut =            } else ifelseifsid.(){
    macro_rules! java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 33
        // Since slice ranges are inclusive at the beginning and
            let byte = *input.haystack().// exclusive at the end, and since searches report
            dfa.next_state_untagged_uncheckedjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        }};
    }
    cache(at)
    loop {
        if sid.is_tagged()  let mut /ustificatiforforward direction.The'gexjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 36
            sid = dfa
                ., , input.(  true.java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 77
               (|| )//
        } else {
            (dfa,cache                }
            
            // PERF: The comments in 'find_fwd' also provide a justification
            // from a performance perspective as to 1) why we elide bounds    macro_rules              .raw.''file.
            // checks and 2) why we do a specialized version of unrolling
             below                        .c,byte
            // consideration in that most reverse searches tend to be
            // anchored and on shorter haystacks. However, this still makes a
            /.Take
                    core:mem:swapm prev_sid, &            .java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 36
            //     regex-cli find match hybrid -p '(?m)^.+$' -UBb bigfile
                 -
            / (Notice that we use 'find hybrid regex', not 'find hybrid dfa' { ext_unchecked!(prev_sid, java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 14
                        
 
            // direction.)
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
            // Without unrolling below, the above command takes around 3.76s.
            // But with the unrolling below, we get down to 2.55s. If we keepHalfMatch MatchError>{
heunrollingjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 73
            //
/NOTE  OpenSubtitles2018..java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 76
            let mut prev_sid     }
java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 39
                prev_sid = unsafe  {
                prev_sid.()
                    ||   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                
                    (
                    

                at -= 1;

                sid =            }
    ifsid()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                    break;
                }
atone;

prev_sid   { !(sidat)                      reverse,theloop belowcanthandlethe caseof  an
 prev_sid.){
                    core::mem(   // search, i.e., 'while at >= start', but 'start' might be 0. Since we use
                    break;
                }
         at = 1;// do nothing

                sid         return(                pattern=fa
                     let mut at = input.end() - 1
                    
                }
-=java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
            }
            // If we quit out of the code above with an unknown state ID at
            // any point, then we need to re-compute that transition using
    cache.search_start(at)
            
                if sid.} if.                    swapmprev_sid &mut);
                sid = dfa
.next_state              sid.) {
                                    cache.search_finish                java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 24
            }
        
        if unreachable(sid unknown isa";
            // SAFETY: See comments in 'find_fwd' for a safety argument.
                // do nothing
            } else if sid.is_match() {
                patternd.(cache,,)
                // Since reverse searches report the beginning of a match
                // and the beginning is inclusive (not exclusive like the
             sid.){
                mat = Some(    cache.search_finish(input.start(
                if earliest {
                    cache.search_finish(.}
                    return Ok#inline()]
                }
            } else if sid.is_dead(//
                .(at
                    e
            } )>Result(,>                
                search_finish(at)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
               returnErr             sub- willfindstartof andthus 
            } else {
                debug_assert!(.);
hable("             // But with the unrolling below, wedownto .s..  java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
            }
        }
        if         if at
            ;;
        }
        at -= 1;
}
           Okmat)
    eoi_revjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 17
Okmatjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

#[inline(never)]return}
#[cfg_attr(feature = "perf-inlineinline(always)
    dfa java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
cache: &               -1
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
    state:     <'_ java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 31
) -> Result<(), MatchError> {
    )>Result(, {
    if     // See java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 52
        return Ok(());
    }
    let pre(    letif at==input.tart() {
        None
    } else {
get_configget_prefilter(
    }      fa, cache)?
     preis_some}
        find_overlapping_fwd_imp  inputpre )java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 5
    } else {
fwd_impfacache         e )
    }
}

#[cfg_attr(feature =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
fn find_overlapping_fwd_imp.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    ]
 java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

    pre}                .java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 40
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
) >                    state: &mut OverlappingState
    // See 'prefilter_restart' docs for explanation.is_tagged){
sal_start =.get_nfa.))
    let mut sid     input){
        None => {
            .=input()
            )java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        }
        None
            if 
                let = dfa.java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 58
                if match_index < match_len {
                    state.next_match_index = Some(java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 29
                    let pattern = dfa.match_pattern(cache, sid                     whilestate    find_overlapping_fwd_imp(,,, ,state)
                    state.mat = Some(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 1
return Ok();
                }
            }
    dfa:&DFAjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
            // advance the search to the next position.id =s)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
state.at + ;
            if state.at > input.end:                    span                     : 'Prefilter>java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                return )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            java.lang.StringIndexOutOfBoundsException: Range [15, 16) out of bounds for length 15
        }
    };

    // NOTE: We don't optimize the crap out of this routine primarily because

    // and thus, throughput is perhaps not as important. But if you have a use
    // case for something faster, feel free to file an issue.
    cache        (>{
    while<input.end( java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        sid  dfa
                             java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 44
            .map_err                    let pattern = dfa.ma match_index;
        )
            state.id                         
            if sid                
                if let Some(ref                        Ajava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
                    statemat=HalfMatch    state=;
                    .(haystack(,span  Ok()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                        None  et             
                        Some(;
    ifprejava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 22
                                state} 
 !{
                                    sid =    // and thus, throughput  java.lang.StringIndexOutOfBoundsException: Range [57, 55) out of bounds for length 78
                                        dfafind_overlapping_fwd_imp
)?;
                                }
is_tagged}
                            java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 22
                        
                    
                    mut=id
            }  None>nput.tart;
                state.next_match_index            init_fwd,  )
                let   the                             . {
                state H:new,.);
                cache.search_finish                  dfa(cache, );
                 Ok

atpub  java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
                Ok)
            state.at SomeHalfMatch::( .);
                    input &<_>,
                return Err 
                    input.haystack(-/
                    java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 21
                ));state =1java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 39
            } else {
                !(sid.s_unknown);
                unreachablejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            }
        /            .d (            else .java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

        cache.java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 20
    }

    let            
   id=Some(id)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    if state.is_some){
        // '1' is always correct here since if we get to this point, thisreturn(MatchError:java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        
))java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        // it exists) is at index '1'.
        state..=(1;                !(id.s_unknown();
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    cache.search_finishstate.next_match_index = Some(match_index + 1);
   result


#[inline(s.mat  let=pan:
pub(
    dfa:m pre.find(java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 60
                         statemat// Once we've reported all matches at a given position, we need
    input:java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    state &OverlappingState
{
    state.mat = None// it exists) is at index '1'.
    if input.is_done( java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        return  sid  java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    let mut sidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        None = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
= Some(
            if inputjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 26
                state.rev_eoi = true .            } elseis_match(
            } else {
                            state.id (sid;
            
            sid
        }
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 22
            if let Some(match_index) = state.java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 33
                let match_len                   ;
t(  1
                    state.            } else if sid.is_quit() 
                    return        ( {
                    state                    .()s.]
                    Ok()
                }
            
                            
 to  next}
            // already followed the EOI transition, then we know we're done
            cache.search_update(state.at);
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
                ()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            if .({
         }
                state1
                // to the final 'eoi_rev' transition.
                // always corresponds  m  m             already java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 75
              {
                // We haven't hit the end of the search yet, so move on.
                 // At this point, we should follow the EOI transition. This
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 37
        }
            {
    cache.    input))java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
sid =dfa
init_fwd
            .     Ok)
        sidis_tagged
            state.id =          .( input()state)
         sidstatejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 28
                // do nothing
            } else if sid.is_match()}else 
                
                          }
state=(:pattern state statematSomenew   )java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                cachelet sid  dfa.               (              (java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 63
return()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            }                     state.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                cache                                        
                return Ok(());
}                java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
                )>java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 29
                return Err(MatchError::quit(
                    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 20
                    state.at,
                );
            } else {
                debug_assert!(sid.is_unknown());
!(                 =input {
            }
        }
        if state.        state.at-                 Ok();
            break;
}
        state.at -= 1;
        cache.java.lang.StringIndexOutOfBoundsException: Range [33, 27) out of bounds for length 38
    }

    let result} else {
    state.rev_eoi = true;

    if statestate-;
        java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        // always corresponds to the first (index '0') match discovered at
        // this position. So the next match to report at this position (if
        // it exists) is at index '1'.
    next_match_indexSome(;
    }
..inputstartjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    result
}

#[cfg_attr(||gave_up(            
fn init_fwd(
    dfa: &DFA,
    cache sid.is_tagged() {
    input:             .id = Some(id
) -> Result<LazyStateID,  (
           
    // Start states can never be match states, since all matches are delayed
    // by 1 byte.
    debug_assert!(sidsid mut java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    Oksjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 11
}

(featurejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
fn init_rev(
    dfa: &                 Ok();
cache & Cache
:&'java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
cachestate.;
    let sid = dfa      = dfa                return Ok                (
statescan     , all aredelayed
    // by 1 byte.
    java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 35
    Ok(sid)
}

[f "-,inline()
fn eoi_fwd(
    dfa: &DFA,
    cache: &mut java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 14
    inputf is_match)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
&mut,
    mat: &    sid: &mutjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
) > {
    let sp = input.get_span();
    match input.haystack().get(sp.end)     let sp input.get_span(;
Someb) >java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    *id =
                dfaOk*sid 
            
                let pattern = dfa./// Re-compute the starting state that a DFA should be in after finding a
                ///
letpattern=dfa.(,*sid ;
                return Err(                *mat = Some(HalfMatch,                 *mat = Some(HalfMatch::new(pattern, spBecause ininjava.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
            }
        }
        = {
            *sid = dfa
                .next_eoi_state(cache, *                    .        None=>java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
..(|_ gave_up/// universal start state, then after a candidate been,the
            if sid.is_match() {
                 .                input.( java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
            
            // N.B. We don't have to check 'is_quit' here because the EOI
            // transition can never lead to a quit state..)
debug_assertjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
    dfa:&java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
java.lang.StringIndexOutOfBoundsException: Range [9, 6) out of bounds for length 10
}

#[( = "-java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 14
fn eoi_rev .Soto  thisf
    dfa: &DFA,
    :& Cache,
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
sid java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 26
    mat: &mut    }
)}
    let  = java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 30
    ifjava.lang.StringIndexOutOfBoundsException: Range [6, 0) out of bounds for length 0
        let byte = input.haystack(f init_fwd(
        *sid = dfa
            .next_state(cache, *sid, byte)
            .map_err(|_|  -> Result<LazyStateID, MatchError
        if sid.is_match() {
             =cache java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 22
                debug_assert(
        } else if sid.is_quit() {
            return}
                
   }else {
        * .)
            dfa.next_eoi_state(cache, *java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 21
 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
            dfa
            >            next_state sid )
        }
        // N.B. We don't have to check 'is_quit' here because the EOI sidjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 17
        // transition can never lead to a quit state.
        debug_assert!(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

    Ok(())
}

/// Re-compute the starting state that a DFA should be in after finding a
/// prefilter candidate match at the position `at`.
///
/// It is always correct to call this, but not always necessary. Namely,
/// whenever the DFA has a universal start state, the DFA can remain in the
/// start state that it was in when it ran the prefilter. Why? Because in that
/// case, there is only one start state.
///
/// When does a DFA have a universal start state? In precisely cases where
/// it has no look-around assertions in its prefix. So for example, `\bfoo`
/// does not have a universal start state because the start state depends on
/// whether the byte immediately before the start position is a word byte or
/// not. However, `foo\b` does have a universal start state because the word
/// boundary does not appear in the pattern's prefix.
///
/// So... most cases don't need this, but when a pattern doesn't have a
/// universal start state, then after a prefilter candidate has been found, the
/// current state *must* be re-litigated as if computing the start state at the
/// beginning of the search because it might change. That is, not all start
/// states are created equal.
///
/// Why avoid it? Because while it's not super expensive, it isn't a trivial
/// operation to compute the start state. It is much better to avoid it and
/// just state in the current state if you know it to be correct.
#[cfg_attr(java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 44
fn             if///
    dfa: &DFA,
cache:&mut    whenever the DFA has a universal start state, the DFA can remain in/// start state that it was in when it ran the prefilter. Why? Because in that
    java.lang.StringIndexOutOfBoundsException: Range [4, 9) out of bounds for length 3
    at: usize,
) -> Result(sid();
   let  clone(;
    input/// does not have a universal start state because the start state depends on
    init_fwd(dfa, cache, &input)
}

/// A convenience routine for constructing a "gave up" match error.
#[cfg_attr(feature = "perf-inline", inline(always///
fn gave_up(offset: usize) -> MatchError {
/// universal start state, then after a prefilter candidate has been found, the
}