Mercurial > hg > orthanc-stone
annotate Resources/CodeGeneration/testWasmIntegrated/jsoncpp-1.8.4/jsoncpp.cpp @ 1298:8a0a62189f46
replacing std::auto_ptr by std::unique_ptr
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Mon, 02 Mar 2020 16:31:30 +0100 |
| parents | baa9e1e932db |
| children |
| rev | line source |
|---|---|
| 499 | 1 /// Json-cpp amalgamated source (http://jsoncpp.sourceforge.net/). |
| 2 /// It is intended to be used with #include "json/json.h" | |
| 3 | |
| 4 // ////////////////////////////////////////////////////////////////////// | |
| 5 // Beginning of content of file: LICENSE | |
| 6 // ////////////////////////////////////////////////////////////////////// | |
| 7 | |
| 8 /* | |
| 9 The JsonCpp library's source code, including accompanying documentation, | |
| 10 tests and demonstration applications, are licensed under the following | |
| 11 conditions... | |
| 12 | |
| 13 Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all | |
| 14 jurisdictions which recognize such a disclaimer. In such jurisdictions, | |
| 15 this software is released into the Public Domain. | |
| 16 | |
| 17 In jurisdictions which do not recognize Public Domain property (e.g. Germany as of | |
| 18 2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and | |
| 19 The JsonCpp Authors, and is released under the terms of the MIT License (see below). | |
| 20 | |
| 21 In jurisdictions which recognize Public Domain property, the user of this | |
| 22 software may choose to accept it either as 1) Public Domain, 2) under the | |
| 23 conditions of the MIT License (see below), or 3) under the terms of dual | |
| 24 Public Domain/MIT License conditions described here, as they choose. | |
| 25 | |
| 26 The MIT License is about as close to Public Domain as a license can get, and is | |
| 27 described in clear, concise terms at: | |
| 28 | |
| 29 http://en.wikipedia.org/wiki/MIT_License | |
| 30 | |
| 31 The full text of the MIT License follows: | |
| 32 | |
| 33 ======================================================================== | |
| 34 Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors | |
| 35 | |
| 36 Permission is hereby granted, free of charge, to any person | |
| 37 obtaining a copy of this software and associated documentation | |
| 38 files (the "Software"), to deal in the Software without | |
| 39 restriction, including without limitation the rights to use, copy, | |
| 40 modify, merge, publish, distribute, sublicense, and/or sell copies | |
| 41 of the Software, and to permit persons to whom the Software is | |
| 42 furnished to do so, subject to the following conditions: | |
| 43 | |
| 44 The above copyright notice and this permission notice shall be | |
| 45 included in all copies or substantial portions of the Software. | |
| 46 | |
| 47 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
| 48 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
| 49 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
| 50 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |
| 51 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
| 52 ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
| 53 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
| 54 SOFTWARE. | |
| 55 ======================================================================== | |
| 56 (END LICENSE TEXT) | |
| 57 | |
| 58 The MIT license is compatible with both the GPL and commercial | |
| 59 software, affording one all of the rights of Public Domain with the | |
| 60 minor nuisance of being required to keep the above copyright notice | |
| 61 and license text in the source code. Note also that by accepting the | |
| 62 Public Domain "license" you can re-license your copy using whatever | |
| 63 license you like. | |
| 64 | |
| 65 */ | |
| 66 | |
| 67 // ////////////////////////////////////////////////////////////////////// | |
| 68 // End of content of file: LICENSE | |
| 69 // ////////////////////////////////////////////////////////////////////// | |
| 70 | |
| 71 | |
| 72 | |
| 73 | |
| 74 | |
| 75 | |
| 76 #include "json/json.h" | |
| 77 | |
| 78 #ifndef JSON_IS_AMALGAMATION | |
| 79 #error "Compile with -I PATH_TO_JSON_DIRECTORY" | |
| 80 #endif | |
| 81 | |
| 82 | |
| 83 // ////////////////////////////////////////////////////////////////////// | |
| 84 // Beginning of content of file: src/lib_json/json_tool.h | |
| 85 // ////////////////////////////////////////////////////////////////////// | |
| 86 | |
| 87 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors | |
| 88 // Distributed under MIT license, or public domain if desired and | |
| 89 // recognized in your jurisdiction. | |
| 90 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE | |
| 91 | |
| 92 #ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED | |
| 93 #define LIB_JSONCPP_JSON_TOOL_H_INCLUDED | |
| 94 | |
| 95 #if !defined(JSON_IS_AMALGAMATION) | |
| 96 #include <json/config.h> | |
| 97 #endif | |
| 98 | |
| 99 // Also support old flag NO_LOCALE_SUPPORT | |
| 100 #ifdef NO_LOCALE_SUPPORT | |
| 101 #define JSONCPP_NO_LOCALE_SUPPORT | |
| 102 #endif | |
| 103 | |
| 104 #ifndef JSONCPP_NO_LOCALE_SUPPORT | |
| 105 #include <clocale> | |
| 106 #endif | |
| 107 | |
| 108 /* This header provides common string manipulation support, such as UTF-8, | |
| 109 * portable conversion from/to string... | |
| 110 * | |
| 111 * It is an internal header that must not be exposed. | |
| 112 */ | |
| 113 | |
| 114 namespace Json { | |
| 115 static inline char getDecimalPoint() { | |
| 116 #ifdef JSONCPP_NO_LOCALE_SUPPORT | |
| 117 return '\0'; | |
| 118 #else | |
| 119 struct lconv* lc = localeconv(); | |
| 120 return lc ? *(lc->decimal_point) : '\0'; | |
| 121 #endif | |
| 122 } | |
| 123 | |
| 124 /// Converts a unicode code-point to UTF-8. | |
| 125 static inline String codePointToUTF8(unsigned int cp) { | |
| 126 String result; | |
| 127 | |
| 128 // based on description from http://en.wikipedia.org/wiki/UTF-8 | |
| 129 | |
| 130 if (cp <= 0x7f) { | |
| 131 result.resize(1); | |
| 132 result[0] = static_cast<char>(cp); | |
| 133 } else if (cp <= 0x7FF) { | |
| 134 result.resize(2); | |
| 135 result[1] = static_cast<char>(0x80 | (0x3f & cp)); | |
| 136 result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6))); | |
| 137 } else if (cp <= 0xFFFF) { | |
| 138 result.resize(3); | |
| 139 result[2] = static_cast<char>(0x80 | (0x3f & cp)); | |
| 140 result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 6))); | |
| 141 result[0] = static_cast<char>(0xE0 | (0xf & (cp >> 12))); | |
| 142 } else if (cp <= 0x10FFFF) { | |
| 143 result.resize(4); | |
| 144 result[3] = static_cast<char>(0x80 | (0x3f & cp)); | |
| 145 result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6))); | |
| 146 result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12))); | |
| 147 result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18))); | |
| 148 } | |
| 149 | |
| 150 return result; | |
| 151 } | |
| 152 | |
| 153 enum { | |
| 154 /// Constant that specify the size of the buffer that must be passed to | |
| 155 /// uintToString. | |
| 156 uintToStringBufferSize = 3 * sizeof(LargestUInt) + 1 | |
| 157 }; | |
| 158 | |
| 159 // Defines a char buffer for use with uintToString(). | |
| 160 typedef char UIntToStringBuffer[uintToStringBufferSize]; | |
| 161 | |
| 162 /** Converts an unsigned integer to string. | |
| 163 * @param value Unsigned integer to convert to string | |
| 164 * @param current Input/Output string buffer. | |
| 165 * Must have at least uintToStringBufferSize chars free. | |
| 166 */ | |
| 167 static inline void uintToString(LargestUInt value, char*& current) { | |
| 168 *--current = 0; | |
| 169 do { | |
| 170 *--current = static_cast<char>(value % 10U + static_cast<unsigned>('0')); | |
| 171 value /= 10; | |
| 172 } while (value != 0); | |
| 173 } | |
| 174 | |
| 175 /** Change ',' to '.' everywhere in buffer. | |
| 176 * | |
| 177 * We had a sophisticated way, but it did not work in WinCE. | |
| 178 * @see https://github.com/open-source-parsers/jsoncpp/pull/9 | |
| 179 */ | |
| 180 template <typename Iter> Iter fixNumericLocale(Iter begin, Iter end) { | |
| 181 for (; begin != end; ++begin) { | |
| 182 if (*begin == ',') { | |
| 183 *begin = '.'; | |
| 184 } | |
| 185 } | |
| 186 return begin; | |
| 187 } | |
| 188 | |
| 189 template <typename Iter> void fixNumericLocaleInput(Iter begin, Iter end) { | |
| 190 char decimalPoint = getDecimalPoint(); | |
| 191 if (decimalPoint == '\0' || decimalPoint == '.') { | |
| 192 return; | |
| 193 } | |
| 194 for (; begin != end; ++begin) { | |
| 195 if (*begin == '.') { | |
| 196 *begin = decimalPoint; | |
| 197 } | |
| 198 } | |
| 199 } | |
| 200 | |
| 201 /** | |
| 202 * Return iterator that would be the new end of the range [begin,end), if we | |
| 203 * were to delete zeros in the end of string, but not the last zero before '.'. | |
| 204 */ | |
| 205 template <typename Iter> Iter fixZerosInTheEnd(Iter begin, Iter end) { | |
| 206 for (; begin != end; --end) { | |
| 207 if (*(end - 1) != '0') { | |
| 208 return end; | |
| 209 } | |
| 210 // Don't delete the last zero before the decimal point. | |
| 211 if (begin != (end - 1) && *(end - 2) == '.') { | |
| 212 return end; | |
| 213 } | |
| 214 } | |
| 215 return end; | |
| 216 } | |
| 217 | |
| 218 } // namespace Json | |
| 219 | |
| 220 #endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED | |
| 221 | |
| 222 // ////////////////////////////////////////////////////////////////////// | |
| 223 // End of content of file: src/lib_json/json_tool.h | |
| 224 // ////////////////////////////////////////////////////////////////////// | |
| 225 | |
| 226 | |
| 227 | |
| 228 | |
| 229 | |
| 230 | |
| 231 // ////////////////////////////////////////////////////////////////////// | |
| 232 // Beginning of content of file: src/lib_json/json_reader.cpp | |
| 233 // ////////////////////////////////////////////////////////////////////// | |
| 234 | |
| 235 // Copyright 2007-2011 Baptiste Lepilleur and The JsonCpp Authors | |
| 236 // Copyright (C) 2016 InfoTeCS JSC. All rights reserved. | |
| 237 // Distributed under MIT license, or public domain if desired and | |
| 238 // recognized in your jurisdiction. | |
| 239 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE | |
| 240 | |
| 241 #if !defined(JSON_IS_AMALGAMATION) | |
| 242 #include "json_tool.h" | |
| 243 #include <json/assertions.h> | |
| 244 #include <json/reader.h> | |
| 245 #include <json/value.h> | |
| 246 #endif // if !defined(JSON_IS_AMALGAMATION) | |
| 247 #include <cassert> | |
| 248 #include <cstring> | |
| 249 #include <istream> | |
| 250 #include <limits> | |
| 251 #include <memory> | |
| 252 #include <set> | |
| 253 #include <sstream> | |
| 254 #include <utility> | |
| 255 | |
| 256 #include <cstdio> | |
| 257 #if __cplusplus >= 201103L | |
| 258 | |
| 259 #if !defined(sscanf) | |
| 260 #define sscanf std::sscanf | |
| 261 #endif | |
| 262 | |
| 263 #endif //__cplusplus | |
| 264 | |
| 265 #if defined(_MSC_VER) | |
| 266 #if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES) | |
| 267 #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1 | |
| 268 #endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES | |
| 269 #endif //_MSC_VER | |
| 270 | |
| 271 #if defined(_MSC_VER) | |
| 272 // Disable warning about strdup being deprecated. | |
| 273 #pragma warning(disable : 4996) | |
| 274 #endif | |
| 275 | |
| 276 // Define JSONCPP_DEPRECATED_STACK_LIMIT as an appropriate integer at compile | |
| 277 // time to change the stack limit | |
| 278 #if !defined(JSONCPP_DEPRECATED_STACK_LIMIT) | |
| 279 #define JSONCPP_DEPRECATED_STACK_LIMIT 1000 | |
| 280 #endif | |
| 281 | |
| 282 static size_t const stackLimit_g = | |
| 283 JSONCPP_DEPRECATED_STACK_LIMIT; // see readValue() | |
| 284 | |
| 285 namespace Json { | |
| 286 | |
| 287 #if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520) | |
| 288 typedef std::unique_ptr<CharReader> CharReaderPtr; | |
| 289 #else | |
|
1298
8a0a62189f46
replacing std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
499
diff
changeset
|
290 typedef std::unique_ptr<CharReader> CharReaderPtr; |
| 499 | 291 #endif |
| 292 | |
| 293 // Implementation of class Features | |
| 294 // //////////////////////////////// | |
| 295 | |
| 296 Features::Features() = default; | |
| 297 | |
| 298 Features Features::all() { return {}; } | |
| 299 | |
| 300 Features Features::strictMode() { | |
| 301 Features features; | |
| 302 features.allowComments_ = false; | |
| 303 features.strictRoot_ = true; | |
| 304 features.allowDroppedNullPlaceholders_ = false; | |
| 305 features.allowNumericKeys_ = false; | |
| 306 return features; | |
| 307 } | |
| 308 | |
| 309 // Implementation of class Reader | |
| 310 // //////////////////////////////// | |
| 311 | |
| 312 bool Reader::containsNewLine(Reader::Location begin, Reader::Location end) { | |
| 313 for (; begin < end; ++begin) | |
| 314 if (*begin == '\n' || *begin == '\r') | |
| 315 return true; | |
| 316 return false; | |
| 317 } | |
| 318 | |
| 319 // Class Reader | |
| 320 // ////////////////////////////////////////////////////////////////// | |
| 321 | |
| 322 Reader::Reader() | |
| 323 : errors_(), document_(), commentsBefore_(), features_(Features::all()) {} | |
| 324 | |
| 325 Reader::Reader(const Features& features) | |
| 326 : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(), | |
| 327 lastValue_(), commentsBefore_(), features_(features), collectComments_() { | |
| 328 } | |
| 329 | |
| 330 bool Reader::parse(const std::string& document, | |
| 331 Value& root, | |
| 332 bool collectComments) { | |
| 333 document_.assign(document.begin(), document.end()); | |
| 334 const char* begin = document_.c_str(); | |
| 335 const char* end = begin + document_.length(); | |
| 336 return parse(begin, end, root, collectComments); | |
| 337 } | |
| 338 | |
| 339 bool Reader::parse(std::istream& is, Value& root, bool collectComments) { | |
| 340 // std::istream_iterator<char> begin(is); | |
| 341 // std::istream_iterator<char> end; | |
| 342 // Those would allow streamed input from a file, if parse() were a | |
| 343 // template function. | |
| 344 | |
| 345 // Since String is reference-counted, this at least does not | |
| 346 // create an extra copy. | |
| 347 String doc; | |
| 348 std::getline(is, doc, (char)EOF); | |
| 349 return parse(doc.data(), doc.data() + doc.size(), root, collectComments); | |
| 350 } | |
| 351 | |
| 352 bool Reader::parse(const char* beginDoc, | |
| 353 const char* endDoc, | |
| 354 Value& root, | |
| 355 bool collectComments) { | |
| 356 if (!features_.allowComments_) { | |
| 357 collectComments = false; | |
| 358 } | |
| 359 | |
| 360 begin_ = beginDoc; | |
| 361 end_ = endDoc; | |
| 362 collectComments_ = collectComments; | |
| 363 current_ = begin_; | |
| 364 lastValueEnd_ = nullptr; | |
| 365 lastValue_ = nullptr; | |
| 366 commentsBefore_.clear(); | |
| 367 errors_.clear(); | |
| 368 while (!nodes_.empty()) | |
| 369 nodes_.pop(); | |
| 370 nodes_.push(&root); | |
| 371 | |
| 372 bool successful = readValue(); | |
| 373 Token token; | |
| 374 skipCommentTokens(token); | |
| 375 if (collectComments_ && !commentsBefore_.empty()) | |
| 376 root.setComment(commentsBefore_, commentAfter); | |
| 377 if (features_.strictRoot_) { | |
| 378 if (!root.isArray() && !root.isObject()) { | |
| 379 // Set error location to start of doc, ideally should be first token found | |
| 380 // in doc | |
| 381 token.type_ = tokenError; | |
| 382 token.start_ = beginDoc; | |
| 383 token.end_ = endDoc; | |
| 384 addError( | |
| 385 "A valid JSON document must be either an array or an object value.", | |
| 386 token); | |
| 387 return false; | |
| 388 } | |
| 389 } | |
| 390 return successful; | |
| 391 } | |
| 392 | |
| 393 bool Reader::readValue() { | |
| 394 // readValue() may call itself only if it calls readObject() or ReadArray(). | |
| 395 // These methods execute nodes_.push() just before and nodes_.pop)() just | |
| 396 // after calling readValue(). parse() executes one nodes_.push(), so > instead | |
| 397 // of >=. | |
| 398 if (nodes_.size() > stackLimit_g) | |
| 399 throwRuntimeError("Exceeded stackLimit in readValue()."); | |
| 400 | |
| 401 Token token; | |
| 402 skipCommentTokens(token); | |
| 403 bool successful = true; | |
| 404 | |
| 405 if (collectComments_ && !commentsBefore_.empty()) { | |
| 406 currentValue().setComment(commentsBefore_, commentBefore); | |
| 407 commentsBefore_.clear(); | |
| 408 } | |
| 409 | |
| 410 switch (token.type_) { | |
| 411 case tokenObjectBegin: | |
| 412 successful = readObject(token); | |
| 413 currentValue().setOffsetLimit(current_ - begin_); | |
| 414 break; | |
| 415 case tokenArrayBegin: | |
| 416 successful = readArray(token); | |
| 417 currentValue().setOffsetLimit(current_ - begin_); | |
| 418 break; | |
| 419 case tokenNumber: | |
| 420 successful = decodeNumber(token); | |
| 421 break; | |
| 422 case tokenString: | |
| 423 successful = decodeString(token); | |
| 424 break; | |
| 425 case tokenTrue: { | |
| 426 Value v(true); | |
| 427 currentValue().swapPayload(v); | |
| 428 currentValue().setOffsetStart(token.start_ - begin_); | |
| 429 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 430 } break; | |
| 431 case tokenFalse: { | |
| 432 Value v(false); | |
| 433 currentValue().swapPayload(v); | |
| 434 currentValue().setOffsetStart(token.start_ - begin_); | |
| 435 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 436 } break; | |
| 437 case tokenNull: { | |
| 438 Value v; | |
| 439 currentValue().swapPayload(v); | |
| 440 currentValue().setOffsetStart(token.start_ - begin_); | |
| 441 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 442 } break; | |
| 443 case tokenArraySeparator: | |
| 444 case tokenObjectEnd: | |
| 445 case tokenArrayEnd: | |
| 446 if (features_.allowDroppedNullPlaceholders_) { | |
| 447 // "Un-read" the current token and mark the current value as a null | |
| 448 // token. | |
| 449 current_--; | |
| 450 Value v; | |
| 451 currentValue().swapPayload(v); | |
| 452 currentValue().setOffsetStart(current_ - begin_ - 1); | |
| 453 currentValue().setOffsetLimit(current_ - begin_); | |
| 454 break; | |
| 455 } // Else, fall through... | |
| 456 default: | |
| 457 currentValue().setOffsetStart(token.start_ - begin_); | |
| 458 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 459 return addError("Syntax error: value, object or array expected.", token); | |
| 460 } | |
| 461 | |
| 462 if (collectComments_) { | |
| 463 lastValueEnd_ = current_; | |
| 464 lastValue_ = ¤tValue(); | |
| 465 } | |
| 466 | |
| 467 return successful; | |
| 468 } | |
| 469 | |
| 470 void Reader::skipCommentTokens(Token& token) { | |
| 471 if (features_.allowComments_) { | |
| 472 do { | |
| 473 readToken(token); | |
| 474 } while (token.type_ == tokenComment); | |
| 475 } else { | |
| 476 readToken(token); | |
| 477 } | |
| 478 } | |
| 479 | |
| 480 bool Reader::readToken(Token& token) { | |
| 481 skipSpaces(); | |
| 482 token.start_ = current_; | |
| 483 Char c = getNextChar(); | |
| 484 bool ok = true; | |
| 485 switch (c) { | |
| 486 case '{': | |
| 487 token.type_ = tokenObjectBegin; | |
| 488 break; | |
| 489 case '}': | |
| 490 token.type_ = tokenObjectEnd; | |
| 491 break; | |
| 492 case '[': | |
| 493 token.type_ = tokenArrayBegin; | |
| 494 break; | |
| 495 case ']': | |
| 496 token.type_ = tokenArrayEnd; | |
| 497 break; | |
| 498 case '"': | |
| 499 token.type_ = tokenString; | |
| 500 ok = readString(); | |
| 501 break; | |
| 502 case '/': | |
| 503 token.type_ = tokenComment; | |
| 504 ok = readComment(); | |
| 505 break; | |
| 506 case '0': | |
| 507 case '1': | |
| 508 case '2': | |
| 509 case '3': | |
| 510 case '4': | |
| 511 case '5': | |
| 512 case '6': | |
| 513 case '7': | |
| 514 case '8': | |
| 515 case '9': | |
| 516 case '-': | |
| 517 token.type_ = tokenNumber; | |
| 518 readNumber(); | |
| 519 break; | |
| 520 case 't': | |
| 521 token.type_ = tokenTrue; | |
| 522 ok = match("rue", 3); | |
| 523 break; | |
| 524 case 'f': | |
| 525 token.type_ = tokenFalse; | |
| 526 ok = match("alse", 4); | |
| 527 break; | |
| 528 case 'n': | |
| 529 token.type_ = tokenNull; | |
| 530 ok = match("ull", 3); | |
| 531 break; | |
| 532 case ',': | |
| 533 token.type_ = tokenArraySeparator; | |
| 534 break; | |
| 535 case ':': | |
| 536 token.type_ = tokenMemberSeparator; | |
| 537 break; | |
| 538 case 0: | |
| 539 token.type_ = tokenEndOfStream; | |
| 540 break; | |
| 541 default: | |
| 542 ok = false; | |
| 543 break; | |
| 544 } | |
| 545 if (!ok) | |
| 546 token.type_ = tokenError; | |
| 547 token.end_ = current_; | |
| 548 return true; | |
| 549 } | |
| 550 | |
| 551 void Reader::skipSpaces() { | |
| 552 while (current_ != end_) { | |
| 553 Char c = *current_; | |
| 554 if (c == ' ' || c == '\t' || c == '\r' || c == '\n') | |
| 555 ++current_; | |
| 556 else | |
| 557 break; | |
| 558 } | |
| 559 } | |
| 560 | |
| 561 bool Reader::match(Location pattern, int patternLength) { | |
| 562 if (end_ - current_ < patternLength) | |
| 563 return false; | |
| 564 int index = patternLength; | |
| 565 while (index--) | |
| 566 if (current_[index] != pattern[index]) | |
| 567 return false; | |
| 568 current_ += patternLength; | |
| 569 return true; | |
| 570 } | |
| 571 | |
| 572 bool Reader::readComment() { | |
| 573 Location commentBegin = current_ - 1; | |
| 574 Char c = getNextChar(); | |
| 575 bool successful = false; | |
| 576 if (c == '*') | |
| 577 successful = readCStyleComment(); | |
| 578 else if (c == '/') | |
| 579 successful = readCppStyleComment(); | |
| 580 if (!successful) | |
| 581 return false; | |
| 582 | |
| 583 if (collectComments_) { | |
| 584 CommentPlacement placement = commentBefore; | |
| 585 if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) { | |
| 586 if (c != '*' || !containsNewLine(commentBegin, current_)) | |
| 587 placement = commentAfterOnSameLine; | |
| 588 } | |
| 589 | |
| 590 addComment(commentBegin, current_, placement); | |
| 591 } | |
| 592 return true; | |
| 593 } | |
| 594 | |
| 595 String Reader::normalizeEOL(Reader::Location begin, Reader::Location end) { | |
| 596 String normalized; | |
| 597 normalized.reserve(static_cast<size_t>(end - begin)); | |
| 598 Reader::Location current = begin; | |
| 599 while (current != end) { | |
| 600 char c = *current++; | |
| 601 if (c == '\r') { | |
| 602 if (current != end && *current == '\n') | |
| 603 // convert dos EOL | |
| 604 ++current; | |
| 605 // convert Mac EOL | |
| 606 normalized += '\n'; | |
| 607 } else { | |
| 608 normalized += c; | |
| 609 } | |
| 610 } | |
| 611 return normalized; | |
| 612 } | |
| 613 | |
| 614 void Reader::addComment(Location begin, | |
| 615 Location end, | |
| 616 CommentPlacement placement) { | |
| 617 assert(collectComments_); | |
| 618 const String& normalized = normalizeEOL(begin, end); | |
| 619 if (placement == commentAfterOnSameLine) { | |
| 620 assert(lastValue_ != nullptr); | |
| 621 lastValue_->setComment(normalized, placement); | |
| 622 } else { | |
| 623 commentsBefore_ += normalized; | |
| 624 } | |
| 625 } | |
| 626 | |
| 627 bool Reader::readCStyleComment() { | |
| 628 while ((current_ + 1) < end_) { | |
| 629 Char c = getNextChar(); | |
| 630 if (c == '*' && *current_ == '/') | |
| 631 break; | |
| 632 } | |
| 633 return getNextChar() == '/'; | |
| 634 } | |
| 635 | |
| 636 bool Reader::readCppStyleComment() { | |
| 637 while (current_ != end_) { | |
| 638 Char c = getNextChar(); | |
| 639 if (c == '\n') | |
| 640 break; | |
| 641 if (c == '\r') { | |
| 642 // Consume DOS EOL. It will be normalized in addComment. | |
| 643 if (current_ != end_ && *current_ == '\n') | |
| 644 getNextChar(); | |
| 645 // Break on Moc OS 9 EOL. | |
| 646 break; | |
| 647 } | |
| 648 } | |
| 649 return true; | |
| 650 } | |
| 651 | |
| 652 void Reader::readNumber() { | |
| 653 const char* p = current_; | |
| 654 char c = '0'; // stopgap for already consumed character | |
| 655 // integral part | |
| 656 while (c >= '0' && c <= '9') | |
| 657 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 658 // fractional part | |
| 659 if (c == '.') { | |
| 660 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 661 while (c >= '0' && c <= '9') | |
| 662 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 663 } | |
| 664 // exponential part | |
| 665 if (c == 'e' || c == 'E') { | |
| 666 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 667 if (c == '+' || c == '-') | |
| 668 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 669 while (c >= '0' && c <= '9') | |
| 670 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 671 } | |
| 672 } | |
| 673 | |
| 674 bool Reader::readString() { | |
| 675 Char c = '\0'; | |
| 676 while (current_ != end_) { | |
| 677 c = getNextChar(); | |
| 678 if (c == '\\') | |
| 679 getNextChar(); | |
| 680 else if (c == '"') | |
| 681 break; | |
| 682 } | |
| 683 return c == '"'; | |
| 684 } | |
| 685 | |
| 686 bool Reader::readObject(Token& token) { | |
| 687 Token tokenName; | |
| 688 String name; | |
| 689 Value init(objectValue); | |
| 690 currentValue().swapPayload(init); | |
| 691 currentValue().setOffsetStart(token.start_ - begin_); | |
| 692 while (readToken(tokenName)) { | |
| 693 bool initialTokenOk = true; | |
| 694 while (tokenName.type_ == tokenComment && initialTokenOk) | |
| 695 initialTokenOk = readToken(tokenName); | |
| 696 if (!initialTokenOk) | |
| 697 break; | |
| 698 if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object | |
| 699 return true; | |
| 700 name.clear(); | |
| 701 if (tokenName.type_ == tokenString) { | |
| 702 if (!decodeString(tokenName, name)) | |
| 703 return recoverFromError(tokenObjectEnd); | |
| 704 } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) { | |
| 705 Value numberName; | |
| 706 if (!decodeNumber(tokenName, numberName)) | |
| 707 return recoverFromError(tokenObjectEnd); | |
| 708 name = String(numberName.asCString()); | |
| 709 } else { | |
| 710 break; | |
| 711 } | |
| 712 | |
| 713 Token colon; | |
| 714 if (!readToken(colon) || colon.type_ != tokenMemberSeparator) { | |
| 715 return addErrorAndRecover("Missing ':' after object member name", colon, | |
| 716 tokenObjectEnd); | |
| 717 } | |
| 718 Value& value = currentValue()[name]; | |
| 719 nodes_.push(&value); | |
| 720 bool ok = readValue(); | |
| 721 nodes_.pop(); | |
| 722 if (!ok) // error already set | |
| 723 return recoverFromError(tokenObjectEnd); | |
| 724 | |
| 725 Token comma; | |
| 726 if (!readToken(comma) || | |
| 727 (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator && | |
| 728 comma.type_ != tokenComment)) { | |
| 729 return addErrorAndRecover("Missing ',' or '}' in object declaration", | |
| 730 comma, tokenObjectEnd); | |
| 731 } | |
| 732 bool finalizeTokenOk = true; | |
| 733 while (comma.type_ == tokenComment && finalizeTokenOk) | |
| 734 finalizeTokenOk = readToken(comma); | |
| 735 if (comma.type_ == tokenObjectEnd) | |
| 736 return true; | |
| 737 } | |
| 738 return addErrorAndRecover("Missing '}' or object member name", tokenName, | |
| 739 tokenObjectEnd); | |
| 740 } | |
| 741 | |
| 742 bool Reader::readArray(Token& token) { | |
| 743 Value init(arrayValue); | |
| 744 currentValue().swapPayload(init); | |
| 745 currentValue().setOffsetStart(token.start_ - begin_); | |
| 746 skipSpaces(); | |
| 747 if (current_ != end_ && *current_ == ']') // empty array | |
| 748 { | |
| 749 Token endArray; | |
| 750 readToken(endArray); | |
| 751 return true; | |
| 752 } | |
| 753 int index = 0; | |
| 754 for (;;) { | |
| 755 Value& value = currentValue()[index++]; | |
| 756 nodes_.push(&value); | |
| 757 bool ok = readValue(); | |
| 758 nodes_.pop(); | |
| 759 if (!ok) // error already set | |
| 760 return recoverFromError(tokenArrayEnd); | |
| 761 | |
| 762 Token currentToken; | |
| 763 // Accept Comment after last item in the array. | |
| 764 ok = readToken(currentToken); | |
| 765 while (currentToken.type_ == tokenComment && ok) { | |
| 766 ok = readToken(currentToken); | |
| 767 } | |
| 768 bool badTokenType = (currentToken.type_ != tokenArraySeparator && | |
| 769 currentToken.type_ != tokenArrayEnd); | |
| 770 if (!ok || badTokenType) { | |
| 771 return addErrorAndRecover("Missing ',' or ']' in array declaration", | |
| 772 currentToken, tokenArrayEnd); | |
| 773 } | |
| 774 if (currentToken.type_ == tokenArrayEnd) | |
| 775 break; | |
| 776 } | |
| 777 return true; | |
| 778 } | |
| 779 | |
| 780 bool Reader::decodeNumber(Token& token) { | |
| 781 Value decoded; | |
| 782 if (!decodeNumber(token, decoded)) | |
| 783 return false; | |
| 784 currentValue().swapPayload(decoded); | |
| 785 currentValue().setOffsetStart(token.start_ - begin_); | |
| 786 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 787 return true; | |
| 788 } | |
| 789 | |
| 790 bool Reader::decodeNumber(Token& token, Value& decoded) { | |
| 791 // Attempts to parse the number as an integer. If the number is | |
| 792 // larger than the maximum supported value of an integer then | |
| 793 // we decode the number as a double. | |
| 794 Location current = token.start_; | |
| 795 bool isNegative = *current == '-'; | |
| 796 if (isNegative) | |
| 797 ++current; | |
| 798 // TODO: Help the compiler do the div and mod at compile time or get rid of | |
| 799 // them. | |
| 800 Value::LargestUInt maxIntegerValue = | |
| 801 isNegative ? Value::LargestUInt(Value::maxLargestInt) + 1 | |
| 802 : Value::maxLargestUInt; | |
| 803 Value::LargestUInt threshold = maxIntegerValue / 10; | |
| 804 Value::LargestUInt value = 0; | |
| 805 while (current < token.end_) { | |
| 806 Char c = *current++; | |
| 807 if (c < '0' || c > '9') | |
| 808 return decodeDouble(token, decoded); | |
| 809 auto digit(static_cast<Value::UInt>(c - '0')); | |
| 810 if (value >= threshold) { | |
| 811 // We've hit or exceeded the max value divided by 10 (rounded down). If | |
| 812 // a) we've only just touched the limit, b) this is the last digit, and | |
| 813 // c) it's small enough to fit in that rounding delta, we're okay. | |
| 814 // Otherwise treat this number as a double to avoid overflow. | |
| 815 if (value > threshold || current != token.end_ || | |
| 816 digit > maxIntegerValue % 10) { | |
| 817 return decodeDouble(token, decoded); | |
| 818 } | |
| 819 } | |
| 820 value = value * 10 + digit; | |
| 821 } | |
| 822 if (isNegative && value == maxIntegerValue) | |
| 823 decoded = Value::minLargestInt; | |
| 824 else if (isNegative) | |
| 825 decoded = -Value::LargestInt(value); | |
| 826 else if (value <= Value::LargestUInt(Value::maxInt)) | |
| 827 decoded = Value::LargestInt(value); | |
| 828 else | |
| 829 decoded = value; | |
| 830 return true; | |
| 831 } | |
| 832 | |
| 833 bool Reader::decodeDouble(Token& token) { | |
| 834 Value decoded; | |
| 835 if (!decodeDouble(token, decoded)) | |
| 836 return false; | |
| 837 currentValue().swapPayload(decoded); | |
| 838 currentValue().setOffsetStart(token.start_ - begin_); | |
| 839 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 840 return true; | |
| 841 } | |
| 842 | |
| 843 bool Reader::decodeDouble(Token& token, Value& decoded) { | |
| 844 double value = 0; | |
| 845 String buffer(token.start_, token.end_); | |
| 846 IStringStream is(buffer); | |
| 847 if (!(is >> value)) | |
| 848 return addError( | |
| 849 "'" + String(token.start_, token.end_) + "' is not a number.", token); | |
| 850 decoded = value; | |
| 851 return true; | |
| 852 } | |
| 853 | |
| 854 bool Reader::decodeString(Token& token) { | |
| 855 String decoded_string; | |
| 856 if (!decodeString(token, decoded_string)) | |
| 857 return false; | |
| 858 Value decoded(decoded_string); | |
| 859 currentValue().swapPayload(decoded); | |
| 860 currentValue().setOffsetStart(token.start_ - begin_); | |
| 861 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 862 return true; | |
| 863 } | |
| 864 | |
| 865 bool Reader::decodeString(Token& token, String& decoded) { | |
| 866 decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2)); | |
| 867 Location current = token.start_ + 1; // skip '"' | |
| 868 Location end = token.end_ - 1; // do not include '"' | |
| 869 while (current != end) { | |
| 870 Char c = *current++; | |
| 871 if (c == '"') | |
| 872 break; | |
| 873 else if (c == '\\') { | |
| 874 if (current == end) | |
| 875 return addError("Empty escape sequence in string", token, current); | |
| 876 Char escape = *current++; | |
| 877 switch (escape) { | |
| 878 case '"': | |
| 879 decoded += '"'; | |
| 880 break; | |
| 881 case '/': | |
| 882 decoded += '/'; | |
| 883 break; | |
| 884 case '\\': | |
| 885 decoded += '\\'; | |
| 886 break; | |
| 887 case 'b': | |
| 888 decoded += '\b'; | |
| 889 break; | |
| 890 case 'f': | |
| 891 decoded += '\f'; | |
| 892 break; | |
| 893 case 'n': | |
| 894 decoded += '\n'; | |
| 895 break; | |
| 896 case 'r': | |
| 897 decoded += '\r'; | |
| 898 break; | |
| 899 case 't': | |
| 900 decoded += '\t'; | |
| 901 break; | |
| 902 case 'u': { | |
| 903 unsigned int unicode; | |
| 904 if (!decodeUnicodeCodePoint(token, current, end, unicode)) | |
| 905 return false; | |
| 906 decoded += codePointToUTF8(unicode); | |
| 907 } break; | |
| 908 default: | |
| 909 return addError("Bad escape sequence in string", token, current); | |
| 910 } | |
| 911 } else { | |
| 912 decoded += c; | |
| 913 } | |
| 914 } | |
| 915 return true; | |
| 916 } | |
| 917 | |
| 918 bool Reader::decodeUnicodeCodePoint(Token& token, | |
| 919 Location& current, | |
| 920 Location end, | |
| 921 unsigned int& unicode) { | |
| 922 | |
| 923 if (!decodeUnicodeEscapeSequence(token, current, end, unicode)) | |
| 924 return false; | |
| 925 if (unicode >= 0xD800 && unicode <= 0xDBFF) { | |
| 926 // surrogate pairs | |
| 927 if (end - current < 6) | |
| 928 return addError( | |
| 929 "additional six characters expected to parse unicode surrogate pair.", | |
| 930 token, current); | |
| 931 if (*(current++) == '\\' && *(current++) == 'u') { | |
| 932 unsigned int surrogatePair; | |
| 933 if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) { | |
| 934 unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF); | |
| 935 } else | |
| 936 return false; | |
| 937 } else | |
| 938 return addError("expecting another \\u token to begin the second half of " | |
| 939 "a unicode surrogate pair", | |
| 940 token, current); | |
| 941 } | |
| 942 return true; | |
| 943 } | |
| 944 | |
| 945 bool Reader::decodeUnicodeEscapeSequence(Token& token, | |
| 946 Location& current, | |
| 947 Location end, | |
| 948 unsigned int& ret_unicode) { | |
| 949 if (end - current < 4) | |
| 950 return addError( | |
| 951 "Bad unicode escape sequence in string: four digits expected.", token, | |
| 952 current); | |
| 953 int unicode = 0; | |
| 954 for (int index = 0; index < 4; ++index) { | |
| 955 Char c = *current++; | |
| 956 unicode *= 16; | |
| 957 if (c >= '0' && c <= '9') | |
| 958 unicode += c - '0'; | |
| 959 else if (c >= 'a' && c <= 'f') | |
| 960 unicode += c - 'a' + 10; | |
| 961 else if (c >= 'A' && c <= 'F') | |
| 962 unicode += c - 'A' + 10; | |
| 963 else | |
| 964 return addError( | |
| 965 "Bad unicode escape sequence in string: hexadecimal digit expected.", | |
| 966 token, current); | |
| 967 } | |
| 968 ret_unicode = static_cast<unsigned int>(unicode); | |
| 969 return true; | |
| 970 } | |
| 971 | |
| 972 bool Reader::addError(const String& message, Token& token, Location extra) { | |
| 973 ErrorInfo info; | |
| 974 info.token_ = token; | |
| 975 info.message_ = message; | |
| 976 info.extra_ = extra; | |
| 977 errors_.push_back(info); | |
| 978 return false; | |
| 979 } | |
| 980 | |
| 981 bool Reader::recoverFromError(TokenType skipUntilToken) { | |
| 982 size_t const errorCount = errors_.size(); | |
| 983 Token skip; | |
| 984 for (;;) { | |
| 985 if (!readToken(skip)) | |
| 986 errors_.resize(errorCount); // discard errors caused by recovery | |
| 987 if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream) | |
| 988 break; | |
| 989 } | |
| 990 errors_.resize(errorCount); | |
| 991 return false; | |
| 992 } | |
| 993 | |
| 994 bool Reader::addErrorAndRecover(const String& message, | |
| 995 Token& token, | |
| 996 TokenType skipUntilToken) { | |
| 997 addError(message, token); | |
| 998 return recoverFromError(skipUntilToken); | |
| 999 } | |
| 1000 | |
| 1001 Value& Reader::currentValue() { return *(nodes_.top()); } | |
| 1002 | |
| 1003 Reader::Char Reader::getNextChar() { | |
| 1004 if (current_ == end_) | |
| 1005 return 0; | |
| 1006 return *current_++; | |
| 1007 } | |
| 1008 | |
| 1009 void Reader::getLocationLineAndColumn(Location location, | |
| 1010 int& line, | |
| 1011 int& column) const { | |
| 1012 Location current = begin_; | |
| 1013 Location lastLineStart = current; | |
| 1014 line = 0; | |
| 1015 while (current < location && current != end_) { | |
| 1016 Char c = *current++; | |
| 1017 if (c == '\r') { | |
| 1018 if (*current == '\n') | |
| 1019 ++current; | |
| 1020 lastLineStart = current; | |
| 1021 ++line; | |
| 1022 } else if (c == '\n') { | |
| 1023 lastLineStart = current; | |
| 1024 ++line; | |
| 1025 } | |
| 1026 } | |
| 1027 // column & line start at 1 | |
| 1028 column = int(location - lastLineStart) + 1; | |
| 1029 ++line; | |
| 1030 } | |
| 1031 | |
| 1032 String Reader::getLocationLineAndColumn(Location location) const { | |
| 1033 int line, column; | |
| 1034 getLocationLineAndColumn(location, line, column); | |
| 1035 char buffer[18 + 16 + 16 + 1]; | |
| 1036 jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column); | |
| 1037 return buffer; | |
| 1038 } | |
| 1039 | |
| 1040 // Deprecated. Preserved for backward compatibility | |
| 1041 String Reader::getFormatedErrorMessages() const { | |
| 1042 return getFormattedErrorMessages(); | |
| 1043 } | |
| 1044 | |
| 1045 String Reader::getFormattedErrorMessages() const { | |
| 1046 String formattedMessage; | |
| 1047 for (const auto& error : errors_) { | |
| 1048 formattedMessage += | |
| 1049 "* " + getLocationLineAndColumn(error.token_.start_) + "\n"; | |
| 1050 formattedMessage += " " + error.message_ + "\n"; | |
| 1051 if (error.extra_) | |
| 1052 formattedMessage += | |
| 1053 "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n"; | |
| 1054 } | |
| 1055 return formattedMessage; | |
| 1056 } | |
| 1057 | |
| 1058 std::vector<Reader::StructuredError> Reader::getStructuredErrors() const { | |
| 1059 std::vector<Reader::StructuredError> allErrors; | |
| 1060 for (const auto& error : errors_) { | |
| 1061 Reader::StructuredError structured; | |
| 1062 structured.offset_start = error.token_.start_ - begin_; | |
| 1063 structured.offset_limit = error.token_.end_ - begin_; | |
| 1064 structured.message = error.message_; | |
| 1065 allErrors.push_back(structured); | |
| 1066 } | |
| 1067 return allErrors; | |
| 1068 } | |
| 1069 | |
| 1070 bool Reader::pushError(const Value& value, const String& message) { | |
| 1071 ptrdiff_t const length = end_ - begin_; | |
| 1072 if (value.getOffsetStart() > length || value.getOffsetLimit() > length) | |
| 1073 return false; | |
| 1074 Token token; | |
| 1075 token.type_ = tokenError; | |
| 1076 token.start_ = begin_ + value.getOffsetStart(); | |
| 1077 token.end_ = end_ + value.getOffsetLimit(); | |
| 1078 ErrorInfo info; | |
| 1079 info.token_ = token; | |
| 1080 info.message_ = message; | |
| 1081 info.extra_ = nullptr; | |
| 1082 errors_.push_back(info); | |
| 1083 return true; | |
| 1084 } | |
| 1085 | |
| 1086 bool Reader::pushError(const Value& value, | |
| 1087 const String& message, | |
| 1088 const Value& extra) { | |
| 1089 ptrdiff_t const length = end_ - begin_; | |
| 1090 if (value.getOffsetStart() > length || value.getOffsetLimit() > length || | |
| 1091 extra.getOffsetLimit() > length) | |
| 1092 return false; | |
| 1093 Token token; | |
| 1094 token.type_ = tokenError; | |
| 1095 token.start_ = begin_ + value.getOffsetStart(); | |
| 1096 token.end_ = begin_ + value.getOffsetLimit(); | |
| 1097 ErrorInfo info; | |
| 1098 info.token_ = token; | |
| 1099 info.message_ = message; | |
| 1100 info.extra_ = begin_ + extra.getOffsetStart(); | |
| 1101 errors_.push_back(info); | |
| 1102 return true; | |
| 1103 } | |
| 1104 | |
| 1105 bool Reader::good() const { return errors_.empty(); } | |
| 1106 | |
| 1107 // exact copy of Features | |
| 1108 class OurFeatures { | |
| 1109 public: | |
| 1110 static OurFeatures all(); | |
| 1111 bool allowComments_; | |
| 1112 bool strictRoot_; | |
| 1113 bool allowDroppedNullPlaceholders_; | |
| 1114 bool allowNumericKeys_; | |
| 1115 bool allowSingleQuotes_; | |
| 1116 bool failIfExtra_; | |
| 1117 bool rejectDupKeys_; | |
| 1118 bool allowSpecialFloats_; | |
| 1119 size_t stackLimit_; | |
| 1120 }; // OurFeatures | |
| 1121 | |
| 1122 // exact copy of Implementation of class Features | |
| 1123 // //////////////////////////////// | |
| 1124 | |
| 1125 OurFeatures OurFeatures::all() { return {}; } | |
| 1126 | |
| 1127 // Implementation of class Reader | |
| 1128 // //////////////////////////////// | |
| 1129 | |
| 1130 // exact copy of Reader, renamed to OurReader | |
| 1131 class OurReader { | |
| 1132 public: | |
| 1133 typedef char Char; | |
| 1134 typedef const Char* Location; | |
| 1135 struct StructuredError { | |
| 1136 ptrdiff_t offset_start; | |
| 1137 ptrdiff_t offset_limit; | |
| 1138 String message; | |
| 1139 }; | |
| 1140 | |
| 1141 OurReader(OurFeatures const& features); | |
| 1142 bool parse(const char* beginDoc, | |
| 1143 const char* endDoc, | |
| 1144 Value& root, | |
| 1145 bool collectComments = true); | |
| 1146 String getFormattedErrorMessages() const; | |
| 1147 std::vector<StructuredError> getStructuredErrors() const; | |
| 1148 bool pushError(const Value& value, const String& message); | |
| 1149 bool pushError(const Value& value, const String& message, const Value& extra); | |
| 1150 bool good() const; | |
| 1151 | |
| 1152 private: | |
| 1153 OurReader(OurReader const&); // no impl | |
| 1154 void operator=(OurReader const&); // no impl | |
| 1155 | |
| 1156 enum TokenType { | |
| 1157 tokenEndOfStream = 0, | |
| 1158 tokenObjectBegin, | |
| 1159 tokenObjectEnd, | |
| 1160 tokenArrayBegin, | |
| 1161 tokenArrayEnd, | |
| 1162 tokenString, | |
| 1163 tokenNumber, | |
| 1164 tokenTrue, | |
| 1165 tokenFalse, | |
| 1166 tokenNull, | |
| 1167 tokenNaN, | |
| 1168 tokenPosInf, | |
| 1169 tokenNegInf, | |
| 1170 tokenArraySeparator, | |
| 1171 tokenMemberSeparator, | |
| 1172 tokenComment, | |
| 1173 tokenError | |
| 1174 }; | |
| 1175 | |
| 1176 class Token { | |
| 1177 public: | |
| 1178 TokenType type_; | |
| 1179 Location start_; | |
| 1180 Location end_; | |
| 1181 }; | |
| 1182 | |
| 1183 class ErrorInfo { | |
| 1184 public: | |
| 1185 Token token_; | |
| 1186 String message_; | |
| 1187 Location extra_; | |
| 1188 }; | |
| 1189 | |
| 1190 typedef std::deque<ErrorInfo> Errors; | |
| 1191 | |
| 1192 bool readToken(Token& token); | |
| 1193 void skipSpaces(); | |
| 1194 bool match(Location pattern, int patternLength); | |
| 1195 bool readComment(); | |
| 1196 bool readCStyleComment(); | |
| 1197 bool readCppStyleComment(); | |
| 1198 bool readString(); | |
| 1199 bool readStringSingleQuote(); | |
| 1200 bool readNumber(bool checkInf); | |
| 1201 bool readValue(); | |
| 1202 bool readObject(Token& token); | |
| 1203 bool readArray(Token& token); | |
| 1204 bool decodeNumber(Token& token); | |
| 1205 bool decodeNumber(Token& token, Value& decoded); | |
| 1206 bool decodeString(Token& token); | |
| 1207 bool decodeString(Token& token, String& decoded); | |
| 1208 bool decodeDouble(Token& token); | |
| 1209 bool decodeDouble(Token& token, Value& decoded); | |
| 1210 bool decodeUnicodeCodePoint(Token& token, | |
| 1211 Location& current, | |
| 1212 Location end, | |
| 1213 unsigned int& unicode); | |
| 1214 bool decodeUnicodeEscapeSequence(Token& token, | |
| 1215 Location& current, | |
| 1216 Location end, | |
| 1217 unsigned int& unicode); | |
| 1218 bool addError(const String& message, Token& token, Location extra = nullptr); | |
| 1219 bool recoverFromError(TokenType skipUntilToken); | |
| 1220 bool addErrorAndRecover(const String& message, | |
| 1221 Token& token, | |
| 1222 TokenType skipUntilToken); | |
| 1223 void skipUntilSpace(); | |
| 1224 Value& currentValue(); | |
| 1225 Char getNextChar(); | |
| 1226 void | |
| 1227 getLocationLineAndColumn(Location location, int& line, int& column) const; | |
| 1228 String getLocationLineAndColumn(Location location) const; | |
| 1229 void addComment(Location begin, Location end, CommentPlacement placement); | |
| 1230 void skipCommentTokens(Token& token); | |
| 1231 | |
| 1232 static String normalizeEOL(Location begin, Location end); | |
| 1233 static bool containsNewLine(Location begin, Location end); | |
| 1234 | |
| 1235 typedef std::stack<Value*> Nodes; | |
| 1236 Nodes nodes_; | |
| 1237 Errors errors_; | |
| 1238 String document_; | |
| 1239 Location begin_; | |
| 1240 Location end_; | |
| 1241 Location current_; | |
| 1242 Location lastValueEnd_; | |
| 1243 Value* lastValue_; | |
| 1244 String commentsBefore_; | |
| 1245 | |
| 1246 OurFeatures const features_; | |
| 1247 bool collectComments_; | |
| 1248 }; // OurReader | |
| 1249 | |
| 1250 // complete copy of Read impl, for OurReader | |
| 1251 | |
| 1252 bool OurReader::containsNewLine(OurReader::Location begin, | |
| 1253 OurReader::Location end) { | |
| 1254 for (; begin < end; ++begin) | |
| 1255 if (*begin == '\n' || *begin == '\r') | |
| 1256 return true; | |
| 1257 return false; | |
| 1258 } | |
| 1259 | |
| 1260 OurReader::OurReader(OurFeatures const& features) | |
| 1261 : errors_(), document_(), begin_(), end_(), current_(), lastValueEnd_(), | |
| 1262 lastValue_(), commentsBefore_(), features_(features), collectComments_() { | |
| 1263 } | |
| 1264 | |
| 1265 bool OurReader::parse(const char* beginDoc, | |
| 1266 const char* endDoc, | |
| 1267 Value& root, | |
| 1268 bool collectComments) { | |
| 1269 if (!features_.allowComments_) { | |
| 1270 collectComments = false; | |
| 1271 } | |
| 1272 | |
| 1273 begin_ = beginDoc; | |
| 1274 end_ = endDoc; | |
| 1275 collectComments_ = collectComments; | |
| 1276 current_ = begin_; | |
| 1277 lastValueEnd_ = nullptr; | |
| 1278 lastValue_ = nullptr; | |
| 1279 commentsBefore_.clear(); | |
| 1280 errors_.clear(); | |
| 1281 while (!nodes_.empty()) | |
| 1282 nodes_.pop(); | |
| 1283 nodes_.push(&root); | |
| 1284 | |
| 1285 bool successful = readValue(); | |
| 1286 Token token; | |
| 1287 skipCommentTokens(token); | |
| 1288 if (features_.failIfExtra_) { | |
| 1289 if ((features_.strictRoot_ || token.type_ != tokenError) && | |
| 1290 token.type_ != tokenEndOfStream) { | |
| 1291 addError("Extra non-whitespace after JSON value.", token); | |
| 1292 return false; | |
| 1293 } | |
| 1294 } | |
| 1295 if (collectComments_ && !commentsBefore_.empty()) | |
| 1296 root.setComment(commentsBefore_, commentAfter); | |
| 1297 if (features_.strictRoot_) { | |
| 1298 if (!root.isArray() && !root.isObject()) { | |
| 1299 // Set error location to start of doc, ideally should be first token found | |
| 1300 // in doc | |
| 1301 token.type_ = tokenError; | |
| 1302 token.start_ = beginDoc; | |
| 1303 token.end_ = endDoc; | |
| 1304 addError( | |
| 1305 "A valid JSON document must be either an array or an object value.", | |
| 1306 token); | |
| 1307 return false; | |
| 1308 } | |
| 1309 } | |
| 1310 return successful; | |
| 1311 } | |
| 1312 | |
| 1313 bool OurReader::readValue() { | |
| 1314 // To preserve the old behaviour we cast size_t to int. | |
| 1315 if (nodes_.size() > features_.stackLimit_) | |
| 1316 throwRuntimeError("Exceeded stackLimit in readValue()."); | |
| 1317 Token token; | |
| 1318 skipCommentTokens(token); | |
| 1319 bool successful = true; | |
| 1320 | |
| 1321 if (collectComments_ && !commentsBefore_.empty()) { | |
| 1322 currentValue().setComment(commentsBefore_, commentBefore); | |
| 1323 commentsBefore_.clear(); | |
| 1324 } | |
| 1325 | |
| 1326 switch (token.type_) { | |
| 1327 case tokenObjectBegin: | |
| 1328 successful = readObject(token); | |
| 1329 currentValue().setOffsetLimit(current_ - begin_); | |
| 1330 break; | |
| 1331 case tokenArrayBegin: | |
| 1332 successful = readArray(token); | |
| 1333 currentValue().setOffsetLimit(current_ - begin_); | |
| 1334 break; | |
| 1335 case tokenNumber: | |
| 1336 successful = decodeNumber(token); | |
| 1337 break; | |
| 1338 case tokenString: | |
| 1339 successful = decodeString(token); | |
| 1340 break; | |
| 1341 case tokenTrue: { | |
| 1342 Value v(true); | |
| 1343 currentValue().swapPayload(v); | |
| 1344 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1345 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 1346 } break; | |
| 1347 case tokenFalse: { | |
| 1348 Value v(false); | |
| 1349 currentValue().swapPayload(v); | |
| 1350 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1351 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 1352 } break; | |
| 1353 case tokenNull: { | |
| 1354 Value v; | |
| 1355 currentValue().swapPayload(v); | |
| 1356 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1357 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 1358 } break; | |
| 1359 case tokenNaN: { | |
| 1360 Value v(std::numeric_limits<double>::quiet_NaN()); | |
| 1361 currentValue().swapPayload(v); | |
| 1362 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1363 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 1364 } break; | |
| 1365 case tokenPosInf: { | |
| 1366 Value v(std::numeric_limits<double>::infinity()); | |
| 1367 currentValue().swapPayload(v); | |
| 1368 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1369 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 1370 } break; | |
| 1371 case tokenNegInf: { | |
| 1372 Value v(-std::numeric_limits<double>::infinity()); | |
| 1373 currentValue().swapPayload(v); | |
| 1374 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1375 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 1376 } break; | |
| 1377 case tokenArraySeparator: | |
| 1378 case tokenObjectEnd: | |
| 1379 case tokenArrayEnd: | |
| 1380 if (features_.allowDroppedNullPlaceholders_) { | |
| 1381 // "Un-read" the current token and mark the current value as a null | |
| 1382 // token. | |
| 1383 current_--; | |
| 1384 Value v; | |
| 1385 currentValue().swapPayload(v); | |
| 1386 currentValue().setOffsetStart(current_ - begin_ - 1); | |
| 1387 currentValue().setOffsetLimit(current_ - begin_); | |
| 1388 break; | |
| 1389 } // else, fall through ... | |
| 1390 default: | |
| 1391 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1392 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 1393 return addError("Syntax error: value, object or array expected.", token); | |
| 1394 } | |
| 1395 | |
| 1396 if (collectComments_) { | |
| 1397 lastValueEnd_ = current_; | |
| 1398 lastValue_ = ¤tValue(); | |
| 1399 } | |
| 1400 | |
| 1401 return successful; | |
| 1402 } | |
| 1403 | |
| 1404 void OurReader::skipCommentTokens(Token& token) { | |
| 1405 if (features_.allowComments_) { | |
| 1406 do { | |
| 1407 readToken(token); | |
| 1408 } while (token.type_ == tokenComment); | |
| 1409 } else { | |
| 1410 readToken(token); | |
| 1411 } | |
| 1412 } | |
| 1413 | |
| 1414 bool OurReader::readToken(Token& token) { | |
| 1415 skipSpaces(); | |
| 1416 token.start_ = current_; | |
| 1417 Char c = getNextChar(); | |
| 1418 bool ok = true; | |
| 1419 switch (c) { | |
| 1420 case '{': | |
| 1421 token.type_ = tokenObjectBegin; | |
| 1422 break; | |
| 1423 case '}': | |
| 1424 token.type_ = tokenObjectEnd; | |
| 1425 break; | |
| 1426 case '[': | |
| 1427 token.type_ = tokenArrayBegin; | |
| 1428 break; | |
| 1429 case ']': | |
| 1430 token.type_ = tokenArrayEnd; | |
| 1431 break; | |
| 1432 case '"': | |
| 1433 token.type_ = tokenString; | |
| 1434 ok = readString(); | |
| 1435 break; | |
| 1436 case '\'': | |
| 1437 if (features_.allowSingleQuotes_) { | |
| 1438 token.type_ = tokenString; | |
| 1439 ok = readStringSingleQuote(); | |
| 1440 break; | |
| 1441 } // else fall through | |
| 1442 case '/': | |
| 1443 token.type_ = tokenComment; | |
| 1444 ok = readComment(); | |
| 1445 break; | |
| 1446 case '0': | |
| 1447 case '1': | |
| 1448 case '2': | |
| 1449 case '3': | |
| 1450 case '4': | |
| 1451 case '5': | |
| 1452 case '6': | |
| 1453 case '7': | |
| 1454 case '8': | |
| 1455 case '9': | |
| 1456 token.type_ = tokenNumber; | |
| 1457 readNumber(false); | |
| 1458 break; | |
| 1459 case '-': | |
| 1460 if (readNumber(true)) { | |
| 1461 token.type_ = tokenNumber; | |
| 1462 } else { | |
| 1463 token.type_ = tokenNegInf; | |
| 1464 ok = features_.allowSpecialFloats_ && match("nfinity", 7); | |
| 1465 } | |
| 1466 break; | |
| 1467 case 't': | |
| 1468 token.type_ = tokenTrue; | |
| 1469 ok = match("rue", 3); | |
| 1470 break; | |
| 1471 case 'f': | |
| 1472 token.type_ = tokenFalse; | |
| 1473 ok = match("alse", 4); | |
| 1474 break; | |
| 1475 case 'n': | |
| 1476 token.type_ = tokenNull; | |
| 1477 ok = match("ull", 3); | |
| 1478 break; | |
| 1479 case 'N': | |
| 1480 if (features_.allowSpecialFloats_) { | |
| 1481 token.type_ = tokenNaN; | |
| 1482 ok = match("aN", 2); | |
| 1483 } else { | |
| 1484 ok = false; | |
| 1485 } | |
| 1486 break; | |
| 1487 case 'I': | |
| 1488 if (features_.allowSpecialFloats_) { | |
| 1489 token.type_ = tokenPosInf; | |
| 1490 ok = match("nfinity", 7); | |
| 1491 } else { | |
| 1492 ok = false; | |
| 1493 } | |
| 1494 break; | |
| 1495 case ',': | |
| 1496 token.type_ = tokenArraySeparator; | |
| 1497 break; | |
| 1498 case ':': | |
| 1499 token.type_ = tokenMemberSeparator; | |
| 1500 break; | |
| 1501 case 0: | |
| 1502 token.type_ = tokenEndOfStream; | |
| 1503 break; | |
| 1504 default: | |
| 1505 ok = false; | |
| 1506 break; | |
| 1507 } | |
| 1508 if (!ok) | |
| 1509 token.type_ = tokenError; | |
| 1510 token.end_ = current_; | |
| 1511 return true; | |
| 1512 } | |
| 1513 | |
| 1514 void OurReader::skipSpaces() { | |
| 1515 while (current_ != end_) { | |
| 1516 Char c = *current_; | |
| 1517 if (c == ' ' || c == '\t' || c == '\r' || c == '\n') | |
| 1518 ++current_; | |
| 1519 else | |
| 1520 break; | |
| 1521 } | |
| 1522 } | |
| 1523 | |
| 1524 bool OurReader::match(Location pattern, int patternLength) { | |
| 1525 if (end_ - current_ < patternLength) | |
| 1526 return false; | |
| 1527 int index = patternLength; | |
| 1528 while (index--) | |
| 1529 if (current_[index] != pattern[index]) | |
| 1530 return false; | |
| 1531 current_ += patternLength; | |
| 1532 return true; | |
| 1533 } | |
| 1534 | |
| 1535 bool OurReader::readComment() { | |
| 1536 Location commentBegin = current_ - 1; | |
| 1537 Char c = getNextChar(); | |
| 1538 bool successful = false; | |
| 1539 if (c == '*') | |
| 1540 successful = readCStyleComment(); | |
| 1541 else if (c == '/') | |
| 1542 successful = readCppStyleComment(); | |
| 1543 if (!successful) | |
| 1544 return false; | |
| 1545 | |
| 1546 if (collectComments_) { | |
| 1547 CommentPlacement placement = commentBefore; | |
| 1548 if (lastValueEnd_ && !containsNewLine(lastValueEnd_, commentBegin)) { | |
| 1549 if (c != '*' || !containsNewLine(commentBegin, current_)) | |
| 1550 placement = commentAfterOnSameLine; | |
| 1551 } | |
| 1552 | |
| 1553 addComment(commentBegin, current_, placement); | |
| 1554 } | |
| 1555 return true; | |
| 1556 } | |
| 1557 | |
| 1558 String OurReader::normalizeEOL(OurReader::Location begin, | |
| 1559 OurReader::Location end) { | |
| 1560 String normalized; | |
| 1561 normalized.reserve(static_cast<size_t>(end - begin)); | |
| 1562 OurReader::Location current = begin; | |
| 1563 while (current != end) { | |
| 1564 char c = *current++; | |
| 1565 if (c == '\r') { | |
| 1566 if (current != end && *current == '\n') | |
| 1567 // convert dos EOL | |
| 1568 ++current; | |
| 1569 // convert Mac EOL | |
| 1570 normalized += '\n'; | |
| 1571 } else { | |
| 1572 normalized += c; | |
| 1573 } | |
| 1574 } | |
| 1575 return normalized; | |
| 1576 } | |
| 1577 | |
| 1578 void OurReader::addComment(Location begin, | |
| 1579 Location end, | |
| 1580 CommentPlacement placement) { | |
| 1581 assert(collectComments_); | |
| 1582 const String& normalized = normalizeEOL(begin, end); | |
| 1583 if (placement == commentAfterOnSameLine) { | |
| 1584 assert(lastValue_ != nullptr); | |
| 1585 lastValue_->setComment(normalized, placement); | |
| 1586 } else { | |
| 1587 commentsBefore_ += normalized; | |
| 1588 } | |
| 1589 } | |
| 1590 | |
| 1591 bool OurReader::readCStyleComment() { | |
| 1592 while ((current_ + 1) < end_) { | |
| 1593 Char c = getNextChar(); | |
| 1594 if (c == '*' && *current_ == '/') | |
| 1595 break; | |
| 1596 } | |
| 1597 return getNextChar() == '/'; | |
| 1598 } | |
| 1599 | |
| 1600 bool OurReader::readCppStyleComment() { | |
| 1601 while (current_ != end_) { | |
| 1602 Char c = getNextChar(); | |
| 1603 if (c == '\n') | |
| 1604 break; | |
| 1605 if (c == '\r') { | |
| 1606 // Consume DOS EOL. It will be normalized in addComment. | |
| 1607 if (current_ != end_ && *current_ == '\n') | |
| 1608 getNextChar(); | |
| 1609 // Break on Moc OS 9 EOL. | |
| 1610 break; | |
| 1611 } | |
| 1612 } | |
| 1613 return true; | |
| 1614 } | |
| 1615 | |
| 1616 bool OurReader::readNumber(bool checkInf) { | |
| 1617 const char* p = current_; | |
| 1618 if (checkInf && p != end_ && *p == 'I') { | |
| 1619 current_ = ++p; | |
| 1620 return false; | |
| 1621 } | |
| 1622 char c = '0'; // stopgap for already consumed character | |
| 1623 // integral part | |
| 1624 while (c >= '0' && c <= '9') | |
| 1625 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 1626 // fractional part | |
| 1627 if (c == '.') { | |
| 1628 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 1629 while (c >= '0' && c <= '9') | |
| 1630 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 1631 } | |
| 1632 // exponential part | |
| 1633 if (c == 'e' || c == 'E') { | |
| 1634 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 1635 if (c == '+' || c == '-') | |
| 1636 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 1637 while (c >= '0' && c <= '9') | |
| 1638 c = (current_ = p) < end_ ? *p++ : '\0'; | |
| 1639 } | |
| 1640 return true; | |
| 1641 } | |
| 1642 bool OurReader::readString() { | |
| 1643 Char c = 0; | |
| 1644 while (current_ != end_) { | |
| 1645 c = getNextChar(); | |
| 1646 if (c == '\\') | |
| 1647 getNextChar(); | |
| 1648 else if (c == '"') | |
| 1649 break; | |
| 1650 } | |
| 1651 return c == '"'; | |
| 1652 } | |
| 1653 | |
| 1654 bool OurReader::readStringSingleQuote() { | |
| 1655 Char c = 0; | |
| 1656 while (current_ != end_) { | |
| 1657 c = getNextChar(); | |
| 1658 if (c == '\\') | |
| 1659 getNextChar(); | |
| 1660 else if (c == '\'') | |
| 1661 break; | |
| 1662 } | |
| 1663 return c == '\''; | |
| 1664 } | |
| 1665 | |
| 1666 bool OurReader::readObject(Token& token) { | |
| 1667 Token tokenName; | |
| 1668 String name; | |
| 1669 Value init(objectValue); | |
| 1670 currentValue().swapPayload(init); | |
| 1671 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1672 while (readToken(tokenName)) { | |
| 1673 bool initialTokenOk = true; | |
| 1674 while (tokenName.type_ == tokenComment && initialTokenOk) | |
| 1675 initialTokenOk = readToken(tokenName); | |
| 1676 if (!initialTokenOk) | |
| 1677 break; | |
| 1678 if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object | |
| 1679 return true; | |
| 1680 name.clear(); | |
| 1681 if (tokenName.type_ == tokenString) { | |
| 1682 if (!decodeString(tokenName, name)) | |
| 1683 return recoverFromError(tokenObjectEnd); | |
| 1684 } else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) { | |
| 1685 Value numberName; | |
| 1686 if (!decodeNumber(tokenName, numberName)) | |
| 1687 return recoverFromError(tokenObjectEnd); | |
| 1688 name = numberName.asString(); | |
| 1689 } else { | |
| 1690 break; | |
| 1691 } | |
| 1692 | |
| 1693 Token colon; | |
| 1694 if (!readToken(colon) || colon.type_ != tokenMemberSeparator) { | |
| 1695 return addErrorAndRecover("Missing ':' after object member name", colon, | |
| 1696 tokenObjectEnd); | |
| 1697 } | |
| 1698 if (name.length() >= (1U << 30)) | |
| 1699 throwRuntimeError("keylength >= 2^30"); | |
| 1700 if (features_.rejectDupKeys_ && currentValue().isMember(name)) { | |
| 1701 String msg = "Duplicate key: '" + name + "'"; | |
| 1702 return addErrorAndRecover(msg, tokenName, tokenObjectEnd); | |
| 1703 } | |
| 1704 Value& value = currentValue()[name]; | |
| 1705 nodes_.push(&value); | |
| 1706 bool ok = readValue(); | |
| 1707 nodes_.pop(); | |
| 1708 if (!ok) // error already set | |
| 1709 return recoverFromError(tokenObjectEnd); | |
| 1710 | |
| 1711 Token comma; | |
| 1712 if (!readToken(comma) || | |
| 1713 (comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator && | |
| 1714 comma.type_ != tokenComment)) { | |
| 1715 return addErrorAndRecover("Missing ',' or '}' in object declaration", | |
| 1716 comma, tokenObjectEnd); | |
| 1717 } | |
| 1718 bool finalizeTokenOk = true; | |
| 1719 while (comma.type_ == tokenComment && finalizeTokenOk) | |
| 1720 finalizeTokenOk = readToken(comma); | |
| 1721 if (comma.type_ == tokenObjectEnd) | |
| 1722 return true; | |
| 1723 } | |
| 1724 return addErrorAndRecover("Missing '}' or object member name", tokenName, | |
| 1725 tokenObjectEnd); | |
| 1726 } | |
| 1727 | |
| 1728 bool OurReader::readArray(Token& token) { | |
| 1729 Value init(arrayValue); | |
| 1730 currentValue().swapPayload(init); | |
| 1731 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1732 skipSpaces(); | |
| 1733 if (current_ != end_ && *current_ == ']') // empty array | |
| 1734 { | |
| 1735 Token endArray; | |
| 1736 readToken(endArray); | |
| 1737 return true; | |
| 1738 } | |
| 1739 int index = 0; | |
| 1740 for (;;) { | |
| 1741 Value& value = currentValue()[index++]; | |
| 1742 nodes_.push(&value); | |
| 1743 bool ok = readValue(); | |
| 1744 nodes_.pop(); | |
| 1745 if (!ok) // error already set | |
| 1746 return recoverFromError(tokenArrayEnd); | |
| 1747 | |
| 1748 Token currentToken; | |
| 1749 // Accept Comment after last item in the array. | |
| 1750 ok = readToken(currentToken); | |
| 1751 while (currentToken.type_ == tokenComment && ok) { | |
| 1752 ok = readToken(currentToken); | |
| 1753 } | |
| 1754 bool badTokenType = (currentToken.type_ != tokenArraySeparator && | |
| 1755 currentToken.type_ != tokenArrayEnd); | |
| 1756 if (!ok || badTokenType) { | |
| 1757 return addErrorAndRecover("Missing ',' or ']' in array declaration", | |
| 1758 currentToken, tokenArrayEnd); | |
| 1759 } | |
| 1760 if (currentToken.type_ == tokenArrayEnd) | |
| 1761 break; | |
| 1762 } | |
| 1763 return true; | |
| 1764 } | |
| 1765 | |
| 1766 bool OurReader::decodeNumber(Token& token) { | |
| 1767 Value decoded; | |
| 1768 if (!decodeNumber(token, decoded)) | |
| 1769 return false; | |
| 1770 currentValue().swapPayload(decoded); | |
| 1771 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1772 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 1773 return true; | |
| 1774 } | |
| 1775 | |
| 1776 bool OurReader::decodeNumber(Token& token, Value& decoded) { | |
| 1777 // Attempts to parse the number as an integer. If the number is | |
| 1778 // larger than the maximum supported value of an integer then | |
| 1779 // we decode the number as a double. | |
| 1780 Location current = token.start_; | |
| 1781 bool isNegative = *current == '-'; | |
| 1782 if (isNegative) | |
| 1783 ++current; | |
| 1784 // TODO: Help the compiler do the div and mod at compile time or get rid of | |
| 1785 // them. | |
| 1786 Value::LargestUInt maxIntegerValue = | |
| 1787 isNegative ? Value::LargestUInt(Value::minLargestInt) | |
| 1788 : Value::maxLargestUInt; | |
| 1789 Value::LargestUInt threshold = maxIntegerValue / 10; | |
| 1790 Value::LargestUInt value = 0; | |
| 1791 while (current < token.end_) { | |
| 1792 Char c = *current++; | |
| 1793 if (c < '0' || c > '9') | |
| 1794 return decodeDouble(token, decoded); | |
| 1795 auto digit(static_cast<Value::UInt>(c - '0')); | |
| 1796 if (value >= threshold) { | |
| 1797 // We've hit or exceeded the max value divided by 10 (rounded down). If | |
| 1798 // a) we've only just touched the limit, b) this is the last digit, and | |
| 1799 // c) it's small enough to fit in that rounding delta, we're okay. | |
| 1800 // Otherwise treat this number as a double to avoid overflow. | |
| 1801 if (value > threshold || current != token.end_ || | |
| 1802 digit > maxIntegerValue % 10) { | |
| 1803 return decodeDouble(token, decoded); | |
| 1804 } | |
| 1805 } | |
| 1806 value = value * 10 + digit; | |
| 1807 } | |
| 1808 if (isNegative) | |
| 1809 decoded = -Value::LargestInt(value); | |
| 1810 else if (value <= Value::LargestUInt(Value::maxInt)) | |
| 1811 decoded = Value::LargestInt(value); | |
| 1812 else | |
| 1813 decoded = value; | |
| 1814 return true; | |
| 1815 } | |
| 1816 | |
| 1817 bool OurReader::decodeDouble(Token& token) { | |
| 1818 Value decoded; | |
| 1819 if (!decodeDouble(token, decoded)) | |
| 1820 return false; | |
| 1821 currentValue().swapPayload(decoded); | |
| 1822 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1823 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 1824 return true; | |
| 1825 } | |
| 1826 | |
| 1827 bool OurReader::decodeDouble(Token& token, Value& decoded) { | |
| 1828 double value = 0; | |
| 1829 const int bufferSize = 32; | |
| 1830 int count; | |
| 1831 ptrdiff_t const length = token.end_ - token.start_; | |
| 1832 | |
| 1833 // Sanity check to avoid buffer overflow exploits. | |
| 1834 if (length < 0) { | |
| 1835 return addError("Unable to parse token length", token); | |
| 1836 } | |
| 1837 auto const ulength = static_cast<size_t>(length); | |
| 1838 | |
| 1839 // Avoid using a string constant for the format control string given to | |
| 1840 // sscanf, as this can cause hard to debug crashes on OS X. See here for more | |
| 1841 // info: | |
| 1842 // | |
| 1843 // http://developer.apple.com/library/mac/#DOCUMENTATION/DeveloperTools/gcc-4.0.1/gcc/Incompatibilities.html | |
| 1844 char format[] = "%lf"; | |
| 1845 | |
| 1846 if (length <= bufferSize) { | |
| 1847 Char buffer[bufferSize + 1]; | |
| 1848 memcpy(buffer, token.start_, ulength); | |
| 1849 buffer[length] = 0; | |
| 1850 fixNumericLocaleInput(buffer, buffer + length); | |
| 1851 count = sscanf(buffer, format, &value); | |
| 1852 } else { | |
| 1853 String buffer(token.start_, token.end_); | |
| 1854 count = sscanf(buffer.c_str(), format, &value); | |
| 1855 } | |
| 1856 | |
| 1857 if (count != 1) | |
| 1858 return addError( | |
| 1859 "'" + String(token.start_, token.end_) + "' is not a number.", token); | |
| 1860 decoded = value; | |
| 1861 return true; | |
| 1862 } | |
| 1863 | |
| 1864 bool OurReader::decodeString(Token& token) { | |
| 1865 String decoded_string; | |
| 1866 if (!decodeString(token, decoded_string)) | |
| 1867 return false; | |
| 1868 Value decoded(decoded_string); | |
| 1869 currentValue().swapPayload(decoded); | |
| 1870 currentValue().setOffsetStart(token.start_ - begin_); | |
| 1871 currentValue().setOffsetLimit(token.end_ - begin_); | |
| 1872 return true; | |
| 1873 } | |
| 1874 | |
| 1875 bool OurReader::decodeString(Token& token, String& decoded) { | |
| 1876 decoded.reserve(static_cast<size_t>(token.end_ - token.start_ - 2)); | |
| 1877 Location current = token.start_ + 1; // skip '"' | |
| 1878 Location end = token.end_ - 1; // do not include '"' | |
| 1879 while (current != end) { | |
| 1880 Char c = *current++; | |
| 1881 if (c == '"') | |
| 1882 break; | |
| 1883 else if (c == '\\') { | |
| 1884 if (current == end) | |
| 1885 return addError("Empty escape sequence in string", token, current); | |
| 1886 Char escape = *current++; | |
| 1887 switch (escape) { | |
| 1888 case '"': | |
| 1889 decoded += '"'; | |
| 1890 break; | |
| 1891 case '/': | |
| 1892 decoded += '/'; | |
| 1893 break; | |
| 1894 case '\\': | |
| 1895 decoded += '\\'; | |
| 1896 break; | |
| 1897 case 'b': | |
| 1898 decoded += '\b'; | |
| 1899 break; | |
| 1900 case 'f': | |
| 1901 decoded += '\f'; | |
| 1902 break; | |
| 1903 case 'n': | |
| 1904 decoded += '\n'; | |
| 1905 break; | |
| 1906 case 'r': | |
| 1907 decoded += '\r'; | |
| 1908 break; | |
| 1909 case 't': | |
| 1910 decoded += '\t'; | |
| 1911 break; | |
| 1912 case 'u': { | |
| 1913 unsigned int unicode; | |
| 1914 if (!decodeUnicodeCodePoint(token, current, end, unicode)) | |
| 1915 return false; | |
| 1916 decoded += codePointToUTF8(unicode); | |
| 1917 } break; | |
| 1918 default: | |
| 1919 return addError("Bad escape sequence in string", token, current); | |
| 1920 } | |
| 1921 } else { | |
| 1922 decoded += c; | |
| 1923 } | |
| 1924 } | |
| 1925 return true; | |
| 1926 } | |
| 1927 | |
| 1928 bool OurReader::decodeUnicodeCodePoint(Token& token, | |
| 1929 Location& current, | |
| 1930 Location end, | |
| 1931 unsigned int& unicode) { | |
| 1932 | |
| 1933 if (!decodeUnicodeEscapeSequence(token, current, end, unicode)) | |
| 1934 return false; | |
| 1935 if (unicode >= 0xD800 && unicode <= 0xDBFF) { | |
| 1936 // surrogate pairs | |
| 1937 if (end - current < 6) | |
| 1938 return addError( | |
| 1939 "additional six characters expected to parse unicode surrogate pair.", | |
| 1940 token, current); | |
| 1941 if (*(current++) == '\\' && *(current++) == 'u') { | |
| 1942 unsigned int surrogatePair; | |
| 1943 if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) { | |
| 1944 unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF); | |
| 1945 } else | |
| 1946 return false; | |
| 1947 } else | |
| 1948 return addError("expecting another \\u token to begin the second half of " | |
| 1949 "a unicode surrogate pair", | |
| 1950 token, current); | |
| 1951 } | |
| 1952 return true; | |
| 1953 } | |
| 1954 | |
| 1955 bool OurReader::decodeUnicodeEscapeSequence(Token& token, | |
| 1956 Location& current, | |
| 1957 Location end, | |
| 1958 unsigned int& ret_unicode) { | |
| 1959 if (end - current < 4) | |
| 1960 return addError( | |
| 1961 "Bad unicode escape sequence in string: four digits expected.", token, | |
| 1962 current); | |
| 1963 int unicode = 0; | |
| 1964 for (int index = 0; index < 4; ++index) { | |
| 1965 Char c = *current++; | |
| 1966 unicode *= 16; | |
| 1967 if (c >= '0' && c <= '9') | |
| 1968 unicode += c - '0'; | |
| 1969 else if (c >= 'a' && c <= 'f') | |
| 1970 unicode += c - 'a' + 10; | |
| 1971 else if (c >= 'A' && c <= 'F') | |
| 1972 unicode += c - 'A' + 10; | |
| 1973 else | |
| 1974 return addError( | |
| 1975 "Bad unicode escape sequence in string: hexadecimal digit expected.", | |
| 1976 token, current); | |
| 1977 } | |
| 1978 ret_unicode = static_cast<unsigned int>(unicode); | |
| 1979 return true; | |
| 1980 } | |
| 1981 | |
| 1982 bool OurReader::addError(const String& message, Token& token, Location extra) { | |
| 1983 ErrorInfo info; | |
| 1984 info.token_ = token; | |
| 1985 info.message_ = message; | |
| 1986 info.extra_ = extra; | |
| 1987 errors_.push_back(info); | |
| 1988 return false; | |
| 1989 } | |
| 1990 | |
| 1991 bool OurReader::recoverFromError(TokenType skipUntilToken) { | |
| 1992 size_t errorCount = errors_.size(); | |
| 1993 Token skip; | |
| 1994 for (;;) { | |
| 1995 if (!readToken(skip)) | |
| 1996 errors_.resize(errorCount); // discard errors caused by recovery | |
| 1997 if (skip.type_ == skipUntilToken || skip.type_ == tokenEndOfStream) | |
| 1998 break; | |
| 1999 } | |
| 2000 errors_.resize(errorCount); | |
| 2001 return false; | |
| 2002 } | |
| 2003 | |
| 2004 bool OurReader::addErrorAndRecover(const String& message, | |
| 2005 Token& token, | |
| 2006 TokenType skipUntilToken) { | |
| 2007 addError(message, token); | |
| 2008 return recoverFromError(skipUntilToken); | |
| 2009 } | |
| 2010 | |
| 2011 Value& OurReader::currentValue() { return *(nodes_.top()); } | |
| 2012 | |
| 2013 OurReader::Char OurReader::getNextChar() { | |
| 2014 if (current_ == end_) | |
| 2015 return 0; | |
| 2016 return *current_++; | |
| 2017 } | |
| 2018 | |
| 2019 void OurReader::getLocationLineAndColumn(Location location, | |
| 2020 int& line, | |
| 2021 int& column) const { | |
| 2022 Location current = begin_; | |
| 2023 Location lastLineStart = current; | |
| 2024 line = 0; | |
| 2025 while (current < location && current != end_) { | |
| 2026 Char c = *current++; | |
| 2027 if (c == '\r') { | |
| 2028 if (*current == '\n') | |
| 2029 ++current; | |
| 2030 lastLineStart = current; | |
| 2031 ++line; | |
| 2032 } else if (c == '\n') { | |
| 2033 lastLineStart = current; | |
| 2034 ++line; | |
| 2035 } | |
| 2036 } | |
| 2037 // column & line start at 1 | |
| 2038 column = int(location - lastLineStart) + 1; | |
| 2039 ++line; | |
| 2040 } | |
| 2041 | |
| 2042 String OurReader::getLocationLineAndColumn(Location location) const { | |
| 2043 int line, column; | |
| 2044 getLocationLineAndColumn(location, line, column); | |
| 2045 char buffer[18 + 16 + 16 + 1]; | |
| 2046 jsoncpp_snprintf(buffer, sizeof(buffer), "Line %d, Column %d", line, column); | |
| 2047 return buffer; | |
| 2048 } | |
| 2049 | |
| 2050 String OurReader::getFormattedErrorMessages() const { | |
| 2051 String formattedMessage; | |
| 2052 for (const auto& error : errors_) { | |
| 2053 formattedMessage += | |
| 2054 "* " + getLocationLineAndColumn(error.token_.start_) + "\n"; | |
| 2055 formattedMessage += " " + error.message_ + "\n"; | |
| 2056 if (error.extra_) | |
| 2057 formattedMessage += | |
| 2058 "See " + getLocationLineAndColumn(error.extra_) + " for detail.\n"; | |
| 2059 } | |
| 2060 return formattedMessage; | |
| 2061 } | |
| 2062 | |
| 2063 std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const { | |
| 2064 std::vector<OurReader::StructuredError> allErrors; | |
| 2065 for (const auto& error : errors_) { | |
| 2066 OurReader::StructuredError structured; | |
| 2067 structured.offset_start = error.token_.start_ - begin_; | |
| 2068 structured.offset_limit = error.token_.end_ - begin_; | |
| 2069 structured.message = error.message_; | |
| 2070 allErrors.push_back(structured); | |
| 2071 } | |
| 2072 return allErrors; | |
| 2073 } | |
| 2074 | |
| 2075 bool OurReader::pushError(const Value& value, const String& message) { | |
| 2076 ptrdiff_t length = end_ - begin_; | |
| 2077 if (value.getOffsetStart() > length || value.getOffsetLimit() > length) | |
| 2078 return false; | |
| 2079 Token token; | |
| 2080 token.type_ = tokenError; | |
| 2081 token.start_ = begin_ + value.getOffsetStart(); | |
| 2082 token.end_ = end_ + value.getOffsetLimit(); | |
| 2083 ErrorInfo info; | |
| 2084 info.token_ = token; | |
| 2085 info.message_ = message; | |
| 2086 info.extra_ = nullptr; | |
| 2087 errors_.push_back(info); | |
| 2088 return true; | |
| 2089 } | |
| 2090 | |
| 2091 bool OurReader::pushError(const Value& value, | |
| 2092 const String& message, | |
| 2093 const Value& extra) { | |
| 2094 ptrdiff_t length = end_ - begin_; | |
| 2095 if (value.getOffsetStart() > length || value.getOffsetLimit() > length || | |
| 2096 extra.getOffsetLimit() > length) | |
| 2097 return false; | |
| 2098 Token token; | |
| 2099 token.type_ = tokenError; | |
| 2100 token.start_ = begin_ + value.getOffsetStart(); | |
| 2101 token.end_ = begin_ + value.getOffsetLimit(); | |
| 2102 ErrorInfo info; | |
| 2103 info.token_ = token; | |
| 2104 info.message_ = message; | |
| 2105 info.extra_ = begin_ + extra.getOffsetStart(); | |
| 2106 errors_.push_back(info); | |
| 2107 return true; | |
| 2108 } | |
| 2109 | |
| 2110 bool OurReader::good() const { return errors_.empty(); } | |
| 2111 | |
| 2112 class OurCharReader : public CharReader { | |
| 2113 bool const collectComments_; | |
| 2114 OurReader reader_; | |
| 2115 | |
| 2116 public: | |
| 2117 OurCharReader(bool collectComments, OurFeatures const& features) | |
| 2118 : collectComments_(collectComments), reader_(features) {} | |
| 2119 bool parse(char const* beginDoc, | |
| 2120 char const* endDoc, | |
| 2121 Value* root, | |
| 2122 String* errs) override { | |
| 2123 bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_); | |
| 2124 if (errs) { | |
| 2125 *errs = reader_.getFormattedErrorMessages(); | |
| 2126 } | |
| 2127 return ok; | |
| 2128 } | |
| 2129 }; | |
| 2130 | |
| 2131 CharReaderBuilder::CharReaderBuilder() { setDefaults(&settings_); } | |
| 2132 CharReaderBuilder::~CharReaderBuilder() = default; | |
| 2133 CharReader* CharReaderBuilder::newCharReader() const { | |
| 2134 bool collectComments = settings_["collectComments"].asBool(); | |
| 2135 OurFeatures features = OurFeatures::all(); | |
| 2136 features.allowComments_ = settings_["allowComments"].asBool(); | |
| 2137 features.strictRoot_ = settings_["strictRoot"].asBool(); | |
| 2138 features.allowDroppedNullPlaceholders_ = | |
| 2139 settings_["allowDroppedNullPlaceholders"].asBool(); | |
| 2140 features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool(); | |
| 2141 features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool(); | |
| 2142 #if defined(JSON_HAS_INT64) | |
| 2143 features.stackLimit_ = settings_["stackLimit"].asUInt64(); | |
| 2144 #else | |
| 2145 features.stackLimit_ = settings_["stackLimit"].asUInt(); | |
| 2146 #endif | |
| 2147 features.failIfExtra_ = settings_["failIfExtra"].asBool(); | |
| 2148 features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool(); | |
| 2149 features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool(); | |
| 2150 return new OurCharReader(collectComments, features); | |
| 2151 } | |
| 2152 static void getValidReaderKeys(std::set<String>* valid_keys) { | |
| 2153 valid_keys->clear(); | |
| 2154 valid_keys->insert("collectComments"); | |
| 2155 valid_keys->insert("allowComments"); | |
| 2156 valid_keys->insert("strictRoot"); | |
| 2157 valid_keys->insert("allowDroppedNullPlaceholders"); | |
| 2158 valid_keys->insert("allowNumericKeys"); | |
| 2159 valid_keys->insert("allowSingleQuotes"); | |
| 2160 valid_keys->insert("stackLimit"); | |
| 2161 valid_keys->insert("failIfExtra"); | |
| 2162 valid_keys->insert("rejectDupKeys"); | |
| 2163 valid_keys->insert("allowSpecialFloats"); | |
| 2164 } | |
| 2165 bool CharReaderBuilder::validate(Json::Value* invalid) const { | |
| 2166 Json::Value my_invalid; | |
| 2167 if (!invalid) | |
| 2168 invalid = &my_invalid; // so we do not need to test for NULL | |
| 2169 Json::Value& inv = *invalid; | |
| 2170 std::set<String> valid_keys; | |
| 2171 getValidReaderKeys(&valid_keys); | |
| 2172 Value::Members keys = settings_.getMemberNames(); | |
| 2173 size_t n = keys.size(); | |
| 2174 for (size_t i = 0; i < n; ++i) { | |
| 2175 String const& key = keys[i]; | |
| 2176 if (valid_keys.find(key) == valid_keys.end()) { | |
| 2177 inv[key] = settings_[key]; | |
| 2178 } | |
| 2179 } | |
| 2180 return inv.empty(); | |
| 2181 } | |
| 2182 Value& CharReaderBuilder::operator[](const String& key) { | |
| 2183 return settings_[key]; | |
| 2184 } | |
| 2185 // static | |
| 2186 void CharReaderBuilder::strictMode(Json::Value* settings) { | |
| 2187 //! [CharReaderBuilderStrictMode] | |
| 2188 (*settings)["allowComments"] = false; | |
| 2189 (*settings)["strictRoot"] = true; | |
| 2190 (*settings)["allowDroppedNullPlaceholders"] = false; | |
| 2191 (*settings)["allowNumericKeys"] = false; | |
| 2192 (*settings)["allowSingleQuotes"] = false; | |
| 2193 (*settings)["stackLimit"] = 1000; | |
| 2194 (*settings)["failIfExtra"] = true; | |
| 2195 (*settings)["rejectDupKeys"] = true; | |
| 2196 (*settings)["allowSpecialFloats"] = false; | |
| 2197 //! [CharReaderBuilderStrictMode] | |
| 2198 } | |
| 2199 // static | |
| 2200 void CharReaderBuilder::setDefaults(Json::Value* settings) { | |
| 2201 //! [CharReaderBuilderDefaults] | |
| 2202 (*settings)["collectComments"] = true; | |
| 2203 (*settings)["allowComments"] = true; | |
| 2204 (*settings)["strictRoot"] = false; | |
| 2205 (*settings)["allowDroppedNullPlaceholders"] = false; | |
| 2206 (*settings)["allowNumericKeys"] = false; | |
| 2207 (*settings)["allowSingleQuotes"] = false; | |
| 2208 (*settings)["stackLimit"] = 1000; | |
| 2209 (*settings)["failIfExtra"] = false; | |
| 2210 (*settings)["rejectDupKeys"] = false; | |
| 2211 (*settings)["allowSpecialFloats"] = false; | |
| 2212 //! [CharReaderBuilderDefaults] | |
| 2213 } | |
| 2214 | |
| 2215 ////////////////////////////////// | |
| 2216 // global functions | |
| 2217 | |
| 2218 bool parseFromStream(CharReader::Factory const& fact, | |
| 2219 IStream& sin, | |
| 2220 Value* root, | |
| 2221 String* errs) { | |
| 2222 OStringStream ssin; | |
| 2223 ssin << sin.rdbuf(); | |
| 2224 String doc = ssin.str(); | |
| 2225 char const* begin = doc.data(); | |
| 2226 char const* end = begin + doc.size(); | |
| 2227 // Note that we do not actually need a null-terminator. | |
| 2228 CharReaderPtr const reader(fact.newCharReader()); | |
| 2229 return reader->parse(begin, end, root, errs); | |
| 2230 } | |
| 2231 | |
| 2232 IStream& operator>>(IStream& sin, Value& root) { | |
| 2233 CharReaderBuilder b; | |
| 2234 String errs; | |
| 2235 bool ok = parseFromStream(b, sin, &root, &errs); | |
| 2236 if (!ok) { | |
| 2237 throwRuntimeError(errs); | |
| 2238 } | |
| 2239 return sin; | |
| 2240 } | |
| 2241 | |
| 2242 } // namespace Json | |
| 2243 | |
| 2244 // ////////////////////////////////////////////////////////////////////// | |
| 2245 // End of content of file: src/lib_json/json_reader.cpp | |
| 2246 // ////////////////////////////////////////////////////////////////////// | |
| 2247 | |
| 2248 | |
| 2249 | |
| 2250 | |
| 2251 | |
| 2252 | |
| 2253 // ////////////////////////////////////////////////////////////////////// | |
| 2254 // Beginning of content of file: src/lib_json/json_valueiterator.inl | |
| 2255 // ////////////////////////////////////////////////////////////////////// | |
| 2256 | |
| 2257 // Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors | |
| 2258 // Distributed under MIT license, or public domain if desired and | |
| 2259 // recognized in your jurisdiction. | |
| 2260 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE | |
| 2261 | |
| 2262 // included by json_value.cpp | |
| 2263 | |
| 2264 namespace Json { | |
| 2265 | |
| 2266 // ////////////////////////////////////////////////////////////////// | |
| 2267 // ////////////////////////////////////////////////////////////////// | |
| 2268 // ////////////////////////////////////////////////////////////////// | |
| 2269 // class ValueIteratorBase | |
| 2270 // ////////////////////////////////////////////////////////////////// | |
| 2271 // ////////////////////////////////////////////////////////////////// | |
| 2272 // ////////////////////////////////////////////////////////////////// | |
| 2273 | |
| 2274 ValueIteratorBase::ValueIteratorBase() : current_() {} | |
| 2275 | |
| 2276 ValueIteratorBase::ValueIteratorBase( | |
| 2277 const Value::ObjectValues::iterator& current) | |
| 2278 : current_(current), isNull_(false) {} | |
| 2279 | |
| 2280 Value& ValueIteratorBase::deref() const { return current_->second; } | |
| 2281 | |
| 2282 void ValueIteratorBase::increment() { ++current_; } | |
| 2283 | |
| 2284 void ValueIteratorBase::decrement() { --current_; } | |
| 2285 | |
| 2286 ValueIteratorBase::difference_type | |
| 2287 ValueIteratorBase::computeDistance(const SelfType& other) const { | |
| 2288 #ifdef JSON_USE_CPPTL_SMALLMAP | |
| 2289 return other.current_ - current_; | |
| 2290 #else | |
| 2291 // Iterator for null value are initialized using the default | |
| 2292 // constructor, which initialize current_ to the default | |
| 2293 // std::map::iterator. As begin() and end() are two instance | |
| 2294 // of the default std::map::iterator, they can not be compared. | |
| 2295 // To allow this, we handle this comparison specifically. | |
| 2296 if (isNull_ && other.isNull_) { | |
| 2297 return 0; | |
| 2298 } | |
| 2299 | |
| 2300 // Usage of std::distance is not portable (does not compile with Sun Studio 12 | |
| 2301 // RogueWave STL, | |
| 2302 // which is the one used by default). | |
| 2303 // Using a portable hand-made version for non random iterator instead: | |
| 2304 // return difference_type( std::distance( current_, other.current_ ) ); | |
| 2305 difference_type myDistance = 0; | |
| 2306 for (Value::ObjectValues::iterator it = current_; it != other.current_; | |
| 2307 ++it) { | |
| 2308 ++myDistance; | |
| 2309 } | |
| 2310 return myDistance; | |
| 2311 #endif | |
| 2312 } | |
| 2313 | |
| 2314 bool ValueIteratorBase::isEqual(const SelfType& other) const { | |
| 2315 if (isNull_) { | |
| 2316 return other.isNull_; | |
| 2317 } | |
| 2318 return current_ == other.current_; | |
| 2319 } | |
| 2320 | |
| 2321 void ValueIteratorBase::copy(const SelfType& other) { | |
| 2322 current_ = other.current_; | |
| 2323 isNull_ = other.isNull_; | |
| 2324 } | |
| 2325 | |
| 2326 Value ValueIteratorBase::key() const { | |
| 2327 const Value::CZString czstring = (*current_).first; | |
| 2328 if (czstring.data()) { | |
| 2329 if (czstring.isStaticString()) | |
| 2330 return Value(StaticString(czstring.data())); | |
| 2331 return Value(czstring.data(), czstring.data() + czstring.length()); | |
| 2332 } | |
| 2333 return Value(czstring.index()); | |
| 2334 } | |
| 2335 | |
| 2336 UInt ValueIteratorBase::index() const { | |
| 2337 const Value::CZString czstring = (*current_).first; | |
| 2338 if (!czstring.data()) | |
| 2339 return czstring.index(); | |
| 2340 return Value::UInt(-1); | |
| 2341 } | |
| 2342 | |
| 2343 String ValueIteratorBase::name() const { | |
| 2344 char const* keey; | |
| 2345 char const* end; | |
| 2346 keey = memberName(&end); | |
| 2347 if (!keey) | |
| 2348 return String(); | |
| 2349 return String(keey, end); | |
| 2350 } | |
| 2351 | |
| 2352 char const* ValueIteratorBase::memberName() const { | |
| 2353 const char* cname = (*current_).first.data(); | |
| 2354 return cname ? cname : ""; | |
| 2355 } | |
| 2356 | |
| 2357 char const* ValueIteratorBase::memberName(char const** end) const { | |
| 2358 const char* cname = (*current_).first.data(); | |
| 2359 if (!cname) { | |
| 2360 *end = nullptr; | |
| 2361 return nullptr; | |
| 2362 } | |
| 2363 *end = cname + (*current_).first.length(); | |
| 2364 return cname; | |
| 2365 } | |
| 2366 | |
| 2367 // ////////////////////////////////////////////////////////////////// | |
| 2368 // ////////////////////////////////////////////////////////////////// | |
| 2369 // ////////////////////////////////////////////////////////////////// | |
| 2370 // class ValueConstIterator | |
| 2371 // ////////////////////////////////////////////////////////////////// | |
| 2372 // ////////////////////////////////////////////////////////////////// | |
| 2373 // ////////////////////////////////////////////////////////////////// | |
| 2374 | |
| 2375 ValueConstIterator::ValueConstIterator() = default; | |
| 2376 | |
| 2377 ValueConstIterator::ValueConstIterator( | |
| 2378 const Value::ObjectValues::iterator& current) | |
| 2379 : ValueIteratorBase(current) {} | |
| 2380 | |
| 2381 ValueConstIterator::ValueConstIterator(ValueIterator const& other) | |
| 2382 : ValueIteratorBase(other) {} | |
| 2383 | |
| 2384 ValueConstIterator& ValueConstIterator:: | |
| 2385 operator=(const ValueIteratorBase& other) { | |
| 2386 copy(other); | |
| 2387 return *this; | |
| 2388 } | |
| 2389 | |
| 2390 // ////////////////////////////////////////////////////////////////// | |
| 2391 // ////////////////////////////////////////////////////////////////// | |
| 2392 // ////////////////////////////////////////////////////////////////// | |
| 2393 // class ValueIterator | |
| 2394 // ////////////////////////////////////////////////////////////////// | |
| 2395 // ////////////////////////////////////////////////////////////////// | |
| 2396 // ////////////////////////////////////////////////////////////////// | |
| 2397 | |
| 2398 ValueIterator::ValueIterator() = default; | |
| 2399 | |
| 2400 ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current) | |
| 2401 : ValueIteratorBase(current) {} | |
| 2402 | |
| 2403 ValueIterator::ValueIterator(const ValueConstIterator& other) | |
| 2404 : ValueIteratorBase(other) { | |
| 2405 throwRuntimeError("ConstIterator to Iterator should never be allowed."); | |
| 2406 } | |
| 2407 | |
| 2408 ValueIterator::ValueIterator(const ValueIterator& other) = default; | |
| 2409 | |
| 2410 ValueIterator& ValueIterator::operator=(const SelfType& other) { | |
| 2411 copy(other); | |
| 2412 return *this; | |
| 2413 } | |
| 2414 | |
| 2415 } // namespace Json | |
| 2416 | |
| 2417 // ////////////////////////////////////////////////////////////////////// | |
| 2418 // End of content of file: src/lib_json/json_valueiterator.inl | |
| 2419 // ////////////////////////////////////////////////////////////////////// | |
| 2420 | |
| 2421 | |
| 2422 | |
| 2423 | |
| 2424 | |
| 2425 | |
| 2426 // ////////////////////////////////////////////////////////////////////// | |
| 2427 // Beginning of content of file: src/lib_json/json_value.cpp | |
| 2428 // ////////////////////////////////////////////////////////////////////// | |
| 2429 | |
| 2430 // Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors | |
| 2431 // Distributed under MIT license, or public domain if desired and | |
| 2432 // recognized in your jurisdiction. | |
| 2433 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE | |
| 2434 | |
| 2435 #if !defined(JSON_IS_AMALGAMATION) | |
| 2436 #include <json/assertions.h> | |
| 2437 #include <json/value.h> | |
| 2438 #include <json/writer.h> | |
| 2439 #endif // if !defined(JSON_IS_AMALGAMATION) | |
| 2440 #include <cassert> | |
| 2441 #include <cmath> | |
| 2442 #include <cstring> | |
| 2443 #include <sstream> | |
| 2444 #include <utility> | |
| 2445 #ifdef JSON_USE_CPPTL | |
| 2446 #include <cpptl/conststring.h> | |
| 2447 #endif | |
| 2448 #include <algorithm> // min() | |
| 2449 #include <cstddef> // size_t | |
| 2450 | |
| 2451 // Provide implementation equivalent of std::snprintf for older _MSC compilers | |
| 2452 #if defined(_MSC_VER) && _MSC_VER < 1900 | |
| 2453 #include <stdarg.h> | |
| 2454 static int msvc_pre1900_c99_vsnprintf(char* outBuf, | |
| 2455 size_t size, | |
| 2456 const char* format, | |
| 2457 va_list ap) { | |
| 2458 int count = -1; | |
| 2459 if (size != 0) | |
| 2460 count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap); | |
| 2461 if (count == -1) | |
| 2462 count = _vscprintf(format, ap); | |
| 2463 return count; | |
| 2464 } | |
| 2465 | |
| 2466 int JSON_API msvc_pre1900_c99_snprintf(char* outBuf, | |
| 2467 size_t size, | |
| 2468 const char* format, | |
| 2469 ...) { | |
| 2470 va_list ap; | |
| 2471 va_start(ap, format); | |
| 2472 const int count = msvc_pre1900_c99_vsnprintf(outBuf, size, format, ap); | |
| 2473 va_end(ap); | |
| 2474 return count; | |
| 2475 } | |
| 2476 #endif | |
| 2477 | |
| 2478 // Disable warning C4702 : unreachable code | |
| 2479 #if defined(_MSC_VER) | |
| 2480 #pragma warning(disable : 4702) | |
| 2481 #endif | |
| 2482 | |
| 2483 #define JSON_ASSERT_UNREACHABLE assert(false) | |
| 2484 | |
| 2485 namespace Json { | |
| 2486 | |
| 2487 // This is a walkaround to avoid the static initialization of Value::null. | |
| 2488 // kNull must be word-aligned to avoid crashing on ARM. We use an alignment of | |
| 2489 // 8 (instead of 4) as a bit of future-proofing. | |
| 2490 #if defined(__ARMEL__) | |
| 2491 #define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment))) | |
| 2492 #else | |
| 2493 #define ALIGNAS(byte_alignment) | |
| 2494 #endif | |
| 2495 // static const unsigned char ALIGNAS(8) kNull[sizeof(Value)] = { 0 }; | |
| 2496 // const unsigned char& kNullRef = kNull[0]; | |
| 2497 // const Value& Value::null = reinterpret_cast<const Value&>(kNullRef); | |
| 2498 // const Value& Value::nullRef = null; | |
| 2499 | |
| 2500 // static | |
| 2501 Value const& Value::nullSingleton() { | |
| 2502 static Value const nullStatic; | |
| 2503 return nullStatic; | |
| 2504 } | |
| 2505 | |
| 2506 // for backwards compatibility, we'll leave these global references around, but | |
| 2507 // DO NOT use them in JSONCPP library code any more! | |
| 2508 Value const& Value::null = Value::nullSingleton(); | |
| 2509 Value const& Value::nullRef = Value::nullSingleton(); | |
| 2510 | |
| 2511 const Int Value::minInt = Int(~(UInt(-1) / 2)); | |
| 2512 const Int Value::maxInt = Int(UInt(-1) / 2); | |
| 2513 const UInt Value::maxUInt = UInt(-1); | |
| 2514 #if defined(JSON_HAS_INT64) | |
| 2515 const Int64 Value::minInt64 = Int64(~(UInt64(-1) / 2)); | |
| 2516 const Int64 Value::maxInt64 = Int64(UInt64(-1) / 2); | |
| 2517 const UInt64 Value::maxUInt64 = UInt64(-1); | |
| 2518 // The constant is hard-coded because some compiler have trouble | |
| 2519 // converting Value::maxUInt64 to a double correctly (AIX/xlC). | |
| 2520 // Assumes that UInt64 is a 64 bits integer. | |
| 2521 static const double maxUInt64AsDouble = 18446744073709551615.0; | |
| 2522 #endif // defined(JSON_HAS_INT64) | |
| 2523 const LargestInt Value::minLargestInt = LargestInt(~(LargestUInt(-1) / 2)); | |
| 2524 const LargestInt Value::maxLargestInt = LargestInt(LargestUInt(-1) / 2); | |
| 2525 const LargestUInt Value::maxLargestUInt = LargestUInt(-1); | |
| 2526 | |
| 2527 const UInt Value::defaultRealPrecision = 17; | |
| 2528 | |
| 2529 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) | |
| 2530 template <typename T, typename U> | |
| 2531 static inline bool InRange(double d, T min, U max) { | |
| 2532 // The casts can lose precision, but we are looking only for | |
| 2533 // an approximate range. Might fail on edge cases though. ~cdunn | |
| 2534 // return d >= static_cast<double>(min) && d <= static_cast<double>(max); | |
| 2535 return d >= min && d <= max; | |
| 2536 } | |
| 2537 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) | |
| 2538 static inline double integerToDouble(Json::UInt64 value) { | |
| 2539 return static_cast<double>(Int64(value / 2)) * 2.0 + | |
| 2540 static_cast<double>(Int64(value & 1)); | |
| 2541 } | |
| 2542 | |
| 2543 template <typename T> static inline double integerToDouble(T value) { | |
| 2544 return static_cast<double>(value); | |
| 2545 } | |
| 2546 | |
| 2547 template <typename T, typename U> | |
| 2548 static inline bool InRange(double d, T min, U max) { | |
| 2549 return d >= integerToDouble(min) && d <= integerToDouble(max); | |
| 2550 } | |
| 2551 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) | |
| 2552 | |
| 2553 /** Duplicates the specified string value. | |
| 2554 * @param value Pointer to the string to duplicate. Must be zero-terminated if | |
| 2555 * length is "unknown". | |
| 2556 * @param length Length of the value. if equals to unknown, then it will be | |
| 2557 * computed using strlen(value). | |
| 2558 * @return Pointer on the duplicate instance of string. | |
| 2559 */ | |
| 2560 static inline char* duplicateStringValue(const char* value, size_t length) { | |
| 2561 // Avoid an integer overflow in the call to malloc below by limiting length | |
| 2562 // to a sane value. | |
| 2563 if (length >= static_cast<size_t>(Value::maxInt)) | |
| 2564 length = Value::maxInt - 1; | |
| 2565 | |
| 2566 char* newString = static_cast<char*>(malloc(length + 1)); | |
| 2567 if (newString == nullptr) { | |
| 2568 throwRuntimeError("in Json::Value::duplicateStringValue(): " | |
| 2569 "Failed to allocate string value buffer"); | |
| 2570 } | |
| 2571 memcpy(newString, value, length); | |
| 2572 newString[length] = 0; | |
| 2573 return newString; | |
| 2574 } | |
| 2575 | |
| 2576 /* Record the length as a prefix. | |
| 2577 */ | |
| 2578 static inline char* duplicateAndPrefixStringValue(const char* value, | |
| 2579 unsigned int length) { | |
| 2580 // Avoid an integer overflow in the call to malloc below by limiting length | |
| 2581 // to a sane value. | |
| 2582 JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) - | |
| 2583 sizeof(unsigned) - 1U, | |
| 2584 "in Json::Value::duplicateAndPrefixStringValue(): " | |
| 2585 "length too big for prefixing"); | |
| 2586 unsigned actualLength = length + static_cast<unsigned>(sizeof(unsigned)) + 1U; | |
| 2587 char* newString = static_cast<char*>(malloc(actualLength)); | |
| 2588 if (newString == nullptr) { | |
| 2589 throwRuntimeError("in Json::Value::duplicateAndPrefixStringValue(): " | |
| 2590 "Failed to allocate string value buffer"); | |
| 2591 } | |
| 2592 *reinterpret_cast<unsigned*>(newString) = length; | |
| 2593 memcpy(newString + sizeof(unsigned), value, length); | |
| 2594 newString[actualLength - 1U] = | |
| 2595 0; // to avoid buffer over-run accidents by users later | |
| 2596 return newString; | |
| 2597 } | |
| 2598 inline static void decodePrefixedString(bool isPrefixed, | |
| 2599 char const* prefixed, | |
| 2600 unsigned* length, | |
| 2601 char const** value) { | |
| 2602 if (!isPrefixed) { | |
| 2603 *length = static_cast<unsigned>(strlen(prefixed)); | |
| 2604 *value = prefixed; | |
| 2605 } else { | |
| 2606 *length = *reinterpret_cast<unsigned const*>(prefixed); | |
| 2607 *value = prefixed + sizeof(unsigned); | |
| 2608 } | |
| 2609 } | |
| 2610 /** Free the string duplicated by | |
| 2611 * duplicateStringValue()/duplicateAndPrefixStringValue(). | |
| 2612 */ | |
| 2613 #if JSONCPP_USING_SECURE_MEMORY | |
| 2614 static inline void releasePrefixedStringValue(char* value) { | |
| 2615 unsigned length = 0; | |
| 2616 char const* valueDecoded; | |
| 2617 decodePrefixedString(true, value, &length, &valueDecoded); | |
| 2618 size_t const size = sizeof(unsigned) + length + 1U; | |
| 2619 memset(value, 0, size); | |
| 2620 free(value); | |
| 2621 } | |
| 2622 static inline void releaseStringValue(char* value, unsigned length) { | |
| 2623 // length==0 => we allocated the strings memory | |
| 2624 size_t size = (length == 0) ? strlen(value) : length; | |
| 2625 memset(value, 0, size); | |
| 2626 free(value); | |
| 2627 } | |
| 2628 #else // !JSONCPP_USING_SECURE_MEMORY | |
| 2629 static inline void releasePrefixedStringValue(char* value) { free(value); } | |
| 2630 static inline void releaseStringValue(char* value, unsigned) { free(value); } | |
| 2631 #endif // JSONCPP_USING_SECURE_MEMORY | |
| 2632 | |
| 2633 } // namespace Json | |
| 2634 | |
| 2635 // ////////////////////////////////////////////////////////////////// | |
| 2636 // ////////////////////////////////////////////////////////////////// | |
| 2637 // ////////////////////////////////////////////////////////////////// | |
| 2638 // ValueInternals... | |
| 2639 // ////////////////////////////////////////////////////////////////// | |
| 2640 // ////////////////////////////////////////////////////////////////// | |
| 2641 // ////////////////////////////////////////////////////////////////// | |
| 2642 #if !defined(JSON_IS_AMALGAMATION) | |
| 2643 | |
| 2644 #include "json_valueiterator.inl" | |
| 2645 #endif // if !defined(JSON_IS_AMALGAMATION) | |
| 2646 | |
| 2647 namespace Json { | |
| 2648 | |
| 2649 Exception::Exception(String msg) : msg_(std::move(msg)) {} | |
| 2650 Exception::~Exception() JSONCPP_NOEXCEPT {} | |
| 2651 char const* Exception::what() const JSONCPP_NOEXCEPT { return msg_.c_str(); } | |
| 2652 RuntimeError::RuntimeError(String const& msg) : Exception(msg) {} | |
| 2653 LogicError::LogicError(String const& msg) : Exception(msg) {} | |
| 2654 JSONCPP_NORETURN void throwRuntimeError(String const& msg) { | |
| 2655 throw RuntimeError(msg); | |
| 2656 } | |
| 2657 JSONCPP_NORETURN void throwLogicError(String const& msg) { | |
| 2658 throw LogicError(msg); | |
| 2659 } | |
| 2660 | |
| 2661 // ////////////////////////////////////////////////////////////////// | |
| 2662 // ////////////////////////////////////////////////////////////////// | |
| 2663 // ////////////////////////////////////////////////////////////////// | |
| 2664 // class Value::CommentInfo | |
| 2665 // ////////////////////////////////////////////////////////////////// | |
| 2666 // ////////////////////////////////////////////////////////////////// | |
| 2667 // ////////////////////////////////////////////////////////////////// | |
| 2668 | |
| 2669 Value::CommentInfo::CommentInfo() = default; | |
| 2670 | |
| 2671 Value::CommentInfo::~CommentInfo() { | |
| 2672 if (comment_) | |
| 2673 releaseStringValue(comment_, 0u); | |
| 2674 } | |
| 2675 | |
| 2676 void Value::CommentInfo::setComment(const char* text, size_t len) { | |
| 2677 if (comment_) { | |
| 2678 releaseStringValue(comment_, 0u); | |
| 2679 comment_ = nullptr; | |
| 2680 } | |
| 2681 JSON_ASSERT(text != nullptr); | |
| 2682 JSON_ASSERT_MESSAGE( | |
| 2683 text[0] == '\0' || text[0] == '/', | |
| 2684 "in Json::Value::setComment(): Comments must start with /"); | |
| 2685 // It seems that /**/ style comments are acceptable as well. | |
| 2686 comment_ = duplicateStringValue(text, len); | |
| 2687 } | |
| 2688 | |
| 2689 // ////////////////////////////////////////////////////////////////// | |
| 2690 // ////////////////////////////////////////////////////////////////// | |
| 2691 // ////////////////////////////////////////////////////////////////// | |
| 2692 // class Value::CZString | |
| 2693 // ////////////////////////////////////////////////////////////////// | |
| 2694 // ////////////////////////////////////////////////////////////////// | |
| 2695 // ////////////////////////////////////////////////////////////////// | |
| 2696 | |
| 2697 // Notes: policy_ indicates if the string was allocated when | |
| 2698 // a string is stored. | |
| 2699 | |
| 2700 Value::CZString::CZString(ArrayIndex index) : cstr_(nullptr), index_(index) {} | |
| 2701 | |
| 2702 Value::CZString::CZString(char const* str, | |
| 2703 unsigned length, | |
| 2704 DuplicationPolicy allocate) | |
| 2705 : cstr_(str) { | |
| 2706 // allocate != duplicate | |
| 2707 storage_.policy_ = allocate & 0x3; | |
| 2708 storage_.length_ = length & 0x3FFFFFFF; | |
| 2709 } | |
| 2710 | |
| 2711 Value::CZString::CZString(const CZString& other) { | |
| 2712 cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != nullptr | |
| 2713 ? duplicateStringValue(other.cstr_, other.storage_.length_) | |
| 2714 : other.cstr_); | |
| 2715 storage_.policy_ = | |
| 2716 static_cast<unsigned>( | |
| 2717 other.cstr_ | |
| 2718 ? (static_cast<DuplicationPolicy>(other.storage_.policy_) == | |
| 2719 noDuplication | |
| 2720 ? noDuplication | |
| 2721 : duplicate) | |
| 2722 : static_cast<DuplicationPolicy>(other.storage_.policy_)) & | |
| 2723 3U; | |
| 2724 storage_.length_ = other.storage_.length_; | |
| 2725 } | |
| 2726 | |
| 2727 #if JSON_HAS_RVALUE_REFERENCES | |
| 2728 Value::CZString::CZString(CZString&& other) | |
| 2729 : cstr_(other.cstr_), index_(other.index_) { | |
| 2730 other.cstr_ = nullptr; | |
| 2731 } | |
| 2732 #endif | |
| 2733 | |
| 2734 Value::CZString::~CZString() { | |
| 2735 if (cstr_ && storage_.policy_ == duplicate) { | |
| 2736 releaseStringValue(const_cast<char*>(cstr_), | |
| 2737 storage_.length_ + 1u); // +1 for null terminating | |
| 2738 // character for sake of | |
| 2739 // completeness but not actually | |
| 2740 // necessary | |
| 2741 } | |
| 2742 } | |
| 2743 | |
| 2744 void Value::CZString::swap(CZString& other) { | |
| 2745 std::swap(cstr_, other.cstr_); | |
| 2746 std::swap(index_, other.index_); | |
| 2747 } | |
| 2748 | |
| 2749 Value::CZString& Value::CZString::operator=(const CZString& other) { | |
| 2750 cstr_ = other.cstr_; | |
| 2751 index_ = other.index_; | |
| 2752 return *this; | |
| 2753 } | |
| 2754 | |
| 2755 #if JSON_HAS_RVALUE_REFERENCES | |
| 2756 Value::CZString& Value::CZString::operator=(CZString&& other) { | |
| 2757 cstr_ = other.cstr_; | |
| 2758 index_ = other.index_; | |
| 2759 other.cstr_ = nullptr; | |
| 2760 return *this; | |
| 2761 } | |
| 2762 #endif | |
| 2763 | |
| 2764 bool Value::CZString::operator<(const CZString& other) const { | |
| 2765 if (!cstr_) | |
| 2766 return index_ < other.index_; | |
| 2767 // return strcmp(cstr_, other.cstr_) < 0; | |
| 2768 // Assume both are strings. | |
| 2769 unsigned this_len = this->storage_.length_; | |
| 2770 unsigned other_len = other.storage_.length_; | |
| 2771 unsigned min_len = std::min<unsigned>(this_len, other_len); | |
| 2772 JSON_ASSERT(this->cstr_ && other.cstr_); | |
| 2773 int comp = memcmp(this->cstr_, other.cstr_, min_len); | |
| 2774 if (comp < 0) | |
| 2775 return true; | |
| 2776 if (comp > 0) | |
| 2777 return false; | |
| 2778 return (this_len < other_len); | |
| 2779 } | |
| 2780 | |
| 2781 bool Value::CZString::operator==(const CZString& other) const { | |
| 2782 if (!cstr_) | |
| 2783 return index_ == other.index_; | |
| 2784 // return strcmp(cstr_, other.cstr_) == 0; | |
| 2785 // Assume both are strings. | |
| 2786 unsigned this_len = this->storage_.length_; | |
| 2787 unsigned other_len = other.storage_.length_; | |
| 2788 if (this_len != other_len) | |
| 2789 return false; | |
| 2790 JSON_ASSERT(this->cstr_ && other.cstr_); | |
| 2791 int comp = memcmp(this->cstr_, other.cstr_, this_len); | |
| 2792 return comp == 0; | |
| 2793 } | |
| 2794 | |
| 2795 ArrayIndex Value::CZString::index() const { return index_; } | |
| 2796 | |
| 2797 // const char* Value::CZString::c_str() const { return cstr_; } | |
| 2798 const char* Value::CZString::data() const { return cstr_; } | |
| 2799 unsigned Value::CZString::length() const { return storage_.length_; } | |
| 2800 bool Value::CZString::isStaticString() const { | |
| 2801 return storage_.policy_ == noDuplication; | |
| 2802 } | |
| 2803 | |
| 2804 // ////////////////////////////////////////////////////////////////// | |
| 2805 // ////////////////////////////////////////////////////////////////// | |
| 2806 // ////////////////////////////////////////////////////////////////// | |
| 2807 // class Value::Value | |
| 2808 // ////////////////////////////////////////////////////////////////// | |
| 2809 // ////////////////////////////////////////////////////////////////// | |
| 2810 // ////////////////////////////////////////////////////////////////// | |
| 2811 | |
| 2812 /*! \internal Default constructor initialization must be equivalent to: | |
| 2813 * memset( this, 0, sizeof(Value) ) | |
| 2814 * This optimization is used in ValueInternalMap fast allocator. | |
| 2815 */ | |
| 2816 Value::Value(ValueType type) { | |
| 2817 static char const emptyString[] = ""; | |
| 2818 initBasic(type); | |
| 2819 switch (type) { | |
| 2820 case nullValue: | |
| 2821 break; | |
| 2822 case intValue: | |
| 2823 case uintValue: | |
| 2824 value_.int_ = 0; | |
| 2825 break; | |
| 2826 case realValue: | |
| 2827 value_.real_ = 0.0; | |
| 2828 break; | |
| 2829 case stringValue: | |
| 2830 // allocated_ == false, so this is safe. | |
| 2831 value_.string_ = const_cast<char*>(static_cast<char const*>(emptyString)); | |
| 2832 break; | |
| 2833 case arrayValue: | |
| 2834 case objectValue: | |
| 2835 value_.map_ = new ObjectValues(); | |
| 2836 break; | |
| 2837 case booleanValue: | |
| 2838 value_.bool_ = false; | |
| 2839 break; | |
| 2840 default: | |
| 2841 JSON_ASSERT_UNREACHABLE; | |
| 2842 } | |
| 2843 } | |
| 2844 | |
| 2845 Value::Value(Int value) { | |
| 2846 initBasic(intValue); | |
| 2847 value_.int_ = value; | |
| 2848 } | |
| 2849 | |
| 2850 Value::Value(UInt value) { | |
| 2851 initBasic(uintValue); | |
| 2852 value_.uint_ = value; | |
| 2853 } | |
| 2854 #if defined(JSON_HAS_INT64) | |
| 2855 Value::Value(Int64 value) { | |
| 2856 initBasic(intValue); | |
| 2857 value_.int_ = value; | |
| 2858 } | |
| 2859 Value::Value(UInt64 value) { | |
| 2860 initBasic(uintValue); | |
| 2861 value_.uint_ = value; | |
| 2862 } | |
| 2863 #endif // defined(JSON_HAS_INT64) | |
| 2864 | |
| 2865 Value::Value(double value) { | |
| 2866 initBasic(realValue); | |
| 2867 value_.real_ = value; | |
| 2868 } | |
| 2869 | |
| 2870 Value::Value(const char* value) { | |
| 2871 initBasic(stringValue, true); | |
| 2872 JSON_ASSERT_MESSAGE(value != nullptr, | |
| 2873 "Null Value Passed to Value Constructor"); | |
| 2874 value_.string_ = duplicateAndPrefixStringValue( | |
| 2875 value, static_cast<unsigned>(strlen(value))); | |
| 2876 } | |
| 2877 | |
| 2878 Value::Value(const char* begin, const char* end) { | |
| 2879 initBasic(stringValue, true); | |
| 2880 value_.string_ = | |
| 2881 duplicateAndPrefixStringValue(begin, static_cast<unsigned>(end - begin)); | |
| 2882 } | |
| 2883 | |
| 2884 Value::Value(const String& value) { | |
| 2885 initBasic(stringValue, true); | |
| 2886 value_.string_ = duplicateAndPrefixStringValue( | |
| 2887 value.data(), static_cast<unsigned>(value.length())); | |
| 2888 } | |
| 2889 | |
| 2890 Value::Value(const StaticString& value) { | |
| 2891 initBasic(stringValue); | |
| 2892 value_.string_ = const_cast<char*>(value.c_str()); | |
| 2893 } | |
| 2894 | |
| 2895 #ifdef JSON_USE_CPPTL | |
| 2896 Value::Value(const CppTL::ConstString& value) { | |
| 2897 initBasic(stringValue, true); | |
| 2898 value_.string_ = duplicateAndPrefixStringValue( | |
| 2899 value, static_cast<unsigned>(value.length())); | |
| 2900 } | |
| 2901 #endif | |
| 2902 | |
| 2903 Value::Value(bool value) { | |
| 2904 initBasic(booleanValue); | |
| 2905 value_.bool_ = value; | |
| 2906 } | |
| 2907 | |
| 2908 Value::Value(const Value& other) { | |
| 2909 dupPayload(other); | |
| 2910 dupMeta(other); | |
| 2911 } | |
| 2912 | |
| 2913 Value::Value(Value&& other) { | |
| 2914 initBasic(nullValue); | |
| 2915 swap(other); | |
| 2916 } | |
| 2917 | |
| 2918 Value::~Value() { | |
| 2919 releasePayload(); | |
| 2920 delete[] comments_; | |
| 2921 value_.uint_ = 0; | |
| 2922 } | |
| 2923 | |
| 2924 Value& Value::operator=(const Value& other) { | |
| 2925 Value(other).swap(*this); | |
| 2926 return *this; | |
| 2927 } | |
| 2928 | |
| 2929 Value& Value::operator=(Value&& other) { | |
| 2930 other.swap(*this); | |
| 2931 return *this; | |
| 2932 } | |
| 2933 | |
| 2934 void Value::swapPayload(Value& other) { | |
| 2935 std::swap(bits_, other.bits_); | |
| 2936 std::swap(value_, other.value_); | |
| 2937 } | |
| 2938 | |
| 2939 void Value::copyPayload(const Value& other) { | |
| 2940 releasePayload(); | |
| 2941 dupPayload(other); | |
| 2942 } | |
| 2943 | |
| 2944 void Value::swap(Value& other) { | |
| 2945 swapPayload(other); | |
| 2946 std::swap(comments_, other.comments_); | |
| 2947 std::swap(start_, other.start_); | |
| 2948 std::swap(limit_, other.limit_); | |
| 2949 } | |
| 2950 | |
| 2951 void Value::copy(const Value& other) { | |
| 2952 copyPayload(other); | |
| 2953 delete[] comments_; | |
| 2954 dupMeta(other); | |
| 2955 } | |
| 2956 | |
| 2957 ValueType Value::type() const { | |
| 2958 return static_cast<ValueType>(bits_.value_type_); | |
| 2959 } | |
| 2960 | |
| 2961 int Value::compare(const Value& other) const { | |
| 2962 if (*this < other) | |
| 2963 return -1; | |
| 2964 if (*this > other) | |
| 2965 return 1; | |
| 2966 return 0; | |
| 2967 } | |
| 2968 | |
| 2969 bool Value::operator<(const Value& other) const { | |
| 2970 int typeDelta = type() - other.type(); | |
| 2971 if (typeDelta) | |
| 2972 return typeDelta < 0 ? true : false; | |
| 2973 switch (type()) { | |
| 2974 case nullValue: | |
| 2975 return false; | |
| 2976 case intValue: | |
| 2977 return value_.int_ < other.value_.int_; | |
| 2978 case uintValue: | |
| 2979 return value_.uint_ < other.value_.uint_; | |
| 2980 case realValue: | |
| 2981 return value_.real_ < other.value_.real_; | |
| 2982 case booleanValue: | |
| 2983 return value_.bool_ < other.value_.bool_; | |
| 2984 case stringValue: { | |
| 2985 if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) { | |
| 2986 if (other.value_.string_) | |
| 2987 return true; | |
| 2988 else | |
| 2989 return false; | |
| 2990 } | |
| 2991 unsigned this_len; | |
| 2992 unsigned other_len; | |
| 2993 char const* this_str; | |
| 2994 char const* other_str; | |
| 2995 decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len, | |
| 2996 &this_str); | |
| 2997 decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len, | |
| 2998 &other_str); | |
| 2999 unsigned min_len = std::min<unsigned>(this_len, other_len); | |
| 3000 JSON_ASSERT(this_str && other_str); | |
| 3001 int comp = memcmp(this_str, other_str, min_len); | |
| 3002 if (comp < 0) | |
| 3003 return true; | |
| 3004 if (comp > 0) | |
| 3005 return false; | |
| 3006 return (this_len < other_len); | |
| 3007 } | |
| 3008 case arrayValue: | |
| 3009 case objectValue: { | |
| 3010 int delta = int(value_.map_->size() - other.value_.map_->size()); | |
| 3011 if (delta) | |
| 3012 return delta < 0; | |
| 3013 return (*value_.map_) < (*other.value_.map_); | |
| 3014 } | |
| 3015 default: | |
| 3016 JSON_ASSERT_UNREACHABLE; | |
| 3017 } | |
| 3018 return false; // unreachable | |
| 3019 } | |
| 3020 | |
| 3021 bool Value::operator<=(const Value& other) const { return !(other < *this); } | |
| 3022 | |
| 3023 bool Value::operator>=(const Value& other) const { return !(*this < other); } | |
| 3024 | |
| 3025 bool Value::operator>(const Value& other) const { return other < *this; } | |
| 3026 | |
| 3027 bool Value::operator==(const Value& other) const { | |
| 3028 if (type() != other.type()) | |
| 3029 return false; | |
| 3030 switch (type()) { | |
| 3031 case nullValue: | |
| 3032 return true; | |
| 3033 case intValue: | |
| 3034 return value_.int_ == other.value_.int_; | |
| 3035 case uintValue: | |
| 3036 return value_.uint_ == other.value_.uint_; | |
| 3037 case realValue: | |
| 3038 return value_.real_ == other.value_.real_; | |
| 3039 case booleanValue: | |
| 3040 return value_.bool_ == other.value_.bool_; | |
| 3041 case stringValue: { | |
| 3042 if ((value_.string_ == nullptr) || (other.value_.string_ == nullptr)) { | |
| 3043 return (value_.string_ == other.value_.string_); | |
| 3044 } | |
| 3045 unsigned this_len; | |
| 3046 unsigned other_len; | |
| 3047 char const* this_str; | |
| 3048 char const* other_str; | |
| 3049 decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len, | |
| 3050 &this_str); | |
| 3051 decodePrefixedString(other.isAllocated(), other.value_.string_, &other_len, | |
| 3052 &other_str); | |
| 3053 if (this_len != other_len) | |
| 3054 return false; | |
| 3055 JSON_ASSERT(this_str && other_str); | |
| 3056 int comp = memcmp(this_str, other_str, this_len); | |
| 3057 return comp == 0; | |
| 3058 } | |
| 3059 case arrayValue: | |
| 3060 case objectValue: | |
| 3061 return value_.map_->size() == other.value_.map_->size() && | |
| 3062 (*value_.map_) == (*other.value_.map_); | |
| 3063 default: | |
| 3064 JSON_ASSERT_UNREACHABLE; | |
| 3065 } | |
| 3066 return false; // unreachable | |
| 3067 } | |
| 3068 | |
| 3069 bool Value::operator!=(const Value& other) const { return !(*this == other); } | |
| 3070 | |
| 3071 const char* Value::asCString() const { | |
| 3072 JSON_ASSERT_MESSAGE(type() == stringValue, | |
| 3073 "in Json::Value::asCString(): requires stringValue"); | |
| 3074 if (value_.string_ == nullptr) | |
| 3075 return nullptr; | |
| 3076 unsigned this_len; | |
| 3077 char const* this_str; | |
| 3078 decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len, | |
| 3079 &this_str); | |
| 3080 return this_str; | |
| 3081 } | |
| 3082 | |
| 3083 #if JSONCPP_USING_SECURE_MEMORY | |
| 3084 unsigned Value::getCStringLength() const { | |
| 3085 JSON_ASSERT_MESSAGE(type() == stringValue, | |
| 3086 "in Json::Value::asCString(): requires stringValue"); | |
| 3087 if (value_.string_ == 0) | |
| 3088 return 0; | |
| 3089 unsigned this_len; | |
| 3090 char const* this_str; | |
| 3091 decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len, | |
| 3092 &this_str); | |
| 3093 return this_len; | |
| 3094 } | |
| 3095 #endif | |
| 3096 | |
| 3097 bool Value::getString(char const** begin, char const** end) const { | |
| 3098 if (type() != stringValue) | |
| 3099 return false; | |
| 3100 if (value_.string_ == nullptr) | |
| 3101 return false; | |
| 3102 unsigned length; | |
| 3103 decodePrefixedString(this->isAllocated(), this->value_.string_, &length, | |
| 3104 begin); | |
| 3105 *end = *begin + length; | |
| 3106 return true; | |
| 3107 } | |
| 3108 | |
| 3109 String Value::asString() const { | |
| 3110 switch (type()) { | |
| 3111 case nullValue: | |
| 3112 return ""; | |
| 3113 case stringValue: { | |
| 3114 if (value_.string_ == nullptr) | |
| 3115 return ""; | |
| 3116 unsigned this_len; | |
| 3117 char const* this_str; | |
| 3118 decodePrefixedString(this->isAllocated(), this->value_.string_, &this_len, | |
| 3119 &this_str); | |
| 3120 return String(this_str, this_len); | |
| 3121 } | |
| 3122 case booleanValue: | |
| 3123 return value_.bool_ ? "true" : "false"; | |
| 3124 case intValue: | |
| 3125 return valueToString(value_.int_); | |
| 3126 case uintValue: | |
| 3127 return valueToString(value_.uint_); | |
| 3128 case realValue: | |
| 3129 return valueToString(value_.real_); | |
| 3130 default: | |
| 3131 JSON_FAIL_MESSAGE("Type is not convertible to string"); | |
| 3132 } | |
| 3133 } | |
| 3134 | |
| 3135 #ifdef JSON_USE_CPPTL | |
| 3136 CppTL::ConstString Value::asConstString() const { | |
| 3137 unsigned len; | |
| 3138 char const* str; | |
| 3139 decodePrefixedString(isAllocated(), value_.string_, &len, &str); | |
| 3140 return CppTL::ConstString(str, len); | |
| 3141 } | |
| 3142 #endif | |
| 3143 | |
| 3144 Value::Int Value::asInt() const { | |
| 3145 switch (type()) { | |
| 3146 case intValue: | |
| 3147 JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range"); | |
| 3148 return Int(value_.int_); | |
| 3149 case uintValue: | |
| 3150 JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range"); | |
| 3151 return Int(value_.uint_); | |
| 3152 case realValue: | |
| 3153 JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt), | |
| 3154 "double out of Int range"); | |
| 3155 return Int(value_.real_); | |
| 3156 case nullValue: | |
| 3157 return 0; | |
| 3158 case booleanValue: | |
| 3159 return value_.bool_ ? 1 : 0; | |
| 3160 default: | |
| 3161 break; | |
| 3162 } | |
| 3163 JSON_FAIL_MESSAGE("Value is not convertible to Int."); | |
| 3164 } | |
| 3165 | |
| 3166 Value::UInt Value::asUInt() const { | |
| 3167 switch (type()) { | |
| 3168 case intValue: | |
| 3169 JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range"); | |
| 3170 return UInt(value_.int_); | |
| 3171 case uintValue: | |
| 3172 JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range"); | |
| 3173 return UInt(value_.uint_); | |
| 3174 case realValue: | |
| 3175 JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt), | |
| 3176 "double out of UInt range"); | |
| 3177 return UInt(value_.real_); | |
| 3178 case nullValue: | |
| 3179 return 0; | |
| 3180 case booleanValue: | |
| 3181 return value_.bool_ ? 1 : 0; | |
| 3182 default: | |
| 3183 break; | |
| 3184 } | |
| 3185 JSON_FAIL_MESSAGE("Value is not convertible to UInt."); | |
| 3186 } | |
| 3187 | |
| 3188 #if defined(JSON_HAS_INT64) | |
| 3189 | |
| 3190 Value::Int64 Value::asInt64() const { | |
| 3191 switch (type()) { | |
| 3192 case intValue: | |
| 3193 return Int64(value_.int_); | |
| 3194 case uintValue: | |
| 3195 JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range"); | |
| 3196 return Int64(value_.uint_); | |
| 3197 case realValue: | |
| 3198 JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64), | |
| 3199 "double out of Int64 range"); | |
| 3200 return Int64(value_.real_); | |
| 3201 case nullValue: | |
| 3202 return 0; | |
| 3203 case booleanValue: | |
| 3204 return value_.bool_ ? 1 : 0; | |
| 3205 default: | |
| 3206 break; | |
| 3207 } | |
| 3208 JSON_FAIL_MESSAGE("Value is not convertible to Int64."); | |
| 3209 } | |
| 3210 | |
| 3211 Value::UInt64 Value::asUInt64() const { | |
| 3212 switch (type()) { | |
| 3213 case intValue: | |
| 3214 JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range"); | |
| 3215 return UInt64(value_.int_); | |
| 3216 case uintValue: | |
| 3217 return UInt64(value_.uint_); | |
| 3218 case realValue: | |
| 3219 JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64), | |
| 3220 "double out of UInt64 range"); | |
| 3221 return UInt64(value_.real_); | |
| 3222 case nullValue: | |
| 3223 return 0; | |
| 3224 case booleanValue: | |
| 3225 return value_.bool_ ? 1 : 0; | |
| 3226 default: | |
| 3227 break; | |
| 3228 } | |
| 3229 JSON_FAIL_MESSAGE("Value is not convertible to UInt64."); | |
| 3230 } | |
| 3231 #endif // if defined(JSON_HAS_INT64) | |
| 3232 | |
| 3233 LargestInt Value::asLargestInt() const { | |
| 3234 #if defined(JSON_NO_INT64) | |
| 3235 return asInt(); | |
| 3236 #else | |
| 3237 return asInt64(); | |
| 3238 #endif | |
| 3239 } | |
| 3240 | |
| 3241 LargestUInt Value::asLargestUInt() const { | |
| 3242 #if defined(JSON_NO_INT64) | |
| 3243 return asUInt(); | |
| 3244 #else | |
| 3245 return asUInt64(); | |
| 3246 #endif | |
| 3247 } | |
| 3248 | |
| 3249 double Value::asDouble() const { | |
| 3250 switch (type()) { | |
| 3251 case intValue: | |
| 3252 return static_cast<double>(value_.int_); | |
| 3253 case uintValue: | |
| 3254 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) | |
| 3255 return static_cast<double>(value_.uint_); | |
| 3256 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) | |
| 3257 return integerToDouble(value_.uint_); | |
| 3258 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) | |
| 3259 case realValue: | |
| 3260 return value_.real_; | |
| 3261 case nullValue: | |
| 3262 return 0.0; | |
| 3263 case booleanValue: | |
| 3264 return value_.bool_ ? 1.0 : 0.0; | |
| 3265 default: | |
| 3266 break; | |
| 3267 } | |
| 3268 JSON_FAIL_MESSAGE("Value is not convertible to double."); | |
| 3269 } | |
| 3270 | |
| 3271 float Value::asFloat() const { | |
| 3272 switch (type()) { | |
| 3273 case intValue: | |
| 3274 return static_cast<float>(value_.int_); | |
| 3275 case uintValue: | |
| 3276 #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) | |
| 3277 return static_cast<float>(value_.uint_); | |
| 3278 #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) | |
| 3279 // This can fail (silently?) if the value is bigger than MAX_FLOAT. | |
| 3280 return static_cast<float>(integerToDouble(value_.uint_)); | |
| 3281 #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) | |
| 3282 case realValue: | |
| 3283 return static_cast<float>(value_.real_); | |
| 3284 case nullValue: | |
| 3285 return 0.0; | |
| 3286 case booleanValue: | |
| 3287 return value_.bool_ ? 1.0f : 0.0f; | |
| 3288 default: | |
| 3289 break; | |
| 3290 } | |
| 3291 JSON_FAIL_MESSAGE("Value is not convertible to float."); | |
| 3292 } | |
| 3293 | |
| 3294 bool Value::asBool() const { | |
| 3295 switch (type()) { | |
| 3296 case booleanValue: | |
| 3297 return value_.bool_; | |
| 3298 case nullValue: | |
| 3299 return false; | |
| 3300 case intValue: | |
| 3301 return value_.int_ ? true : false; | |
| 3302 case uintValue: | |
| 3303 return value_.uint_ ? true : false; | |
| 3304 case realValue: | |
| 3305 // This is kind of strange. Not recommended. | |
| 3306 return (value_.real_ != 0.0) ? true : false; | |
| 3307 default: | |
| 3308 break; | |
| 3309 } | |
| 3310 JSON_FAIL_MESSAGE("Value is not convertible to bool."); | |
| 3311 } | |
| 3312 | |
| 3313 bool Value::isConvertibleTo(ValueType other) const { | |
| 3314 switch (other) { | |
| 3315 case nullValue: | |
| 3316 return (isNumeric() && asDouble() == 0.0) || | |
| 3317 (type() == booleanValue && value_.bool_ == false) || | |
| 3318 (type() == stringValue && asString().empty()) || | |
| 3319 (type() == arrayValue && value_.map_->empty()) || | |
| 3320 (type() == objectValue && value_.map_->empty()) || | |
| 3321 type() == nullValue; | |
| 3322 case intValue: | |
| 3323 return isInt() || | |
| 3324 (type() == realValue && InRange(value_.real_, minInt, maxInt)) || | |
| 3325 type() == booleanValue || type() == nullValue; | |
| 3326 case uintValue: | |
| 3327 return isUInt() || | |
| 3328 (type() == realValue && InRange(value_.real_, 0, maxUInt)) || | |
| 3329 type() == booleanValue || type() == nullValue; | |
| 3330 case realValue: | |
| 3331 return isNumeric() || type() == booleanValue || type() == nullValue; | |
| 3332 case booleanValue: | |
| 3333 return isNumeric() || type() == booleanValue || type() == nullValue; | |
| 3334 case stringValue: | |
| 3335 return isNumeric() || type() == booleanValue || type() == stringValue || | |
| 3336 type() == nullValue; | |
| 3337 case arrayValue: | |
| 3338 return type() == arrayValue || type() == nullValue; | |
| 3339 case objectValue: | |
| 3340 return type() == objectValue || type() == nullValue; | |
| 3341 } | |
| 3342 JSON_ASSERT_UNREACHABLE; | |
| 3343 return false; | |
| 3344 } | |
| 3345 | |
| 3346 /// Number of values in array or object | |
| 3347 ArrayIndex Value::size() const { | |
| 3348 switch (type()) { | |
| 3349 case nullValue: | |
| 3350 case intValue: | |
| 3351 case uintValue: | |
| 3352 case realValue: | |
| 3353 case booleanValue: | |
| 3354 case stringValue: | |
| 3355 return 0; | |
| 3356 case arrayValue: // size of the array is highest index + 1 | |
| 3357 if (!value_.map_->empty()) { | |
| 3358 ObjectValues::const_iterator itLast = value_.map_->end(); | |
| 3359 --itLast; | |
| 3360 return (*itLast).first.index() + 1; | |
| 3361 } | |
| 3362 return 0; | |
| 3363 case objectValue: | |
| 3364 return ArrayIndex(value_.map_->size()); | |
| 3365 } | |
| 3366 JSON_ASSERT_UNREACHABLE; | |
| 3367 return 0; // unreachable; | |
| 3368 } | |
| 3369 | |
| 3370 bool Value::empty() const { | |
| 3371 if (isNull() || isArray() || isObject()) | |
| 3372 return size() == 0u; | |
| 3373 else | |
| 3374 return false; | |
| 3375 } | |
| 3376 | |
| 3377 Value::operator bool() const { return !isNull(); } | |
| 3378 | |
| 3379 void Value::clear() { | |
| 3380 JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue || | |
| 3381 type() == objectValue, | |
| 3382 "in Json::Value::clear(): requires complex value"); | |
| 3383 start_ = 0; | |
| 3384 limit_ = 0; | |
| 3385 switch (type()) { | |
| 3386 case arrayValue: | |
| 3387 case objectValue: | |
| 3388 value_.map_->clear(); | |
| 3389 break; | |
| 3390 default: | |
| 3391 break; | |
| 3392 } | |
| 3393 } | |
| 3394 | |
| 3395 void Value::resize(ArrayIndex newSize) { | |
| 3396 JSON_ASSERT_MESSAGE(type() == nullValue || type() == arrayValue, | |
| 3397 "in Json::Value::resize(): requires arrayValue"); | |
| 3398 if (type() == nullValue) | |
| 3399 *this = Value(arrayValue); | |
| 3400 ArrayIndex oldSize = size(); | |
| 3401 if (newSize == 0) | |
| 3402 clear(); | |
| 3403 else if (newSize > oldSize) | |
| 3404 this->operator[](newSize - 1); | |
| 3405 else { | |
| 3406 for (ArrayIndex index = newSize; index < oldSize; ++index) { | |
| 3407 value_.map_->erase(index); | |
| 3408 } | |
| 3409 JSON_ASSERT(size() == newSize); | |
| 3410 } | |
| 3411 } | |
| 3412 | |
| 3413 Value& Value::operator[](ArrayIndex index) { | |
| 3414 JSON_ASSERT_MESSAGE( | |
| 3415 type() == nullValue || type() == arrayValue, | |
| 3416 "in Json::Value::operator[](ArrayIndex): requires arrayValue"); | |
| 3417 if (type() == nullValue) | |
| 3418 *this = Value(arrayValue); | |
| 3419 CZString key(index); | |
| 3420 auto it = value_.map_->lower_bound(key); | |
| 3421 if (it != value_.map_->end() && (*it).first == key) | |
| 3422 return (*it).second; | |
| 3423 | |
| 3424 ObjectValues::value_type defaultValue(key, nullSingleton()); | |
| 3425 it = value_.map_->insert(it, defaultValue); | |
| 3426 return (*it).second; | |
| 3427 } | |
| 3428 | |
| 3429 Value& Value::operator[](int index) { | |
| 3430 JSON_ASSERT_MESSAGE( | |
| 3431 index >= 0, | |
| 3432 "in Json::Value::operator[](int index): index cannot be negative"); | |
| 3433 return (*this)[ArrayIndex(index)]; | |
| 3434 } | |
| 3435 | |
| 3436 const Value& Value::operator[](ArrayIndex index) const { | |
| 3437 JSON_ASSERT_MESSAGE( | |
| 3438 type() == nullValue || type() == arrayValue, | |
| 3439 "in Json::Value::operator[](ArrayIndex)const: requires arrayValue"); | |
| 3440 if (type() == nullValue) | |
| 3441 return nullSingleton(); | |
| 3442 CZString key(index); | |
| 3443 ObjectValues::const_iterator it = value_.map_->find(key); | |
| 3444 if (it == value_.map_->end()) | |
| 3445 return nullSingleton(); | |
| 3446 return (*it).second; | |
| 3447 } | |
| 3448 | |
| 3449 const Value& Value::operator[](int index) const { | |
| 3450 JSON_ASSERT_MESSAGE( | |
| 3451 index >= 0, | |
| 3452 "in Json::Value::operator[](int index) const: index cannot be negative"); | |
| 3453 return (*this)[ArrayIndex(index)]; | |
| 3454 } | |
| 3455 | |
| 3456 void Value::initBasic(ValueType type, bool allocated) { | |
| 3457 setType(type); | |
| 3458 setIsAllocated(allocated); | |
| 3459 comments_ = nullptr; | |
| 3460 start_ = 0; | |
| 3461 limit_ = 0; | |
| 3462 } | |
| 3463 | |
| 3464 void Value::dupPayload(const Value& other) { | |
| 3465 setType(other.type()); | |
| 3466 setIsAllocated(false); | |
| 3467 switch (type()) { | |
| 3468 case nullValue: | |
| 3469 case intValue: | |
| 3470 case uintValue: | |
| 3471 case realValue: | |
| 3472 case booleanValue: | |
| 3473 value_ = other.value_; | |
| 3474 break; | |
| 3475 case stringValue: | |
| 3476 if (other.value_.string_ && other.isAllocated()) { | |
| 3477 unsigned len; | |
| 3478 char const* str; | |
| 3479 decodePrefixedString(other.isAllocated(), other.value_.string_, &len, | |
| 3480 &str); | |
| 3481 value_.string_ = duplicateAndPrefixStringValue(str, len); | |
| 3482 setIsAllocated(true); | |
| 3483 } else { | |
| 3484 value_.string_ = other.value_.string_; | |
| 3485 } | |
| 3486 break; | |
| 3487 case arrayValue: | |
| 3488 case objectValue: | |
| 3489 value_.map_ = new ObjectValues(*other.value_.map_); | |
| 3490 break; | |
| 3491 default: | |
| 3492 JSON_ASSERT_UNREACHABLE; | |
| 3493 } | |
| 3494 } | |
| 3495 | |
| 3496 void Value::releasePayload() { | |
| 3497 switch (type()) { | |
| 3498 case nullValue: | |
| 3499 case intValue: | |
| 3500 case uintValue: | |
| 3501 case realValue: | |
| 3502 case booleanValue: | |
| 3503 break; | |
| 3504 case stringValue: | |
| 3505 if (isAllocated()) | |
| 3506 releasePrefixedStringValue(value_.string_); | |
| 3507 break; | |
| 3508 case arrayValue: | |
| 3509 case objectValue: | |
| 3510 delete value_.map_; | |
| 3511 break; | |
| 3512 default: | |
| 3513 JSON_ASSERT_UNREACHABLE; | |
| 3514 } | |
| 3515 } | |
| 3516 | |
| 3517 void Value::dupMeta(const Value& other) { | |
| 3518 if (other.comments_) { | |
| 3519 comments_ = new CommentInfo[numberOfCommentPlacement]; | |
| 3520 for (int comment = 0; comment < numberOfCommentPlacement; ++comment) { | |
| 3521 const CommentInfo& otherComment = other.comments_[comment]; | |
| 3522 if (otherComment.comment_) | |
| 3523 comments_[comment].setComment(otherComment.comment_, | |
| 3524 strlen(otherComment.comment_)); | |
| 3525 } | |
| 3526 } else { | |
| 3527 comments_ = nullptr; | |
| 3528 } | |
| 3529 start_ = other.start_; | |
| 3530 limit_ = other.limit_; | |
| 3531 } | |
| 3532 | |
| 3533 // Access an object value by name, create a null member if it does not exist. | |
| 3534 // @pre Type of '*this' is object or null. | |
| 3535 // @param key is null-terminated. | |
| 3536 Value& Value::resolveReference(const char* key) { | |
| 3537 JSON_ASSERT_MESSAGE( | |
| 3538 type() == nullValue || type() == objectValue, | |
| 3539 "in Json::Value::resolveReference(): requires objectValue"); | |
| 3540 if (type() == nullValue) | |
| 3541 *this = Value(objectValue); | |
| 3542 CZString actualKey(key, static_cast<unsigned>(strlen(key)), | |
| 3543 CZString::noDuplication); // NOTE! | |
| 3544 auto it = value_.map_->lower_bound(actualKey); | |
| 3545 if (it != value_.map_->end() && (*it).first == actualKey) | |
| 3546 return (*it).second; | |
| 3547 | |
| 3548 ObjectValues::value_type defaultValue(actualKey, nullSingleton()); | |
| 3549 it = value_.map_->insert(it, defaultValue); | |
| 3550 Value& value = (*it).second; | |
| 3551 return value; | |
| 3552 } | |
| 3553 | |
| 3554 // @param key is not null-terminated. | |
| 3555 Value& Value::resolveReference(char const* key, char const* end) { | |
| 3556 JSON_ASSERT_MESSAGE( | |
| 3557 type() == nullValue || type() == objectValue, | |
| 3558 "in Json::Value::resolveReference(key, end): requires objectValue"); | |
| 3559 if (type() == nullValue) | |
| 3560 *this = Value(objectValue); | |
| 3561 CZString actualKey(key, static_cast<unsigned>(end - key), | |
| 3562 CZString::duplicateOnCopy); | |
| 3563 auto it = value_.map_->lower_bound(actualKey); | |
| 3564 if (it != value_.map_->end() && (*it).first == actualKey) | |
| 3565 return (*it).second; | |
| 3566 | |
| 3567 ObjectValues::value_type defaultValue(actualKey, nullSingleton()); | |
| 3568 it = value_.map_->insert(it, defaultValue); | |
| 3569 Value& value = (*it).second; | |
| 3570 return value; | |
| 3571 } | |
| 3572 | |
| 3573 Value Value::get(ArrayIndex index, const Value& defaultValue) const { | |
| 3574 const Value* value = &((*this)[index]); | |
| 3575 return value == &nullSingleton() ? defaultValue : *value; | |
| 3576 } | |
| 3577 | |
| 3578 bool Value::isValidIndex(ArrayIndex index) const { return index < size(); } | |
| 3579 | |
| 3580 Value const* Value::find(char const* begin, char const* end) const { | |
| 3581 JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue, | |
| 3582 "in Json::Value::find(key, end, found): requires " | |
| 3583 "objectValue or nullValue"); | |
| 3584 if (type() == nullValue) | |
| 3585 return nullptr; | |
| 3586 CZString actualKey(begin, static_cast<unsigned>(end - begin), | |
| 3587 CZString::noDuplication); | |
| 3588 ObjectValues::const_iterator it = value_.map_->find(actualKey); | |
| 3589 if (it == value_.map_->end()) | |
| 3590 return nullptr; | |
| 3591 return &(*it).second; | |
| 3592 } | |
| 3593 const Value& Value::operator[](const char* key) const { | |
| 3594 Value const* found = find(key, key + strlen(key)); | |
| 3595 if (!found) | |
| 3596 return nullSingleton(); | |
| 3597 return *found; | |
| 3598 } | |
| 3599 Value const& Value::operator[](const String& key) const { | |
| 3600 Value const* found = find(key.data(), key.data() + key.length()); | |
| 3601 if (!found) | |
| 3602 return nullSingleton(); | |
| 3603 return *found; | |
| 3604 } | |
| 3605 | |
| 3606 Value& Value::operator[](const char* key) { | |
| 3607 return resolveReference(key, key + strlen(key)); | |
| 3608 } | |
| 3609 | |
| 3610 Value& Value::operator[](const String& key) { | |
| 3611 return resolveReference(key.data(), key.data() + key.length()); | |
| 3612 } | |
| 3613 | |
| 3614 Value& Value::operator[](const StaticString& key) { | |
| 3615 return resolveReference(key.c_str()); | |
| 3616 } | |
| 3617 | |
| 3618 #ifdef JSON_USE_CPPTL | |
| 3619 Value& Value::operator[](const CppTL::ConstString& key) { | |
| 3620 return resolveReference(key.c_str(), key.end_c_str()); | |
| 3621 } | |
| 3622 Value const& Value::operator[](CppTL::ConstString const& key) const { | |
| 3623 Value const* found = find(key.c_str(), key.end_c_str()); | |
| 3624 if (!found) | |
| 3625 return nullSingleton(); | |
| 3626 return *found; | |
| 3627 } | |
| 3628 #endif | |
| 3629 | |
| 3630 Value& Value::append(const Value& value) { return (*this)[size()] = value; } | |
| 3631 | |
| 3632 #if JSON_HAS_RVALUE_REFERENCES | |
| 3633 Value& Value::append(Value&& value) { | |
| 3634 return (*this)[size()] = std::move(value); | |
| 3635 } | |
| 3636 #endif | |
| 3637 | |
| 3638 Value Value::get(char const* begin, | |
| 3639 char const* end, | |
| 3640 Value const& defaultValue) const { | |
| 3641 Value const* found = find(begin, end); | |
| 3642 return !found ? defaultValue : *found; | |
| 3643 } | |
| 3644 Value Value::get(char const* key, Value const& defaultValue) const { | |
| 3645 return get(key, key + strlen(key), defaultValue); | |
| 3646 } | |
| 3647 Value Value::get(String const& key, Value const& defaultValue) const { | |
| 3648 return get(key.data(), key.data() + key.length(), defaultValue); | |
| 3649 } | |
| 3650 | |
| 3651 bool Value::removeMember(const char* begin, const char* end, Value* removed) { | |
| 3652 if (type() != objectValue) { | |
| 3653 return false; | |
| 3654 } | |
| 3655 CZString actualKey(begin, static_cast<unsigned>(end - begin), | |
| 3656 CZString::noDuplication); | |
| 3657 auto it = value_.map_->find(actualKey); | |
| 3658 if (it == value_.map_->end()) | |
| 3659 return false; | |
| 3660 if (removed) | |
| 3661 #if JSON_HAS_RVALUE_REFERENCES | |
| 3662 *removed = std::move(it->second); | |
| 3663 #else | |
| 3664 *removed = it->second; | |
| 3665 #endif | |
| 3666 value_.map_->erase(it); | |
| 3667 return true; | |
| 3668 } | |
| 3669 bool Value::removeMember(const char* key, Value* removed) { | |
| 3670 return removeMember(key, key + strlen(key), removed); | |
| 3671 } | |
| 3672 bool Value::removeMember(String const& key, Value* removed) { | |
| 3673 return removeMember(key.data(), key.data() + key.length(), removed); | |
| 3674 } | |
| 3675 void Value::removeMember(const char* key) { | |
| 3676 JSON_ASSERT_MESSAGE(type() == nullValue || type() == objectValue, | |
| 3677 "in Json::Value::removeMember(): requires objectValue"); | |
| 3678 if (type() == nullValue) | |
| 3679 return; | |
| 3680 | |
| 3681 CZString actualKey(key, unsigned(strlen(key)), CZString::noDuplication); | |
| 3682 value_.map_->erase(actualKey); | |
| 3683 } | |
| 3684 void Value::removeMember(const String& key) { removeMember(key.c_str()); } | |
| 3685 | |
| 3686 bool Value::removeIndex(ArrayIndex index, Value* removed) { | |
| 3687 if (type() != arrayValue) { | |
| 3688 return false; | |
| 3689 } | |
| 3690 CZString key(index); | |
| 3691 auto it = value_.map_->find(key); | |
| 3692 if (it == value_.map_->end()) { | |
| 3693 return false; | |
| 3694 } | |
| 3695 if (removed) | |
| 3696 *removed = it->second; | |
| 3697 ArrayIndex oldSize = size(); | |
| 3698 // shift left all items left, into the place of the "removed" | |
| 3699 for (ArrayIndex i = index; i < (oldSize - 1); ++i) { | |
| 3700 CZString keey(i); | |
| 3701 (*value_.map_)[keey] = (*this)[i + 1]; | |
| 3702 } | |
| 3703 // erase the last one ("leftover") | |
| 3704 CZString keyLast(oldSize - 1); | |
| 3705 auto itLast = value_.map_->find(keyLast); | |
| 3706 value_.map_->erase(itLast); | |
| 3707 return true; | |
| 3708 } | |
| 3709 | |
| 3710 #ifdef JSON_USE_CPPTL | |
| 3711 Value Value::get(const CppTL::ConstString& key, | |
| 3712 const Value& defaultValue) const { | |
| 3713 return get(key.c_str(), key.end_c_str(), defaultValue); | |
| 3714 } | |
| 3715 #endif | |
| 3716 | |
| 3717 bool Value::isMember(char const* begin, char const* end) const { | |
| 3718 Value const* value = find(begin, end); | |
| 3719 return nullptr != value; | |
| 3720 } | |
| 3721 bool Value::isMember(char const* key) const { | |
| 3722 return isMember(key, key + strlen(key)); | |
| 3723 } | |
| 3724 bool Value::isMember(String const& key) const { | |
| 3725 return isMember(key.data(), key.data() + key.length()); | |
| 3726 } | |
| 3727 | |
| 3728 #ifdef JSON_USE_CPPTL | |
| 3729 bool Value::isMember(const CppTL::ConstString& key) const { | |
| 3730 return isMember(key.c_str(), key.end_c_str()); | |
| 3731 } | |
| 3732 #endif | |
| 3733 | |
| 3734 Value::Members Value::getMemberNames() const { | |
| 3735 JSON_ASSERT_MESSAGE( | |
| 3736 type() == nullValue || type() == objectValue, | |
| 3737 "in Json::Value::getMemberNames(), value must be objectValue"); | |
| 3738 if (type() == nullValue) | |
| 3739 return Value::Members(); | |
| 3740 Members members; | |
| 3741 members.reserve(value_.map_->size()); | |
| 3742 ObjectValues::const_iterator it = value_.map_->begin(); | |
| 3743 ObjectValues::const_iterator itEnd = value_.map_->end(); | |
| 3744 for (; it != itEnd; ++it) { | |
| 3745 members.push_back(String((*it).first.data(), (*it).first.length())); | |
| 3746 } | |
| 3747 return members; | |
| 3748 } | |
| 3749 // | |
| 3750 //# ifdef JSON_USE_CPPTL | |
| 3751 // EnumMemberNames | |
| 3752 // Value::enumMemberNames() const | |
| 3753 //{ | |
| 3754 // if ( type() == objectValue ) | |
| 3755 // { | |
| 3756 // return CppTL::Enum::any( CppTL::Enum::transform( | |
| 3757 // CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>() ), | |
| 3758 // MemberNamesTransform() ) ); | |
| 3759 // } | |
| 3760 // return EnumMemberNames(); | |
| 3761 //} | |
| 3762 // | |
| 3763 // | |
| 3764 // EnumValues | |
| 3765 // Value::enumValues() const | |
| 3766 //{ | |
| 3767 // if ( type() == objectValue || type() == arrayValue ) | |
| 3768 // return CppTL::Enum::anyValues( *(value_.map_), | |
| 3769 // CppTL::Type<const Value &>() ); | |
| 3770 // return EnumValues(); | |
| 3771 //} | |
| 3772 // | |
| 3773 //# endif | |
| 3774 | |
| 3775 static bool IsIntegral(double d) { | |
| 3776 double integral_part; | |
| 3777 return modf(d, &integral_part) == 0.0; | |
| 3778 } | |
| 3779 | |
| 3780 bool Value::isNull() const { return type() == nullValue; } | |
| 3781 | |
| 3782 bool Value::isBool() const { return type() == booleanValue; } | |
| 3783 | |
| 3784 bool Value::isInt() const { | |
| 3785 switch (type()) { | |
| 3786 case intValue: | |
| 3787 #if defined(JSON_HAS_INT64) | |
| 3788 return value_.int_ >= minInt && value_.int_ <= maxInt; | |
| 3789 #else | |
| 3790 return true; | |
| 3791 #endif | |
| 3792 case uintValue: | |
| 3793 return value_.uint_ <= UInt(maxInt); | |
| 3794 case realValue: | |
| 3795 return value_.real_ >= minInt && value_.real_ <= maxInt && | |
| 3796 IsIntegral(value_.real_); | |
| 3797 default: | |
| 3798 break; | |
| 3799 } | |
| 3800 return false; | |
| 3801 } | |
| 3802 | |
| 3803 bool Value::isUInt() const { | |
| 3804 switch (type()) { | |
| 3805 case intValue: | |
| 3806 #if defined(JSON_HAS_INT64) | |
| 3807 return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt); | |
| 3808 #else | |
| 3809 return value_.int_ >= 0; | |
| 3810 #endif | |
| 3811 case uintValue: | |
| 3812 #if defined(JSON_HAS_INT64) | |
| 3813 return value_.uint_ <= maxUInt; | |
| 3814 #else | |
| 3815 return true; | |
| 3816 #endif | |
| 3817 case realValue: | |
| 3818 return value_.real_ >= 0 && value_.real_ <= maxUInt && | |
| 3819 IsIntegral(value_.real_); | |
| 3820 default: | |
| 3821 break; | |
| 3822 } | |
| 3823 return false; | |
| 3824 } | |
| 3825 | |
| 3826 bool Value::isInt64() const { | |
| 3827 #if defined(JSON_HAS_INT64) | |
| 3828 switch (type()) { | |
| 3829 case intValue: | |
| 3830 return true; | |
| 3831 case uintValue: | |
| 3832 return value_.uint_ <= UInt64(maxInt64); | |
| 3833 case realValue: | |
| 3834 // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a | |
| 3835 // double, so double(maxInt64) will be rounded up to 2^63. Therefore we | |
| 3836 // require the value to be strictly less than the limit. | |
| 3837 return value_.real_ >= double(minInt64) && | |
| 3838 value_.real_ < double(maxInt64) && IsIntegral(value_.real_); | |
| 3839 default: | |
| 3840 break; | |
| 3841 } | |
| 3842 #endif // JSON_HAS_INT64 | |
| 3843 return false; | |
| 3844 } | |
| 3845 | |
| 3846 bool Value::isUInt64() const { | |
| 3847 #if defined(JSON_HAS_INT64) | |
| 3848 switch (type()) { | |
| 3849 case intValue: | |
| 3850 return value_.int_ >= 0; | |
| 3851 case uintValue: | |
| 3852 return true; | |
| 3853 case realValue: | |
| 3854 // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a | |
| 3855 // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we | |
| 3856 // require the value to be strictly less than the limit. | |
| 3857 return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble && | |
| 3858 IsIntegral(value_.real_); | |
| 3859 default: | |
| 3860 break; | |
| 3861 } | |
| 3862 #endif // JSON_HAS_INT64 | |
| 3863 return false; | |
| 3864 } | |
| 3865 | |
| 3866 bool Value::isIntegral() const { | |
| 3867 switch (type()) { | |
| 3868 case intValue: | |
| 3869 case uintValue: | |
| 3870 return true; | |
| 3871 case realValue: | |
| 3872 #if defined(JSON_HAS_INT64) | |
| 3873 // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a | |
| 3874 // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we | |
| 3875 // require the value to be strictly less than the limit. | |
| 3876 return value_.real_ >= double(minInt64) && | |
| 3877 value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_); | |
| 3878 #else | |
| 3879 return value_.real_ >= minInt && value_.real_ <= maxUInt && | |
| 3880 IsIntegral(value_.real_); | |
| 3881 #endif // JSON_HAS_INT64 | |
| 3882 default: | |
| 3883 break; | |
| 3884 } | |
| 3885 return false; | |
| 3886 } | |
| 3887 | |
| 3888 bool Value::isDouble() const { | |
| 3889 return type() == intValue || type() == uintValue || type() == realValue; | |
| 3890 } | |
| 3891 | |
| 3892 bool Value::isNumeric() const { return isDouble(); } | |
| 3893 | |
| 3894 bool Value::isString() const { return type() == stringValue; } | |
| 3895 | |
| 3896 bool Value::isArray() const { return type() == arrayValue; } | |
| 3897 | |
| 3898 bool Value::isObject() const { return type() == objectValue; } | |
| 3899 | |
| 3900 void Value::setComment(const char* comment, | |
| 3901 size_t len, | |
| 3902 CommentPlacement placement) { | |
| 3903 if (!comments_) | |
| 3904 comments_ = new CommentInfo[numberOfCommentPlacement]; | |
| 3905 if ((len > 0) && (comment[len - 1] == '\n')) { | |
| 3906 // Always discard trailing newline, to aid indentation. | |
| 3907 len -= 1; | |
| 3908 } | |
| 3909 comments_[placement].setComment(comment, len); | |
| 3910 } | |
| 3911 | |
| 3912 void Value::setComment(const char* comment, CommentPlacement placement) { | |
| 3913 setComment(comment, strlen(comment), placement); | |
| 3914 } | |
| 3915 | |
| 3916 void Value::setComment(const String& comment, CommentPlacement placement) { | |
| 3917 setComment(comment.c_str(), comment.length(), placement); | |
| 3918 } | |
| 3919 | |
| 3920 bool Value::hasComment(CommentPlacement placement) const { | |
| 3921 return comments_ != nullptr && comments_[placement].comment_ != nullptr; | |
| 3922 } | |
| 3923 | |
| 3924 String Value::getComment(CommentPlacement placement) const { | |
| 3925 if (hasComment(placement)) | |
| 3926 return comments_[placement].comment_; | |
| 3927 return ""; | |
| 3928 } | |
| 3929 | |
| 3930 void Value::setOffsetStart(ptrdiff_t start) { start_ = start; } | |
| 3931 | |
| 3932 void Value::setOffsetLimit(ptrdiff_t limit) { limit_ = limit; } | |
| 3933 | |
| 3934 ptrdiff_t Value::getOffsetStart() const { return start_; } | |
| 3935 | |
| 3936 ptrdiff_t Value::getOffsetLimit() const { return limit_; } | |
| 3937 | |
| 3938 String Value::toStyledString() const { | |
| 3939 StreamWriterBuilder builder; | |
| 3940 | |
| 3941 String out = this->hasComment(commentBefore) ? "\n" : ""; | |
| 3942 out += Json::writeString(builder, *this); | |
| 3943 out += '\n'; | |
| 3944 | |
| 3945 return out; | |
| 3946 } | |
| 3947 | |
| 3948 Value::const_iterator Value::begin() const { | |
| 3949 switch (type()) { | |
| 3950 case arrayValue: | |
| 3951 case objectValue: | |
| 3952 if (value_.map_) | |
| 3953 return const_iterator(value_.map_->begin()); | |
| 3954 break; | |
| 3955 default: | |
| 3956 break; | |
| 3957 } | |
| 3958 return {}; | |
| 3959 } | |
| 3960 | |
| 3961 Value::const_iterator Value::end() const { | |
| 3962 switch (type()) { | |
| 3963 case arrayValue: | |
| 3964 case objectValue: | |
| 3965 if (value_.map_) | |
| 3966 return const_iterator(value_.map_->end()); | |
| 3967 break; | |
| 3968 default: | |
| 3969 break; | |
| 3970 } | |
| 3971 return {}; | |
| 3972 } | |
| 3973 | |
| 3974 Value::iterator Value::begin() { | |
| 3975 switch (type()) { | |
| 3976 case arrayValue: | |
| 3977 case objectValue: | |
| 3978 if (value_.map_) | |
| 3979 return iterator(value_.map_->begin()); | |
| 3980 break; | |
| 3981 default: | |
| 3982 break; | |
| 3983 } | |
| 3984 return iterator(); | |
| 3985 } | |
| 3986 | |
| 3987 Value::iterator Value::end() { | |
| 3988 switch (type()) { | |
| 3989 case arrayValue: | |
| 3990 case objectValue: | |
| 3991 if (value_.map_) | |
| 3992 return iterator(value_.map_->end()); | |
| 3993 break; | |
| 3994 default: | |
| 3995 break; | |
| 3996 } | |
| 3997 return iterator(); | |
| 3998 } | |
| 3999 | |
| 4000 // class PathArgument | |
| 4001 // ////////////////////////////////////////////////////////////////// | |
| 4002 | |
| 4003 PathArgument::PathArgument() : key_() {} | |
| 4004 | |
| 4005 PathArgument::PathArgument(ArrayIndex index) | |
| 4006 : key_(), index_(index), kind_(kindIndex) {} | |
| 4007 | |
| 4008 PathArgument::PathArgument(const char* key) | |
| 4009 : key_(key), index_(), kind_(kindKey) {} | |
| 4010 | |
| 4011 PathArgument::PathArgument(const String& key) | |
| 4012 : key_(key.c_str()), index_(), kind_(kindKey) {} | |
| 4013 | |
| 4014 // class Path | |
| 4015 // ////////////////////////////////////////////////////////////////// | |
| 4016 | |
| 4017 Path::Path(const String& path, | |
| 4018 const PathArgument& a1, | |
| 4019 const PathArgument& a2, | |
| 4020 const PathArgument& a3, | |
| 4021 const PathArgument& a4, | |
| 4022 const PathArgument& a5) { | |
| 4023 InArgs in; | |
| 4024 in.reserve(5); | |
| 4025 in.push_back(&a1); | |
| 4026 in.push_back(&a2); | |
| 4027 in.push_back(&a3); | |
| 4028 in.push_back(&a4); | |
| 4029 in.push_back(&a5); | |
| 4030 makePath(path, in); | |
| 4031 } | |
| 4032 | |
| 4033 void Path::makePath(const String& path, const InArgs& in) { | |
| 4034 const char* current = path.c_str(); | |
| 4035 const char* end = current + path.length(); | |
| 4036 auto itInArg = in.begin(); | |
| 4037 while (current != end) { | |
| 4038 if (*current == '[') { | |
| 4039 ++current; | |
| 4040 if (*current == '%') | |
| 4041 addPathInArg(path, in, itInArg, PathArgument::kindIndex); | |
| 4042 else { | |
| 4043 ArrayIndex index = 0; | |
| 4044 for (; current != end && *current >= '0' && *current <= '9'; ++current) | |
| 4045 index = index * 10 + ArrayIndex(*current - '0'); | |
| 4046 args_.push_back(index); | |
| 4047 } | |
| 4048 if (current == end || *++current != ']') | |
| 4049 invalidPath(path, int(current - path.c_str())); | |
| 4050 } else if (*current == '%') { | |
| 4051 addPathInArg(path, in, itInArg, PathArgument::kindKey); | |
| 4052 ++current; | |
| 4053 } else if (*current == '.' || *current == ']') { | |
| 4054 ++current; | |
| 4055 } else { | |
| 4056 const char* beginName = current; | |
| 4057 while (current != end && !strchr("[.", *current)) | |
| 4058 ++current; | |
| 4059 args_.push_back(String(beginName, current)); | |
| 4060 } | |
| 4061 } | |
| 4062 } | |
| 4063 | |
| 4064 void Path::addPathInArg(const String& /*path*/, | |
| 4065 const InArgs& in, | |
| 4066 InArgs::const_iterator& itInArg, | |
| 4067 PathArgument::Kind kind) { | |
| 4068 if (itInArg == in.end()) { | |
| 4069 // Error: missing argument %d | |
| 4070 } else if ((*itInArg)->kind_ != kind) { | |
| 4071 // Error: bad argument type | |
| 4072 } else { | |
| 4073 args_.push_back(**itInArg++); | |
| 4074 } | |
| 4075 } | |
| 4076 | |
| 4077 void Path::invalidPath(const String& /*path*/, int /*location*/) { | |
| 4078 // Error: invalid path. | |
| 4079 } | |
| 4080 | |
| 4081 const Value& Path::resolve(const Value& root) const { | |
| 4082 const Value* node = &root; | |
| 4083 for (const auto& arg : args_) { | |
| 4084 if (arg.kind_ == PathArgument::kindIndex) { | |
| 4085 if (!node->isArray() || !node->isValidIndex(arg.index_)) { | |
| 4086 // Error: unable to resolve path (array value expected at position... | |
| 4087 return Value::null; | |
| 4088 } | |
| 4089 node = &((*node)[arg.index_]); | |
| 4090 } else if (arg.kind_ == PathArgument::kindKey) { | |
| 4091 if (!node->isObject()) { | |
| 4092 // Error: unable to resolve path (object value expected at position...) | |
| 4093 return Value::null; | |
| 4094 } | |
| 4095 node = &((*node)[arg.key_]); | |
| 4096 if (node == &Value::nullSingleton()) { | |
| 4097 // Error: unable to resolve path (object has no member named '' at | |
| 4098 // position...) | |
| 4099 return Value::null; | |
| 4100 } | |
| 4101 } | |
| 4102 } | |
| 4103 return *node; | |
| 4104 } | |
| 4105 | |
| 4106 Value Path::resolve(const Value& root, const Value& defaultValue) const { | |
| 4107 const Value* node = &root; | |
| 4108 for (const auto& arg : args_) { | |
| 4109 if (arg.kind_ == PathArgument::kindIndex) { | |
| 4110 if (!node->isArray() || !node->isValidIndex(arg.index_)) | |
| 4111 return defaultValue; | |
| 4112 node = &((*node)[arg.index_]); | |
| 4113 } else if (arg.kind_ == PathArgument::kindKey) { | |
| 4114 if (!node->isObject()) | |
| 4115 return defaultValue; | |
| 4116 node = &((*node)[arg.key_]); | |
| 4117 if (node == &Value::nullSingleton()) | |
| 4118 return defaultValue; | |
| 4119 } | |
| 4120 } | |
| 4121 return *node; | |
| 4122 } | |
| 4123 | |
| 4124 Value& Path::make(Value& root) const { | |
| 4125 Value* node = &root; | |
| 4126 for (const auto& arg : args_) { | |
| 4127 if (arg.kind_ == PathArgument::kindIndex) { | |
| 4128 if (!node->isArray()) { | |
| 4129 // Error: node is not an array at position ... | |
| 4130 } | |
| 4131 node = &((*node)[arg.index_]); | |
| 4132 } else if (arg.kind_ == PathArgument::kindKey) { | |
| 4133 if (!node->isObject()) { | |
| 4134 // Error: node is not an object at position... | |
| 4135 } | |
| 4136 node = &((*node)[arg.key_]); | |
| 4137 } | |
| 4138 } | |
| 4139 return *node; | |
| 4140 } | |
| 4141 | |
| 4142 } // namespace Json | |
| 4143 | |
| 4144 // ////////////////////////////////////////////////////////////////////// | |
| 4145 // End of content of file: src/lib_json/json_value.cpp | |
| 4146 // ////////////////////////////////////////////////////////////////////// | |
| 4147 | |
| 4148 | |
| 4149 | |
| 4150 | |
| 4151 | |
| 4152 | |
| 4153 // ////////////////////////////////////////////////////////////////////// | |
| 4154 // Beginning of content of file: src/lib_json/json_writer.cpp | |
| 4155 // ////////////////////////////////////////////////////////////////////// | |
| 4156 | |
| 4157 // Copyright 2011 Baptiste Lepilleur and The JsonCpp Authors | |
| 4158 // Distributed under MIT license, or public domain if desired and | |
| 4159 // recognized in your jurisdiction. | |
| 4160 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE | |
| 4161 | |
| 4162 #if !defined(JSON_IS_AMALGAMATION) | |
| 4163 #include "json_tool.h" | |
| 4164 #include <json/writer.h> | |
| 4165 #endif // if !defined(JSON_IS_AMALGAMATION) | |
| 4166 #include <cassert> | |
| 4167 #include <cstring> | |
| 4168 #include <iomanip> | |
| 4169 #include <memory> | |
| 4170 #include <set> | |
| 4171 #include <sstream> | |
| 4172 #include <utility> | |
| 4173 | |
| 4174 #if __cplusplus >= 201103L | |
| 4175 #include <cmath> | |
| 4176 #include <cstdio> | |
| 4177 | |
| 4178 #if !defined(isnan) | |
| 4179 #define isnan std::isnan | |
| 4180 #endif | |
| 4181 | |
| 4182 #if !defined(isfinite) | |
| 4183 #define isfinite std::isfinite | |
| 4184 #endif | |
| 4185 | |
| 4186 #else | |
| 4187 #include <cmath> | |
| 4188 #include <cstdio> | |
| 4189 | |
| 4190 #if defined(_MSC_VER) | |
| 4191 #if !defined(isnan) | |
| 4192 #include <float.h> | |
| 4193 #define isnan _isnan | |
| 4194 #endif | |
| 4195 | |
| 4196 #if !defined(isfinite) | |
| 4197 #include <float.h> | |
| 4198 #define isfinite _finite | |
| 4199 #endif | |
| 4200 | |
| 4201 #if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES) | |
| 4202 #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1 | |
| 4203 #endif //_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES | |
| 4204 | |
| 4205 #endif //_MSC_VER | |
| 4206 | |
| 4207 #if defined(__sun) && defined(__SVR4) // Solaris | |
| 4208 #if !defined(isfinite) | |
| 4209 #include <ieeefp.h> | |
| 4210 #define isfinite finite | |
| 4211 #endif | |
| 4212 #endif | |
| 4213 | |
| 4214 #if defined(__hpux) | |
| 4215 #if !defined(isfinite) | |
| 4216 #if defined(__ia64) && !defined(finite) | |
| 4217 #define isfinite(x) \ | |
| 4218 ((sizeof(x) == sizeof(float) ? _Isfinitef(x) : _IsFinite(x))) | |
| 4219 #endif | |
| 4220 #endif | |
| 4221 #endif | |
| 4222 | |
| 4223 #if !defined(isnan) | |
| 4224 // IEEE standard states that NaN values will not compare to themselves | |
| 4225 #define isnan(x) (x != x) | |
| 4226 #endif | |
| 4227 | |
| 4228 #if !defined(__APPLE__) | |
| 4229 #if !defined(isfinite) | |
| 4230 #define isfinite finite | |
| 4231 #endif | |
| 4232 #endif | |
| 4233 #endif | |
| 4234 | |
| 4235 #if defined(_MSC_VER) | |
| 4236 // Disable warning about strdup being deprecated. | |
| 4237 #pragma warning(disable : 4996) | |
| 4238 #endif | |
| 4239 | |
| 4240 namespace Json { | |
| 4241 | |
| 4242 #if __cplusplus >= 201103L || (defined(_CPPLIB_VER) && _CPPLIB_VER >= 520) | |
| 4243 typedef std::unique_ptr<StreamWriter> StreamWriterPtr; | |
| 4244 #else | |
|
1298
8a0a62189f46
replacing std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
499
diff
changeset
|
4245 typedef std::unique_ptr<StreamWriter> StreamWriterPtr; |
| 499 | 4246 #endif |
| 4247 | |
| 4248 String valueToString(LargestInt value) { | |
| 4249 UIntToStringBuffer buffer; | |
| 4250 char* current = buffer + sizeof(buffer); | |
| 4251 if (value == Value::minLargestInt) { | |
| 4252 uintToString(LargestUInt(Value::maxLargestInt) + 1, current); | |
| 4253 *--current = '-'; | |
| 4254 } else if (value < 0) { | |
| 4255 uintToString(LargestUInt(-value), current); | |
| 4256 *--current = '-'; | |
| 4257 } else { | |
| 4258 uintToString(LargestUInt(value), current); | |
| 4259 } | |
| 4260 assert(current >= buffer); | |
| 4261 return current; | |
| 4262 } | |
| 4263 | |
| 4264 String valueToString(LargestUInt value) { | |
| 4265 UIntToStringBuffer buffer; | |
| 4266 char* current = buffer + sizeof(buffer); | |
| 4267 uintToString(value, current); | |
| 4268 assert(current >= buffer); | |
| 4269 return current; | |
| 4270 } | |
| 4271 | |
| 4272 #if defined(JSON_HAS_INT64) | |
| 4273 | |
| 4274 String valueToString(Int value) { return valueToString(LargestInt(value)); } | |
| 4275 | |
| 4276 String valueToString(UInt value) { return valueToString(LargestUInt(value)); } | |
| 4277 | |
| 4278 #endif // # if defined(JSON_HAS_INT64) | |
| 4279 | |
| 4280 namespace { | |
| 4281 String valueToString(double value, | |
| 4282 bool useSpecialFloats, | |
| 4283 unsigned int precision, | |
| 4284 PrecisionType precisionType) { | |
| 4285 // Print into the buffer. We need not request the alternative representation | |
| 4286 // that always has a decimal point because JSON doesn't distinguish the | |
| 4287 // concepts of reals and integers. | |
| 4288 if (!isfinite(value)) { | |
| 4289 static const char* const reps[2][3] = {{"NaN", "-Infinity", "Infinity"}, | |
| 4290 {"null", "-1e+9999", "1e+9999"}}; | |
| 4291 return reps[useSpecialFloats ? 0 : 1] | |
| 4292 [isnan(value) ? 0 : (value < 0) ? 1 : 2]; | |
| 4293 } | |
| 4294 | |
| 4295 String buffer(size_t(36), '\0'); | |
| 4296 while (true) { | |
| 4297 int len = jsoncpp_snprintf( | |
| 4298 &*buffer.begin(), buffer.size(), | |
| 4299 (precisionType == PrecisionType::significantDigits) ? "%.*g" : "%.*f", | |
| 4300 precision, value); | |
| 4301 assert(len >= 0); | |
| 4302 auto wouldPrint = static_cast<size_t>(len); | |
| 4303 if (wouldPrint >= buffer.size()) { | |
| 4304 buffer.resize(wouldPrint + 1); | |
| 4305 continue; | |
| 4306 } | |
| 4307 buffer.resize(wouldPrint); | |
| 4308 break; | |
| 4309 } | |
| 4310 | |
| 4311 buffer.erase(fixNumericLocale(buffer.begin(), buffer.end()), buffer.end()); | |
| 4312 | |
| 4313 // strip the zero padding from the right | |
| 4314 if (precisionType == PrecisionType::decimalPlaces) { | |
| 4315 buffer.erase(fixZerosInTheEnd(buffer.begin(), buffer.end()), buffer.end()); | |
| 4316 } | |
| 4317 | |
| 4318 // try to ensure we preserve the fact that this was given to us as a double on | |
| 4319 // input | |
| 4320 if (buffer.find('.') == buffer.npos && buffer.find('e') == buffer.npos) { | |
| 4321 buffer += ".0"; | |
| 4322 } | |
| 4323 return buffer; | |
| 4324 } | |
| 4325 } // namespace | |
| 4326 | |
| 4327 String valueToString(double value, | |
| 4328 unsigned int precision, | |
| 4329 PrecisionType precisionType) { | |
| 4330 return valueToString(value, false, precision, precisionType); | |
| 4331 } | |
| 4332 | |
| 4333 String valueToString(bool value) { return value ? "true" : "false"; } | |
| 4334 | |
| 4335 static bool isAnyCharRequiredQuoting(char const* s, size_t n) { | |
| 4336 assert(s || !n); | |
| 4337 | |
| 4338 char const* const end = s + n; | |
| 4339 for (char const* cur = s; cur < end; ++cur) { | |
| 4340 if (*cur == '\\' || *cur == '\"' || *cur < ' ' || | |
| 4341 static_cast<unsigned char>(*cur) < 0x80) | |
| 4342 return true; | |
| 4343 } | |
| 4344 return false; | |
| 4345 } | |
| 4346 | |
| 4347 static unsigned int utf8ToCodepoint(const char*& s, const char* e) { | |
| 4348 const unsigned int REPLACEMENT_CHARACTER = 0xFFFD; | |
| 4349 | |
| 4350 unsigned int firstByte = static_cast<unsigned char>(*s); | |
| 4351 | |
| 4352 if (firstByte < 0x80) | |
| 4353 return firstByte; | |
| 4354 | |
| 4355 if (firstByte < 0xE0) { | |
| 4356 if (e - s < 2) | |
| 4357 return REPLACEMENT_CHARACTER; | |
| 4358 | |
| 4359 unsigned int calculated = | |
| 4360 ((firstByte & 0x1F) << 6) | (static_cast<unsigned int>(s[1]) & 0x3F); | |
| 4361 s += 1; | |
| 4362 // oversized encoded characters are invalid | |
| 4363 return calculated < 0x80 ? REPLACEMENT_CHARACTER : calculated; | |
| 4364 } | |
| 4365 | |
| 4366 if (firstByte < 0xF0) { | |
| 4367 if (e - s < 3) | |
| 4368 return REPLACEMENT_CHARACTER; | |
| 4369 | |
| 4370 unsigned int calculated = ((firstByte & 0x0F) << 12) | | |
| 4371 ((static_cast<unsigned int>(s[1]) & 0x3F) << 6) | | |
| 4372 (static_cast<unsigned int>(s[2]) & 0x3F); | |
| 4373 s += 2; | |
| 4374 // surrogates aren't valid codepoints itself | |
| 4375 // shouldn't be UTF-8 encoded | |
| 4376 if (calculated >= 0xD800 && calculated <= 0xDFFF) | |
| 4377 return REPLACEMENT_CHARACTER; | |
| 4378 // oversized encoded characters are invalid | |
| 4379 return calculated < 0x800 ? REPLACEMENT_CHARACTER : calculated; | |
| 4380 } | |
| 4381 | |
| 4382 if (firstByte < 0xF8) { | |
| 4383 if (e - s < 4) | |
| 4384 return REPLACEMENT_CHARACTER; | |
| 4385 | |
| 4386 unsigned int calculated = ((firstByte & 0x07) << 18) | | |
| 4387 ((static_cast<unsigned int>(s[1]) & 0x3F) << 12) | | |
| 4388 ((static_cast<unsigned int>(s[2]) & 0x3F) << 6) | | |
| 4389 (static_cast<unsigned int>(s[3]) & 0x3F); | |
| 4390 s += 3; | |
| 4391 // oversized encoded characters are invalid | |
| 4392 return calculated < 0x10000 ? REPLACEMENT_CHARACTER : calculated; | |
| 4393 } | |
| 4394 | |
| 4395 return REPLACEMENT_CHARACTER; | |
| 4396 } | |
| 4397 | |
| 4398 static const char hex2[] = "000102030405060708090a0b0c0d0e0f" | |
| 4399 "101112131415161718191a1b1c1d1e1f" | |
| 4400 "202122232425262728292a2b2c2d2e2f" | |
| 4401 "303132333435363738393a3b3c3d3e3f" | |
| 4402 "404142434445464748494a4b4c4d4e4f" | |
| 4403 "505152535455565758595a5b5c5d5e5f" | |
| 4404 "606162636465666768696a6b6c6d6e6f" | |
| 4405 "707172737475767778797a7b7c7d7e7f" | |
| 4406 "808182838485868788898a8b8c8d8e8f" | |
| 4407 "909192939495969798999a9b9c9d9e9f" | |
| 4408 "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf" | |
| 4409 "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf" | |
| 4410 "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf" | |
| 4411 "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf" | |
| 4412 "e0e1e2e3e4e5e6e7e8e9eaebecedeeef" | |
| 4413 "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"; | |
| 4414 | |
| 4415 static String toHex16Bit(unsigned int x) { | |
| 4416 const unsigned int hi = (x >> 8) & 0xff; | |
| 4417 const unsigned int lo = x & 0xff; | |
| 4418 String result(4, ' '); | |
| 4419 result[0] = hex2[2 * hi]; | |
| 4420 result[1] = hex2[2 * hi + 1]; | |
| 4421 result[2] = hex2[2 * lo]; | |
| 4422 result[3] = hex2[2 * lo + 1]; | |
| 4423 return result; | |
| 4424 } | |
| 4425 | |
| 4426 static String valueToQuotedStringN(const char* value, unsigned length) { | |
| 4427 if (value == nullptr) | |
| 4428 return ""; | |
| 4429 | |
| 4430 if (!isAnyCharRequiredQuoting(value, length)) | |
| 4431 return String("\"") + value + "\""; | |
| 4432 // We have to walk value and escape any special characters. | |
| 4433 // Appending to String is not efficient, but this should be rare. | |
| 4434 // (Note: forward slashes are *not* rare, but I am not escaping them.) | |
| 4435 String::size_type maxsize = length * 2 + 3; // allescaped+quotes+NULL | |
| 4436 String result; | |
| 4437 result.reserve(maxsize); // to avoid lots of mallocs | |
| 4438 result += "\""; | |
| 4439 char const* end = value + length; | |
| 4440 for (const char* c = value; c != end; ++c) { | |
| 4441 switch (*c) { | |
| 4442 case '\"': | |
| 4443 result += "\\\""; | |
| 4444 break; | |
| 4445 case '\\': | |
| 4446 result += "\\\\"; | |
| 4447 break; | |
| 4448 case '\b': | |
| 4449 result += "\\b"; | |
| 4450 break; | |
| 4451 case '\f': | |
| 4452 result += "\\f"; | |
| 4453 break; | |
| 4454 case '\n': | |
| 4455 result += "\\n"; | |
| 4456 break; | |
| 4457 case '\r': | |
| 4458 result += "\\r"; | |
| 4459 break; | |
| 4460 case '\t': | |
| 4461 result += "\\t"; | |
| 4462 break; | |
| 4463 // case '/': | |
| 4464 // Even though \/ is considered a legal escape in JSON, a bare | |
| 4465 // slash is also legal, so I see no reason to escape it. | |
| 4466 // (I hope I am not misunderstanding something.) | |
| 4467 // blep notes: actually escaping \/ may be useful in javascript to avoid </ | |
| 4468 // sequence. | |
| 4469 // Should add a flag to allow this compatibility mode and prevent this | |
| 4470 // sequence from occurring. | |
| 4471 default: { | |
| 4472 unsigned int cp = utf8ToCodepoint(c, end); | |
| 4473 // don't escape non-control characters | |
| 4474 // (short escape sequence are applied above) | |
| 4475 if (cp < 0x80 && cp >= 0x20) | |
| 4476 result += static_cast<char>(cp); | |
| 4477 else if (cp < 0x10000) { // codepoint is in Basic Multilingual Plane | |
| 4478 result += "\\u"; | |
| 4479 result += toHex16Bit(cp); | |
| 4480 } else { // codepoint is not in Basic Multilingual Plane | |
| 4481 // convert to surrogate pair first | |
| 4482 cp -= 0x10000; | |
| 4483 result += "\\u"; | |
| 4484 result += toHex16Bit((cp >> 10) + 0xD800); | |
| 4485 result += "\\u"; | |
| 4486 result += toHex16Bit((cp & 0x3FF) + 0xDC00); | |
| 4487 } | |
| 4488 } break; | |
| 4489 } | |
| 4490 } | |
| 4491 result += "\""; | |
| 4492 return result; | |
| 4493 } | |
| 4494 | |
| 4495 String valueToQuotedString(const char* value) { | |
| 4496 return valueToQuotedStringN(value, static_cast<unsigned int>(strlen(value))); | |
| 4497 } | |
| 4498 | |
| 4499 // Class Writer | |
| 4500 // ////////////////////////////////////////////////////////////////// | |
| 4501 Writer::~Writer() = default; | |
| 4502 | |
| 4503 // Class FastWriter | |
| 4504 // ////////////////////////////////////////////////////////////////// | |
| 4505 | |
| 4506 FastWriter::FastWriter() | |
| 4507 | |
| 4508 = default; | |
| 4509 | |
| 4510 void FastWriter::enableYAMLCompatibility() { yamlCompatibilityEnabled_ = true; } | |
| 4511 | |
| 4512 void FastWriter::dropNullPlaceholders() { dropNullPlaceholders_ = true; } | |
| 4513 | |
| 4514 void FastWriter::omitEndingLineFeed() { omitEndingLineFeed_ = true; } | |
| 4515 | |
| 4516 String FastWriter::write(const Value& root) { | |
| 4517 document_.clear(); | |
| 4518 writeValue(root); | |
| 4519 if (!omitEndingLineFeed_) | |
| 4520 document_ += '\n'; | |
| 4521 return document_; | |
| 4522 } | |
| 4523 | |
| 4524 void FastWriter::writeValue(const Value& value) { | |
| 4525 switch (value.type()) { | |
| 4526 case nullValue: | |
| 4527 if (!dropNullPlaceholders_) | |
| 4528 document_ += "null"; | |
| 4529 break; | |
| 4530 case intValue: | |
| 4531 document_ += valueToString(value.asLargestInt()); | |
| 4532 break; | |
| 4533 case uintValue: | |
| 4534 document_ += valueToString(value.asLargestUInt()); | |
| 4535 break; | |
| 4536 case realValue: | |
| 4537 document_ += valueToString(value.asDouble()); | |
| 4538 break; | |
| 4539 case stringValue: { | |
| 4540 // Is NULL possible for value.string_? No. | |
| 4541 char const* str; | |
| 4542 char const* end; | |
| 4543 bool ok = value.getString(&str, &end); | |
| 4544 if (ok) | |
| 4545 document_ += valueToQuotedStringN(str, static_cast<unsigned>(end - str)); | |
| 4546 break; | |
| 4547 } | |
| 4548 case booleanValue: | |
| 4549 document_ += valueToString(value.asBool()); | |
| 4550 break; | |
| 4551 case arrayValue: { | |
| 4552 document_ += '['; | |
| 4553 ArrayIndex size = value.size(); | |
| 4554 for (ArrayIndex index = 0; index < size; ++index) { | |
| 4555 if (index > 0) | |
| 4556 document_ += ','; | |
| 4557 writeValue(value[index]); | |
| 4558 } | |
| 4559 document_ += ']'; | |
| 4560 } break; | |
| 4561 case objectValue: { | |
| 4562 Value::Members members(value.getMemberNames()); | |
| 4563 document_ += '{'; | |
| 4564 for (auto it = members.begin(); it != members.end(); ++it) { | |
| 4565 const String& name = *it; | |
| 4566 if (it != members.begin()) | |
| 4567 document_ += ','; | |
| 4568 document_ += valueToQuotedStringN(name.data(), | |
| 4569 static_cast<unsigned>(name.length())); | |
| 4570 document_ += yamlCompatibilityEnabled_ ? ": " : ":"; | |
| 4571 writeValue(value[name]); | |
| 4572 } | |
| 4573 document_ += '}'; | |
| 4574 } break; | |
| 4575 } | |
| 4576 } | |
| 4577 | |
| 4578 // Class StyledWriter | |
| 4579 // ////////////////////////////////////////////////////////////////// | |
| 4580 | |
| 4581 StyledWriter::StyledWriter() = default; | |
| 4582 | |
| 4583 String StyledWriter::write(const Value& root) { | |
| 4584 document_.clear(); | |
| 4585 addChildValues_ = false; | |
| 4586 indentString_.clear(); | |
| 4587 writeCommentBeforeValue(root); | |
| 4588 writeValue(root); | |
| 4589 writeCommentAfterValueOnSameLine(root); | |
| 4590 document_ += '\n'; | |
| 4591 return document_; | |
| 4592 } | |
| 4593 | |
| 4594 void StyledWriter::writeValue(const Value& value) { | |
| 4595 switch (value.type()) { | |
| 4596 case nullValue: | |
| 4597 pushValue("null"); | |
| 4598 break; | |
| 4599 case intValue: | |
| 4600 pushValue(valueToString(value.asLargestInt())); | |
| 4601 break; | |
| 4602 case uintValue: | |
| 4603 pushValue(valueToString(value.asLargestUInt())); | |
| 4604 break; | |
| 4605 case realValue: | |
| 4606 pushValue(valueToString(value.asDouble())); | |
| 4607 break; | |
| 4608 case stringValue: { | |
| 4609 // Is NULL possible for value.string_? No. | |
| 4610 char const* str; | |
| 4611 char const* end; | |
| 4612 bool ok = value.getString(&str, &end); | |
| 4613 if (ok) | |
| 4614 pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end - str))); | |
| 4615 else | |
| 4616 pushValue(""); | |
| 4617 break; | |
| 4618 } | |
| 4619 case booleanValue: | |
| 4620 pushValue(valueToString(value.asBool())); | |
| 4621 break; | |
| 4622 case arrayValue: | |
| 4623 writeArrayValue(value); | |
| 4624 break; | |
| 4625 case objectValue: { | |
| 4626 Value::Members members(value.getMemberNames()); | |
| 4627 if (members.empty()) | |
| 4628 pushValue("{}"); | |
| 4629 else { | |
| 4630 writeWithIndent("{"); | |
| 4631 indent(); | |
| 4632 auto it = members.begin(); | |
| 4633 for (;;) { | |
| 4634 const String& name = *it; | |
| 4635 const Value& childValue = value[name]; | |
| 4636 writeCommentBeforeValue(childValue); | |
| 4637 writeWithIndent(valueToQuotedString(name.c_str())); | |
| 4638 document_ += " : "; | |
| 4639 writeValue(childValue); | |
| 4640 if (++it == members.end()) { | |
| 4641 writeCommentAfterValueOnSameLine(childValue); | |
| 4642 break; | |
| 4643 } | |
| 4644 document_ += ','; | |
| 4645 writeCommentAfterValueOnSameLine(childValue); | |
| 4646 } | |
| 4647 unindent(); | |
| 4648 writeWithIndent("}"); | |
| 4649 } | |
| 4650 } break; | |
| 4651 } | |
| 4652 } | |
| 4653 | |
| 4654 void StyledWriter::writeArrayValue(const Value& value) { | |
| 4655 unsigned size = value.size(); | |
| 4656 if (size == 0) | |
| 4657 pushValue("[]"); | |
| 4658 else { | |
| 4659 bool isArrayMultiLine = isMultilineArray(value); | |
| 4660 if (isArrayMultiLine) { | |
| 4661 writeWithIndent("["); | |
| 4662 indent(); | |
| 4663 bool hasChildValue = !childValues_.empty(); | |
| 4664 unsigned index = 0; | |
| 4665 for (;;) { | |
| 4666 const Value& childValue = value[index]; | |
| 4667 writeCommentBeforeValue(childValue); | |
| 4668 if (hasChildValue) | |
| 4669 writeWithIndent(childValues_[index]); | |
| 4670 else { | |
| 4671 writeIndent(); | |
| 4672 writeValue(childValue); | |
| 4673 } | |
| 4674 if (++index == size) { | |
| 4675 writeCommentAfterValueOnSameLine(childValue); | |
| 4676 break; | |
| 4677 } | |
| 4678 document_ += ','; | |
| 4679 writeCommentAfterValueOnSameLine(childValue); | |
| 4680 } | |
| 4681 unindent(); | |
| 4682 writeWithIndent("]"); | |
| 4683 } else // output on a single line | |
| 4684 { | |
| 4685 assert(childValues_.size() == size); | |
| 4686 document_ += "[ "; | |
| 4687 for (unsigned index = 0; index < size; ++index) { | |
| 4688 if (index > 0) | |
| 4689 document_ += ", "; | |
| 4690 document_ += childValues_[index]; | |
| 4691 } | |
| 4692 document_ += " ]"; | |
| 4693 } | |
| 4694 } | |
| 4695 } | |
| 4696 | |
| 4697 bool StyledWriter::isMultilineArray(const Value& value) { | |
| 4698 ArrayIndex const size = value.size(); | |
| 4699 bool isMultiLine = size * 3 >= rightMargin_; | |
| 4700 childValues_.clear(); | |
| 4701 for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) { | |
| 4702 const Value& childValue = value[index]; | |
| 4703 isMultiLine = ((childValue.isArray() || childValue.isObject()) && | |
| 4704 !childValue.empty()); | |
| 4705 } | |
| 4706 if (!isMultiLine) // check if line length > max line length | |
| 4707 { | |
| 4708 childValues_.reserve(size); | |
| 4709 addChildValues_ = true; | |
| 4710 ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]' | |
| 4711 for (ArrayIndex index = 0; index < size; ++index) { | |
| 4712 if (hasCommentForValue(value[index])) { | |
| 4713 isMultiLine = true; | |
| 4714 } | |
| 4715 writeValue(value[index]); | |
| 4716 lineLength += static_cast<ArrayIndex>(childValues_[index].length()); | |
| 4717 } | |
| 4718 addChildValues_ = false; | |
| 4719 isMultiLine = isMultiLine || lineLength >= rightMargin_; | |
| 4720 } | |
| 4721 return isMultiLine; | |
| 4722 } | |
| 4723 | |
| 4724 void StyledWriter::pushValue(const String& value) { | |
| 4725 if (addChildValues_) | |
| 4726 childValues_.push_back(value); | |
| 4727 else | |
| 4728 document_ += value; | |
| 4729 } | |
| 4730 | |
| 4731 void StyledWriter::writeIndent() { | |
| 4732 if (!document_.empty()) { | |
| 4733 char last = document_[document_.length() - 1]; | |
| 4734 if (last == ' ') // already indented | |
| 4735 return; | |
| 4736 if (last != '\n') // Comments may add new-line | |
| 4737 document_ += '\n'; | |
| 4738 } | |
| 4739 document_ += indentString_; | |
| 4740 } | |
| 4741 | |
| 4742 void StyledWriter::writeWithIndent(const String& value) { | |
| 4743 writeIndent(); | |
| 4744 document_ += value; | |
| 4745 } | |
| 4746 | |
| 4747 void StyledWriter::indent() { indentString_ += String(indentSize_, ' '); } | |
| 4748 | |
| 4749 void StyledWriter::unindent() { | |
| 4750 assert(indentString_.size() >= indentSize_); | |
| 4751 indentString_.resize(indentString_.size() - indentSize_); | |
| 4752 } | |
| 4753 | |
| 4754 void StyledWriter::writeCommentBeforeValue(const Value& root) { | |
| 4755 if (!root.hasComment(commentBefore)) | |
| 4756 return; | |
| 4757 | |
| 4758 document_ += '\n'; | |
| 4759 writeIndent(); | |
| 4760 const String& comment = root.getComment(commentBefore); | |
| 4761 String::const_iterator iter = comment.begin(); | |
| 4762 while (iter != comment.end()) { | |
| 4763 document_ += *iter; | |
| 4764 if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/')) | |
| 4765 writeIndent(); | |
| 4766 ++iter; | |
| 4767 } | |
| 4768 | |
| 4769 // Comments are stripped of trailing newlines, so add one here | |
| 4770 document_ += '\n'; | |
| 4771 } | |
| 4772 | |
| 4773 void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) { | |
| 4774 if (root.hasComment(commentAfterOnSameLine)) | |
| 4775 document_ += " " + root.getComment(commentAfterOnSameLine); | |
| 4776 | |
| 4777 if (root.hasComment(commentAfter)) { | |
| 4778 document_ += '\n'; | |
| 4779 document_ += root.getComment(commentAfter); | |
| 4780 document_ += '\n'; | |
| 4781 } | |
| 4782 } | |
| 4783 | |
| 4784 bool StyledWriter::hasCommentForValue(const Value& value) { | |
| 4785 return value.hasComment(commentBefore) || | |
| 4786 value.hasComment(commentAfterOnSameLine) || | |
| 4787 value.hasComment(commentAfter); | |
| 4788 } | |
| 4789 | |
| 4790 // Class StyledStreamWriter | |
| 4791 // ////////////////////////////////////////////////////////////////// | |
| 4792 | |
| 4793 StyledStreamWriter::StyledStreamWriter(String indentation) | |
| 4794 : document_(nullptr), indentation_(std::move(indentation)), | |
| 4795 addChildValues_(), indented_(false) {} | |
| 4796 | |
| 4797 void StyledStreamWriter::write(OStream& out, const Value& root) { | |
| 4798 document_ = &out; | |
| 4799 addChildValues_ = false; | |
| 4800 indentString_.clear(); | |
| 4801 indented_ = true; | |
| 4802 writeCommentBeforeValue(root); | |
| 4803 if (!indented_) | |
| 4804 writeIndent(); | |
| 4805 indented_ = true; | |
| 4806 writeValue(root); | |
| 4807 writeCommentAfterValueOnSameLine(root); | |
| 4808 *document_ << "\n"; | |
| 4809 document_ = nullptr; // Forget the stream, for safety. | |
| 4810 } | |
| 4811 | |
| 4812 void StyledStreamWriter::writeValue(const Value& value) { | |
| 4813 switch (value.type()) { | |
| 4814 case nullValue: | |
| 4815 pushValue("null"); | |
| 4816 break; | |
| 4817 case intValue: | |
| 4818 pushValue(valueToString(value.asLargestInt())); | |
| 4819 break; | |
| 4820 case uintValue: | |
| 4821 pushValue(valueToString(value.asLargestUInt())); | |
| 4822 break; | |
| 4823 case realValue: | |
| 4824 pushValue(valueToString(value.asDouble())); | |
| 4825 break; | |
| 4826 case stringValue: { | |
| 4827 // Is NULL possible for value.string_? No. | |
| 4828 char const* str; | |
| 4829 char const* end; | |
| 4830 bool ok = value.getString(&str, &end); | |
| 4831 if (ok) | |
| 4832 pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end - str))); | |
| 4833 else | |
| 4834 pushValue(""); | |
| 4835 break; | |
| 4836 } | |
| 4837 case booleanValue: | |
| 4838 pushValue(valueToString(value.asBool())); | |
| 4839 break; | |
| 4840 case arrayValue: | |
| 4841 writeArrayValue(value); | |
| 4842 break; | |
| 4843 case objectValue: { | |
| 4844 Value::Members members(value.getMemberNames()); | |
| 4845 if (members.empty()) | |
| 4846 pushValue("{}"); | |
| 4847 else { | |
| 4848 writeWithIndent("{"); | |
| 4849 indent(); | |
| 4850 auto it = members.begin(); | |
| 4851 for (;;) { | |
| 4852 const String& name = *it; | |
| 4853 const Value& childValue = value[name]; | |
| 4854 writeCommentBeforeValue(childValue); | |
| 4855 writeWithIndent(valueToQuotedString(name.c_str())); | |
| 4856 *document_ << " : "; | |
| 4857 writeValue(childValue); | |
| 4858 if (++it == members.end()) { | |
| 4859 writeCommentAfterValueOnSameLine(childValue); | |
| 4860 break; | |
| 4861 } | |
| 4862 *document_ << ","; | |
| 4863 writeCommentAfterValueOnSameLine(childValue); | |
| 4864 } | |
| 4865 unindent(); | |
| 4866 writeWithIndent("}"); | |
| 4867 } | |
| 4868 } break; | |
| 4869 } | |
| 4870 } | |
| 4871 | |
| 4872 void StyledStreamWriter::writeArrayValue(const Value& value) { | |
| 4873 unsigned size = value.size(); | |
| 4874 if (size == 0) | |
| 4875 pushValue("[]"); | |
| 4876 else { | |
| 4877 bool isArrayMultiLine = isMultilineArray(value); | |
| 4878 if (isArrayMultiLine) { | |
| 4879 writeWithIndent("["); | |
| 4880 indent(); | |
| 4881 bool hasChildValue = !childValues_.empty(); | |
| 4882 unsigned index = 0; | |
| 4883 for (;;) { | |
| 4884 const Value& childValue = value[index]; | |
| 4885 writeCommentBeforeValue(childValue); | |
| 4886 if (hasChildValue) | |
| 4887 writeWithIndent(childValues_[index]); | |
| 4888 else { | |
| 4889 if (!indented_) | |
| 4890 writeIndent(); | |
| 4891 indented_ = true; | |
| 4892 writeValue(childValue); | |
| 4893 indented_ = false; | |
| 4894 } | |
| 4895 if (++index == size) { | |
| 4896 writeCommentAfterValueOnSameLine(childValue); | |
| 4897 break; | |
| 4898 } | |
| 4899 *document_ << ","; | |
| 4900 writeCommentAfterValueOnSameLine(childValue); | |
| 4901 } | |
| 4902 unindent(); | |
| 4903 writeWithIndent("]"); | |
| 4904 } else // output on a single line | |
| 4905 { | |
| 4906 assert(childValues_.size() == size); | |
| 4907 *document_ << "[ "; | |
| 4908 for (unsigned index = 0; index < size; ++index) { | |
| 4909 if (index > 0) | |
| 4910 *document_ << ", "; | |
| 4911 *document_ << childValues_[index]; | |
| 4912 } | |
| 4913 *document_ << " ]"; | |
| 4914 } | |
| 4915 } | |
| 4916 } | |
| 4917 | |
| 4918 bool StyledStreamWriter::isMultilineArray(const Value& value) { | |
| 4919 ArrayIndex const size = value.size(); | |
| 4920 bool isMultiLine = size * 3 >= rightMargin_; | |
| 4921 childValues_.clear(); | |
| 4922 for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) { | |
| 4923 const Value& childValue = value[index]; | |
| 4924 isMultiLine = ((childValue.isArray() || childValue.isObject()) && | |
| 4925 !childValue.empty()); | |
| 4926 } | |
| 4927 if (!isMultiLine) // check if line length > max line length | |
| 4928 { | |
| 4929 childValues_.reserve(size); | |
| 4930 addChildValues_ = true; | |
| 4931 ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]' | |
| 4932 for (ArrayIndex index = 0; index < size; ++index) { | |
| 4933 if (hasCommentForValue(value[index])) { | |
| 4934 isMultiLine = true; | |
| 4935 } | |
| 4936 writeValue(value[index]); | |
| 4937 lineLength += static_cast<ArrayIndex>(childValues_[index].length()); | |
| 4938 } | |
| 4939 addChildValues_ = false; | |
| 4940 isMultiLine = isMultiLine || lineLength >= rightMargin_; | |
| 4941 } | |
| 4942 return isMultiLine; | |
| 4943 } | |
| 4944 | |
| 4945 void StyledStreamWriter::pushValue(const String& value) { | |
| 4946 if (addChildValues_) | |
| 4947 childValues_.push_back(value); | |
| 4948 else | |
| 4949 *document_ << value; | |
| 4950 } | |
| 4951 | |
| 4952 void StyledStreamWriter::writeIndent() { | |
| 4953 // blep intended this to look at the so-far-written string | |
| 4954 // to determine whether we are already indented, but | |
| 4955 // with a stream we cannot do that. So we rely on some saved state. | |
| 4956 // The caller checks indented_. | |
| 4957 *document_ << '\n' << indentString_; | |
| 4958 } | |
| 4959 | |
| 4960 void StyledStreamWriter::writeWithIndent(const String& value) { | |
| 4961 if (!indented_) | |
| 4962 writeIndent(); | |
| 4963 *document_ << value; | |
| 4964 indented_ = false; | |
| 4965 } | |
| 4966 | |
| 4967 void StyledStreamWriter::indent() { indentString_ += indentation_; } | |
| 4968 | |
| 4969 void StyledStreamWriter::unindent() { | |
| 4970 assert(indentString_.size() >= indentation_.size()); | |
| 4971 indentString_.resize(indentString_.size() - indentation_.size()); | |
| 4972 } | |
| 4973 | |
| 4974 void StyledStreamWriter::writeCommentBeforeValue(const Value& root) { | |
| 4975 if (!root.hasComment(commentBefore)) | |
| 4976 return; | |
| 4977 | |
| 4978 if (!indented_) | |
| 4979 writeIndent(); | |
| 4980 const String& comment = root.getComment(commentBefore); | |
| 4981 String::const_iterator iter = comment.begin(); | |
| 4982 while (iter != comment.end()) { | |
| 4983 *document_ << *iter; | |
| 4984 if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/')) | |
| 4985 // writeIndent(); // would include newline | |
| 4986 *document_ << indentString_; | |
| 4987 ++iter; | |
| 4988 } | |
| 4989 indented_ = false; | |
| 4990 } | |
| 4991 | |
| 4992 void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) { | |
| 4993 if (root.hasComment(commentAfterOnSameLine)) | |
| 4994 *document_ << ' ' << root.getComment(commentAfterOnSameLine); | |
| 4995 | |
| 4996 if (root.hasComment(commentAfter)) { | |
| 4997 writeIndent(); | |
| 4998 *document_ << root.getComment(commentAfter); | |
| 4999 } | |
| 5000 indented_ = false; | |
| 5001 } | |
| 5002 | |
| 5003 bool StyledStreamWriter::hasCommentForValue(const Value& value) { | |
| 5004 return value.hasComment(commentBefore) || | |
| 5005 value.hasComment(commentAfterOnSameLine) || | |
| 5006 value.hasComment(commentAfter); | |
| 5007 } | |
| 5008 | |
| 5009 ////////////////////////// | |
| 5010 // BuiltStyledStreamWriter | |
| 5011 | |
| 5012 /// Scoped enums are not available until C++11. | |
| 5013 struct CommentStyle { | |
| 5014 /// Decide whether to write comments. | |
| 5015 enum Enum { | |
| 5016 None, ///< Drop all comments. | |
| 5017 Most, ///< Recover odd behavior of previous versions (not implemented yet). | |
| 5018 All ///< Keep all comments. | |
| 5019 }; | |
| 5020 }; | |
| 5021 | |
| 5022 struct BuiltStyledStreamWriter : public StreamWriter { | |
| 5023 BuiltStyledStreamWriter(String indentation, | |
| 5024 CommentStyle::Enum cs, | |
| 5025 String colonSymbol, | |
| 5026 String nullSymbol, | |
| 5027 String endingLineFeedSymbol, | |
| 5028 bool useSpecialFloats, | |
| 5029 unsigned int precision, | |
| 5030 PrecisionType precisionType); | |
| 5031 int write(Value const& root, OStream* sout) override; | |
| 5032 | |
| 5033 private: | |
| 5034 void writeValue(Value const& value); | |
| 5035 void writeArrayValue(Value const& value); | |
| 5036 bool isMultilineArray(Value const& value); | |
| 5037 void pushValue(String const& value); | |
| 5038 void writeIndent(); | |
| 5039 void writeWithIndent(String const& value); | |
| 5040 void indent(); | |
| 5041 void unindent(); | |
| 5042 void writeCommentBeforeValue(Value const& root); | |
| 5043 void writeCommentAfterValueOnSameLine(Value const& root); | |
| 5044 static bool hasCommentForValue(const Value& value); | |
| 5045 | |
| 5046 typedef std::vector<String> ChildValues; | |
| 5047 | |
| 5048 ChildValues childValues_; | |
| 5049 String indentString_; | |
| 5050 unsigned int rightMargin_; | |
| 5051 String indentation_; | |
| 5052 CommentStyle::Enum cs_; | |
| 5053 String colonSymbol_; | |
| 5054 String nullSymbol_; | |
| 5055 String endingLineFeedSymbol_; | |
| 5056 bool addChildValues_ : 1; | |
| 5057 bool indented_ : 1; | |
| 5058 bool useSpecialFloats_ : 1; | |
| 5059 unsigned int precision_; | |
| 5060 PrecisionType precisionType_; | |
| 5061 }; | |
| 5062 BuiltStyledStreamWriter::BuiltStyledStreamWriter(String indentation, | |
| 5063 CommentStyle::Enum cs, | |
| 5064 String colonSymbol, | |
| 5065 String nullSymbol, | |
| 5066 String endingLineFeedSymbol, | |
| 5067 bool useSpecialFloats, | |
| 5068 unsigned int precision, | |
| 5069 PrecisionType precisionType) | |
| 5070 : rightMargin_(74), indentation_(std::move(indentation)), cs_(cs), | |
| 5071 colonSymbol_(std::move(colonSymbol)), nullSymbol_(std::move(nullSymbol)), | |
| 5072 endingLineFeedSymbol_(std::move(endingLineFeedSymbol)), | |
| 5073 addChildValues_(false), indented_(false), | |
| 5074 useSpecialFloats_(useSpecialFloats), precision_(precision), | |
| 5075 precisionType_(precisionType) {} | |
| 5076 int BuiltStyledStreamWriter::write(Value const& root, OStream* sout) { | |
| 5077 sout_ = sout; | |
| 5078 addChildValues_ = false; | |
| 5079 indented_ = true; | |
| 5080 indentString_.clear(); | |
| 5081 writeCommentBeforeValue(root); | |
| 5082 if (!indented_) | |
| 5083 writeIndent(); | |
| 5084 indented_ = true; | |
| 5085 writeValue(root); | |
| 5086 writeCommentAfterValueOnSameLine(root); | |
| 5087 *sout_ << endingLineFeedSymbol_; | |
| 5088 sout_ = nullptr; | |
| 5089 return 0; | |
| 5090 } | |
| 5091 void BuiltStyledStreamWriter::writeValue(Value const& value) { | |
| 5092 switch (value.type()) { | |
| 5093 case nullValue: | |
| 5094 pushValue(nullSymbol_); | |
| 5095 break; | |
| 5096 case intValue: | |
| 5097 pushValue(valueToString(value.asLargestInt())); | |
| 5098 break; | |
| 5099 case uintValue: | |
| 5100 pushValue(valueToString(value.asLargestUInt())); | |
| 5101 break; | |
| 5102 case realValue: | |
| 5103 pushValue(valueToString(value.asDouble(), useSpecialFloats_, precision_, | |
| 5104 precisionType_)); | |
| 5105 break; | |
| 5106 case stringValue: { | |
| 5107 // Is NULL is possible for value.string_? No. | |
| 5108 char const* str; | |
| 5109 char const* end; | |
| 5110 bool ok = value.getString(&str, &end); | |
| 5111 if (ok) | |
| 5112 pushValue(valueToQuotedStringN(str, static_cast<unsigned>(end - str))); | |
| 5113 else | |
| 5114 pushValue(""); | |
| 5115 break; | |
| 5116 } | |
| 5117 case booleanValue: | |
| 5118 pushValue(valueToString(value.asBool())); | |
| 5119 break; | |
| 5120 case arrayValue: | |
| 5121 writeArrayValue(value); | |
| 5122 break; | |
| 5123 case objectValue: { | |
| 5124 Value::Members members(value.getMemberNames()); | |
| 5125 if (members.empty()) | |
| 5126 pushValue("{}"); | |
| 5127 else { | |
| 5128 writeWithIndent("{"); | |
| 5129 indent(); | |
| 5130 auto it = members.begin(); | |
| 5131 for (;;) { | |
| 5132 String const& name = *it; | |
| 5133 Value const& childValue = value[name]; | |
| 5134 writeCommentBeforeValue(childValue); | |
| 5135 writeWithIndent(valueToQuotedStringN( | |
| 5136 name.data(), static_cast<unsigned>(name.length()))); | |
| 5137 *sout_ << colonSymbol_; | |
| 5138 writeValue(childValue); | |
| 5139 if (++it == members.end()) { | |
| 5140 writeCommentAfterValueOnSameLine(childValue); | |
| 5141 break; | |
| 5142 } | |
| 5143 *sout_ << ","; | |
| 5144 writeCommentAfterValueOnSameLine(childValue); | |
| 5145 } | |
| 5146 unindent(); | |
| 5147 writeWithIndent("}"); | |
| 5148 } | |
| 5149 } break; | |
| 5150 } | |
| 5151 } | |
| 5152 | |
| 5153 void BuiltStyledStreamWriter::writeArrayValue(Value const& value) { | |
| 5154 unsigned size = value.size(); | |
| 5155 if (size == 0) | |
| 5156 pushValue("[]"); | |
| 5157 else { | |
| 5158 bool isMultiLine = (cs_ == CommentStyle::All) || isMultilineArray(value); | |
| 5159 if (isMultiLine) { | |
| 5160 writeWithIndent("["); | |
| 5161 indent(); | |
| 5162 bool hasChildValue = !childValues_.empty(); | |
| 5163 unsigned index = 0; | |
| 5164 for (;;) { | |
| 5165 Value const& childValue = value[index]; | |
| 5166 writeCommentBeforeValue(childValue); | |
| 5167 if (hasChildValue) | |
| 5168 writeWithIndent(childValues_[index]); | |
| 5169 else { | |
| 5170 if (!indented_) | |
| 5171 writeIndent(); | |
| 5172 indented_ = true; | |
| 5173 writeValue(childValue); | |
| 5174 indented_ = false; | |
| 5175 } | |
| 5176 if (++index == size) { | |
| 5177 writeCommentAfterValueOnSameLine(childValue); | |
| 5178 break; | |
| 5179 } | |
| 5180 *sout_ << ","; | |
| 5181 writeCommentAfterValueOnSameLine(childValue); | |
| 5182 } | |
| 5183 unindent(); | |
| 5184 writeWithIndent("]"); | |
| 5185 } else // output on a single line | |
| 5186 { | |
| 5187 assert(childValues_.size() == size); | |
| 5188 *sout_ << "["; | |
| 5189 if (!indentation_.empty()) | |
| 5190 *sout_ << " "; | |
| 5191 for (unsigned index = 0; index < size; ++index) { | |
| 5192 if (index > 0) | |
| 5193 *sout_ << ((!indentation_.empty()) ? ", " : ","); | |
| 5194 *sout_ << childValues_[index]; | |
| 5195 } | |
| 5196 if (!indentation_.empty()) | |
| 5197 *sout_ << " "; | |
| 5198 *sout_ << "]"; | |
| 5199 } | |
| 5200 } | |
| 5201 } | |
| 5202 | |
| 5203 bool BuiltStyledStreamWriter::isMultilineArray(Value const& value) { | |
| 5204 ArrayIndex const size = value.size(); | |
| 5205 bool isMultiLine = size * 3 >= rightMargin_; | |
| 5206 childValues_.clear(); | |
| 5207 for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) { | |
| 5208 Value const& childValue = value[index]; | |
| 5209 isMultiLine = ((childValue.isArray() || childValue.isObject()) && | |
| 5210 !childValue.empty()); | |
| 5211 } | |
| 5212 if (!isMultiLine) // check if line length > max line length | |
| 5213 { | |
| 5214 childValues_.reserve(size); | |
| 5215 addChildValues_ = true; | |
| 5216 ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]' | |
| 5217 for (ArrayIndex index = 0; index < size; ++index) { | |
| 5218 if (hasCommentForValue(value[index])) { | |
| 5219 isMultiLine = true; | |
| 5220 } | |
| 5221 writeValue(value[index]); | |
| 5222 lineLength += static_cast<ArrayIndex>(childValues_[index].length()); | |
| 5223 } | |
| 5224 addChildValues_ = false; | |
| 5225 isMultiLine = isMultiLine || lineLength >= rightMargin_; | |
| 5226 } | |
| 5227 return isMultiLine; | |
| 5228 } | |
| 5229 | |
| 5230 void BuiltStyledStreamWriter::pushValue(String const& value) { | |
| 5231 if (addChildValues_) | |
| 5232 childValues_.push_back(value); | |
| 5233 else | |
| 5234 *sout_ << value; | |
| 5235 } | |
| 5236 | |
| 5237 void BuiltStyledStreamWriter::writeIndent() { | |
| 5238 // blep intended this to look at the so-far-written string | |
| 5239 // to determine whether we are already indented, but | |
| 5240 // with a stream we cannot do that. So we rely on some saved state. | |
| 5241 // The caller checks indented_. | |
| 5242 | |
| 5243 if (!indentation_.empty()) { | |
| 5244 // In this case, drop newlines too. | |
| 5245 *sout_ << '\n' << indentString_; | |
| 5246 } | |
| 5247 } | |
| 5248 | |
| 5249 void BuiltStyledStreamWriter::writeWithIndent(String const& value) { | |
| 5250 if (!indented_) | |
| 5251 writeIndent(); | |
| 5252 *sout_ << value; | |
| 5253 indented_ = false; | |
| 5254 } | |
| 5255 | |
| 5256 void BuiltStyledStreamWriter::indent() { indentString_ += indentation_; } | |
| 5257 | |
| 5258 void BuiltStyledStreamWriter::unindent() { | |
| 5259 assert(indentString_.size() >= indentation_.size()); | |
| 5260 indentString_.resize(indentString_.size() - indentation_.size()); | |
| 5261 } | |
| 5262 | |
| 5263 void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) { | |
| 5264 if (cs_ == CommentStyle::None) | |
| 5265 return; | |
| 5266 if (!root.hasComment(commentBefore)) | |
| 5267 return; | |
| 5268 | |
| 5269 if (!indented_) | |
| 5270 writeIndent(); | |
| 5271 const String& comment = root.getComment(commentBefore); | |
| 5272 String::const_iterator iter = comment.begin(); | |
| 5273 while (iter != comment.end()) { | |
| 5274 *sout_ << *iter; | |
| 5275 if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/')) | |
| 5276 // writeIndent(); // would write extra newline | |
| 5277 *sout_ << indentString_; | |
| 5278 ++iter; | |
| 5279 } | |
| 5280 indented_ = false; | |
| 5281 } | |
| 5282 | |
| 5283 void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine( | |
| 5284 Value const& root) { | |
| 5285 if (cs_ == CommentStyle::None) | |
| 5286 return; | |
| 5287 if (root.hasComment(commentAfterOnSameLine)) | |
| 5288 *sout_ << " " + root.getComment(commentAfterOnSameLine); | |
| 5289 | |
| 5290 if (root.hasComment(commentAfter)) { | |
| 5291 writeIndent(); | |
| 5292 *sout_ << root.getComment(commentAfter); | |
| 5293 } | |
| 5294 } | |
| 5295 | |
| 5296 // static | |
| 5297 bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value) { | |
| 5298 return value.hasComment(commentBefore) || | |
| 5299 value.hasComment(commentAfterOnSameLine) || | |
| 5300 value.hasComment(commentAfter); | |
| 5301 } | |
| 5302 | |
| 5303 /////////////// | |
| 5304 // StreamWriter | |
| 5305 | |
| 5306 StreamWriter::StreamWriter() : sout_(nullptr) {} | |
| 5307 StreamWriter::~StreamWriter() = default; | |
| 5308 StreamWriter::Factory::~Factory() = default; | |
| 5309 StreamWriterBuilder::StreamWriterBuilder() { setDefaults(&settings_); } | |
| 5310 StreamWriterBuilder::~StreamWriterBuilder() = default; | |
| 5311 StreamWriter* StreamWriterBuilder::newStreamWriter() const { | |
| 5312 String indentation = settings_["indentation"].asString(); | |
| 5313 String cs_str = settings_["commentStyle"].asString(); | |
| 5314 String pt_str = settings_["precisionType"].asString(); | |
| 5315 bool eyc = settings_["enableYAMLCompatibility"].asBool(); | |
| 5316 bool dnp = settings_["dropNullPlaceholders"].asBool(); | |
| 5317 bool usf = settings_["useSpecialFloats"].asBool(); | |
| 5318 unsigned int pre = settings_["precision"].asUInt(); | |
| 5319 CommentStyle::Enum cs = CommentStyle::All; | |
| 5320 if (cs_str == "All") { | |
| 5321 cs = CommentStyle::All; | |
| 5322 } else if (cs_str == "None") { | |
| 5323 cs = CommentStyle::None; | |
| 5324 } else { | |
| 5325 throwRuntimeError("commentStyle must be 'All' or 'None'"); | |
| 5326 } | |
| 5327 PrecisionType precisionType(significantDigits); | |
| 5328 if (pt_str == "significant") { | |
| 5329 precisionType = PrecisionType::significantDigits; | |
| 5330 } else if (pt_str == "decimal") { | |
| 5331 precisionType = PrecisionType::decimalPlaces; | |
| 5332 } else { | |
| 5333 throwRuntimeError("precisionType must be 'significant' or 'decimal'"); | |
| 5334 } | |
| 5335 String colonSymbol = " : "; | |
| 5336 if (eyc) { | |
| 5337 colonSymbol = ": "; | |
| 5338 } else if (indentation.empty()) { | |
| 5339 colonSymbol = ":"; | |
| 5340 } | |
| 5341 String nullSymbol = "null"; | |
| 5342 if (dnp) { | |
| 5343 nullSymbol.clear(); | |
| 5344 } | |
| 5345 if (pre > 17) | |
| 5346 pre = 17; | |
| 5347 String endingLineFeedSymbol; | |
| 5348 return new BuiltStyledStreamWriter(indentation, cs, colonSymbol, nullSymbol, | |
| 5349 endingLineFeedSymbol, usf, pre, | |
| 5350 precisionType); | |
| 5351 } | |
| 5352 static void getValidWriterKeys(std::set<String>* valid_keys) { | |
| 5353 valid_keys->clear(); | |
| 5354 valid_keys->insert("indentation"); | |
| 5355 valid_keys->insert("commentStyle"); | |
| 5356 valid_keys->insert("enableYAMLCompatibility"); | |
| 5357 valid_keys->insert("dropNullPlaceholders"); | |
| 5358 valid_keys->insert("useSpecialFloats"); | |
| 5359 valid_keys->insert("precision"); | |
| 5360 valid_keys->insert("precisionType"); | |
| 5361 } | |
| 5362 bool StreamWriterBuilder::validate(Json::Value* invalid) const { | |
| 5363 Json::Value my_invalid; | |
| 5364 if (!invalid) | |
| 5365 invalid = &my_invalid; // so we do not need to test for NULL | |
| 5366 Json::Value& inv = *invalid; | |
| 5367 std::set<String> valid_keys; | |
| 5368 getValidWriterKeys(&valid_keys); | |
| 5369 Value::Members keys = settings_.getMemberNames(); | |
| 5370 size_t n = keys.size(); | |
| 5371 for (size_t i = 0; i < n; ++i) { | |
| 5372 String const& key = keys[i]; | |
| 5373 if (valid_keys.find(key) == valid_keys.end()) { | |
| 5374 inv[key] = settings_[key]; | |
| 5375 } | |
| 5376 } | |
| 5377 return inv.empty(); | |
| 5378 } | |
| 5379 Value& StreamWriterBuilder::operator[](const String& key) { | |
| 5380 return settings_[key]; | |
| 5381 } | |
| 5382 // static | |
| 5383 void StreamWriterBuilder::setDefaults(Json::Value* settings) { | |
| 5384 //! [StreamWriterBuilderDefaults] | |
| 5385 (*settings)["commentStyle"] = "All"; | |
| 5386 (*settings)["indentation"] = "\t"; | |
| 5387 (*settings)["enableYAMLCompatibility"] = false; | |
| 5388 (*settings)["dropNullPlaceholders"] = false; | |
| 5389 (*settings)["useSpecialFloats"] = false; | |
| 5390 (*settings)["precision"] = 17; | |
| 5391 (*settings)["precisionType"] = "significant"; | |
| 5392 //! [StreamWriterBuilderDefaults] | |
| 5393 } | |
| 5394 | |
| 5395 String writeString(StreamWriter::Factory const& factory, Value const& root) { | |
| 5396 OStringStream sout; | |
| 5397 StreamWriterPtr const writer(factory.newStreamWriter()); | |
| 5398 writer->write(root, &sout); | |
| 5399 return sout.str(); | |
| 5400 } | |
| 5401 | |
| 5402 OStream& operator<<(OStream& sout, Value const& root) { | |
| 5403 StreamWriterBuilder builder; | |
| 5404 StreamWriterPtr const writer(builder.newStreamWriter()); | |
| 5405 writer->write(root, &sout); | |
| 5406 return sout; | |
| 5407 } | |
| 5408 | |
| 5409 } // namespace Json | |
| 5410 | |
| 5411 // ////////////////////////////////////////////////////////////////////// | |
| 5412 // End of content of file: src/lib_json/json_writer.cpp | |
| 5413 // ////////////////////////////////////////////////////////////////////// | |
| 5414 | |
| 5415 | |
| 5416 | |
| 5417 | |
| 5418 |