Revert "JSON Spirit updated to v4.06"

This reverts commit 2227389fa8fa1b9ff19234838fc7b641e935125b.

14 files changed, 382 insertions, 681 deletions

diff --git a/src/bitcoinrpc.cpp b/src/bitcoinrpc.cpp
index 4d0767e431..f2a52e92ed 100644
--- a/src/bitcoinrpc.cpp
+++ b/src/bitcoinrpc.cpp
@@ -31,8 +31,6 @@ using namespace boost;
 using namespace boost::asio;
 using namespace json_spirit;
 
-static const char* Value_type_name[]={"obj", "array", "str", "bool", "int", "real", "null"};
-
 static std::string strRPCUserColonPass;
 
 // These are created by StartRPCThreads, destroyed in StopRPCThreads
diff --git a/src/json/LICENSE.txt b/src/json/LICENSE.txt
index 6ed66a2e69..797d5363b3 100644
--- a/src/json/LICENSE.txt
+++ b/src/json/LICENSE.txt
@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2007 - 2010 John W. Wilkinson
+Copyright (c) 2007 - 2009 John W. Wilkinson
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
diff --git a/src/json/json_spirit.h b/src/json/json_spirit.h
index ef442e9fd5..ac1879d5b3 100644
--- a/src/json/json_spirit.h
+++ b/src/json/json_spirit.h
@@ -1,10 +1,10 @@
 #ifndef JSON_SPIRIT
 #define JSON_SPIRIT
 
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
+// json spirit version 4.03
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
diff --git a/src/json/json_spirit_error_position.h b/src/json/json_spirit_error_position.h
index e2b59b47ae..17208507df 100644
--- a/src/json/json_spirit_error_position.h
+++ b/src/json/json_spirit_error_position.h
@@ -1,10 +1,10 @@
 #ifndef JSON_SPIRIT_ERROR_POSITION
 #define JSON_SPIRIT_ERROR_POSITION
 
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
+// json spirit version 4.03
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -48,7 +48,7 @@ namespace json_spirit
         return ( reason_ == lhs.reason_ ) &&
                ( line_   == lhs.line_ ) &&
                ( column_ == lhs.column_ ); 
-    }
+}
 }
 
 #endif
diff --git a/src/json/json_spirit_reader.cpp b/src/json/json_spirit_reader.cpp
index 7dea074736..aa4f637226 100644
--- a/src/json/json_spirit_reader.cpp
+++ b/src/json/json_spirit_reader.cpp
@@ -1,137 +1,137 @@
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
+// json spirit version 4.03
 
 #include "json_spirit_reader.h"
 #include "json_spirit_reader_template.h"
 
 using namespace json_spirit;
 
