kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #2740 from constantined/constantined 

UTF-8 support for JSON-RPC
0.10
Gavin Andresen 11 years ago
parent
8435f7b8ee 2ecb7555a9
commit
125bdead3e
18 changed files with 697 additions and 398 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      src/bitcoinrpc.cpp
  2. 2
      src/json/LICENSE.txt
  3. 4
      src/json/json_spirit.h
  4. 6
      src/json/json_spirit_error_position.h
  5. 248
      src/json/json_spirit_reader.cpp
  6. 16
      src/json/json_spirit_reader.h
  7. 114
      src/json/json_spirit_reader_template.h
  8. 4
      src/json/json_spirit_stream_reader.h
  9. 8
      src/json/json_spirit_utils.h
  10. 203
      src/json/json_spirit_value.h
  11. 169
      src/json/json_spirit_writer.cpp
  12. 53
      src/json/json_spirit_writer.h
  13. 33
      src/json/json_spirit_writer_options.h
  14. 201
      src/json/json_spirit_writer_template.h
  15. 4
      src/qt/rpcconsole.cpp
  16. 10
      src/test/base58_tests.cpp
  17. 4
      src/test/script_tests.cpp
  18. 4
      src/test/transaction_tests.cpp

12
src/bitcoinrpc.cpp
Unescape View File

@ -31,6 +31,8 @@ using namespace boost;
using namespace boost::asio; using namespace boost::asio;
using namespace json_spirit; using namespace json_spirit;
static const char* Value_type_name[]={"obj", "array", "str", "bool", "int", "real", "null"};
static std::string strRPCUserColonPass; static std::string strRPCUserColonPass;
// These are created by StartRPCThreads, destroyed in StopRPCThreads // These are created by StartRPCThreads, destroyed in StopRPCThreads
@ -531,7 +533,7 @@ string JSONRPCRequest(const string& strMethod, const Array& params, const Value&
request.push_back(Pair("method", strMethod)); request.push_back(Pair("method", strMethod));
request.push_back(Pair("params", params)); request.push_back(Pair("params", params));
request.push_back(Pair("id", id)); request.push_back(Pair("id", id));
return write_string(Value(request), false) + "\n"; return write_string(Value(request), raw_utf8) + "\n";
} }
Object JSONRPCReplyObj(const Value& result, const Value& error, const Value& id) Object JSONRPCReplyObj(const Value& result, const Value& error, const Value& id)
@ -549,7 +551,7 @@ Object JSONRPCReplyObj(const Value& result, const Value& error, const Value& id)
string JSONRPCReply(const Value& result, const Value& error, const Value& id) string JSONRPCReply(const Value& result, const Value& error, const Value& id)
{ {
Object reply = JSONRPCReplyObj(result, error, id); Object reply = JSONRPCReplyObj(result, error, id);
return write_string(Value(reply), false) + "\n"; return write_string(Value(reply), raw_utf8) + "\n";
} }
void ErrorReply(std::ostream& stream, const Object& objError, const Value& id) void ErrorReply(std::ostream& stream, const Object& objError, const Value& id)
@ -980,7 +982,7 @@ static string JSONRPCExecBatch(const Array& vReq)
for (unsigned int reqIdx = 0; reqIdx < vReq.size(); reqIdx++) for (unsigned int reqIdx = 0; reqIdx < vReq.size(); reqIdx++)
ret.push_back(JSONRPCExecOne(vReq[reqIdx])); ret.push_back(JSONRPCExecOne(vReq[reqIdx]));
return write_string(Value(ret), false) + "\n"; return write_string(Value(ret), raw_utf8) + "\n";
} }
void ServiceConnection(AcceptedConnection *conn) void ServiceConnection(AcceptedConnection *conn)
@ -1282,7 +1284,7 @@ int CommandLineRPC(int argc, char *argv[])
if (error.type() != null_type) if (error.type() != null_type)
{ {
// Error // Error
strPrint = "error: " + write_string(error, false); strPrint = "error: " + write_string(error, raw_utf8);
int code = find_value(error.get_obj(), "code").get_int(); int code = find_value(error.get_obj(), "code").get_int();
nRet = abs(code); nRet = abs(code);
} }
@ -1294,7 +1296,7 @@ int CommandLineRPC(int argc, char *argv[])
else if (result.type() == str_type) else if (result.type() == str_type)
strPrint = result.get_str(); strPrint = result.get_str();
else else
strPrint = write_string(result, true); strPrint = write_string(result, pretty_print | raw_utf8);
} }
} }
catch (boost::thread_interrupted) { catch (boost::thread_interrupted) {

2
src/json/LICENSE.txt
Unescape View File

@ -1,6 +1,6 @@
The MIT License The MIT License
Copyright (c) 2007 - 2009 John W. Wilkinson Copyright (c) 2007 - 2010 John W. Wilkinson
Permission is hereby granted, free of charge, to any person Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation obtaining a copy of this software and associated documentation

4
src/json/json_spirit.h
Unescape View File

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT #ifndef JSON_SPIRIT
#define JSON_SPIRIT #define JSON_SPIRIT
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once

6
src/json/json_spirit_error_position.h
Unescape View File

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_ERROR_POSITION #ifndef JSON_SPIRIT_ERROR_POSITION
#define JSON_SPIRIT_ERROR_POSITION #define JSON_SPIRIT_ERROR_POSITION
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once
@ -48,7 +48,7 @@ namespace json_spirit
return ( reason_ == lhs.reason_ ) && return ( reason_ == lhs.reason_ ) &&
( line_ == lhs.line_ ) && ( line_ == lhs.line_ ) &&
( column_ == lhs.column_ ); ( column_ == lhs.column_ );
} }
} }
#endif #endif

