trivet/numbers/

decoder.rs

// Trivet
// Copyright (c) 2025 by Stacy Prowell.  All rights reserved.
// https://gitlab.com/binary-tools/trivet

//! Parse numbers.
//!
//! A general number parser can be found in [`NumberParser`].  This is capable of parsing
//! both integer and floating point numbers, and can do so in decimal, binary, octal, and
//! hexadecimal.
//!
//! There is a standard for hexadecimal floating point numbers that, since 2008, is part
//! of the IEEE 754 standard.

use crate::errors::syntax_error;
use crate::errors::ParseResult;
use crate::numbers::Radix;
use crate::parse_from_string;
use crate::ParserCore;
use std::fmt::Debug;

use super::binary_float::parse_binary_float;
use super::decimal_float::parse_decimal_float;
use super::hexadecimal_float::parse_hexadecimal_float;
use super::octal_float::parse_octal_float;

/// Define the sign.
#[derive(Debug, Clone)]
pub enum Sign {
    Negative,
    None,
    Positive,
}

/// Define a number as parts.
#[derive(Debug, Clone)]
pub struct NumberParts {
    /// The radix for this number.
    pub radix: Radix,
    /// The sign for this number.
    pub sign: Sign,
    /// If true, this number is NaN.  No other items are relevant.
    pub is_nan: bool,
    /// If true, this number is infinity.  No other items except the sign are relevant.
    pub is_inf: bool,
    /// Any digits to the left of the decimal or exponent marker, whichever comes first.  This may be
    /// empty if there are no digits to the left of the decimal or exponent marker, or if the number is
    /// either `inf` or `nan`.
    pub whole: String,
    /// Any digits to the right of the decimal and left of the exponent marker.  If there
    /// is no decimal point, then this is `None`.
    pub fraction: Option<String>,
    /// The sign of the exponent.  If there is no exponent marker, then this is `None`.
    pub exponent_sign: Option<Sign>,
    /// Any digits to the right of the exponent marker.  If there is no exponent marker,
    /// then this is `None`.
    pub exponent: Option<String>,
}

impl NumberParts {
    /// Determine if this is likely to represent a floating point number.
    pub fn is_apparent_float(&self) -> bool {
        self.fraction.is_some() || self.exponent.is_some() || self.is_inf || self.is_nan
    }

    /// Convert this to a string that can subsequently be parsed.  This includes the sign
    /// unless it is a plus.  If `include_radix` is `true`, then the radix prefix is included.
    /// Otherwise it is not.
    pub fn as_string(&self, include_radix: bool) -> String {
        let mut result = String::new();
        if let Sign::Negative = self.sign {
            result.push('-')
        }
        if self.is_nan {
            result.push_str("nan");
            return result;
        }
        if self.is_inf {
            result.push_str("inf");
            return result;
        }
        if include_radix {
            result.push_str(&self.radix.as_prefix());
        }
        result.push_str(&self.whole);
        if let Some(ref digits) = self.fraction {
            result.push('.');
            result.push_str(digits);
        }
        if let Some(ref digits) = self.exponent {
            if self.radix == Radix::Hexadecimal {
                result.push('p');
            } else {
                result.push('e');
            }
            if let Some(Sign::Negative) = self.exponent_sign {
                result.push('-');
            }
            result.push_str(digits);
        }
        result
    }
}

impl From<u128> for NumberParts {
    fn from(value: u128) -> Self {
        Self {
            radix: Radix::Decimal,
            sign: Sign::None,
            is_nan: false,
            is_inf: false,
            whole: value.to_string(),
            fraction: None,
            exponent_sign: None,
            exponent: None,
        }
    }
}

impl From<i128> for NumberParts {
    fn from(value: i128) -> Self {
        let (sign, value) = if value < 0 {
            (Sign::Negative, -value)
        } else {
            (Sign::None, value)
        };
        Self {
            radix: Radix::Decimal,
            sign,
            is_nan: false,
            is_inf: false,
            whole: value.to_string(),
            fraction: None,
            exponent_sign: None,
            exponent: None,
        }
    }
}

impl From<u64> for NumberParts {
    fn from(value: u64) -> Self {
        Self {
            radix: Radix::Decimal,
            sign: Sign::None,
            is_nan: false,
            is_inf: false,
            whole: value.to_string(),
            fraction: None,
            exponent_sign: None,
            exponent: None,
        }
    }
}

impl From<i64> for NumberParts {
    fn from(value: i64) -> Self {
        let (sign, value) = if value < 0 {
            (Sign::Negative, -value)
        } else {
            (Sign::None, value)
        };
        Self {
            radix: Radix::Decimal,
            sign,
            is_nan: false,
            is_inf: false,
            whole: value.to_string(),
            fraction: None,
            exponent_sign: None,
            exponent: None,
        }
    }
}

impl From<f64> for NumberParts {
    fn from(value: f64) -> Self {
        if f64::is_nan(value) {
            return Self {
                radix: Radix::Decimal,
                sign: Sign::None,
                is_nan: true,
                is_inf: false,
                whole: "".into(),
                fraction: None,
                exponent_sign: None,
                exponent: None,
            };
        }
        let (sign, value) = if value < 0.0 {
            (Sign::Negative, -value)
        } else {
            (Sign::None, value)
        };
        if value == f64::INFINITY {
            return Self {
                radix: Radix::Decimal,
                sign,
                is_nan: false,
                is_inf: true,
                whole: "".into(),
                fraction: None,
                exponent_sign: None,
                exponent: None,
            };
        }
        let sci = format!("{:e}", value);
        let parts: Vec<&str> = sci.split('e').collect();
        let mantissa = parts[0];
        let exponent = parts[1];
        let (exponent_sign, exponent) = if let Some(body) = exponent.strip_prefix('-') {
            (Sign::Negative, body)
        } else {
            (Sign::None, exponent)
        };
        let mantissa_parts: Vec<&str> = mantissa.split('.').collect();
        let whole = mantissa_parts[0].to_string();
        let fraction = mantissa_parts.get(1).unwrap_or(&"0").to_string();
        Self {
            radix: Radix::Decimal,
            sign,
            is_nan: false,
            is_inf: false,
            whole,
            fraction: if fraction.is_empty() {
                None
            } else {
                Some(fraction)
            },
            exponent_sign: Some(exponent_sign),
            exponent: Some(exponent.into()),
        }
    }
}

impl From<NumberParts> for i64 {
    fn from(np: NumberParts) -> Self {
        if np.whole.is_empty() {
            0
        } else {
            let value = i64::from_str_radix(&np.whole, np.radix.value()).unwrap_or(0);
            if let Sign::Negative = np.sign {
                -value
            } else {
                value
            }
        }
    }
}

