Method parse_pattern_token

src/query.rs:304–345

(&mut self)

    }

    fn parse_pattern_token(&mut self) -> Result<PatternToken, String> {
        self.skip_whitespace();
        if self.consume_literal("\"") {
            let mut out = String::new();
            while let Some(c) = self.bump() {
                match c {
                    '\\' => {
                        if let Some(n) = self.bump() {
                            out.push(n);
                        } else {
                            break;
                        }
                    }
                    '"' => {
                        return Ok(PatternToken {
                            text: out,
                            quoted: true,
                        })
                    }
                    _ => out.push(c),
                }
            }
            Err("unterminated string literal".into())
        } else {
            let start = self.i;
            while let Some(c) = self.peek() {
                if c.is_whitespace() || c == ')' {
                    break;
                }
                // Everything else belongs to the token (including ':', '*', etc.)
                self.bump();
            }
            if self.i == start {
                Err("expected pattern".into())
            } else {
                Ok(PatternToken {
                    text: self.s[start..self.i].to_string(),
                    quoted: false,
                })
            }
        }
    }

    fn consume_keyword(&mut self, keyword: &str) -> bool {
        let save = self.i;