248
src/json/json_spirit_reader.cpp
Unescape View File

@ -1,137 +1,137 @@
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#include "json_spirit_reader.h" #include "json_spirit_reader.h"
#include "json_spirit_reader_template.h" #include "json_spirit_reader_template.h"
using namespace json_spirit; using namespace json_spirit;
bool json_spirit::read( const std::string& s, Value& value ) #ifdef JSON_SPIRIT_VALUE_ENABLED
{ bool json_spirit::read( const std::string& s, Value& value )
return read_string( s, value ); {
} return read_string( s, value );
}
void json_spirit::read_or_throw( const std::string& s, Value& value )
{ void json_spirit::read_or_throw( const std::string& s, Value& value )
read_string_or_throw( s, value ); {
} read_string_or_throw( s, value );
}
bool json_spirit::read( std::istream& is, Value& value )
{ bool json_spirit::read( std::istream& is, Value& value )
return read_stream( is, value ); {
} return read_stream( is, value );
}
void json_spirit::read_or_throw( std::istream& is, Value& value )
{ void json_spirit::read_or_throw( std::istream& is, Value& value )
read_stream_or_throw( is, value ); {
} read_stream_or_throw( is, value );
}
bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
{ bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
return read_range( begin, end, 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 )
{ 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 ); {
} begin = read_range_or_throw( begin, end, value );
}
#ifndef BOOST_NO_STD_WSTRING #endif
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 #endif
bool json_spirit::read( const std::string& s, mValue& value ) #ifdef JSON_SPIRIT_MVALUE_ENABLED
{ bool json_spirit::read( const std::string& s, mValue& value )
return read_string( s, value ); {
} return read_string( s, value );
}
void json_spirit::read_or_throw( const std::string& s, mValue& value )
{ void json_spirit::read_or_throw( const std::string& s, mValue& value )
read_string_or_throw( s, value ); {
} read_string_or_throw( s, value );
}
bool json_spirit::read( std::istream& is, mValue& value )
{ bool json_spirit::read( std::istream& is, mValue& value )
return read_stream( is, value ); {
} return read_stream( is, value );
}
void json_spirit::read_or_throw( std::istream& is, mValue& value )
{ void json_spirit::read_or_throw( std::istream& is, mValue& value )
read_stream_or_throw( is, value ); {
} read_stream_or_throw( is, value );
}
bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
{ bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
return read_range( begin, end, 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 )
{ 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 ); {
} begin = read_range_or_throw( begin, end, value );
}
#ifndef BOOST_NO_STD_WSTRING #endif
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 #endif

16
src/json/json_spirit_reader.h
Unescape View File

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_READER #ifndef JSON_SPIRIT_READER
#define JSON_SPIRIT_READER #define JSON_SPIRIT_READER
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once
@ -18,6 +18,7 @@ namespace json_spirit
{ {
// functions to reads a JSON values // functions to reads a JSON values
#ifdef JSON_SPIRIT_VALUE_ENABLED
bool read( const std::string& s, Value& value ); bool read( const std::string& s, Value& value );
bool read( std::istream& is, Value& value ); bool read( std::istream& is, Value& value );
bool read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value ); bool read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
@ -25,9 +26,9 @@ namespace json_spirit
void read_or_throw( const std::string& s, Value& value ); void read_or_throw( const std::string& s, Value& value );
void read_or_throw( std::istream& is, 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 ); void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
#endif
#ifndef BOOST_NO_STD_WSTRING #if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
bool read( const std::wstring& s, wValue& value ); bool read( const std::wstring& s, wValue& value );
bool read( std::wistream& is, wValue& value ); bool read( std::wistream& is, wValue& value );
bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value ); bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );
@ -35,9 +36,9 @@ namespace json_spirit
void read_or_throw( const std::wstring& s, wValue& value ); void read_or_throw( const std::wstring& s, wValue& value );
void read_or_throw( std::wistream& is, 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 ); void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );
#endif #endif
#ifdef JSON_SPIRIT_MVALUE_ENABLED
bool read( const std::string& s, mValue& value ); bool read( const std::string& s, mValue& value );
bool read( std::istream& is, mValue& value ); bool read( std::istream& is, mValue& value );
bool read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value ); bool read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
@ -45,9 +46,9 @@ namespace json_spirit
void read_or_throw( const std::string& s, mValue& value ); void read_or_throw( const std::string& s, mValue& value );
void read_or_throw( std::istream& is, 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 ); void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
#endif
#ifndef BOOST_NO_STD_WSTRING #if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
bool read( const std::wstring& s, wmValue& value ); bool read( const std::wstring& s, wmValue& value );
bool read( std::wistream& is, wmValue& value ); bool read( std::wistream& is, wmValue& value );
bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value ); bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );
@ -55,7 +56,6 @@ namespace json_spirit
void read_or_throw( const std::wstring& s, wmValue& value ); void read_or_throw( const std::wstring& s, wmValue& value );
void read_or_throw( std::wistream& is, 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 ); void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );
#endif #endif
} }