impl From<NumberParts> for i128 {
    fn from(np: NumberParts) -> Self {
        if np.whole.is_empty() {
            0
        } else {
            let value = i128::from_str_radix(&np.whole, np.radix.value()).unwrap_or(0);
            if let Sign::Negative = np.sign {
                -value
            } else {
                value
            }
        }
    }
}

impl From<NumberParts> for f64 {
    fn from(np: NumberParts) -> Self {
        if np.is_nan {
            return f64::NAN;
        }
        let mut np = np;
        let negative = matches!(np.sign, Sign::Negative);
        np.sign = Sign::None;
        if np.is_inf {
            if negative {
                return f64::NEG_INFINITY;
            } else {
                return f64::INFINITY;
            }
        }
        let text = np.as_string(false);
        println!("{}", text);
        let mut parser = parse_from_string(&text);
        let core = parser.borrow_core();
        let settings = &NumberParserSettings::default();
        let result = match np.radix {
            Radix::Binary => parse_binary_float(core, negative, settings),
            Radix::Octal => parse_octal_float(core, negative, settings),
            Radix::Decimal => parse_decimal_float(core, negative, settings),
            Radix::Hexadecimal => parse_hexadecimal_float(core, negative, settings),
        };
        println!("{:?}", result);
        match result {
            Ok(value) => value,
            Err(_) => f64::NAN,
        }
    }
}

/// Provide the number parser configuration.  You will seldom use this directly.
/// Instead, reference the current settings through a [`NumberParser`] instance.
#[derive(Debug, Clone)]
pub struct NumberParserSettings {
    /// Allow underscores in numbers.  If this is true, then arbitrary underscores can
    /// occur in numbers, and these are dropped during parsing.  If false, then
    /// underscores are not permitted.
    pub permit_underscores: bool,

    /// If true, methods that do not explicitly specify a radix will try to detect and
    /// parse hexadecimal numbers.
    pub permit_hexadecimal: bool,

    /// If true, methods that do not explicitly specify a radix will try to detect and
    /// parse octal numbers.
    pub permit_octal: bool,

    /// If true, methods that do not explicitly specify a radix will try to detect and
    /// parse binary numbers.
    pub permit_binary: bool,

    /// If true, allow a number to start with a plus sign.
    pub permit_plus: bool,

    /// Specify the characters that indicate a hexadecimal value.
    pub hexadecimal_indicator: Vec<char>,

    /// Specify the characters that indicate an octal value.
    pub octal_indicator: Vec<char>,

    /// Specify the characters that indicate a binary value.
    pub binary_indicator: Vec<char>,

    /// If true, floating point numbers can be in non-decimal radix.
    pub decimal_only_floats: bool,

    /// If true, permit an empty whole part.  That is, `.15` is legal.
    pub permit_empty_whole: bool,

    /// If true, permit an empty fractional part.  That is, `15.` is legal.
    pub permit_empty_fraction: bool,

    /// If true, permit a leading zero for a non-zero whole.  That is, `01.5` is legal.
    ///
    /// **NB**: This only applies to decimal numbers, as leading zeros are common and
    /// expected in other bases.
    pub permit_leading_zero: bool,
}

impl Default for NumberParserSettings {
    fn default() -> Self {
        Self {
            permit_binary: true,
            permit_octal: true,
            permit_hexadecimal: true,
            binary_indicator: vec!['0', 'b'],
            octal_indicator: vec!['0', 'o'],
            hexadecimal_indicator: vec!['0', 'x'],
            permit_plus: true,
            permit_leading_zero: true,
            permit_empty_whole: true,
            permit_empty_fraction: true,
            permit_underscores: true,
            decimal_only_floats: false,
        }
    }
}

impl NumberParserSettings {
    /// Make a new instance.  The parsing rules are maximally permissive.
    pub fn new() -> Self {
        Self::default()
    }
}

/// Provide for parsing of numbers in various forms.
///
/// To use this, make an instance and then configure it if you wish.
///
/// # Plus / Minus
///
/// (Signed) numbers can start with an optional minus or plus sign to indicate the
/// sign.  If you do not want to allow the plus sign, see [`NumberParserSettings::permit_plus`].
///
/// # Permitted Radices
///
/// The methods [`Self::parse_u128`], [`Self::parse_i128`], and [`Self::parse_f64`],
/// can parse numbers that occur in any supported radix.  You can disable parsing of
/// numbers in hexadecimal, octal, or binary by setting the appropriate flag to false.
/// Decimal numbers cannot be disabled.
///
/// # Radix Indicator
///
/// Different radices can be detected automatically using a leading radix indicator.
/// This is also configurable, with the following defaults.
///
/// |Prefix |Radix |
/// |-------|------|
/// |`0b`   |Binary |
/// |`0o`   |Octal  |
/// |none   |Decimal |
/// |`0x`   |Hexadecimal |
///
/// Radix indicators can be configured if you wish, but you must be careful to avoid
/// excessive ambiguity.  The following is an example.
///
/// ```rust
/// use trivet::numbers::NumberParser;
/// use trivet::ParserCore;
/// use trivet::errors::ParseResult;
/// use trivet::parse_from_string;
///
/// # fn main() -> ParseResult<()> {
/// let mut parser = parse_from_string("17 $ffef_1021");
/// let mut core = parser.borrow_core();
/// let mut numpar = NumberParser::new();
/// numpar.settings.permit_binary = false;
/// numpar.settings.permit_octal = false;
/// numpar.settings.hexadecimal_indicator = vec!['$'];
///
/// assert_eq!(numpar.parse_u128(&mut core)?, 17);
/// core.consume();
/// assert_eq!(numpar.parse_u128(&mut core)?, 0xffef1021);
/// # Ok(())
/// # }
/// ```
///
/// # Explicit Radix
///
/// Methods that explicitly specify a radix *do not look for* a radix indicator, and
/// will fail if one is encountered.  They also ignore the enabled/disabled status of
/// any radix.
///
/// ```rust
/// use trivet::numbers::NumberParser;
/// use trivet::numbers::Radix;
/// use trivet::ParserCore;
/// use trivet::errors::ParseResult;
/// use trivet::parse_from_string;
///
/// # fn main() -> ParseResult<()> {
/// let mut parser = parse_from_string("17 ffef_1021");
/// let mut core = parser.borrow_core();
/// let mut numpar = NumberParser::new();
///
/// assert_eq!(numpar.parse_u128_radix(&mut core, Radix::Decimal)?, 17);
/// let _ = core.consume_ws_only();
/// assert_eq!(numpar.parse_u128_radix(&mut core, Radix::Hexadecimal)?, 0xffef1021);
/// # Ok(())
/// # }
/// ```
///
#[derive(Debug, Clone)]
pub struct NumberParser {
    /// The parser settings.
    pub settings: NumberParserSettings,
}

