Fixed compilation issues with MSVC 6: replace usage of ostringstream with valueToString to support 64 bits integer and high precision floating point conversion to string. Replace usage of ULL and LL literal with UInt64(expr) and Int64(expr). Introduced helper function uint64ToDouble() to work-around missing conversion. Unit tests do not pass yet.

blep · blep · commit f587e6a420c4 · 2011-05-26T22:55:24.000Z
diff --git a/src/lib_json/json_value.cpp b/src/lib_json/json_value.cpp
@@ -48,10 +48,28 @@ const LargestUInt Value::maxLargestUInt = LargestUInt(-1);
 /// Unknown size marker
 static const unsigned int unknown = (unsigned)-1;
 
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+template <typename T, typename U>
+static inline bool InRange(double d, T min, U max) {
+   return d >= min && d <= max;
+}
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double integerToDouble( Json::UInt64 value )
+{
+    return static_cast<double>( UInt(value >> 32) ) * (UInt64(1)<<32) + UInt(value & 0xffffffff);
+}
+
+template<typename T>
+static inline double integerToDouble( T value )
+{
+    return static_cast<double>( value );
+}
+
 template <typename T, typename U>
 static inline bool InRange(double d, T min, U max) {
-  return d >= min && d <= max;
+   return d >= integerToDouble(min) && d <= integerToDouble(max);
 }
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
 
 
 /** Duplicates the specified string value.
@@ -673,9 +691,6 @@ Value::asCString() const
 std::string 
 Value::asString() const
 {
-   // Let the STL sort it out for numeric types.
-   std::ostringstream oss;
-
    switch ( type_ )
    {
    case nullValue:
@@ -685,18 +700,14 @@ Value::asString() const
    case booleanValue:
       return value_.bool_ ? "true" : "false";
    case intValue:
-      oss << value_.int_;
-      break;
+      return valueToString( value_.int_ );
    case uintValue:
-      oss << value_.uint_;
-      break;
+      return valueToString( value_.uint_ );
    case realValue:
-      oss << value_.real_;
-      break;
+      return valueToString( value_.real_ );
    default:
       JSON_FAIL_MESSAGE( "Type is not convertible to string" );
    }
-   return oss.str();
 }
 
 # ifdef JSON_USE_CPPTL
@@ -842,7 +853,7 @@ Value::asDouble() const
 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
       return static_cast<double>( value_.uint_ );
 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
-      return static_cast<double>( Int(value_.uint_/2) ) * 2 + Int(value_.uint_ & 1);
+      return integerToDouble( value_.uint_ );
 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    case realValue:
       return value_.real_;
diff --git a/src/test_lib_json/jsontest.cpp b/src/test_lib_json/jsontest.cpp
@@ -249,6 +249,23 @@ TestResult::addToLastFailure( const std::string &message )
    return *this;
 }
 
+TestResult &
+TestResult::operator << ( Json::Int64 value ) {
+   return addToLastFailure( Json::valueToString(value) );
+}
+
+
+TestResult &
+TestResult::operator << ( Json::UInt64 value ) {
+   return addToLastFailure( Json::valueToString(value) );
+}
+
+
+TestResult &
+TestResult::operator << ( bool value ) {
+   return addToLastFailure(value ? "true" : "false");
+}
+
 
 // class TestCase
 // //////////////////////////////////////////////////////////////////
diff --git a/src/test_lib_json/jsontest.h b/src/test_lib_json/jsontest.h
@@ -8,6 +8,7 @@
 
 # include <json/config.h>
 # include <json/value.h>
+# include <json/writer.h>
 # include <stdio.h>
 # include <deque>
 # include <sstream>
@@ -90,14 +91,17 @@ namespace JsonTest {
       template <typename T>
       TestResult &operator << ( const T& value ) {
          std::ostringstream oss;
+         oss.precision( 16 );
+         oss.setf( std::ios_base::floatfield );
          oss << value;
          return addToLastFailure(oss.str());
       }
 
       // Specialized versions.
-      TestResult &operator << ( bool value ) {
-         return addToLastFailure(value ? "true" : "false");
-      }
+      TestResult &operator << ( bool value );
+      // std:ostream does not support 64bits integers on all STL implementation
+      TestResult &operator << ( Json::Int64 value );
+      TestResult &operator << ( Json::UInt64 value );
 
    private:
       TestResult &addToLastFailure( const std::string &message );
@@ -195,6 +199,7 @@ namespace JsonTest {
       return result;
    }
 
+
    TestResult &
    checkStringEqual( TestResult &result, 
                      const std::string &expected, const std::string &actual,
diff --git a/src/test_lib_json/main.cpp b/src/test_lib_json/main.cpp
