partially revert 'Added features that allow the reader to accept common non-standard JSON.'

revert '642befc836ac5093b528e7d8b4fd66b66735a98c',
but keep the *added* methods for `decodedNumber()` and `decodedDouble()`.

CMakeLists.txt

@@ -60,7 +60,7 @@ ENDMACRO(jsoncpp_parse_version)
 #SET( JSONCPP_VERSION_MAJOR X )
 #SET( JSONCPP_VERSION_MINOR Y )
 #SET( JSONCPP_VERSION_PATCH Z )
-SET( JSONCPP_VERSION 1.10.0 )
+SET( JSONCPP_VERSION 0.9.4 )
 jsoncpp_parse_version( ${JSONCPP_VERSION} JSONCPP_VERSION )
 #IF(NOT JSONCPP_VERSION_FOUND)
 #    MESSAGE(FATAL_ERROR "Failed to parse version string properly. Expect X.Y.Z")

include/json/assertions.h

@@ -13,29 +13,21 @@
 #include "config.h"
 #endif // if !defined(JSON_IS_AMALGAMATION)
 
-/** It should not be possible for a maliciously designed file to
- *  cause an abort() or seg-fault, so these macros are used only
- *  for pre-condition violations and internal logic errors.
- */
 #if JSON_USE_EXCEPTION
-
+#include <stdexcept>
-// @todo <= add detail about condition in exception
 #define JSON_ASSERT(condition)                                                 \
-  {if (!(condition)) {Json::throwLogicError( "assert json failed" );}}
+  {if (!(condition)) {throw std::logic_error( "assert json failed" );}} // @todo <= add detail about condition in exception
-
 #define JSON_FAIL_MESSAGE(message)                                             \
   {                                                                            \
     std::ostringstream oss; oss << message;                                    \
-    Json::throwLogicError(oss.str());                                          \
+    throw std::logic_error(oss.str());                                         \
-    abort();                                                                   \
   }
-
+//#define JSON_FAIL_MESSAGE(message) throw std::logic_error(message)
 #else // JSON_USE_EXCEPTION
-
 #define JSON_ASSERT(condition) assert(condition)
 
 // The call to assert() will show the failure message in debug builds. In
