#[derive(PartialEq, Eq, Debug)]

#[derive(PartialEq, Eq, Debug)]

#[derive(PartialEq, Eq, Debug)]

pub(crate) fn parse_numeric_constant(token_lexeme: &str) -> ParseResult {

    let attrs = parse_num_const_attributes(token_lexeme);

    // TODO(feroldi): Check whether it is an integer or floating point before

    // evaluating.

    let (value, has_overflowed) = eval_integer_constant(attrs);

    let integer = IntegerConst {

        value,

        is_unsigned: false,

    };

    ParseResult {

        num_const: NumConst::Int(integer),

        has_overflowed,

    }

}

fn parse_num_const_attributes(token_lexeme: &str) -> NumConstAttrs {

    let mut seq = Seq::new(token_lexeme);

    let radix;

    let digits_start;

    let digits_end;

    if seq.peek() != b'0' {

        radix = 10;

        while seq.peek().is_ascii_digit() {

            seq.bump();

        }

        (digits_start, digits_end) = (0, seq.pos);

    } else if token_lexeme.len() == 1 {

        radix = 10;

        (digits_start, digits_end) = (0, 1);

    } else {

        seq.bump();

        if matches!(seq.peek(), b'x' | b'X') {

            seq.bump();

            radix = 16;

            digits_start = 2;

            while seq.peek().is_ascii_hexdigit() {

                seq.bump();

            }

            radix = 8;

            digits_start = 1;

            while seq.peek().is_ascii_octdigit() {

                seq.bump();

            }

        digits_end = seq.pos;

    NumConstAttrs {

        radix,

        digits: &token_lexeme.as_bytes()[digits_start..digits_end],

    }

}

fn eval_integer_constant(attrs: NumConstAttrs) -> (u64, bool) {

    let mut value = 0u64;

    let mut has_overflowed = false;

    for &digit in attrs.digits {

        let (low_mul, overflowed) = value.overflowing_mul(attrs.radix);

        has_overflowed |= overflowed;

        value = low_mul;

        let (low_add, overflowed) = value.overflowing_add(convert_digit_to_int(digit));

        has_overflowed |= overflowed;

        value = low_add;

    }

    (value, has_overflowed)

}

    fn new(token_lexeme: &str) -> Seq {

        Seq {

            iter: token_lexeme.as_bytes().iter().peekable(),

            pos: 0,

        }

    }

    fn peek(&mut self) -> u8 {

        self.iter.peek().map(|&&c| c).unwrap_or(b'\0')

    }

    fn bump(&mut self) -> u8 {

        match self.iter.next() {

            Some(&ch) => {

                self.pos += 1;

                ch

    }

fn convert_digit_to_int(digit: u8) -> u64 {

    match digit {

        b'0'..=b'9' => (digit - b'0') as u64,

        b'a'..=b'f' => (digit - b'a') as u64 + 10,

        b'A'..=b'F' => (digit - b'A') as u64 + 10,

}