0.8.0 fix u64 overflowing #36

Author: maciejhirsz

src/parser.rs

@@ -50,7 +50,7 @@ macro_rules! sequence {
 
 macro_rules! read_num {
     ($tok:ident, $num:ident, $then:expr) => {
-        while let Some(ch) = $tok.next_byte() {
+        while let Some(ch) = $tok.checked_next_byte() {
             match ch {
                 b'0' ... b'9' => {
                     let $num = ch - b'0';
@@ -213,22 +213,42 @@ impl<'a> Tokenizer<'a> {
 
     fn read_number(&mut self, first: u8, is_negative: bool) -> JsonResult<f64> {
         let mut num = (first - b'0') as u64;
+        let mut digits = 0u8;
 
-        read_num!(self, digit, num = num * 10 + digit as u64);
+        // Cap on how many iterations we do while reading to u64
+        // in order to avoid an overflow.
+        while digits < 18 {
+            digits += 1;
 
-        match self.peek_byte() {
-            Some(b'.') | Some(b'e') | Some(b'E') => {},
-            _ => {
-                return if is_negative {
-                    Ok(-(num as f64))
-                } else {
-                    Ok(num as f64)
-                };
+            if let Some(ch) = self.next_byte() {
+                match ch {
+                    b'0' ... b'9' => {
+                        num = num * 10 + (ch - b'0') as u64;
+                    },
+                    b'.' | b'e' | b'E' => {
+                        self.left_over = Some(ch);
+                        break;
+                    }
+                    ch => {
+                        self.left_over = Some(ch);
+                        return Ok(
+                            if is_negative { -(num as f64) } else { num as f64 }
+                        );
+                    }
+                }
+            } else {
+                return Ok(
+                    if is_negative { -(num as f64) } else { num as f64 }
+                );
             }
         }
 
         let mut num = num as f64;
 
+        // Attempt to continue reading digits that would overflow
+        // u64 into freshly converted f64
+        read_num!(self, digit, num = num * 10.0 + digit as f64);
+
         if let Some(b'.') = self.peek_byte() {
             self.left_over = None;
             let mut precision = -1;
@@ -251,22 +271,14 @@ impl<'a> Tokenizer<'a> {
                     },
                 };
 
-                while let Some(ch) = self.checked_next_byte() {
-                    match ch {
-                        b'0' ... b'9' => e = e * 10 + (ch - b'0') as i32,
-                        ch => {
-                            self.left_over = Some(ch);
-                            break;
-                        }
-                    }
-                }
+                read_num!(self, digit, e = e * 10 + digit as i32);
 
                 num *= 10f64.powi(e * sign);
             },
             byte => self.left_over = byte
         }
 
-        Ok(if is_negative { num * -1.0 } else { num })
+        Ok(if is_negative { -num } else { num })
     }
 
     fn next(&mut self) -> JsonResult<Token> {

tests/lib.rs

@@ -322,6 +322,11 @@ fn parse_number_with_negative_e() {
     assert_eq!(parse("5E-2").unwrap(), 0.05);
 }
 
+#[test]
+fn parse_large_number() {
+    assert_eq!(parse("18446744073709551616").unwrap(), 18446744073709552000f64);
+}
+
 #[test]
 fn parse_array() {
     assert_eq!(parse(r#"[10, "foo", true, null]"#).unwrap(), array![