|
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
|
|
|
290 typedef std::auto_ptr<CharReader> CharReaderPtr;
|
|
|
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
|
|
|
4245 typedef std::auto_ptr<StreamWriter> StreamWriterPtr;
|
|
|
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
|
