| 1 |
/// Find and parse sign and get remaining bytes. |
| 2 |
#[inline] |
| 3 |
fn parse_sign<'a>(bytes: &'a [u8]) -> (bool, &'a [u8]) { |
| 4 |
match bytes.get(0) { |
| 5 |
Some(&b'+') => (true, &bytes[1..]), |
| 6 |
Some(&b'-') => (false, &bytes[1..]), |
| 7 |
_ => (true, bytes), |
| 8 |
} |
| 9 |
} |
| 10 |
|
| 11 |
// Convert u8 to digit. |
| 12 |
#[inline] |
| 13 |
fn to_digit(c: u8) -> Option<u32> { |
| 14 |
(c as char).to_digit(10) |
| 15 |
} |
| 16 |
|
| 17 |
// Add digit from exponent. |
| 18 |
#[inline] |
| 19 |
fn add_digit_i32(value: i32, digit: u32) -> Option<i32> { |
| 20 |
return value.checked_mul(10)?.checked_add(digit as i32); |
| 21 |
} |
| 22 |
|
| 23 |
// Subtract digit from exponent. |
| 24 |
#[inline] |
| 25 |
fn sub_digit_i32(value: i32, digit: u32) -> Option<i32> { |
| 26 |
return value.checked_mul(10)?.checked_sub(digit as i32); |
| 27 |
} |
| 28 |
|
| 29 |
// Convert character to digit. |
| 30 |
#[inline] |
| 31 |
fn is_digit(c: u8) -> bool { |
| 32 |
to_digit(c).is_some() |
| 33 |
} |
| 34 |
|
| 35 |
// Split buffer at index. |
| 36 |
#[inline] |
| 37 |
fn split_at_index<'a>(digits: &'a [u8], index: usize) -> (&'a [u8], &'a [u8]) { |
| 38 |
(&digits[..index], &digits[index..]) |
| 39 |
} |
| 40 |
|
| 41 |
/// Consume until a an invalid digit is found. |
| 42 |
/// |
| 43 |
/// - `digits` - Slice containing 0 or more digits. |
| 44 |
#[inline] |
| 45 |
fn consume_digits<'a>(digits: &'a [u8]) -> (&'a [u8], &'a [u8]) { |
| 46 |
// Consume all digits. |
| 47 |
let mut index = 0; |
| 48 |
while index < digits.len() && is_digit(digits[index]) { |
| 49 |
index += 1; |
| 50 |
} |
| 51 |
split_at_index(digits, index) |
| 52 |
} |
| 53 |
|
| 54 |
// Trim leading 0s. |
| 55 |
#[inline] |
| 56 |
fn ltrim_zero<'a>(bytes: &'a [u8]) -> &'a [u8] { |
| 57 |
let count = bytes.iter().take_while(|&&si| si == b'0').count(); |
| 58 |
&bytes[count..] |
| 59 |
} |
| 60 |
|
| 61 |
// Trim trailing 0s. |
| 62 |
#[inline] |
| 63 |
fn rtrim_zero<'a>(bytes: &'a [u8]) -> &'a [u8] { |
| 64 |
let count = bytes.iter().rev().take_while(|&&si| si == b'0').count(); |
| 65 |
let index = bytes.len() - count; |
| 66 |
&bytes[..index] |
| 67 |
} |
| 68 |
|
| 69 |
// PARSERS |
| 70 |
// ------- |
| 71 |
|
| 72 |
/// Parse the exponent of the float. |
| 73 |
/// |
| 74 |
/// * `exponent` - Slice containing the exponent digits. |
| 75 |
/// * `is_positive` - If the exponent sign is positive. |
| 76 |
fn parse_exponent(exponent: &[u8], is_positive: bool) -> i32 { |
| 77 |
// Parse the sign bit or current data. |
| 78 |
let mut value: i32 = 0; |
| 79 |
match is_positive { |
| 80 |
true => { |
| 81 |
for c in exponent { |
| 82 |
value = match add_digit_i32(value, to_digit(*c).unwrap()) { |
| 83 |
Some(v) => v, |
| 84 |
None => return i32::max_value(), |
| 85 |
}; |
| 86 |
} |
| 87 |
}, |
| 88 |
false => { |
| 89 |
for c in exponent { |
| 90 |
value = match sub_digit_i32(value, to_digit(*c).unwrap()) { |
| 91 |
Some(v) => v, |
| 92 |
None => return i32::min_value(), |
| 93 |
}; |
| 94 |
} |
| 95 |
}, |
| 96 |
} |
| 97 |
|
| 98 |
value |
| 99 |
} |
| 100 |
|
| 101 |
pub fn case_insensitive_starts_with<'a, 'b, Iter1, Iter2>(mut x: Iter1, mut y: Iter2) -> bool |
| 102 |
where |
| 103 |
Iter1: Iterator<Item = &'a u8>, |
| 104 |
Iter2: Iterator<Item = &'b u8>, |
| 105 |
{ |
| 106 |
// We use a faster optimization here for ASCII letters, which NaN |
| 107 |
// and infinite strings **must** be. [A-Z] is 0x41-0x5A, while |
| 108 |
// [a-z] is 0x61-0x7A. Therefore, the xor must be 0 or 32 if they |
| 109 |
// are case-insensitive equal, but only if at least 1 of the inputs |
| 110 |
// is an ASCII letter. |
| 111 |
loop { |
| 112 |
let yi = y.next(); |
| 113 |
if yi.is_none() { |
| 114 |
return true; |
| 115 |
} |
| 116 |
let yi = *yi.unwrap(); |
| 117 |
let is_not_equal = x.next().map_or(true, |&xi| { |
| 118 |
let xor = xi ^ yi; |
| 119 |
xor != 0 && xor != 0x20 |
| 120 |
}); |
| 121 |
if is_not_equal { |
| 122 |
return false; |
| 123 |
} |
| 124 |
} |
| 125 |
} |
| 126 |
|
| 127 |
/// Parse float from input bytes, returning the float and the remaining bytes. |
| 128 |
/// |
| 129 |
/// * `bytes` - Array of bytes leading with float-data. |
| 130 |
pub fn parse_float<'a, F>(bytes: &'a [u8]) -> (F, &'a [u8]) |
| 131 |
where |
| 132 |
F: minimal_lexical::Float, |
| 133 |
{ |
| 134 |
let start = bytes; |
| 135 |
|
| 136 |
// Parse the sign. |
| 137 |
let (is_positive, bytes) = parse_sign(bytes); |
| 138 |
|
| 139 |
// Check NaN, Inf, Infinity |
| 140 |
if case_insensitive_starts_with(bytes.iter(), b"NaN".iter()) { |
| 141 |
let mut float = F::from_bits(F::EXPONENT_MASK | (F::HIDDEN_BIT_MASK >> 1)); |
| 142 |
if !is_positive { |
| 143 |
float = -float; |
| 144 |
} |
| 145 |
return (float, &bytes[3..]); |
| 146 |
} else if case_insensitive_starts_with(bytes.iter(), b"Infinity".iter()) { |
| 147 |
let mut float = F::from_bits(F::EXPONENT_MASK); |
| 148 |
if !is_positive { |
| 149 |
float = -float; |
| 150 |
} |
| 151 |
return (float, &bytes[8..]); |
| 152 |
} else if case_insensitive_starts_with(bytes.iter(), b"inf".iter()) { |
| 153 |
let mut float = F::from_bits(F::EXPONENT_MASK); |
| 154 |
if !is_positive { |
| 155 |
float = -float; |
| 156 |
} |
| 157 |
return (float, &bytes[3..]); |
| 158 |
} |
| 159 |
|
| 160 |
// Extract and parse the float components: |
| 161 |
// 1. Integer |
| 162 |
// 2. Fraction |
| 163 |
// 3. Exponent |
| 164 |
let (integer_slc, bytes) = consume_digits(bytes); |
| 165 |
let (fraction_slc, bytes) = match bytes.first() { |
| 166 |
Some(&b'.') => consume_digits(&bytes[1..]), |
| 167 |
_ => (&bytes[..0], bytes), |
| 168 |
}; |
| 169 |
let (exponent, bytes) = match bytes.first() { |
| 170 |
Some(&b'e') | Some(&b'E') => { |
| 171 |
// Extract and parse the exponent. |
| 172 |
let (is_positive, bytes) = parse_sign(&bytes[1..]); |
| 173 |
let (exponent, bytes) = consume_digits(bytes); |
| 174 |
(parse_exponent(exponent, is_positive), bytes) |
| 175 |
}, |
| 176 |
_ => (0, bytes), |
| 177 |
}; |
| 178 |
|
| 179 |
if bytes.len() == start.len() { |
| 180 |
return (F::from_u64(0), bytes); |
| 181 |
} |
| 182 |
|
| 183 |
// Note: You may want to check and validate the float data here: |
| 184 |
// 1). Many floats require integer or fraction digits, if a fraction |
| 185 |
// is present. |
| 186 |
// 2). All floats require either integer or fraction digits. |
| 187 |
// 3). Some floats do not allow a '+' sign before the significant digits. |
| 188 |
// 4). Many floats require exponent digits after the exponent symbol. |
| 189 |
// 5). Some floats do not allow a '+' sign before the exponent. |
| 190 |
|
| 191 |
// We now need to trim leading and trailing 0s from the integer |
| 192 |
// and fraction, respectively. This is required to make the |
| 193 |
// fast and moderate paths more efficient, and for the slow |
| 194 |
// path. |
| 195 |
let integer_slc = ltrim_zero(integer_slc); |
| 196 |
let fraction_slc = rtrim_zero(fraction_slc); |
| 197 |
|
| 198 |
// Create the float and return our data. |
| 199 |
let mut float: F = |
| 200 |
minimal_lexical::parse_float(integer_slc.iter(), fraction_slc.iter(), exponent); |
| 201 |
if !is_positive { |
| 202 |
float = -float; |
| 203 |
} |
| 204 |
|
| 205 |
(float, bytes) |
| 206 |
} |
| 207 |
|
| 208 |
macro_rules! b { |
| 209 |
($x:literal) => { |
| 210 |
$x.as_bytes() |
| 211 |
}; |
| 212 |
} |
| 213 |
|
| 214 |
#[test] |
| 215 |
fn f32_test() { |
| 216 |
assert_eq!( |
| 217 |
(184467440000000000000.0, b!("\x00\x00006")), |
| 218 |
parse_float::<f32>(b"000184467440737095516150\x00\x00006") |
| 219 |
); |
| 220 |
} |
| 221 |
|
| 222 |
#[test] |
| 223 |
fn f64_test() { |
| 224 |
assert_eq!( |
| 225 |
(184467440737095500000.0, b!("\x00\x00006")), |
| 226 |
parse_float::<f64>(b"000184467440737095516150\x00\x00006") |
| 227 |
); |
| 228 |
} |