impl Default for NumberParser {
    fn default() -> Self {
        Self::new()
    }
}

impl NumberParser {
    /// Make a new number parser.  All options are enabled by default, and the
    /// default radix indicators are installed.  This is a very permissive form
    /// of number parsing, and can be problematic for some parsers.  Check the
    /// options carefully to ensure the ones you want are installed.
    pub fn new() -> Self {
        NumberParser {
            settings: NumberParserSettings::new(),
        }
    }

    /// Get the text of the next number in the stream.  This extracts the longest string that matches
    /// the following expression.  Note that this may not be a valid number.
    ///
    /// ```text
    /// [-+]? (indicator)? [0-9a-z_]* ('.' [0-9a-z_]*)? ([eEpP] [0-9a-z_]*)?
    /// ```
    ///
    /// The `+` can be allowed or disallowed using options, and is discarded from the returned string.
    ///
    /// **The [`NumberParserSettings::decimal_only_floats`] flag is ignored.**  It can be checked after
    /// returning the result.
    ///
    /// In the above `indicator` is any allowed radix indicator.  The returned value will be a triple
    /// consisting of the apparent radix of the number, the text of the number, and a flag indicating
    /// whether the number is a floating point value.
    ///
    /// The exponent indicator `p` is required iff the number is in hexadecimal.  The exponent indicator
    /// `p` is prohibited if hexadecimal is not allowed.
    ///
    /// This method honors the settings, so only permitted radices and the appropriate indicators are used,
    /// and underscores may or may not be permitted.
    ///
    /// Note that even if underscores are permitted, they are discarded during parsing.
    ///
    /// Note that tests for leading zero, empty whole, and empty fracitonal part are not performed here.
    /// Perform those on evaluation.
    ///
    /// Several methods may be useful with respect to the output of this method.
    ///
    /// - `i16::from_str_radix`
    /// - `i32::from_str_radix`
    /// - `i64::from_str_radix`
    /// - `i128::from_str_radix`
    /// - `u16::from_str_radix`
    /// - `u32::from_str_radix`
    /// - `u64::from_str_radix`
    /// - `u128::from_str_radix`
    /// - `f64::from_str` (must use `std::str::FromStr`)
    ///
    /// ```
    /// use trivet::parse_from_string;
    /// use trivet::numbers::NumberParser;
    /// use trivet::numbers::Radix;
    ///
    /// // Parse an integer value.
    /// let mut parser = parse_from_string("-0x21_e4");
    /// let mut np = NumberParser::new();
    /// let (radix, text, fp) = np.get_text(parser.borrow_core());
    /// assert_eq!(radix, Radix::Hexadecimal);
    /// assert_eq!(text, "-21e4".to_string());
    /// assert_eq!(fp, false);
    /// let value = i16::from_str_radix(&text, radix.value());
    /// assert_eq!(value, Ok(-0x21e4));
    /// ```
    ///
    /// ```
    /// use trivet::parse_from_string;
    /// use trivet::numbers::NumberParser;
    /// use trivet::numbers::Radix;
    /// use std::str::FromStr;
    ///
    /// // Parse a floating point value.
    /// let mut parser = parse_from_string("-174.0210");
    /// let mut np = NumberParser::new();
    /// let (radix, text, fp) = np.get_text(parser.borrow_core());
    /// assert_eq!(radix, Radix::Decimal);
    /// assert_eq!(text, "-174.0210".to_string());
    /// assert_eq!(fp, true);
    /// let value = f64::from_str(&text);
    /// assert_eq!(value, Ok(-174.0210));
    /// ```
    ///
    pub fn get_text(&self, parser: &mut ParserCore) -> (Radix, String, bool) {
        let parts = self.get_parts(parser);

        // Done.
        (
            parts.radix,
            parts.as_string(false),
            parts.is_apparent_float(),
        )
    }

    /// Parse text from the stream to generate the parts of a number.
    pub fn get_parts(&self, parser: &mut ParserCore) -> NumberParts {
        let mut text = String::new();

        // Watch for a negative sign or a plus sign.
        let sign = if parser.peek_and_consume('-') {
            Sign::Negative
        } else if parser.peek_and_consume('+') {
            Sign::Positive
        } else {
            Sign::None
        };

        // Watch for inf and nan.
        if parser.peek_and_consume_chars(&['n', 'a', 'n']) {
            return NumberParts {
                radix: Radix::Decimal,
                sign: Sign::None,
                is_inf: false,
                is_nan: true,
                whole: String::from(""),
                fraction: None,
                exponent_sign: None,
                exponent: None,
            };
        }
        if parser.peek_and_consume_chars(&['i', 'n', 'f']) {
            let _ = parser.peek_and_consume_chars(&['i', 'n', 'i', 't', 'y']);
            return NumberParts {
                radix: Radix::Decimal,
                sign,
                is_inf: true,
                is_nan: false,
                whole: String::from(""),
                fraction: None,
                exponent_sign: None,
                exponent: None,
            };
        }

        // Try to match (and consume) a radix indicator.
        let radix = self.get_radix(parser);

        // Figure out the style for exponents.
        let exponent_marker = if radix == Radix::Hexadecimal {
            vec!['p', 'P']
        } else if self.settings.permit_hexadecimal {
            vec!['e', 'E', 'p', 'P']
        } else {
            vec!['e', 'E']
        };

        // Now consume digits.  We stop when we encounter the exponent marker or a non-alphanumeric
        // character.
        let (whole_vec, mut last) = if self.settings.permit_underscores {
            parser.take(
                |ch| ch == '_',
                |ch| exponent_marker.contains(&ch) || !ch.is_alphanumeric(),
            )
        } else {
            parser.take(
                |_| false,
                |ch| exponent_marker.contains(&ch) || !ch.is_alphanumeric(),
            )
        };
        let whole = String::from_iter(whole_vec);

        // Look for a decimal point.
        let mut fraction = None;
        if Some('.') == last {
            parser.consume();
            text.push('.');
            let (frac_vec, newlast) = if self.settings.permit_underscores {
                parser.take(
                    |ch| ch == '_',
                    |ch| exponent_marker.contains(&ch) || !ch.is_alphanumeric(),
                )
            } else {
                parser.take(
                    |_| false,
                    |ch| exponent_marker.contains(&ch) || !ch.is_alphanumeric(),
                )
            };
            last = newlast;
            fraction = Some(String::from_iter(frac_vec));
        }

        // Look for an exponent.
        let mut exponent_sign = None;
        let mut exponent = None;
        if let Some(ch) = last {
            if exponent_marker.contains(&ch) {
                parser.consume();

                // Push a p if hexadecial; otherwise push an e.
                text.push(exponent_marker[0]);

                // Watch for a negative sign or a plus sign.
                exponent_sign = if parser.peek_and_consume('-') {
                    Some(Sign::Negative)
                } else if parser.peek_and_consume('+') {
                    Some(Sign::Positive)
                } else {
                    Some(Sign::None)
                };
                exponent = Some(if self.settings.permit_underscores {
                    parser.take_while_unless(|ch| ch.is_alphanumeric(), |ch| ch == '_')
                } else {
                    parser.take_while(|ch| ch.is_alphanumeric())
                });
            }
        }

        // Done.
        NumberParts {
            radix,
            sign,
            is_inf: false,
            is_nan: false,
            whole,
            fraction,
            exponent_sign,
            exponent,
        }
    }

