#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum ScalarError {
UnterminatedString,
InvalidEscape,
InvalidUnicodeEscape,
LoneSurrogate,
ControlCharacterInString,
InvalidNumber,
InvalidLiteral,
TrailingGarbageAfterScalar,
}
impl std::fmt::Display for ScalarError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Self::UnterminatedString => "unterminated string",
Self::InvalidEscape => "invalid escape sequence",
Self::InvalidUnicodeEscape => "invalid \\u escape",
Self::LoneSurrogate => "lone UTF-16 surrogate",
Self::ControlCharacterInString => "raw control character in string",
Self::InvalidNumber => "invalid number",
Self::InvalidLiteral => "invalid literal",
Self::TrailingGarbageAfterScalar => "unexpected characters after value",
})
}
}
impl std::error::Error for ScalarError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StrPart<'j, 's> {
Borrowed(&'j str),
Decoded(&'s str),
DecodedRaw(&'s [u8]),
}
#[inline(always)]
#[must_use]
pub fn is_token_boundary(b: u8) -> bool {
matches!(
b,
b' ' | b'\t' | b'\n' | b'\r' | b'{' | b'}' | b'[' | b']' | b':' | b','
)
}
#[inline(always)]
fn find_special_scalar(input: &[u8], mut from: usize) -> Option<(usize, u8)> {
while from < input.len() {
let b = input[from];
if b == b'"' || b == b'\\' || b < 0x20 {
return Some((from, b));
}
from += 1;
}
None
}
#[inline(always)]
fn find_special(input: &[u8], mut from: usize) -> Option<(usize, u8)> {
#[cfg(target_arch = "aarch64")]
unsafe {
use crate::scan::{MODE_STANDARD, neon};
use std::arch::aarch64::{vld1q_u8, vmaxvq_u8, vorrq_u8};
if from + 16 <= input.len() {
let mask = neon::hit_mask::<MODE_STANDARD>(vld1q_u8(input.as_ptr().add(from)));
if mask != 0 {
let i = from + (mask.trailing_zeros() as usize) / 4;
return Some((i, input[i]));
}
from += 16;
}
while from + 32 <= input.len() {
let h0 = neon::hit_vec::<MODE_STANDARD>(vld1q_u8(input.as_ptr().add(from)));
let h1 = neon::hit_vec::<MODE_STANDARD>(vld1q_u8(input.as_ptr().add(from + 16)));
if vmaxvq_u8(vorrq_u8(h0, h1)) == 0 {
from += 32;
continue;
}
let m0 = neon::nib_mask(h0);
let i = if m0 != 0 {
from + (m0.trailing_zeros() as usize) / 4
} else {
from + 16 + (neon::nib_mask(h1).trailing_zeros() as usize) / 4
};
return Some((i, input[i]));
}
while from + 16 <= input.len() {
let mask = neon::hit_mask::<MODE_STANDARD>(vld1q_u8(input.as_ptr().add(from)));
if mask != 0 {
let i = from + (mask.trailing_zeros() as usize) / 4;
return Some((i, input[i]));
}
from += 16;
}
if from < input.len() && input.len() >= 16 {
return neon::tail_find::<MODE_STANDARD>(input, from).map(|i| (i, input[i]));
}
}
#[cfg(target_arch = "x86_64")]
unsafe {
use crate::scan::{MODE_STANDARD, x86};
use std::arch::x86_64::_mm_loadu_si128;
if std::arch::is_x86_feature_detected!("avx2") {
return find_special_avx2(input, from);
}
while from + 16 <= input.len() {
let mask = x86::sse2_hit_mask::<MODE_STANDARD>(_mm_loadu_si128(
input.as_ptr().add(from).cast(),
));
if mask != 0 {
let i = from + mask.trailing_zeros() as usize;
return Some((i, input[i]));
}
from += 16;
}
if from < input.len() && input.len() >= 16 {
return x86::sse2_tail_find::<MODE_STANDARD>(input, from).map(|i| (i, input[i]));
}
}
find_special_scalar(input, from)
}
#[cfg(target_arch = "x86_64")]
#[target_feature(enable = "avx2")]
fn find_special_avx2(input: &[u8], mut from: usize) -> Option<(usize, u8)> {
unsafe {
use crate::scan::{MODE_STANDARD, x86};
use std::arch::x86_64::_mm256_loadu_si256;
while from + 32 <= input.len() {
let mask = x86::avx2_hit_mask::<MODE_STANDARD>(_mm256_loadu_si256(
input.as_ptr().add(from).cast(),
));
if mask != 0 {
let i = from + mask.trailing_zeros() as usize;
return Some((i, input[i]));
}
from += 32;
}
if from < input.len() && input.len() >= 32 {
return x86::avx2_tail_find::<MODE_STANDARD>(input, from).map(|i| (i, input[i]));
}
find_special_scalar(input, from)
}
}
const HEX_TABLE: [u8; 256] = {
let mut t = [0xFFu8; 256];
let mut i = 0;
while i < 10 {
t[b'0' as usize + i] = i as u8;
i += 1;
}
let mut i = 0;
while i < 6 {
t[b'a' as usize + i] = 10 + i as u8;
t[b'A' as usize + i] = 10 + i as u8;
i += 1;
}
t
};
#[inline(always)]
fn hex4(input: &[u8], at: usize) -> Result<u32, ScalarError> {
if at + 4 > input.len() {
return Err(ScalarError::InvalidUnicodeEscape);
}
let mut v: u32 = 0;
let mut bad: u8 = 0;
for &b in &input[at..at + 4] {
let d = HEX_TABLE[b as usize];
bad |= d;
v = v << 4 | (d & 0x0F) as u32;
}
if bad & 0x80 != 0 {
return Err(ScalarError::InvalidUnicodeEscape);
}
Ok(v)
}
#[inline(always)]
unsafe fn write_utf8_raw(dst: *mut u8, cp: u32) -> usize {
unsafe {
match cp {
0..=0x7F => {
dst.write(cp as u8);
1
}
0x80..=0x7FF => {
dst.write(0xC0 | (cp >> 6) as u8);
dst.add(1).write(0x80 | (cp & 0x3F) as u8);
2
}
0x800..=0xFFFF => {
dst.write(0xE0 | (cp >> 12) as u8);
dst.add(1).write(0x80 | ((cp >> 6) & 0x3F) as u8);
dst.add(2).write(0x80 | (cp & 0x3F) as u8);
3
}
_ => {
dst.write(0xF0 | (cp >> 18) as u8);
dst.add(1).write(0x80 | ((cp >> 12) & 0x3F) as u8);
dst.add(2).write(0x80 | ((cp >> 6) & 0x3F) as u8);
dst.add(3).write(0x80 | (cp & 0x3F) as u8);
4
}
}
}
}
#[inline]
pub unsafe fn parse_string<'j, 's>(
input: &'j [u8],
quote_idx: usize,
scratch: &'s mut Vec<u8>,
) -> Result<(StrPart<'j, 's>, usize), ScalarError> {
let start = quote_idx + 1;
let (first_special, byte) =
find_special(input, start).ok_or(ScalarError::UnterminatedString)?;
if byte == b'"' {
let span = &input[start..first_special];
let s = unsafe { std::str::from_utf8_unchecked(span) };
return Ok((StrPart::Borrowed(s), first_special + 1));
}
if byte != b'\\' {
return Err(ScalarError::ControlCharacterInString);
}
scratch.clear();
scratch.reserve((input.len() - start) + DECODE_SLACK);
let base = scratch.as_mut_ptr();
let mut scratch_raw = false;
let mut w = first_special - start;
unsafe {
std::ptr::copy_nonoverlapping(input.as_ptr().add(start), base, w);
}
let mut i = first_special;
loop {
let esc = *input.get(i + 1).ok_or(ScalarError::UnterminatedString)?;
i += 2;
unsafe {
match esc {
b'"' => push_byte_raw(base, &mut w, b'"'),
b'\\' => push_byte_raw(base, &mut w, b'\\'),
b'/' => push_byte_raw(base, &mut w, b'/'),
b'b' => push_byte_raw(base, &mut w, 0x08),
b'f' => push_byte_raw(base, &mut w, 0x0C),
b'n' => push_byte_raw(base, &mut w, b'\n'),
b'r' => push_byte_raw(base, &mut w, b'\r'),
b't' => push_byte_raw(base, &mut w, b'\t'),
b'u' => {
let cp = hex4(input, i)?;
i += 4;
if (0xD800..=0xDBFF).contains(&cp) {
if input.get(i) == Some(&b'\\') && input.get(i + 1) == Some(&b'u') {
let lo = hex4(input, i + 2)?;
if !(0xDC00..=0xDFFF).contains(&lo) {
return Err(ScalarError::LoneSurrogate);
}
i += 6;
let combined = 0x10000 + ((cp - 0xD800) << 10) + (lo - 0xDC00);
w += write_utf8_raw(base.add(w), combined);
} else {
return Err(ScalarError::LoneSurrogate);
}
} else if (0xDC00..=0xDFFF).contains(&cp) {
w += write_utf8_raw(base.add(w), cp);
scratch_raw = true;
} else {
w += write_utf8_raw(base.add(w), cp);
}
}
_ => return Err(ScalarError::InvalidEscape),
}
}
if input.get(i) == Some(&b'\\') {
continue;
}
let (next, byte, next_w) =
unsafe { decode_span(input, i, base, w) }.ok_or(ScalarError::UnterminatedString)?;
w = next_w;
i = next;
if byte == b'"' {
unsafe {
scratch.set_len(w);
}
let part = if scratch_raw {
StrPart::DecodedRaw(scratch.as_slice())
} else {
StrPart::Decoded(unsafe { std::str::from_utf8_unchecked(scratch) })
};
return Ok((part, i + 1));
}
if byte != b'\\' {
return Err(ScalarError::ControlCharacterInString);
}
}
}
const DECODE_SLACK: usize = 16;
#[inline(always)]
unsafe fn push_byte_raw(base: *mut u8, w: &mut usize, b: u8) {
unsafe {
base.add(*w).write(b);
}
*w += 1;
}
#[cfg(target_arch = "aarch64")]
#[inline(always)]
unsafe fn decode_span(
input: &[u8],
mut i: usize,
dst: *mut u8,
mut w: usize,
) -> Option<(usize, u8, usize)> {
use crate::scan::{MODE_STANDARD, neon, padded_tail};
unsafe {
while i + 16 <= input.len() {
let mask = neon::copy_scan::<MODE_STANDARD>(input.as_ptr().add(i), dst.add(w));
if mask != 0 {
let k = (mask.trailing_zeros() as usize) / 4;
return Some((i + k, input[i + k], w + k));
}
i += 16;
w += 16;
}
let rem = input.len() - i;
if rem == 0 {
return None;
}
let chunk = padded_tail::<16>(&input[i..]);
let mask = neon::copy_scan::<MODE_STANDARD>(chunk.as_ptr(), dst.add(w))
& (u64::MAX >> (64 - 4 * rem));
if mask != 0 {
let k = (mask.trailing_zeros() as usize) / 4;
Some((i + k, input[i + k], w + k))
} else {
None
}
}
}
#[cfg(target_arch = "x86_64")]
#[inline(always)]
unsafe fn decode_span(
input: &[u8],
mut i: usize,
dst: *mut u8,
mut w: usize,
) -> Option<(usize, u8, usize)> {
use crate::scan::{MODE_STANDARD, padded_tail, x86};
unsafe {
while i + 16 <= input.len() {
let mask = x86::sse2_copy_scan::<MODE_STANDARD>(input.as_ptr().add(i), dst.add(w));
if mask != 0 {
let k = mask.trailing_zeros() as usize;
return Some((i + k, input[i + k], w + k));
}
i += 16;
w += 16;
}
let rem = input.len() - i;
if rem == 0 {
return None;
}
let chunk = padded_tail::<16>(&input[i..]);
let mask =
x86::sse2_copy_scan::<MODE_STANDARD>(chunk.as_ptr(), dst.add(w)) & ((1u64 << rem) - 1);
if mask != 0 {
let k = mask.trailing_zeros() as usize;
Some((i + k, input[i + k], w + k))
} else {
None
}
}
}
#[cfg(not(any(target_arch = "aarch64", target_arch = "x86_64")))]
#[inline(always)]
unsafe fn decode_span(
input: &[u8],
mut i: usize,
dst: *mut u8,
mut w: usize,
) -> Option<(usize, u8, usize)> {
while i < input.len() {
let b = input[i];
if b == b'"' || b == b'\\' || b < 0x20 {
return Some((i, b, w));
}
unsafe {
dst.add(w).write(b);
}
i += 1;
w += 1;
}
None
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub enum Number<'j> {
Int(i64),
NegativeZero,
Float(f64),
Big(&'j str),
}
#[inline(always)]
fn parse_8digits_le(mut v: u64) -> u64 {
const MASK: u64 = 0x0000_00FF_0000_00FF;
const MUL1: u64 = 0x000F_4240_0000_0064; const MUL2: u64 = 0x0000_2710_0000_0001; v = v.wrapping_sub(0x3030_3030_3030_3030);
v = v.wrapping_mul(10).wrapping_add(v >> 8);
let v1 = (v & MASK).wrapping_mul(MUL1);
let v2 = ((v >> 16) & MASK).wrapping_mul(MUL2);
((v1.wrapping_add(v2) >> 32) as u32) as u64
}
#[inline(always)]
fn parse_4digits_le(mut v: u32) -> u64 {
v = v.wrapping_sub(0x3030_3030);
v = v.wrapping_mul(10).wrapping_add(v >> 8);
(((v & 0xFF) * 100) + ((v >> 16) & 0xFF)) as u64
}
#[inline(always)]
fn scan_digits_acc(input: &[u8], mut i: usize, acc: &mut u64) -> usize {
const HI: u64 = 0xF0F0_F0F0_F0F0_F0F0;
const ALL_DIGITS: u64 = 0x3333_3333_3333_3333;
while i + 8 <= input.len() {
let chunk = u64::from_le_bytes(input[i..i + 8].try_into().unwrap());
let matched = (chunk & HI) | ((chunk.wrapping_add(0x0606_0606_0606_0606) & HI) >> 4);
if matched == ALL_DIGITS {
*acc = acc
.wrapping_mul(100_000_000)
.wrapping_add(parse_8digits_le(chunk));
i += 8;
continue;
}
let mut consecutive = ((matched ^ ALL_DIGITS).trailing_zeros() / 8) as usize;
if consecutive >= 4 {
*acc = acc
.wrapping_mul(10_000)
.wrapping_add(parse_4digits_le(chunk as u32));
i += 4;
consecutive -= 4;
}
while consecutive > 0 {
*acc = acc.wrapping_mul(10).wrapping_add((input[i] - b'0') as u64);
i += 1;
consecutive -= 1;
}
return i;
}
while let Some(&b) = input.get(i) {
if !b.is_ascii_digit() {
break;
}
*acc = acc.wrapping_mul(10).wrapping_add((b - b'0') as u64);
i += 1;
}
i
}
#[inline]
pub fn parse_number(input: &[u8], start: usize) -> Result<(Number<'_>, usize), ScalarError> {
let mut i = start;
let negative = input[i] == b'-';
if negative {
i += 1;
}
let mut mantissa: u64 = 0;
let int_start = i;
match input.get(i) {
Some(b'0') => i += 1, Some(b'1'..=b'9') => i = scan_digits_acc(input, i, &mut mantissa),
_ => return Err(ScalarError::InvalidNumber),
}
let int_end = i;
let mut frac_start = i;
let mut frac_end = i;
if input.get(i) == Some(&b'.') {
i += 1;
frac_start = i;
i = scan_digits_acc(input, i, &mut mantissa);
frac_end = i;
if frac_end == frac_start {
return Err(ScalarError::InvalidNumber);
}
}
let mut explicit_exp: i64 = 0;
let mut has_exp = false;
if matches!(input.get(i), Some(b'e' | b'E')) {
has_exp = true;
i += 1;
let exp_negative = match input.get(i) {
Some(b'-') => {
i += 1;
true
}
Some(b'+') => {
i += 1;
false
}
_ => false,
};
let exp_start = i;
let mut abs_exp: u64 = 0;
i = scan_digits_acc(input, i, &mut abs_exp);
if i == exp_start {
return Err(ScalarError::InvalidNumber);
}
let mut sig_start = exp_start;
while input.get(sig_start) == Some(&b'0') {
sig_start += 1;
}
explicit_exp = if i - sig_start >= 19 || abs_exp > i64::MAX as u64 {
i64::MAX
} else {
abs_exp as i64
};
if exp_negative {
explicit_exp = explicit_exp.wrapping_neg();
}
}
if let Some(&b) = input.get(i)
&& !is_token_boundary(b)
{
return Err(ScalarError::TrailingGarbageAfterScalar);
}
if frac_end == frac_start && !has_exp {
let digits = int_end - int_start;
if digits <= 19 {
if negative {
if mantissa == 0 {
return Ok((Number::NegativeZero, i));
}
if mantissa <= i64::MAX as u64 + 1 {
return Ok((Number::Int((mantissa as i64).wrapping_neg()), i));
}
} else if i64::try_from(mantissa).is_ok() {
return Ok((Number::Int(mantissa as i64), i));
}
}
let digits = unsafe { std::str::from_utf8_unchecked(&input[start..i]) };
return Ok((Number::Big(digits), i));
}
let int_len = int_end - int_start;
let frac_len = frac_end - frac_start;
let sig = if input[int_start] == b'0' && int_len == 1 {
frac_len
- input[frac_start..frac_end]
.iter()
.take_while(|&&b| b == b'0')
.count()
} else {
int_len + frac_len
};
if sig <= 19 {
let w = mantissa;
let exp10 = explicit_exp.saturating_sub(frac_len as i64);
let f = 'fast: {
if w == 0 {
break 'fast Some(0.0);
}
if w < (1 << 53) && (-22..=22).contains(&exp10) {
let m = w as f64;
break 'fast Some(if exp10 < 0 {
m / crate::float::POW10[(-exp10) as usize]
} else {
m * crate::float::POW10[exp10 as usize]
});
}
if exp10 < -342 {
break 'fast Some(0.0);
}
if exp10 > 308 {
break 'fast Some(f64::INFINITY);
}
crate::float::eisel_lemire(w, exp10)
};
if let Some(f) = f {
return Ok((Number::Float(if negative { -f } else { f }), i));
}
}
let f =
fast_float2::parse::<f64, _>(&input[start..i]).map_err(|_| ScalarError::InvalidNumber)?;
Ok((Number::Float(f), i))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Literal {
True,
False,
Null,
}
#[inline]
pub fn parse_literal(input: &[u8], start: usize) -> Result<(Literal, usize), ScalarError> {
let rest = &input[start..];
let (lit, end) = if rest.starts_with(b"true") {
(Literal::True, start + 4)
} else if rest.starts_with(b"false") {
(Literal::False, start + 5)
} else if rest.starts_with(b"null") {
(Literal::Null, start + 4)
} else {
return Err(ScalarError::InvalidLiteral);
};
if let Some(&b) = input.get(end)
&& !is_token_boundary(b)
{
return Err(ScalarError::TrailingGarbageAfterScalar);
}
Ok((lit, end))
}
#[cfg(test)]
mod tests {
use super::*;
fn parse_str_owned(doc: &[u8]) -> Result<(String, usize), ScalarError> {
let mut scratch = Vec::new();
let (part, end) = unsafe { parse_string(doc, 0, &mut scratch) }?;
let s = match part {
StrPart::Borrowed(s) | StrPart::Decoded(s) => s.to_string(),
StrPart::DecodedRaw(b) => String::from_utf8_lossy(b).into_owned(),
};
Ok((s, end))
}
fn parse_str_raw_bytes(doc: &[u8]) -> Result<(Vec<u8>, bool), ScalarError> {
let mut scratch = Vec::new();
let (part, _) = unsafe { parse_string(doc, 0, &mut scratch) }?;
Ok(match part {
StrPart::Borrowed(s) | StrPart::Decoded(s) => (s.as_bytes().to_vec(), false),
StrPart::DecodedRaw(b) => (b.to_vec(), true),
})
}
#[test]
fn plain_string() {
assert_eq!(
parse_str_owned(br#""hello", tail"#).unwrap(),
("hello".into(), 7)
);
}
#[test]
fn escapes() {
assert_eq!(
parse_str_owned(br#""a\"b\\c\nd\t""#).unwrap().0,
"a\"b\\c\nd\t"
);
}
#[test]
fn unicode_escape() {
assert_eq!(parse_str_owned(b"\"A\\u00e9\"").unwrap().0, "A\u{e9}");
}
#[test]
fn surrogate_pair() {
assert_eq!(
parse_str_owned(b"\"\\ud83d\\ude00\"").unwrap().0,
"\u{1F600}"
);
}
#[test]
fn lone_high_surrogate_rejected() {
assert_eq!(
parse_str_owned(br#""\ud800xx""#).unwrap_err(),
ScalarError::LoneSurrogate
);
assert_eq!(
parse_str_owned(b"\"\\ud800\"").unwrap_err(),
ScalarError::LoneSurrogate
);
}
#[test]
fn lone_low_surrogate_emitted_as_wtf8() {
let (bytes, raw) = parse_str_raw_bytes(b"\"\\uDFAA\"").unwrap();
assert!(raw);
assert_eq!(bytes, [0xED, 0xBE, 0xAA]);
let (bytes, raw) = parse_str_raw_bytes(b"\"\\uDd1ea\"").unwrap();
assert!(raw);
assert_eq!(bytes, [0xED, 0xB4, 0x9E, b'a']);
}
#[test]
fn control_char_rejected() {
assert_eq!(
parse_str_owned(b"\"a\x01b\"").unwrap_err(),
ScalarError::ControlCharacterInString
);
}
#[test]
fn unterminated() {
assert_eq!(
parse_str_owned(br#""abc"#).unwrap_err(),
ScalarError::UnterminatedString
);
}
#[test]
fn long_string_simd_path() {
let mut doc = vec![b'"'];
doc.extend(std::iter::repeat_n(b'x', 1000));
doc.push(b'"');
let (s, end) = parse_str_owned(&doc).unwrap();
assert_eq!(s.len(), 1000);
assert_eq!(end, 1002);
}
#[test]
fn numbers() {
assert_eq!(parse_number(b"0,", 0).unwrap(), (Number::Int(0), 1));
assert_eq!(parse_number(b"-1", 0).unwrap(), (Number::Int(-1), 2));
assert_eq!(parse_number(b"-0,", 0).unwrap(), (Number::NegativeZero, 2));
assert_eq!(parse_number(b"-0.0", 0).unwrap().0, Number::Float(-0.0));
assert_eq!(
parse_number(b"9223372036854775807", 0).unwrap().0,
Number::Int(i64::MAX)
);
assert_eq!(
parse_number(b"-9223372036854775808", 0).unwrap().0,
Number::Int(i64::MIN)
);
assert_eq!(parse_number(b"1.5", 0).unwrap().0, Number::Float(1.5));
assert_eq!(parse_number(b"1e3", 0).unwrap().0, Number::Float(1000.0));
assert_eq!(
parse_number(b"-2.5e-2", 0).unwrap().0,
Number::Float(-0.025)
);
assert_eq!(
parse_number(b"123456789012345678901", 0).unwrap().0,
Number::Big("123456789012345678901")
);
}
#[test]
fn string_boundary_sweep() {
for len in 0..=40 {
let content = &"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN"[..len];
let doc: Box<[u8]> = format!("\"{content}\"").into_bytes().into_boxed_slice();
let (s, end) = parse_str_owned(&doc).unwrap();
assert_eq!(s, content, "len {len}");
assert_eq!(end, doc.len(), "len {len}");
for pos in 0..len {
let mut inner = content.to_string().into_bytes();
inner[pos] = b'\\';
inner.insert(pos + 1, b'n');
let doc: Box<[u8]> = format!("\"{}\"", String::from_utf8(inner).unwrap())
.into_bytes()
.into_boxed_slice();
let (s, _) = parse_str_owned(&doc).unwrap();
let mut expected = content.to_string();
expected.replace_range(pos..=pos, "\n");
assert_eq!(s, expected, "len {len} escape at {pos}");
}
let doc: Box<[u8]> = format!("\"{content}").into_bytes().into_boxed_slice();
assert_eq!(
parse_str_owned(&doc).unwrap_err(),
ScalarError::UnterminatedString,
"unterminated len {len}"
);
}
}
#[test]
fn exponent_leading_zeros() {
let long_zero = b"1e00000000000000000000000";
assert_eq!(parse_number(long_zero, 0).unwrap().0, Number::Float(1.0));
assert_eq!(
parse_number(b"1e-00000000000000000000001", 0).unwrap().0,
Number::Float(0.1)
);
assert_eq!(
parse_number(b"9999999999999999991e00000000000000000000000", 0)
.unwrap()
.0,
Number::Float(9999999999999999991.0)
);
assert_eq!(
parse_number(b"1e0000000000000000000009999", 0).unwrap().0,
Number::Float(f64::INFINITY)
);
assert_eq!(
parse_number(b"1e-0000000000000000000009999", 0).unwrap().0,
Number::Float(0.0)
);
}
#[test]
fn bad_numbers() {
for bad in [&b"01"[..], b"-", b"1.", b".5", b"1e", b"1e+", b"+1"] {
assert!(parse_number(bad, 0).is_err(), "accepted {bad:?}");
}
}
#[test]
fn literals() {
assert_eq!(parse_literal(b"true,", 0).unwrap(), (Literal::True, 4));
assert_eq!(parse_literal(b"false]", 0).unwrap(), (Literal::False, 5));
assert_eq!(parse_literal(b"null}", 0).unwrap(), (Literal::Null, 4));
assert!(parse_literal(b"nul", 0).is_err());
assert!(parse_literal(b"tru", 0).is_err());
}
}