Find multiple matches on the same line.

src/editor.rs

@@ -663,25 +663,28 @@
     }
 
     /// Try to find a query, this is called after pressing Ctrl-F and for each key that is pressed.
-    /// `last_match` is the last row that was matched, `forward` indicates whether to search forward
-    /// or backward. Returns the row of a new match, or `None` if the search was unsuccessful.
+    /// `q` represents the query, `lst` is the last position that was matched, `fw` indicates
+    /// whether to search forward or backward. Returns the position of a new match, or `None`
+    /// if the search was unsuccessful.
     #[allow(clippy::trivially_copy_pass_by_ref)] // This Clippy recommendation is only relevant on 32 bit platforms.
-    fn find(&mut self, query: &str, last_match: &Option<usize>, forward: bool) -> Option<usize> {
+    fn find(&mut self, q: &str, lst: &Option<(usize, usize)>, fw: bool) -> Option<(usize, usize)> {
         let num_rows = self.rows.len();
-        let mut current = last_match.unwrap_or_else(|| num_rows.saturating_sub(1));
-        // TODO: Handle multiple matches per line
-        for _ in 0..num_rows {
-            current = (current + if forward { 1 } else { num_rows - 1 }) % num_rows;
-            let row = &mut self.rows[current];
-            if let Some(cx) = slice_find(&row.chars, query.as_bytes()) {
-                // self.cursor.coff: Try to reset the column offset; if the match is after the offset, this
-                // will be updated in self.cursor.scroll() so that the result is visible
-                (self.cursor.x, self.cursor.y, self.cursor.coff) = (cx, current, 0);
-                let rx = row.cx2rx[cx];
-                row.match_segment = Some(rx..rx + query.len());
-                return Some(current);
+        let mut cur = lst.unwrap_or_else(|| (usize::MAX, num_rows.saturating_sub(1)));
+        while {
+            // TODO: add find backwards on the same line
+            let row = &mut self.rows[cur.1];
+            let slice = if cur.0 == usize::MAX { &row.chars[..] } else { &row.chars[cur.0 + 1..] };
+            if let Some(cx) = slice_find(slice, q.as_bytes()) {
+                cur.0 = if cur.0 == usize::MAX { cx } else { cur.0 + cx + 1 };
+                (self.cursor.x, self.cursor.y, self.cursor.coff) = (cur.0, cur.1, 0);
+                let rx = row.cx2rx[cur.0];
+                row.match_segment = Some(rx..rx + q.len());
+                return Some(cur);
             }
-        }
+            cur = (usize::MAX, (cur.1 + if fw { 1 } else { num_rows - 1 }) % num_rows);
+            // if it wrapped back to the starting line
+            cur.1 != lst.map_or(num_rows.saturating_sub(1), |lst| lst.1)
+        } {}
         None
     }
 
@@ -736,7 +739,7 @@
     /// Save(prompt buffer)
     Save(String),
     /// Find(prompt buffer, saved cursor state, last match)
-    Find(String, CursorState, Option<usize>),
+    Find(String, CursorState, Option<(usize, usize)>),
     /// GoTo(prompt buffer)
     GoTo(String),
     /// Execute(prompt buffer)
@@ -766,7 +769,7 @@
                 PromptState::Completed(file_name) => ed.save_as(file_name)?,
             },
             Self::Find(b, saved_cursor, last_match) => {
-                if let Some(row_idx) = last_match {
+                if let Some((_, row_idx)) = last_match {
                     ed.rows[row_idx].match_segment = None;
                 }
                 match process_prompt_keypress(b, key) {