    /// Peek at the stream and guess the radix.
    fn get_radix(&self, parser: &mut ParserCore) -> Radix {
        if self.settings.permit_hexadecimal
            && parser.peek_and_consume_chars(&self.settings.hexadecimal_indicator)
        {
            Radix::Hexadecimal
        } else if self.settings.permit_octal
            && parser.peek_and_consume_chars(&self.settings.octal_indicator)
        {
            Radix::Octal
        } else if self.settings.permit_binary
            && parser.peek_and_consume_chars(&self.settings.binary_indicator)
        {
            Radix::Binary
        } else {
            Radix::Decimal
        }
    }

    /// Parse a floating point number from the stream.  The number's radix is inferred from any
    /// radix prefixes, and only the allowed integer types are checked.
    ///
    /// Floating point numbers can be in any supported radix, and the radix indicator is checked.
    /// It is it not present, then decimal is assumed.  The structure of a floating point number
    /// is as follows.
    ///
    /// ```text
    /// Float  ::= '-'? ( Radix)? ( 'inf' | 'infinity' | 'nan' | Number )
    /// Radix  ::= ( '0x' | '0o' | '0b' )
    /// Number ::= ( Digit+ |
    ///              Digit+ '.' Digit* |
    ///              Digit* '.' Digit+ ) Exp?
    /// Exp    ::= ('e'|'p') ('-'|'+') Digit+
    /// Digit  ::= [0-9a-zA-Z]
    /// ```
    ///
    /// Empty whole and fractional parts may be permitted; refer to the
    /// [`NumberParserSettings::permit_empty_whole`] and [`NumberParserSettings::permit_empty_fraction`]
    /// settings.  A leading zero may be allowed or not.  Refer to
    /// [`NumberParserSettings::permit_leading_zero`].
    /// If both the whole and fractional parts are empty, this is *always* an error.
    ///
    /// The exponent can be indicated with either an `e` or a `p`.  If the radix is hexadecimal,
    /// then *only* `p` can be used to avoid ambiguity.
    ///
    /// Some examples.
    ///
    /// |Number   |Value    |
    /// |---------|---------|
    /// |`0,5`    |0.5      |
    /// |`0b0.1`  |0.5      |
    /// |`0b1e-1` |0.5      |
    /// |`0o0.4`  |0.5      |
    /// |`0x0.8`  |0.5      |
    /// |`0x1.4`  |1.25     |
    /// |`0x3p4`  |196,608  |
    /// |`0b0.12e-2` |0.0029296875 |
    ///
    /// **Caution**: This code does not adhere to the IEEE-754 standard for non-decimal bases!
    /// It uses a "best estimate" approach.  For base 10 [`Self::parse_f64_decimal`] is used, and
    /// is intended to be compliant.
    ///
    pub fn parse_f64(&self, parser: &mut ParserCore) -> ParseResult<f64> {
        // Look for a leading minus sign.
        let negative = parser.peek_and_consume('-');
        if !negative {
            parser.peek_and_consume('+');
        }

        // Look for some special cases.
        if parser.peek_and_consume_chars(&['i', 'n', 'f']) {
            let _ = parser.peek_and_consume_chars(&['i', 'n', 'i', 't', 'y']);
            if negative {
                return Ok(f64::NEG_INFINITY);
            }
            return Ok(f64::INFINITY);
        }
        if parser.peek_and_consume_chars(&['n', 'a', 'n']) {
            return Ok(f64::NAN);
        }

        // Look for a radix indicator in the stream.  If we don't find one, we will assume
        // decimal.  We skip any radix indicators that are either empty or are for a radix
        // that is not allowed.
        let radix = self.get_radix(parser);

        // Parse based on the radix.
        match radix {
            Radix::Binary => parse_binary_float(parser, negative, &self.settings),
            Radix::Hexadecimal => parse_hexadecimal_float(parser, negative, &self.settings),
            Radix::Octal => parse_octal_float(parser, negative, &self.settings),
            _ => parse_decimal_float(parser, negative, &self.settings),
        }
    }

    /// Parse the body of an i128.
    fn parse_i128_body(
        &self,
        parser: &mut ParserCore,
        negative: bool,
        radix: Radix,
    ) -> ParseResult<i128> {
        // Deal with any leading minus sign.
        let mut digits = false;
        let mut nonzero_pending = true;
        let mut value = 0i128;
        let mut fail_mul;
        let mut fail_add;
        let mut fail = false;

        let accumulate = if negative {
            i128::overflowing_sub
        } else {
            i128::overflowing_add
        };
        let base = radix.value();

        // Process all alphanumerics until we encounter a non-alphanumeric character or we encounter
        // an error.
        while !parser.is_at_eof() {
            // Get next potential digit and convert it to the numeric value.  Note that
            // underscores do not count as digits.
            let ch = parser.peek();
            if self.settings.permit_underscores && ch == '_' {
                parser.consume();
                continue;
            }
            let mut dig = ch as u32;
            if (0x30..=0x39).contains(&dig) {
                dig -= 0x30;
            } else if (0x41..0x5B).contains(&(dig & 0xdf)) {
                dig = (dig & 0xdf) - 0x37;
            } else {
                // Not alphanumeric.
                break;
            }
            digits = true;

            // If the digit is larger than the base, reject with an error.
            if dig >= base {
                return Err(syntax_error(
                    parser.loc(),
                    &format!("The digit '{}' is invalid for base {}.", ch, base),
                ));
            }

            // Consume the digit now.
            parser.consume();

            // Accumulate it.  The first non-zero digit is handled differently from
            // subsequent digits.  We discard leading zeros.
            if nonzero_pending {
                if dig > 0 {
                    // This is the first non-zero digit.
                    if negative {
                        value = -(dig as i128);
                    } else {
                        value = dig as i128;
                    }
                    nonzero_pending = false;
                }
            } else {
                (value, fail_mul) = value.overflowing_mul(base as i128);
                (value, fail_add) = accumulate(value, dig as i128);
                fail = fail || fail_mul || fail_add;
            }
        }

        // If we overflowed (or underflowed) during accumulation, issue an error now.
        if fail {
            return Err(syntax_error(
                parser.loc(),
                "Integer value out of bounds for i64",
            ));
        }

        // If we didn't get any digits, then reject with an error.
        if !digits {
            return Err(syntax_error(
                parser.loc(),
                "Expected a number but found no valid digits.",
            ));
        }
        Ok(value)
    }