-#ifdef JSON_SPIRIT_VALUE_ENABLED
-    bool json_spirit::read( const std::string& s, Value& value )
-    {
-        return read_string( s, value );
-    }
-    
-    void json_spirit::read_or_throw( const std::string& s, Value& value )
-    {
-        read_string_or_throw( s, value );
-    }
-
-    bool json_spirit::read( std::istream& is, Value& value )
-    {
-        return read_stream( is, value );
-    }
-
-    void json_spirit::read_or_throw( std::istream& is, Value& value )
-    {
-        read_stream_or_throw( is, value );
-    }
-
-    bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
-    {
-        return read_range( begin, end, value );
-    }
-
-    void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
-    {
-        begin = read_range_or_throw( begin, end, value );
-    }
-#endif
+bool json_spirit::read( const std::string& s, Value& value )
+{
+    return read_string( s, value );
+}
+
+void json_spirit::read_or_throw( const std::string& s, Value& value )
+{
+    read_string_or_throw( s, value );
+}
+
+bool json_spirit::read( std::istream& is, Value& value )
+{
+    return read_stream( is, value );
+}
+
+void json_spirit::read_or_throw( std::istream& is, Value& value )
+{
+    read_stream_or_throw( is, value );
+}
+
+bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
+{
+    return read_range( begin, end, value );
+}
+
+void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
+{
+    begin = read_range_or_throw( begin, end, value );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+
+bool json_spirit::read( const std::wstring& s, wValue& value )
+{
+    return read_string( s, value );
+}
+
+void json_spirit::read_or_throw( const std::wstring& s, wValue& value )
+{
+    read_string_or_throw( s, value );
+}
+
+bool json_spirit::read( std::wistream& is, wValue& value )
+{
+    return read_stream( is, value );
+}
+
+void json_spirit::read_or_throw( std::wistream& is, wValue& value )
+{
+    read_stream_or_throw( is, value );
+}
+
+bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
+{
+    return read_range( begin, end, value );
+}
+
+void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
+{
+    begin = read_range_or_throw( begin, end, value );
+}
 
-#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
-    bool json_spirit::read( const std::wstring& s, wValue& value )
-    {
-        return read_string( s, value );
-    }
-
-    void json_spirit::read_or_throw( const std::wstring& s, wValue& value )
-    {
-        read_string_or_throw( s, value );
-    }
-
-    bool json_spirit::read( std::wistream& is, wValue& value )
-    {
-        return read_stream( is, value );
-    }
-
-    void json_spirit::read_or_throw( std::wistream& is, wValue& value )
-    {
-        read_stream_or_throw( is, value );
-    }
-
-    bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
-    {
-        return read_range( begin, end, value );
-    }
-
-    void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
-    {
-        begin = read_range_or_throw( begin, end, value );
-    }
 #endif
 
-#ifdef JSON_SPIRIT_MVALUE_ENABLED
-    bool json_spirit::read( const std::string& s, mValue& value )
-    {
-        return read_string( s, value );
-    }
-
-    void json_spirit::read_or_throw( const std::string& s, mValue& value )
-    {
-        read_string_or_throw( s, value );
-    }
-    
-    bool json_spirit::read( std::istream& is, mValue& value )
-    {
-        return read_stream( is, value );
-    }
-
-    void json_spirit::read_or_throw( std::istream& is, mValue& value )
-    {
-        read_stream_or_throw( is, value );
-    }
-
-    bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
-    {
-        return read_range( begin, end, value );
-    }
-
-    void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
-    {
-        begin = read_range_or_throw( begin, end, value );
-    }
-#endif
+bool json_spirit::read( const std::string& s, mValue& value )
+{
+    return read_string( s, value );
+}
+
+void json_spirit::read_or_throw( const std::string& s, mValue& value )
+{
+    read_string_or_throw( s, value );
+}
+
+bool json_spirit::read( std::istream& is, mValue& value )
+{
+    return read_stream( is, value );
+}
+
+void json_spirit::read_or_throw( std::istream& is, mValue& value )
+{
+    read_stream_or_throw( is, value );
+}
+
+bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
+{
+    return read_range( begin, end, value );
+}
+
+void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
+{
+    begin = read_range_or_throw( begin, end, value );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+
+bool json_spirit::read( const std::wstring& s, wmValue& value )
+{
+    return read_string( s, value );
+}
+
+void json_spirit::read_or_throw( const std::wstring& s, wmValue& value )
+{
+    read_string_or_throw( s, value );
+}
+
+bool json_spirit::read( std::wistream& is, wmValue& value )
+{
+    return read_stream( is, value );
+}
+
+void json_spirit::read_or_throw( std::wistream& is, wmValue& value )
+{
+    read_stream_or_throw( is, value );
+}
+
+bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
+{
+    return read_range( begin, end, value );
+}
+
+void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
+{
+    begin = read_range_or_throw( begin, end, value );
+}
 
-#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
-    bool json_spirit::read( const std::wstring& s, wmValue& value )
-    {
-        return read_string( s, value );
-    }
-
-    void json_spirit::read_or_throw( const std::wstring& s, wmValue& value )
-    {
-        read_string_or_throw( s, value );
-    }
-
-    bool json_spirit::read( std::wistream& is, wmValue& value )
-    {
-        return read_stream( is, value );
-    }
-
-    void json_spirit::read_or_throw( std::wistream& is, wmValue& value )
-    {
-        read_stream_or_throw( is, value );
-    }
-
-    bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
-    {
-        return read_range( begin, end, value );
-    }
-
-    void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
-    {
-        begin = read_range_or_throw( begin, end, value );
-    }
 #endif
diff --git a/src/json/json_spirit_reader.h b/src/json/json_spirit_reader.h
index f0dc5330f2..96494a9789 100644
--- a/src/json/json_spirit_reader.h
+++ b/src/json/json_spirit_reader.h
@@ -1,10 +1,10 @@
 #ifndef JSON_SPIRIT_READER
 #define JSON_SPIRIT_READER
 
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
+// json spirit version 4.03
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -18,7 +18,6 @@ namespace json_spirit
 {
     // functions to reads a JSON values
 
-#ifdef JSON_SPIRIT_VALUE_ENABLED
     bool read( const std::string& s, Value& value );
     bool read( std::istream& is,     Value& value );
     bool read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
@@ -26,9 +25,9 @@ namespace json_spirit
     void read_or_throw( const std::string& s, Value& value );  
     void read_or_throw( std::istream& is,     Value& value );
     void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
-#endif
 
-#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
+#ifndef BOOST_NO_STD_WSTRING
+
     bool read( const std::wstring& s, wValue& value );
     bool read( std::wistream&  is,    wValue& value );
     bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );    
@@ -36,9 +35,9 @@ namespace json_spirit
     void read_or_throw( const std::wstring& s, wValue& value );
     void read_or_throw( std::wistream& is,     wValue& value );
     void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );
+
 #endif
 
-#ifdef JSON_SPIRIT_MVALUE_ENABLED
     bool read( const std::string& s, mValue& value );
     bool read( std::istream& is,     mValue& value );
     bool read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
@@ -46,9 +45,9 @@ namespace json_spirit
     void read_or_throw( const std::string& s, mValue& value );  
     void read_or_throw( std::istream& is,     mValue& value );
     void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
-#endif
 
-#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
+#ifndef BOOST_NO_STD_WSTRING
+
     bool read( const std::wstring& s, wmValue& value );
     bool read( std::wistream& is,     wmValue& value );
     bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );    
@@ -56,6 +55,7 @@ namespace json_spirit
     void read_or_throw( const std::wstring& s, wmValue& value );
     void read_or_throw( std::wistream& is,     wmValue& value );
     void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );
+
 #endif
 }
 
diff --git a/src/json/json_spirit_reader_template.h b/src/json/json_spirit_reader_template.h
index d3d0cecaa5..4dec00e6c9 100644
--- a/src/json/json_spirit_reader_template.h
+++ b/src/json/json_spirit_reader_template.h
@@ -1,14 +1,10 @@
 #ifndef JSON_SPIRIT_READER_TEMPLATE
 #define JSON_SPIRIT_READER_TEMPLATE
 
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
+// json spirit version 4.03
 
 #include "json_spirit_value.h"
 #include "json_spirit_error_position.h"
@@ -488,7 +484,7 @@ namespace json_spirit
                     ;
 
                 string_ 
