Add error messages to JSONReader and friends. This required a bit of refactor...

base/json_reader.h

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // A JSON parser.  Converts strings of JSON into a Value object (see
 // base/values.h).
 // http://www.ietf.org/rfc/rfc4627.txt?number=4627
 //
 // Known limitations/deviations from the RFC:
 // - Only knows how to parse ints within the range of a signed 32 bit int and
 //   decimal numbers within a double.
 // - Assumes input is encoded as UTF8.  The spec says we should allow UTF-16
 //   (BE or LE) and UTF-32 (BE or LE) as well.
 // - We limit nesting to 100 levels to prevent stack overflow (this is allowed
 //   by the RFC).
 // - A Unicode FAQ ("http://unicode.org/faq/utf_bom.html") writes a data
 //   stream may start with a Unicode Byte-Order-Mark (U+FEFF), i.e. the input
 //   UTF-8 string for the JSONReader::JsonToValue() function may start with a
 //   UTF-8 BOM (0xEF, 0xBB, 0xBF).
 //   To avoid the function from mis-treating a UTF-8 BOM as an invalid
 //   character, the function skips a Unicode BOM at the beginning of the
 //   Unicode string (converted from the input UTF-8 string) before parsing it.
 //
-// TODO(tc): It would be nice to give back an error string when we fail to
-//   parse JSON.
 // TODO(tc): Add a parsing option to to relax object keys being wrapped in
 //   double quotes
 // TODO(tc): Add an option to disable comment stripping
+// TODO(aa): Consider making the constructor public and the static Read() method
+// only a convenience for the common uses with more complex configuration going
+// on the instance.
 
 #ifndef BASE_JSON_READER_H_
 #define BASE_JSON_READER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
 class Value;
@@ skipping 28 matching lines @@
 
     // End should be one char past the end of the token.
     int length;
 
     // Get the character that's one past the end of this token.
     wchar_t NextChar() {
       return *(begin + length);
     }
   };
 
-  // Reads and parses |json| and populates |root|.  If |json| is not a properly
-  // formed JSON string, returns false and leaves root unaltered.  If
-  // allow_trailing_comma is true, we will ignore trailing commas in objects
-  // and arrays even though this goes against the RFC.
+  // Error messages that can be returned.
+  static const char* kBadRootElementType;
+  static const char* kInvalidEscape;
+  static const char* kSyntaxError;
+  static const char* kTrailingComma;
+  static const char* kTooMuchNesting;
+  static const char* kUnexpectedDataAfterRoot;
+  static const char* kUnsupportedEncoding;
+  static const char* kUnquotedDictionaryKey;
+
+  // Reads and parses |json| and populates |root|. If |json| is not a properly
+  // formed JSON string, returns false, leaves root unaltered and sets
+  // error_message if it was non-null. If allow_trailing_comma is true, we will
+  // ignore trailing commas in objects and arrays even though this goes against
+  // the RFC.
   static bool Read(const std::string& json,
                    Value** root,
                    bool allow_trailing_comma);
 
+  // Reads and parses |json| like Read(). |error_message_out| is optional. If
+  // specified and false is returned, error_message_out will be populated with
+  // a string describing the error. Otherwise, error_message_out is unmodified.
+  static bool ReadAndReturnError(const std::string& json,
+                                 Value** root,
+                                 bool allow_trailing_comma,
+                                 std::string *error_message_out);
+
  private:
-  JSONReader(const wchar_t* json_start_pos, bool allow_trailing_comma);
+  static std::string FormatErrorMessage(int line, int column,
+                                        const char* description);
+
+  JSONReader();
   DISALLOW_EVIL_CONSTRUCTORS(JSONReader);
 
   FRIEND_TEST(JSONReaderTest, Reading);
+  FRIEND_TEST(JSONReaderTest, ErrorMessages);
+
+  // Returns the error message if the last call to JsonToValue() failed. If the
+  // last call did not fail, returns a valid empty string.
+  std::string* error_message() { return &error_message_; }

[tony, 2008/12/05 20:37:57]

Nit: Can we just return a string here?  I think the extra copy is ok and then
the string won't deref unexpectedly when JSONReader goes out of scope.

 
   // Pass through method from JSONReader::Read.  We have this so unittests can
   // disable the root check.
-  static bool JsonToValue(const std::string& json, Value** root,
-                          bool check_root,
-                          bool allow_trailing_comma);
+  bool JsonToValue(const std::string& json, Value** root, bool check_root,
+                   bool allow_trailing_comma);
 
   // Recursively build Value.  Returns false if we don't have a valid JSON
   // string.  If |is_root| is true, we verify that the root element is either
   // an object or an array.
   bool BuildValue(Value** root, bool is_root);
 
   // Parses a sequence of characters into a Token::NUMBER. If the sequence of
   // characters is not a valid number, returns a Token::INVALID_TOKEN. Note
   // that DecodeNumber is used to actually convert from a string to an
   // int/double.
@@ skipping 22 matching lines @@
   // Increments json_pos_ past leading whitespace and comments.
   void EatWhitespaceAndComments();
 
   // If json_pos_ is at the start of a comment, eat it, otherwise, returns
   // false.
   bool EatComment();
 
   // Checks if json_pos_ matches str.
   bool NextStringMatch(const std::wstring& str);
 
+  // Creates the error message that will be returned to the caller. The current
+  // line and column are determined and added into the final message.
+  void SetErrorMessage(const char* description, const wchar_t* error_pos);
+
+  // Pointer to the starting position in the input string.
+  const wchar_t* start_pos_;
+
   // Pointer to the current position in the input string.
   const wchar_t* json_pos_;
 
   // Used to keep track of how many nested lists/dicts there are.
   int stack_depth_;
 
   // A parser flag that allows trailing commas in objects and arrays.
   bool allow_trailing_comma_;
+
+  // Contains the error message for the last call to JsonToValue(), if any.
+  std::string error_message_;
 };
 
 #endif  // BASE_JSON_READER_H_