    /// Read an unsigned from the stream at the current location and compute
    /// and return a `u64` value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number; that can be specified by
    /// the `allow_underscores` flag.
    ///
    /// Number radices are read and processed here.  The arguments allow excluding any radices
    /// you do not want to permit.  Note that we don't generate an error saying that, say,
    /// "octal is not permitted," we just treat the 'o' as an illegal digit.
    ///
    /// **This method does not allow you to change the radix specifiers!**  The default radix
    /// specifiers are always used, if enabled, with the default radix being decimal.  This is
    /// *subject to change* so do not rely on this!
    ///
    /// |Prefix  |Radix       |
    /// |--------|------------|
    /// |`0b`    |Binary      |
    /// |`0o`    |Octal       |
    /// |`0x`    |Hexadecimal |
    ///
    /// If an optional radix is provided, it must be 2, 8, 10, or 16 (it isn't checked here).
    /// In that case no radix indicator is checked or permitted.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    fn parse_u128_body(&self, parser: &mut ParserCore, radix: Radix) -> ParseResult<u128> {
        let mut digits = false;
        let mut nonzero_pending = true;
        let mut value = 0u128;
        let mut fail_mul;
        let mut fail_add;
        let mut fail = false;
        let base = radix.value();

        // Process all alphanumerics until we encounter a non-alphanumeric character or we
        // encounter an error.
        while !parser.is_at_eof() {
            // Get next potential digit and convert it to the numeric value.  Note that
            // underscores do not count as digits.
            let ch = parser.peek();
            if self.settings.permit_underscores && ch == '_' {
                parser.consume();
                continue;
            }
            let mut dig = ch as u32;
            if (0x30..=0x39).contains(&dig) {
                dig -= 0x30;
            } else if (0x41..0x5B).contains(&(dig & 0xdf)) {
                dig = (dig & 0xdf) - 0x37;
            } else {
                // Not alphanumeric.
                break;
            }
            digits = true;

            // If the digit is larger than the base, reject with an error.
            if dig >= base {
                return Err(syntax_error(
                    parser.loc(),
                    &format!("The digit '{}' is invalid for base {}.", ch, base),
                ));
            }

            // Consume the digit now.
            parser.consume();

            // Accumulate it.  The first non-zero digit is handled differently from
            // subsequent digits.
            if nonzero_pending {
                if dig > 0 {
                    // This is the first non-zero digit.
                    value = dig as u128;
                    nonzero_pending = false;
                }
            } else {
                // Accumulate the value and keep track of overflows.
                (value, fail_mul) = value.overflowing_mul(base as u128);
                (value, fail_add) = value.overflowing_add(dig as u128);
                fail = fail || fail_mul || fail_add;
            }
        }

        // Report any overflow.
        if fail {
            return Err(syntax_error(
                parser.loc(),
                "Integer value too large for u64",
            ));
        }

