Serialize number to no more than necessary precision

Author: upsuper

Cargo.toml

@@ -21,6 +21,7 @@ encoding_rs = "0.5"
 
 [dependencies]
 cssparser-macros = {path = "./macros", version = "0.3"}
+dtoa = "0.4.1"
 heapsize = {version = ">= 0.3, < 0.5", optional = true}
 matches = "0.1"
 phf = "0.7"

src/css-parsing-tests/component_value_list.json

@@ -247,6 +247,12 @@
 	["number", "-0.67", -0.67, "number"]
 ],
 
+"12.3e30 -0.0123e30 9999e-13", [
+	["number", "1.23e31", 1.23e31, "number"], " ",
+	["number", "-1.23e28", -1.23e28, "number"], " ",
+	["number", "9.999e-10", 9.999e-10, "number"]
+],
+
 "3. /* Decimal point must have following digits */", [
 	["number", "3", 3, "integer"], ".", " "
 ],
@@ -264,12 +270,12 @@
 	["percentage", "12", 12, "integer"], " ",
 	["percentage", "+34", 34, "integer"], " ",
 	["percentage", "-45", -45, "integer"], " ",
-	["percentage", "0.66999996", 0.67, "number"], " ",
+	["percentage", "0.67", 0.67, "number"], " ",
 	["percentage", "+0.89", 0.89, "number"], " ",
 	["percentage", "-0.01", -0.01, "number"], " ",
 	["percentage", "2.3", 2.3000000000, "number"], " ",
 	["percentage", "+45.0", 45.0, "number"], " ",
-	["percentage", "-0.66999996", -0.67, "number"]
+	["percentage", "-0.67", -0.67, "number"]
 ],
 
 "12e2% +34e+1% -45E-0% .68e+3% +.79e-1% -.01E2% 2.3E+1% +45.0e6% -0.67e0%", [
@@ -281,7 +287,7 @@
 	["percentage", "-1.0", -1, "number"], " ",
 	["percentage", "23.0", 23, "number"], " ",
 	["percentage", "+45000000.0", 45000000, "number"], " ",
-	["percentage", "-0.66999996", -0.67, "number"]
+	["percentage", "-0.67", -0.67, "number"]
 ],
 
 "12\\% /* Percent sign can not be escaped */", [

src/lib.rs

@@ -68,6 +68,7 @@ fn parse_border_spacing(_context: &ParserContext, input: &mut Parser)
 
 #![recursion_limit="200"]  // For color::parse_color_keyword
 
+extern crate dtoa;
 #[macro_use] extern crate cssparser_macros;
 #[macro_use] extern crate matches;
 #[macro_use] extern crate procedural_masquerade;

src/serializer.rs

@@ -2,8 +2,10 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use dtoa;
 use std::ascii::AsciiExt;
 use std::fmt::{self, Write};
+use std::str;
 
 use super::Token;
 
@@ -41,6 +43,123 @@ pub trait ToCss {
     }
 }
 
