Function parse_float

cranelift/codegen/src/ir/immediates.rs:971–1121

Parse a float using the same format as `format_float` above. The encoding parameters are: w - exponent field width in bits t - trailing significand field width in bits

(s: &str, w: u8, t: u8)

/// t - trailing significand field width in bits
///
fn parse_float(s: &str, w: u8, t: u8) -> Result<u128, &'static str> {
    debug_assert!(w > 0 && w <= 16, "Invalid exponent range");
    debug_assert!(1 + w + t <= 128, "Too large IEEE format for u128");
    debug_assert!((t + w + 1).is_power_of_two(), "Unexpected IEEE format size");

    let (sign_bit, s2) = if let Some(num) = s.strip_prefix('-') {
        (1u128 << (t + w), num)
    } else if let Some(num) = s.strip_prefix('+') {
        (0, num)
    } else {
        (0, s)
    };

    if !s2.starts_with("0x") {
        let max_e_bits = ((1u128 << w) - 1) << t;
        let quiet_bit = 1u128 << (t - 1);

        // The only decimal encoding allowed is 0.
        if s2 == "0.0" {
            return Ok(sign_bit);
        }

        if s2 == "Inf" {
            // +/- infinity: e = max, t = 0.
            return Ok(sign_bit | max_e_bits);
        }
        if s2 == "NaN" {
            // Canonical quiet NaN: e = max, t = quiet.
            return Ok(sign_bit | max_e_bits | quiet_bit);
        }
        if let Some(nan) = s2.strip_prefix("NaN:0x") {
            // Quiet NaN with payload.
            return match u128::from_str_radix(nan, 16) {
                Ok(payload) if payload < quiet_bit => {
                    Ok(sign_bit | max_e_bits | quiet_bit | payload)
                }
                _ => Err("Invalid NaN payload"),
            };
        }
        if let Some(nan) = s2.strip_prefix("sNaN:0x") {
            // Signaling NaN with payload.
            return match u128::from_str_radix(nan, 16) {
                Ok(payload) if 0 < payload && payload < quiet_bit => {
                    Ok(sign_bit | max_e_bits | payload)
                }
                _ => Err("Invalid sNaN payload"),
            };
        }

        return Err("Float must be hexadecimal");
    }
    let s3 = &s2[2..];

    let mut digits = 0u8;
    let mut digits_before_period: Option<u8> = None;
    let mut significand = 0u128;
    let mut exponent = 0i32;