Fixes #93

Author: maciejhirsz

src/error.rs

@@ -13,6 +13,7 @@ pub enum Error {
         column: usize,
     },
     UnexpectedEndOfJson,
+    ExceededDepthLimit,
     FailedUtf8Parsing,
     WrongType(String),
 }
@@ -35,6 +36,7 @@ impl fmt::Display for Error {
             } => write!(f, "Unexpected character: {} at ({}:{})", ch, line, column),
 
             UnexpectedEndOfJson   => write!(f, "Unexpected end of JSON"),
+            ExceededDepthLimit    => write!(f, "Exceeded depth limit"),
             FailedUtf8Parsing     => write!(f, "Failed to parse UTF-8 bytes"),
             WrongType(ref s)      => write!(f, "Wrong type, expected: {}", s),
         }
@@ -44,9 +46,11 @@ impl fmt::Display for Error {
 impl error::Error for Error {
     fn description(&self) -> &str {
         use Error::*;
+
         match *self {
             UnexpectedCharacter { .. } => "Unexpected character",
             UnexpectedEndOfJson        => "Unexpected end of JSON",
+            ExceededDepthLimit         => "Exceeded depth limit",
             FailedUtf8Parsing          => "Failed to read bytes as UTF-8 from JSON",
             WrongType(_)               => "Wrong type",
         }

src/object.rs

@@ -339,6 +339,13 @@ impl Object {
         }
     }
 
+    #[inline]
+    pub fn override_last(&mut self, value: JsonValue) {
+        if let Some(node) = self.store.last_mut() {
+            node.value = value;
+        }
+    }
+
     pub fn get(&self, key: &str) -> Option<&JsonValue> {
         if self.store.len() == 0 {
             return None;

src/parser.rs

@@ -17,7 +17,7 @@
 // This makes for some ugly code, but it is faster. Hopefully in the future
 // with MIR support the compiler will get smarter about this.
 
-use std::{ ptr, mem, str, slice, char };
+use std::{ str, slice, char };
 use object::Object;
 use number::Number;
 use { JsonValue, Error, Result };
@@ -27,6 +27,10 @@ use { JsonValue, Error, Result };
 const MAX_PRECISION: u64 = 576460752303423500;
 
 
+// How many nested Objects/Arrays are allowed to be parsed
+const DEPTH_LIMIT: usize = 512;
+
+
 // Position is only used when we stumble upon an unexpected character. We don't
 // track lines during parsing, as that would mean doing unnecessary work.
 // Instead, if an error occurs, we figure out the line and column from the
@@ -121,6 +125,20 @@ macro_rules! expect_byte_ignore_whitespace {
     })
 }
 
+// Expect to find EOF or just whitespaces leading to EOF after a JSON value
+macro_rules! expect_eof {
+    ($parser:ident) => ({
+        while !$parser.is_eof() {
+            match $parser.read_byte() {
+                9 ... 13 | 32 => $parser.bump(),
+                ch            => {
+                    $parser.bump();
+                    return $parser.unexpected_character(ch);
+                }
+            }
+        }
+    })
+}
 
 // Expect a particular byte to be next. Also available with a variant
 // creates a `match` expression just to ease some pain.
@@ -350,52 +368,6 @@ macro_rules! expect_fraction {
     })
 }
 