        // If we didn't get any digits, then reject with an error.
        if !digits {
            return Err(syntax_error(
                parser.loc(),
                "Expected a number but found no valid digits",
            ));
        }
        Ok(value)
    }

    /// Read a possibly-signed integer from the stream at the current location and compute
    /// and return an `i64` value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number; that can be specified by
    /// the `allow_underscores` flag.
    ///
    /// Number radices are read and processed here.  The arguments allow excluding any radices
    /// you do not want to permit.  Note that we don't generate an error saying that, say,
    /// "octal is not permitted," we just treat the 'o' as an illegal digit.
    ///
    /// **This method does not allow you to change the radix specifiers!**  The default radix
    /// specifiers are always used, if enabled, with the default radix being decimal.  This is
    /// *subject to change* so do not rely on this!
    ///
    /// |Prefix  |Radix       |
    /// |--------|------------|
    /// |`0b`    |Binary      |
    /// |`0o`    |Octal       |
    /// |`0x`    |Hexadecimal |
    ///
    /// If an optional radix is provided, it must be 2, 8, 10, or 16 (it isn't checked here).
    /// In that case no radix indicator is checked or permitted.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    fn parse_i64_body(
        &self,
        parser: &mut ParserCore,
        negative: bool,
        radix: Radix,
    ) -> ParseResult<i64> {
        // Deal with any leading minus sign.
        let mut digits = false;
        let mut nonzero_pending = true;
        let mut value = 0i64;
        let mut fail_mul;
        let mut fail_add;
        let mut fail = false;

        let accumulate = if negative {
            i64::overflowing_sub
        } else {
            i64::overflowing_add
        };
        let base = radix.value();

        // Now we have the radix and we might have also processed a digit.  Process all
        // alphanumerics until we encounter a non-alphanumeric character or we encounter
        // an error.
        while !parser.is_at_eof() {
            // Get next potential digit and convert it to the numeric value.  Note that
            // underscores do not count as digits.
            let ch = parser.peek();
            if self.settings.permit_underscores && ch == '_' {
                parser.consume();
                continue;
            }
            let mut dig = ch as u32;
            if (0x30..=0x39).contains(&dig) {
                dig -= 0x30;
            } else if (0x41..0x5B).contains(&(dig & 0xdf)) {
                dig = (dig & 0xdf) - 0x37;
            } else {
                // Not alphanumeric.
                break;
            }
            digits = true;

            // If the digit is larger than the base, reject with an error.
            if dig >= base {
                return Err(syntax_error(
                    parser.loc(),
                    &format!("The digit '{}' is invalid for base {}.", ch, base),
                ));
            }

            // Consume the digit now.
            parser.consume();

            // Accumulate it.  The first non-zero digit is handled differently from
            // subsequent digits.  We discard leading zeros.
            if nonzero_pending {
                if dig > 0 {
                    // This is the first non-zero digit.
                    if negative {
                        value = -(dig as i64);
                    } else {
                        value = dig as i64;
                    }
                    nonzero_pending = false;
                }
            } else {
                (value, fail_mul) = value.overflowing_mul(base as i64);
                (value, fail_add) = accumulate(value, dig as i64);
                fail = fail || fail_mul || fail_add;
            }
        }

        // If we overflowed (or underflowed) during accumulation, issue an error now.
        if fail {
            return Err(syntax_error(
                parser.loc(),
                "Integer value out of bounds for i64",
            ));
        }

        // If we didn't get any digits, then reject with an error.
        if !digits {
            return Err(syntax_error(
                parser.loc(),
                "Expected a number but found no valid digits.",
            ));
        }
        Ok(value)
    }

    /// Read an unsigned from the stream at the current location and compute
    /// and return a `u64` value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number; that can be specified by
    /// the `allow_underscores` flag.
    ///
    /// Number radices are read and processed here.  The arguments allow excluding any radices
    /// you do not want to permit.  Note that we don't generate an error saying that, say,
    /// "octal is not permitted," we just treat the 'o' as an illegal digit.
    ///
    /// **This method does not allow you to change the radix specifiers!**  The default radix
    /// specifiers are always used, if enabled, with the default radix being decimal.  This is
    /// *subject to change* so do not rely on this!
    ///
    /// |Prefix  |Radix       |
    /// |--------|------------|
    /// |`0b`    |Binary      |
    /// |`0o`    |Octal       |
    /// |`0x`    |Hexadecimal |
    ///
    /// If an optional radix is provided, it must be 2, 8, 10, or 16 (it isn't checked here).
    /// In that case no radix indicator is checked or permitted.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    fn parse_u64_body(&self, parser: &mut ParserCore, radix: Radix) -> ParseResult<u64> {
        let mut digits = false;
        let mut nonzero_pending = true;
        let mut value = 0u64;
        let mut fail_mul;
        let mut fail_add;
        let mut fail = false;
        let base = radix.value();

        // Now we have the radix and we might have also processed a digit.  Process all
        // alphanumerics until we encounter a non-alphanumeric character or we encounter
        // an error.
        while !parser.is_at_eof() {
            // Get next potential digit and convert it to the numeric value.  Note that
            // underscores do not count as digits.
            let ch = parser.peek();
            if self.settings.permit_underscores && ch == '_' {
                parser.consume();
                continue;
            }
            let mut dig = ch as u32;
            if (0x30..=0x39).contains(&dig) {
                dig -= 0x30;
            } else if (0x41..0x5B).contains(&(dig & 0xdf)) {
                dig = (dig & 0xdf) - 0x37;
            } else {
                // Not alphanumeric.
                break;
            }
            digits = true;

            // If the digit is larger than the base, reject with an error.
            if dig >= base {
                return Err(syntax_error(
                    parser.loc(),
                    &format!("The digit '{}' is invalid for base {}.", ch, base),
                ));
            }

            // Consume the digit now.
            parser.consume();

            // Accumulate it.  The first non-zero digit is handled differently from
            // subsequent digits.
            if nonzero_pending {
                if dig > 0 {
                    // This is the first non-zero digit.
                    value = dig as u64;
                    nonzero_pending = false;
                }
            } else {
                // Accumulate the value and keep track of overflows.
                (value, fail_mul) = value.overflowing_mul(base as u64);
                (value, fail_add) = value.overflowing_add(dig as u64);
                fail = fail || fail_mul || fail_add;
            }
        }

        // Report any overflow.
        if fail {
            return Err(syntax_error(
                parser.loc(),
                "Integer value too large for u64",
            ));
        }

        // If we didn't get any digits, then reject with an error.
        if !digits {
            return Err(syntax_error(
                parser.loc(),
                "Expected a number but found no valid digits",
            ));
        }
        Ok(value)
    }

    /// Parse a floating point number from the stream.  This method assumes the number will be in
    /// decimal and does not look for, or accept, a radix specifier.  Underscores are also not
    /// accepted here.
    ///
    /// The structure of a floating point number is as follows.
    ///
    /// ```text
    /// Float  ::= '-'? ( 'inf' | 'infinity' | 'nan' | Number )
    /// Number ::= ( Digit+ |
    ///              Digit+ '.' Digit* |
    ///              Digit* '.' Digit+ ) Exp?
    /// Exp    ::= [eEpP] ('-'|'+') Digit+
    /// Digit  ::= [0-9]
    /// ```
    ///
    pub fn parse_f64_decimal(&self, parser: &mut ParserCore) -> ParseResult<f64> {
        let negative = parser.peek_and_consume('-');
        if !negative {
            parser.peek_and_consume('+');
        }
        parse_decimal_float(parser, negative, &self.settings)
    }

    /// Read an integer from the stream at the current location and compute
    /// and return its value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number.
    ///
    /// Number radices are read and processed here, based on the configuration.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    pub fn parse_i128(&self, parser: &mut ParserCore) -> ParseResult<i128> {
        let negative = parser.peek_and_consume('-');
        if !negative {
            parser.peek_and_consume('+');
        }
        let radix = self.get_radix(parser);
        self.parse_i128_body(parser, negative, radix)
    }

    /// Read an integer from the stream at the current location and compute
    /// and return its value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number.
    ///
    /// Number radices are read and processed here, based on the configuration.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    pub fn parse_u128(&self, parser: &mut ParserCore) -> ParseResult<u128> {
        let radix = self.get_radix(parser);
        self.parse_u128_body(parser, radix)
    }

    /// Read an integer from the stream at the current location and compute
    /// and return its value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number.
    ///
    /// Number radices are read and processed here, based on the configuration.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    pub fn parse_i64(&self, parser: &mut ParserCore) -> ParseResult<i64> {
        let negative = parser.peek_and_consume('-');
        if !negative {
            parser.peek_and_consume('+');
        }
        let radix = self.get_radix(parser);
        self.parse_i64_body(parser, negative, radix)
    }

    /// Read an integer from the stream at the current location and compute
    /// and return its value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number.
    ///
    /// Number radices are read and processed here, based on the configuration.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    pub fn parse_u64(&self, parser: &mut ParserCore) -> ParseResult<u64> {
        let radix = self.get_radix(parser);
        self.parse_u64_body(parser, radix)
    }

    /// Read an integer from the stream at the current location and compute
    /// and return its value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number.
    ///
    /// The number is parsed according to the given radix.  Radix specifiers are not
    /// permitted.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    pub fn parse_i128_radix(&self, parser: &mut ParserCore, radix: Radix) -> ParseResult<i128> {
        let negative = parser.peek_and_consume('-');
        if !negative {
            parser.peek_and_consume('+');
        }
        self.parse_i128_body(parser, negative, radix)
    }

    /// Read an integer from the stream at the current location and compute
    /// and return its value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number.
    ///
    /// The number is parsed according to the given radix.  Radix specifiers are not
    /// permitted.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    pub fn parse_u128_radix(&self, parser: &mut ParserCore, radix: Radix) -> ParseResult<u128> {
        self.parse_u128_body(parser, radix)
    }

    /// Read an integer from the stream at the current location and compute
    /// and return its value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number.
    ///
    /// The number is parsed according to the given radix.  Radix specifiers are not
    /// permitted.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    pub fn parse_i64_radix(&self, parser: &mut ParserCore, radix: Radix) -> ParseResult<i64> {
        let negative = parser.peek_and_consume('-');
        if !negative {
            parser.peek_and_consume('+');
        }
        self.parse_i64_body(parser, negative, radix)
    }

    /// Read an integer from the stream at the current location and compute
    /// and return its value.  Every alphanumeric character is treated as if it is part
    /// of the number.  Underscores may be permitted in the number.
    ///
    /// The number is parsed according to the given radix.  Radix specifiers are not
    /// permitted.
    ///
    /// Errors are generated if an unexpected alphanumeric character is encountered during
    /// parsing.  The first non-alphanumeric stops the parse.
    pub fn parse_u64_radix(&self, parser: &mut ParserCore, radix: Radix) -> ParseResult<u64> {
        self.parse_u64_body(parser, radix)
    }
}