+const PRECISION_FOR_F32: usize = 6;
+
+fn dtoa_pretty<W>(dest: &mut W, value: f32, has_exp: &mut bool)
+                  -> fmt::Result where W: fmt::Write {
+    let mut buf = [b'\0'; 40];
+    // Put a leading zero at the beginning to capture any carry.
+    buf[0] = b'0';
+    let len = dtoa::write(&mut buf[1..], value).unwrap() + 1;
+    let sign = match buf[1] {
+        s @ b'+' | s @ b'-' => {
+            buf[1] = b'0';
+            Some(s)
+        }
+        _ => None,
+    };
+    // Locate dot, exp, and the first non-zero digit.
+    let mut pos_dot = None;
+    let mut pos_exp = None;
+    let mut prec_start = None;
+    for i in 1..len {
+        if buf[i] == b'.' {
+            debug_assert!(pos_dot.is_none());
+            pos_dot = Some(i);
+        } else if buf[i] == b'e' {
+            pos_exp = Some(i);
+            break;
+        } else if prec_start.is_none() && buf[i] != b'0' {
+            debug_assert!(buf[i] >= b'1' && buf[i] <= b'9');
+            prec_start = Some(i);
+        }
+    }
+    // If there is no non-zero digit at all, it is just zero.
+    if prec_start.is_none() {
+        return dest.write_char('0');
+    }
+    let prec_start = prec_start.unwrap();
+    let coeff_end = pos_exp.unwrap_or(len);
+    let pos_dot = pos_dot.unwrap_or(coeff_end);
+    // Find the end position of the number within the given precision.
+    let prec_end = {
+        let end = prec_start + PRECISION_FOR_F32;
+        if pos_dot > prec_start && pos_dot <= end {
+            end + 1
+        } else {
+            end
+        }
+    };
+    let mut new_coeff_end = coeff_end;
+    if prec_end < coeff_end {
+        // Round to the given precision.
+        let next_char = buf[prec_end];
+        new_coeff_end = prec_end;
+        if next_char >= b'5' {
+            for i in (0..prec_end).rev() {
+                if buf[i] == b'.' {
+                    continue;
+                }
+                if buf[i] != b'9' {
+                    buf[i] += 1;
+                    new_coeff_end = i + 1;
+                    break;
+                }
+                buf[i] = b'0';
+            }
+        }
+    }
+    if new_coeff_end < pos_dot {
+        // If the precision isn't enough to reach the dot, set all digits
+        // in-between to zero and keep the number until the dot.
+        for i in new_coeff_end..pos_dot {
+            buf[i] = b'0';
+        }
+        new_coeff_end = pos_dot;
+    } else {
+        // Strip any trailing zeros.
+        for i in (0..new_coeff_end).rev() {
+            if buf[i] != b'0' {
+                if buf[i] == b'.' {
+                    new_coeff_end = i;
+                }
+                break;
+            }
+            new_coeff_end = i;
+        }
+    }
+    // Move exponent part if necessary.
+    let real_end = if let Some(pos_exp) = pos_exp {
+        if new_coeff_end != pos_exp {
+            for i in 0..len - pos_exp {
+                buf[new_coeff_end + i] = buf[pos_exp + i];
+            }
+        }
+        *has_exp = true;
+        new_coeff_end + (len - pos_exp)
+    } else {
+        new_coeff_end
+    };
+    // Add back the sign and strip the leading zero.
+    let result = if let Some(sign) = sign {
+        if buf[1] == b'0' && buf[2] != b'.' {
+            buf[1] = sign;
+            &buf[1..real_end]
+        } else {
+            debug_assert!(buf[0] == b'0');
+            buf[0] = sign;
+            &buf[0..real_end]
+        }
+    } else {
+        if buf[1] == b'0' && buf[2] != b'.' {
+            &buf[2..real_end]
+        } else {
+            debug_assert!(buf[0] == b'0');
+            &buf[1..real_end]
+        }
+    };
+    dest.write_str(str::from_utf8(result).unwrap())
+}
 
 #[inline]
 fn write_numeric<W>(value: f32, int_value: Option<i32>, has_sign: bool, dest: &mut W)
@@ -50,14 +169,15 @@ fn write_numeric<W>(value: f32, int_value: Option<i32>, has_sign: bool, dest: &m
         dest.write_str("+")?;
     }
 
+    let mut has_exp = false;
     if value == 0.0 && value.is_sign_negative() {
         // Negative zero. Work around #20596.
         dest.write_str("-0")?
     } else {
-        write!(dest, "{}", value)?
+        dtoa_pretty(dest, value, &mut has_exp)?;
     }
 
-    if int_value.is_none() && value.fract() == 0. {
+    if int_value.is_none() && value.fract() == 0. && !has_exp {
         dest.write_str(".0")?;
     }
     Ok(())

src/tests.rs

@@ -31,7 +31,7 @@ fn almost_equals(a: &Json, b: &Json) -> bool {
         (_, &Json::I64(b)) => almost_equals(a, &Json::F64(b as f64)),
         (_, &Json::U64(b)) => almost_equals(a, &Json::F64(b as f64)),
 
-        (&Json::F64(a), &Json::F64(b)) => (a - b).abs() < 1e-6,
+        (&Json::F64(a), &Json::F64(b)) => (a - b).abs() <= a.abs() * 1e-6,
 
         (&Json::Boolean(a), &Json::Boolean(b)) => a == b,
         (&Json::String(ref a), &Json::String(ref b)) => a == b,
@@ -949,3 +949,23 @@ fn parse_entirely_reports_first_error() {
     let result: Result<(), _> = parser.parse_entirely(|_| Err(ParseError::Custom(E::Foo)));
     assert_eq!(result, Err(ParseError::Custom(E::Foo)));
 }
+
+#[test]
+fn roundtrip_numeric_token() {
+    fn test_roundtrip(value: &str) {
+        let mut input = ParserInput::new(value);
+        let mut parser = Parser::new(&mut input);
+        let token = parser.next().unwrap();
+        assert_eq!(token.to_css_string(), value);
+    }
+    // Test simple number serialization
+    for i in 0..101 {
+        test_roundtrip(&format!("{}", i));
+        for j in 1..10 {
+            test_roundtrip(&format!("{}.{}", i, j));
+            for k in 1..10 {
+                test_roundtrip(&format!("{}.{}{}", i, j, k));
+            }
+        }
+    }
+}