Merge pull request #1 from boa-dev/fix/buffer-overflow

Author: HalidOdat

Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "ryu-js"
-version = "1.0.5" # don't forget to update html_root_url
+version = "0.1.0" # don't forget to update html_root_url
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 license = "Apache-2.0 OR BSL-1.0"
-description = "Fast floating point to string conversion"
-repository = "https://github.com/dtolnay/ryu"
-documentation = "https://docs.rs/ryu"
+description = "Fast floating point to string conversion, ECMAScript compliant."
+repository = "https://github.com/boa-dev/ryu-js"
+documentation = "https://docs.rs/ryu-js"
 readme = "README.md"
 edition = "2018"
 

README.md

@@ -1,9 +1,10 @@
-# Ryū
+# Ryū-js
 
-[<img alt="github" src="https://img.shields.io/badge/github-dtolnay/ryu-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/dtolnay/ryu)
-[<img alt="crates.io" src="https://img.shields.io/crates/v/ryu.svg?style=for-the-badge&color=fc8d62&logo=rust" height="20">](https://crates.io/crates/ryu)
-[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-ryu-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K" height="20">](https://docs.rs/ryu)
-[<img alt="build status" src="https://img.shields.io/github/workflow/status/dtolnay/ryu/CI/master?style=for-the-badge" height="20">](https://github.com/dtolnay/ryu/actions?query=branch%3Amaster)
+Ryū-js is a fork of the [ryu][ryu-crate] crate adjusted to comply to the ECMAScript [number-to-string][number-to-string] algorithm.
+This crate is used in the `Boa` crate for number to string conversions
+
+[ryu-crate]: https://crates.io/crates/ryu
+[number-to-string]: https://tc39.es/ecma262/#sec-numeric-types-number-tostring
 
 Pure Rust implementation of Ryū, an algorithm to quickly convert floating point
 numbers to decimal strings.
@@ -15,46 +16,27 @@ under the creative commons CC-BY-SA license.
 This Rust implementation is a line-by-line port of Ulf Adams' implementation in
 C, [https://github.com/ulfjack/ryu][upstream].
 
-*Requirements: this crate supports any compiler version back to rustc 1.31; it
-uses nothing from the Rust standard library so is usable from no_std crates.*
-
 [paper]: https://dl.acm.org/citation.cfm?id=3192369
 [upstream]: https://github.com/ulfjack/ryu/tree/1c413e127f8d02afd12eb6259bc80163722f1385
 
 ```toml
 [dependencies]
-ryu = "1.0"
+ryu-js = "0.1"
 ```
 
 ## Example
 
 ```rust
 fn main() {
-    let mut buffer = ryu::Buffer::new();
+    let mut buffer = ryu_js::Buffer::new();
     let printed = buffer.format(1.234);
     assert_eq!(printed, "1.234");
 }
 ```
 
 ## Performance
 
-You can run upstream's benchmarks with:
-
-```console
-$ git clone https://github.com/ulfjack/ryu c-ryu
-$ cd c-ryu
-$ bazel run -c opt //ryu/benchmark
-```
-
-And the same benchmark against our implementation with:
-
-```console
-$ git clone https://github.com/dtolnay/ryu rust-ryu
-$ cd rust-ryu
-$ cargo run --example upstream_benchmark --release
-```
-
-These benchmarks measure the average time to print a 32-bit float and average
+The benchmarks measure the average time to print a 32-bit float and average
 time to print a 64-bit float, where the inputs are distributed as uniform random
 bit patterns 32 and 64 bits wide.
 

benches/bench.rs

@@ -15,7 +15,7 @@ macro_rules! benches {
             $(
                 #[bench]
                 fn $name(b: &mut Bencher) {
-                    let mut buf = ryu::Buffer::new();
+                    let mut buf = ryu_js::Buffer::new();
 
                     b.iter(move || {
                         let value = black_box($value);

examples/upstream_benchmark.rs

@@ -53,7 +53,7 @@ macro_rules! benchmark {
 
                 let t1 = std::time::SystemTime::now();
                 for _ in 0..ITERATIONS {
-                    throwaway += ryu::Buffer::new().format_finite(f).len();
+                    throwaway += ryu_js::Buffer::new().format_finite(f).len();
                 }
                 let duration = t1.elapsed().unwrap();
                 let nanos = duration.as_secs() * 1_000_000_000 + duration.subsec_nanos() as u64;

src/buffer/mod.rs

@@ -1,28 +1,28 @@
 use crate::raw;
 #[cfg(maybe_uninit)]
 use core::mem::MaybeUninit;
-use core::{mem, slice, str};
+use core::{slice, str};
 #[cfg(feature = "no-panic")]
 use no_panic::no_panic;
 
-const NAN: &'static str = "NaN";
-const INFINITY: &'static str = "Infinity";
-const NEG_INFINITY: &'static str = "-Infinity";
+const NAN: &str = "NaN";
+const INFINITY: &str = "Infinity";
+const NEG_INFINITY: &str = "-Infinity";
 
 /// Safe API for formatting floating point numbers to text.
 ///
 /// ## Example
 ///
 /// ```
-/// let mut buffer = ryu::Buffer::new();
+/// let mut buffer = ryu_js::Buffer::new();
 /// let printed = buffer.format_finite(1.234);
 /// assert_eq!(printed, "1.234");
 /// ```
 pub struct Buffer {
     #[cfg(maybe_uninit)]
-    bytes: [MaybeUninit<u8>; 24],
+    bytes: [MaybeUninit<u8>; 25],
     #[cfg(not(maybe_uninit))]
-    bytes: [u8; 24],
+    bytes: [u8; 25],
 }
 
 impl Buffer {
@@ -34,11 +34,11 @@ impl Buffer {
         // assume_init is safe here, since this is an array of MaybeUninit, which does not need
         // to be initialized.
         #[cfg(maybe_uninit)]
-        let bytes = [MaybeUninit::<u8>::uninit(); 24];
+        let bytes = [MaybeUninit::<u8>::uninit(); 25];
         #[cfg(not(maybe_uninit))]
         let bytes = unsafe { mem::uninitialized() };
 
-        Buffer { bytes: bytes }
+        Buffer { bytes }
     }
 
     /// Print a floating point number into this buffer and return a reference to
@@ -47,11 +47,13 @@ impl Buffer {
     /// # Special cases
     ///
     /// This function formats NaN as the string "NaN", positive infinity as
-    /// "inf", and negative infinity as "-inf" to match std::fmt.
+    /// "Infinity", and negative infinity as "-Infinity" to match the [ECMAScript specification][spec].
     ///
     /// If your input is known to be finite, you may get better performance by
     /// calling the `format_finite` method instead of `format` to avoid the
     /// checks for special cases.
+    ///
+    /// [spec]: https://tc39.es/ecma262/#sec-numeric-types-number-tostring
     #[cfg_attr(feature = "no-panic", inline)]
     #[cfg_attr(feature = "no-panic", no_panic)]
     pub fn format<F: Float>(&mut self, f: F) -> &str {
@@ -125,7 +127,7 @@ impl Sealed for f32 {
     #[inline]
     fn is_nonfinite(self) -> bool {
         const EXP_MASK: u32 = 0x7f800000;
-        let bits = unsafe { mem::transmute::<f32, u32>(self) };
+        let bits = self.to_bits();
         bits & EXP_MASK == EXP_MASK
     }
 
@@ -134,7 +136,7 @@ impl Sealed for f32 {
     fn format_nonfinite(self) -> &'static str {
         const MANTISSA_MASK: u32 = 0x007fffff;
         const SIGN_MASK: u32 = 0x80000000;
-        let bits = unsafe { mem::transmute::<f32, u32>(self) };
+        let bits = self.to_bits();
         if bits & MANTISSA_MASK != 0 {
             NAN
         } else if bits & SIGN_MASK != 0 {
@@ -154,7 +156,7 @@ impl Sealed for f64 {
     #[inline]
     fn is_nonfinite(self) -> bool {
         const EXP_MASK: u64 = 0x7ff0000000000000;
-        let bits = unsafe { mem::transmute::<f64, u64>(self) };
+        let bits = self.to_bits();
         bits & EXP_MASK == EXP_MASK
     }
 
@@ -163,7 +165,7 @@ impl Sealed for f64 {
     fn format_nonfinite(self) -> &'static str {
         const MANTISSA_MASK: u64 = 0x000fffffffffffff;
         const SIGN_MASK: u64 = 0x8000000000000000;
-        let bits = unsafe { mem::transmute::<f64, u64>(self) };
+        let bits = self.to_bits();
         if bits & MANTISSA_MASK != 0 {
             NAN
         } else if bits & SIGN_MASK != 0 {

src/lib.rs

@@ -1,13 +1,5 @@
-//! [![github]](https://github.com/dtolnay/ryu) [![crates-io]](https://crates.io/crates/ryu) [![docs-rs]](https://docs.rs/ryu)
-//!
-//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
-//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
-//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logoColor=white&logo=data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgdmlld0JveD0iMCAwIDUxMiA1MTIiPjxwYXRoIGZpbGw9IiNmNWY1ZjUiIGQ9Ik00ODguNiAyNTAuMkwzOTIgMjE0VjEwNS41YzAtMTUtOS4zLTI4LjQtMjMuNC0zMy43bC0xMDAtMzcuNWMtOC4xLTMuMS0xNy4xLTMuMS0yNS4zIDBsLTEwMCAzNy41Yy0xNC4xIDUuMy0yMy40IDE4LjctMjMuNCAzMy43VjIxNGwtOTYuNiAzNi4yQzkuMyAyNTUuNSAwIDI2OC45IDAgMjgzLjlWMzk0YzAgMTMuNiA3LjcgMjYuMSAxOS45IDMyLjJsMTAwIDUwYzEwLjEgNS4xIDIyLjEgNS4xIDMyLjIgMGwxMDMuOS01MiAxMDMuOSA1MmMxMC4xIDUuMSAyMi4xIDUuMSAzMi4yIDBsMTAwLTUwYzEyLjItNi4xIDE5LjktMTguNiAxOS45LTMyLjJWMjgzLjljMC0xNS05LjMtMjguNC0yMy40LTMzLjd6TTM1OCAyMTQuOGwtODUgMzEuOXYtNjguMmw4NS0zN3Y3My4zek0xNTQgMTA0LjFsMTAyLTM4LjIgMTAyIDM4LjJ2LjZsLTEwMiA0MS40LTEwMi00MS40di0uNnptODQgMjkxLjFsLTg1IDQyLjV2LTc5LjFsODUtMzguOHY3NS40em0wLTExMmwtMTAyIDQxLjQtMTAyLTQxLjR2LS42bDEwMi0zOC4yIDEwMiAzOC4ydi42em0yNDAgMTEybC04NSA0Mi41di03OS4xbDg1LTM4Ljh2NzUuNHptMC0xMTJsLTEwMiA0MS40LTEwMi00MS40di0uNmwxMDItMzguMiAxMDIgMzguMnYuNnoiPjwvcGF0aD48L3N2Zz4K
-//!
-//! <br>
-//!
-//! Pure Rust implementation of Ryū, an algorithm to quickly convert floating
-//! point numbers to decimal strings.
+//! ECMAScript compliant pure Rust implementation of Ryū, an algorithm to quickly
+//! convert floating point numbers to decimal strings.
 //!
 //! The PLDI'18 paper [*Ryū: fast float-to-string conversion*][paper] by Ulf
 //! Adams includes a complete correctness proof of the algorithm. The paper is
@@ -23,31 +15,15 @@
 //!
 //! ```
 //! fn main() {
-//!     let mut buffer = ryu::Buffer::new();
+//!     let mut buffer = ryu_js::Buffer::new();
 //!     let printed = buffer.format(1.234);
 //!     assert_eq!(printed, "1.234");
 //! }
 //! ```
 //!
 //! ## Performance
 //!
-//! You can run upstream's benchmarks with:
-//!
-//! ```console
-//! $ git clone https://github.com/ulfjack/ryu c-ryu
-//! $ cd c-ryu
-//! $ bazel run -c opt //ryu/benchmark
-//! ```
-//!
-//! And the same benchmark against our implementation with:
-//!
-//! ```console
-//! $ git clone https://github.com/dtolnay/ryu rust-ryu
-//! $ cd rust-ryu
-//! $ cargo run --example upstream_benchmark --release
-//! ```
-//!
-//! These benchmarks measure the average time to print a 32-bit float and average
+//! The benchmarks measure the average time to print a 32-bit float and average
 //! time to print a 64-bit float, where the inputs are distributed as uniform random
 //! bit patterns 32 and 64 bits wide.
 //!
@@ -89,7 +65,7 @@
 //! notation.
 
 #![no_std]
-#![doc(html_root_url = "https://docs.rs/ryu/1.0.5")]
+#![doc(html_root_url = "https://docs.rs/ryu-js/0.1.0")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(
     feature = "cargo-clippy",

src/pretty/mod.rs

@@ -6,13 +6,13 @@ use self::mantissa::*;
 use crate::common;
 use crate::d2s::{self, *};
 use crate::f2s::*;
-use core::{mem, ptr};
+use core::ptr;
 #[cfg(feature = "no-panic")]
 use no_panic::no_panic;
 
 /// Print f64 to the given buffer and return number of bytes written.
 ///
-/// At most 24 bytes will be written.
+/// At most 25 bytes will be written.
 ///
 /// ## Special cases
 ///
@@ -41,7 +41,7 @@ use no_panic::no_panic;
 ///
 /// unsafe {
 ///     let mut buffer = [MaybeUninit::<u8>::uninit(); 24];
-///     let len = ryu::raw::format64(f, buffer.as_mut_ptr() as *mut u8);
+///     let len = ryu_js::raw::format64(f, buffer.as_mut_ptr() as *mut u8);
 ///     let slice = slice::from_raw_parts(buffer.as_ptr() as *const u8, len);
 ///     let print = str::from_utf8_unchecked(slice);
 ///     assert_eq!(print, "1.234");
@@ -50,7 +50,7 @@ use no_panic::no_panic;
 #[must_use]
 #[cfg_attr(feature = "no-panic", no_panic)]
 pub unsafe fn format64(f: f64, result: *mut u8) -> usize {
-    let bits = mem::transmute::<f64, u64>(f);
+    let bits = f.to_bits();
     let sign = ((bits >> (DOUBLE_MANTISSA_BITS + DOUBLE_EXPONENT_BITS)) & 1) != 0;
     let ieee_mantissa = bits & ((1u64 << DOUBLE_MANTISSA_BITS) - 1);
     let ieee_exponent =
@@ -146,7 +146,7 @@ pub unsafe fn format64(f: f64, result: *mut u8) -> usize {
 ///
 /// unsafe {
 ///     let mut buffer = [MaybeUninit::<u8>::uninit(); 16];
-///     let len = ryu::raw::format32(f, buffer.as_mut_ptr() as *mut u8);
+///     let len = ryu_js::raw::format32(f, buffer.as_mut_ptr() as *mut u8);
 ///     let slice = slice::from_raw_parts(buffer.as_ptr() as *const u8, len);
 ///     let print = str::from_utf8_unchecked(slice);
 ///     assert_eq!(print, "1.234");
@@ -155,7 +155,7 @@ pub unsafe fn format64(f: f64, result: *mut u8) -> usize {
 #[must_use]
 #[cfg_attr(feature = "no-panic", no_panic)]
 pub unsafe fn format32(f: f32, result: *mut u8) -> usize {
-    let bits = mem::transmute::<f32, u32>(f);
+    let bits = f.to_bits();
     let sign = ((bits >> (FLOAT_MANTISSA_BITS + FLOAT_EXPONENT_BITS)) & 1) != 0;
     let ieee_mantissa = bits & ((1u32 << FLOAT_MANTISSA_BITS) - 1);
     let ieee_exponent =

src/s2d.rs

@@ -114,8 +114,7 @@ pub fn s2d(buffer: &[u8]) -> Result<f64, Error> {
     // whether the conversion was exact (trailing_zeros).
     let e2: i32;
     let m2: u64;
-    let mut trailing_zeros: bool;
-    if e10 >= 0 {
+    let mut trailing_zeros = if e10 >= 0 {
         // The length of m * 10^e in bits is:
         //   log2(m10 * 10^e10) = log2(m10) + e10 log2(10) = log2(m10) + e10 + e10 * log2(5)
         //
@@ -151,8 +150,7 @@ pub fn s2d(buffer: &[u8]) -> Result<f64, Error> {
         // requires that the largest power of 2 that divides m10 + e10 is
         // greater than e2. If e2 is less than e10, then the result must be
         // exact. Otherwise we use the existing multiple_of_power_of_2 function.
-        trailing_zeros =
-            e2 < e10 || e2 - e10 < 64 && multiple_of_power_of_2(m10, (e2 - e10) as u32);
+        e2 < e10 || e2 - e10 < 64 && multiple_of_power_of_2(m10, (e2 - e10) as u32)
     } else {
         e2 = floor_log2(m10)
             .wrapping_add(e10 as u32)
@@ -169,8 +167,9 @@ pub fn s2d(buffer: &[u8]) -> Result<f64, Error> {
             unsafe { d2s::DOUBLE_POW5_INV_SPLIT.get_unchecked(-e10 as usize) },
             j as u32,
         );
-        trailing_zeros = multiple_of_power_of_5(m10, -e10 as u32);
-    }
+
+        multiple_of_power_of_5(m10, -e10 as u32)
+    };
 
     // Compute the final IEEE exponent.
     let mut ieee_e2 = i32::max(0, e2 + DOUBLE_EXPONENT_BIAS as i32 + floor_log2(m2) as i32) as u32;

src/s2f.rs

@@ -114,8 +114,7 @@ pub fn s2f(buffer: &[u8]) -> Result<f32, Error> {
     // whether the conversion was exact (trailing_zeros).
     let e2: i32;
     let m2: u32;
-    let mut trailing_zeros: bool;
-    if e10 >= 0 {
+    let mut trailing_zeros = if e10 >= 0 {
         // The length of m * 10^e in bits is:
         //   log2(m10 * 10^e10) = log2(m10) + e10 log2(10) = log2(m10) + e10 + e10 * log2(5)
         //
@@ -146,8 +145,7 @@ pub fn s2f(buffer: &[u8]) -> Result<f32, Error> {
         // requires that the largest power of 2 that divides m10 + e10 is
         // greater than e2. If e2 is less than e10, then the result must be
         // exact. Otherwise we use the existing multiple_of_power_of_2 function.
-        trailing_zeros =
-            e2 < e10 || e2 - e10 < 32 && multiple_of_power_of_2_32(m10, (e2 - e10) as u32);
+        e2 < e10 || e2 - e10 < 32 && multiple_of_power_of_2_32(m10, (e2 - e10) as u32)
     } else {
         e2 = floor_log2(m10)
             .wrapping_add(e10 as u32)
@@ -159,8 +157,9 @@ pub fn s2f(buffer: &[u8]) -> Result<f32, Error> {
             .wrapping_sub(1)
             .wrapping_add(f2s::FLOAT_POW5_INV_BITCOUNT);
         m2 = mul_pow5_inv_div_pow2(m10, -e10 as u32, j);
-        trailing_zeros = multiple_of_power_of_5_32(m10, -e10 as u32);
-    }
+
+        multiple_of_power_of_5_32(m10, -e10 as u32)
+    };
 
     // Compute the final IEEE exponent.
     let mut ieee_e2 = i32::max(0, e2 + FLOAT_EXPONENT_BIAS as i32 + floor_log2(m2) as i32) as u32;

tests/common_test.rs

@@ -66,18 +66,3 @@ fn test_log10_pow5() {
     assert_eq!(2, log10_pow5(4));
     assert_eq!(1831, log10_pow5(2620));
 }
-
-#[test]
-fn test_float_to_bits() {
-    assert_eq!(0, 0.0_f32.to_bits());
-    assert_eq!(0x40490fda, 3.1415926_f32.to_bits());
-}
-
-#[test]
-fn test_double_to_bits() {
-    assert_eq!(0, 0.0_f64.to_bits());
-    assert_eq!(
-        0x400921FB54442D18,
-        3.1415926535897932384626433_f64.to_bits(),
-    );
-}