Fix a bug in capture with match

Fixes rust-lang#557

Author: hikotq

src/backtrack.rs

@@ -98,6 +98,7 @@ impl<'a, 'm, 'r, 's, I: Input> Bounded<'a, 'm, 'r, 's, I> {
         slots: &'s mut [Slot],
         input: I,
         start: usize,
+        end: usize, 
     ) -> bool {
         let mut cache = cache.borrow_mut();
         let cache = &mut cache.backtrack;
@@ -109,7 +110,7 @@ impl<'a, 'm, 'r, 's, I: Input> Bounded<'a, 'm, 'r, 's, I> {
             slots: slots,
             m: cache,
         };
-        b.exec_(start)
+        b.exec_(start, end)
     }
 
     /// Clears the cache such that the backtracking engine can be executed
@@ -147,7 +148,7 @@ impl<'a, 'm, 'r, 's, I: Input> Bounded<'a, 'm, 'r, 's, I> {
 
     /// Start backtracking at the given position in the input, but also look
     /// for literal prefixes.
-    fn exec_(&mut self, mut at: InputAt) -> bool {
+    fn exec_(&mut self, mut at: InputAt, end: usize) -> bool {
         self.clear();
         // If this is an anchored regex at the beginning of the input, then
         // we're either already done or we only need to try backtracking once.
@@ -170,7 +171,7 @@ impl<'a, 'm, 'r, 's, I: Input> Bounded<'a, 'm, 'r, 's, I> {
             if matched && self.prog.matches.len() == 1 {
                 return true;
             }
-            if at.is_end() {
+            if at.pos() == end {
                 break;
             }
             at = self.input.at(at.next_pos());

src/exec.rs

@@ -10,7 +10,6 @@
 
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::cmp;
 use std::sync::Arc;
 
 use thread_local::CachedThreadLocal;
@@ -877,13 +876,7 @@ impl<'c> ExecNoSync<'c> {
         match_start: usize,
         match_end: usize,
     ) -> Option<(usize, usize)> {
-        // We can't use match_end directly, because we may need to examine one
-        // "character" after the end of a match for lookahead operators. We
-        // need to move two characters beyond the end, since some look-around
-        // operations may falsely assume a premature end of text otherwise.
-        let e = cmp::min(
-            next_utf8(text, next_utf8(text, match_end)), text.len());
-        self.captures_nfa(slots, &text[..e], match_start)
+        self.captures_nfa_type_with_end(MatchNfaType::Auto, slots, text, match_start, match_end)
     }
 
     /// Like find_nfa, but fills in captures.
@@ -905,8 +898,19 @@ impl<'c> ExecNoSync<'c> {
         slots: &mut [Slot],
         text: &[u8],
         start: usize,
+        ) -> Option<(usize, usize)>{
+        self.captures_nfa_type_with_end(ty, slots, text, start, text.len())
+    }
+
+    fn captures_nfa_type_with_end(
+        &self,
+        ty: MatchNfaType,
+        slots: &mut [Slot],
+        text: &[u8],
+        start: usize,
+        end: usize, 
     ) -> Option<(usize, usize)> {
-        if self.exec_nfa(ty, &mut [false], slots, false, text, start) {
+        if self.exec_nfa_with_end(ty, &mut [false], slots, false, text, start, end) {
             match (slots[0], slots[1]) {
                 (Some(s), Some(e)) => Some((s, e)),
                 _ => None,
@@ -917,13 +921,26 @@ impl<'c> ExecNoSync<'c> {
     }
 
     fn exec_nfa(
+        &self,
+        ty: MatchNfaType,
+        matches: &mut [bool],
+        slots: &mut [Slot],
+        quit_after_match: bool,
+        text: &[u8],
+        start: usize,
+    ) -> bool {
+        self.exec_nfa_with_end(ty, matches, slots, quit_after_match, text, start, text.len())
+    }
+    
+    fn exec_nfa_with_end(
         &self,
         mut ty: MatchNfaType,
         matches: &mut [bool],
         slots: &mut [Slot],
         quit_after_match: bool,
         text: &[u8],
         start: usize,
+        end: usize, 
     ) -> bool {
         use self::MatchNfaType::*;
         if let Auto = ty {
@@ -935,10 +952,10 @@ impl<'c> ExecNoSync<'c> {
         }
         match ty {
             Auto => unreachable!(),
-            Backtrack => self.exec_backtrack(matches, slots, text, start),
+            Backtrack => self.exec_backtrack(matches, slots, text, start, end),
             PikeVM => {
                 self.exec_pikevm(
-                    matches, slots, quit_after_match, text, start)
+                    matches, slots, quit_after_match, text, start, end)
             }
         }
     }
@@ -951,6 +968,7 @@ impl<'c> ExecNoSync<'c> {
         quit_after_match: bool,
         text: &[u8],
         start: usize,
+        end: usize, 
     ) -> bool {
         if self.ro.nfa.uses_bytes() {
             pikevm::Fsm::exec(
@@ -960,7 +978,8 @@ impl<'c> ExecNoSync<'c> {
                 slots,
                 quit_after_match,
                 ByteInput::new(text, self.ro.nfa.only_utf8),
-                start)
+                start,
+                end)
         } else {
             pikevm::Fsm::exec(
                 &self.ro.nfa,
@@ -969,7 +988,8 @@ impl<'c> ExecNoSync<'c> {
                 slots,
                 quit_after_match,
                 CharInput::new(text),
-                start)
+                start,
+                end)
         }
     }
 
@@ -980,6 +1000,7 @@ impl<'c> ExecNoSync<'c> {
         slots: &mut [Slot],
         text: &[u8],
         start: usize,
+        end: usize
     ) -> bool {
         if self.ro.nfa.uses_bytes() {
             backtrack::Bounded::exec(
@@ -988,15 +1009,15 @@ impl<'c> ExecNoSync<'c> {
                 matches,
                 slots,
                 ByteInput::new(text, self.ro.nfa.only_utf8),
-                start)
+                start, end)
         } else {
             backtrack::Bounded::exec(
                 &self.ro.nfa,
                 self.cache,
                 matches,
                 slots,
                 CharInput::new(text),
-                start)
+                start, end)
         }
     }
 

src/pikevm.rs

@@ -107,6 +107,7 @@ impl<'r, I: Input> Fsm<'r, I> {
         quit_after_match: bool,
         input: I,
         start: usize,
+        end: usize, 
     ) -> bool {
         let mut cache = cache.borrow_mut();
         let cache = &mut cache.pikevm;
@@ -124,6 +125,7 @@ impl<'r, I: Input> Fsm<'r, I> {
             slots,
             quit_after_match,
             at,
+            end, 
         )
     }
 
@@ -135,6 +137,7 @@ impl<'r, I: Input> Fsm<'r, I> {
         slots: &mut [Slot],
         quit_after_match: bool,
         mut at: InputAt,
+        end: usize, 
     ) -> bool {
         let mut matched = false;
         let mut all_matched = false;
@@ -212,7 +215,7 @@ impl<'r, I: Input> Fsm<'r, I> {
                     }
                 }
             }
-            if at.is_end() {
+            if at.pos() == end {
                 break;
             }
             at = at_next;