114
src/json/json_spirit_reader_template.h
Unescape View File

@ -1,10 +1,14 @@
#ifndef JSON_SPIRIT_READER_TEMPLATE #ifndef JSON_SPIRIT_READER_TEMPLATE
#define JSON_SPIRIT_READER_TEMPLATE #define JSON_SPIRIT_READER_TEMPLATE
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include "json_spirit_value.h" #include "json_spirit_value.h"
#include "json_spirit_error_position.h" #include "json_spirit_error_position.h"
@ -484,7 +488,7 @@ namespace json_spirit
; ;
string_ string_
= lexeme_d // this causes white space inside a string to be retained = lexeme_d // this causes white space and what would appear to be comments inside a string to be retained
[ [
confix_p confix_p
( (
@ -514,6 +518,44 @@ namespace json_spirit
Semantic_actions_t& actions_; Semantic_actions_t& actions_;
}; };
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 > template< class Iter_type, class Value_type >
Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value ) Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
{ {
@ -522,7 +564,9 @@ namespace json_spirit
const spirit_namespace::parse_info< Iter_type > info = const spirit_namespace::parse_info< Iter_type > info =
spirit_namespace::parse( begin, end, spirit_namespace::parse( begin, end,
Json_grammer< Value_type, Iter_type >( semantic_actions ), Json_grammer< Value_type, Iter_type >( semantic_actions ),
spirit_namespace::space_p ); spirit_namespace::space_p |
spirit_namespace::comment_p("//") |
spirit_namespace::comment_p("/*", "*/") );
if( !info.hit ) if( !info.hit )
{ {
@ -533,17 +577,14 @@ namespace json_spirit
return info.stop; return info.stop;
} }
template< class Iter_type, class Value_type > // reads a JSON Value from a pair of input iterators, e.g.
void add_posn_iter_and_read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value ) //
{ // string::const_iterator start = str.begin();
typedef spirit_namespace::position_iterator< Iter_type > Posn_iter_t; // const bool success = read_string( start, str.end(), value );
//
const Posn_iter_t posn_begin( begin, end ); // The iterator 'start' will point to the character past the
const Posn_iter_t posn_end( end, end ); // last one read.
//
read_range_or_throw( posn_begin, posn_end, value );
}
template< class Iter_type, class Value_type > template< class Iter_type, class Value_type >
bool read_range( Iter_type& begin, Iter_type end, Value_type& value ) bool read_range( Iter_type& begin, Iter_type end, Value_type& value )
{ {
@ -559,12 +600,10 @@ namespace json_spirit
} }
} }
template< class String_type, class Value_type > // reads a JSON Value from a string, e.g.
void read_string_or_throw( const String_type& s, Value_type& value ) //
{ // const bool success = read_string( str, value );
add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value ); //
}
template< class String_type, class Value_type > template< class String_type, class Value_type >
bool read_string( const String_type& s, Value_type& value ) bool read_string( const String_type& s, Value_type& value )
{ {
@ -573,25 +612,20 @@ namespace json_spirit
return read_range( begin, s.end(), value ); return read_range( begin, s.end(), value );
} }
template< class Istream_type > // reads a JSON Value from a string throwing an exception on invalid input, e.g.
struct Multi_pass_iters //
// 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 )
{ {
typedef typename Istream_type::char_type Char_type; add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value );
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 > template< class Istream_type, class Value_type >
bool read_stream( Istream_type& is, Value_type& value ) bool read_stream( Istream_type& is, Value_type& value )
{ {
@ -600,6 +634,10 @@ namespace json_spirit
return read_range( mp_iters.begin_, mp_iters.end_, value ); 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 > template< class Istream_type, class Value_type >
void read_stream_or_throw( Istream_type& is, Value_type& value ) void read_stream_or_throw( Istream_type& is, Value_type& value )
{ {

4
src/json/json_spirit_stream_reader.h
Unescape View File

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_READ_STREAM #ifndef JSON_SPIRIT_READ_STREAM
#define JSON_SPIRIT_READ_STREAM #define JSON_SPIRIT_READ_STREAM
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once

8
src/json/json_spirit_utils.h
Unescape View File

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_UTILS #ifndef JSON_SPIRIT_UTILS
#define JSON_SPIRIT_UTILS #define JSON_SPIRIT_UTILS
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once
@ -37,9 +37,11 @@ namespace json_spirit
} }
} }
#ifdef JSON_SPIRIT_VALUE_ENABLED
typedef std::map< std::string, Value > Mapped_obj; typedef std::map< std::string, Value > Mapped_obj;
#endif
#ifndef BOOST_NO_STD_WSTRING #if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
typedef std::map< std::wstring, wValue > wMapped_obj; typedef std::map< std::wstring, wValue > wMapped_obj;
#endif #endif

203
src/json/json_spirit_value.h
Unescape View File

@ -1,10 +1,10 @@
#ifndef JSON_SPIRIT_VALUE #ifndef JSON_SPIRIT_VALUE
#define JSON_SPIRIT_VALUE #define JSON_SPIRIT_VALUE
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once
@ -21,10 +21,19 @@
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <boost/variant.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 namespace json_spirit
{ {
enum Value_type{ obj_type, array_type, str_type, bool_type, int_type, real_type, null_type }; 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 template< class Config > // Config determines whether the value uses std::string or std::wstring and
// whether JSON Objects are represented as vectors or maps // whether JSON Objects are represented as vectors or maps
@ -49,6 +58,12 @@ namespace json_spirit
Value_impl( boost::uint64_t value ); Value_impl( boost::uint64_t value );
Value_impl( double 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 ); Value_impl( const Value_impl& other );
bool operator==( const Value_impl& lhs ) const; bool operator==( const Value_impl& lhs ) const;
@ -81,13 +96,32 @@ namespace json_spirit
void check_type( const Value_type vtype ) const; void check_type( const Value_type vtype ) const;
typedef boost::variant< String_type, typedef boost::variant< boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >,
boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >, String_type, bool, boost::int64_t, double, Null, boost::uint64_t > Variant;
bool, boost::int64_t, double > Variant;
Value_type type_;
Variant v_; Variant v_;
bool is_uint64_;
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;
}
};
}; };
// vector objects // vector objects
@ -98,6 +132,10 @@ namespace json_spirit
typedef typename Config::String_type String_type; typedef typename Config::String_type String_type;
typedef typename Config::Value_type Value_type; typedef typename Config::Value_type Value_type;
Pair_impl()
{
}
Pair_impl( const String_type& name, const Value_type& value ); Pair_impl( const String_type& name, const Value_type& value );
bool operator==( const Pair_impl& lhs ) const; bool operator==( const Pair_impl& lhs ) const;
@ -106,6 +144,7 @@ namespace json_spirit
Value_type value_; Value_type value_;
}; };
#if defined( JSON_SPIRIT_VALUE_ENABLED ) || defined( JSON_SPIRIT_WVALUE_ENABLED )
template< class String > template< class String >
struct Config_vector struct Config_vector
{ {
@ -122,30 +161,32 @@ namespace json_spirit
return obj.back().value_; return obj.back().value_;
} }
static String_type get_name( const Pair_type& pair ) static const String_type& get_name( const Pair_type& pair )
{ {
return pair.name_; return pair.name_;
} }
static Value_type get_value( const Pair_type& pair ) static const Value_type& get_value( const Pair_type& pair )
{ {
return pair.value_; return pair.value_;
} }
}; };
#endif
// typedefs for ASCII // typedefs for ASCII
#ifdef JSON_SPIRIT_VALUE_ENABLED
typedef Config_vector< std::string > Config; typedef Config_vector< std::string > Config;
typedef Config::Value_type Value; typedef Config::Value_type Value;
typedef Config::Pair_type Pair; typedef Config::Pair_type Pair;
typedef Config::Object_type Object; typedef Config::Object_type Object;
typedef Config::Array_type Array; typedef Config::Array_type Array;
#endif
// typedefs for Unicode // typedefs for Unicode
#ifndef BOOST_NO_STD_WSTRING #if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
typedef Config_vector< std::wstring > wConfig; typedef Config_vector< std::wstring > wConfig;
typedef wConfig::Value_type wValue; typedef wConfig::Value_type wValue;
@ -156,6 +197,7 @@ namespace json_spirit
// map objects // map objects
#if defined( JSON_SPIRIT_MVALUE_ENABLED ) || defined( JSON_SPIRIT_WMVALUE_ENABLED )
template< class String > template< class String >
struct Config_map struct Config_map
{ {
@ -163,135 +205,134 @@ namespace json_spirit
typedef Value_impl< Config_map > Value_type; typedef Value_impl< Config_map > Value_type;
typedef std::vector< Value_type > Array_type; typedef std::vector< Value_type > Array_type;
typedef std::map< String_type, Value_type > Object_type; typedef std::map< String_type, Value_type > Object_type;
typedef typename Object_type::value_type Pair_type; typedef std::pair< const String_type, Value_type > Pair_type;
static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value ) static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
{ {
return obj[ name ] = value; return obj[ name ] = value;
} }
static String_type get_name( const Pair_type& pair ) static const String_type& get_name( const Pair_type& pair )
{ {
return pair.first; return pair.first;
} }
static Value_type get_value( const Pair_type& pair ) static const Value_type& get_value( const Pair_type& pair )
{ {
return pair.second; return pair.second;
} }
}; };
#endif
// typedefs for ASCII // typedefs for ASCII
#ifdef JSON_SPIRIT_MVALUE_ENABLED
typedef Config_map< std::string > mConfig; typedef Config_map< std::string > mConfig;
typedef mConfig::Value_type mValue; typedef mConfig::Value_type mValue;
typedef mConfig::Object_type mObject; typedef mConfig::Object_type mObject;
typedef mConfig::Array_type mArray; typedef mConfig::Array_type mArray;
#endif
// typedefs for Unicode // typedefs for Unicode
#ifndef BOOST_NO_STD_WSTRING #if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
typedef Config_map< std::wstring > wmConfig; typedef Config_map< std::wstring > wmConfig;
typedef wmConfig::Value_type wmValue; typedef wmConfig::Value_type wmValue;
typedef wmConfig::Object_type wmObject; typedef wmConfig::Object_type wmObject;
typedef wmConfig::Array_type wmArray; typedef wmConfig::Array_type wmArray;
#endif #endif
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
// //
// implementation // implementation
inline bool operator==( const Null&, const Null& )
{
return true;
}
template< class Config > template< class Config >
const Value_impl< Config > Value_impl< Config >::null; const Value_impl< Config > Value_impl< Config >::null;
template< class Config > template< class Config >
Value_impl< Config >::Value_impl() Value_impl< Config >::Value_impl()
: type_( null_type ) : v_( Null() )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( const Const_str_ptr value ) Value_impl< Config >::Value_impl( const Const_str_ptr value )
: type_( str_type ) : v_( String_type( value ) )
, v_( String_type( value ) )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( const String_type& value ) Value_impl< Config >::Value_impl( const String_type& value )
: type_( str_type ) : v_( value )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( const Object& value ) Value_impl< Config >::Value_impl( const Object& value )
: type_( obj_type ) : v_( value )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( const Array& value ) Value_impl< Config >::Value_impl( const Array& value )
: type_( array_type ) : v_( value )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( bool value ) Value_impl< Config >::Value_impl( bool value )
: type_( bool_type ) : v_( value )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( int value ) Value_impl< Config >::Value_impl( int value )
: type_( int_type ) : v_( static_cast< boost::int64_t >( value ) )
, v_( static_cast< boost::int64_t >( value ) )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( boost::int64_t value ) Value_impl< Config >::Value_impl( boost::int64_t value )
: type_( int_type ) : v_( value )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( boost::uint64_t value ) Value_impl< Config >::Value_impl( boost::uint64_t value )
: type_( int_type ) : v_( value )
, v_( static_cast< boost::int64_t >( value ) )
, is_uint64_( true )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( double value ) Value_impl< Config >::Value_impl( double value )
: type_( real_type ) : v_( value )
, v_( value )
, is_uint64_( false )
{ {
} }
template< class Config > template< class Config >
Value_impl< Config >::Value_impl( const Value_impl< Config >& other ) Value_impl< Config >::Value_impl( const Value_impl< Config >& other )
: type_( other.type() ) : v_( other.v_ )
, v_( other.v_ ) {
, is_uint64_( other.is_uint64_ ) }
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) )
{ {
} }
@ -300,9 +341,7 @@ namespace json_spirit
{ {
Value_impl tmp( lhs ); Value_impl tmp( lhs );
std::swap( type_, tmp.type_ );
std::swap( v_, tmp.v_ ); std::swap( v_, tmp.v_ );
std::swap( is_uint64_, tmp.is_uint64_ );
return *this; return *this;
} }
@ -320,13 +359,18 @@ namespace json_spirit
template< class Config > template< class Config >
Value_type Value_impl< Config >::type() const Value_type Value_impl< Config >::type() const
{ {
return type_; if( is_uint64() )
{
return int_type;
}
return static_cast< Value_type >( v_.which() );
} }
template< class Config > template< class Config >
bool Value_impl< Config >::is_uint64() const bool Value_impl< Config >::is_uint64() const
{ {
return is_uint64_; return v_.which() == null_type + 1;
} }
template< class Config > template< class Config >
@ -342,8 +386,7 @@ namespace json_spirit
{ {
std::ostringstream os; std::ostringstream os;
///// Bitcoin: Tell the types by name instead of by number os << "get_value< " << value_type_to_string( vtype ) << " > called on " << value_type_to_string( type() ) << " Value";
os << "value is type " << Value_type_name[type()] << ", expected " << Value_type_name[vtype];
throw std::runtime_error( os.str() ); throw std::runtime_error( os.str() );
} }
@ -352,7 +395,7 @@ namespace json_spirit
template< class Config > template< class Config >
const typename Config::String_type& Value_impl< Config >::get_str() const 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_ ); return *boost::get< String_type >( &v_ );
} }
@ -368,7 +411,7 @@ namespace json_spirit
template< class Config > template< class Config >
const typename Value_impl< Config >::Array& Value_impl< Config >::get_array() const 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_ ); return *boost::get< Array >( &v_ );
} }
@ -376,7 +419,7 @@ namespace json_spirit
template< class Config > template< class Config >
bool Value_impl< Config >::get_bool() const bool Value_impl< Config >::get_bool() const
{ {
check_type( bool_type ); check_type( bool_type );
return boost::get< bool >( v_ ); return boost::get< bool >( v_ );
} }
@ -384,7 +427,7 @@ namespace json_spirit
template< class Config > template< class Config >
int Value_impl< Config >::get_int() const int Value_impl< Config >::get_int() const
{ {
check_type( int_type ); check_type( int_type );
return static_cast< int >( get_int64() ); return static_cast< int >( get_int64() );
} }
@ -392,7 +435,12 @@ namespace json_spirit
template< class Config > template< class Config >
boost::int64_t Value_impl< Config >::get_int64() const boost::int64_t Value_impl< Config >::get_int64() const
{ {
check_type( int_type ); check_type( int_type );
if( is_uint64() )
{
return static_cast< boost::int64_t >( get_uint64() );
}
return boost::get< boost::int64_t >( v_ ); return boost::get< boost::int64_t >( v_ );
} }
@ -400,9 +448,14 @@ namespace json_spirit
template< class Config > template< class Config >
boost::uint64_t Value_impl< Config >::get_uint64() const boost::uint64_t Value_impl< Config >::get_uint64() const
{ {
check_type( int_type ); check_type( int_type );
return static_cast< boost::uint64_t >( get_int64() ); if( !is_uint64() )
{
return static_cast< boost::uint64_t >( get_int64() );
}
return boost::get< boost::uint64_t >( v_ );
} }
template< class Config > template< class Config >
@ -414,7 +467,7 @@ namespace json_spirit
: static_cast< double >( get_int64() ); : static_cast< double >( get_int64() );
} }
check_type( real_type ); check_type( real_type );
return boost::get< double >( v_ ); return boost::get< double >( v_ );
} }
@ -422,7 +475,7 @@ namespace json_spirit
template< class Config > template< class Config >
typename Value_impl< Config >::Object& Value_impl< Config >::get_obj() typename Value_impl< Config >::Object& Value_impl< Config >::get_obj()
{ {
check_type( obj_type ); check_type( obj_type );
return *boost::get< Object >( &v_ ); return *boost::get< Object >( &v_ );
} }
@ -430,7 +483,7 @@ namespace json_spirit
template< class Config > template< class Config >
typename Value_impl< Config >::Array& Value_impl< Config >::get_array() typename Value_impl< Config >::Array& Value_impl< Config >::get_array()
{ {
check_type( array_type ); check_type( array_type );
return *boost::get< Array >( &v_ ); return *boost::get< Array >( &v_ );
} }
@ -529,6 +582,24 @@ namespace json_spirit
{ {
return internal_::get_value( *this, internal_::Type_to_type< T >() ); 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 #endif

169
src/json/json_spirit_writer.cpp
Unescape View File

@ -1,95 +1,96 @@
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#include "json_spirit_writer.h" #include "json_spirit_writer.h"
#include "json_spirit_writer_template.h" #include "json_spirit_writer_template.h"
void json_spirit::write( const Value& value, std::ostream& os ) using namespace json_spirit;
{
write_stream( value, os, false ); #ifdef JSON_SPIRIT_VALUE_ENABLED
} void json_spirit::write( const Value& value, std::ostream& os, unsigned int options )
{
void json_spirit::write_formatted( const Value& value, std::ostream& os ) write_stream( value, os, options );
{ }
write_stream( value, os, true ); std::string json_spirit::write( const Value& value, unsigned int options )
} {
return write_string( value, options );
std::string json_spirit::write( const Value& value ) }
{
return write_string( value, false ); 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, true ); std::string json_spirit::write_formatted( const Value& value )
} {
return write_string( value, pretty_print );
#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 );
}
#endif #endif
void json_spirit::write( const mValue& value, std::ostream& os ) #ifdef JSON_SPIRIT_MVALUE_ENABLED
{ void json_spirit::write( const mValue& value, std::ostream& os, unsigned int options )
write_stream( value, os, false ); {
} write_stream( value, os, options );
}
void json_spirit::write_formatted( const mValue& value, std::ostream& os )
{ std::string json_spirit::write( const mValue& value, unsigned int options )
write_stream( value, os, true ); {
} return write_string( value, options );
}
std::string json_spirit::write( const mValue& value )
{ void json_spirit::write_formatted( const mValue& value, std::ostream& os )
return write_string( value, false ); {
} write_stream( value, os, pretty_print );
}
std::string json_spirit::write_formatted( const mValue& value )
{ std::string json_spirit::write_formatted( const mValue& value )
return write_string( value, true ); {
} return write_string( value, pretty_print );
}
#ifndef BOOST_NO_STD_WSTRING #endif
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 ) #if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
{ void json_spirit::write( const wValue& value, std::wostream& os, unsigned int options )
return write_string( value, true ); {
} 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 );
}
#endif #endif