-                    = lexeme_d // this causes white space and what would appear to be comments inside a string to be retained
+                    = lexeme_d // this causes white space inside a string to be retained
                       [
                           confix_p
                           ( 
@@ -519,44 +515,6 @@ namespace json_spirit
     };
 
     template< class Iter_type, class Value_type >
-    void add_posn_iter_and_read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
-    {
-        typedef spirit_namespace::position_iterator< Iter_type > Posn_iter_t;
-
-        const Posn_iter_t posn_begin( begin, end );
-        const Posn_iter_t posn_end( end, end );
-     
-        read_range_or_throw( posn_begin, posn_end, value );
-    }
-
-    template< class Istream_type >
-    struct Multi_pass_iters
-    {
-        typedef typename Istream_type::char_type Char_type;
-        typedef std::istream_iterator< Char_type, Char_type > istream_iter;
-        typedef spirit_namespace::multi_pass< istream_iter > Mp_iter;
-
-        Multi_pass_iters( Istream_type& is )
-        {
-            is.unsetf( std::ios::skipws );
-
-            begin_ = spirit_namespace::make_multi_pass( istream_iter( is ) );
-            end_   = spirit_namespace::make_multi_pass( istream_iter() );
-        }
-
-        Mp_iter begin_;
-        Mp_iter end_;
-    };
-
-    // reads a JSON Value from a pair of input iterators throwing an exception on invalid input, e.g.
-    //
-    // string::const_iterator start = str.begin();
-    // const string::const_iterator next = read_range_or_throw( str.begin(), str.end(), value );
-    //
-    // The iterator 'next' will point to the character past the 
-    // last one read.
-    //
-    template< class Iter_type, class Value_type >
     Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
     {
         Semantic_actions< Value_type, Iter_type > semantic_actions( value );
@@ -564,9 +522,7 @@ namespace json_spirit
         const spirit_namespace::parse_info< Iter_type > info = 
                             spirit_namespace::parse( begin, end, 
                                                     Json_grammer< Value_type, Iter_type >( semantic_actions ), 
-                                                    spirit_namespace::space_p | 
-                                                    spirit_namespace::comment_p("//") | 
-                                                    spirit_namespace::comment_p("/*", "*/") );
+                                                    spirit_namespace::space_p );
 
         if( !info.hit )
         {
@@ -577,14 +533,17 @@ namespace json_spirit
         return info.stop;
     }
 
-    // reads a JSON Value from a pair of input iterators, e.g.
-    //
-    // string::const_iterator start = str.begin();
-    // const bool success = read_string( start, str.end(), value );
-    //
-    // The iterator 'start' will point to the character past the 
-    // last one read.
-    //
+    template< class Iter_type, class Value_type >
+    void add_posn_iter_and_read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
+    {
+        typedef spirit_namespace::position_iterator< Iter_type > Posn_iter_t;
+
+        const Posn_iter_t posn_begin( begin, end );
+        const Posn_iter_t posn_end( end, end );
+     
+        read_range_or_throw( posn_begin, posn_end, value );
+    }
+
     template< class Iter_type, class Value_type >
     bool read_range( Iter_type& begin, Iter_type end, Value_type& value )
     {
@@ -600,10 +559,12 @@ namespace json_spirit
         }
     }
 
-    // reads a JSON Value from a string, e.g.
-    //
-    // const bool success = read_string( str, value );
-    //
+    template< class String_type, class Value_type >
+    void read_string_or_throw( const String_type& s, Value_type& value )
+    {
+        add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value );
+    }
+
     template< class String_type, class Value_type >
     bool read_string( const String_type& s, Value_type& value )
     {
@@ -612,20 +573,25 @@ namespace json_spirit
         return read_range( begin, s.end(), value );
     }
 
-    // reads a JSON Value from a string throwing an exception on invalid input, e.g.
-    //
-    // read_string_or_throw( is, value );
-    //
-    template< class String_type, class Value_type >
-    void read_string_or_throw( const String_type& s, Value_type& value )
+    template< class Istream_type >
+    struct Multi_pass_iters
     {
-        add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value );
-    }
+        typedef typename Istream_type::char_type Char_type;
+        typedef std::istream_iterator< Char_type, Char_type > istream_iter;
+        typedef spirit_namespace::multi_pass< istream_iter > Mp_iter;
+
+        Multi_pass_iters( Istream_type& is )
+        {
+            is.unsetf( std::ios::skipws );
+
+            begin_ = spirit_namespace::make_multi_pass( istream_iter( is ) );
+            end_   = spirit_namespace::make_multi_pass( istream_iter() );
+        }
+
+        Mp_iter begin_;
+        Mp_iter end_;
+    };
 
-    // reads a JSON Value from a stream, e.g.
-    //
-    // const bool success = read_stream( is, value );
-    //
     template< class Istream_type, class Value_type >
     bool read_stream( Istream_type& is, Value_type& value )
     {
@@ -634,10 +600,6 @@ namespace json_spirit
         return read_range( mp_iters.begin_, mp_iters.end_, value );
     }
 
-    // reads a JSON Value from a stream throwing an exception on invalid input, e.g.
-    //
-    // read_stream_or_throw( is, value );
-    //
     template< class Istream_type, class Value_type >
     void read_stream_or_throw( Istream_type& is, Value_type& value )
     {
diff --git a/src/json/json_spirit_stream_reader.h b/src/json/json_spirit_stream_reader.h
index 8bbdbc0543..7e59c9adc2 100644
--- a/src/json/json_spirit_stream_reader.h
+++ b/src/json/json_spirit_stream_reader.h
@@ -1,10 +1,10 @@
 #ifndef JSON_SPIRIT_READ_STREAM
 #define JSON_SPIRIT_READ_STREAM
 
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
+// json spirit version 4.03
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
diff --git a/src/json/json_spirit_utils.h b/src/json/json_spirit_utils.h
index a174ac3a98..553e3b96a4 100644
--- a/src/json/json_spirit_utils.h
+++ b/src/json/json_spirit_utils.h
@@ -1,10 +1,10 @@
 #ifndef JSON_SPIRIT_UTILS
 #define JSON_SPIRIT_UTILS
 
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
+// json spirit version 4.03
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -37,11 +37,9 @@ namespace json_spirit
         }
     }
 
-#ifdef JSON_SPIRIT_VALUE_ENABLED
     typedef std::map< std::string, Value > Mapped_obj;
-#endif
 
-#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
+#ifndef BOOST_NO_STD_WSTRING
     typedef std::map< std::wstring, wValue > wMapped_obj;
 #endif
 
diff --git a/src/json/json_spirit_value.h b/src/json/json_spirit_value.h
index a5020405d4..7e83a2a7e3 100644
--- a/src/json/json_spirit_value.h
+++ b/src/json/json_spirit_value.h
@@ -1,10 +1,10 @@
 #ifndef JSON_SPIRIT_VALUE
 #define JSON_SPIRIT_VALUE
 
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
+// json spirit version 4.03
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
@@ -21,20 +21,11 @@
 #include <boost/shared_ptr.hpp> 
 #include <boost/variant.hpp> 
 
