0.8.5 micro optimizations

Author: maciejhirsz

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "json"
-version = "0.8.4"
+version = "0.8.5"
 authors = ["Maciej Hirsz <maciej.hirsz@gmail.com>"]
 description = "JSON implementation in Rust"
 repository = "https://github.com/maciejhirsz/json-rust"

src/codegen.rs

@@ -41,7 +41,7 @@ pub trait Generator {
         self.get_buffer().push(ch)
     }
 
-    fn write_min(&mut self, slice: &[u8], minslice: &[u8]);
+    fn write_min(&mut self, slice: &[u8], min: u8);
 
     fn new_line(&mut self) {}
 
@@ -76,42 +76,33 @@ pub trait Generator {
         self.write_char(b'"');
     }
 
-    fn write_number(&mut self, mut num: f64) {
+    fn write_number(&mut self, num: f64) {
         match num.classify() {
-            FpCategory::Nan      |
-            FpCategory::Infinite => {
-                self.write(b"null");
-                return;
+            FpCategory::Normal    |
+            FpCategory::Subnormal => {
+                if num.fract() == 0.0 && num < 1e19 {
+                    itoa::write(self.get_buffer(), num as i64).unwrap();
+                } else {
+                    let abs = num.abs();
+                    if abs < 1e-15 || abs > 1e19 {
+                        write!(self.get_buffer(), "{:e}", num).unwrap();
+                    } else {
+                        write!(self.get_buffer(), "{}", num).unwrap();
+                    }
+                }
             },
             FpCategory::Zero => {
-                self.write(if num.is_sign_negative() { b"-0" } else { b"0" });
-                return;
+                if num.is_sign_negative() {
+                    self.write(b"-0");
+                } else {
+                    self.write_char(b'0');
+                }
             },
-            _ => {},
-        }
-
-        if num.is_sign_negative() {
-            num = num.abs();
-            self.write_char(b'-');
-        }
-
-        let fract = num.fract();
-
-        if fract > 0.0 {
-            if num < 1e-15 {
-                write!(self.get_buffer(), "{:e}", num).unwrap();
-            } else {
-                write!(self.get_buffer(), "{}", num).unwrap();
+            FpCategory::Nan      |
+            FpCategory::Infinite => {
+                self.write(b"null");
             }
-            return;
-        }
-
-        if num > 1e19 {
-            write!(self.get_buffer(), "{:e}", num).unwrap();
-            return;
         }
-
-        itoa::write(self.get_buffer(), num as u64).unwrap();
     }
 
     fn write_json(&mut self, json: &JsonValue) {
@@ -130,7 +121,7 @@ pub trait Generator {
                         first = false;
                         self.new_line();
                     } else {
-                        self.write(b",");
+                        self.write_char(b',');
                         self.new_line();
                     }
                     self.write_json(item);
@@ -148,11 +139,11 @@ pub trait Generator {
                         first = false;
                         self.new_line();
                     } else {
-                        self.write(b",");
+                        self.write_char(b',');
                         self.new_line();
                     }
                     self.write_string(key);
-                    self.write_min(b": ", b":");
+                    self.write_min(b": ", b':');
                     self.write_json(value);
                 }
                 self.dedent();
@@ -184,8 +175,8 @@ impl Generator for DumpGenerator {
     }
 
     #[inline(always)]
-    fn write_min(&mut self, _: &[u8], minslice: &[u8]) {
-        self.code.extend_from_slice(minslice);
+    fn write_min(&mut self, _: &[u8], min: u8) {
+        self.code.push(min);
     }
 
     fn consume(self) -> String {
@@ -216,7 +207,7 @@ impl Generator for PrettyGenerator {
     }
 
     #[inline(always)]
-    fn write_min(&mut self, slice: &[u8], _: &[u8]) {
+    fn write_min(&mut self, slice: &[u8], _: u8) {
         self.code.extend_from_slice(slice);
     }
 

src/parser.rs

@@ -393,11 +393,11 @@ impl<'a> Parser<'a> {
 
     fn read_number_with_fraction(&mut self, mut num: f64) -> JsonResult<f64> {
         if next_byte!(self || return Ok(num)) == b'.' {
-            let mut precision = -1;
+            let mut precision = 0.1;
 
             read_num!(self, digit, {
-                num += (digit as f64) * 10_f64.powi(precision);
-                precision -= 1;
+                num += (digit as f64) * precision;
+                precision /= 10.0;
             });
         } else {
             self.index -= 1;