53
src/json/json_spirit_writer.h
Unescape View File

@ -1,49 +1,62 @@
#ifndef JSON_SPIRIT_WRITER #ifndef JSON_SPIRIT_WRITER
#define JSON_SPIRIT_WRITER #define JSON_SPIRIT_WRITER
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020) #if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once # pragma once
#endif #endif
#include "json_spirit_value.h" #include "json_spirit_value.h"
#include "json_spirit_writer_options.h"
#include <iostream> #include <iostream>
namespace json_spirit namespace json_spirit
{ {
// functions to convert JSON Values to text, // these functions to convert JSON Values to text
// the "formatted" versions add whitespace to format the output nicely
void write ( const Value& value, std::ostream& os ); #ifdef JSON_SPIRIT_VALUE_ENABLED
void write_formatted( const Value& value, std::ostream& os ); void write( const Value& value, std::ostream& os, unsigned int options = 0 );
std::string write ( const Value& value ); std::string write( const Value& value, unsigned int options = 0 );
std::string write_formatted( const Value& value ); #endif
#ifndef BOOST_NO_STD_WSTRING #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
void write ( const wValue& value, std::wostream& os ); #if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
void write_formatted( const wValue& value, std::wostream& os ); void write( const wValue& value, std::wostream& os, unsigned int options = 0 );
std::wstring write ( const wValue& value ); std::wstring write( const wValue& value, unsigned int options = 0 );
std::wstring write_formatted( const wValue& value ); #endif
#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 #endif
void write ( const mValue& value, std::ostream& os ); // 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_formatted( 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 ); std::string write_formatted( const mValue& value );
#endif
#ifndef BOOST_NO_STD_WSTRING #if defined( JSON_SPIRIT_WVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
void write_formatted( const wValue& value, std::wostream& os );
void write ( const wmValue& value, std::wostream& os ); std::wstring write_formatted( const wValue& value );
#endif
#if defined( JSON_SPIRIT_WMVALUE_ENABLED ) && !defined( BOOST_NO_STD_WSTRING )
void write_formatted( 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 ); std::wstring write_formatted( const wmValue& value );
#endif #endif
} }