-// comment out the value types you don't need to reduce build times and intermediate file sizes
-#define JSON_SPIRIT_VALUE_ENABLED
-#define JSON_SPIRIT_WVALUE_ENABLED
-#define JSON_SPIRIT_MVALUE_ENABLED
-#define JSON_SPIRIT_WMVALUE_ENABLED
-
 namespace json_spirit
 {
     enum Value_type{ obj_type, array_type, str_type, bool_type, int_type, real_type, null_type };
+    static const char* Value_type_name[]={"obj", "array", "str", "bool", "int", "real", "null"};
 
-    static std::string value_type_to_string( Value_type vtype );
-
-    struct Null{};
-    
     template< class Config >    // Config determines whether the value uses std::string or std::wstring and
                                 // whether JSON Objects are represented as vectors or maps
     class Value_impl
@@ -58,12 +49,6 @@ namespace json_spirit
         Value_impl( boost::uint64_t    value );
         Value_impl( double             value );
 
-        template< class Iter >
-        Value_impl( Iter first, Iter last );    // constructor from containers, e.g. std::vector or std::list
-
-        template< BOOST_VARIANT_ENUM_PARAMS( typename T ) >
-        Value_impl( const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& variant ); // constructor for compatible variant types
-
         Value_impl( const Value_impl& other );
 
         bool operator==( const Value_impl& lhs ) const;
@@ -96,32 +81,13 @@ namespace json_spirit
 
         void check_type( const Value_type vtype ) const;
 
-        typedef boost::variant< boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >, 
-                                String_type, bool, boost::int64_t, double, Null, boost::uint64_t > Variant;
+        typedef boost::variant< String_type, 
+                                boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >, 
+                                bool, boost::int64_t, double > Variant;
 
+        Value_type type_;
         Variant v_;
-
-        class Variant_converter_visitor : public boost::static_visitor< Variant > 
-        {
-        public:
-         
-              template< typename T, typename A, template< typename, typename > class Cont >
-              Variant operator()( const Cont< T, A >& cont ) const 
-              {
-                  return Array( cont.begin(), cont.end() );
-              }
-             
-              Variant operator()( int i ) const 
-              {
-                  return static_cast< boost::int64_t >( i );
-              }
-           
-              template<class T>
-              Variant operator()( const T& t ) const 
-              {
-                  return t;
-              }
-        };
+        bool is_uint64_;
     };
 
     // vector objects
@@ -132,10 +98,6 @@ namespace json_spirit
         typedef typename Config::String_type String_type;
         typedef typename Config::Value_type Value_type;
 
-        Pair_impl()
-        {
-        }
-
         Pair_impl( const String_type& name, const Value_type& value );
 
         bool operator==( const Pair_impl& lhs ) const;
@@ -144,7 +106,6 @@ namespace json_spirit
         Value_type value_;
     };
 
-#if defined( JSON_SPIRIT_VALUE_ENABLED ) || defined( JSON_SPIRIT_WVALUE_ENABLED )
     template< class String >
     struct Config_vector
     {
@@ -161,32 +122,30 @@ namespace json_spirit
             return obj.back().value_;
         }
                 
-        static const String_type& get_name( const Pair_type& pair )
+        static String_type get_name( const Pair_type& pair )
         {
             return pair.name_;
         }
                 
-        static const Value_type& get_value( const Pair_type& pair )
+        static Value_type get_value( const Pair_type& pair )
         {
             return pair.value_;
         }
     };
-#endif
 
     // typedefs for ASCII
 
-#ifdef JSON_SPIRIT_VALUE_ENABLED
     typedef Config_vector< std::string > Config;
 
     typedef Config::Value_type  Value;
     typedef Config::Pair_type   Pair;
     typedef Config::Object_type Object;
     typedef Config::Array_type  Array;
-#endif
 
     // typedefs for Unicode
 
-#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
+#ifndef BOOST_NO_STD_WSTRING
+
     typedef Config_vector< std::wstring > wConfig;
 
     typedef wConfig::Value_type  wValue;
@@ -197,7 +156,6 @@ namespace json_spirit
 
     // map objects
 
-#if defined( JSON_SPIRIT_MVALUE_ENABLED ) || defined( JSON_SPIRIT_WMVALUE_ENABLED )
     template< class String >
     struct Config_map
     {
@@ -205,134 +163,135 @@ namespace json_spirit
         typedef Value_impl< Config_map > Value_type;
         typedef std::vector< Value_type > Array_type;
         typedef std::map< String_type, Value_type > Object_type;
-        typedef std::pair< const String_type, Value_type > Pair_type;
+        typedef typename Object_type::value_type Pair_type;
 
         static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
         {
             return obj[ name ] = value;
         }
                 
-        static const String_type& get_name( const Pair_type& pair )
+        static String_type get_name( const Pair_type& pair )
         {
             return pair.first;
         }
                 
-        static const Value_type& get_value( const Pair_type& pair )
+        static Value_type get_value( const Pair_type& pair )
         {
             return pair.second;
         }
     };
-#endif
 
     // typedefs for ASCII
 
-#ifdef JSON_SPIRIT_MVALUE_ENABLED
     typedef Config_map< std::string > mConfig;
 
     typedef mConfig::Value_type  mValue;
     typedef mConfig::Object_type mObject;
     typedef mConfig::Array_type  mArray;
-#endif
 
     // typedefs for Unicode
 
-#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
+#ifndef BOOST_NO_STD_WSTRING
+
     typedef Config_map< std::wstring > wmConfig;
 
     typedef wmConfig::Value_type  wmValue;
     typedef wmConfig::Object_type wmObject;
     typedef wmConfig::Array_type  wmArray;
+
 #endif
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     //
     // implementation
 
-    inline bool operator==( const Null&, const Null& )
-    {
-        return true;
-    }
-
     template< class Config >
     const Value_impl< Config > Value_impl< Config >::null;
 
     template< class Config >
     Value_impl< Config >::Value_impl()
-    :   v_( Null() )
+    :   type_( null_type )
+    ,   is_uint64_( false )
     {
     }
 
     template< class Config >
     Value_impl< Config >::Value_impl( const Const_str_ptr value )
-    :  v_( String_type( value ) )
+    :   type_( str_type )
+    ,   v_( String_type( value ) )
+    ,   is_uint64_( false )
     {
     }
 
     template< class Config >
     Value_impl< Config >::Value_impl( const String_type& value )
-    :   v_( value )
+    :   type_( str_type )
+    ,   v_( value )
+    ,   is_uint64_( false )
     {
     }
 
     template< class Config >
     Value_impl< Config >::Value_impl( const Object& value )
-    :   v_( value )
+    :   type_( obj_type )
+    ,   v_( value )
+    ,   is_uint64_( false )
     {
     }
 
     template< class Config >
     Value_impl< Config >::Value_impl( const Array& value )
-    :   v_( value )
+    :   type_( array_type )
+    ,   v_( value )
+    ,   is_uint64_( false )
     {
     }
 
     template< class Config >
     Value_impl< Config >::Value_impl( bool value )
