Method lex_word

crates/rustc_codegen_spirv/src/builder/spirv_asm.rs:205–262

(&self, line: &mut std::str::Chars<'a>)

impl<'cx, 'tcx> Builder<'cx, 'tcx> {
    fn lex_word<'a>(&self, line: &mut std::str::Chars<'a>) -> Option<Token<'a, 'cx, 'tcx>> {
        loop {
            let start = line.as_str();
            match line.next()? {
                // skip over leading whitespace
                ch if ch.is_whitespace() => continue,
                // lex a string
                '"' => {
                    let mut cooked = String::new();
                    loop {
                        match line.next() {
                            None => {
                                self.err("Unterminated string in instruction");
                                return None;
                            }
                            Some('"') => break,
                            Some('\\') => {
                                let escape = match line.next() {
                                    None => {
                                        self.err("Unterminated string in instruction");
                                        return None;
                                    }
                                    Some('n') => '\n',
                                    Some('r') => '\r',
                                    Some('t') => '\t',
                                    Some('0') => '\0',
                                    Some('\\') => '\\',
                                    Some('\'') => '\'',
                                    Some('"') => '"',
                                    Some(escape) => {
                                        self.err(&format!("invalid escape '\\{escape}'"));
                                        return None;
                                    }
                                };
                                cooked.push(escape);
                            }
                            Some(ch) => {
                                cooked.push(ch);
                            }
                        }
                    }
                    break Some(Token::String(cooked));
                }
                // lex a word
                _ => {
                    let end = loop {
                        let end = line.as_str();
                        match line.next() {
                            Some(ch) if !ch.is_whitespace() => continue,
                            _ => break end,
                        }
                    };
                    let word = &start[..(start.len() - end.len())];
                    break Some(Token::Word(word));
                }
            }
        }
    }