Function parse_quoted_string

cel/src/parser/parse.rs:250–362

(
    s: &str,
    mut chars: &mut Enumerate<Chars>,
    mut res: String,
    quote: char,
)

}

fn parse_quoted_string(
    s: &str,
    mut chars: &mut Enumerate<Chars>,
    mut res: String,
    quote: char,
) -> Result<String, ParseSequenceError> {
    let mut in_single_quotes = quote == '\'';
    let mut in_double_quotes = quote == '"';

    while let Some((idx, c)) = chars.next() {
        let in_quotes = in_single_quotes || in_double_quotes;

        if c == '\\' && in_quotes {
            match chars.next() {
                None => {
                    return Err(ParseSequenceError::InvalidEscape {
                        escape: format!("{c}"),
                        index: idx,
                        string: String::from(s),
                    });
                }
                Some((idx, c2)) => {
                    let mut push_escape_character = false;

                    let value = match c2 {
                        'a' => '\u{07}',
                        'b' => '\u{08}',
                        'v' => '\u{0B}',
                        'f' => '\u{0C}',
                        'n' => '\n',
                        'r' => '\r',
                        't' => '\t',
                        '\\' => c2,
                        '?' => c2,
                        '\'' => {
                            push_escape_character = in_double_quotes;
                            c2
                        }
                        '"' => {
                            push_escape_character = in_single_quotes;
                            c2
                        }
                        '`' => c2,
                        'x' | 'u' | 'U' => {
                            let length = match c2 {
                                'x' => 2,
                                'u' => 4,
                                'U' => 8,
                                _ => unreachable!(),
                            };

                            parse_unicode_hex(length, &mut chars).map_err(|x| {
                                ParseSequenceError::InvalidUnicode {
                                    source: x.clone(),
                                    index: idx,
                                    string: String::from(s),
                                }
                            })?