-    :   v_( value )
+    :   type_( bool_type )
+    ,   v_( value )
+    ,   is_uint64_( false )
     {
     }
 
     template< class Config >
     Value_impl< Config >::Value_impl( int value )
-    :   v_( static_cast< boost::int64_t >( value ) )
+    :   type_( int_type )
+    ,   v_( static_cast< boost::int64_t >( value ) )
+    ,   is_uint64_( false )
     {
     }
 
     template< class Config >
     Value_impl< Config >::Value_impl( boost::int64_t value )
-    :   v_( value )
+    :   type_( int_type )
+    ,   v_( value )
+    ,   is_uint64_( false )
     {
     }
 
     template< class Config >
     Value_impl< Config >::Value_impl( boost::uint64_t value )
-    :   v_( value )
+    :   type_( int_type )
+    ,   v_( static_cast< boost::int64_t >( value ) )
+    ,   is_uint64_( true )
     {
     }
 
     template< class Config >
     Value_impl< Config >::Value_impl( double value )
-    :   v_( value )
+    :   type_( real_type )
+    ,   v_( value )
+    ,   is_uint64_( false )
     {
     }
 
     template< class Config >
     Value_impl< Config >::Value_impl( const Value_impl< Config >& other )
-    :   v_( other.v_ )
-    {
-    }
-
-    template< class Config >
-    template< class Iter >
-    Value_impl< Config >::Value_impl( Iter first, Iter last )
-    :   v_( Array( first, last ) )
-    {
-    }
-
-    template< class Config >
-    template< BOOST_VARIANT_ENUM_PARAMS( typename T ) >
-    Value_impl< Config >::Value_impl( const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& variant )
-    :   v_( boost::apply_visitor( Variant_converter_visitor(), variant) )
+    :   type_( other.type() )
+    ,   v_( other.v_ )
+    ,   is_uint64_( other.is_uint64_ )
     {
     }
 
@@ -341,7 +300,9 @@ namespace json_spirit
     {
         Value_impl tmp( lhs );
 
+        std::swap( type_, tmp.type_ );
         std::swap( v_, tmp.v_ );
+        std::swap( is_uint64_, tmp.is_uint64_ );
 
         return *this;
     }
@@ -359,18 +320,13 @@ namespace json_spirit
     template< class Config >
     Value_type Value_impl< Config >::type() const
     {
-        if( is_uint64() )
-        {
-            return int_type;
-        }
-
-        return static_cast< Value_type >( v_.which() );
+        return type_;
     }
 
     template< class Config >
     bool Value_impl< Config >::is_uint64() const
     {
-        return v_.which() == null_type + 1;
+        return is_uint64_;
     }
 
     template< class Config >
@@ -386,7 +342,8 @@ namespace json_spirit
         {
             std::ostringstream os;
 
-            os << "get_value< " << value_type_to_string( vtype ) << " > called on " << value_type_to_string( type() ) << " Value";
+            ///// Bitcoin: Tell the types by name instead of by number
+            os << "value is type " << Value_type_name[type()] << ", expected " << Value_type_name[vtype];
 
             throw std::runtime_error( os.str() );
         }
@@ -395,7 +352,7 @@ namespace json_spirit
     template< class Config >
     const typename Config::String_type& Value_impl< Config >::get_str() const
     {
-        check_type( str_type );
+        check_type(  str_type );
 
         return *boost::get< String_type >( &v_ );
     }
@@ -411,7 +368,7 @@ namespace json_spirit
     template< class Config >
     const typename Value_impl< Config >::Array& Value_impl< Config >::get_array() const
     {
-        check_type( array_type );
+        check_type(  array_type );
 
         return *boost::get< Array >( &v_ );
     }
@@ -419,7 +376,7 @@ namespace json_spirit
     template< class Config >
     bool Value_impl< Config >::get_bool() const
     {
-        check_type( bool_type );
+        check_type(  bool_type );
 
         return boost::get< bool >( v_ );
     }
@@ -427,7 +384,7 @@ namespace json_spirit
     template< class Config >
     int Value_impl< Config >::get_int() const
     {
-        check_type( int_type );
+        check_type(  int_type );
 
         return static_cast< int >( get_int64() );
     }
@@ -435,12 +392,7 @@ namespace json_spirit
     template< class Config >
     boost::int64_t Value_impl< Config >::get_int64() const
     {
-        check_type( int_type );
-
-        if( is_uint64() )
-        {
-            return static_cast< boost::int64_t >( get_uint64() );
-        }
+        check_type(  int_type );
 
         return boost::get< boost::int64_t >( v_ );
     }
@@ -448,14 +400,9 @@ namespace json_spirit
     template< class Config >
     boost::uint64_t Value_impl< Config >::get_uint64() const
     {
-        check_type( int_type );
+        check_type(  int_type );
 
-        if( !is_uint64() )
-        {
-            return static_cast< boost::uint64_t >( get_int64() );
-        }
-
-        return boost::get< boost::uint64_t >( v_ );
+        return static_cast< boost::uint64_t >( get_int64() );
     }
 
     template< class Config >
@@ -467,7 +414,7 @@ namespace json_spirit
                                : static_cast< double >( get_int64() );
         }
 
-        check_type( real_type );
+        check_type(  real_type );
 
         return boost::get< double >( v_ );
     }
@@ -475,7 +422,7 @@ namespace json_spirit
     template< class Config >
     typename Value_impl< Config >::Object& Value_impl< Config >::get_obj()
     {
-        check_type( obj_type );
+        check_type(  obj_type );
 
         return *boost::get< Object >( &v_ );
     }
@@ -483,7 +430,7 @@ namespace json_spirit
     template< class Config >
     typename Value_impl< Config >::Array& Value_impl< Config >::get_array()
     {
-        check_type( array_type );
+        check_type(  array_type );
 
         return *boost::get< Array >( &v_ );
     }
@@ -582,24 +529,6 @@ namespace json_spirit
     {
         return internal_::get_value( *this, internal_::Type_to_type< T >() );
     }
