regress 0.2.0

A regular expression engine targeting EcmaScript 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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use crate::bytesearch::{charset_contains, ByteArraySet, ByteSeq, ByteSet, SmallArraySet};
use crate::cursor::{Cursorable, Position};
use crate::indexing::ElementType;
use crate::insn::MAX_CHAR_SET_LENGTH;
use crate::matchers::CharProperties;
use crate::types::BracketContents;

/// A trait for things that match a single Element.
pub trait SingleCharMatcher<Cursor: Cursorable> {
    /// \return whether we match the character at the given position, advancing
    /// the position if so. On a false return, the position is unspecified.
    fn matches(&self, pos: &mut Position, cursor: Cursor) -> bool;
}

/// Insn::Char
pub struct Char<Cursor: Cursorable> {
    pub c: Cursor::Element,
}
impl<Cursor: Cursorable> SingleCharMatcher<Cursor> for Char<Cursor> {
    #[inline(always)]
    fn matches(&self, pos: &mut Position, cursor: Cursor) -> bool {
        match cursor.next(pos) {
            Some(c2) => c2 == self.c,
            _ => false,
        }
    }
}

/// Insn::CharICase
pub struct CharICase<Cursor: Cursorable> {
    pub c: Cursor::Element,
}
impl<Cursor: Cursorable> SingleCharMatcher<Cursor> for CharICase<Cursor> {
    #[inline(always)]
    fn matches(&self, pos: &mut Position, cursor: Cursor) -> bool {
        match cursor.next(pos) {
            Some(c2) => c2 == self.c || Cursor::CharProps::fold(c2) == self.c,
            _ => false,
        }
    }
}

/// Insn::CharSet
pub struct CharSet<'a> {
    pub chars: &'a [char; MAX_CHAR_SET_LENGTH],
}

impl<'a, Cursor: Cursorable> SingleCharMatcher<Cursor> for CharSet<'a> {
    #[inline(always)]
    fn matches(&self, pos: &mut Position, cursor: Cursor) -> bool {
        match cursor.next(pos) {
            Some(c) => charset_contains(self.chars, c.as_char()),
            None => false,
        }
    }
}

/// Insn::Bracket
pub struct Bracket<'a> {
    pub bc: &'a BracketContents,
}

impl<'a, Cursor: Cursorable> SingleCharMatcher<Cursor> for Bracket<'a> {
    #[inline(always)]
    fn matches(&self, pos: &mut Position, cursor: Cursor) -> bool {
        match cursor.next(pos) {
            Some(c) => Cursor::CharProps::bracket(self.bc, c),
            _ => false,
        }
    }
}

/// Insn::MatchAny
pub struct MatchAny {}
impl MatchAny {
    pub fn new() -> Self {
        Self {}
    }
}
impl<Cursor: Cursorable> SingleCharMatcher<Cursor> for MatchAny {
    #[inline(always)]
    fn matches(&self, pos: &mut Position, cursor: Cursor) -> bool {
        // If there is a character, it counts as a match.
        cursor.next(pos).is_some()
    }
}

/// Insn::MatchAnyExceptLineTerminator
pub struct MatchAnyExceptLineTerminator {}
impl MatchAnyExceptLineTerminator {
    pub fn new() -> Self {
        Self {}
    }
}
impl<Cursor: Cursorable> SingleCharMatcher<Cursor> for MatchAnyExceptLineTerminator {
    #[inline(always)]
    fn matches(&self, pos: &mut Position, cursor: Cursor) -> bool {
        match cursor.next(pos) {
            Some(c2) => !Cursor::CharProps::is_line_terminator(c2),
            _ => false,
        }
    }
}

/// Any ByteSet may match a single char.
pub struct MatchByteSet<'a, Bytes: ByteSet> {
    pub bytes: &'a Bytes,
}

impl<'a, Cursor: Cursorable, Bytes: ByteSet> SingleCharMatcher<Cursor> for MatchByteSet<'a, Bytes> {
    #[inline(always)]
    fn matches(&self, pos: &mut Position, cursor: Cursor) -> bool {
        if let Some(b) = cursor.next_byte(pos) {
            self.bytes.contains(b)
        } else {
            false
        }
    }
}

/// Provide a variant for ByteArraySet where we hold it directly.
/// The arrays are small and so we don't want to indirect through a pointer.
pub struct MatchByteArraySet<ArraySet: SmallArraySet> {
    pub bytes: ByteArraySet<ArraySet>,
}

impl<Cursor: Cursorable, ArraySet: SmallArraySet> SingleCharMatcher<Cursor>
    for MatchByteArraySet<ArraySet>
{
    #[inline(always)]
    fn matches(&self, pos: &mut Position, cursor: Cursor) -> bool {
        if let Some(b) = cursor.next_byte(pos) {
            self.bytes.0.contains(b)
        } else {
            false
        }
    }
}

/// A ByteSeq of length <= 4 may match a single char.
pub struct MatchByteSeq<'a, Bytes: ByteSeq> {
    pub bytes: &'a Bytes,
}

impl<'a, Cursor: Cursorable, Bytes: ByteSeq> SingleCharMatcher<Cursor> for MatchByteSeq<'a, Bytes> {
    #[inline(always)]
    fn matches(&self, pos: &mut Position, cursor: Cursor) -> bool {
        debug_assert!(
            Bytes::LENGTH <= 4,
            "This looks like it could match more than one char"
        );
        cursor.try_match_lit(pos, self.bytes)
    }
}