jiter 0.17.0

Fast Iterable JSON parser
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

#[cfg(target_arch = "aarch64")]
mod aarch64;
mod fallback_int;
mod fallback_string;
mod number;
mod swar_int;
#[cfg(target_arch = "x86_64")]
mod x86_64;

pub(crate) use fallback_int::decode_int_chunk as decode_int_chunk_small;
pub(crate) use number::{NumberChunk, decode_number_chunk};

use crate::errors::JsonResult;
use crate::number_decoder::IntChunk;
use crate::string_decoder::StringChunk;

/// the number of digits consumed per `IntChunk::Ongoing` chunk from `decode_int_chunk_big`
#[cfg(all(
    feature = "num-bigint",
    any(target_arch = "x86_64", all(target_arch = "aarch64", target_endian = "little"))
))]
pub(crate) const ONGOING_CHUNK_MULTIPLIER: u64 = 10u64.pow(16);
#[cfg(all(
    feature = "num-bigint",
    not(any(target_arch = "x86_64", all(target_arch = "aarch64", target_endian = "little")))
))]
pub(crate) const ONGOING_CHUNK_MULTIPLIER: u64 = 10u64.pow(18);

#[inline(always)]
pub(crate) fn decode_string_chunk(
    data: &[u8],
    index: usize,
    ascii_only: bool,
    allow_partial: bool,
) -> JsonResult<(StringChunk, bool, usize)> {
    #[cfg(target_arch = "aarch64")]
    {
        aarch64::decode_string_chunk(data, index, ascii_only, allow_partial)
    }
    #[cfg(target_arch = "x86_64")]
    {
        // SAFETY: SSE2 is part of the x86_64 baseline.
        unsafe { x86_64::decode_string_chunk(data, index, ascii_only, allow_partial) }
    }
    #[cfg(not(any(target_arch = "aarch64", target_arch = "x86_64")))]
    {
        fallback_string::decode_string_chunk(data, index, ascii_only, allow_partial)
    }
}

/// Classify sixteen bytes, returning digit values in little-endian byte order and the digit
/// count. Bytes after the first non-digit have unspecified values.
#[inline(always)]
fn classify_digit_chunk(data: &[u8; 16]) -> ([u64; 2], u32) {
    #[cfg(all(target_arch = "aarch64", target_endian = "little"))]
    {
        // SAFETY: all supported aarch64 targets support neon intrinsics.
        unsafe { aarch64::classify_digit_chunk(data) }
    }
    #[cfg(target_arch = "x86_64")]
    {
        // SAFETY: SSE2 is part of the x86_64 baseline.
        unsafe { x86_64::classify_digit_chunk(data) }
    }
    #[cfg(not(any(target_arch = "x86_64", all(target_arch = "aarch64", target_endian = "little"))))]
    {
        fallback_int::classify_digit_chunk(data)
    }
}

#[inline(always)]
pub(crate) fn find_digit_run_end(data: &[u8], index: usize, limit: usize) -> Option<usize> {
    #[cfg(all(target_arch = "aarch64", target_endian = "little"))]
    {
        // SAFETY: all supported aarch64 targets support neon intrinsics.
        unsafe { aarch64::find_digit_run_end(data, index, limit) }
    }
    #[cfg(target_arch = "x86_64")]
    {
        // SAFETY: SSE2 is part of the x86_64 baseline.
        unsafe { x86_64::find_digit_run_end(data, index, limit) }
    }
    #[cfg(not(any(target_arch = "x86_64", all(target_arch = "aarch64", target_endian = "little"))))]
    {
        fallback_int::find_digit_run_end(data, index, limit)
    }
}

#[inline(always)]
pub(crate) fn decode_int_chunk_big(data: &[u8], index: usize) -> (IntChunk, usize) {
    #[cfg(all(target_arch = "aarch64", target_endian = "little"))]
    {
        // SAFETY: all supported aarch64 targets support neon intrinsics
        unsafe { aarch64::decode_int_chunk_big(data, index) }
    }
    #[cfg(target_arch = "x86_64")]
    {
        // SAFETY: SSE2 is part of the x86_64 baseline.
        unsafe { x86_64::decode_int_chunk_big(data, index) }
    }
    #[cfg(not(any(target_arch = "x86_64", all(target_arch = "aarch64", target_endian = "little"))))]
    {
        fallback_int::decode_int_chunk(data, index, 0)
    }
}