use alloc::boxed::Box;
use alloc::collections::BTreeMap;
use alloc::format;
use alloc::string::{String, ToString};
use alloc::vec;
use alloc::vec::Vec;
use crate::types::*;
use crate::unicode::is_valid_unicode_property;
fn pattern_max_length(p: &Pattern) -> Option<usize> {
let mut max = 0;
for branch in &p.branches {
let mut total: usize = 0;
for node in branch {
total = total.checked_add(node_max_length(node)?)?;
}
if total > max { max = total; }
}
Some(max)
}
fn node_max_length(n: &Node) -> Option<usize> {
match n {
Node::Literal(_) | Node::Dot | Node::CharClass(_) => Some(1),
Node::LinebreakMatcher => Some(2),
Node::Anchor(_) | Node::SetFlags(_) | Node::RestoreFlags(_)
| Node::Lookahead { .. } | Node::Lookbehind { .. } => Some(0),
Node::Group { inner, .. }
| Node::FlagGroup { inner, .. }
| Node::AtomicGroup { inner } => pattern_max_length(inner),
Node::Quantified { inner, max, .. } => {
let inner_max = node_max_length(inner)?;
if *max == u32::MAX {
if inner_max <= 1 { Some(inner_max) } else { None }
} else {
inner_max.checked_mul(*max as usize)
}
}
Node::Backreference(_) | Node::NamedBackreference(_) => None,
Node::GraphemeCluster => None,
n => unreachable!(
"parser::node_max_length called with engine-internal node {n:?} \
— only invoked on freshly-parsed pattern bodies which never \
contain such nodes"
),
}
}
fn is_lookbehind_bounded(p: &Pattern) -> bool {
pattern_max_length(p).is_some()
}
pub struct Parser {
chars: Vec<char>,
pos: usize,
pub flags: Flags,
pub group_count: usize,
pub named_groups: BTreeMap<String, usize>,
all_named_backrefs: Vec<String>,
}
impl Parser {
pub fn new(pattern: &str, flags: Flags) -> Self {
Parser {
chars: pattern.chars().collect(),
pos: 0,
flags,
group_count: 0,
named_groups: BTreeMap::new(),
all_named_backrefs: Vec::new(),
}
}
pub fn parse(mut self) -> Result<(Pattern, usize, BTreeMap<String, usize>), PatternSyntaxError> {
let pattern = self.parse_pattern()?;
if self.pos < self.chars.len() {
return Err(self.error(format!("Unexpected character '{}' at position {}", self.chars[self.pos], self.pos)));
}
for name in &self.all_named_backrefs {
if !self.named_groups.contains_key(name) {
return Err(self.error(format!("Unknown named group: {}", name)));
}
}
let gc = self.group_count;
let ng = self.named_groups;
Ok((pattern, gc, ng))
}
fn error(&self, message: String) -> PatternSyntaxError {
PatternSyntaxError::with_context(
message,
self.chars.iter().collect(),
self.pos,
)
}
fn peek(&self) -> Option<char> {
self.chars.get(self.pos).copied()
}
fn advance(&mut self) -> Option<char> {
let c = self.chars.get(self.pos).copied();
if c.is_some() { self.pos += 1; }
c
}
fn expect(&mut self, expected: char) -> Result<(), PatternSyntaxError> {
match self.advance() {
Some(c) if c == expected => Ok(()),
_ => Err(self.error(format!("Expected '{}'", expected))),
}
}
fn parse_pattern(&mut self) -> Result<Pattern, PatternSyntaxError> {
let mut branches = Vec::new();
loop {
let branch_start_flags = self.flags;
let mut branch = self.parse_branch()?;
branch.insert(0, Node::SetFlags(branch_start_flags));
branches.push(branch);
if self.peek() != Some('|') { break; }
self.advance();
}
Ok(Pattern { branches })
}
fn parse_branch(&mut self) -> Result<Vec<Node>, PatternSyntaxError> {
let mut nodes = Vec::new();
loop {
if self.flags.comments {
self.skip_comments_whitespace();
}
match self.peek() {
None => break,
Some('|') | Some(')') => break,
_ => {}
}
if self.pos + 1 < self.chars.len() && self.chars[self.pos] == '\\' && self.chars[self.pos + 1] == 'Q' {
self.pos += 2;
let mut quoted_chars = Vec::new();
loop {
if self.pos >= self.chars.len() { break; }
if self.pos + 1 < self.chars.len() && self.chars[self.pos] == '\\' && self.chars[self.pos + 1] == 'E' {
self.pos += 2;
break;
}
quoted_chars.push(self.chars[self.pos]);
self.pos += 1;
}
if quoted_chars.is_empty() {
continue;
}
for &ch in "ed_chars[..quoted_chars.len() - 1] {
nodes.push(Node::Literal(ch));
}
let last = Node::Literal(*quoted_chars.last().unwrap());
let node = self.maybe_parse_quantifier(last)?;
nodes.push(node);
continue;
}
let node = self.parse_atom()?;
let node = self.maybe_parse_quantifier(node)?;
nodes.push(node);
}
Ok(nodes)
}
fn skip_comments_whitespace(&mut self) {
loop {
match self.peek() {
Some(c) if c == ' ' || c == '\t' || c == '\n' || c == '\r' => {
self.advance();
}
Some('#') => {
self.advance();
while let Some(ch) = self.peek() {
if ch == '\n' { self.advance(); break; }
self.advance();
}
}
_ => break,
}
}
}
fn parse_atom(&mut self) -> Result<Node, PatternSyntaxError> {
let c = self.peek().ok_or_else(|| self.error("Unexpected end of pattern".to_string()))?;
match c {
'\\' => self.parse_escape(),
'.' => { self.advance(); Ok(Node::Dot) }
'^' => { self.advance(); Ok(Node::Anchor(AnchorKind::StartOfLine)) }
'$' => { self.advance(); Ok(Node::Anchor(AnchorKind::EndOfLine)) }
'[' => self.parse_char_class_node(),
'(' => self.parse_group(),
'*' | '+' | '?' => {
Err(self.error(format!("Dangling meta character '{}'", c)))
}
'{' => {
let saved = self.pos;
self.advance();
match self.parse_quantifier_braces() {
Ok((min, max)) => {
let kind = match self.peek() {
Some('?') => { self.advance(); QuantKind::Reluctant }
Some('+') => { self.advance(); QuantKind::Possessive }
_ => QuantKind::Greedy,
};
let empty = Node::Group {
index: None,
name: None,
inner: Pattern { branches: vec![vec![]] },
};
Ok(Node::Quantified { inner: Box::new(empty), min, max, kind })
}
Err(_) => {
self.pos = saved;
Err(self.error(format!("Illegal repetition near index {}", self.pos)))
}
}
}
_ => { self.advance(); Ok(Node::Literal(c)) }
}
}
fn parse_escape(&mut self) -> Result<Node, PatternSyntaxError> {
self.advance(); let c = self.advance().ok_or_else(|| self.error("Unexpected end of pattern after \\".to_string()))?;
match c {
'd' => Ok(self.predefined_node(PredefinedClass::Digit)),
'D' => Ok(self.predefined_node(PredefinedClass::NonDigit)),
'w' => Ok(self.predefined_node(PredefinedClass::Word)),
'W' => Ok(self.predefined_node(PredefinedClass::NonWord)),
's' => Ok(self.predefined_node(PredefinedClass::Whitespace)),
'S' => Ok(self.predefined_node(PredefinedClass::NonWhitespace)),
'h' => Ok(self.predefined_node(PredefinedClass::HorizWhitespace)),
'H' => Ok(self.predefined_node(PredefinedClass::NonHorizWhitespace)),
'v' => Ok(self.predefined_node(PredefinedClass::VertWhitespace)),
'V' => Ok(self.predefined_node(PredefinedClass::NonVertWhitespace)),
'A' => Ok(Node::Anchor(AnchorKind::StartOfInput)),
'z' => Ok(Node::Anchor(AnchorKind::EndOfInput)),
'Z' => Ok(Node::Anchor(AnchorKind::EndOfInputBeforeFinalNewline)),
'b' => {
if self.peek() == Some('{') {
return Err(self.error("\\b{g} grapheme cluster boundary is not supported".to_string()));
}
Ok(Node::Anchor(AnchorKind::WordBoundary))
}
'B' => Ok(Node::Anchor(AnchorKind::NonWordBoundary)),
'G' => Ok(Node::Anchor(AnchorKind::PreviousMatchEnd)),
't' => Ok(Node::Literal('\t')),
'n' => Ok(Node::Literal('\n')),
'r' => Ok(Node::Literal('\r')),
'f' => Ok(Node::Literal('\x0C')),
'a' => Ok(Node::Literal('\x07')),
'e' => Ok(Node::Literal('\x1B')),
'R' => Ok(Node::LinebreakMatcher),
'X' => Ok(Node::GraphemeCluster),
'p' => self.parse_unicode_property_node(false),
'P' => self.parse_unicode_property_node(true),
'x' => self.parse_hex_char().map(Node::Literal),
'u' => self.parse_unicode_char().map(Node::Literal),
'0' => self.parse_octal_char().map(Node::Literal),
'c' => self.parse_control_char().map(Node::Literal),
'1'..='9' => {
let mut num = (c as u32 - '0' as u32) as usize;
while let Some(d) = self.peek() {
if d.is_ascii_digit() {
let new_num = num * 10 + (d as u32 - '0' as u32) as usize;
if new_num <= self.group_count {
num = new_num;
self.advance();
} else {
break;
}
} else {
break;
}
}
Ok(Node::Backreference(num))
}
'k' => {
self.expect('<')?;
let name = self.parse_group_name()?;
self.expect('>')?;
self.all_named_backrefs.push(name.clone());
Ok(Node::NamedBackreference(name))
}
'\\' | '.' | '*' | '+' | '?' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '^' | '$' | '-' | '!' | '=' | '<' | '>' | '/' | '#' | ' ' | '&' | '~' | '@' | '`' | '\'' | '"' | ',' | ';' | ':' => {
Ok(Node::Literal(c))
}
'E' => {
Err(self.error(format!("Illegal/unsupported escape sequence near index {}", self.pos - 1)))
}
_ => Ok(Node::Literal(c)),
}
}
fn parse_hex_char(&mut self) -> Result<char, PatternSyntaxError> {
if self.peek() == Some('{') {
self.advance();
let mut hex = String::new();
while let Some(c) = self.peek() {
if c == '}' { self.advance(); break; }
hex.push(c);
self.advance();
}
let code = u32::from_str_radix(&hex, 16).map_err(|_| self.error(format!("Invalid hex escape: {}", hex)))?;
Ok(char::from_u32(code).unwrap_or('\0'))
} else {
let mut hex = String::new();
for _ in 0..2 {
if let Some(c) = self.peek() {
if c.is_ascii_hexdigit() { hex.push(c); self.advance(); }
else { break; }
}
}
if hex.len() != 2 {
return Err(self.error("Invalid hex escape".to_string()));
}
let code = u32::from_str_radix(&hex, 16).map_err(|_| self.error(format!("Invalid hex escape: {}", hex)))?;
Ok(char::from_u32(code).unwrap_or('\0'))
}
}
fn parse_unicode_char(&mut self) -> Result<char, PatternSyntaxError> {
let code = self.parse_4hex()?;
if (0xD800..=0xDBFF).contains(&code) {
let saved_pos = self.pos;
if self.peek() == Some('\\') {
self.advance();
if self.peek() == Some('u') {
self.advance();
if let Ok(low) = self.parse_4hex() {
if (0xDC00..=0xDFFF).contains(&low) {
let cp = 0x10000 + ((code - 0xD800) << 10) + (low - 0xDC00);
return Ok(char::from_u32(cp).unwrap_or('\0'));
}
}
}
}
self.pos = saved_pos;
}
Ok(char::from_u32(code).unwrap_or('\0'))
}
fn parse_4hex(&mut self) -> Result<u32, PatternSyntaxError> {
let mut hex = String::new();
for _ in 0..4 {
if let Some(c) = self.peek() {
if c.is_ascii_hexdigit() { hex.push(c); self.advance(); }
else { break; }
}
}
u32::from_str_radix(&hex, 16).map_err(|_| self.error(format!("Invalid unicode escape: {}", hex)))
}
fn parse_octal_char(&mut self) -> Result<char, PatternSyntaxError> {
let first = match self.peek() {
Some(c) if ('0'..='7').contains(&c) => { self.advance(); c }
_ => {
return Err(self.error(format!("Illegal octal escape sequence near index {}", self.pos)));
}
};
let max_more = if ('0'..='3').contains(&first) { 2 } else { 1 };
let mut oct = String::new();
oct.push(first);
for _ in 0..max_more {
if let Some(c) = self.peek() {
if ('0'..='7').contains(&c) { oct.push(c); self.advance(); }
else { break; }
}
}
let code = u32::from_str_radix(&oct, 8).unwrap_or(0);
Ok(char::from_u32(code).unwrap_or('\0'))
}
fn parse_control_char(&mut self) -> Result<char, PatternSyntaxError> {
let ctrl = self.advance().ok_or_else(|| self.error("Expected control character after \\c".to_string()))?;
let code = (ctrl as u32) ^ 0x40;
Ok(char::from_u32(code).unwrap_or('\0'))
}
fn predefined_node(&self, pc: PredefinedClass) -> Node {
Node::CharClass(CharClass {
negated: false,
items: vec![CharClassItem::Predefined(pc)],
})
}
fn parse_unicode_property_node(&mut self, negated: bool) -> Result<Node, PatternSyntaxError> {
let (name, neg) = self.parse_property_name(negated)?;
Ok(Node::CharClass(CharClass {
negated: false,
items: vec![CharClassItem::UnicodeProperty { name, negated: neg }],
}))
}
fn parse_property_name(&mut self, negated: bool) -> Result<(String, bool), PatternSyntaxError> {
if self.peek() == Some('{') {
self.advance();
let mut name = String::new();
while let Some(c) = self.peek() {
if c == '}' { self.advance(); break; }
name.push(c);
self.advance();
}
if !is_valid_unicode_property(&name) {
return Err(self.error(format!("Unknown Unicode property: {}", name)));
}
Ok((name, negated))
} else {
let c = self.advance().ok_or_else(|| self.error("Expected property name after \\p".to_string()))?;
Ok((c.to_string(), negated))
}
}
fn parse_group_name(&mut self) -> Result<String, PatternSyntaxError> {
let mut name = String::new();
while let Some(c) = self.peek() {
if c.is_alphanumeric() || c == '_' {
name.push(c);
self.advance();
} else {
break;
}
}
if name.is_empty() {
return Err(self.error("Empty group name".to_string()));
}
if name.starts_with(|c: char| c.is_ascii_digit()) {
return Err(self.error(format!("Group name must start with a letter, not '{}'", name.chars().next().unwrap())));
}
Ok(name)
}
fn parse_group(&mut self) -> Result<Node, PatternSyntaxError> {
self.advance();
if self.peek() == Some('?') {
self.advance();
match self.peek() {
Some(':') => {
self.advance();
let saved = self.flags;
let inner = self.parse_pattern()?;
self.flags = saved;
self.expect(')')?;
Ok(Node::Group { index: None, name: None, inner })
}
Some('<') => {
self.advance();
match self.peek() {
Some('=') => {
self.advance();
let saved = self.flags;
let inner = self.parse_pattern()?;
self.flags = saved;
self.expect(')')?;
if !is_lookbehind_bounded(&inner) {
return Err(self.error(
"Look-behind group does not have an obvious maximum length".to_string()));
}
Ok(Node::Lookbehind { positive: true, inner })
}
Some('!') => {
self.advance();
let saved = self.flags;
let inner = self.parse_pattern()?;
self.flags = saved;
self.expect(')')?;
if !is_lookbehind_bounded(&inner) {
return Err(self.error(
"Look-behind group does not have an obvious maximum length".to_string()));
}
Ok(Node::Lookbehind { positive: false, inner })
}
_ => {
let name = self.parse_group_name()?;
self.expect('>')?;
if self.named_groups.contains_key(&name) {
return Err(self.error(format!("Duplicate group name: {}", name)));
}
self.group_count += 1;
let index = self.group_count;
self.named_groups.insert(name.clone(), index);
let saved = self.flags;
let inner = self.parse_pattern()?;
self.flags = saved;
self.expect(')')?;
Ok(Node::Group { index: Some(index), name: Some(name), inner })
}
}
}
Some('=') => {
self.advance();
let saved = self.flags;
let inner = self.parse_pattern()?;
self.flags = saved;
self.expect(')')?;
Ok(Node::Lookahead { positive: true, inner })
}
Some('!') => {
self.advance();
let saved = self.flags;
let inner = self.parse_pattern()?;
self.flags = saved;
self.expect(')')?;
Ok(Node::Lookahead { positive: false, inner })
}
Some('>') => {
self.advance();
let saved = self.flags;
let inner = self.parse_pattern()?;
self.flags = saved;
self.expect(')')?;
Ok(Node::AtomicGroup { inner })
}
_ => self.parse_inline_flags(),
}
} else {
self.group_count += 1;
let index = self.group_count;
let saved = self.flags;
let inner = self.parse_pattern()?;
self.flags = saved;
self.expect(')')?;
Ok(Node::Group { index: Some(index), name: None, inner })
}
}
fn parse_inline_flags(&mut self) -> Result<Node, PatternSyntaxError> {
let mut set_flags = Flags::default();
let mut clear_flags = Flags::default();
let mut clearing = false;
loop {
match self.peek() {
Some(ch @ ('i' | 'm' | 's' | 'x' | 'U' | 'd' | 'u')) => {
self.advance();
let target = if clearing { &mut clear_flags } else { &mut set_flags };
match ch {
'i' => target.case_insensitive = true,
'm' => target.multiline = true,
's' => target.dotall = true,
'x' => target.comments = true,
'U' => target.unicode_class = true,
'd' => target.unix_lines = true,
'u' => target.unicode_case = true,
ch => unreachable!(
"inline-flag char {ch:?} not in the outer pattern \
'i' | 'm' | 's' | 'x' | 'U' | 'd' | 'u'"
),
}
}
Some('-') => { self.advance(); clearing = true; }
Some(':') => {
self.advance();
let saved = self.flags;
self.apply_flags(set_flags, clear_flags);
let active_flags = self.flags;
let inner = self.parse_pattern()?;
self.flags = saved;
self.expect(')')?;
return Ok(Node::FlagGroup { flags: active_flags, inner });
}
Some(')') => {
self.advance();
self.apply_flags(set_flags, clear_flags);
return Ok(Node::SetFlags(self.flags));
}
_ => {
return Err(self.error("Invalid inline flag".to_string()));
}
}
}
}
fn apply_flags(&mut self, set: Flags, clear: Flags) {
if set.case_insensitive { self.flags.case_insensitive = true; }
if set.multiline { self.flags.multiline = true; }
if set.dotall { self.flags.dotall = true; }
if set.comments { self.flags.comments = true; }
if set.unicode_class { self.flags.unicode_class = true; }
if set.unix_lines { self.flags.unix_lines = true; }
if set.unicode_case { self.flags.unicode_case = true; }
if clear.case_insensitive { self.flags.case_insensitive = false; }
if clear.multiline { self.flags.multiline = false; }
if clear.dotall { self.flags.dotall = false; }
if clear.comments { self.flags.comments = false; }
if clear.unicode_class { self.flags.unicode_class = false; }
if clear.unix_lines { self.flags.unix_lines = false; }
if clear.unicode_case { self.flags.unicode_case = false; }
}
fn maybe_parse_quantifier(&mut self, node: Node) -> Result<Node, PatternSyntaxError> {
if self.flags.comments {
self.skip_comments_whitespace();
}
let (min, max) = match self.peek() {
Some('*') => { self.advance(); (0, u32::MAX) }
Some('+') => { self.advance(); (1, u32::MAX) }
Some('?') => { self.advance(); (0, 1) }
Some('{') => {
self.advance();
match self.parse_quantifier_braces() {
Ok((min, max)) => (min, max),
Err(_) => {
return Err(self.error(format!("Illegal repetition near index {}", self.pos)));
}
}
}
_ => return Ok(node),
};
let kind = match self.peek() {
Some('?') => { self.advance(); QuantKind::Reluctant }
Some('+') => { self.advance(); QuantKind::Possessive }
_ => QuantKind::Greedy,
};
Ok(Node::Quantified { inner: Box::new(node), min, max, kind })
}
fn parse_quantifier_braces(&mut self) -> Result<(u32, u32), PatternSyntaxError> {
let mut min_str = String::new();
while let Some(c) = self.peek() {
if c.is_ascii_digit() { min_str.push(c); self.advance(); }
else { break; }
}
if min_str.is_empty() {
return Err(self.error("Invalid quantifier".to_string()));
}
let min: u32 = min_str.parse().map_err(|_| self.error("Invalid quantifier number".to_string()))?;
match self.peek() {
Some('}') => { self.advance(); Ok((min, min)) }
Some(',') => {
self.advance();
if self.peek() == Some('}') {
self.advance();
Ok((min, u32::MAX))
} else {
let mut max_str = String::new();
while let Some(c) = self.peek() {
if c.is_ascii_digit() { max_str.push(c); self.advance(); }
else { break; }
}
self.expect('}')?;
let max: u32 = max_str.parse().map_err(|_| self.error("Invalid quantifier number".to_string()))?;
if min > max {
return Err(self.error(format!("Illegal repetition range near index {}", self.pos)));
}
Ok((min, max))
}
}
_ => Err(self.error("Invalid quantifier".to_string())),
}
}
fn parse_char_class_node(&mut self) -> Result<Node, PatternSyntaxError> {
let cc = self.parse_char_class()?;
Ok(Node::CharClass(cc))
}
fn parse_char_class(&mut self) -> Result<CharClass, PatternSyntaxError> {
self.expect('[')?;
let negated = if self.peek() == Some('^') { self.advance(); true } else { false };
let items = self.parse_char_class_body(true)?;
Ok(CharClass { negated, items })
}
fn parse_char_class_body(&mut self, consume_closing: bool)
-> Result<Vec<CharClassItem>, PatternSyntaxError>
{
let mut items = Vec::new();
let mut at_start = true;
loop {
if self.flags.comments {
self.skip_comments_whitespace();
}
match self.peek() {
None => return Err(self.error("Unclosed character class".to_string())),
Some(']') if at_start => {
self.advance();
items.push(CharClassItem::Single(']'));
at_start = false;
continue;
}
Some(']') => {
if consume_closing { self.advance(); }
return Ok(items);
}
Some('[') => {
let nested = self.parse_char_class()?;
items.push(CharClassItem::Nested(nested));
at_start = false;
continue;
}
Some('&') if self.pos + 1 < self.chars.len()
&& self.chars[self.pos + 1] == '&' =>
{
self.advance();
self.advance();
let right_items = self.parse_intersection_rhs()?;
items = vec![CharClassItem::Intersection(items, right_items)];
at_start = false;
continue;
}
_ => {
at_start = false;
let item = self.parse_char_class_item()?;
if self.peek() == Some('-')
&& self.pos + 1 < self.chars.len()
&& self.chars[self.pos + 1] != ']'
{
if let CharClassItem::Single(start) = item {
self.advance();
let end_item = self.parse_char_class_item()?;
if let CharClassItem::Single(end) = end_item {
if start > end {
return Err(self.error(format!("Invalid range: {}-{}", start, end)));
}
items.push(CharClassItem::Range(start, end));
continue;
} else {
return Err(self.error("Illegal character range".to_string()));
}
}
}
items.push(item);
}
}
}
}
fn parse_intersection_rhs(&mut self) -> Result<Vec<CharClassItem>, PatternSyntaxError> {
let mut items = Vec::new();
loop {
if self.flags.comments {
self.skip_comments_whitespace();
}
match self.peek() {
None => return Err(self.error("Unclosed character class".to_string())),
Some(']') => break,
Some('&') if self.pos + 1 < self.chars.len()
&& self.chars[self.pos + 1] == '&' => break,
Some('[') => {
let nested = self.parse_char_class()?;
items.push(CharClassItem::Nested(nested));
}
_ => {
let inner = self.parse_char_class_body(false)?;
items.extend(inner);
}
}
}
if items.is_empty() {
return Err(self.error("Empty intersection operand".to_string()));
}
Ok(items)
}
fn parse_char_class_item(&mut self) -> Result<CharClassItem, PatternSyntaxError> {
match self.peek() {
Some('\\') => {
self.advance();
let c = self.advance().ok_or_else(|| self.error("Unexpected end in character class".to_string()))?;
match c {
'd' => Ok(CharClassItem::Predefined(PredefinedClass::Digit)),
'D' => Ok(CharClassItem::Predefined(PredefinedClass::NonDigit)),
'w' => Ok(CharClassItem::Predefined(PredefinedClass::Word)),
'W' => Ok(CharClassItem::Predefined(PredefinedClass::NonWord)),
's' => Ok(CharClassItem::Predefined(PredefinedClass::Whitespace)),
'S' => Ok(CharClassItem::Predefined(PredefinedClass::NonWhitespace)),
'h' => Ok(CharClassItem::Predefined(PredefinedClass::HorizWhitespace)),
'H' => Ok(CharClassItem::Predefined(PredefinedClass::NonHorizWhitespace)),
'v' => Ok(CharClassItem::Predefined(PredefinedClass::VertWhitespace)),
'V' => Ok(CharClassItem::Predefined(PredefinedClass::NonVertWhitespace)),
'p' => {
let (name, negated) = self.parse_property_name(false)?;
Ok(CharClassItem::UnicodeProperty { name, negated })
}
'P' => {
let (name, negated) = self.parse_property_name(true)?;
Ok(CharClassItem::UnicodeProperty { name, negated })
}
't' => Ok(CharClassItem::Single('\t')),
'n' => Ok(CharClassItem::Single('\n')),
'r' => Ok(CharClassItem::Single('\r')),
'f' => Ok(CharClassItem::Single('\x0C')),
'a' => Ok(CharClassItem::Single('\x07')),
'e' => Ok(CharClassItem::Single('\x1B')),
'x' => self.parse_hex_char().map(CharClassItem::Single),
'u' => self.parse_unicode_char().map(CharClassItem::Single),
'0' => self.parse_octal_char().map(CharClassItem::Single),
'c' => self.parse_control_char().map(CharClassItem::Single),
'Q' => {
let mut items = Vec::new();
loop {
if self.pos >= self.chars.len() { break; }
if self.pos + 1 < self.chars.len() && self.chars[self.pos] == '\\' && self.chars[self.pos + 1] == 'E' {
self.pos += 2;
break;
}
items.push(CharClassItem::Single(self.chars[self.pos]));
self.pos += 1;
}
if items.len() == 1 { return Ok(items.into_iter().next().unwrap()); }
Ok(CharClassItem::Nested(CharClass { negated: false, items }))
}
'1'..='9' => Err(self.error(format!("Illegal backreference in character class near index {}", self.pos - 1))),
_ => Ok(CharClassItem::Single(c)),
}
}
Some('[') => {
let nested = self.parse_char_class()?;
Ok(CharClassItem::Nested(nested))
}
Some(c) => { self.advance(); Ok(CharClassItem::Single(c)) }
None => Err(self.error("Unexpected end in character class".to_string())),
}
}
}