33
src/json/json_spirit_writer_options.h
Unescape View File

@ -0,0 +1,33 @@
#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

201
src/json/json_spirit_writer_template.h
Unescape View File

@ -1,16 +1,22 @@
#ifndef JSON_SPIRIT_WRITER_TEMPLATE #ifndef JSON_SPIRIT_WRITER_TEMPLATE
#define JSON_SPIRIT_WRITER_TEMPLATE #define JSON_SPIRIT_WRITER_TEMPLATE
// Copyright John W. Wilkinson 2007 - 2009. // Copyright John W. Wilkinson 2007 - 2013
// Distributed under the MIT License, see accompanying file LICENSE.txt // Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.03 // json spirit version 4.06
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include "json_spirit_value.h" #include "json_spirit_value.h"
#include "json_spirit_writer_options.h"
#include <cassert> #include <cassert>
#include <sstream> #include <sstream>
#include <iomanip> #include <iomanip>
#include <boost/io/ios_state.hpp>
namespace json_spirit namespace json_spirit
{ {
@ -60,7 +66,7 @@ namespace json_spirit
} }
template< class String_type > template< class String_type >
String_type add_esc_chars( const String_type& s ) String_type add_esc_chars( const String_type& s, bool raw_utf8, bool esc_nonascii )
{ {
typedef typename String_type::const_iterator Iter_type; typedef typename String_type::const_iterator Iter_type;
typedef typename String_type::value_type Char_type; typedef typename String_type::value_type Char_type;
@ -75,21 +81,80 @@ namespace json_spirit
if( add_esc_char( c, result ) ) continue; if( add_esc_char( c, result ) ) continue;
const wint_t unsigned_c( ( c >= 0 ) ? c : 256 + c ); if( raw_utf8 )
if( iswprint( unsigned_c ) )
{ {
result += c; result += c;
} }
else else
{ {
result += non_printable_to_string< String_type >( unsigned_c ); 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; 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;
}
}
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, // this class generates the JSON text,
// it keeps track of the indentation level etc. // it keeps track of the indentation level etc.
// //
@ -105,10 +170,15 @@ namespace json_spirit
public: public:
Generator( const Value_type& value, Ostream_type& os, bool pretty ) Generator( const Value_type& value, Ostream_type& os, unsigned int options )
: os_( os ) : os_( os )
, indentation_level_( 0 ) , indentation_level_( 0 )
, pretty_( pretty ) , 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 )
{ {
output( value ); output( value );
} }
@ -123,12 +193,8 @@ namespace json_spirit
case array_type: output( value.get_array() ); break; case array_type: output( value.get_array() ); break;
case str_type: output( value.get_str() ); break; case str_type: output( value.get_str() ); break;
case bool_type: output( value.get_bool() ); break; case bool_type: output( value.get_bool() ); break;
case real_type: output( value.get_real() ); break;
case int_type: output_int( value ); 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; case null_type: os_ << "null"; break;
default: assert( false ); default: assert( false );
} }
@ -139,11 +205,6 @@ namespace json_spirit
output_array_or_obj( obj, '{', '}' ); output_array_or_obj( obj, '{', '}' );
} }
void output( const Array_type& arr )
{
output_array_or_obj( arr, '[', ']' );
}
void output( const Obj_member_type& member ) void output( const Obj_member_type& member )
{ {
output( Config_type::get_name( member ) ); space(); output( Config_type::get_name( member ) ); space();
@ -165,7 +226,7 @@ namespace json_spirit
void output( const String_type& s ) void output( const String_type& s )
{ {
os_ << '"' << add_esc_chars( s ) << '"'; os_ << '"' << add_esc_chars( s, raw_utf8_, esc_nonascii_ ) << '"';
} }
void output( bool b ) void output( bool b )
@ -173,6 +234,75 @@ namespace json_spirit
os_ << to_str< String_type >( b ? "true" : "false" ); 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 > template< class T >
void output_array_or_obj( const T& t, Char_type start_char, Char_type end_char ) void output_array_or_obj( const T& t, Char_type start_char, Char_type end_char )
{ {
@ -182,14 +312,9 @@ namespace json_spirit
for( typename T::const_iterator i = t.begin(); i != t.end(); ++i ) for( typename T::const_iterator i = t.begin(); i != t.end(); ++i )
{ {
indent(); output( *i ); indent();
typename T::const_iterator next = i; output_composite_item( i, t.end() );
if( ++next != t.end())
{
os_ << ',';
}
new_line(); new_line();
} }
@ -224,22 +349,36 @@ namespace json_spirit
Ostream_type& os_; Ostream_type& os_;
int indentation_level_; int indentation_level_;
bool pretty_; 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 > template< class Value_type, class Ostream_type >
void write_stream( const Value_type& value, Ostream_type& os, bool pretty ) void write_stream( const Value_type& value, Ostream_type& os, unsigned int options = 0 )
{ {
Generator< Value_type, Ostream_type >( value, os, pretty ); os << std::dec;
Generator< Value_type, Ostream_type >( value, os, options );
} }
// writes JSON Value to a stream, e.g.
//
// const string json_str = write( value, pretty_print );
//
template< class Value_type > template< class Value_type >
typename Value_type::String_type write_string( const Value_type& value, bool pretty ) typename Value_type::String_type write_string( const Value_type& value, unsigned int options = 0 )
{ {
typedef typename Value_type::String_type::value_type Char_type; typedef typename Value_type::String_type::value_type Char_type;
std::basic_ostringstream< Char_type > os; std::basic_ostringstream< Char_type > os;
write_stream( value, os, pretty ); write_stream( value, os, options );
return os.str(); return os.str();
} }

4
src/qt/rpcconsole.cpp
Unescape View File

@ -159,7 +159,7 @@ void RPCExecutor::request(const QString &command)
else if (result.type() == json_spirit::str_type) else if (result.type() == json_spirit::str_type)
strPrint = result.get_str(); strPrint = result.get_str();
else else
strPrint = write_string(result, true); strPrint = write_string(result, json_spirit::pretty_print | json_spirit::raw_utf8);
emit reply(RPCConsole::CMD_REPLY, QString::fromStdString(strPrint)); emit reply(RPCConsole::CMD_REPLY, QString::fromStdString(strPrint));
} }
@ -173,7 +173,7 @@ void RPCExecutor::request(const QString &command)
} }
catch(std::runtime_error &) // raised when converting to invalid type, i.e. missing code or message catch(std::runtime_error &) // raised when converting to invalid type, i.e. missing code or message
{ // Show raw JSON object { // Show raw JSON object
emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(write_string(json_spirit::Value(objError), false))); emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(write_string(json_spirit::Value(objError), json_spirit::raw_utf8)));
} }
} }
catch (std::exception& e) catch (std::exception& e)