#[cfg(test)]
mod tests {
    use core::f64;

    use crate::{
        errors::ParseResult,
        numbers::{NumberParser, Radix},
        parse_from_string,
    };

    use super::{NumberParts, Sign};

    #[test]
    fn each() {
        let numpar = NumberParser::new();
        let mut parser = parse_from_string("-7563");
        assert_eq!(numpar.parse_i128(parser.borrow_core()).unwrap(), -7563);
    }

    #[test]
    fn get_text_test() -> ParseResult<()> {
        let source = r#"
            0
            0.0
            -0
            -0.0
            +0
            +0.0
            0x0
            0o0
            0b0
            0x76_5afe
            0b01_0010
            0o14_234
            +0x01_24ffp12
            +12e-14
            1_123_232e-74
            1_123_998E+21
            __1_123_543__P-__12__
            0xfe
            nan
            inf
            +inf
            -inf
            infinity
        "#;
        let result = &[
            (Radix::Decimal, "0".to_string(), false),
            (Radix::Decimal, "0.0".to_string(), true),
            (Radix::Decimal, "-0".to_string(), false),
            (Radix::Decimal, "-0.0".to_string(), true),
            (Radix::Decimal, "0".to_string(), false),
            (Radix::Decimal, "0.0".to_string(), true),
            (Radix::Hexadecimal, "0".to_string(), false),
            (Radix::Octal, "0".to_string(), false),
            (Radix::Binary, "0".to_string(), false),
            (Radix::Hexadecimal, "765afe".to_string(), false),
            (Radix::Binary, "010010".to_string(), false),
            (Radix::Octal, "14234".to_string(), false),
            (Radix::Hexadecimal, "0124ffp12".to_string(), true),
            (Radix::Decimal, "12e-14".to_string(), true),
            (Radix::Decimal, "1123232e-74".to_string(), true),
            (Radix::Decimal, "1123998e21".to_string(), true),
            (Radix::Decimal, "1123543e-12".to_string(), true),
            (Radix::Hexadecimal, "fe".to_string(), false),
            (Radix::Decimal, "nan".to_string(), true),
            (Radix::Decimal, "inf".to_string(), true),
            (Radix::Decimal, "inf".to_string(), true),
            (Radix::Decimal, "-inf".to_string(), true),
            (Radix::Decimal, "inf".to_string(), true),
        ];
        let mut parser = parse_from_string(source);
        let np = NumberParser::new();
        let mut index = 0;
        parser.consume_ws();
        loop {
            if parser.is_at_eof() {
                break;
            }
            print!("Trying {:?}... ", result[index]);
            assert_eq!(result[index], np.get_text(parser.borrow_core()));
            println!("Done");
            parser.consume_ws();
            index += 1;
        }
        Ok(())
    }

    #[test]
    fn get_text_no_underscores_test() -> ParseResult<()> {
        let source = r#"
            0
            0.0
            -0
            -0.0
            +0
            +0.0
            0x0
            0o0
            0b0
            0x765afe
            0b010010
            0o14234
            +0x0124ffp12
            +12e-14
            1123232e-74
            1123998E+21
            1123543P-12
            0xfe
        "#;
        let result = &[
            (Radix::Decimal, "0".to_string(), false),
            (Radix::Decimal, "0.0".to_string(), true),
            (Radix::Decimal, "-0".to_string(), false),
            (Radix::Decimal, "-0.0".to_string(), true),
            (Radix::Decimal, "0".to_string(), false),
            (Radix::Decimal, "0.0".to_string(), true),
            (Radix::Hexadecimal, "0".to_string(), false),
            (Radix::Octal, "0".to_string(), false),
            (Radix::Binary, "0".to_string(), false),
            (Radix::Hexadecimal, "765afe".to_string(), false),
            (Radix::Binary, "010010".to_string(), false),
            (Radix::Octal, "14234".to_string(), false),
            (Radix::Hexadecimal, "0124ffp12".to_string(), true),
            (Radix::Decimal, "12e-14".to_string(), true),
            (Radix::Decimal, "1123232e-74".to_string(), true),
            (Radix::Decimal, "1123998e21".to_string(), true),
            (Radix::Decimal, "1123543e-12".to_string(), true),
            (Radix::Hexadecimal, "fe".to_string(), false),
        ];
        let mut parser = parse_from_string(source);
        let mut np = NumberParser::new();
        np.settings.permit_underscores = false;
        let mut index = 0;
        parser.consume_ws();
        loop {
            if parser.is_at_eof() {
                break;
            }
            print!("Trying {:?}... ", result[index]);
            assert_eq!(result[index], np.get_text(parser.borrow_core()));
            println!("Done");
            parser.consume_ws();
            index += 1;
        }
        Ok(())
    }

