fn scan_escaped_char(&mut self) -> ScannedChar {
        match self.curr {
            Some('\\') => {
                self.bump();
                let out = match self.curr {
                    None => return ScannedChar::Eof,
                    Some(c) => {
                        self.bump();
                        match c {
                            'b' => '\u{0008}',
                            't' => '\t',
                            'n' => '\n',
                            'f' => '\u{000c}',
                            'r' => '\r',
                            '\'' => '\'',
                            '\"' => '\"',
                            '\\' => '\\',
                            '0' ... '7' => self.scan_octal_escape(),
                            _ => return ScannedChar::InvalidEscape(c),
                        }
                    },
                };
                ScannedChar::Escape(out)
            },
            Some(c) => {
                self.bump();
                ScannedChar::Normal(c)
            },
            None => ScannedChar::Eof,
        }
    }
/// Reads a char inside a string or character literal. If `curr` is a
/// backslash, the escape character is parsed, if possible. The boolean
/// value denotes if the returned char was created from a escape sequence.
///
/// Returns `None` if
/// - `curr` is `None` (EOF),
/// - a '\' followed by EOF is found
///
/// Invalid escape sequences result in an error, but the backslash will be
/// ignored and the char after it will be returned.
Reads a char inside a string or character literal. If `curr` is a
backslash, the escape character is parsed, if possible. The boolean
value denotes if the returned char was created from a escape sequence.



Invalid escape sequences result in an error, but the backslash will be
ignored and the char after it will be returned.
Reads a char inside a string or character literal . If ` curr ` is a backslash the escape character is parsed if possible . The boolean value denotes if the returned char was created from a escape sequence . Invalid escape sequences result in an error but the backslash will be ignored and the char after it will be returned .
fn scan_escaped_char(&mut self) -> ScannedChar {
        match self.curr {
            Some('\\') => {
                self.bump();
                let out = match self.curr {
                    None => return ScannedChar::Eof,
                    Some(c) => {
                        self.bump();
                        match c {
                            'b' => '\u{0008}',
                            't' => '\t',
                            'n' => '\n',
                            'f' => '\u{000c}',
                            'r' => '\r',
                            '\'' => '\'',
                            '\"' => '\"',
                            '\\' => '\\',
                            '0' ... '7' => self.scan_octal_escape(),
                            _ => return ScannedChar::InvalidEscape(c),
                        }
                    },
                };
                ScannedChar::Escape(out)
            },
            Some(c) => {
                self.bump();
                ScannedChar::Normal(c)
            },
            None => ScannedChar::Eof,
        }
    }
fn scan_escaped_char ( & mut self ) -> ScannedChar { match self . curr { Some ( '\\' ) => { self . bump ( ) ; let out = match self . curr { None => return ScannedChar :: Eof , Some ( c ) => { self . bump ( ) ; match c { 'b' => '\u{0008}' , 't' => '\t' , 'n' => '\n' , 'f' => '\u{000c}' , 'r' => '\r' , '\'' => '\'' , '\"' => '\"' , '\\' => '\\' , '0' ... '7' => self . scan_octal_escape ( ) , _ => return ScannedChar :: InvalidEscape ( c ) , } } , } ; ScannedChar :: Escape ( out ) } , Some ( c ) => { self . bump ( ) ; ScannedChar :: Normal ( c ) } , None => ScannedChar :: Eof , } }
Reads a char inside a string or character literal.
Reads a char inside a string or character literal .
&mut self
&mut self