Jonas Schnelli
9 years ago
committed by
Jonas Schnelli
6 changed files with 0 additions and 1406 deletions
@ -1,77 +0,0 @@
@@ -1,77 +0,0 @@
|
||||
// Copyright 2014 BitPay Inc.
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
//
|
||||
// To re-create univalue_escapes.h:
|
||||
// $ g++ -o gen gen.cpp
|
||||
// $ ./gen > univalue_escapes.h
|
||||
//
|
||||
|
||||
#include <ctype.h> |
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include "univalue.h" |
||||
|
||||
using namespace std; |
||||
|
||||
static bool initEscapes; |
||||
static const char *escapes[256]; |
||||
|
||||
static void initJsonEscape() |
||||
{ |
||||
escapes[(int)'"'] = "\\\""; |
||||
escapes[(int)'\\'] = "\\\\"; |
||||
escapes[(int)'\b'] = "\\b"; |
||||
escapes[(int)'\f'] = "\\f"; |
||||
escapes[(int)'\n'] = "\\n"; |
||||
escapes[(int)'\r'] = "\\r"; |
||||
escapes[(int)'\t'] = "\\t"; |
||||
|
||||
initEscapes = true; |
||||
} |
||||
|
||||
static void outputEscape() |
||||
{ |
||||
printf( "// Automatically generated file. Do not modify.\n" |
||||
"#ifndef BITCOIN_UNIVALUE_UNIVALUE_ESCAPES_H\n" |
||||
"#define BITCOIN_UNIVALUE_UNIVALUE_ESCAPES_H\n" |
||||
"static const char *escapes[256] = {\n"); |
||||
|
||||
for (unsigned int i = 0; i < 256; i++) { |
||||
if (!escapes[i]) { |
||||
printf("\tNULL,\n"); |
||||
} else { |
||||
printf("\t\""); |
||||
|
||||
unsigned int si; |
||||
for (si = 0; si < strlen(escapes[i]); si++) { |
||||
char ch = escapes[i][si]; |
||||
switch (ch) { |
||||
case '"': |
||||
printf("\\\""); |
||||
break; |
||||
case '\\': |
||||
printf("\\\\"); |
||||
break; |
||||
default: |
||||
printf("%c", escapes[i][si]); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
printf("\",\n"); |
||||
} |
||||
} |
||||
|
||||
printf( "};\n" |
||||
"#endif // BITCOIN_UNIVALUE_UNIVALUE_ESCAPES_H\n"); |
||||
} |
||||
|
||||
int main (int argc, char *argv[]) |
||||
{ |
||||
initJsonEscape(); |
||||
outputEscape(); |
||||
return 0; |
||||
} |
||||
|
@ -1,303 +0,0 @@
@@ -1,303 +0,0 @@
|
||||
// Copyright 2014 BitPay Inc.
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include <stdint.h> |
||||
#include <ctype.h> |
||||
#include <iomanip> |
||||
#include <sstream> |
||||
#include <stdexcept> // std::runtime_error |
||||
|
||||
#include "univalue.h" |
||||
|
||||
#include "utilstrencodings.h" // ParseXX |
||||
|
||||
using namespace std; |
||||
|
||||
const UniValue NullUniValue; |
||||
|
||||
void UniValue::clear() |
||||
{ |
||||
typ = VNULL; |
||||
val.clear(); |
||||
keys.clear(); |
||||
values.clear(); |
||||
} |
||||
|
||||
bool UniValue::setNull() |
||||
{ |
||||
clear(); |
||||
return true; |
||||
} |
||||
|
||||
bool UniValue::setBool(bool val_) |
||||
{ |
||||
clear(); |
||||
typ = VBOOL; |
||||
if (val_) |
||||
val = "1"; |
||||
return true; |
||||
} |
||||
|
||||
static bool validNumStr(const string& s) |
||||
{ |
||||
string tokenVal; |
||||
unsigned int consumed; |
||||
enum jtokentype tt = getJsonToken(tokenVal, consumed, s.c_str()); |
||||
return (tt == JTOK_NUMBER); |
||||
} |
||||
|
||||
bool UniValue::setNumStr(const string& val_) |
||||
{ |
||||
if (!validNumStr(val_)) |
||||
return false; |
||||
|
||||
clear(); |
||||
typ = VNUM; |
||||
val = val_; |
||||
return true; |
||||
} |
||||
|
||||
bool UniValue::setInt(uint64_t val) |
||||
{ |
||||
string s; |
||||
ostringstream oss; |
||||
|
||||
oss << val; |
||||
|
||||
return setNumStr(oss.str()); |
||||
} |
||||
|
||||
bool UniValue::setInt(int64_t val) |
||||
{ |
||||
string s; |
||||
ostringstream oss; |
||||
|
||||
oss << val; |
||||
|
||||
return setNumStr(oss.str()); |
||||
} |
||||
|
||||
bool UniValue::setFloat(double val) |
||||
{ |
||||
string s; |
||||
ostringstream oss; |
||||
|
||||
oss << std::setprecision(16) << val; |
||||
|
||||
bool ret = setNumStr(oss.str()); |
||||
typ = VNUM; |
||||
return ret; |
||||
} |
||||
|
||||
bool UniValue::setStr(const string& val_) |
||||
{ |
||||
clear(); |
||||
typ = VSTR; |
||||
val = val_; |
||||
return true; |
||||
} |
||||
|
||||
bool UniValue::setArray() |
||||
{ |
||||
clear(); |
||||
typ = VARR; |
||||
return true; |
||||
} |
||||
|
||||
bool UniValue::setObject() |
||||
{ |
||||
clear(); |
||||
typ = VOBJ; |
||||
return true; |
||||
} |
||||
|
||||
bool UniValue::push_back(const UniValue& val) |
||||
{ |
||||
if (typ != VARR) |
||||
return false; |
||||
|
||||
values.push_back(val); |
||||
return true; |
||||
} |
||||
|
||||
bool UniValue::push_backV(const std::vector<UniValue>& vec) |
||||
{ |
||||
if (typ != VARR) |
||||
return false; |
||||
|
||||
values.insert(values.end(), vec.begin(), vec.end()); |
||||
|
||||
return true; |
||||
} |
||||
|
||||
bool UniValue::pushKV(const std::string& key, const UniValue& val) |
||||
{ |
||||
if (typ != VOBJ) |
||||
return false; |
||||
|
||||
keys.push_back(key); |
||||
values.push_back(val); |
||||
return true; |
||||
} |
||||
|
||||
bool UniValue::pushKVs(const UniValue& obj) |
||||
{ |
||||
if (typ != VOBJ || obj.typ != VOBJ) |
||||
return false; |
||||
|
||||
for (unsigned int i = 0; i < obj.keys.size(); i++) { |
||||
keys.push_back(obj.keys[i]); |
||||
values.push_back(obj.values[i]); |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
int UniValue::findKey(const std::string& key) const |
||||
{ |
||||
for (unsigned int i = 0; i < keys.size(); i++) { |
||||
if (keys[i] == key) |
||||
return (int) i; |
||||
} |
||||
|
||||
return -1; |
||||
} |
||||
|
||||
bool UniValue::checkObject(const std::map<std::string,UniValue::VType>& t) |
||||
{ |
||||
for (std::map<std::string,UniValue::VType>::const_iterator it = t.begin(); |
||||
it != t.end(); it++) { |
||||
int idx = findKey(it->first); |
||||
if (idx < 0) |
||||
return false; |
||||
|
||||
if (values[idx].getType() != it->second) |
||||
return false; |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
const UniValue& UniValue::operator[](const std::string& key) const |
||||
{ |
||||
if (typ != VOBJ) |
||||
return NullUniValue; |
||||
|
||||
int index = findKey(key); |
||||
if (index < 0) |
||||
return NullUniValue; |
||||
|
||||
return values[index]; |
||||
} |
||||
|
||||
const UniValue& UniValue::operator[](unsigned int index) const |
||||
{ |
||||
if (typ != VOBJ && typ != VARR) |
||||
return NullUniValue; |
||||
if (index >= values.size()) |
||||
return NullUniValue; |
||||
|
||||
return values[index]; |
||||
} |
||||
|
||||
const char *uvTypeName(UniValue::VType t) |
||||
{ |
||||
switch (t) { |
||||
case UniValue::VNULL: return "null"; |
||||
case UniValue::VBOOL: return "bool"; |
||||
case UniValue::VOBJ: return "object"; |
||||
case UniValue::VARR: return "array"; |
||||
case UniValue::VSTR: return "string"; |
||||
case UniValue::VNUM: return "number"; |
||||
} |
||||
|
||||
// not reached
|
||||
return NULL; |
||||
} |
||||
|
||||
const UniValue& find_value( const UniValue& obj, const std::string& name) |
||||
{ |
||||
for (unsigned int i = 0; i < obj.keys.size(); i++) |
||||
{ |
||||
if( obj.keys[i] == name ) |
||||
{ |
||||
return obj.values[i]; |
||||
} |
||||
} |
||||
|
||||
return NullUniValue; |
||||
} |
||||
|
||||
std::vector<std::string> UniValue::getKeys() const |
||||
{ |
||||
if (typ != VOBJ) |
||||
throw std::runtime_error("JSON value is not an object as expected"); |
||||
return keys; |
||||
} |
||||
|
||||
std::vector<UniValue> UniValue::getValues() const |
||||
{ |
||||
if (typ != VOBJ && typ != VARR) |
||||
throw std::runtime_error("JSON value is not an object or array as expected"); |
||||
return values; |
||||
} |
||||
|
||||
bool UniValue::get_bool() const |
||||
{ |
||||
if (typ != VBOOL) |
||||
throw std::runtime_error("JSON value is not a boolean as expected"); |
||||
return getBool(); |
||||
} |
||||
|
||||
std::string UniValue::get_str() const |
||||
{ |
||||
if (typ != VSTR) |
||||
throw std::runtime_error("JSON value is not a string as expected"); |
||||
return getValStr(); |
||||
} |
||||
|
||||
int UniValue::get_int() const |
||||
{ |
||||
if (typ != VNUM) |
||||
throw std::runtime_error("JSON value is not an integer as expected"); |
||||
int32_t retval; |
||||
if (!ParseInt32(getValStr(), &retval)) |
||||
throw std::runtime_error("JSON integer out of range"); |
||||
return retval; |
||||
} |
||||
|
||||
int64_t UniValue::get_int64() const |
||||
{ |
||||
if (typ != VNUM) |
||||
throw std::runtime_error("JSON value is not an integer as expected"); |
||||
int64_t retval; |
||||
if (!ParseInt64(getValStr(), &retval)) |
||||
throw std::runtime_error("JSON integer out of range"); |
||||
return retval; |
||||
} |
||||
|
||||
double UniValue::get_real() const |
||||
{ |
||||
if (typ != VNUM) |
||||
throw std::runtime_error("JSON value is not a number as expected"); |
||||
double retval; |
||||
if (!ParseDouble(getValStr(), &retval)) |
||||
throw std::runtime_error("JSON double out of range"); |
||||
return retval; |
||||
} |
||||
|
||||
const UniValue& UniValue::get_obj() const |
||||
{ |
||||
if (typ != VOBJ) |
||||
throw std::runtime_error("JSON value is not an object as expected"); |
||||
return *this; |
||||
} |
||||
|
||||
const UniValue& UniValue::get_array() const |
||||
{ |
||||
if (typ != VARR) |
||||
throw std::runtime_error("JSON value is not an array as expected"); |
||||
return *this; |
||||
} |
||||
|
@ -1,248 +0,0 @@
@@ -1,248 +0,0 @@
|
||||
// Copyright 2014 BitPay Inc.
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#ifndef BITCOIN_UNIVALUE_UNIVALUE_H |
||||
#define BITCOIN_UNIVALUE_UNIVALUE_H |
||||
|
||||
#include <stdint.h> |
||||
#include <string> |
||||
#include <vector> |
||||
#include <map> |
||||
#include <cassert> |
||||
|
||||
#include <sstream> // .get_int64() |
||||
#include <utility> // std::pair |
||||
|
||||
class UniValue { |
||||
public: |
||||
enum VType { VNULL, VOBJ, VARR, VSTR, VNUM, VBOOL, }; |
||||
|
||||
UniValue() { typ = VNULL; } |
||||
UniValue(UniValue::VType initialType, const std::string& initialStr = "") { |
||||
typ = initialType; |
||||
val = initialStr; |
||||
} |
||||
UniValue(uint64_t val_) { |
||||
setInt(val_); |
||||
} |
||||
UniValue(int64_t val_) { |
||||
setInt(val_); |
||||
} |
||||
UniValue(bool val_) { |
||||
setBool(val_); |
||||
} |
||||
UniValue(int val_) { |
||||
setInt(val_); |
||||
} |
||||
UniValue(double val_) { |
||||
setFloat(val_); |
||||
} |
||||
UniValue(const std::string& val_) { |
||||
setStr(val_); |
||||
} |
||||
UniValue(const char *val_) { |
||||
std::string s(val_); |
||||
setStr(s); |
||||
} |
||||
~UniValue() {} |
||||
|
||||
void clear(); |
||||
|
||||
bool setNull(); |
||||
bool setBool(bool val); |
||||
bool setNumStr(const std::string& val); |
||||
bool setInt(uint64_t val); |
||||
bool setInt(int64_t val); |
||||
bool setInt(int val) { return setInt((int64_t)val); } |
||||
bool setFloat(double val); |
||||
bool setStr(const std::string& val); |
||||
bool setArray(); |
||||
bool setObject(); |
||||
|
||||
enum VType getType() const { return typ; } |
||||
const std::string& getValStr() const { return val; } |
||||
bool empty() const { return (values.size() == 0); } |
||||
|
||||
size_t size() const { return values.size(); } |
||||
|
||||
bool getBool() const { return isTrue(); } |
||||
bool checkObject(const std::map<std::string,UniValue::VType>& memberTypes); |
||||
const UniValue& operator[](const std::string& key) const; |
||||
const UniValue& operator[](unsigned int index) const; |
||||
bool exists(const std::string& key) const { return (findKey(key) >= 0); } |
||||
|
||||
bool isNull() const { return (typ == VNULL); } |
||||
bool isTrue() const { return (typ == VBOOL) && (val == "1"); } |
||||
bool isFalse() const { return (typ == VBOOL) && (val != "1"); } |
||||
bool isBool() const { return (typ == VBOOL); } |
||||
bool isStr() const { return (typ == VSTR); } |
||||
bool isNum() const { return (typ == VNUM); } |
||||
bool isArray() const { return (typ == VARR); } |
||||
bool isObject() const { return (typ == VOBJ); } |
||||
|
||||
bool push_back(const UniValue& val); |
||||
bool push_back(const std::string& val_) { |
||||
UniValue tmpVal(VSTR, val_); |
||||
return push_back(tmpVal); |
||||
} |
||||
bool push_back(const char *val_) { |
||||
std::string s(val_); |
||||
return push_back(s); |
||||
} |
||||
bool push_backV(const std::vector<UniValue>& vec); |
||||
|
||||
bool pushKV(const std::string& key, const UniValue& val); |
||||
bool pushKV(const std::string& key, const std::string& val) { |
||||
UniValue tmpVal(VSTR, val); |
||||
return pushKV(key, tmpVal); |
||||
} |
||||
bool pushKV(const std::string& key, const char *val_) { |
||||
std::string val(val_); |
||||
return pushKV(key, val); |
||||
} |
||||
bool pushKV(const std::string& key, int64_t val) { |
||||
UniValue tmpVal(val); |
||||
return pushKV(key, tmpVal); |
||||
} |
||||
bool pushKV(const std::string& key, uint64_t val) { |
||||
UniValue tmpVal(val); |
||||
return pushKV(key, tmpVal); |
||||
} |
||||
bool pushKV(const std::string& key, int val) { |
||||
UniValue tmpVal((int64_t)val); |
||||
return pushKV(key, tmpVal); |
||||
} |
||||
bool pushKV(const std::string& key, double val) { |
||||
UniValue tmpVal(val); |
||||
return pushKV(key, tmpVal); |
||||
} |
||||
bool pushKVs(const UniValue& obj); |
||||
|
||||
std::string write(unsigned int prettyIndent = 0, |
||||
unsigned int indentLevel = 0) const; |
||||
|
||||
bool read(const char *raw); |
||||
bool read(const std::string& rawStr) { |
||||
return read(rawStr.c_str()); |
||||
} |
||||
|
||||
private: |
||||
UniValue::VType typ; |
||||
std::string val; // numbers are stored as C++ strings
|
||||
std::vector<std::string> keys; |
||||
std::vector<UniValue> values; |
||||
|
||||
int findKey(const std::string& key) const; |
||||
void writeArray(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const; |
||||
void writeObject(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const; |
||||
|
||||
public: |
||||
// Strict type-specific getters, these throw std::runtime_error if the
|
||||
// value is of unexpected type
|
||||
std::vector<std::string> getKeys() const; |
||||
std::vector<UniValue> getValues() const; |
||||
bool get_bool() const; |
||||
std::string get_str() const; |
||||
int get_int() const; |
||||
int64_t get_int64() const; |
||||
double get_real() const; |
||||
const UniValue& get_obj() const; |
||||
const UniValue& get_array() const; |
||||
|
||||
enum VType type() const { return getType(); } |
||||
bool push_back(std::pair<std::string,UniValue> pear) { |
||||
return pushKV(pear.first, pear.second); |
||||
} |
||||
friend const UniValue& find_value( const UniValue& obj, const std::string& name); |
||||
}; |
||||
|
||||
//
|
||||
// The following were added for compatibility with json_spirit.
|
||||
// Most duplicate other methods, and should be removed.
|
||||
//
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, const char *cVal) |
||||
{ |
||||
std::string key(cKey); |
||||
UniValue uVal(cVal); |
||||
return std::make_pair(key, uVal); |
||||
} |
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, std::string strVal) |
||||
{ |
||||
std::string key(cKey); |
||||
UniValue uVal(strVal); |
||||
return std::make_pair(key, uVal); |
||||
} |
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, uint64_t u64Val) |
||||
{ |
||||
std::string key(cKey); |
||||
UniValue uVal(u64Val); |
||||
return std::make_pair(key, uVal); |
||||
} |
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, int64_t i64Val) |
||||
{ |
||||
std::string key(cKey); |
||||
UniValue uVal(i64Val); |
||||
return std::make_pair(key, uVal); |
||||
} |
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, bool iVal) |
||||
{ |
||||
std::string key(cKey); |
||||
UniValue uVal(iVal); |
||||
return std::make_pair(key, uVal); |
||||
} |
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, int iVal) |
||||
{ |
||||
std::string key(cKey); |
||||
UniValue uVal(iVal); |
||||
return std::make_pair(key, uVal); |
||||
} |
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, double dVal) |
||||
{ |
||||
std::string key(cKey); |
||||
UniValue uVal(dVal); |
||||
return std::make_pair(key, uVal); |
||||
} |
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, const UniValue& uVal) |
||||
{ |
||||
std::string key(cKey); |
||||
return std::make_pair(key, uVal); |
||||
} |
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(std::string key, const UniValue& uVal) |
||||
{ |
||||
return std::make_pair(key, uVal); |
||||
} |
||||
|
||||
enum jtokentype { |
||||
JTOK_ERR = -1, |
||||
JTOK_NONE = 0, // eof
|
||||
JTOK_OBJ_OPEN, |
||||
JTOK_OBJ_CLOSE, |
||||
JTOK_ARR_OPEN, |
||||
JTOK_ARR_CLOSE, |
||||
JTOK_COLON, |
||||
JTOK_COMMA, |
||||
JTOK_KW_NULL, |
||||
JTOK_KW_TRUE, |
||||
JTOK_KW_FALSE, |
||||
JTOK_NUMBER, |
||||
JTOK_STRING, |
||||
}; |
||||
|
||||
extern enum jtokentype getJsonToken(std::string& tokenVal, |
||||
unsigned int& consumed, const char *raw); |
||||
extern const char *uvTypeName(UniValue::VType t); |
||||
|
||||
extern const UniValue NullUniValue; |
||||
|
||||
const UniValue& find_value( const UniValue& obj, const std::string& name); |
||||
|
||||
#endif // BITCOIN_UNIVALUE_UNIVALUE_H
|
@ -1,262 +0,0 @@
@@ -1,262 +0,0 @@
|
||||
// Automatically generated file. Do not modify.
|
||||
#ifndef BITCOIN_UNIVALUE_UNIVALUE_ESCAPES_H |
||||
#define BITCOIN_UNIVALUE_UNIVALUE_ESCAPES_H |
||||
static const char *escapes[256] = { |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
"\\b", |
||||
"\\t", |
||||
"\\n", |
||||
NULL, |
||||
"\\f", |
||||
"\\r", |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
"\\\"", |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
"\\\\", |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
NULL, |
||||
}; |
||||
#endif // BITCOIN_UNIVALUE_UNIVALUE_ESCAPES_H
|
@ -1,389 +0,0 @@
@@ -1,389 +0,0 @@
|
||||
// Copyright 2014 BitPay Inc.
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include <string.h> |
||||
#include <vector> |
||||
#include <stdio.h> |
||||
#include "univalue.h" |
||||
|
||||
using namespace std; |
||||
|
||||
// convert hexadecimal string to unsigned integer
|
||||
static const char *hatoui(const char *first, const char *last, |
||||
unsigned int& out) |
||||
{ |
||||
unsigned int result = 0; |
||||
for (; first != last; ++first) |
||||
{ |
||||
int digit; |
||||
if (isdigit(*first)) |
||||
digit = *first - '0'; |
||||
|
||||
else if (*first >= 'a' && *first <= 'f') |
||||
digit = *first - 'a' + 10; |
||||
|
||||
else if (*first >= 'A' && *first <= 'F') |
||||
digit = *first - 'A' + 10; |
||||
|
||||
else |
||||
break; |
||||
|
||||
result = 16 * result + digit; |
||||
} |
||||
out = result; |
||||
|
||||
return first; |
||||
} |
||||
|
||||
enum jtokentype getJsonToken(string& tokenVal, unsigned int& consumed, |
||||
const char *raw) |
||||
{ |
||||
tokenVal.clear(); |
||||
consumed = 0; |
||||
|
||||
const char *rawStart = raw; |
||||
|
||||
while ((*raw) && (isspace(*raw))) // skip whitespace
|
||||
raw++; |
||||
|
||||
switch (*raw) { |
||||
|
||||
case 0: |
||||
return JTOK_NONE; |
||||
|
||||
case '{': |
||||
raw++; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_OBJ_OPEN; |
||||
case '}': |
||||
raw++; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_OBJ_CLOSE; |
||||
case '[': |
||||
raw++; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_ARR_OPEN; |
||||
case ']': |
||||
raw++; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_ARR_CLOSE; |
||||
|
||||
case ':': |
||||
raw++; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_COLON; |
||||
case ',': |
||||
raw++; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_COMMA; |
||||
|
||||
case 'n': |
||||
case 't': |
||||
case 'f': |
||||
if (!strncmp(raw, "null", 4)) { |
||||
raw += 4; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_KW_NULL; |
||||
} else if (!strncmp(raw, "true", 4)) { |
||||
raw += 4; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_KW_TRUE; |
||||
} else if (!strncmp(raw, "false", 5)) { |
||||
raw += 5; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_KW_FALSE; |
||||
} else |
||||
return JTOK_ERR; |
||||
|
||||
case '-': |
||||
case '0': |
||||
case '1': |
||||
case '2': |
||||
case '3': |
||||
case '4': |
||||
case '5': |
||||
case '6': |
||||
case '7': |
||||
case '8': |
||||
case '9': { |
||||
// part 1: int
|
||||
string numStr; |
||||
|
||||
const char *first = raw; |
||||
|
||||
const char *firstDigit = first; |
||||
if (!isdigit(*firstDigit)) |
||||
firstDigit++; |
||||
if ((*firstDigit == '0') && isdigit(firstDigit[1])) |
||||
return JTOK_ERR; |
||||
|
||||
numStr += *raw; // copy first char
|
||||
raw++; |
||||
|
||||
if ((*first == '-') && (!isdigit(*raw))) |
||||
return JTOK_ERR; |
||||
|
||||
while ((*raw) && isdigit(*raw)) { // copy digits
|
||||
numStr += *raw; |
||||
raw++; |
||||
} |
||||
|
||||
// part 2: frac
|
||||
if (*raw == '.') { |
||||
numStr += *raw; // copy .
|
||||
raw++; |
||||
|
||||
if (!isdigit(*raw)) |
||||
return JTOK_ERR; |
||||
while ((*raw) && isdigit(*raw)) { // copy digits
|
||||
numStr += *raw; |
||||
raw++; |
||||
} |
||||
} |
||||
|
||||
// part 3: exp
|
||||
if (*raw == 'e' || *raw == 'E') { |
||||
numStr += *raw; // copy E
|
||||
raw++; |
||||
|
||||
if (*raw == '-' || *raw == '+') { // copy +/-
|
||||
numStr += *raw; |
||||
raw++; |
||||
} |
||||
|
||||
if (!isdigit(*raw)) |
||||
return JTOK_ERR; |
||||
while ((*raw) && isdigit(*raw)) { // copy digits
|
||||
numStr += *raw; |
||||
raw++; |
||||
} |
||||
} |
||||
|
||||
tokenVal = numStr; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_NUMBER; |
||||
} |
||||
|
||||
case '"': { |
||||
raw++; // skip "
|
||||
|
||||
string valStr; |
||||
|
||||
while (*raw) { |
||||
if (*raw < 0x20) |
||||
return JTOK_ERR; |
||||
|
||||
else if (*raw == '\\') { |
||||
raw++; // skip backslash
|
||||
|
||||
switch (*raw) { |
||||
case '"': valStr += "\""; break; |
||||
case '\\': valStr += "\\"; break; |
||||
case '/': valStr += "/"; break; |
||||
case 'b': valStr += "\b"; break; |
||||
case 'f': valStr += "\f"; break; |
||||
case 'n': valStr += "\n"; break; |
||||
case 'r': valStr += "\r"; break; |
||||
case 't': valStr += "\t"; break; |
||||
|
||||
case 'u': { |
||||
unsigned int codepoint; |
||||
if (hatoui(raw + 1, raw + 1 + 4, codepoint) != |
||||
raw + 1 + 4) |
||||
return JTOK_ERR; |
||||
|
||||
if (codepoint <= 0x7f) |
||||
valStr.push_back((char)codepoint); |
||||
else if (codepoint <= 0x7FF) { |
||||
valStr.push_back((char)(0xC0 | (codepoint >> 6))); |
||||
valStr.push_back((char)(0x80 | (codepoint & 0x3F))); |
||||
} else if (codepoint <= 0xFFFF) { |
||||
valStr.push_back((char)(0xE0 | (codepoint >> 12))); |
||||
valStr.push_back((char)(0x80 | ((codepoint >> 6) & 0x3F))); |
||||
valStr.push_back((char)(0x80 | (codepoint & 0x3F))); |
||||
} |
||||
|
||||
raw += 4; |
||||
break; |
||||
} |
||||
default: |
||||
return JTOK_ERR; |
||||
|
||||
} |
||||
|
||||
raw++; // skip esc'd char
|
||||
} |
||||
|
||||
else if (*raw == '"') { |
||||
raw++; // skip "
|
||||
break; // stop scanning
|
||||
} |
||||
|
||||
else { |
||||
valStr += *raw; |
||||
raw++; |
||||
} |
||||
} |
||||
|
||||
tokenVal = valStr; |
||||
consumed = (raw - rawStart); |
||||
return JTOK_STRING; |
||||
} |
||||
|
||||
default: |
||||
return JTOK_ERR; |
||||
} |
||||
} |
||||
|
||||
bool UniValue::read(const char *raw) |
||||
{ |
||||
clear(); |
||||
|
||||
bool expectName = false; |
||||
bool expectColon = false; |
||||
vector<UniValue*> stack; |
||||
|
||||
string tokenVal; |
||||
unsigned int consumed; |
||||
enum jtokentype tok = JTOK_NONE; |
||||
enum jtokentype last_tok = JTOK_NONE; |
||||
do { |
||||
last_tok = tok; |
||||
|
||||
tok = getJsonToken(tokenVal, consumed, raw); |
||||
if (tok == JTOK_NONE || tok == JTOK_ERR) |
||||
return false; |
||||
raw += consumed; |
||||
|
||||
switch (tok) { |
||||
|
||||
case JTOK_OBJ_OPEN: |
||||
case JTOK_ARR_OPEN: { |
||||
VType utyp = (tok == JTOK_OBJ_OPEN ? VOBJ : VARR); |
||||
if (!stack.size()) { |
||||
if (utyp == VOBJ) |
||||
setObject(); |
||||
else |
||||
setArray(); |
||||
stack.push_back(this); |
||||
} else { |
||||
UniValue tmpVal(utyp); |
||||
UniValue *top = stack.back(); |
||||
top->values.push_back(tmpVal); |
||||
|
||||
UniValue *newTop = &(top->values.back()); |
||||
stack.push_back(newTop); |
||||
} |
||||
|
||||
if (utyp == VOBJ) |
||||
expectName = true; |
||||
break; |
||||
} |
||||
|
||||
case JTOK_OBJ_CLOSE: |
||||
case JTOK_ARR_CLOSE: { |
||||
if (!stack.size() || expectColon || (last_tok == JTOK_COMMA)) |
||||
return false; |
||||
|
||||
VType utyp = (tok == JTOK_OBJ_CLOSE ? VOBJ : VARR); |
||||
UniValue *top = stack.back(); |
||||
if (utyp != top->getType()) |
||||
return false; |
||||
|
||||
stack.pop_back(); |
||||
expectName = false; |
||||
break; |
||||
} |
||||
|
||||
case JTOK_COLON: { |
||||
if (!stack.size() || expectName || !expectColon) |
||||
return false; |
||||
|
||||
UniValue *top = stack.back(); |
||||
if (top->getType() != VOBJ) |
||||
return false; |
||||
|
||||
expectColon = false; |
||||
break; |
||||
} |
||||
|
||||
case JTOK_COMMA: { |
||||
if (!stack.size() || expectName || expectColon || |
||||
(last_tok == JTOK_COMMA) || (last_tok == JTOK_ARR_OPEN)) |
||||
return false; |
||||
|
||||
UniValue *top = stack.back(); |
||||
if (top->getType() == VOBJ) |
||||
expectName = true; |
||||
break; |
||||
} |
||||
|
||||
case JTOK_KW_NULL: |
||||
case JTOK_KW_TRUE: |
||||
case JTOK_KW_FALSE: { |
||||
if (!stack.size() || expectName || expectColon) |
||||
return false; |
||||
|
||||
UniValue tmpVal; |
||||
switch (tok) { |
||||
case JTOK_KW_NULL: |
||||
// do nothing more
|
||||
break; |
||||
case JTOK_KW_TRUE: |
||||
tmpVal.setBool(true); |
||||
break; |
||||
case JTOK_KW_FALSE: |
||||
tmpVal.setBool(false); |
||||
break; |
||||
default: /* impossible */ break; |
||||
} |
||||
|
||||
UniValue *top = stack.back(); |
||||
top->values.push_back(tmpVal); |
||||
|
||||
break; |
||||
} |
||||
|
||||
case JTOK_NUMBER: { |
||||
if (!stack.size() || expectName || expectColon) |
||||
return false; |
||||
|
||||
UniValue tmpVal(VNUM, tokenVal); |
||||
UniValue *top = stack.back(); |
||||
top->values.push_back(tmpVal); |
||||
|
||||
break; |
||||
} |
||||
|
||||
case JTOK_STRING: { |
||||
if (!stack.size()) |
||||
return false; |
||||
|
||||
UniValue *top = stack.back(); |
||||
|
||||
if (expectName) { |
||||
top->keys.push_back(tokenVal); |
||||
expectName = false; |
||||
expectColon = true; |
||||
} else { |
||||
UniValue tmpVal(VSTR, tokenVal); |
||||
top->values.push_back(tmpVal); |
||||
} |
||||
|
||||
break; |
||||
} |
||||
|
||||
default: |
||||
return false; |
||||
} |
||||
} while (!stack.empty ()); |
||||
|
||||
/* Check that nothing follows the initial construct (parsed above). */ |
||||
tok = getJsonToken(tokenVal, consumed, raw); |
||||
if (tok != JTOK_NONE) |
||||
return false; |
||||
|
||||
return true; |
||||
} |
||||
|
@ -1,127 +0,0 @@
@@ -1,127 +0,0 @@
|
||||
// Copyright 2014 BitPay Inc.
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include <ctype.h> |
||||
#include <iomanip> |
||||
#include <sstream> |
||||
#include <stdio.h> |
||||
#include "univalue.h" |
||||
#include "univalue_escapes.h" |
||||
|
||||
// TODO: Using UTF8
|
||||
|
||||
using namespace std; |
||||
|
||||
static string json_escape(const string& inS) |
||||
{ |
||||
string outS; |
||||
outS.reserve(inS.size() * 2); |
||||
|
||||
for (unsigned int i = 0; i < inS.size(); i++) { |
||||
unsigned char ch = inS[i]; |
||||
const char *escStr = escapes[ch]; |
||||
|
||||
if (escStr) |
||||
outS += escStr; |
||||
|
||||
else if (isprint(ch)) |
||||
outS += ch; |
||||
|
||||
else { |
||||
char tmpesc[16]; |
||||
sprintf(tmpesc, "\\u%04x", ch); |
||||
outS += tmpesc; |
||||
} |
||||
} |
||||
|
||||
return outS; |
||||
} |
||||
|
||||
string UniValue::write(unsigned int prettyIndent, |
||||
unsigned int indentLevel) const |
||||
{ |
||||
string s; |
||||
s.reserve(1024); |
||||
|
||||
unsigned int modIndent = indentLevel; |
||||
if (modIndent == 0) |
||||
modIndent = 1; |
||||
|
||||
switch (typ) { |
||||
case VNULL: |
||||
s += "null"; |
||||
break; |
||||
case VOBJ: |
||||
writeObject(prettyIndent, modIndent, s); |
||||
break; |
||||
case VARR: |
||||
writeArray(prettyIndent, modIndent, s); |
||||
break; |
||||
case VSTR: |
||||
s += "\"" + json_escape(val) + "\""; |
||||
break; |
||||
case VNUM: |
||||
s += val; |
||||
break; |
||||
case VBOOL: |
||||
s += (val == "1" ? "true" : "false"); |
||||
break; |
||||
} |
||||
|
||||
return s; |
||||
} |
||||
|
||||
static void indentStr(unsigned int prettyIndent, unsigned int indentLevel, string& s) |
||||
{ |
||||
s.append(prettyIndent * indentLevel, ' '); |
||||
} |
||||
|
||||
void UniValue::writeArray(unsigned int prettyIndent, unsigned int indentLevel, string& s) const |
||||
{ |
||||
s += "["; |
||||
if (prettyIndent) |
||||
s += "\n"; |
||||
|
||||
for (unsigned int i = 0; i < values.size(); i++) { |
||||
if (prettyIndent) |
||||
indentStr(prettyIndent, indentLevel, s); |
||||
s += values[i].write(prettyIndent, indentLevel + 1); |
||||
if (i != (values.size() - 1)) { |
||||
s += ","; |
||||
if (prettyIndent) |
||||
s += " "; |
||||
} |
||||
if (prettyIndent) |
||||
s += "\n"; |
||||
} |
||||
|
||||
if (prettyIndent) |
||||
indentStr(prettyIndent, indentLevel - 1, s); |
||||
s += "]"; |
||||
} |
||||
|
||||
void UniValue::writeObject(unsigned int prettyIndent, unsigned int indentLevel, string& s) const |
||||
{ |
||||
s += "{"; |
||||
if (prettyIndent) |
||||
s += "\n"; |
||||
|
||||
for (unsigned int i = 0; i < keys.size(); i++) { |
||||
if (prettyIndent) |
||||
indentStr(prettyIndent, indentLevel, s); |
||||
s += "\"" + json_escape(keys[i]) + "\":"; |
||||
if (prettyIndent) |
||||
s += " "; |
||||
s += values[i].write(prettyIndent, indentLevel + 1); |
||||
if (i != (values.size() - 1)) |
||||
s += ","; |
||||
if (prettyIndent) |
||||
s += "\n"; |
||||
} |
||||
|
||||
if (prettyIndent) |
||||
indentStr(prettyIndent, indentLevel - 1, s); |
||||
s += "}"; |
||||
} |
||||
|
Loading…
Reference in new issue