Method class

std/re/src/main/parser.rs:234–269

(&mut self)

    }

    fn class(&mut self) -> Result<Node, ParseError> {
        self.bump(); // open bracket
        let negated = if self.peek() == Some('^') { self.bump(); true } else { false };
        let mut items = Vec::new();
        if self.peek() == Some(']') { items.push(ClassItem::Ch(']')); self.bump(); }
        loop {
            match self.peek() {
                None => return Err(self.err("unterminated character set")),
                Some(']') => { self.bump(); break; }
                Some('\\') => { self.bump(); items.push(self.class_escape()?); }
                Some(c) => {
                    self.bump();
                    let is_range = self.peek() == Some('-')
                        && self.at(1).is_some()
                        && self.at(1) != Some(']');
                    if is_range {
                        self.bump(); // dash
                        let end = if self.peek() == Some('\\') {
                            self.bump();
                            match self.class_escape()? {
                                ClassItem::Ch(e) => e,
                                _ => return Err(self.err("bad character range")),
                            }
                        } else {
                            self.bump().unwrap()
                        };
                        if (end as u32) < (c as u32) { return Err(self.err("bad character range")); }
                        items.push(ClassItem::Range(c, end));
                    } else {
                        items.push(ClassItem::Ch(c));
                    }
                }
            }
        }
        Ok(Node::Class { items, negated })
    }

    fn class_escape(&mut self) -> Result<ClassItem, ParseError> {
        let c = self.bump().ok_or(self.err("trailing backslash"))?;