├── .gitignore ├── CMakeLists.txt ├── LICENSE.txt ├── Makefile ├── README.md ├── json11.cpp ├── json11.hpp ├── json11.pc.in └── test.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | # generated files 2 | test 3 | libjson11.a 4 | json11.pc 5 | 6 | # Cmake 7 | CMakeCache.txt 8 | CTestTestfile.cmake 9 | CMakeFiles 10 | CMakeScripts 11 | cmake_install.cmake 12 | install_manifest.txt -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8) 2 | if (CMAKE_VERSION VERSION_LESS "3") 3 | project(json11 CXX) 4 | else() 5 | cmake_policy(SET CMP0048 NEW) 6 | project(json11 VERSION 1.0.0 LANGUAGES CXX) 7 | endif() 8 | 9 | enable_testing() 10 | 11 | option(JSON11_BUILD_TESTS "Build unit tests" OFF) 12 | option(JSON11_ENABLE_DR1467_CANARY "Enable canary test for DR 1467" OFF) 13 | 14 | if(CMAKE_VERSION VERSION_LESS "3") 15 | add_definitions(-std=c++11) 16 | else() 17 | set(CMAKE_CXX_STANDARD 11) 18 | set(CMAKE_CXX_STANDARD_REQUIRED ON) 19 | endif() 20 | 21 | if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) 22 | set(CMAKE_INSTALL_PREFIX /usr) 23 | endif() 24 | 25 | add_library(json11 json11.cpp) 26 | target_include_directories(json11 PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) 27 | target_compile_options(json11 28 | PRIVATE -fPIC -fno-rtti -fno-exceptions -Wall) 29 | 30 | # Set warning flags, which may vary per platform 31 | include(CheckCXXCompilerFlag) 32 | set(_possible_warnings_flags /W4 /WX -Wextra -Werror) 33 | foreach(_warning_flag ${_possible_warnings_flags}) 34 | unset(_flag_supported) 35 | CHECK_CXX_COMPILER_FLAG(${_warning_flag} _flag_supported) 36 | if(${_flag_supported}) 37 | target_compile_options(json11 PRIVATE ${_warning_flag}) 38 | endif() 39 | endforeach() 40 | 41 | configure_file("json11.pc.in" "json11.pc" @ONLY) 42 | 43 | if (JSON11_BUILD_TESTS) 44 | 45 | # enable test for DR1467, described here: https://llvm.org/bugs/show_bug.cgi?id=23812 46 | if(JSON11_ENABLE_DR1467_CANARY) 47 | add_definitions(-D JSON11_ENABLE_DR1467_CANARY=1) 48 | else() 49 | add_definitions(-D JSON11_ENABLE_DR1467_CANARY=0) 50 | endif() 51 | 52 | add_executable(json11_test test.cpp) 53 | target_link_libraries(json11_test json11) 54 | endif() 55 | 56 | install(TARGETS json11 DESTINATION lib/${CMAKE_LIBRARY_ARCHITECTURE}) 57 | install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/json11.hpp" DESTINATION include/${CMAKE_LIBRARY_ARCHITECTURE}) 58 | install(FILES "${CMAKE_CURRENT_BINARY_DIR}/json11.pc" DESTINATION lib/${CMAKE_LIBRARY_ARCHITECTURE}/pkgconfig) 59 | -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 2013 Dropbox, Inc. 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy 4 | of this software and associated documentation files (the "Software"), to deal 5 | in the Software without restriction, including without limitation the rights 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 | copies of the Software, and to permit persons to whom the Software is 8 | furnished to do so, subject to the following conditions: 9 | 10 | The above copyright notice and this permission notice shall be included in 11 | all copies or substantial portions of the Software. 12 | 13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 19 | THE SOFTWARE. 20 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | # Environment variable to enable or disable code which demonstrates the behavior change 2 | # in Xcode 7 / Clang 3.7, introduced by DR1467 and described here: 3 | # https://llvm.org/bugs/show_bug.cgi?id=23812 4 | # Defaults to on in order to act as a warning to anyone who's unaware of the issue. 5 | ifneq ($(JSON11_ENABLE_DR1467_CANARY),) 6 | CANARY_ARGS = -DJSON11_ENABLE_DR1467_CANARY=$(JSON11_ENABLE_DR1467_CANARY) 7 | endif 8 | 9 | test: json11.cpp json11.hpp test.cpp 10 | $(CXX) $(CANARY_ARGS) -O -std=c++11 json11.cpp test.cpp -o test -fno-rtti -fno-exceptions 11 | 12 | clean: 13 | if [ -e test ]; then rm test; fi 14 | 15 | .PHONY: clean 16 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | json11 2 | ------ 3 | 4 | json11 is a tiny JSON library for C++11, providing JSON parsing and serialization. 5 | 6 | The core object provided by the library is json11::Json. A Json object represents any JSON 7 | value: null, bool, number (int or double), string (std::string), array (std::vector), or 8 | object (std::map). 9 | 10 | Json objects act like values. They can be assigned, copied, moved, compared for equality or 11 | order, and so on. There are also helper methods Json::dump, to serialize a Json to a string, and 12 | Json::parse (static) to parse a std::string as a Json object. 13 | 14 | It's easy to make a JSON object with C++11's new initializer syntax: 15 | 16 | Json my_json = Json::object { 17 | { "key1", "value1" }, 18 | { "key2", false }, 19 | { "key3", Json::array { 1, 2, 3 } }, 20 | }; 21 | std::string json_str = my_json.dump(); 22 | 23 | There are also implicit constructors that allow standard and user-defined types to be 24 | automatically converted to JSON. For example: 25 | 26 | class Point { 27 | public: 28 | int x; 29 | int y; 30 | Point (int x, int y) : x(x), y(y) {} 31 | Json to_json() const { return Json::array { x, y }; } 32 | }; 33 | 34 | std::vector points = { { 1, 2 }, { 10, 20 }, { 100, 200 } }; 35 | std::string points_json = Json(points).dump(); 36 | 37 | JSON values can have their values queried and inspected: 38 | 39 | Json json = Json::array { Json::object { { "k", "v" } } }; 40 | std::string str = json[0]["k"].string_value(); 41 | 42 | For more documentation see json11.hpp. 43 | -------------------------------------------------------------------------------- /json11.cpp: -------------------------------------------------------------------------------- 1 | /* Copyright (c) 2013 Dropbox, Inc. 2 | * 3 | * Permission is hereby granted, free of charge, to any person obtaining a copy 4 | * of this software and associated documentation files (the "Software"), to deal 5 | * in the Software without restriction, including without limitation the rights 6 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 | * copies of the Software, and to permit persons to whom the Software is 8 | * furnished to do so, subject to the following conditions: 9 | * 10 | * The above copyright notice and this permission notice shall be included in 11 | * all copies or substantial portions of the Software. 12 | * 13 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 19 | * THE SOFTWARE. 20 | */ 21 | 22 | #include "json11.hpp" 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | 29 | namespace json11 { 30 | 31 | static const int max_depth = 200; 32 | 33 | using std::string; 34 | using std::vector; 35 | using std::map; 36 | using std::make_shared; 37 | using std::initializer_list; 38 | using std::move; 39 | 40 | /* Helper for representing null - just a do-nothing struct, plus comparison 41 | * operators so the helpers in JsonValue work. We can't use nullptr_t because 42 | * it may not be orderable. 43 | */ 44 | struct NullStruct { 45 | bool operator==(NullStruct) const { return true; } 46 | bool operator<(NullStruct) const { return false; } 47 | }; 48 | 49 | /* * * * * * * * * * * * * * * * * * * * 50 | * Serialization 51 | */ 52 | 53 | static void dump(NullStruct, string &out) { 54 | out += "null"; 55 | } 56 | 57 | static void dump(double value, string &out) { 58 | if (std::isfinite(value)) { 59 | char buf[32]; 60 | snprintf(buf, sizeof buf, "%.17g", value); 61 | out += buf; 62 | } else { 63 | out += "null"; 64 | } 65 | } 66 | 67 | static void dump(int value, string &out) { 68 | char buf[32]; 69 | snprintf(buf, sizeof buf, "%d", value); 70 | out += buf; 71 | } 72 | 73 | static void dump(bool value, string &out) { 74 | out += value ? "true" : "false"; 75 | } 76 | 77 | static void dump(const string &value, string &out) { 78 | out += '"'; 79 | for (size_t i = 0; i < value.length(); i++) { 80 | const char ch = value[i]; 81 | if (ch == '\\') { 82 | out += "\\\\"; 83 | } else if (ch == '"') { 84 | out += "\\\""; 85 | } else if (ch == '\b') { 86 | out += "\\b"; 87 | } else if (ch == '\f') { 88 | out += "\\f"; 89 | } else if (ch == '\n') { 90 | out += "\\n"; 91 | } else if (ch == '\r') { 92 | out += "\\r"; 93 | } else if (ch == '\t') { 94 | out += "\\t"; 95 | } else if (static_cast(ch) <= 0x1f) { 96 | char buf[8]; 97 | snprintf(buf, sizeof buf, "\\u%04x", ch); 98 | out += buf; 99 | } else if (static_cast(ch) == 0xe2 && static_cast(value[i+1]) == 0x80 100 | && static_cast(value[i+2]) == 0xa8) { 101 | out += "\\u2028"; 102 | i += 2; 103 | } else if (static_cast(ch) == 0xe2 && static_cast(value[i+1]) == 0x80 104 | && static_cast(value[i+2]) == 0xa9) { 105 | out += "\\u2029"; 106 | i += 2; 107 | } else { 108 | out += ch; 109 | } 110 | } 111 | out += '"'; 112 | } 113 | 114 | static void dump(const Json::array &values, string &out) { 115 | bool first = true; 116 | out += "["; 117 | for (const auto &value : values) { 118 | if (!first) 119 | out += ", "; 120 | value.dump(out); 121 | first = false; 122 | } 123 | out += "]"; 124 | } 125 | 126 | static void dump(const Json::object &values, string &out) { 127 | bool first = true; 128 | out += "{"; 129 | for (const auto &kv : values) { 130 | if (!first) 131 | out += ", "; 132 | dump(kv.first, out); 133 | out += ": "; 134 | kv.second.dump(out); 135 | first = false; 136 | } 137 | out += "}"; 138 | } 139 | 140 | void Json::dump(string &out) const { 141 | m_ptr->dump(out); 142 | } 143 | 144 | /* * * * * * * * * * * * * * * * * * * * 145 | * Value wrappers 146 | */ 147 | 148 | template 149 | class Value : public JsonValue { 150 | protected: 151 | 152 | // Constructors 153 | explicit Value(const T &value) : m_value(value) {} 154 | explicit Value(T &&value) : m_value(move(value)) {} 155 | 156 | // Get type tag 157 | Json::Type type() const override { 158 | return tag; 159 | } 160 | 161 | // Comparisons 162 | bool equals(const JsonValue * other) const override { 163 | return m_value == static_cast *>(other)->m_value; 164 | } 165 | bool less(const JsonValue * other) const override { 166 | return m_value < static_cast *>(other)->m_value; 167 | } 168 | 169 | const T m_value; 170 | void dump(string &out) const override { json11::dump(m_value, out); } 171 | }; 172 | 173 | class JsonDouble final : public Value { 174 | double number_value() const override { return m_value; } 175 | int int_value() const override { return static_cast(m_value); } 176 | bool equals(const JsonValue * other) const override { return m_value == other->number_value(); } 177 | bool less(const JsonValue * other) const override { return m_value < other->number_value(); } 178 | public: 179 | explicit JsonDouble(double value) : Value(value) {} 180 | }; 181 | 182 | class JsonInt final : public Value { 183 | double number_value() const override { return m_value; } 184 | int int_value() const override { return m_value; } 185 | bool equals(const JsonValue * other) const override { return m_value == other->number_value(); } 186 | bool less(const JsonValue * other) const override { return m_value < other->number_value(); } 187 | public: 188 | explicit JsonInt(int value) : Value(value) {} 189 | }; 190 | 191 | class JsonBoolean final : public Value { 192 | bool bool_value() const override { return m_value; } 193 | public: 194 | explicit JsonBoolean(bool value) : Value(value) {} 195 | }; 196 | 197 | class JsonString final : public Value { 198 | const string &string_value() const override { return m_value; } 199 | public: 200 | explicit JsonString(const string &value) : Value(value) {} 201 | explicit JsonString(string &&value) : Value(move(value)) {} 202 | }; 203 | 204 | class JsonArray final : public Value { 205 | const Json::array &array_items() const override { return m_value; } 206 | const Json & operator[](size_t i) const override; 207 | public: 208 | explicit JsonArray(const Json::array &value) : Value(value) {} 209 | explicit JsonArray(Json::array &&value) : Value(move(value)) {} 210 | }; 211 | 212 | class JsonObject final : public Value { 213 | const Json::object &object_items() const override { return m_value; } 214 | const Json & operator[](const string &key) const override; 215 | public: 216 | explicit JsonObject(const Json::object &value) : Value(value) {} 217 | explicit JsonObject(Json::object &&value) : Value(move(value)) {} 218 | }; 219 | 220 | class JsonNull final : public Value { 221 | public: 222 | JsonNull() : Value({}) {} 223 | }; 224 | 225 | /* * * * * * * * * * * * * * * * * * * * 226 | * Static globals - static-init-safe 227 | */ 228 | struct Statics { 229 | const std::shared_ptr null = make_shared(); 230 | const std::shared_ptr t = make_shared(true); 231 | const std::shared_ptr f = make_shared(false); 232 | const string empty_string; 233 | const vector empty_vector; 234 | const map empty_map; 235 | Statics() {} 236 | }; 237 | 238 | static const Statics & statics() { 239 | static const Statics s {}; 240 | return s; 241 | } 242 | 243 | static const Json & static_null() { 244 | // This has to be separate, not in Statics, because Json() accesses statics().null. 245 | static const Json json_null; 246 | return json_null; 247 | } 248 | 249 | /* * * * * * * * * * * * * * * * * * * * 250 | * Constructors 251 | */ 252 | 253 | Json::Json() noexcept : m_ptr(statics().null) {} 254 | Json::Json(std::nullptr_t) noexcept : m_ptr(statics().null) {} 255 | Json::Json(double value) : m_ptr(make_shared(value)) {} 256 | Json::Json(int value) : m_ptr(make_shared(value)) {} 257 | Json::Json(bool value) : m_ptr(value ? statics().t : statics().f) {} 258 | Json::Json(const string &value) : m_ptr(make_shared(value)) {} 259 | Json::Json(string &&value) : m_ptr(make_shared(move(value))) {} 260 | Json::Json(const char * value) : m_ptr(make_shared(value)) {} 261 | Json::Json(const Json::array &values) : m_ptr(make_shared(values)) {} 262 | Json::Json(Json::array &&values) : m_ptr(make_shared(move(values))) {} 263 | Json::Json(const Json::object &values) : m_ptr(make_shared(values)) {} 264 | Json::Json(Json::object &&values) : m_ptr(make_shared(move(values))) {} 265 | 266 | /* * * * * * * * * * * * * * * * * * * * 267 | * Accessors 268 | */ 269 | 270 | Json::Type Json::type() const { return m_ptr->type(); } 271 | double Json::number_value() const { return m_ptr->number_value(); } 272 | int Json::int_value() const { return m_ptr->int_value(); } 273 | bool Json::bool_value() const { return m_ptr->bool_value(); } 274 | const string & Json::string_value() const { return m_ptr->string_value(); } 275 | const vector & Json::array_items() const { return m_ptr->array_items(); } 276 | const map & Json::object_items() const { return m_ptr->object_items(); } 277 | const Json & Json::operator[] (size_t i) const { return (*m_ptr)[i]; } 278 | const Json & Json::operator[] (const string &key) const { return (*m_ptr)[key]; } 279 | 280 | double JsonValue::number_value() const { return 0; } 281 | int JsonValue::int_value() const { return 0; } 282 | bool JsonValue::bool_value() const { return false; } 283 | const string & JsonValue::string_value() const { return statics().empty_string; } 284 | const vector & JsonValue::array_items() const { return statics().empty_vector; } 285 | const map & JsonValue::object_items() const { return statics().empty_map; } 286 | const Json & JsonValue::operator[] (size_t) const { return static_null(); } 287 | const Json & JsonValue::operator[] (const string &) const { return static_null(); } 288 | 289 | const Json & JsonObject::operator[] (const string &key) const { 290 | auto iter = m_value.find(key); 291 | return (iter == m_value.end()) ? static_null() : iter->second; 292 | } 293 | const Json & JsonArray::operator[] (size_t i) const { 294 | if (i >= m_value.size()) return static_null(); 295 | else return m_value[i]; 296 | } 297 | 298 | /* * * * * * * * * * * * * * * * * * * * 299 | * Comparison 300 | */ 301 | 302 | bool Json::operator== (const Json &other) const { 303 | if (m_ptr == other.m_ptr) 304 | return true; 305 | if (m_ptr->type() != other.m_ptr->type()) 306 | return false; 307 | 308 | return m_ptr->equals(other.m_ptr.get()); 309 | } 310 | 311 | bool Json::operator< (const Json &other) const { 312 | if (m_ptr == other.m_ptr) 313 | return false; 314 | if (m_ptr->type() != other.m_ptr->type()) 315 | return m_ptr->type() < other.m_ptr->type(); 316 | 317 | return m_ptr->less(other.m_ptr.get()); 318 | } 319 | 320 | /* * * * * * * * * * * * * * * * * * * * 321 | * Parsing 322 | */ 323 | 324 | /* esc(c) 325 | * 326 | * Format char c suitable for printing in an error message. 327 | */ 328 | static inline string esc(char c) { 329 | char buf[12]; 330 | if (static_cast(c) >= 0x20 && static_cast(c) <= 0x7f) { 331 | snprintf(buf, sizeof buf, "'%c' (%d)", c, c); 332 | } else { 333 | snprintf(buf, sizeof buf, "(%d)", c); 334 | } 335 | return string(buf); 336 | } 337 | 338 | static inline bool in_range(long x, long lower, long upper) { 339 | return (x >= lower && x <= upper); 340 | } 341 | 342 | namespace { 343 | /* JsonParser 344 | * 345 | * Object that tracks all state of an in-progress parse. 346 | */ 347 | struct JsonParser final { 348 | 349 | /* State 350 | */ 351 | const string &str; 352 | size_t i; 353 | string &err; 354 | bool failed; 355 | const JsonParse strategy; 356 | 357 | /* fail(msg, err_ret = Json()) 358 | * 359 | * Mark this parse as failed. 360 | */ 361 | Json fail(string &&msg) { 362 | return fail(move(msg), Json()); 363 | } 364 | 365 | template 366 | T fail(string &&msg, const T err_ret) { 367 | if (!failed) 368 | err = std::move(msg); 369 | failed = true; 370 | return err_ret; 371 | } 372 | 373 | /* consume_whitespace() 374 | * 375 | * Advance until the current character is non-whitespace. 376 | */ 377 | void consume_whitespace() { 378 | while (str[i] == ' ' || str[i] == '\r' || str[i] == '\n' || str[i] == '\t') 379 | i++; 380 | } 381 | 382 | /* consume_comment() 383 | * 384 | * Advance comments (c-style inline and multiline). 385 | */ 386 | bool consume_comment() { 387 | bool comment_found = false; 388 | if (str[i] == '/') { 389 | i++; 390 | if (i == str.size()) 391 | return fail("unexpected end of input after start of comment", false); 392 | if (str[i] == '/') { // inline comment 393 | i++; 394 | // advance until next line, or end of input 395 | while (i < str.size() && str[i] != '\n') { 396 | i++; 397 | } 398 | comment_found = true; 399 | } 400 | else if (str[i] == '*') { // multiline comment 401 | i++; 402 | if (i > str.size()-2) 403 | return fail("unexpected end of input inside multi-line comment", false); 404 | // advance until closing tokens 405 | while (!(str[i] == '*' && str[i+1] == '/')) { 406 | i++; 407 | if (i > str.size()-2) 408 | return fail( 409 | "unexpected end of input inside multi-line comment", false); 410 | } 411 | i += 2; 412 | comment_found = true; 413 | } 414 | else 415 | return fail("malformed comment", false); 416 | } 417 | return comment_found; 418 | } 419 | 420 | /* consume_garbage() 421 | * 422 | * Advance until the current character is non-whitespace and non-comment. 423 | */ 424 | void consume_garbage() { 425 | consume_whitespace(); 426 | if(strategy == JsonParse::COMMENTS) { 427 | bool comment_found = false; 428 | do { 429 | comment_found = consume_comment(); 430 | if (failed) return; 431 | consume_whitespace(); 432 | } 433 | while(comment_found); 434 | } 435 | } 436 | 437 | /* get_next_token() 438 | * 439 | * Return the next non-whitespace character. If the end of the input is reached, 440 | * flag an error and return 0. 441 | */ 442 | char get_next_token() { 443 | consume_garbage(); 444 | if (failed) return static_cast(0); 445 | if (i == str.size()) 446 | return fail("unexpected end of input", static_cast(0)); 447 | 448 | return str[i++]; 449 | } 450 | 451 | /* encode_utf8(pt, out) 452 | * 453 | * Encode pt as UTF-8 and add it to out. 454 | */ 455 | void encode_utf8(long pt, string & out) { 456 | if (pt < 0) 457 | return; 458 | 459 | if (pt < 0x80) { 460 | out += static_cast(pt); 461 | } else if (pt < 0x800) { 462 | out += static_cast((pt >> 6) | 0xC0); 463 | out += static_cast((pt & 0x3F) | 0x80); 464 | } else if (pt < 0x10000) { 465 | out += static_cast((pt >> 12) | 0xE0); 466 | out += static_cast(((pt >> 6) & 0x3F) | 0x80); 467 | out += static_cast((pt & 0x3F) | 0x80); 468 | } else { 469 | out += static_cast((pt >> 18) | 0xF0); 470 | out += static_cast(((pt >> 12) & 0x3F) | 0x80); 471 | out += static_cast(((pt >> 6) & 0x3F) | 0x80); 472 | out += static_cast((pt & 0x3F) | 0x80); 473 | } 474 | } 475 | 476 | /* parse_string() 477 | * 478 | * Parse a string, starting at the current position. 479 | */ 480 | string parse_string() { 481 | string out; 482 | long last_escaped_codepoint = -1; 483 | while (true) { 484 | if (i == str.size()) 485 | return fail("unexpected end of input in string", ""); 486 | 487 | char ch = str[i++]; 488 | 489 | if (ch == '"') { 490 | encode_utf8(last_escaped_codepoint, out); 491 | return out; 492 | } 493 | 494 | if (in_range(ch, 0, 0x1f)) 495 | return fail("unescaped " + esc(ch) + " in string", ""); 496 | 497 | // The usual case: non-escaped characters 498 | if (ch != '\\') { 499 | encode_utf8(last_escaped_codepoint, out); 500 | last_escaped_codepoint = -1; 501 | out += ch; 502 | continue; 503 | } 504 | 505 | // Handle escapes 506 | if (i == str.size()) 507 | return fail("unexpected end of input in string", ""); 508 | 509 | ch = str[i++]; 510 | 511 | if (ch == 'u') { 512 | // Extract 4-byte escape sequence 513 | string esc = str.substr(i, 4); 514 | // Explicitly check length of the substring. The following loop 515 | // relies on std::string returning the terminating NUL when 516 | // accessing str[length]. Checking here reduces brittleness. 517 | if (esc.length() < 4) { 518 | return fail("bad \\u escape: " + esc, ""); 519 | } 520 | for (size_t j = 0; j < 4; j++) { 521 | if (!in_range(esc[j], 'a', 'f') && !in_range(esc[j], 'A', 'F') 522 | && !in_range(esc[j], '0', '9')) 523 | return fail("bad \\u escape: " + esc, ""); 524 | } 525 | 526 | long codepoint = strtol(esc.data(), nullptr, 16); 527 | 528 | // JSON specifies that characters outside the BMP shall be encoded as a pair 529 | // of 4-hex-digit \u escapes encoding their surrogate pair components. Check 530 | // whether we're in the middle of such a beast: the previous codepoint was an 531 | // escaped lead (high) surrogate, and this is a trail (low) surrogate. 532 | if (in_range(last_escaped_codepoint, 0xD800, 0xDBFF) 533 | && in_range(codepoint, 0xDC00, 0xDFFF)) { 534 | // Reassemble the two surrogate pairs into one astral-plane character, per 535 | // the UTF-16 algorithm. 536 | encode_utf8((((last_escaped_codepoint - 0xD800) << 10) 537 | | (codepoint - 0xDC00)) + 0x10000, out); 538 | last_escaped_codepoint = -1; 539 | } else { 540 | encode_utf8(last_escaped_codepoint, out); 541 | last_escaped_codepoint = codepoint; 542 | } 543 | 544 | i += 4; 545 | continue; 546 | } 547 | 548 | encode_utf8(last_escaped_codepoint, out); 549 | last_escaped_codepoint = -1; 550 | 551 | if (ch == 'b') { 552 | out += '\b'; 553 | } else if (ch == 'f') { 554 | out += '\f'; 555 | } else if (ch == 'n') { 556 | out += '\n'; 557 | } else if (ch == 'r') { 558 | out += '\r'; 559 | } else if (ch == 't') { 560 | out += '\t'; 561 | } else if (ch == '"' || ch == '\\' || ch == '/') { 562 | out += ch; 563 | } else { 564 | return fail("invalid escape character " + esc(ch), ""); 565 | } 566 | } 567 | } 568 | 569 | /* parse_number() 570 | * 571 | * Parse a double. 572 | */ 573 | Json parse_number() { 574 | size_t start_pos = i; 575 | 576 | if (str[i] == '-') 577 | i++; 578 | 579 | // Integer part 580 | if (str[i] == '0') { 581 | i++; 582 | if (in_range(str[i], '0', '9')) 583 | return fail("leading 0s not permitted in numbers"); 584 | } else if (in_range(str[i], '1', '9')) { 585 | i++; 586 | while (in_range(str[i], '0', '9')) 587 | i++; 588 | } else { 589 | return fail("invalid " + esc(str[i]) + " in number"); 590 | } 591 | 592 | if (str[i] != '.' && str[i] != 'e' && str[i] != 'E' 593 | && (i - start_pos) <= static_cast(std::numeric_limits::digits10)) { 594 | return std::atoi(str.c_str() + start_pos); 595 | } 596 | 597 | // Decimal part 598 | if (str[i] == '.') { 599 | i++; 600 | if (!in_range(str[i], '0', '9')) 601 | return fail("at least one digit required in fractional part"); 602 | 603 | while (in_range(str[i], '0', '9')) 604 | i++; 605 | } 606 | 607 | // Exponent part 608 | if (str[i] == 'e' || str[i] == 'E') { 609 | i++; 610 | 611 | if (str[i] == '+' || str[i] == '-') 612 | i++; 613 | 614 | if (!in_range(str[i], '0', '9')) 615 | return fail("at least one digit required in exponent"); 616 | 617 | while (in_range(str[i], '0', '9')) 618 | i++; 619 | } 620 | 621 | return std::strtod(str.c_str() + start_pos, nullptr); 622 | } 623 | 624 | /* expect(str, res) 625 | * 626 | * Expect that 'str' starts at the character that was just read. If it does, advance 627 | * the input and return res. If not, flag an error. 628 | */ 629 | Json expect(const string &expected, Json res) { 630 | assert(i != 0); 631 | i--; 632 | if (str.compare(i, expected.length(), expected) == 0) { 633 | i += expected.length(); 634 | return res; 635 | } else { 636 | return fail("parse error: expected " + expected + ", got " + str.substr(i, expected.length())); 637 | } 638 | } 639 | 640 | /* parse_json() 641 | * 642 | * Parse a JSON object. 643 | */ 644 | Json parse_json(int depth) { 645 | if (depth > max_depth) { 646 | return fail("exceeded maximum nesting depth"); 647 | } 648 | 649 | char ch = get_next_token(); 650 | if (failed) 651 | return Json(); 652 | 653 | if (ch == '-' || (ch >= '0' && ch <= '9')) { 654 | i--; 655 | return parse_number(); 656 | } 657 | 658 | if (ch == 't') 659 | return expect("true", true); 660 | 661 | if (ch == 'f') 662 | return expect("false", false); 663 | 664 | if (ch == 'n') 665 | return expect("null", Json()); 666 | 667 | if (ch == '"') 668 | return parse_string(); 669 | 670 | if (ch == '{') { 671 | map data; 672 | ch = get_next_token(); 673 | if (ch == '}') 674 | return data; 675 | 676 | while (1) { 677 | if (ch != '"') 678 | return fail("expected '\"' in object, got " + esc(ch)); 679 | 680 | string key = parse_string(); 681 | if (failed) 682 | return Json(); 683 | 684 | ch = get_next_token(); 685 | if (ch != ':') 686 | return fail("expected ':' in object, got " + esc(ch)); 687 | 688 | data[std::move(key)] = parse_json(depth + 1); 689 | if (failed) 690 | return Json(); 691 | 692 | ch = get_next_token(); 693 | if (ch == '}') 694 | break; 695 | if (ch != ',') 696 | return fail("expected ',' in object, got " + esc(ch)); 697 | 698 | ch = get_next_token(); 699 | } 700 | return data; 701 | } 702 | 703 | if (ch == '[') { 704 | vector data; 705 | ch = get_next_token(); 706 | if (ch == ']') 707 | return data; 708 | 709 | while (1) { 710 | i--; 711 | data.push_back(parse_json(depth + 1)); 712 | if (failed) 713 | return Json(); 714 | 715 | ch = get_next_token(); 716 | if (ch == ']') 717 | break; 718 | if (ch != ',') 719 | return fail("expected ',' in list, got " + esc(ch)); 720 | 721 | ch = get_next_token(); 722 | (void)ch; 723 | } 724 | return data; 725 | } 726 | 727 | return fail("expected value, got " + esc(ch)); 728 | } 729 | }; 730 | }//namespace { 731 | 732 | Json Json::parse(const string &in, string &err, JsonParse strategy) { 733 | JsonParser parser { in, 0, err, false, strategy }; 734 | Json result = parser.parse_json(0); 735 | 736 | // Check for any trailing garbage 737 | parser.consume_garbage(); 738 | if (parser.failed) 739 | return Json(); 740 | if (parser.i != in.size()) 741 | return parser.fail("unexpected trailing " + esc(in[parser.i])); 742 | 743 | return result; 744 | } 745 | 746 | // Documented in json11.hpp 747 | vector Json::parse_multi(const string &in, 748 | std::string::size_type &parser_stop_pos, 749 | string &err, 750 | JsonParse strategy) { 751 | JsonParser parser { in, 0, err, false, strategy }; 752 | parser_stop_pos = 0; 753 | vector json_vec; 754 | while (parser.i != in.size() && !parser.failed) { 755 | json_vec.push_back(parser.parse_json(0)); 756 | if (parser.failed) 757 | break; 758 | 759 | // Check for another object 760 | parser.consume_garbage(); 761 | if (parser.failed) 762 | break; 763 | parser_stop_pos = parser.i; 764 | } 765 | return json_vec; 766 | } 767 | 768 | /* * * * * * * * * * * * * * * * * * * * 769 | * Shape-checking 770 | */ 771 | 772 | bool Json::has_shape(const shape & types, string & err) const { 773 | if (!is_object()) { 774 | err = "expected JSON object, got " + dump(); 775 | return false; 776 | } 777 | 778 | const auto& obj_items = object_items(); 779 | for (auto & item : types) { 780 | const auto it = obj_items.find(item.first); 781 | if (it == obj_items.cend() || it->second.type() != item.second) { 782 | err = "bad type for " + item.first + " in " + dump(); 783 | return false; 784 | } 785 | } 786 | 787 | return true; 788 | } 789 | 790 | } // namespace json11 791 | -------------------------------------------------------------------------------- /json11.hpp: -------------------------------------------------------------------------------- 1 | /* json11 2 | * 3 | * json11 is a tiny JSON library for C++11, providing JSON parsing and serialization. 4 | * 5 | * The core object provided by the library is json11::Json. A Json object represents any JSON 6 | * value: null, bool, number (int or double), string (std::string), array (std::vector), or 7 | * object (std::map). 8 | * 9 | * Json objects act like values: they can be assigned, copied, moved, compared for equality or 10 | * order, etc. There are also helper methods Json::dump, to serialize a Json to a string, and 11 | * Json::parse (static) to parse a std::string as a Json object. 12 | * 13 | * Internally, the various types of Json object are represented by the JsonValue class 14 | * hierarchy. 15 | * 16 | * A note on numbers - JSON specifies the syntax of number formatting but not its semantics, 17 | * so some JSON implementations distinguish between integers and floating-point numbers, while 18 | * some don't. In json11, we choose the latter. Because some JSON implementations (namely 19 | * Javascript itself) treat all numbers as the same type, distinguishing the two leads 20 | * to JSON that will be *silently* changed by a round-trip through those implementations. 21 | * Dangerous! To avoid that risk, json11 stores all numbers as double internally, but also 22 | * provides integer helpers. 23 | * 24 | * Fortunately, double-precision IEEE754 ('double') can precisely store any integer in the 25 | * range +/-2^53, which includes every 'int' on most systems. (Timestamps often use int64 26 | * or long long to avoid the Y2038K problem; a double storing microseconds since some epoch 27 | * will be exact for +/- 275 years.) 28 | */ 29 | 30 | /* Copyright (c) 2013 Dropbox, Inc. 31 | * 32 | * Permission is hereby granted, free of charge, to any person obtaining a copy 33 | * of this software and associated documentation files (the "Software"), to deal 34 | * in the Software without restriction, including without limitation the rights 35 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 36 | * copies of the Software, and to permit persons to whom the Software is 37 | * furnished to do so, subject to the following conditions: 38 | * 39 | * The above copyright notice and this permission notice shall be included in 40 | * all copies or substantial portions of the Software. 41 | * 42 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 43 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 44 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 45 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 46 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 47 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 48 | * THE SOFTWARE. 49 | */ 50 | 51 | #pragma once 52 | 53 | #include 54 | #include 55 | #include 56 | #include 57 | #include 58 | 59 | #ifdef _MSC_VER 60 | #if _MSC_VER <= 1800 // VS 2013 61 | #ifndef noexcept 62 | #define noexcept throw() 63 | #endif 64 | 65 | #ifndef snprintf 66 | #define snprintf _snprintf_s 67 | #endif 68 | #endif 69 | #endif 70 | 71 | namespace json11 { 72 | 73 | enum JsonParse { 74 | STANDARD, COMMENTS 75 | }; 76 | 77 | class JsonValue; 78 | 79 | class Json final { 80 | public: 81 | // Types 82 | enum Type { 83 | NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT 84 | }; 85 | 86 | // Array and object typedefs 87 | typedef std::vector array; 88 | typedef std::map object; 89 | 90 | // Constructors for the various types of JSON value. 91 | Json() noexcept; // NUL 92 | Json(std::nullptr_t) noexcept; // NUL 93 | Json(double value); // NUMBER 94 | Json(int value); // NUMBER 95 | Json(bool value); // BOOL 96 | Json(const std::string &value); // STRING 97 | Json(std::string &&value); // STRING 98 | Json(const char * value); // STRING 99 | Json(const array &values); // ARRAY 100 | Json(array &&values); // ARRAY 101 | Json(const object &values); // OBJECT 102 | Json(object &&values); // OBJECT 103 | 104 | // Implicit constructor: anything with a to_json() function. 105 | template 106 | Json(const T & t) : Json(t.to_json()) {} 107 | 108 | // Implicit constructor: map-like objects (std::map, std::unordered_map, etc) 109 | template ().begin()->first)>::value 111 | && std::is_constructible().begin()->second)>::value, 112 | int>::type = 0> 113 | Json(const M & m) : Json(object(m.begin(), m.end())) {} 114 | 115 | // Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc) 116 | template ().begin())>::value, 118 | int>::type = 0> 119 | Json(const V & v) : Json(array(v.begin(), v.end())) {} 120 | 121 | // This prevents Json(some_pointer) from accidentally producing a bool. Use 122 | // Json(bool(some_pointer)) if that behavior is desired. 123 | Json(void *) = delete; 124 | 125 | // Accessors 126 | Type type() const; 127 | 128 | bool is_null() const { return type() == NUL; } 129 | bool is_number() const { return type() == NUMBER; } 130 | bool is_bool() const { return type() == BOOL; } 131 | bool is_string() const { return type() == STRING; } 132 | bool is_array() const { return type() == ARRAY; } 133 | bool is_object() const { return type() == OBJECT; } 134 | 135 | // Return the enclosed value if this is a number, 0 otherwise. Note that json11 does not 136 | // distinguish between integer and non-integer numbers - number_value() and int_value() 137 | // can both be applied to a NUMBER-typed object. 138 | double number_value() const; 139 | int int_value() const; 140 | 141 | // Return the enclosed value if this is a boolean, false otherwise. 142 | bool bool_value() const; 143 | // Return the enclosed string if this is a string, "" otherwise. 144 | const std::string &string_value() const; 145 | // Return the enclosed std::vector if this is an array, or an empty vector otherwise. 146 | const array &array_items() const; 147 | // Return the enclosed std::map if this is an object, or an empty map otherwise. 148 | const object &object_items() const; 149 | 150 | // Return a reference to arr[i] if this is an array, Json() otherwise. 151 | const Json & operator[](size_t i) const; 152 | // Return a reference to obj[key] if this is an object, Json() otherwise. 153 | const Json & operator[](const std::string &key) const; 154 | 155 | // Serialize. 156 | void dump(std::string &out) const; 157 | std::string dump() const { 158 | std::string out; 159 | dump(out); 160 | return out; 161 | } 162 | 163 | // Parse. If parse fails, return Json() and assign an error message to err. 164 | static Json parse(const std::string & in, 165 | std::string & err, 166 | JsonParse strategy = JsonParse::STANDARD); 167 | static Json parse(const char * in, 168 | std::string & err, 169 | JsonParse strategy = JsonParse::STANDARD) { 170 | if (in) { 171 | return parse(std::string(in), err, strategy); 172 | } else { 173 | err = "null input"; 174 | return nullptr; 175 | } 176 | } 177 | // Parse multiple objects, concatenated or separated by whitespace 178 | static std::vector parse_multi( 179 | const std::string & in, 180 | std::string::size_type & parser_stop_pos, 181 | std::string & err, 182 | JsonParse strategy = JsonParse::STANDARD); 183 | 184 | static inline std::vector parse_multi( 185 | const std::string & in, 186 | std::string & err, 187 | JsonParse strategy = JsonParse::STANDARD) { 188 | std::string::size_type parser_stop_pos; 189 | return parse_multi(in, parser_stop_pos, err, strategy); 190 | } 191 | 192 | bool operator== (const Json &rhs) const; 193 | bool operator< (const Json &rhs) const; 194 | bool operator!= (const Json &rhs) const { return !(*this == rhs); } 195 | bool operator<= (const Json &rhs) const { return !(rhs < *this); } 196 | bool operator> (const Json &rhs) const { return (rhs < *this); } 197 | bool operator>= (const Json &rhs) const { return !(*this < rhs); } 198 | 199 | /* has_shape(types, err) 200 | * 201 | * Return true if this is a JSON object and, for each item in types, has a field of 202 | * the given type. If not, return false and set err to a descriptive message. 203 | */ 204 | typedef std::initializer_list> shape; 205 | bool has_shape(const shape & types, std::string & err) const; 206 | 207 | private: 208 | std::shared_ptr m_ptr; 209 | }; 210 | 211 | // Internal class hierarchy - JsonValue objects are not exposed to users of this API. 212 | class JsonValue { 213 | protected: 214 | friend class Json; 215 | friend class JsonInt; 216 | friend class JsonDouble; 217 | virtual Json::Type type() const = 0; 218 | virtual bool equals(const JsonValue * other) const = 0; 219 | virtual bool less(const JsonValue * other) const = 0; 220 | virtual void dump(std::string &out) const = 0; 221 | virtual double number_value() const; 222 | virtual int int_value() const; 223 | virtual bool bool_value() const; 224 | virtual const std::string &string_value() const; 225 | virtual const Json::array &array_items() const; 226 | virtual const Json &operator[](size_t i) const; 227 | virtual const Json::object &object_items() const; 228 | virtual const Json &operator[](const std::string &key) const; 229 | virtual ~JsonValue() {} 230 | }; 231 | 232 | } // namespace json11 233 | -------------------------------------------------------------------------------- /json11.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@CMAKE_INSTALL_PREFIX@ 2 | libdir=${prefix}/lib/@CMAKE_LIBRARY_ARCHITECTURE@ 3 | includedir=${prefix}/include/@CMAKE_LIBRARY_ARCHITECTURE@ 4 | 5 | Name: @PROJECT_NAME@ 6 | Description: json11 is a tiny JSON library for C++11, providing JSON parsing and serialization. 7 | Version: @PROJECT_VERSION@ 8 | Libs: -L${libdir} -ljson11 9 | Cflags: -I${includedir} 10 | -------------------------------------------------------------------------------- /test.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Define JSON11_TEST_CUSTOM_CONFIG to 1 if you want to build this tester into 3 | * your own unit-test framework rather than a stand-alone program. By setting 4 | * The values of the variables included below, you can insert your own custom 5 | * code into this file as it builds, in order to make it into a test case for 6 | * your favorite framework. 7 | */ 8 | #if !JSON11_TEST_CUSTOM_CONFIG 9 | #define JSON11_TEST_CPP_PREFIX_CODE 10 | #define JSON11_TEST_CPP_SUFFIX_CODE 11 | #define JSON11_TEST_STANDALONE_MAIN 1 12 | #define JSON11_TEST_CASE(name) static void name() 13 | #define JSON11_TEST_ASSERT(b) assert(b) 14 | #ifdef NDEBUG 15 | #undef NDEBUG//at now assert will work even in Release build 16 | #endif 17 | #endif // JSON11_TEST_CUSTOM_CONFIG 18 | 19 | /* 20 | * Enable or disable code which demonstrates the behavior change in Xcode 7 / Clang 3.7, 21 | * introduced by DR1467 and described here: https://github.com/dropbox/json11/issues/86 22 | * Defaults to off since it doesn't appear the standards committee is likely to act 23 | * on this, so it needs to be considered normal behavior. 24 | */ 25 | #ifndef JSON11_ENABLE_DR1467_CANARY 26 | #define JSON11_ENABLE_DR1467_CANARY 0 27 | #endif 28 | 29 | /* 30 | * Beginning of standard source file, which makes use of the customizations above. 31 | */ 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include "json11.hpp" 39 | #include 40 | #include 41 | #include 42 | #include 43 | #include 44 | 45 | // Insert user-defined prefix code (includes, function declarations, etc) 46 | // to set up a custom test suite 47 | JSON11_TEST_CPP_PREFIX_CODE 48 | 49 | using namespace json11; 50 | using std::string; 51 | 52 | // Check that Json has the properties we want. 53 | #define CHECK_TRAIT(x) static_assert(std::x::value, #x) 54 | CHECK_TRAIT(is_nothrow_constructible); 55 | CHECK_TRAIT(is_nothrow_default_constructible); 56 | CHECK_TRAIT(is_copy_constructible); 57 | CHECK_TRAIT(is_nothrow_move_constructible); 58 | CHECK_TRAIT(is_copy_assignable); 59 | CHECK_TRAIT(is_nothrow_move_assignable); 60 | CHECK_TRAIT(is_nothrow_destructible); 61 | 62 | JSON11_TEST_CASE(json11_test) { 63 | const string simple_test = 64 | R"({"k1":"v1", "k2":42, "k3":["a",123,true,false,null]})"; 65 | 66 | string err; 67 | const auto json = Json::parse(simple_test, err); 68 | 69 | std::cout << "k1: " << json["k1"].string_value() << "\n"; 70 | std::cout << "k3: " << json["k3"].dump() << "\n"; 71 | 72 | for (auto &k : json["k3"].array_items()) { 73 | std::cout << " - " << k.dump() << "\n"; 74 | } 75 | 76 | string comment_test = R"({ 77 | // comment /* with nested comment */ 78 | "a": 1, 79 | // comment 80 | // continued 81 | "b": "text", 82 | /* multi 83 | line 84 | comment 85 | // line-comment-inside-multiline-comment 86 | */ 87 | // and single-line comment 88 | // and single-line comment /* multiline inside single line */ 89 | "c": [1, 2, 3] 90 | // and single-line comment at end of object 91 | })"; 92 | 93 | string err_comment; 94 | auto json_comment = Json::parse( 95 | comment_test, err_comment, JsonParse::COMMENTS); 96 | JSON11_TEST_ASSERT(!json_comment.is_null()); 97 | JSON11_TEST_ASSERT(err_comment.empty()); 98 | 99 | comment_test = "{\"a\": 1}//trailing line comment"; 100 | json_comment = Json::parse( 101 | comment_test, err_comment, JsonParse::COMMENTS); 102 | JSON11_TEST_ASSERT(!json_comment.is_null()); 103 | JSON11_TEST_ASSERT(err_comment.empty()); 104 | 105 | comment_test = "{\"a\": 1}/*trailing multi-line comment*/"; 106 | json_comment = Json::parse( 107 | comment_test, err_comment, JsonParse::COMMENTS); 108 | JSON11_TEST_ASSERT(!json_comment.is_null()); 109 | JSON11_TEST_ASSERT(err_comment.empty()); 110 | 111 | string failing_comment_test = "{\n/* unterminated comment\n\"a\": 1,\n}"; 112 | string err_failing_comment; 113 | auto json_failing_comment = Json::parse( 114 | failing_comment_test, err_failing_comment, JsonParse::COMMENTS); 115 | JSON11_TEST_ASSERT(json_failing_comment.is_null()); 116 | JSON11_TEST_ASSERT(!err_failing_comment.empty()); 117 | 118 | failing_comment_test = "{\n/* unterminated trailing comment }"; 119 | json_failing_comment = Json::parse( 120 | failing_comment_test, err_failing_comment, JsonParse::COMMENTS); 121 | JSON11_TEST_ASSERT(json_failing_comment.is_null()); 122 | JSON11_TEST_ASSERT(!err_failing_comment.empty()); 123 | 124 | failing_comment_test = "{\n/ / bad comment }"; 125 | json_failing_comment = Json::parse( 126 | failing_comment_test, err_failing_comment, JsonParse::COMMENTS); 127 | JSON11_TEST_ASSERT(json_failing_comment.is_null()); 128 | JSON11_TEST_ASSERT(!err_failing_comment.empty()); 129 | 130 | failing_comment_test = "{// bad comment }"; 131 | json_failing_comment = Json::parse( 132 | failing_comment_test, err_failing_comment, JsonParse::COMMENTS); 133 | JSON11_TEST_ASSERT(json_failing_comment.is_null()); 134 | JSON11_TEST_ASSERT(!err_failing_comment.empty()); 135 | 136 | failing_comment_test = "{\n\"a\": 1\n}/"; 137 | json_failing_comment = Json::parse( 138 | failing_comment_test, err_failing_comment, JsonParse::COMMENTS); 139 | JSON11_TEST_ASSERT(json_failing_comment.is_null()); 140 | JSON11_TEST_ASSERT(!err_failing_comment.empty()); 141 | 142 | failing_comment_test = "{/* bad\ncomment *}"; 143 | json_failing_comment = Json::parse( 144 | failing_comment_test, err_failing_comment, JsonParse::COMMENTS); 145 | JSON11_TEST_ASSERT(json_failing_comment.is_null()); 146 | JSON11_TEST_ASSERT(!err_failing_comment.empty()); 147 | 148 | std::list l1 { 1, 2, 3 }; 149 | std::vector l2 { 1, 2, 3 }; 150 | std::set l3 { 1, 2, 3 }; 151 | JSON11_TEST_ASSERT(Json(l1) == Json(l2)); 152 | JSON11_TEST_ASSERT(Json(l2) == Json(l3)); 153 | 154 | std::map m1 { { "k1", "v1" }, { "k2", "v2" } }; 155 | std::unordered_map m2 { { "k1", "v1" }, { "k2", "v2" } }; 156 | JSON11_TEST_ASSERT(Json(m1) == Json(m2)); 157 | 158 | // Json literals 159 | const Json obj = Json::object({ 160 | { "k1", "v1" }, 161 | { "k2", 42.0 }, 162 | { "k3", Json::array({ "a", 123.0, true, false, nullptr }) }, 163 | }); 164 | 165 | std::cout << "obj: " << obj.dump() << "\n"; 166 | JSON11_TEST_ASSERT(obj.dump() == "{\"k1\": \"v1\", \"k2\": 42, \"k3\": [\"a\", 123, true, false, null]}"); 167 | 168 | JSON11_TEST_ASSERT(Json("a").number_value() == 0); 169 | JSON11_TEST_ASSERT(Json("a").string_value() == "a"); 170 | JSON11_TEST_ASSERT(Json().number_value() == 0); 171 | 172 | JSON11_TEST_ASSERT(obj == json); 173 | JSON11_TEST_ASSERT(Json(42) == Json(42.0)); 174 | JSON11_TEST_ASSERT(Json(42) != Json(42.1)); 175 | 176 | const string unicode_escape_test = 177 | R"([ "blah\ud83d\udca9blah\ud83dblah\udca9blah\u0000blah\u1234" ])"; 178 | 179 | const char utf8[] = "blah" "\xf0\x9f\x92\xa9" "blah" "\xed\xa0\xbd" "blah" 180 | "\xed\xb2\xa9" "blah" "\0" "blah" "\xe1\x88\xb4"; 181 | 182 | Json uni = Json::parse(unicode_escape_test, err); 183 | JSON11_TEST_ASSERT(uni[0].string_value().size() == (sizeof utf8) - 1); 184 | JSON11_TEST_ASSERT(std::memcmp(uni[0].string_value().data(), utf8, sizeof utf8) == 0); 185 | 186 | // Demonstrates the behavior change in Xcode 7 / Clang 3.7, introduced by DR1467 187 | // and described here: https://llvm.org/bugs/show_bug.cgi?id=23812 188 | if (JSON11_ENABLE_DR1467_CANARY) { 189 | Json nested_array = Json::array { Json::array { 1, 2, 3 } }; 190 | JSON11_TEST_ASSERT(nested_array.is_array()); 191 | JSON11_TEST_ASSERT(nested_array.array_items().size() == 1); 192 | JSON11_TEST_ASSERT(nested_array.array_items()[0].is_array()); 193 | JSON11_TEST_ASSERT(nested_array.array_items()[0].array_items().size() == 3); 194 | } 195 | 196 | { 197 | const std::string good_json = R"( {"k1" : "v1"})"; 198 | const std::string bad_json1 = good_json + " {"; 199 | const std::string bad_json2 = good_json + R"({"k2":"v2", "k3":[)"; 200 | struct TestMultiParse { 201 | std::string input; 202 | std::string::size_type expect_parser_stop_pos; 203 | size_t expect_not_empty_elms_count; 204 | Json expect_parse_res; 205 | } tests[] = { 206 | {" {", 0, 0, {}}, 207 | {good_json, good_json.size(), 1, Json(std::map{ { "k1", "v1" } })}, 208 | {bad_json1, good_json.size() + 1, 1, Json(std::map{ { "k1", "v1" } })}, 209 | {bad_json2, good_json.size(), 1, Json(std::map{ { "k1", "v1" } })}, 210 | {"{}", 2, 1, Json::object{}}, 211 | }; 212 | for (const auto &tst : tests) { 213 | std::string::size_type parser_stop_pos; 214 | std::string err; 215 | auto res = Json::parse_multi(tst.input, parser_stop_pos, err); 216 | JSON11_TEST_ASSERT(parser_stop_pos == tst.expect_parser_stop_pos); 217 | JSON11_TEST_ASSERT( 218 | (size_t)std::count_if(res.begin(), res.end(), 219 | [](const Json& j) { return !j.is_null(); }) 220 | == tst.expect_not_empty_elms_count); 221 | if (!res.empty()) { 222 | JSON11_TEST_ASSERT(tst.expect_parse_res == res[0]); 223 | } 224 | } 225 | } 226 | 227 | Json my_json = Json::object { 228 | { "key1", "value1" }, 229 | { "key2", false }, 230 | { "key3", Json::array { 1, 2, 3 } }, 231 | }; 232 | std::string json_obj_str = my_json.dump(); 233 | std::cout << "json_obj_str: " << json_obj_str << "\n"; 234 | JSON11_TEST_ASSERT(json_obj_str == "{\"key1\": \"value1\", \"key2\": false, \"key3\": [1, 2, 3]}"); 235 | 236 | class Point { 237 | public: 238 | int x; 239 | int y; 240 | Point (int x, int y) : x(x), y(y) {} 241 | Json to_json() const { return Json::array { x, y }; } 242 | }; 243 | 244 | std::vector points = { { 1, 2 }, { 10, 20 }, { 100, 200 } }; 245 | std::string points_json = Json(points).dump(); 246 | std::cout << "points_json: " << points_json << "\n"; 247 | JSON11_TEST_ASSERT(points_json == "[[1, 2], [10, 20], [100, 200]]"); 248 | 249 | JSON11_TEST_ASSERT(((Json)(Json::object { { "foo", nullptr } })).has_shape({ { "foo", Json::NUL } }, err) == true); 250 | JSON11_TEST_ASSERT(((Json)(Json::object { { "foo", 1234567 } })).has_shape({ { "foo", Json::NUL } }, err) == false); 251 | JSON11_TEST_ASSERT(((Json)(Json::object { { "bar", 1234567 } })).has_shape({ { "foo", Json::NUL } }, err) == false); 252 | 253 | } 254 | 255 | #if JSON11_TEST_STANDALONE_MAIN 256 | 257 | static void parse_from_stdin() { 258 | string buf; 259 | string line; 260 | while (std::getline(std::cin, line)) { 261 | buf += line + "\n"; 262 | } 263 | 264 | string err; 265 | auto json = Json::parse(buf, err); 266 | if (!err.empty()) { 267 | printf("Failed: %s\n", err.c_str()); 268 | } else { 269 | printf("Result: %s\n", json.dump().c_str()); 270 | } 271 | } 272 | 273 | int main(int argc, char **argv) { 274 | if (argc == 2 && argv[1] == string("--stdin")) { 275 | parse_from_stdin(); 276 | return 0; 277 | } 278 | 279 | json11_test(); 280 | } 281 | 282 | #endif // JSON11_TEST_STANDALONE_MAIN 283 | 284 | // Insert user-defined suffix code (function definitions, etc) 285 | // to set up a custom test suite 286 | JSON11_TEST_CPP_SUFFIX_CODE 287 | --------------------------------------------------------------------------------