Method consume_integer

core/src/lexer.rs:349–385

Consumes the integer at the current position, whose first digit is `first` and which is expected to be expressed in the given `base`. `prefix_len` indicates how many characters were already consumed for this token, without counting `first`.

(
        &mut self,
        base: u8,
        pos: LineCol,
        prefix_len: usize,
    )

    /// expected to be expressed in the given `base`.  `prefix_len` indicates how many characters
    /// were already consumed for this token, without counting `first`.
    fn consume_integer(
        &mut self,
        base: u8,
        pos: LineCol,
        prefix_len: usize,
    ) -> io::Result<TokenSpan> {
        let mut s = String::new();
        loop {
            match self.input.peek() {
                Some(Ok(ch_span)) => match ch_span.ch {
                    '.' => {
                        self.input.next().unwrap()?;
                        return self
                            .handle_bad_read("Numbers in base syntax must be integers", pos);
                    }
                    ch if ch.is_ascii_digit() => s.push(self.input.next().unwrap()?.ch),
                    'a'..='f' | 'A'..='F' => s.push(self.input.next().unwrap()?.ch),
                    ch if ch.is_separator() => break,
                    ch => {
                        self.input.next().unwrap()?;
                        let msg = format!("Unexpected character in numeric literal: {}", ch);
                        return self.handle_bad_read(msg, pos);
                    }
                },
                Some(Err(_)) => return Err(self.input.next().unwrap().unwrap_err()),
                None => break,
            }
        }
        if s.is_empty() {
            return self.handle_bad_read("No digits in integer literal", pos);
        }

        match u32::from_str_radix(&s, u32::from(base)) {
            Ok(i) => Ok(TokenSpan::new(Token::Integer(i as i32), pos, s.len() + prefix_len)),
            Err(e) => self.handle_bad_read(format!("Bad integer {}: {}", s, e), pos),
        }
    }

    /// Consumes the integer at the current position `pos`.
    fn consume_integer_with_base(&mut self, pos: LineCol) -> io::Result<TokenSpan> {