10
src/test/base58_tests.cpp
Unescape View File

@ -20,7 +20,7 @@ BOOST_AUTO_TEST_CASE(base58_EncodeBase58)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
std::string strTest = write_string(tv, false); std::string strTest = write_string(tv, raw_utf8);
if (test.size() < 2) // Allow for extra stuff (useful for comments) if (test.size() < 2) // Allow for extra stuff (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);
@ -43,7 +43,7 @@ BOOST_AUTO_TEST_CASE(base58_DecodeBase58)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
std::string strTest = write_string(tv, false); std::string strTest = write_string(tv, raw_utf8);
if (test.size() < 2) // Allow for extra stuff (useful for comments) if (test.size() < 2) // Allow for extra stuff (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);
@ -113,7 +113,7 @@ BOOST_AUTO_TEST_CASE(base58_keys_valid_parse)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
std::string strTest = write_string(tv, false); std::string strTest = write_string(tv, raw_utf8);
if (test.size() < 3) // Allow for extra stuff (useful for comments) if (test.size() < 3) // Allow for extra stuff (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);
@ -169,7 +169,7 @@ BOOST_AUTO_TEST_CASE(base58_keys_valid_gen)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
std::string strTest = write_string(tv, false); std::string strTest = write_string(tv, raw_utf8);
if (test.size() < 3) // Allow for extra stuff (useful for comments) if (test.size() < 3) // Allow for extra stuff (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);
@ -240,7 +240,7 @@ BOOST_AUTO_TEST_CASE(base58_keys_invalid)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
std::string strTest = write_string(tv, false); std::string strTest = write_string(tv, raw_utf8);
if (test.size() < 1) // Allow for extra stuff (useful for comments) if (test.size() < 1) // Allow for extra stuff (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);

