perl-regex 0.13.3

Regex parsing and validation helpers for Perl syntax
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use super::parser::{parse_named_capture_name, parse_named_capture_name_from};

#[derive(Debug, Clone, PartialEq)]
pub struct CaptureGroup {
    pub name: String,
    pub index: usize,
    pub pattern: String,
}

pub(crate) fn extract_named_captures(pattern: &str) -> Vec<CaptureGroup> {
    let bytes = pattern.as_bytes();
    let mut result = Vec::new();
    let mut i = 0;
    let mut capture_index = 0;

    while i < bytes.len() {
        if bytes[i] == b'\\' {
            i += 2;
            continue;
        }

        if bytes[i] == b'[' {
            i += 1;
            while i < bytes.len() {
                if bytes[i] == b'\\' {
                    i += 2;
                } else if bytes[i] == b']' {
                    i += 1;
                    break;
                } else {
                    i += 1;
                }
            }
            continue;
        }

        if bytes[i] == b'(' {
            i += 1;
            if i < bytes.len() && bytes[i] == b'?' {
                i += 1;
                if i < bytes.len() && bytes[i] == b'<' {
                    i += 1;
                    if i < bytes.len() && (bytes[i] == b'=' || bytes[i] == b'!') {
                        i += 1;
                        continue;
                    }

                    if let Some((name, next)) = parse_named_capture_name_from(bytes, i, b'>') {
                        capture_index += 1;
                        i = next;
                        let (subpattern, next_i) = collect_subpattern(bytes, i);
                        i = next_i;
                        result.push(CaptureGroup {
                            name,
                            index: capture_index,
                            pattern: subpattern,
                        });
                        continue;
                    }
                } else if i < bytes.len() && bytes[i] == b'\'' {
                    if let Some((name, next)) = parse_named_capture_name(bytes, i, b'\'', b'\'') {
                        capture_index += 1;
                        i = next;
                        let (subpattern, next_i) = collect_subpattern(bytes, i);
                        i = next_i;
                        result.push(CaptureGroup {
                            name,
                            index: capture_index,
                            pattern: subpattern,
                        });
                        continue;
                    }
                }
                continue;
            }

            capture_index += 1;
            continue;
        }

        i += 1;
    }

    result
}

fn collect_subpattern(bytes: &[u8], mut i: usize) -> (String, usize) {
    let start = i;
    let mut depth = 1usize;
    while i < bytes.len() && depth > 0 {
        if bytes[i] == b'\\' {
            i += 2;
            continue;
        }

        if bytes[i] == b'[' {
            i += 1;
            while i < bytes.len() {
                if bytes[i] == b'\\' {
                    i += 2;
                } else if bytes[i] == b']' {
                    i += 1;
                    break;
                } else {
                    i += 1;
                }
            }
            continue;
        }

        if bytes[i] == b'(' {
            depth += 1;
        } else if bytes[i] == b')' {
            depth -= 1;
        }
        i += 1;
    }

    let subpattern = if i > 0 && start < i - 1 {
        String::from_utf8_lossy(&bytes[start..i - 1]).into_owned()
    } else {
        String::new()
    };

    (subpattern, i)
}