-
-    static std::string value_type_to_string( const Value_type vtype )
-    {
-        switch( vtype )
-        {
-            case obj_type: return "Object";
-            case array_type: return "Array";
-            case str_type: return "string";
-            case bool_type: return "boolean";
-            case int_type: return "integer";
-            case real_type: return "real";
-            case null_type: return "null";
-        }
-
-        assert( false );
-
-        return "unknown type";
-    }
 }
 
 #endif
diff --git a/src/json/json_spirit_writer.cpp b/src/json/json_spirit_writer.cpp
index 06d3f21d91..d24a632cf3 100644
--- a/src/json/json_spirit_writer.cpp
+++ b/src/json/json_spirit_writer.cpp
@@ -1,96 +1,95 @@
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
+// json spirit version 4.03
 
 #include "json_spirit_writer.h"
 #include "json_spirit_writer_template.h"
 
-using namespace json_spirit;
-
-#ifdef JSON_SPIRIT_VALUE_ENABLED
-    void json_spirit::write( const Value& value, std::ostream& os, unsigned int options )
-    {
-        write_stream( value, os, options );
-    }
-    std::string json_spirit::write( const Value& value, unsigned int options )
-    {
-        return write_string( value, options );
-    }
-
-    void json_spirit::write_formatted( const Value& value, std::ostream& os )
-    {
-        write_stream( value, os, pretty_print );
-    }
-
-    std::string json_spirit::write_formatted( const Value& value )
-    {
-        return write_string( value, pretty_print );
-    }
-#endif
+void json_spirit::write( const Value& value, std::ostream& os )
+{
+    write_stream( value, os, false );
+}
 