    #[test]
    fn get_text_no_hexadecimal_test() -> ParseResult<()> {
        let source = r#"
            0
            0.0
            -0
            -0.0
            +0
            +0.0
            0o0
            0b0
            0b010010
            0o14234
            +12e-14
            1123232e-74
            1123998E+21
        "#;
        let result = &[
            (Radix::Decimal, "0".to_string(), false),
            (Radix::Decimal, "0.0".to_string(), true),
            (Radix::Decimal, "-0".to_string(), false),
            (Radix::Decimal, "-0.0".to_string(), true),
            (Radix::Decimal, "0".to_string(), false),
            (Radix::Decimal, "0.0".to_string(), true),
            (Radix::Octal, "0".to_string(), false),
            (Radix::Binary, "0".to_string(), false),
            (Radix::Binary, "010010".to_string(), false),
            (Radix::Octal, "14234".to_string(), false),
            (Radix::Decimal, "12e-14".to_string(), true),
            (Radix::Decimal, "1123232e-74".to_string(), true),
            (Radix::Decimal, "1123998e21".to_string(), true),
        ];
        let mut parser = parse_from_string(source);
        let mut np = NumberParser::new();
        np.settings.permit_hexadecimal = false;
        let mut index = 0;
        parser.consume_ws();
        loop {
            if parser.is_at_eof() {
                break;
            }
            print!("Trying {:?}... ", result[index]);
            assert_eq!(result[index], np.get_text(parser.borrow_core()));
            println!("Done");
            parser.consume_ws();
            index += 1;
        }
        Ok(())
    }

    #[test]
    fn number_parts_test() {
        let mut parts = NumberParts {
            radix: Radix::Decimal,
            sign: Sign::Negative,
            is_nan: true,
            is_inf: false,
            whole: "16383".to_string(),
            fraction: Some("525".to_string()),
            exponent_sign: Some(Sign::Negative),
            exponent: Some("2".to_string()),
        };
        assert_eq!(parts.as_string(true), "-nan");
        parts.sign = Sign::Positive;
        assert_eq!(parts.as_string(true), "nan");
        parts.is_nan = false;
        parts.is_inf = true;
        assert_eq!(parts.as_string(true), "inf");
        parts.sign = Sign::Negative;
        assert_eq!(parts.as_string(true), "-inf");
        parts.is_inf = false;
        assert_eq!(parts.as_string(true), "-16383.525e-2");
        parts.radix = Radix::Hexadecimal;
        assert_eq!(parts.as_string(false), "-16383.525p-2");
        assert_eq!(parts.as_string(true), "-0x16383.525p-2");
        parts.exponent_sign = Some(Sign::Positive);
        assert_eq!(parts.as_string(true), "-0x16383.525p2");
    }

    #[test]
    fn conversions_test() {
        // Integer conversions.  We can only convert back to signed without a possible error.
        let np: NumberParts = 65536000_u128.into();
        assert_eq!(65536000_i128, np.into());
        let np: NumberParts = 65536000_u64.into();
        assert_eq!(65536000_i64, np.into());
        let value = -6976363876985763_i64;
        let np: NumberParts = value.into();
        assert_eq!(-6976363876985763_i64, np.into());
        let value = -6976363876985763000_i128;
        let np: NumberParts = value.into();
        assert_eq!(-6976363876985763000_i128, np.into());
        let value = 6976363876985763_i64;
        let np: NumberParts = value.into();
        assert_eq!(6976363876985763_i64, np.into());
        let value = 6976363876985763000_i128;
        let np: NumberParts = value.into();
        assert_eq!(6976363876985763000_i128, np.into());

        // Float conversions.
        let nan = f64::NAN;
        let pinf = f64::INFINITY;
        let ninf = f64::NEG_INFINITY;
        let np: NumberParts = nan.into();
        let back: f64 = np.into();
        assert!(back.is_nan());
        let np: NumberParts = pinf.into();
        assert_eq!(f64::INFINITY, np.into());
        let np: NumberParts = ninf.into();
        assert_eq!(f64::NEG_INFINITY, np.into());
        let np: NumberParts = 0.0_f64.into();
        assert_eq!(0.0_f64, np.into());
        let np: NumberParts = 15_f64.into();
        assert_eq!(15_f64, np.into());
        let np: NumberParts = 0.000021_f64.into();
        assert_eq!(0.000021_f64, np.into());
        let np: NumberParts = 81.743e16_f64.into();
        assert_eq!(81.743e16_f64, np.into());
        let value = -81.743e16_f64;
        let np: NumberParts = value.into();
        assert_eq!(value, np.into());
        let value = -81.743e-16_f64;
        let np: NumberParts = value.into();
        assert_eq!(value, np.into());

        // Odd float conversions.
        let np = NumberParts {
            radix: Radix::Binary,
            sign: Sign::Negative,
            is_nan: false,
            is_inf: false,
            whole: "10100110".into(),
            fraction: Some("1".into()),
            exponent_sign: Some(Sign::Positive),
            exponent: Some("1".into()),
        };
        assert_eq!(-333.0, np.into());
        let np = NumberParts {
            radix: Radix::Octal,
            sign: Sign::Positive,
            is_nan: false,
            is_inf: false,
            whole: "0".into(),
            fraction: Some("3404".into()),
            exponent_sign: Some(Sign::Positive),
            exponent: Some("3".into()),
        };
        assert_eq!(224.5, np.into());
        let np = NumberParts {
            radix: Radix::Hexadecimal,
            sign: Sign::Negative,
            is_nan: false,
            is_inf: false,
            whole: "1e4".into(),
            fraction: Some("2".into()),
            exponent_sign: Some(Sign::Negative),
            exponent: Some("2".into()),
        };
        assert_eq!(
            -(256.0 + 14.0 * 16.0 + 4.0 + 2.0 / 16.0) / 16.0 / 16.0,
            np.into()
        );

        // Failed float conversions.
        let np = NumberParts {
            radix: Radix::Octal,
            sign: Sign::Positive,
            is_nan: false,
            is_inf: false,
            whole: "0".into(),
            fraction: Some("384".into()),
            exponent_sign: Some(Sign::Positive),
            exponent: Some("3".into()),
        };
        let value: f64 = np.into();
        assert!(value.is_nan());

        // Zeros.
        let np = NumberParts {
            radix: Radix::Octal,
            sign: Sign::Positive,
            is_nan: false,
            is_inf: false,
            whole: "".into(),
            fraction: None,
            exponent_sign: None,
            exponent: None,
        };
        let value: i64 = np.clone().into();
        assert_eq!(0, value);
        let value: i128 = np.into();
        assert_eq!(0, value);
    }
}