regex.pcre: add non-greedy quantifiers like *?, +?, ?? (fix #26579) (#26582)

Author: penguindark

vlib/regex/pcre/README.md

@@ -16,6 +16,7 @@ and iterative searching.
 | **Wildcard** | `.` | Matches any character (excluding `\n` unless `(?s)` flag is used). |
 | **Alternation** | `|` | Matches the left OR right expression (e.g., `cat|dog`). |
 | **Quantifiers** | `*` | Matches 0 or more times. |
+| **Non-greedy quantifiers** | `*?`, `+?`, `??` | Avoid to consume as much as possible. |
 | | `+` | Matches 1 or more times. |
 | | `?` | Matches 0 or 1 time. |
 | | `{m}` | Matches exactly `m` times. |
@@ -244,6 +245,26 @@ println(year) // Output: 2025
 
 ## Advanced Usage
 
+### Non-greedy Matching
+By default, quantifiers like `*` and `+` are **greedy**, meaning they match
+as much text as possible. Adding a `?` makes them **non-greedy** (or lazy), 
+matching the shortest possible string.
+
+**Example:**
+```v
+import regex.pcre
+
+text := '<div>content</div>'
+
+// Greedy: Matches everything from the first '<' to the last '>'
+r_greedy := pcre.compile(r'<.*>')!
+println(r_greedy.find(text)?.text) // Output: <div>content</div>
+
+// Non-greedy: Matches only until the first '>'
+r_lazy := pcre.compile(r'<.*?>')!
+println(r_lazy.find(text)?.text) // Output: <div>
+```
+
 ### VM Stability (No Stack Overflow)
 Because this engine uses a VM with a heap-allocated stack, it can handle patterns that typically
 crash recursive engines due to stack overflow.

vlib/regex/pcre/regex.v

@@ -1,5 +1,5 @@
 /*
-regex2 0.9.2 beta (VM Edition)
+regex2 0.9.3 beta (VM Edition)
 
 Copyright (c) 2026 Dario Deledda. All rights reserved.
 Use of this source code is governed by an MIT license
@@ -12,6 +12,7 @@ Features:
  - UTF8 support
  - Literal characters, '.', '*', '{m,n}'
  - Short quantifiers: '?', '+'
+ - Non-greedy quantifiers: '*?', '+?', '??'
  - Nested groups: '()'
  - Named groups: '(?P<name>...)'
  - Non-capturing groups: '(?:...)'
@@ -112,31 +113,14 @@ pub:
 	groups []string
 }
 
-// get retrieves the captured text by index.
-// Index 0 returns the whole match, 1+ returns capture groups.
-pub fn (m Match) get(idx int) ?string {
-	if idx == 0 {
-		return m.text
-	}
-	if idx > 0 && idx <= m.groups.len {
-		return m.groups[idx - 1]
-	}
-	return none
-}
-
-// get_all returns the whole match followed by all capture groups.
-pub fn (m Match) get_all() []string {
-	mut res := [m.text]
-	res << m.groups
-	return res
-}
-
 // --- AST Nodes ---
 
 // Quantifier represents a repetition range.
 struct Quantifier {
-	min int
-	max int // -1 for infinity
+mut:
+	min    int
+	max    int  // -1 for infinity
+	greedy bool // true = greedy, false = lazy
 }
 
 // Flags holds the current state of regex options.
@@ -260,8 +244,9 @@ pub fn compile(pattern string) !Regex {
 		nodes:               nodes
 		group_capture_index: -1
 		quant:               Quantifier{
-			min: 1
-			max: 1
+			min:    1
+			max:    1
+			greedy: true
 		}
 	}
 
@@ -280,13 +265,6 @@ pub fn compile(pattern string) !Regex {
 	}
 }
 
-// new_regex is an alias for compile, for compatibility with older PCRE wrappers.
-// Note: The second argument (flags) is currently ignored as flags should be
-// embedded in the pattern (e.g., '(?i)pattern').
-pub fn new_regex(pattern string, _ int) !Regex {
-	return compile(pattern)
-}
-
 // Compiler manages the state of the bytecode generation process.
 struct Compiler {
 mut:
@@ -314,23 +292,46 @@ fn (mut c Compiler) emit_node(node Node) {
 		c.emit_single_node_logic(node)
 
 		c.emit(Inst{ typ: .jmp, target_x: split_idx })
-		c.prog[split_idx].target_x = start_pc
-		c.prog[split_idx].target_y = c.prog.len
+
+		// In this VM, target_x is the first path taken (stack.pop order depends on implementation,
+		// but standard here is target_x executed immediately, target_y pushed to stack).
+		// Greedy: Prefer matching loop (start_pc) over exit.
+		// Lazy: Prefer exit over matching loop.
+		if node.quant.greedy {
+			c.prog[split_idx].target_x = start_pc // Loop
+			c.prog[split_idx].target_y = c.prog.len // Exit
+		} else {
+			c.prog[split_idx].target_x = c.prog.len // Exit
+			c.prog[split_idx].target_y = start_pc // Loop
+		}
 	} else if node.quant.max > node.quant.min {
 		// Finite range
 		rem := node.quant.max - node.quant.min
 		mut splits := []int{}
 
 		for _ in 0 .. rem {
 			idx := c.emit(Inst{ typ: .split })
-			c.prog[idx].target_x = c.prog.len
+			match_pc := c.prog.len
+
+			// If greedy, we prefer to match the node (continue execution)
+			// If lazy, we prefer to skip the match (jump to end)
+			if node.quant.greedy {
+				c.prog[idx].target_x = match_pc // Match node
+			} else {
+				c.prog[idx].target_y = match_pc // Match node (fallback)
+			}
+
 			c.emit_single_node_logic(node)
 			splits << idx
 		}
 
 		end_pc := c.prog.len
 		for idx in splits {
-			c.prog[idx].target_y = end_pc
+			if node.quant.greedy {
+				c.prog[idx].target_y = end_pc // Skip match (fallback)
+			} else {
+				c.prog[idx].target_x = end_pc // Skip match (primary)
+			}
 		}
 	}
 }
@@ -467,7 +468,7 @@ fn parse_nodes(pattern string, pos_start int, terminator rune, group_counter_sta
 					Node{
 						typ:          .alternation
 						alternatives: alternatives
-						quant:        Quantifier{1, 1}
+						quant:        Quantifier{1, 1, true}
 					},
 				], pos, group_counter
 			}
@@ -714,20 +715,20 @@ fn parse_nodes(pattern string, pos_start int, terminator rune, group_counter_sta
 		}
 
 		if parsed_nodes.len > 0 {
-			mut q := Quantifier{1, 1}
+			mut q := Quantifier{1, 1, true}
 			if pos < pattern.len {
 				peek, pl := read_rune(pattern, pos)
 				match peek {
 					`*` {
-						q = Quantifier{0, -1}
+						q = Quantifier{0, -1, true}
 						pos += pl
 					}
 					`+` {
-						q = Quantifier{1, -1}
+						q = Quantifier{1, -1, true}
 						pos += pl
 					}
 					`?` {
-						q = Quantifier{0, 1}
+						q = Quantifier{0, 1, true}
 						pos += pl
 					}
 					`{` {
@@ -751,11 +752,21 @@ fn parse_nodes(pattern string, pos_start int, terminator rune, group_counter_sta
 								-1
 							}
 						}
-						q = Quantifier{min, max}
+						q = Quantifier{min, max, true}
 						pos = end_q + 1
 					}
 					else {}
 				}
+
+				// Check for Non-Greedy modifier '?'
+				// e.g. *?, +?, ??, {m,n}?
+				if pos < pattern.len {
+					peek_lazy, pl_lazy := read_rune(pattern, pos)
+					if peek_lazy == `?` {
+						q.greedy = false
+						pos += pl_lazy
+					}
+				}
 			}
 			parsed_nodes[parsed_nodes.len - 1].quant = q
 		}
@@ -772,7 +783,7 @@ fn parse_nodes(pattern string, pos_start int, terminator rune, group_counter_sta
 			Node{
 				typ:          .alternation
 				alternatives: alternatives
-				quant:        Quantifier{1, 1}
+				quant:        Quantifier{1, 1, true}
 			},
 		], pos, group_counter
 	}
@@ -1185,7 +1196,39 @@ pub fn (r Regex) find_from(text string, start_index int) ?Match {
 	return none
 }
 
+/******************************************************************************
+*
+* C PCRE compatibility layer
+*
+******************************************************************************/
+
+// new_regex is an alias for compile, for compatibility with older PCRE wrappers.
+// Note: The second argument (flags) is currently ignored as flags should be
+// embedded in the pattern (e.g., '(?i)pattern').
+pub fn new_regex(pattern string, _ int) !Regex {
+	return compile(pattern)
+}
+
 // match_str is an alias for find_from, for compatibility with older PCRE wrappers.
 pub fn (r Regex) match_str(text string, start_index int, _ int) ?Match {
 	return r.find_from(text, start_index)
 }
+
+// get retrieves the captured text by index.
+// Index 0 returns the whole match, 1+ returns capture groups.
+pub fn (m Match) get(idx int) ?string {
+	if idx == 0 {
+		return m.text
+	}
+	if idx > 0 && idx <= m.groups.len {
+		return m.groups[idx - 1]
+	}
+	return none
+}
+
+// get_all returns the whole match followed by all capture groups.
+pub fn (m Match) get_all() []string {
+	mut res := [m.text]
+	res << m.groups
+	return res
+}

vlib/regex/pcre/regex_test.v

@@ -520,3 +520,117 @@ fn tst_compile_error(pattern string) {
 	println('Error: Did not get a compilation error!')
 	assert false
 }
+
+fn test_non_greedy_quantifiers() {
+	println('\n--- Testing Non-Greedy Quantifiers (*?, +?, ??, {m,n}?) ---')
+
+	// 1. Lazy Star (*?)
+	// Should stop at the first closing '>' (minimal match)
+	tst_find(r'<.*?>', '<div>content</div>', '<div>')
+	// Contrast with greedy (default) which consumes until the last '>'
+	tst_find(r'<.*>', '<div>content</div>', '<div>content</div>')
+
+	// 2. Lazy Plus (+?)
+	// Should match minimal characters (1 'a') to satisfy the constraint
+	tst_find(r'a+?', 'aaaaa', 'a')
+	// Forced expansion: Must match all 'a's to finally match 'b' (backtracking test)
+	tst_find(r'a+?b', 'aaab', 'aaab')
+
+	// 3. Lazy Question Mark (??)
+	// Should match empty string (prefers 0 occurrences over 1)
+	tst_find(r'a??', 'a', '')
+	// Contextual: 'u' is lazy (prefers skip), matches 'color' immediately
+	tst_find(r'colou??r', 'color', 'color')
+	// Contextual: 'u' is lazy, tries skip, fails to match 'r', backtracks to match 'u'
+	tst_find(r'colou??r', 'colour', 'colour')
+
+	// 4. Lazy Range ({m,n}?)
+	// Should match minimum required (2 digits)
+	tst_find(r'\d{2,5}?', '123456789', '12')
+	// Contrast with greedy which matches maximum (5 digits)
+	tst_find(r'\d{2,5}', '123456789', '12345')
+
+	// 5. Complex/Real-world Case (User report)
+	// Escaped characters + lazy capture group
+	// Should match only '$t(common.hello)', not the span to the second ')'
+	tst_find(r'\$t\((.*?)\)', r'$t(common.hello) dear $t(common.name)', r'$t(common.hello)')
+
+	// --- Negative / Edge Cases ---
+
+	// Lazy quantifier with no termination in string should match nothing/min if possible,
+	// but since it's "find", it grabs the first valid match.
+	tst_find(r'x.*?y', 'x123y456y', 'x123y') // Stops at first y
+
+	// Anchor interaction: ^.*?b
+	// Matches from start, .*? expands lazily until it hits 'b'
+	tst_find(r'^.*?b', '123b', '123b')
+
+	// Ensure lazy doesn't cause failure when a greedy match would succeed (correct backtracking)
+	// Pattern wants to match "a" lazily, but must consume "a" to satisfy the final "a"
+	tst_find(r'a?a', 'a', 'a')
+	tst_find(r'a??a', 'a', 'a')
+}
+
+fn test_compatibility_layer() {
+	// Test new_regex (alias for compile)
+	// Passing '0' as the second argument to simulate the ignored C-flag argument
+	pattern := r'(\w+)\s+(\d+)'
+	re := pcre.new_regex(pattern, 0) or {
+		assert false, 'new_regex failed to compile: ${err}'
+		return
+	}
+
+	text := 'item 42 ignored item 99'
+
+	// Test match_str (alias for find_from)
+	// We start searching from index 0. The third argument '0' is the ignored option flag.
+	// This should match "item 42"
+	m1 := re.match_str(text, 0, 0) or {
+		assert false, 'match_str failed to find match'
+		return
+	}
+
+	// Test get()
+	// Index 0 should be the full text of the match
+	full_match := m1.get(0) or { '' }
+	assert full_match == 'item 42'
+
+	// Index 1 should be the first capture group (\w+)
+	group_1 := m1.get(1) or { '' }
+	assert group_1 == 'item'
+
+	// Index 2 should be the second capture group (\d+)
+	group_2 := m1.get(2) or { '' }
+	assert group_2 == '42'
+
+	// Index 3 should be none (out of bounds)
+	if _ := m1.get(3) {
+		assert false, 'get(3) should return none for 2 groups'
+	}
+
+	// Test get_all()
+	// Should return ['item 42', 'item', '42']
+	all_captures := m1.get_all()
+	assert all_captures.len == 3
+	assert all_captures[0] == 'item 42'
+	assert all_captures[1] == 'item'
+	assert all_captures[2] == '42'
+
+	// Test match_str with a specific start index
+	// Start searching after "item 42" (length is 7)
+	// This should match "item 99"
+	m2 := re.match_str(text, 7, 0) or {
+		assert false, 'match_str failed to find second match from offset'
+		return
+	}
+
+	assert m2.get(0) or { '' } == 'item 99'
+	assert m2.get(2) or { '' } == '99'
+
+	// Test match_str failure case
+	// Start searching at the very end of string
+	no_match := re.match_str(text, text.len, 0)
+	if _ := no_match {
+		assert false, 'match_str should return none when no match is found'
+	}
+}