-
-// This is where the magic happens. This macro will read from the source
-// and try to create an instance of `JsonValue`. Note that it only reads
-// bytes that _begin_ a JSON value, however it can also accept an optional
-// pattern with custom logic. This is used in arrays, which expect either
-// a value or a closing bracket `b"]"`.
-macro_rules! expect_value {
-    {$parser:ident $(, $byte:pat => $then:expr )*} => ({
-        let ch = expect_byte_ignore_whitespace!($parser);
-
-        match ch {
-            $(
-                $byte => $then,
-            )*
-            b'[' => JsonValue::Array(try!($parser.read_array())),
-            b'{' => JsonValue::Object(try!($parser.read_object())),
-            b'"' => expect_string!($parser).into(),
-            b'0' => JsonValue::Number(allow_number_extensions!($parser)),
-            b'1' ... b'9' => {
-                JsonValue::Number(expect_number!($parser, ch))
-            },
-            b'-' => {
-                let ch = expect_byte!($parser);
-                JsonValue::Number(- match ch {
-                    b'0' => allow_number_extensions!($parser),
-                    b'1' ... b'9' => expect_number!($parser, ch),
-                    _    => return $parser.unexpected_character(ch)
-                })
-            }
-            b't' => {
-                expect_sequence!($parser, b'r', b'u', b'e');
-                JsonValue::Boolean(true)
-            },
-            b'f' => {
-                expect_sequence!($parser, b'a', b'l', b's', b'e');
-                JsonValue::Boolean(false)
-            },
-            b'n' => {
-                expect_sequence!($parser, b'u', b'l', b'l');
-                JsonValue::Null
-            },
-            _ => return $parser.unexpected_character(ch)
-        }
-    })
-}
-
 impl<'a> Parser<'a> {
     pub fn new(source: &'a str) -> Self {
         Parser {
@@ -704,102 +676,146 @@ impl<'a> Parser<'a> {
         Ok(Number::from_parts(true, num, (big_e.saturating_add(e * sign))))
     }
 
-    // Given how compilcated reading numbers and strings is, reading objects
-    // is actually pretty simple.
-    fn read_object(&mut self) -> Result<Object> {
-        let key = expect!{ self,
-            b'}'  => return Ok(Object::new()),
-            b'\"' => expect_string!(self)
-        };
+    // Parse away!
+    fn parse(&mut self) -> Result<JsonValue> {
+        let mut stack = Vec::with_capacity(3);
+        let mut ch = expect_byte_ignore_whitespace!(self);
 
-        let mut object = Object::with_capacity(3);
+        'parsing: loop {
+            let mut value = match ch {
+                b'[' => {
+                    ch = expect_byte_ignore_whitespace!(self);
 
-        expect!(self, b':');
+                    if ch != b']' {
+                        if stack.len() == DEPTH_LIMIT {
+                            return Err(Error::ExceededDepthLimit);
+                        }
 
-        object.insert(key, expect_value!(self));
+                        stack.push(StackBlock::Array(Vec::with_capacity(2)));
+                        continue 'parsing;
+                    }
 
-        loop {
-            let key = expect!{ self,
-                b'}' => break,
-                b',' => {
-                    expect!(self, b'"');
-                    expect_string!(self)
+                    JsonValue::Array(Vec::new())
+                },
+                b'{' => {
+                    ch = expect_byte_ignore_whitespace!(self);
+
+                    if ch != b'}' {
+                        if stack.len() == DEPTH_LIMIT {
+                            return Err(Error::ExceededDepthLimit);
+                        }
+
+                        let mut object = Object::with_capacity(3);
+
+                        if ch != b'"' {
+                            return self.unexpected_character(ch)
+                        }
+
+                        object.insert(expect_string!(self), JsonValue::Null);
+                        expect!(self, b':');
+
+                        stack.push(StackBlock::Object(object));
+
+                        ch = expect_byte_ignore_whitespace!(self);
+
+                        continue 'parsing;
+                    }
+
+                    JsonValue::Object(Object::new())
+                },
+                b'"' => expect_string!(self).into(),
+                b'0' => JsonValue::Number(allow_number_extensions!(self)),
+                b'1' ... b'9' => {
+                    JsonValue::Number(expect_number!(self, ch))
+                },
+                b'-' => {
+                    let ch = expect_byte!(self);
+                    JsonValue::Number(- match ch {
+                        b'0' => allow_number_extensions!(self),
+                        b'1' ... b'9' => expect_number!(self, ch),
+                        _    => return self.unexpected_character(ch)
+                    })
                 }
+                b't' => {
+                    expect_sequence!(self, b'r', b'u', b'e');
+                    JsonValue::Boolean(true)
+                },
+                b'f' => {
+                    expect_sequence!(self, b'a', b'l', b's', b'e');
+                    JsonValue::Boolean(false)
+                },
+                b'n' => {
+                    expect_sequence!(self, b'u', b'l', b'l');
+                    JsonValue::Null
+                },
+                _    => return self.unexpected_character(ch)
             };
 
-            expect!(self, b':');
+            'popping: loop {
+                match stack.pop() {
+                    None => {
+                        expect_eof!(self);
 
-            object.insert(key, expect_value!(self));
-        }
+                        return Ok(value);
+                    },
 
-        Ok(object)
-    }
+                    Some(StackBlock::Array(mut array)) => {
+                        array.push(value);
 
-    // And reading arrays is simpler still!
-    fn read_array(&mut self) -> Result<Vec<JsonValue>> {
-        let first = expect_value!{ self, b']' => return Ok(Vec::new()) };
+                        ch = expect_byte_ignore_whitespace!(self);
 
-        let mut array = Vec::with_capacity(2);
+                        match ch {
+                            b',' => {
+                                stack.push(StackBlock::Array(array));
 
-        unsafe {
-            // First member can be written to the array without any checks!
-            ptr::copy_nonoverlapping(
-                &first as *const JsonValue,
-                array.as_mut_ptr(),
-                1
-            );
-            mem::forget(first);
-            array.set_len(1);
-        }
+                                ch = expect_byte_ignore_whitespace!(self);
 
-        expect!{
-            self,
-            b']' => return Ok(array),
-            b',' => {
-                // Same for the second one!
-                let value = expect_value!(self);
-                unsafe {
-                    ptr::copy_nonoverlapping(
-                        &value as *const JsonValue,
-                        array.as_mut_ptr().offset(1),
-                        1
-                    );
-                    mem::forget(value);
-                    array.set_len(2);
-                }
-            }
-        }
+                                continue 'parsing;
+                            },
+                            b']' => {
+                                value = JsonValue::Array(array);
+                                continue 'popping;
+                            },
+                            _ => return self.unexpected_character(ch)
+                        }
+                    },
 
-        loop {
-            expect!{ self,
-                b']' => break,
-                b',' => array.push(expect_value!(self))
-            };
-        }
+                    Some(StackBlock::Object(mut object)) => {
+                        object.override_last(value);
 
-        Ok(array)
-    }
+                        ch = expect_byte_ignore_whitespace!(self);
 
-    // Parse away!
-    fn parse(&mut self) -> Result<JsonValue> {
-        let value = expect_value!(self);
+                        match ch {
+                            b',' => {
+                                expect!(self, b'"');
+                                object.insert(expect_string!(self), JsonValue::Null);
+                                expect!(self, b':');
 
-        // We have read whatever value was there, but we need to make sure
-        // there is nothing left to read - if there is, that's an error.
-        while !self.is_eof() {
-            match self.read_byte() {
-                9 ... 13 | 32 => self.bump(),
-                ch            => {
-                    self.bump();
-                    return self.unexpected_character(ch);
+                                stack.push(StackBlock::Object(object));
+
+                                ch = expect_byte_ignore_whitespace!(self);
+
+                                continue 'parsing;
+                            },
+                            b'}' => {
+                                value = JsonValue::Object(object);
+
+                                continue 'popping;
+                            },
+                            _ => return self.unexpected_character(ch)
+                        }
+                    },
                 }
             }
         }
-
-        Ok(value)
     }
 }
 
+enum StackBlock {
+    Array(Vec<JsonValue>),
+    Object(Object),
+}
+
 // All that hard work, and in the end it's just a single function in the API.
 #[inline]
 pub fn parse(source: &str) -> Result<JsonValue> {

tests/json_checker.rs

@@ -165,7 +165,7 @@ mod json_checker_pass {
 
     #[test]
     fn pass_1() {
-        assert!(parse(r##"
+        parse(r##"
 
         [
             "JSON Test Pattern pass1",
@@ -226,17 +226,21 @@ mod json_checker_pass {
         1e00,2e+00,2e-00
         ,"rosebud"]
 
-        "##).is_ok());
+        "##).unwrap();
+
+        assert!(true);
     }
 
     #[test]
     fn pass_2() {
-        assert!(parse(r#"[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]"#).is_ok());
+        parse(r#"[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]"#).unwrap();
+
+        assert!(true);
     }
 
     #[test]
     fn pass_3() {
-        assert!(parse(r#"
+        parse(r#"
 
         {
             "JSON Test Pattern pass3": {
@@ -245,6 +249,8 @@ mod json_checker_pass {
             }
         }
 
-        "#).is_ok());
+        "#).unwrap();
+
+        assert!(true);
     }
 }