-// release builds we abort, for a core-dump or debugger.
+// release bugs we abort, for a core-dump or debugger.
 #define JSON_FAIL_MESSAGE(message)                                             \
   {                                                                            \
     std::ostringstream oss; oss << message;                                    \

include/json/config.h

@@ -70,14 +70,6 @@
 #if defined(_MSC_VER) && _MSC_VER >= 1500 // MSVC 2008
 /// Indicates that the following function is deprecated.
 #define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
-#elif defined(__clang__) && defined(__has_feature)
-#if __has_feature(attribute_deprecated_with_message)
-#define JSONCPP_DEPRECATED(message)  __attribute__ ((deprecated(message)))
-#endif
-#elif defined(__GNUC__) &&  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
-#define JSONCPP_DEPRECATED(message)  __attribute__ ((deprecated(message)))
-#elif defined(__GNUC__) &&  (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
-#define JSONCPP_DEPRECATED(message)  __attribute__((__deprecated__))
 #endif
 
 #if !defined(JSONCPP_DEPRECATED)

include/json/reader.h

@@ -98,7 +98,7 @@ public:
    *         during parsing.
    * \deprecated Use getFormattedErrorMessages() instead (typo fix).
    */
-  JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.")
+  JSONCPP_DEPRECATED("Use getFormattedErrorMessages instead")
   std::string getFormatedErrorMessages() const;
 
   /** \brief Returns a user friendly string that list errors in the parsed
@@ -226,7 +226,6 @@ public:
 
   class Factory {
   public:
-    virtual ~Factory() {}
     /** \brief Allocate a CharReader via operator new().
      * \throw std::exception if something goes wrong (e.g. invalid settings)
      */
@@ -236,6 +235,8 @@ public:
 
 /** \brief Build a CharReader implementation.
 
+  \deprecated This is experimental and will be altered before the next release.
+
 Usage:
 \code
   using namespace Json;

include/json/value.h

@@ -11,7 +11,6 @@
 #endif // if !defined(JSON_IS_AMALGAMATION)
 #include <string>
 #include <vector>
-#include <exception>
 
 #ifndef JSON_USE_CPPTL_SMALLMAP
 #include <map>
@@ -33,31 +32,6 @@
  */
 namespace Json {
 
-/** Base class for all exceptions we throw.
- *
- * We use nothing but these internally. Of course, STL can throw others.
- */
-class JSON_API Exception;
-/** Exceptions which the user cannot easily avoid.
- *
- * E.g. out-of-memory (when we use malloc), stack-overflow, malicious input
- * 
- * \remark derived from Json::Exception
- */
-class JSON_API RuntimeError;
-/** Exceptions thrown by JSON_ASSERT/JSON_FAIL macros.
- *
- * These are precondition-violations (user bugs) and internal errors (our bugs).
- * 
- * \remark derived from Json::Exception
- */
-class JSON_API LogicError;
-
-/// used internally
-void throwRuntimeError(std::string const& msg);
-/// used internally
-void throwLogicError(std::string const& msg);
-
 /** \brief Type of the value held by a Value object.
  */
 enum ValueType {
@@ -515,7 +489,6 @@ Json::Value obj_value(Json::objectValue); // {}
   //# endif
 
   /// \deprecated Always pass len.
-  JSONCPP_DEPRECATED("Use setComment(std::string const&) instead.")
   void setComment(const char* comment, CommentPlacement placement);
   /// Comments must be //... or /* ... */
   void setComment(const char* comment, size_t len, CommentPlacement placement);
@@ -659,22 +632,16 @@ public:
   /// Value.
   Value key() const;
 
-  /// Return the index of the referenced Value, or -1 if it is not an arrayValue.
+  /// Return the index of the referenced Value. -1 if it is not an arrayValue.
   UInt index() const;
 
-  /// Return the member name of the referenced Value, or "" if it is not an
-  /// objectValue.
-  /// \note Avoid `c_str()` on result, as embedded zeroes are possible.
-  std::string name() const;
-
   /// Return the member name of the referenced Value. "" if it is not an
   /// objectValue.
   /// \deprecated This cannot be used for UTF-8 strings, since there can be embedded nulls.
-  JSONCPP_DEPRECATED("Use `key = name();` instead.")
   char const* memberName() const;
   /// Return the member name of the referenced Value, or NULL if it is not an
   /// objectValue.
-  /// \note Better version than memberName(). Allows embedded nulls.
+  /// Better version than memberName(). Allows embedded nulls.
   char const* memberName(char const** end) const;
 
 protected:

include/json/version.h

@@ -4,10 +4,10 @@
 #ifndef JSON_VERSION_H_INCLUDED
 # define JSON_VERSION_H_INCLUDED
 
-# define JSONCPP_VERSION_STRING "1.10.0"
+# define JSONCPP_VERSION_STRING "0.9.4"
-# define JSONCPP_VERSION_MAJOR 1
+# define JSONCPP_VERSION_MAJOR 0
-# define JSONCPP_VERSION_MINOR 10
+# define JSONCPP_VERSION_MINOR 9
-# define JSONCPP_VERSION_PATCH 0
+# define JSONCPP_VERSION_PATCH 4
 # define JSONCPP_VERSION_QUALIFIER
 # define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8))
 

include/json/writer.h

@@ -46,7 +46,7 @@ public:
   /** Write Value into document as configured in sub-class.
       Do not take ownership of sout, but maintain a reference during function.
       \pre sout != NULL
-      \return zero on success (For now, we always return zero, so check the stream instead.)
+      \return zero on success
       \throw std::exception possibly, depending on configuration
    */
   virtual int write(Value const& root, std::ostream* sout) = 0;
@@ -132,7 +132,7 @@ public:
 };
 
 /** \brief Abstract class for writers.
- * \deprecated Use StreamWriter. (And really, this is an implementation detail.)
+ * \deprecated Use StreamWriter.
  */
 class JSON_API Writer {
 public:
@@ -151,7 +151,6 @@ public:
  * \deprecated Use StreamWriterBuilder.
  */
 class JSON_API FastWriter : public Writer {
-
 public:
   FastWriter();
   virtual ~FastWriter() {}

src/lib_json/json_reader.cpp

@@ -17,6 +17,7 @@
 #include <sstream>
 #include <memory>
 #include <set>
+#include <stdexcept>
 
 #if defined(_MSC_VER) && _MSC_VER < 1500 // VC++ 8.0 and below
 #define snprintf _snprintf
@@ -144,7 +145,7 @@ bool Reader::readValue() {
   // But this deprecated class has a security problem: Bad input can
   // cause a seg-fault. This seems like a fair, binary-compatible way
   // to prevent the problem.
-  if (stackDepth_g >= stackLimit_g) throwRuntimeError("Exceeded stackLimit in readValue().");
+  if (stackDepth_g >= stackLimit_g) throw std::runtime_error("Exceeded stackLimit in readValue().");
   ++stackDepth_g;
 
   Token token;
@@ -1013,7 +1014,7 @@ bool OurReader::parse(const char* beginDoc,
 }
 
 bool OurReader::readValue() {
-  if (stackDepth_ >= features_.stackLimit_) throwRuntimeError("Exceeded stackLimit in readValue().");
+  if (stackDepth_ >= features_.stackLimit_) throw std::runtime_error("Exceeded stackLimit in readValue().");
   ++stackDepth_;
   Token token;
   skipCommentTokens(token);
@@ -1324,7 +1325,7 @@ bool OurReader::readObject(Token& tokenStart) {
       return addErrorAndRecover(
           "Missing ':' after object member name", colon, tokenObjectEnd);
     }
-    if (name.length() >= (1U<<30)) throwRuntimeError("keylength >= 2^30");
+    if (name.length() >= (1U<<30)) throw std::runtime_error("keylength >= 2^30");
     if (features_.rejectDupKeys_ && currentValue().isMember(name)) {
       std::string msg = "Duplicate key: '" + name + "'";
       return addErrorAndRecover(
@@ -1826,7 +1827,7 @@ std::istream& operator>>(std::istream& sin, Value& root) {
             "Error from reader: %s",
             errs.c_str());
 
-    throwRuntimeError("reader error");
+    JSON_FAIL_MESSAGE("reader error");
   }
   return sin;
 }

src/lib_json/json_value.cpp

@@ -88,11 +88,9 @@ static inline char* duplicateStringValue(const char* value,
     length = Value::maxInt - 1;
 
   char* newString = static_cast<char*>(malloc(length + 1));
-  if (newString == NULL) {
+  JSON_ASSERT_MESSAGE(newString != 0,
-    throwRuntimeError(
                       "in Json::Value::duplicateStringValue(): "
                       "Failed to allocate string value buffer");
-  }
   memcpy(newString, value, length);
   newString[length] = 0;
   return newString;
@@ -111,11 +109,9 @@ static inline char* duplicateAndPrefixStringValue(
                       "length too big for prefixing");
   unsigned actualLength = length + sizeof(unsigned) + 1U;
   char* newString = static_cast<char*>(malloc(actualLength));
-  if (newString == 0) {
+  JSON_ASSERT_MESSAGE(newString != 0,
-    throwRuntimeError(
                       "in Json::Value::duplicateAndPrefixStringValue(): "
                       "Failed to allocate string value buffer");
-  }
   *reinterpret_cast<unsigned*>(newString) = length;
   memcpy(newString + sizeof(unsigned), value, length);
   newString[actualLength - 1U] = 0; // to avoid buffer over-run accidents by users later
@@ -153,47 +149,6 @@ static inline void releaseStringValue(char* value) { free(value); }
 
 namespace Json {
 
-class JSON_API Exception : public std::exception {
-public:
-  Exception(std::string const& msg);
-  virtual ~Exception() throw();
-  virtual char const* what() const throw();
-protected:
-  std::string const msg_;
-};
-class JSON_API RuntimeError : public Exception {
-public:
-  RuntimeError(std::string const& msg);
-};
-class JSON_API LogicError : public Exception {
-public:
-  LogicError(std::string const& msg);
-};
-
-Exception::Exception(std::string const& msg)
-  : msg_(msg)
-{}
-Exception::~Exception() throw()
-{}
-char const* Exception::what() const throw()
-{
-  return msg_.c_str();
-}
-RuntimeError::RuntimeError(std::string const& msg)
-  : Exception(msg)
-{}
-LogicError::LogicError(std::string const& msg)
-  : Exception(msg)
-{}
-void throwRuntimeError(std::string const& msg)
-{
-  throw RuntimeError(msg);
-}
-void throwLogicError(std::string const& msg)
-{
-  throw LogicError(msg);
-}
-
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////

src/lib_json/json_valueiterator.inl

@@ -92,14 +92,6 @@ UInt ValueIteratorBase::index() const {
   return Value::UInt(-1);
 }
 
-std::string ValueIteratorBase::name() const {
-  char const* key;
-  char const* end;
-  key = memberName(&end);
-  if (!key) return std::string();
-  return std::string(key, end);
-}
-
 char const* ValueIteratorBase::memberName() const {
   const char* name = (*current_).first.data();
   return name ? name : "";

src/lib_json/json_writer.cpp

@@ -12,25 +12,16 @@
 #include <sstream>
 #include <utility>
 #include <set>
-#include <cassert>
+#include <stdexcept>
-#include <cstring>
+#include <assert.h>
-#include <cstdio>
+#include <math.h>
-
+#include <stdio.h>
-#if defined(_MSC_VER) && _MSC_VER >= 1200 && _MSC_VER < 1800 // Between VC++ 6.0 and VC++ 11.0
+#include <string.h>
-#include <float.h>
-#define isfinite _finite
-#elif defined(__sun) && defined(__SVR4) //Solaris
-#include <ieeefp.h>
-#define isfinite finite
-#else
-#include <cmath>
-#define isfinite std::isfinite
-#endif
 
 #if defined(_MSC_VER) && _MSC_VER < 1500 // VC++ 8.0 and below
+#include <float.h>
+#define isfinite _finite
 #define snprintf _snprintf
-#else
-#define snprintf std::snprintf
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400 // VC++ 8.0
@@ -38,6 +29,11 @@
 #pragma warning(disable : 4996)
 #endif
 
+#if defined(__sun) && defined(__SVR4) //Solaris
+#include <ieeefp.h>
+#define isfinite finite
+#endif
+
 namespace Json {
 
 #if __cplusplus >= 201103L
@@ -1077,7 +1073,7 @@ StreamWriter* StreamWriterBuilder::newStreamWriter() const
   } else if (cs_str == "None") {
     cs = CommentStyle::None;
   } else {
-    throwRuntimeError("commentStyle must be 'All' or 'None'");
+    throw std::runtime_error("commentStyle must be 'All' or 'None'");
   }
   std::string colonSymbol = " : ";
   if (eyc) {

src/test_lib_json/main.cpp

@@ -6,6 +6,7 @@
 #include "jsontest.h"
 #include <json/config.h>
 #include <json/json.h>
+#include <stdexcept>
 #include <cstring>
 
 // Make numeric limits more convenient to talk about.
@@ -1523,7 +1524,7 @@ JSONTEST_FIXTURE(ValueTest, StaticString) {
 
 JSONTEST_FIXTURE(ValueTest, CommentBefore) {
   Json::Value val; // fill val
-  val.setComment(std::string("// this comment should appear before"), Json::commentBefore);
+  val.setComment("// this comment should appear before", Json::commentBefore);
   Json::StreamWriterBuilder wbuilder;
   wbuilder.settings_["commentStyle"] = "All";
   {
@@ -2212,42 +2213,6 @@ JSONTEST_FIXTURE(IteratorTest, distance) {
   JSONTEST_ASSERT_STRING_EQUAL("b", str);
 }
 
-JSONTEST_FIXTURE(IteratorTest, names) {
-  Json::Value json;
-  json["k1"] = "a";
-  json["k2"] = "b";
-  Json::ValueIterator it = json.begin();
-  JSONTEST_ASSERT(it != json.end());
-  JSONTEST_ASSERT_EQUAL(Json::Value("k1"), it.key());
-  JSONTEST_ASSERT_STRING_EQUAL("k1", it.name());
-  JSONTEST_ASSERT_EQUAL(-1, it.index());
-  ++it;
-  JSONTEST_ASSERT(it != json.end());
-  JSONTEST_ASSERT_EQUAL(Json::Value("k2"), it.key());
-  JSONTEST_ASSERT_STRING_EQUAL("k2", it.name());
-  JSONTEST_ASSERT_EQUAL(-1, it.index());
-  ++it;
-  JSONTEST_ASSERT(it == json.end());
-}
-
-JSONTEST_FIXTURE(IteratorTest, indexes) {
-  Json::Value json;
-  json[0] = "a";
-  json[1] = "b";
-  Json::ValueIterator it = json.begin();
-  JSONTEST_ASSERT(it != json.end());
-  JSONTEST_ASSERT_EQUAL(Json::Value(Json::ArrayIndex(0)), it.key());
-  JSONTEST_ASSERT_STRING_EQUAL("", it.name());
-  JSONTEST_ASSERT_EQUAL(0, it.index());
-  ++it;
-  JSONTEST_ASSERT(it != json.end());
-  JSONTEST_ASSERT_EQUAL(Json::Value(Json::ArrayIndex(1)), it.key());
-  JSONTEST_ASSERT_STRING_EQUAL("", it.name());
-  JSONTEST_ASSERT_EQUAL(1, it.index());
-  ++it;
-  JSONTEST_ASSERT(it == json.end());
-}
-
 int main(int argc, const char* argv[]) {
   JsonTest::Runner runner;
   JSONTEST_REGISTER_FIXTURE(runner, ValueTest, checkNormalizeFloatingPointStr);
@@ -2310,8 +2275,6 @@ int main(int argc, const char* argv[]) {
   JSONTEST_REGISTER_FIXTURE(runner, BuilderTest, settings);
 
   JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, distance);
-  JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, names);
-  JSONTEST_REGISTER_FIXTURE(runner, IteratorTest, indexes);
 
   return runner.runCommandLine(argc, argv);
 }

version

@@ -1 +1 @@
-1.10.0
+0.9.4