4
src/test/script_tests.cpp
Unescape View File

@ -118,7 +118,7 @@ BOOST_AUTO_TEST_CASE(script_valid)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
string strTest = write_string(tv, false); string strTest = write_string(tv, raw_utf8);
if (test.size() < 2) // Allow size > 2; extra stuff ignored (useful for comments) if (test.size() < 2) // Allow size > 2; extra stuff ignored (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);
@ -142,7 +142,7 @@ BOOST_AUTO_TEST_CASE(script_invalid)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
string strTest = write_string(tv, false); string strTest = write_string(tv, raw_utf8);
if (test.size() < 2) // Allow size > 2; extra stuff ignored (useful for comments) if (test.size() < 2) // Allow size > 2; extra stuff ignored (useful for comments)
{ {
BOOST_ERROR("Bad test: " << strTest); BOOST_ERROR("Bad test: " << strTest);

4
src/test/transaction_tests.cpp
Unescape View File

@ -29,7 +29,7 @@ BOOST_AUTO_TEST_CASE(tx_valid)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
string strTest = write_string(tv, false); string strTest = write_string(tv, raw_utf8);
if (test[0].type() == array_type) if (test[0].type() == array_type)
{ {
if (test.size() != 3 || test[1].type() != str_type || test[2].type() != bool_type) if (test.size() != 3 || test[1].type() != str_type || test[2].type() != bool_type)
@ -98,7 +98,7 @@ BOOST_AUTO_TEST_CASE(tx_invalid)
BOOST_FOREACH(Value& tv, tests) BOOST_FOREACH(Value& tv, tests)
{ {
Array test = tv.get_array(); Array test = tv.get_array();
string strTest = write_string(tv, false); string strTest = write_string(tv, raw_utf8);
if (test[0].type() == array_type) if (test[0].type() == array_type)
{ {
if (test.size() != 3 || test[1].type() != str_type || test[2].type() != bool_type) if (test.size() != 3 || test[1].type() != str_type || test[2].type() != bool_type)

Write Preview
Loading…
Cancel
Save