-#ifdef JSON_SPIRIT_MVALUE_ENABLED
-    void json_spirit::write( const mValue& value, std::ostream& os, unsigned int options )
-    {
-        write_stream( value, os, options );
-    }
-
-    std::string json_spirit::write( const mValue& value, unsigned int options )
-    {
-        return write_string( value, options );
-    }
-
-    void json_spirit::write_formatted( const mValue& value, std::ostream& os )
-    {
-        write_stream( value, os, pretty_print );
-    }
-
-    std::string json_spirit::write_formatted( const mValue& value )
-    {
-        return write_string( value, pretty_print );
-    }
-#endif
+void json_spirit::write_formatted( const Value& value, std::ostream& os )
+{
+    write_stream( value, os, true );
+}
+
+std::string json_spirit::write( const Value& value )
+{
+    return write_string( value, false );
+}
+
+std::string json_spirit::write_formatted( const Value& value )
+{
+    return write_string( value, true );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+
+void json_spirit::write( const wValue& value, std::wostream& os )
+{
+    write_stream( value, os, false );
+}
+
+void json_spirit::write_formatted( const wValue& value, std::wostream& os )
+{
+    write_stream( value, os, true );
+}
+
+std::wstring json_spirit::write( const wValue&  value )
+{
+    return write_string( value, false );
+}
+
+std::wstring json_spirit::write_formatted( const wValue&  value )
+{
+    return write_string( value, true );
+}
 
-#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
-    void json_spirit::write( const wValue& value, std::wostream& os, unsigned int options )
-    {
-        write_stream( value, os, options );
-    }
-
-    std::wstring json_spirit::write( const wValue& value, unsigned int options )
-    {
-        return write_string( value, options );
-    }
-
-    void json_spirit::write_formatted( const wValue& value, std::wostream& os )
-    {
-        write_stream( value, os, pretty_print );
-    }
-
-    std::wstring json_spirit::write_formatted( const wValue& value )
-    {
-        return write_string( value, pretty_print );
-    }
 #endif
 
-#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
-    void json_spirit::write_formatted( const wmValue& value, std::wostream& os )
-    {
-        write_stream( value, os, pretty_print );
-    }
-
-    std::wstring json_spirit::write_formatted( const wmValue& value )
-    {
-        return write_string( value, pretty_print );
-    }
-
-    void json_spirit::write( const wmValue& value, std::wostream& os, unsigned int options )
-    {
-        write_stream( value, os, options );
-    }
-
-    std::wstring json_spirit::write( const wmValue& value, unsigned int options )
-    {
-        return write_string( value, options );
-    }
+void json_spirit::write( const mValue& value, std::ostream& os )
+{
+    write_stream( value, os, false );
+}
+
+void json_spirit::write_formatted( const mValue& value, std::ostream& os )
+{
+    write_stream( value, os, true );
+}
+
+std::string json_spirit::write( const mValue& value )
+{
+    return write_string( value, false );
+}
+
+std::string json_spirit::write_formatted( const mValue& value )
+{
+    return write_string( value, true );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+
+void json_spirit::write( const wmValue& value, std::wostream& os )
+{
+    write_stream( value, os, false );
+}
+
+void json_spirit::write_formatted( const wmValue& value, std::wostream& os )
+{
+    write_stream( value, os, true );
+}
+
+std::wstring json_spirit::write( const wmValue&  value )
+{
+    return write_string( value, false );
+}
+
+std::wstring json_spirit::write_formatted( const wmValue&  value )
+{
+    return write_string( value, true );
+}
+
 #endif
diff --git a/src/json/json_spirit_writer.h b/src/json/json_spirit_writer.h
index 18c2fd4264..52e14068e7 100644
--- a/src/json/json_spirit_writer.h
+++ b/src/json/json_spirit_writer.h
@@ -1,62 +1,49 @@
 #ifndef JSON_SPIRIT_WRITER
 #define JSON_SPIRIT_WRITER
 
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
+// json spirit version 4.03
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 
 #include "json_spirit_value.h"
-#include "json_spirit_writer_options.h"
 #include <iostream>
 
 namespace json_spirit
 {
-    // these functions to convert JSON Values to text
+    // functions to convert JSON Values to text, 
+    // the "formatted" versions add whitespace to format the output nicely
 
-#ifdef JSON_SPIRIT_VALUE_ENABLED
-    void         write( const Value&  value, std::ostream&  os, unsigned int options = 0 );
-    std::string  write( const Value&  value, unsigned int options = 0 );
-#endif
+    void         write          ( const Value& value, std::ostream&  os );
+    void         write_formatted( const Value& value, std::ostream&  os );
+    std::string  write          ( const Value& value );
+    std::string  write_formatted( const Value& value );
 
-#ifdef JSON_SPIRIT_MVALUE_ENABLED
-    void         write( const mValue& value, std::ostream&  os, unsigned int options = 0 );
-    std::string  write( const mValue& value, unsigned int options = 0 );
-#endif
+#ifndef BOOST_NO_STD_WSTRING
 
-#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
-    void         write( const wValue&  value, std::wostream& os, unsigned int options = 0 );
-    std::wstring write( const wValue&  value, unsigned int options = 0 );
-#endif
+    void         write          ( const wValue& value, std::wostream& os );
+    void         write_formatted( const wValue& value, std::wostream& os );
+    std::wstring write          ( const wValue& value );
+    std::wstring write_formatted( const wValue& value );
 
-#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
-    void         write( const wmValue& value, std::wostream& os, unsigned int options = 0 );
-    std::wstring write( const wmValue& value, unsigned int options = 0 );
 #endif
 
-    // these "formatted" versions of the "write" functions are the equivalent of the above functions
-    // with option "pretty_print"
-    
-#ifdef JSON_SPIRIT_VALUE_ENABLED
-    void         write_formatted( const Value& value, std::ostream&  os );
-    std::string  write_formatted( const Value& value );
-#endif
-#ifdef JSON_SPIRIT_MVALUE_ENABLED
+    void         write          ( const mValue& value, std::ostream&  os );
     void         write_formatted( const mValue& value, std::ostream&  os );
+    std::string  write          ( const mValue& value );
     std::string  write_formatted( const mValue& value );
-#endif
 
-#if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
-    void         write_formatted( const wValue& value, std::wostream& os );
-    std::wstring write_formatted( const wValue& value );
-#endif
-#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
+#ifndef BOOST_NO_STD_WSTRING
+
+    void         write          ( const wmValue& value, std::wostream& os );
     void         write_formatted( const wmValue& value, std::wostream& os );
+    std::wstring write          ( const wmValue& value );
     std::wstring write_formatted( const wmValue& value );
+
 #endif
 }
 
diff --git a/src/json/json_spirit_writer_options.h b/src/json/json_spirit_writer_options.h
deleted file mode 100644
index ac6c57f33c..0000000000
--- a/src/json/json_spirit_writer_options.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef JSON_SPIRIT_WRITER_OPTIONS
-#define JSON_SPIRIT_WRITER_OPTIONS
-
-//          Copyright John W. Wilkinson 2007 - 2013
-// Distributed under the MIT License, see accompanying file LICENSE.txt
-
-// json spirit version 4.06
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-namespace json_spirit
-{
-    enum Output_options{ pretty_print = 0x01,   // Add whitespace to format the output nicely.
-
-                         raw_utf8 = 0x02,       // This prevents non-printable characters from being escapted using "\uNNNN" notation.
-                                                // Note, this is an extension to the JSON standard. It disables the escaping of
-                                                // non-printable characters allowing UTF-8 sequences held in 8 bit char strings
-                                                // to pass through unaltered.
-
-                         remove_trailing_zeros = 0x04,
-                                                // outputs e.g. "1.200000000000000" as "1.2"
-                         single_line_arrays = 0x08,
-                                                // pretty printing except that arrays printed on single lines unless they contain
-                                                // composite elements, i.e. objects or arrays
-                         always_escape_nonascii = 0x10,
-                                                // all unicode wide characters are escaped, i.e. outputed as "\uXXXX", even if they are
-                                                // printable under the current locale, ascii printable chars are not escaped
-                       };
-}
-
-#endif
diff --git a/src/json/json_spirit_writer_template.h b/src/json/json_spirit_writer_template.h
index 014d9d4cd0..28c49ddc64 100644
--- a/src/json/json_spirit_writer_template.h
+++ b/src/json/json_spirit_writer_template.h
@@ -1,22 +1,16 @@
 #ifndef JSON_SPIRIT_WRITER_TEMPLATE
 #define JSON_SPIRIT_WRITER_TEMPLATE
 
-//          Copyright John W. Wilkinson 2007 - 2013
+//          Copyright John W. Wilkinson 2007 - 2009.
 // Distributed under the MIT License, see accompanying file LICENSE.txt
 
-// json spirit version 4.06
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
+// json spirit version 4.03
 
 #include "json_spirit_value.h"
-#include "json_spirit_writer_options.h"
 
 #include <cassert>
 #include <sstream>
 #include <iomanip>
-#include <boost/io/ios_state.hpp>
 
 namespace json_spirit
 {
@@ -66,7 +60,7 @@ namespace json_spirit
     }
 
     template< class String_type >
-    String_type add_esc_chars( const String_type& s, bool raw_utf8, bool esc_nonascii )
+    String_type add_esc_chars( const String_type& s )
     {
         typedef typename String_type::const_iterator Iter_type;
         typedef typename String_type::value_type     Char_type;
@@ -81,80 +75,21 @@ namespace json_spirit
 
             if( add_esc_char( c, result ) ) continue;
 
-            if( raw_utf8 )
+            const wint_t unsigned_c( ( c >= 0 ) ? c : 256 + c );
+
+            if( iswprint( unsigned_c ) )
             {
                 result += c;
             }
             else
             {
-                const wint_t unsigned_c( ( c >= 0 ) ? c : 256 + c );
-
-                if( !esc_nonascii && iswprint( unsigned_c ) )
-                {
-                    result += c;
-                }
-                else
-                {
-                    result += non_printable_to_string< String_type >( unsigned_c );
-                }
-            }
-        }
-
-        return result;
-    }
-
-    template< class Ostream >
-    void append_double( Ostream& os, const double d, const int precision )
-    {
-        os << std::showpoint << std::setprecision( precision ) << d;
-    }
-
-    template< class String_type >
-    void erase_and_extract_exponent( String_type& str, String_type& exp )
-    {
-        const typename String_type::size_type exp_start= str.find( 'e' );
-
-        if( exp_start != String_type::npos )
-        {
-            exp = str.substr( exp_start );
-            str.erase( exp_start );
-        }
-    }
-
-    template< class String_type >
-    typename String_type::size_type find_first_non_zero( const String_type& str )
-    {
-        typename String_type::size_type result = str.size() - 1;
-
-        for( ; result != 0; --result )
-        {
-            if( str[ result ] != '0' )
-            {
-                break;
+                result += non_printable_to_string< String_type >( unsigned_c );
             }
         }
 
         return result;
     }
 
-    template< class String_type >
-    void remove_trailing( String_type& str )
-    {
-        String_type exp;
-
-        erase_and_extract_exponent( str, exp );
-
-        const typename String_type::size_type first_non_zero = find_first_non_zero( str );
-
-        if( first_non_zero != 0 )
-        {
-            const int offset = str[first_non_zero] == '.' ? 2 : 1;  // note zero digits following a decimal point is non standard
-            str.erase( first_non_zero + offset );
-        }
-
-        str += exp;
-    }
-
     // this class generates the JSON text,
     // it keeps track of the indentation level etc.
     //
@@ -170,15 +105,10 @@ namespace json_spirit
 
     public:
 
-        Generator( const Value_type& value, Ostream_type& os, unsigned int options )
+        Generator( const Value_type& value, Ostream_type& os, bool pretty )
         :   os_( os )
         ,   indentation_level_( 0 )
-        ,   pretty_( ( options & pretty_print ) != 0 || ( options & single_line_arrays ) != 0 )
-        ,   raw_utf8_( ( options & raw_utf8 ) != 0 )
-        ,   esc_nonascii_( ( options & always_escape_nonascii ) != 0 )
-        ,   remove_trailing_zeros_( ( options & remove_trailing_zeros ) != 0 )
-        ,   single_line_arrays_( ( options & single_line_arrays ) != 0 )
-        ,   ios_saver_( os )
+        ,   pretty_( pretty )
         {
             output( value );
         }
@@ -193,8 +123,12 @@ namespace json_spirit
                 case array_type: output( value.get_array() ); break;
                 case str_type:   output( value.get_str() );   break;
                 case bool_type:  output( value.get_bool() );  break;
-                case real_type:  output( value.get_real() );  break;
                 case int_type:   output_int( value );         break;
+
+                /// Bitcoin: Added std::fixed and changed precision from 16 to 8
+                case real_type:  os_ << std::showpoint << std::fixed << std::setprecision(8)
+                                     << value.get_real();     break;
+
                 case null_type:  os_ << "null";               break;
                 default: assert( false );
             }
