Unverified Commit 5c201e48 authored by Guolin Ke's avatar Guolin Ke Committed by GitHub
Browse files

fix cpp lint in json11 (#2975)



* indent and constructor

* fix more

* fix long
Co-authored-by: default avatarStrikerRUS <nekit94-12@hotmail.com>
parent 08be1e97
......@@ -21,55 +21,55 @@
/* json11
*
* json11 is a tiny JSON library for C++11, providing JSON parsing and serialization.
* json11 is a tiny JSON library for C++11, providing JSON parsing and
* serialization.
*
* The core object provided by the library is json11::Json. A Json object represents any JSON
* value: null, bool, number (int or double), string (std::string), array (std::vector), or
* object (std::map).
* The core object provided by the library is json11::Json. A Json object
* represents any JSON value: null, bool, number (int or double), string
* (std::string), array (std::vector), or object (std::map).
*
* Json objects act like values: they can be assigned, copied, moved, compared for equality or
* order, etc. There are also helper methods Json::dump, to serialize a Json to a string, and
* Json::parse (static) to parse a std::string as a Json object.
* Json objects act like values: they can be assigned, copied, moved, compared
* for equality or order, etc. There are also helper methods Json::dump, to
* serialize a Json to a string, and Json::parse (static) to parse a std::string
* as a Json object.
*
* Internally, the various types of Json object are represented by the JsonValue class
* hierarchy.
* Internally, the various types of Json object are represented by the JsonValue
* class hierarchy.
*
* A note on numbers - JSON specifies the syntax of number formatting but not its semantics,
* so some JSON implementations distinguish between integers and floating-point numbers, while
* some don't. In json11, we choose the latter. Because some JSON implementations (namely
* Javascript itself) treat all numbers as the same type, distinguishing the two leads
* to JSON that will be *silently* changed by a round-trip through those implementations.
* Dangerous! To avoid that risk, json11 stores all numbers as double internally, but also
* A note on numbers - JSON specifies the syntax of number formatting but not
* its semantics, so some JSON implementations distinguish between integers and
* floating-point numbers, while some don't. In json11, we choose the latter.
* Because some JSON implementations (namely Javascript itself) treat all
* numbers as the same type, distinguishing the two leads to JSON that will be
* *silently* changed by a round-trip through those implementations. Dangerous!
* To avoid that risk, json11 stores all numbers as double internally, but also
* provides integer helpers.
*
* Fortunately, double-precision IEEE754 ('double') can precisely store any integer in the
* range +/-2^53, which includes every 'int' on most systems. (Timestamps often use int64
* or long long to avoid the Y2038K problem; a double storing microseconds since some epoch
* will be exact for +/- 275 years.)
* Fortunately, double-precision IEEE754 ('double') can precisely store any
* integer in the range +/-2^53, which includes every 'int' on most systems.
* (Timestamps often use int64 or long long to avoid the Y2038K problem; a
* double storing microseconds since some epoch will be exact for +/- 275
* years.)
*/
#pragma once
#include <string>
#include <initializer_list>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
namespace json11 {
enum JsonParse {
STANDARD, COMMENTS
};
enum JsonParse { STANDARD, COMMENTS };
class JsonValue;
class Json final {
public:
// Types
enum Type {
NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT
};
enum Type { NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT };
// Array and object typedefs
typedef std::vector<Json> array;
......@@ -77,38 +77,44 @@ class Json final {
// Constructors for the various types of JSON value.
Json() noexcept; // NUL
Json(std::nullptr_t) noexcept; // NUL
Json(double value); // NUMBER
Json(int value); // NUMBER
Json(bool value); // BOOL
Json(const std::string &value); // STRING
Json(std::string &&value); // STRING
Json(const char * value); // STRING
Json(const array &values); // ARRAY
Json(array &&values); // ARRAY
Json(const object &values); // OBJECT
Json(object &&values); // OBJECT
explicit Json(std::nullptr_t) noexcept; // NUL
explicit Json(double value); // NUMBER
explicit Json(int value); // NUMBER
explicit Json(bool value); // BOOL
explicit Json(const std::string &value); // STRING
explicit Json(std::string &&value); // STRING
explicit Json(const char *value); // STRING
explicit Json(const array &values); // ARRAY
explicit Json(array &&values); // ARRAY
explicit Json(const object &values); // OBJECT
explicit Json(object &&values); // OBJECT
// Implicit constructor: anything with a to_json() function.
template <class T, class = decltype(&T::to_json)>
Json(const T & t) : Json(t.to_json()) {}
explicit Json(const T &t) : Json(t.to_json()) {}
// Implicit constructor: map-like objects (std::map, std::unordered_map, etc)
template <class M, typename std::enable_if<
std::is_constructible<std::string, decltype(std::declval<M>().begin()->first)>::value
&& std::is_constructible<Json, decltype(std::declval<M>().begin()->second)>::value,
template <
class M,
typename std::enable_if<
std::is_constructible<
std::string, decltype(std::declval<M>().begin()->first)>::value &&
std::is_constructible<
Json, decltype(std::declval<M>().begin()->second)>::value,
int>::type = 0>
Json(const M & m) : Json(object(m.begin(), m.end())) {}
explicit Json(const M &m) : Json(object(m.begin(), m.end())) {}
// Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc)
// Implicit constructor: vector-like objects (std::list, std::vector,
// std::set, etc)
template <class V, typename std::enable_if<
std::is_constructible<Json, decltype(*std::declval<V>().begin())>::value,
std::is_constructible<
Json, decltype(*std::declval<V>().begin())>::value,
int>::type = 0>
Json(const V & v) : Json(array(v.begin(), v.end())) {}
explicit Json(const V &v) : Json(array(v.begin(), v.end())) {}
// This prevents Json(some_pointer) from accidentally producing a bool. Use
// Json(bool(some_pointer)) if that behavior is desired.
Json(void *) = delete;
explicit Json(void *) = delete;
// Accessors
Type type() const;
......@@ -120,9 +126,10 @@ class Json final {
bool is_array() const { return type() == ARRAY; }
bool is_object() const { return type() == OBJECT; }
// Return the enclosed value if this is a number, 0 otherwise. Note that json11 does not
// distinguish between integer and non-integer numbers - number_value() and int_value()
// can both be applied to a NUMBER-typed object.
// Return the enclosed value if this is a number, 0 otherwise. Note that
// json11 does not distinguish between integer and non-integer numbers -
// number_value() and int_value() can both be applied to a NUMBER-typed
// object.
double number_value() const;
int int_value() const;
......@@ -130,82 +137,81 @@ class Json final {
bool bool_value() const;
// Return the enclosed string if this is a string, "" otherwise.
const std::string &string_value() const;
// Return the enclosed std::vector if this is an array, or an empty vector otherwise.
// Return the enclosed std::vector if this is an array, or an empty vector
// otherwise.
const array &array_items() const;
// Return the enclosed std::map if this is an object, or an empty map otherwise.
// Return the enclosed std::map if this is an object, or an empty map
// otherwise.
const object &object_items() const;
// Return a reference to arr[i] if this is an array, Json() otherwise.
const Json & operator[](size_t i) const;
const Json &operator[](size_t i) const;
// Return a reference to obj[key] if this is an object, Json() otherwise.
const Json & operator[](const std::string &key) const;
const Json &operator[](const std::string &key) const;
// Serialize.
void dump(std::string &out) const;
void dump(std::string *out) const;
std::string dump() const {
std::string out;
dump(out);
dump(&out);
return out;
}
// Parse. If parse fails, return Json() and assign an error message to err.
static Json parse(const std::string & in,
std::string & err,
static Json parse(const std::string &in, std::string *err,
JsonParse strategy = JsonParse::STANDARD);
static Json parse(const char * in,
std::string & err,
static Json parse(const char *in, std::string *err,
JsonParse strategy = JsonParse::STANDARD) {
if (in) {
return parse(std::string(in), err, strategy);
} else {
err = "null input";
return nullptr;
*err = "null input";
return Json(nullptr);
}
}
// Parse multiple objects, concatenated or separated by whitespace
static std::vector<Json> parse_multi(
const std::string & in,
std::string::size_type & parser_stop_pos,
std::string & err,
JsonParse strategy = JsonParse::STANDARD);
const std::string &in, std::string::size_type *parser_stop_pos,
std::string *err, JsonParse strategy = JsonParse::STANDARD);
static inline std::vector<Json> parse_multi(
const std::string & in,
std::string & err,
const std::string &in, std::string *err,
JsonParse strategy = JsonParse::STANDARD) {
std::string::size_type parser_stop_pos;
return parse_multi(in, parser_stop_pos, err, strategy);
return parse_multi(in, &parser_stop_pos, err, strategy);
}
bool operator== (const Json &rhs) const;
bool operator< (const Json &rhs) const;
bool operator!= (const Json &rhs) const { return !(*this == rhs); }
bool operator<= (const Json &rhs) const { return !(rhs < *this); }
bool operator> (const Json &rhs) const { return (rhs < *this); }
bool operator>= (const Json &rhs) const { return !(*this < rhs); }
bool operator==(const Json &rhs) const;
bool operator<(const Json &rhs) const;
bool operator!=(const Json &rhs) const { return !(*this == rhs); }
bool operator<=(const Json &rhs) const { return !(rhs < *this); }
bool operator>(const Json &rhs) const { return (rhs < *this); }
bool operator>=(const Json &rhs) const { return !(*this < rhs); }
/* has_shape(types, err)
*
* Return true if this is a JSON object and, for each item in types, has a field of
* the given type. If not, return false and set err to a descriptive message.
* Return true if this is a JSON object and, for each item in types, has a
* field of the given type. If not, return false and set err to a descriptive
* message.
*/
typedef std::initializer_list<std::pair<std::string, Type>> shape;
bool has_shape(const shape & types, std::string & err) const;
bool has_shape(const shape &types, std::string *err) const;
private:
std::shared_ptr<JsonValue> m_ptr;
};
// Internal class hierarchy - JsonValue objects are not exposed to users of this API.
// Internal class hierarchy - JsonValue objects are not exposed to users of this
// API.
class JsonValue {
protected:
friend class Json;
friend class JsonInt;
friend class JsonDouble;
virtual Json::Type type() const = 0;
virtual bool equals(const JsonValue * other) const = 0;
virtual bool less(const JsonValue * other) const = 0;
virtual void dump(std::string &out) const = 0;
virtual bool equals(const JsonValue *other) const = 0;
virtual bool less(const JsonValue *other) const = 0;
virtual void dump(std::string *out) const = 0;
virtual double number_value() const;
virtual int int_value() const;
virtual bool bool_value() const;
......
......@@ -64,7 +64,7 @@ void GBDT::Init(const Config* config, const Dataset* train_data, const Objective
std::stringstream buffer;
buffer << forced_splits_file.rdbuf();
std::string err;
forced_splits_json_ = Json::parse(buffer.str(), err);
forced_splits_json_ = Json::parse(buffer.str(), &err);
}
objective_function_ = objective_function;
......@@ -725,7 +725,7 @@ void GBDT::ResetConfig(const Config* config) {
std::stringstream buffer;
buffer << forced_splits_file.rdbuf();
std::string err;
forced_splits_json_ = Json::parse(buffer.str(), err);
forced_splits_json_ = Json::parse(buffer.str(), &err);
tree_learner_->SetForcedSplit(&forced_splits_json_);
} else {
forced_splits_json_ = Json();
......
......@@ -1208,7 +1208,7 @@ std::vector<std::vector<double>> DatasetLoader::GetForcedBins(std::string forced
std::stringstream buffer;
buffer << forced_bins_stream.rdbuf();
std::string err;
Json forced_bins_json = Json::parse(buffer.str(), err);
Json forced_bins_json = Json::parse(buffer.str(), &err);
CHECK(forced_bins_json.is_array());
std::vector<Json> forced_bins_arr = forced_bins_json.array_items();
for (size_t i = 0; i < forced_bins_arr.size(); ++i) {
......
......@@ -31,12 +31,12 @@ namespace json11 {
static const int max_depth = 200;
using std::string;
using std::vector;
using std::map;
using std::make_shared;
using std::initializer_list;
using std::make_shared;
using std::map;
using std::move;
using std::string;
using std::vector;
using LightGBM::Log;
......@@ -53,96 +53,90 @@ struct NullStruct {
* Serialization
*/
static void dump(NullStruct, string &out) {
out += "null";
}
static void dump(NullStruct, string *out) { *out += "null"; }
static void dump(double value, string &out) {
static void dump(double value, string *out) {
if (std::isfinite(value)) {
char buf[32];
snprintf(buf, sizeof buf, "%.17g", value);
out += buf;
*out += buf;
} else {
out += "null";
*out += "null";
}
}
static void dump(int value, string &out) {
static void dump(int value, string *out) {
char buf[32];
snprintf(buf, sizeof buf, "%d", value);
out += buf;
*out += buf;
}
static void dump(bool value, string &out) {
out += value ? "true" : "false";
}
static void dump(bool value, string *out) { *out += value ? "true" : "false"; }
static void dump(const string &value, string &out) {
out += '"';
static void dump(const string &value, string *out) {
*out += '"';
for (size_t i = 0; i < value.length(); i++) {
const char ch = value[i];
if (ch == '\\') {
out += "\\\\";
*out += "\\\\";
} else if (ch == '"') {
out += "\\\"";
*out += "\\\"";
} else if (ch == '\b') {
out += "\\b";
*out += "\\b";
} else if (ch == '\f') {
out += "\\f";
*out += "\\f";
} else if (ch == '\n') {
out += "\\n";
*out += "\\n";
} else if (ch == '\r') {
out += "\\r";
*out += "\\r";
} else if (ch == '\t') {
out += "\\t";
*out += "\\t";
} else if (static_cast<uint8_t>(ch) <= 0x1f) {
char buf[8];
snprintf(buf, sizeof buf, "\\u%04x", ch);
out += buf;
} else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1]) == 0x80
&& static_cast<uint8_t>(value[i+2]) == 0xa8) {
out += "\\u2028";
*out += buf;
} else if (static_cast<uint8_t>(ch) == 0xe2 &&
static_cast<uint8_t>(value[i + 1]) == 0x80 &&
static_cast<uint8_t>(value[i + 2]) == 0xa8) {
*out += "\\u2028";
i += 2;
} else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1]) == 0x80
&& static_cast<uint8_t>(value[i+2]) == 0xa9) {
out += "\\u2029";
} else if (static_cast<uint8_t>(ch) == 0xe2 &&
static_cast<uint8_t>(value[i + 1]) == 0x80 &&
static_cast<uint8_t>(value[i + 2]) == 0xa9) {
*out += "\\u2029";
i += 2;
} else {
out += ch;
*out += ch;
}
}
out += '"';
*out += '"';
}
static void dump(const Json::array &values, string &out) {
static void dump(const Json::array &values, string *out) {
bool first = true;
out += "[";
*out += "[";
for (const auto &value : values) {
if (!first)
out += ", ";
if (!first) *out += ", ";
value.dump(out);
first = false;
}
out += "]";
*out += "]";
}
static void dump(const Json::object &values, string &out) {
static void dump(const Json::object &values, string *out) {
bool first = true;
out += "{";
*out += "{";
for (const auto &kv : values) {
if (!first)
out += ", ";
if (!first) *out += ", ";
dump(kv.first, out);
out += ": ";
*out += ": ";
kv.second.dump(out);
first = false;
}
out += "}";
*out += "}";
}
void Json::dump(string &out) const {
m_ptr->dump(out);
}
void Json::dump(string *out) const { m_ptr->dump(out); }
/* * * * * * * * * * * * * * * * * * * *
* Value wrappers
......@@ -156,27 +150,30 @@ class Value : public JsonValue {
explicit Value(T &&value) : m_value(move(value)) {}
// Get type tag
Json::Type type() const override {
return tag;
}
Json::Type type() const override { return tag; }
// Comparisons
bool equals(const JsonValue * other) const override {
bool equals(const JsonValue *other) const override {
return m_value == static_cast<const Value<tag, T> *>(other)->m_value;
}
bool less(const JsonValue * other) const override {
bool less(const JsonValue *other) const override {
return m_value < (static_cast<const Value<tag, T> *>(other)->m_value);
}
const T m_value;
void dump(string &out) const override { json11::dump(m_value, out); }
void dump(string *out) const override { json11::dump(m_value, out); }
};
class JsonDouble final : public Value<Json::NUMBER, double> {
double number_value() const override { return m_value; }
int int_value() const override { return static_cast<int>(m_value); }
bool equals(const JsonValue * other) const override { return m_value == other->number_value(); }
bool less(const JsonValue * other) const override { return m_value < other->number_value(); }
bool equals(const JsonValue *other) const override {
return m_value == other->number_value();
}
bool less(const JsonValue *other) const override {
return m_value < other->number_value();
}
public:
explicit JsonDouble(double value) : Value(value) {}
};
......@@ -184,20 +181,27 @@ class JsonDouble final : public Value<Json::NUMBER, double> {
class JsonInt final : public Value<Json::NUMBER, int> {
double number_value() const override { return m_value; }
int int_value() const override { return m_value; }
bool equals(const JsonValue * other) const override { return m_value == other->number_value(); }
bool less(const JsonValue * other) const override { return m_value < other->number_value(); }
bool equals(const JsonValue *other) const override {
return m_value == other->number_value();
}
bool less(const JsonValue *other) const override {
return m_value < other->number_value();
}
public:
explicit JsonInt(int value) : Value(value) {}
};
class JsonBoolean final : public Value<Json::BOOL, bool> {
bool bool_value() const override { return m_value; }
public:
explicit JsonBoolean(bool value) : Value(value) {}
};
class JsonString final : public Value<Json::STRING, string> {
const string &string_value() const override { return m_value; }
public:
explicit JsonString(const string &value) : Value(value) {}
explicit JsonString(string &&value) : Value(move(value)) {}
......@@ -205,7 +209,8 @@ class JsonString final : public Value<Json::STRING, string> {
class JsonArray final : public Value<Json::ARRAY, Json::array> {
const Json::array &array_items() const override { return m_value; }
const Json & operator[](size_t i) const override;
const Json &operator[](size_t i) const override;
public:
explicit JsonArray(const Json::array &value) : Value(value) {}
explicit JsonArray(Json::array &&value) : Value(move(value)) {}
......@@ -213,7 +218,8 @@ class JsonArray final : public Value<Json::ARRAY, Json::array> {
class JsonObject final : public Value<Json::OBJECT, Json::object> {
const Json::object &object_items() const override { return m_value; }
const Json & operator[](const string &key) const override;
const Json &operator[](const string &key) const override;
public:
explicit JsonObject(const Json::object &value) : Value(value) {}
explicit JsonObject(Json::object &&value) : Value(move(value)) {}
......@@ -237,13 +243,14 @@ struct Statics {
Statics() {}
};
static const Statics & statics() {
static const Statics s {};
static const Statics &statics() {
static const Statics s{};
return s;
}
static const Json & static_null() {
// This has to be separate, not in Statics, because Json() accesses statics().null.
static const Json &static_null() {
// This has to be separate, not in Statics, because Json() accesses
// statics().null.
static const Json json_null;
return json_null;
}
......@@ -259,11 +266,14 @@ Json::Json(int value) : m_ptr(make_shared<JsonInt>(value)) {}
Json::Json(bool value) : m_ptr(value ? statics().t : statics().f) {}
Json::Json(const string &value) : m_ptr(make_shared<JsonString>(value)) {}
Json::Json(string &&value) : m_ptr(make_shared<JsonString>(move(value))) {}
Json::Json(const char * value) : m_ptr(make_shared<JsonString>(value)) {}
Json::Json(const char *value) : m_ptr(make_shared<JsonString>(value)) {}
Json::Json(const Json::array &values) : m_ptr(make_shared<JsonArray>(values)) {}
Json::Json(Json::array &&values) : m_ptr(make_shared<JsonArray>(move(values))) {}
Json::Json(const Json::object &values) : m_ptr(make_shared<JsonObject>(values)) {}
Json::Json(Json::object &&values) : m_ptr(make_shared<JsonObject>(move(values))) {}
Json::Json(Json::array &&values)
: m_ptr(make_shared<JsonArray>(move(values))) {}
Json::Json(const Json::object &values)
: m_ptr(make_shared<JsonObject>(values)) {}
Json::Json(Json::object &&values)
: m_ptr(make_shared<JsonObject>(move(values))) {}
/* * * * * * * * * * * * * * * * * * * *
* Accessors
......@@ -273,26 +283,34 @@ Json::Type Json::type() const { return m_ptr->type();
double Json::number_value() const { return m_ptr->number_value(); }
int Json::int_value() const { return m_ptr->int_value(); }
bool Json::bool_value() const { return m_ptr->bool_value(); }
const string & Json::string_value() const { return m_ptr->string_value(); }
const vector<Json> & Json::array_items() const { return m_ptr->array_items(); }
const map<string, Json> & Json::object_items() const { return m_ptr->object_items(); }
const Json & Json::operator[] (size_t i) const { return (*m_ptr)[i]; }
const Json & Json::operator[] (const string &key) const { return (*m_ptr)[key]; }
const string &Json::string_value() const { return m_ptr->string_value(); }
const vector<Json> &Json::array_items() const { return m_ptr->array_items(); }
const map<string, Json> &Json::object_items() const {
return m_ptr->object_items();
}
const Json &Json::operator[](size_t i) const { return (*m_ptr)[i]; }
const Json &Json::operator[](const string &key) const { return (*m_ptr)[key]; }
double JsonValue::number_value() const { return 0; }
int JsonValue::int_value() const { return 0; }
bool JsonValue::bool_value() const { return false; }
const string & JsonValue::string_value() const { return statics().empty_string; }
const vector<Json> & JsonValue::array_items() const { return statics().empty_vector; }
const map<string, Json> & JsonValue::object_items() const { return statics().empty_map; }
const Json & JsonValue::operator[] (size_t) const { return static_null(); }
const Json & JsonValue::operator[] (const string &) const { return static_null(); }
const string &JsonValue::string_value() const { return statics().empty_string; }
const vector<Json> &JsonValue::array_items() const {
return statics().empty_vector;
}
const map<string, Json> &JsonValue::object_items() const {
return statics().empty_map;
}
const Json &JsonValue::operator[](size_t) const { return static_null(); }
const Json &JsonValue::operator[](const string &) const {
return static_null();
}
const Json & JsonObject::operator[] (const string &key) const {
const Json &JsonObject::operator[](const string &key) const {
auto iter = m_value.find(key);
return (iter == m_value.end()) ? static_null() : iter->second;
}
const Json & JsonArray::operator[] (size_t i) const {
const Json &JsonArray::operator[](size_t i) const {
if (i >= m_value.size())
return static_null();
else
......@@ -303,18 +321,15 @@ const Json & JsonArray::operator[] (size_t i) const {
* Comparison
*/
bool Json::operator== (const Json &other) const {
if (m_ptr == other.m_ptr)
return true;
if (m_ptr->type() != other.m_ptr->type())
return false;
bool Json::operator==(const Json &other) const {
if (m_ptr == other.m_ptr) return true;
if (m_ptr->type() != other.m_ptr->type()) return false;
return m_ptr->equals(other.m_ptr.get());
}
bool Json::operator< (const Json &other) const {
if (m_ptr == other.m_ptr)
return false;
bool Json::operator<(const Json &other) const {
if (m_ptr == other.m_ptr) return false;
if (m_ptr->type() != other.m_ptr->type())
return m_ptr->type() < other.m_ptr->type();
......@@ -339,7 +354,8 @@ static inline string esc(char c) {
return string(buf);
}
static inline bool in_range(long x, long lower, long upper) {
template <typename T>
static inline bool in_range(T x, T lower, T upper) {
return (x >= lower && x <= upper);
}
......@@ -351,10 +367,10 @@ namespace {
struct JsonParser final {
/* State
*/
const char* str;
const char *str;
const size_t str_len;
size_t i;
string &err;
string *err;
bool failed;
const JsonParse strategy;
......@@ -362,14 +378,11 @@ struct JsonParser final {
*
* Mark this parse as failed.
*/
Json fail(string &&msg) {
return fail(move(msg), Json());
}
Json fail(string &&msg) { return fail(move(msg), Json()); }
template <typename T>
T fail(string &&msg, const T err_ret) {
if (!failed)
err = std::move(msg);
if (!failed) *err = std::move(msg);
failed = true;
return err_ret;
}
......@@ -403,12 +416,14 @@ struct JsonParser final {
} else if (str[i] == '*') { // multiline comment
i++;
if (i > str_len - 2)
return fail("Unexpected end of input inside multi-line comment", false);
return fail("Unexpected end of input inside multi-line comment",
false);
// advance until closing tokens
while (!(str[i] == '*' && str[i+1] == '/')) {
while (!(str[i] == '*' && str[i + 1] == '/')) {
i++;
if (i > str_len - 2)
return fail("Unexpected end of input inside multi-line comment", false);
return fail("Unexpected end of input inside multi-line comment",
false);
}
i += 2;
comment_found = true;
......@@ -437,14 +452,13 @@ struct JsonParser final {
/* get_next_token()
*
* Return the next non-whitespace character. If the end of the input is reached,
* flag an error and return 0.
* Return the next non-whitespace character. If the end of the input is
* reached, flag an error and return 0.
*/
char get_next_token() {
consume_garbage();
if (failed) return char{0};
if (i == str_len)
return fail("Unexpected end of input", char{0});
if (i == str_len) return fail("Unexpected end of input", char{0});
return str[i++];
}
......@@ -453,24 +467,23 @@ struct JsonParser final {
*
* Encode pt as UTF-8 and add it to out.
*/
void encode_utf8(long pt, string & out) {
if (pt < 0)
return;
void encode_utf8(int64_t pt, string* out) {
if (pt < 0) return;
if (pt < 0x80) {
out += static_cast<char>(pt);
*out += static_cast<char>(pt);
} else if (pt < 0x800) {
out += static_cast<char>((pt >> 6) | 0xC0);
out += static_cast<char>((pt & 0x3F) | 0x80);
*out += static_cast<char>((pt >> 6) | 0xC0);
*out += static_cast<char>((pt & 0x3F) | 0x80);
} else if (pt < 0x10000) {
out += static_cast<char>((pt >> 12) | 0xE0);
out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
out += static_cast<char>((pt & 0x3F) | 0x80);
*out += static_cast<char>((pt >> 12) | 0xE0);
*out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
*out += static_cast<char>((pt & 0x3F) | 0x80);
} else {
out += static_cast<char>((pt >> 18) | 0xF0);
out += static_cast<char>(((pt >> 12) & 0x3F) | 0x80);
out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
out += static_cast<char>((pt & 0x3F) | 0x80);
*out += static_cast<char>((pt >> 18) | 0xF0);
*out += static_cast<char>(((pt >> 12) & 0x3F) | 0x80);
*out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
*out += static_cast<char>((pt & 0x3F) | 0x80);
}
}
......@@ -480,32 +493,30 @@ struct JsonParser final {
*/
string parse_string() {
string out;
long last_escaped_codepoint = -1;
int64_t last_escaped_codepoint = -1;
while (true) {
if (i == str_len)
return fail("Unexpected end of input in string", "");
if (i == str_len) return fail("Unexpected end of input in string", "");
char ch = str[i++];
if (ch == '"') {
encode_utf8(last_escaped_codepoint, out);
encode_utf8(last_escaped_codepoint, &out);
return out;
}
if (in_range(ch, 0, 0x1f))
if (in_range<int64_t>(ch, 0, 0x1f))
return fail("Unescaped " + esc(ch) + " in string", "");
// The usual case: non-escaped characters
if (ch != '\\') {
encode_utf8(last_escaped_codepoint, out);
encode_utf8(last_escaped_codepoint, &out);
last_escaped_codepoint = -1;
out += ch;
continue;
}
// Handle escapes
if (i == str_len)
return fail("Unexpected end of input in string", "");
if (i == str_len) return fail("Unexpected end of input in string", "");
ch = str[i++];
......@@ -519,26 +530,30 @@ struct JsonParser final {
return fail("Bad \\u escape: " + esc, "");
}
for (size_t j = 0; j < 4; j++) {
if (!in_range(esc[j], 'a', 'f') && !in_range(esc[j], 'A', 'F')
&& !in_range(esc[j], '0', '9'))
if (!in_range(esc[j], 'a', 'f') && !in_range(esc[j], 'A', 'F') &&
!in_range(esc[j], '0', '9'))
return fail("Bad \\u escape: " + esc, "");
}
long codepoint = strtol(esc.data(), nullptr, 16);
// JSON specifies that characters outside the BMP shall be encoded as a pair
// of 4-hex-digit \u escapes encoding their surrogate pair components. Check
// whether we're in the middle of such a beast: the previous codepoint was an
// escaped lead (high) surrogate, and this is a trail (low) surrogate.
if (in_range(last_escaped_codepoint, 0xD800, 0xDBFF)
&& in_range(codepoint, 0xDC00, 0xDFFF)) {
// Reassemble the two surrogate pairs into one astral-plane character, per
// the UTF-16 algorithm.
encode_utf8((((last_escaped_codepoint - 0xD800) << 10)
| (codepoint - 0xDC00)) + 0x10000, out);
int64_t codepoint =
static_cast<int64_t>(strtol(esc.data(), nullptr, 16));
// JSON specifies that characters outside the BMP shall be encoded as a
// pair of 4-hex-digit \u escapes encoding their surrogate pair
// components. Check whether we're in the middle of such a beast: the
// previous codepoint was an escaped lead (high) surrogate, and this is
// a trail (low) surrogate.
if (in_range<int64_t>(last_escaped_codepoint, 0xD800, 0xDBFF) &&
in_range<int64_t>(codepoint, 0xDC00, 0xDFFF)) {
// Reassemble the two surrogate pairs into one astral-plane character,
// per the UTF-16 algorithm.
encode_utf8((((last_escaped_codepoint - 0xD800) << 10) |
(codepoint - 0xDC00)) +
0x10000,
&out);
last_escaped_codepoint = -1;
} else {
encode_utf8(last_escaped_codepoint, out);
encode_utf8(last_escaped_codepoint, &out);
last_escaped_codepoint = codepoint;
}
......@@ -546,7 +561,7 @@ struct JsonParser final {
continue;
}
encode_utf8(last_escaped_codepoint, out);
encode_utf8(last_escaped_codepoint, &out);
last_escaped_codepoint = -1;
if (ch == 'b') {
......@@ -574,8 +589,7 @@ struct JsonParser final {
Json parse_number() {
size_t start_pos = i;
if (str[i] == '-')
i++;
if (str[i] == '-') i++;
// Integer part
if (str[i] == '0') {
......@@ -584,15 +598,15 @@ struct JsonParser final {
return fail("Leading 0s not permitted in numbers");
} else if (in_range(str[i], '1', '9')) {
i++;
while (in_range(str[i], '0', '9'))
i++;
while (in_range(str[i], '0', '9')) i++;
} else {
return fail("Invalid " + esc(str[i]) + " in number");
}
if (str[i] != '.' && str[i] != 'e' && str[i] != 'E'
&& (i - start_pos) <= static_cast<size_t>(std::numeric_limits<int>::digits10)) {
return std::atoi(str + start_pos);
if (str[i] != '.' && str[i] != 'e' && str[i] != 'E' &&
(i - start_pos) <=
static_cast<size_t>(std::numeric_limits<int>::digits10)) {
return Json(std::atoi(str + start_pos));
}
// Decimal part
......@@ -601,31 +615,28 @@ struct JsonParser final {
if (!in_range(str[i], '0', '9'))
return fail("At least one digit required in fractional part");
while (in_range(str[i], '0', '9'))
i++;
while (in_range(str[i], '0', '9')) i++;
}
// Exponent part
if (str[i] == 'e' || str[i] == 'E') {
i++;
if (str[i] == '+' || str[i] == '-')
i++;
if (str[i] == '+' || str[i] == '-') i++;
if (!in_range(str[i], '0', '9'))
return fail("At least one digit required in exponent");
while (in_range(str[i], '0', '9'))
i++;
while (in_range(str[i], '0', '9')) i++;
}
return std::strtod(str + start_pos, nullptr);
return Json(std::strtod(str + start_pos, nullptr));
}
/* expect(str, res)
*
* Expect that 'str' starts at the character that was just read. If it does, advance
* the input and return res. If not, flag an error.
* Expect that 'str' starts at the character that was just read. If it does,
* advance the input and return res. If not, flag an error.
*/
Json expect(const string &expected, Json res) {
CHECK_NE(i, 0)
......@@ -649,81 +660,65 @@ struct JsonParser final {
}
char ch = get_next_token();
if (failed)
return Json();
if (failed) return Json();
if (ch == '-' || (ch >= '0' && ch <= '9')) {
i--;
return parse_number();
}
if (ch == 't')
return expect("true", true);
if (ch == 't') return expect("true", Json(true));
if (ch == 'f')
return expect("false", false);
if (ch == 'f') return expect("false", Json(false));
if (ch == 'n')
return expect("null", Json());
if (ch == 'n') return expect("null", Json());
if (ch == '"')
return parse_string();
if (ch == '"') return Json(parse_string());
if (ch == '{') {
map<string, Json> data;
ch = get_next_token();
if (ch == '}')
return data;
if (ch == '}') return Json(data);
while (1) {
if (ch != '"')
return fail("Expected '\"' in object, got " + esc(ch));
if (ch != '"') return fail("Expected '\"' in object, got " + esc(ch));
string key = parse_string();
if (failed)
return Json();
if (failed) return Json();
ch = get_next_token();
if (ch != ':')
return fail("Expected ':' in object, got " + esc(ch));
if (ch != ':') return fail("Expected ':' in object, got " + esc(ch));
data[std::move(key)] = parse_json(depth + 1);
if (failed)
return Json();
if (failed) return Json();
ch = get_next_token();
if (ch == '}')
break;
if (ch != ',')
return fail("Expected ',' in object, got " + esc(ch));
if (ch == '}') break;
if (ch != ',') return fail("Expected ',' in object, got " + esc(ch));
ch = get_next_token();
}
return data;
return Json(data);
}
if (ch == '[') {
vector<Json> data;
ch = get_next_token();
if (ch == ']')
return data;
if (ch == ']') return Json(data);
while (1) {
i--;
data.push_back(parse_json(depth + 1));
if (failed)
return Json();
if (failed) return Json();
ch = get_next_token();
if (ch == ']')
break;
if (ch != ',')
return fail("Expected ',' in list, got " + esc(ch));
if (ch == ']') break;
if (ch != ',') return fail("Expected ',' in list, got " + esc(ch));
ch = get_next_token();
(void)ch;
}
return data;
return Json(data);
}
return fail("Expected value, got " + esc(ch));
......@@ -731,14 +726,13 @@ struct JsonParser final {
};
} // namespace
Json Json::parse(const string &in, string &err, JsonParse strategy) {
Json Json::parse(const string &in, string *err, JsonParse strategy) {
JsonParser parser{in.c_str(), in.size(), 0, err, false, strategy};
Json result = parser.parse_json(0);
// Check for any trailing garbage
parser.consume_garbage();
if (parser.failed)
return Json();
if (parser.failed) return Json();
if (parser.i != in.size())
return parser.fail("Unexpected trailing " + esc(in[parser.i]));
......@@ -747,22 +741,19 @@ Json Json::parse(const string &in, string &err, JsonParse strategy) {
// Documented in json11.hpp
vector<Json> Json::parse_multi(const string &in,
std::string::size_type &parser_stop_pos,
string &err,
JsonParse strategy) {
std::string::size_type *parser_stop_pos,
string *err, JsonParse strategy) {
JsonParser parser{in.c_str(), in.size(), 0, err, false, strategy};
parser_stop_pos = 0;
*parser_stop_pos = 0;
vector<Json> json_vec;
while (parser.i != in.size() && !parser.failed) {
json_vec.push_back(parser.parse_json(0));
if (parser.failed)
break;
if (parser.failed) break;
// Check for another object
parser.consume_garbage();
if (parser.failed)
break;
parser_stop_pos = parser.i;
if (parser.failed) break;
*parser_stop_pos = parser.i;
}
return json_vec;
}
......@@ -771,15 +762,15 @@ vector<Json> Json::parse_multi(const string &in,
* Shape-checking
*/
bool Json::has_shape(const shape & types, string & err) const {
bool Json::has_shape(const shape &types, string *err) const {
if (!is_object()) {
err = "Expected JSON object, got " + dump();
*err = "Expected JSON object, got " + dump();
return false;
}
for (auto & item : types) {
for (auto &item : types) {
if ((*this)[item.first].type() != item.second) {
err = "Bad type for " + item.first + " in " + dump();
*err = "Bad type for " + item.first + " in " + dump();
return false;
}
}
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment