//! Config settings for lexical.
use lib::slice;
use super::algorithm::copy_to_dst;
use super::rounding::RoundingKind;
// HELPERS
/// Fixed-size string for float configurations.
///
/// These values are guaranteed less than or equal to the maximum
/// number of bytes after a sign byte has been written.
pub(crate) struct FloatConfigString {
/// Storage data for the config string.
data: [u8; MAX_F32_SIZE - 1],
/// Actual length of the data.
length: usize,
}
impl FloatConfigString {
/// Reset data from a byte string.
pub(crate) fn load_bytes(&mut self, bytes: &[u8]) {
assert!(bytes.len() <= self.data.len());
copy_to_dst(&mut self.data, bytes);
self.length = bytes.len();
}
/// Convert to byte slice.
pub(crate) fn as_bytes(&self) -> &[u8] {
// Always safe, since length can only be set from `load_bytes`.
unsafe {
self.data.get_unchecked(..self.length)
}
}
}
// GLOBALS
cfg_if! {
if #[cfg(feature = "radix")] {
/// Not a Number literal.
static mut NAN_STRING: FloatConfigString = FloatConfigString {
// b"NaN"
data: [b'N', b'a', b'N', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0'],
length: 3
};
/// Short infinity literal.
static mut INF_STRING: FloatConfigString = FloatConfigString {
// b"inf"
data: [b'i', b'n', b'f', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0'],
length: 3
};
/// Long infinity literal.
static mut INFINITY_STRING: FloatConfigString = FloatConfigString {
// b"infinity"
data: [b'i', b'n', b'f', b'i', b'n', b'i', b't', b'y', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0'],
length: 8
};
} else {
/// Not a Number literal.
static mut NAN_STRING: FloatConfigString = FloatConfigString {
// b"NaN"
data: [b'N', b'a', b'N', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0'],
length: 3
};
/// Short infinity literal.
static mut INF_STRING: FloatConfigString = FloatConfigString {
// b"inf"
data: [b'i', b'n', b'f', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0'],
length: 3
};
/// Long infinity literal.
static mut INFINITY_STRING: FloatConfigString = FloatConfigString {
// b"infinity"
data: [b'i', b'n', b'f', b'i', b'n', b'i', b't', b'y', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0', b'0'],
length: 8
};
}} // cfg_if
/// Default character for scientific notation, used when the radix < 15.
///
/// To change the expected, default character for an exponent,
/// change this value during before using lexical.
///
/// # Safety
///
/// Do not modify this value in threaded-code, as it is not thread-safe.
#[no_mangle]
pub static mut EXPONENT_DEFAULT_CHAR: u8 = b'e';
/// Backup character for scientific notation, used when the radix >= 15.
///
/// For numerical strings of radix >= 15, 'e' or 'E' is a valid digit,
/// and therefore may no longer be used as a marker for the exponent.
///
/// To change the expected, default character for an exponent,
/// change this value during before using lexical.
///
/// # Safety
///
/// Do not modify this value in threaded-code, as it is not thread-safe.
#[cfg(feature ="radix")]
#[no_mangle]
pub static mut EXPONENT_BACKUP_CHAR: u8 = b'^';
// GETTERS/SETTERS
// We need both C-FFI compatible getters and setters, and non-FFI ones,
// since we don't want to publicly expose the FloatConfigString type.
/// Helper to get a pointer and size from a FloatConfigString.
#[inline]
unsafe extern fn get_string_ffi(ptr: *mut *const u8, size: *mut usize, string: &'static FloatConfigString)
-> i32
{
if ptr.is_null() || size.is_null() {
-1
} else {
let slc = string.as_bytes();
*ptr = slc.as_ptr();
*size = slc.len();
0
}
}
/// Helper to set a FloatConfigString from a pointer and size.
#[inline]
unsafe extern fn set_string_ffi(ptr: *const u8, size: usize, string: &'static mut FloatConfigString)
-> i32
{
if ptr.is_null() {
-1
} else {
string.load_bytes(slice::from_raw_parts(ptr, size));
0
}
}
/// Get string representation of Not a Number as a byte slice.
#[inline]
pub fn get_nan_string() -> &'static [u8]
{
unsafe {
NAN_STRING.as_bytes()
}
}
/// Get string representation of Not a Number as a pointer and size.
///
/// Returns 0 on success, -1 on error. This string is **not**
/// null-terminated.
///
/// * `ptr` - Out-parameter for a pointer to the string.
/// * `size` - Out-parameter for the size of the string.
///
/// # Safety
///
/// Only use this in C-FFI code, otherwise, you use [`get_nan_string`].
///
/// [`get_nan_string`]: fn.get_nan_string.html
#[no_mangle]
pub unsafe extern fn get_nan_string_ffi(ptr: *mut *const u8, size: *mut usize)
-> i32
{
get_string_ffi(ptr, size, &NAN_STRING)
}
/// Set representation of Not a Number from a byte slice.
///
/// * `bytes` - Slice of bytes to assign as NaN string representation.
///
/// # Safety
///
/// Do not call this function in threaded-code, as it is not thread-safe.
///
/// # Panics
///
/// Panics if `bytes.len() >= MAX_F32_SIZE`.
#[inline]
pub unsafe fn set_nan_string(bytes: &[u8])
{
NAN_STRING.load_bytes(bytes);
}
/// Set representation of Not a Number from a pointer and size.
///
/// Returns 0 on success, -1 on error.
///
/// * `ptr` - Pointer to the first character in the contiguous string.
/// * `size` - Size of the string, without the null-terminator.
///
/// # Safety
///
/// Only use this in C-FFI code, otherwise, you use [`set_nan_string`].
/// Do not call this function in threaded-code, as it is not thread-safe.
///
/// [`set_nan_string`]: fn.set_nan_string.html
///
/// # Panics
///
/// Panics if `bytes.len() >= MAX_F32_SIZE`.
#[no_mangle]
pub unsafe extern fn set_nan_string_ffi(ptr: *const u8, size: usize)
-> i32
{
set_string_ffi(ptr, size, &mut NAN_STRING)
}
/// Get the short representation of an Infinity literal as a byte slice.
#[inline]
pub fn get_inf_string() -> &'static [u8]
{
unsafe {
INF_STRING.as_bytes()
}
}
/// Get the short representation of an Infinity literal as a pointer and size.
///
/// Returns 0 on success, -1 on error. This string is **not**
/// null-terminated.
///
/// * `ptr` - Out-parameter for a pointer to the string.
/// * `size` - Out-parameter for the size of the string.
///
/// # Safety
///
/// Only use this in C-FFI code, otherwise, you use [`get_inf_string`].
///
/// [`get_inf_string`]: fn.get_inf_string.html
#[no_mangle]
pub unsafe extern fn get_inf_string_ffi(ptr: *mut *const u8, size: *mut usize)
-> i32
{
get_string_ffi(ptr, size, &mut INF_STRING)
}
/// Set the short representation of Infinity from a byte slice.
///
/// * `bytes` - Slice of bytes to assign as Infinity string representation.
///
/// # Safety
///
/// Do not call this function in threaded-code, as it is not thread-safe.
///
/// # Panics
///
/// Panics if `bytes.len() >= MAX_F32_SIZE`.
#[inline]
pub unsafe fn set_inf_string(bytes: &[u8])
{
INF_STRING.load_bytes(bytes);
}
/// Set the short representation of Infinity from a pointer and size.
///
/// Returns 0 on success, -1 on error.
///
/// * `ptr` - Pointer to the first character in the contiguous string.
/// * `size` - Size of the string, without the null-terminator.
///
/// # Safety
///
/// Only use this in C-FFI code, otherwise, you use [`set_inf_string`].
/// Do not call this function in threaded-code, as it is not thread-safe.
///
/// [`set_inf_string`]: fn.set_inf_string.html
///
/// # Panics
///
/// Panics if `bytes.len() >= MAX_F32_SIZE`.
#[no_mangle]
pub unsafe extern fn set_inf_string_ffi(ptr: *const u8, size: usize)
-> i32
{
set_string_ffi(ptr, size, &mut INF_STRING)
}
/// Get the long representation of an Infinity literal as a byte slice.
#[inline]
pub fn get_infinity_string() -> &'static [u8]
{
unsafe {
INFINITY_STRING.as_bytes()
}
}
/// Get the long representation of an Infinity literal as a pointer and size.
///
/// Returns 0 on success, -1 on error. This string is **not**
/// null-terminated.
///
/// * `ptr` - Out-parameter for a pointer to the string.
/// * `size` - Out-parameter for the size of the string.
///
/// # Safety
///
/// Only use this in C-FFI code, otherwise, you use [`get_infinity_string`].
///
/// [`get_infinity_string`]: fn.get_infinity_string.html
#[no_mangle]
pub unsafe extern fn get_infinity_string_ffi(ptr: *mut *const u8, size: *mut usize)
-> i32
{
get_string_ffi(ptr, size, &mut INFINITY_STRING)
}
/// Set the long representation of Infinity from a byte slice.
///
/// * `bytes` - Slice of bytes to assign as Infinity string representation.
///
/// # Safety
///
/// Do not call this function in threaded-code, as it is not thread-safe.
///
/// # Panics
///
/// Panics if `bytes.len() >= MAX_F32_SIZE`.
#[inline]
pub unsafe fn set_infinity_string(bytes: &[u8])
{
INFINITY_STRING.load_bytes(bytes);
}
/// Set the long representation of Infinity from a pointer and size.
///
/// Returns 0 on success, -1 on error.
///
/// * `ptr` - Pointer to the first character in the contiguous string.
/// * `size` - Size of the string, without the null-terminator.
///
/// # Safety
///
/// Only use this in C-FFI code, otherwise, you use [`set_infinity_string`].
/// Do not call this function in threaded-code, as it is not thread-safe.
///
/// [`set_infinity_string`]: fn.set_infinity_string.html
///
/// # Panics
///
/// Panics if `bytes.len() >= MAX_F32_SIZE`.
#[no_mangle]
pub unsafe extern fn set_infinity_string_ffi(ptr: *const u8, size: usize)
-> i32
{
set_string_ffi(ptr, size, &mut INFINITY_STRING)
}
// CONSTANTS
// Simple, fast optimization.
// Since we're declaring a variable on the stack, and our power-of-two
// alignment dramatically improved atoi performance, do it.
cfg_if! {
if #[cfg(feature = "radix")] {
// Use 256, actually, since we seem to have memory issues with f64.
// Clearly not sufficient memory allocated for non-base10 values.
/// The minimum buffer size required to serialize any `i8` value.
pub const MAX_I8_SIZE: usize = 16;
/// The minimum buffer size required to serialize any `i16` value.
pub const MAX_I16_SIZE: usize = 32;
/// The minimum buffer size required to serialize any `i32` value.
pub const MAX_I32_SIZE: usize = 64;
/// The minimum buffer size required to serialize any `i64` value.
pub const MAX_I64_SIZE: usize = 128;
/// The minimum buffer size required to serialize any `i128` value.
pub const MAX_I128_SIZE: usize = 256;
/// The minimum buffer size required to serialize any `u8` value.
pub const MAX_U8_SIZE: usize = 16;
/// The minimum buffer size required to serialize any `u16` value.
pub const MAX_U16_SIZE: usize = 32;
/// The minimum buffer size required to serialize any `u32` value.
pub const MAX_U32_SIZE: usize = 64;
/// The minimum buffer size required to serialize any `u64` value.
pub const MAX_U64_SIZE: usize = 128;
/// The minimum buffer size required to serialize any `u128` value.
pub const MAX_U128_SIZE: usize = 256;
/// The minimum buffer size required to serialize any `f32` value.
pub const MAX_F32_SIZE: usize = 256;
/// The minimum buffer size required to serialize any `f64` value.
pub const MAX_F64_SIZE: usize = 256;
} else {
// The f64 buffer is actually a size of 60, but use 64 since it's a
// power of 2.
/// The minimum buffer size required to serialize any `i8` value.
pub const MAX_I8_SIZE: usize = 4;
/// The minimum buffer size required to serialize any `i16` value.
pub const MAX_I16_SIZE: usize = 6;
/// The minimum buffer size required to serialize any `i32` value.
pub const MAX_I32_SIZE: usize = 11;
/// The minimum buffer size required to serialize any `i64` value.
pub const MAX_I64_SIZE: usize = 20;
/// The minimum buffer size required to serialize any `i128` value.
pub const MAX_I128_SIZE: usize = 40;
/// The minimum buffer size required to serialize any `u8` value.
pub const MAX_U8_SIZE: usize = 3;
/// The minimum buffer size required to serialize any `u16` value.
pub const MAX_U16_SIZE: usize = 5;
/// The minimum buffer size required to serialize any `u32` value.
pub const MAX_U32_SIZE: usize = 10;
/// The minimum buffer size required to serialize any `u64` value.
pub const MAX_U64_SIZE: usize = 20;
/// The minimum buffer size required to serialize any `u128` value.
pub const MAX_U128_SIZE: usize = 39;
/// The minimum buffer size required to serialize any `f32` value.
pub const MAX_F32_SIZE: usize = 64;
/// The minimum buffer size required to serialize any `f64` value.
pub const MAX_F64_SIZE: usize = 64;
}} // cfg_if
cfg_if! {
if #[cfg(target_pointer_width = "16")] {
/// The minimum buffer size required to serialize any `isize` value.
pub const MAX_ISIZE_SIZE: usize = MAX_I16_SIZE;
/// The minimum buffer size required to serialize any `usize` value.
pub const MAX_USIZE_SIZE: usize = MAX_U16_SIZE;
} else if #[cfg(target_pointer_width = "32")] {
/// The minimum buffer size required to serialize any `isize` value.
pub const MAX_ISIZE_SIZE: usize = MAX_I32_SIZE;
/// The minimum buffer size required to serialize any `usize` value.
pub const MAX_USIZE_SIZE: usize = MAX_U32_SIZE;
} else if #[cfg(target_pointer_width = "64")] {
/// The minimum buffer size required to serialize any `isize` value.
pub const MAX_ISIZE_SIZE: usize = MAX_I64_SIZE;
/// The minimum buffer size required to serialize any `usize` value.
pub const MAX_USIZE_SIZE: usize = MAX_U64_SIZE;
}} // cfg_if
/// The maximum number of bytes that any number-to-string function may write.
pub const BUFFER_SIZE: usize = MAX_F64_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `i8` value.
#[no_mangle]
pub static MAX_I8_SIZE_FFI: usize = MAX_I8_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `i16` value.
#[no_mangle]
pub static MAX_I16_SIZE_FFI: usize = MAX_I16_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `i32` value.
#[no_mangle]
pub static MAX_I32_SIZE_FFI: usize = MAX_I32_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `i64` value.
#[no_mangle]
pub static MAX_I64_SIZE_FFI: usize = MAX_I64_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `i128` value.
#[no_mangle]
pub static MAX_I128_SIZE_FFI: usize = MAX_I128_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `isize` value.
#[no_mangle]
pub static MAX_ISIZE_SIZE_FFI: usize = MAX_ISIZE_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `u8` value.
#[no_mangle]
pub static MAX_U8_SIZE_FFI: usize = MAX_U8_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `u16` value.
#[no_mangle]
pub static MAX_U16_SIZE_FFI: usize = MAX_U16_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `u32` value.
#[no_mangle]
pub static MAX_U32_SIZE_FFI: usize = MAX_U32_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `u64` value.
#[no_mangle]
pub static MAX_U64_SIZE_FFI: usize = MAX_U64_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `u128` value.
#[no_mangle]
pub static MAX_U128_SIZE_FFI: usize = MAX_U128_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `usize` value.
#[no_mangle]
pub static MAX_USIZE_SIZE_FFI: usize = MAX_USIZE_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `f32` value.
#[no_mangle]
pub static MAX_F32_SIZE_FFI: usize = MAX_F32_SIZE;
/// Symbol-generating constant for the minimum buffer required to serialize any `f64` value.
#[no_mangle]
pub static MAX_F64_SIZE_FFI: usize = MAX_F64_SIZE;
/// Symbol-generating constant for the maximum number of bytes that any number-to-string function may write.
#[no_mangle]
pub static BUFFER_SIZE_FFI: usize = BUFFER_SIZE;
/// The rounding scheme for float conversions.
///
/// This defines the global rounding-scheme for float parsing operations.
/// By default, this is set to `RoundingKind::NearestTieEven`. IEEE754
/// recommends this as the default for all for decimal and binary
/// operations.
///
/// # Safety
///
/// Do not modify this value in threaded-code, as it is not thread-safe.
/// See the documentation for [`RoundingKind`] for the permissible
/// values of `FLOAT_ROUNDING` in FFI-code.
///
/// [`RoundingKind`]: enum.RoundingKind.html
#[no_mangle]
#[cfg(feature = "rounding")]
pub static mut FLOAT_ROUNDING: RoundingKind = RoundingKind::NearestTieEven;
// FUNCTIONS
/// Get the exponent notation character.
#[inline]
#[allow(unused_variables)]
pub(crate) fn exponent_notation_char(radix: u32) -> u8 {
unsafe {
#[cfg(not(feature ="radix"))] {
EXPONENT_DEFAULT_CHAR
}
#[cfg(feature ="radix")] {
if radix >= 15 { EXPONENT_BACKUP_CHAR } else { EXPONENT_DEFAULT_CHAR }
}
}
}
// TEST
// ----
#[cfg(test)]
mod tests {
use atof::*;
use ftoa::*;
use util::*;
use util::test::*;
use super::*;
#[cfg(feature ="radix")]
#[test]
fn exponent_notation_char_test() {
unsafe {
assert_eq!(exponent_notation_char(2), EXPONENT_DEFAULT_CHAR);
assert_eq!(exponent_notation_char(8), EXPONENT_DEFAULT_CHAR);
assert_eq!(exponent_notation_char(10), EXPONENT_DEFAULT_CHAR);
assert_eq!(exponent_notation_char(15), EXPONENT_BACKUP_CHAR);
assert_eq!(exponent_notation_char(16), EXPONENT_BACKUP_CHAR);
assert_eq!(exponent_notation_char(32), EXPONENT_BACKUP_CHAR);
}
}
// Only enable when no other threads touch NAN_STRING or INFINITY_STRING.
#[test]
#[ignore]
fn special_bytes_test() {
unsafe {
let mut buffer = new_buffer();
// Test serializing and deserializing special strings.
assert!(try_atof32_slice(b"NaN").value.is_nan());
assert!(try_atof32_slice(b"nan").value.is_nan());
assert!(try_atof32_slice(b"NAN").value.is_nan());
assert!(try_atof32_slice(b"inf").value.is_infinite());
assert!(try_atof32_slice(b"INF").value.is_infinite());
assert!(try_atof32_slice(b"Infinity").value.is_infinite());
assert_eq!(f64toa_slice(f64::NAN, &mut buffer), b"NaN");
assert_eq!(f64toa_slice(f64::INFINITY, &mut buffer), b"inf");
NAN_STRING.load_bytes(b"nan");
INF_STRING.load_bytes(b"Infinity");
assert!(try_atof32_slice(b"inf").error.code == ErrorCode::InvalidDigit);
assert!(try_atof32_slice(b"Infinity").value.is_infinite());
assert_eq!(f64toa_slice(f64::NAN, &mut buffer), b"nan");
assert_eq!(f64toa_slice(f64::INFINITY, &mut buffer), b"Infinity");
NAN_STRING.load_bytes(b"NaN");
INF_STRING.load_bytes(b"inf");
}
}
// Only enable when no other threads touch FLOAT_ROUNDING.
#[cfg(all(feature = "correct", feature = "rounding"))]
#[test]
#[ignore]
fn special_rounding_test() {
// Each one of these pairs is halfway, and we can detect the
// rounding schemes from this.
unsafe {
// Nearest, tie-even
FLOAT_ROUNDING = RoundingKind::NearestTieEven;
assert_eq!(try_atof64_slice(b"-9007199254740993").value, -9007199254740992.0);
assert_eq!(try_atof64_slice(b"-9007199254740995").value, -9007199254740996.0);
assert_eq!(try_atof64_slice(b"9007199254740993").value, 9007199254740992.0);
assert_eq!(try_atof64_slice(b"9007199254740995").value, 9007199254740996.0);
// Nearest, tie-away-zero
FLOAT_ROUNDING = RoundingKind::NearestTieAwayZero;
assert_eq!(try_atof64_slice(b"-9007199254740993").value, -9007199254740994.0);
assert_eq!(try_atof64_slice(b"-9007199254740995").value, -9007199254740996.0);
assert_eq!(try_atof64_slice(b"9007199254740993").value, 9007199254740994.0);
assert_eq!(try_atof64_slice(b"9007199254740995").value, 9007199254740996.0);
// Toward positive infinity
FLOAT_ROUNDING = RoundingKind::TowardPositiveInfinity;
assert_eq!(try_atof64_slice(b"-9007199254740993").value, -9007199254740992.0);
assert_eq!(try_atof64_slice(b"-9007199254740995").value, -9007199254740994.0);
assert_eq!(try_atof64_slice(b"9007199254740993").value, 9007199254740994.0);
assert_eq!(try_atof64_slice(b"9007199254740995").value, 9007199254740996.0);
// Toward negative infinity
FLOAT_ROUNDING = RoundingKind::TowardNegativeInfinity;
assert_eq!(try_atof64_slice(b"-9007199254740993").value, -9007199254740994.0);
assert_eq!(try_atof64_slice(b"-9007199254740995").value, -9007199254740996.0);
assert_eq!(try_atof64_slice(b"9007199254740993").value, 9007199254740992.0);
assert_eq!(try_atof64_slice(b"9007199254740995").value, 9007199254740994.0);
// Toward zero
FLOAT_ROUNDING = RoundingKind::TowardZero;
assert_eq!(try_atof64_slice(b"-9007199254740993").value, -9007199254740992.0);
assert_eq!(try_atof64_slice(b"-9007199254740995").value, -9007199254740994.0);
assert_eq!(try_atof64_slice(b"9007199254740993").value, 9007199254740992.0);
assert_eq!(try_atof64_slice(b"9007199254740995").value, 9007199254740994.0);
// Reset to default
FLOAT_ROUNDING = RoundingKind::NearestTieEven;
}
}
// Only enable when no other threads touch FLOAT_ROUNDING.
#[cfg(all(feature = "correct", feature = "radix", feature = "rounding"))]
#[test]
#[ignore]
fn special_rounding_binary_test() {
// Each one of these pairs is halfway, and we can detect the
// rounding schemes from this.
unsafe {
// Nearest, tie-even
FLOAT_ROUNDING = RoundingKind::NearestTieEven;
assert_eq!(try_atof64_radix_slice(2, b"-100000000000000000000000000000000000000000000000000001").value, -9007199254740992.0);
assert_eq!(try_atof64_radix_slice(2, b"-100000000000000000000000000000000000000000000000000011").value, -9007199254740996.0);
assert_eq!(try_atof64_radix_slice(2, b"100000000000000000000000000000000000000000000000000001").value, 9007199254740992.0);
assert_eq!(try_atof64_radix_slice(2, b"100000000000000000000000000000000000000000000000000011").value, 9007199254740996.0);
// Nearest, tie-away-zero
FLOAT_ROUNDING = RoundingKind::NearestTieAwayZero;
assert_eq!(try_atof64_radix_slice(2, b"-100000000000000000000000000000000000000000000000000001").value, -9007199254740994.0);
assert_eq!(try_atof64_radix_slice(2, b"-100000000000000000000000000000000000000000000000000011").value, -9007199254740996.0);
assert_eq!(try_atof64_radix_slice(2, b"100000000000000000000000000000000000000000000000000001").value, 9007199254740994.0);
assert_eq!(try_atof64_radix_slice(2, b"100000000000000000000000000000000000000000000000000011").value, 9007199254740996.0);
// Toward positive infinity
FLOAT_ROUNDING = RoundingKind::TowardPositiveInfinity;
assert_eq!(try_atof64_radix_slice(2, b"-100000000000000000000000000000000000000000000000000001").value, -9007199254740992.0);
assert_eq!(try_atof64_radix_slice(2, b"-100000000000000000000000000000000000000000000000000011").value, -9007199254740994.0);
assert_eq!(try_atof64_radix_slice(2, b"100000000000000000000000000000000000000000000000000001").value, 9007199254740994.0);
assert_eq!(try_atof64_radix_slice(2, b"100000000000000000000000000000000000000000000000000011").value, 9007199254740996.0);
// Toward negative infinity
FLOAT_ROUNDING = RoundingKind::TowardNegativeInfinity;
assert_eq!(try_atof64_radix_slice(2, b"-100000000000000000000000000000000000000000000000000001").value, -9007199254740994.0);
assert_eq!(try_atof64_radix_slice(2, b"-100000000000000000000000000000000000000000000000000011").value, -9007199254740996.0);
assert_eq!(try_atof64_radix_slice(2, b"100000000000000000000000000000000000000000000000000001").value, 9007199254740992.0);
assert_eq!(try_atof64_radix_slice(2, b"100000000000000000000000000000000000000000000000000011").value, 9007199254740994.0);
// Toward zero
FLOAT_ROUNDING = RoundingKind::TowardZero;
assert_eq!(try_atof64_radix_slice(2, b"-100000000000000000000000000000000000000000000000000001").value, -9007199254740992.0);
assert_eq!(try_atof64_radix_slice(2, b"-100000000000000000000000000000000000000000000000000011").value, -9007199254740994.0);
assert_eq!(try_atof64_radix_slice(2, b"100000000000000000000000000000000000000000000000000001").value, 9007199254740992.0);
assert_eq!(try_atof64_radix_slice(2, b"100000000000000000000000000000000000000000000000000011").value, 9007199254740994.0);
// Reset to default
FLOAT_ROUNDING = RoundingKind::NearestTieEven;
}
}
}