@@ -205,6 +139,11 @@ namespace json_spirit
             output_array_or_obj( obj, '{', '}' );
         }
 
+        void output( const Array_type& arr )
+        {
+            output_array_or_obj( arr, '[', ']' );
+        }
+
         void output( const Obj_member_type& member )
         {
             output( Config_type::get_name( member ) ); space(); 
@@ -226,7 +165,7 @@ namespace json_spirit
 
         void output( const String_type& s )
         {
-            os_ << '"' << add_esc_chars( s, raw_utf8_, esc_nonascii_ ) << '"';
+            os_ << '"' << add_esc_chars( s ) << '"';
         }
 
         void output( bool b )
@@ -234,75 +173,6 @@ namespace json_spirit
             os_ << to_str< String_type >( b ? "true" : "false" );
         }
 
-        void output( double d )
-        {
-            if( remove_trailing_zeros_ )
-            {
-                std::basic_ostringstream< Char_type > os;
-
-                append_double( os, d, 16 );  // note precision is 16 so that we get some trailing space that we can remove,
-                                             // otherwise, 0.1234 gets converted to "0.12399999..."
-
-                String_type str = os.str();
-
-                remove_trailing( str );
-
-                os_ << str;
-            }
-            else
-            {
-                append_double( os_, d, 17 );
-            }
-        }
-
-        static bool contains_composite_elements( const Array_type& arr )
-        {
-            for( typename Array_type::const_iterator i = arr.begin(); i != arr.end(); ++i )
-            {
-                const Value_type& val = *i;
-
-                if( val.type() == obj_type ||
-                    val.type() == array_type )
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        template< class Iter >
-        void output_composite_item( Iter i, Iter last )
-        {
-            output( *i );
-
-            if( ++i != last )
-            {
-                os_ << ',';
-            }
-        }
-
-        void output( const Array_type& arr )
-        {
-            if( single_line_arrays_ && !contains_composite_elements( arr )  )
-            {
-                os_ << '['; space();
-               
-                for( typename Array_type::const_iterator i = arr.begin(); i != arr.end(); ++i )
-                {
-                    output_composite_item( i, arr.end() );
-
-                    space();
-                }
-
-                os_ << ']';
-            }
-            else
-            {
-                output_array_or_obj( arr, '[', ']' );
-            }
-        }
-
         template< class T >
         void output_array_or_obj( const T& t, Char_type start_char, Char_type end_char )
         {
@@ -312,9 +182,14 @@ namespace json_spirit
             
             for( typename T::const_iterator i = t.begin(); i != t.end(); ++i )
             {
-                indent();
+                indent(); output( *i );
 
-                output_composite_item( i, t.end() );
+                typename T::const_iterator next = i;
+
+                if( ++next != t.end())
+                {
+                    os_ << ',';
+                }
 
                 new_line();
             }
@@ -349,36 +224,22 @@ namespace json_spirit
         Ostream_type& os_;
         int indentation_level_;
         bool pretty_;
-        bool raw_utf8_;
-        bool esc_nonascii_;
-        bool remove_trailing_zeros_;
-        bool single_line_arrays_;
-        boost::io::basic_ios_all_saver< Char_type > ios_saver_;  // so that ostream state is reset after control is returned to the caller
     };
 
-    // writes JSON Value to a stream, e.g.
-    //
-    // write_stream( value, os, pretty_print );
-    //
     template< class Value_type, class Ostream_type >
-    void write_stream( const Value_type& value, Ostream_type& os, unsigned int options = 0 )
+    void write_stream( const Value_type& value, Ostream_type& os, bool pretty )
     {
-        os << std::dec;
-        Generator< Value_type, Ostream_type >( value, os, options );
+        Generator< Value_type, Ostream_type >( value, os, pretty );
     }
 
-    // writes JSON Value to a stream, e.g.
-    //
-    // const string json_str = write( value, pretty_print );
-    //
     template< class Value_type >
-    typename Value_type::String_type write_string( const Value_type& value, unsigned int options = 0 )
+    typename Value_type::String_type write_string( const Value_type& value, bool pretty )
     {
         typedef typename Value_type::String_type::value_type Char_type;
 
         std::basic_ostringstream< Char_type > os;
 
-        write_stream( value, os, options );
+        write_stream( value, os, pretty );
 
         return os.str();
     }