1//=== JSON.cpp - JSON value, parsing and serialization - C++ -----------*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===---------------------------------------------------------------------===//
8
9#include "llvm/Support/JSON.h"
10#include "llvm/ADT/STLExtras.h"
11#include "llvm/ADT/StringExtras.h"
12#include "llvm/Support/ConvertUTF.h"
13#include "llvm/Support/Error.h"
14#include "llvm/Support/Format.h"
15#include "llvm/Support/NativeFormatting.h"
16#include "llvm/Support/raw_ostream.h"
17#include <cctype>
18#include <cerrno>
19#include <optional>
20
21namespace llvm {
22namespace json {
23
24Value &Object::operator[](const ObjectKey &K) {
25 return try_emplace(K, Args: nullptr).first->getSecond();
26}
27Value &Object::operator[](ObjectKey &&K) {
28 return try_emplace(K: std::move(K), Args: nullptr).first->getSecond();
29}
30Value *Object::get(StringRef K) {
31 auto I = find(K);
32 if (I == end())
33 return nullptr;
34 return &I->second;
35}
36const Value *Object::get(StringRef K) const {
37 auto I = find(K);
38 if (I == end())
39 return nullptr;
40 return &I->second;
41}
42std::optional<std::nullptr_t> Object::getNull(StringRef K) const {
43 if (auto *V = get(K))
44 return V->getAsNull();
45 return std::nullopt;
46}
47std::optional<bool> Object::getBoolean(StringRef K) const {
48 if (auto *V = get(K))
49 return V->getAsBoolean();
50 return std::nullopt;
51}
52std::optional<double> Object::getNumber(StringRef K) const {
53 if (auto *V = get(K))
54 return V->getAsNumber();
55 return std::nullopt;
56}
57std::optional<int64_t> Object::getInteger(StringRef K) const {
58 if (auto *V = get(K))
59 return V->getAsInteger();
60 return std::nullopt;
61}
62std::optional<llvm::StringRef> Object::getString(StringRef K) const {
63 if (auto *V = get(K))
64 return V->getAsString();
65 return std::nullopt;
66}
67const json::Object *Object::getObject(StringRef K) const {
68 if (auto *V = get(K))
69 return V->getAsObject();
70 return nullptr;
71}
72json::Object *Object::getObject(StringRef K) {
73 if (auto *V = get(K))
74 return V->getAsObject();
75 return nullptr;
76}
77const json::Array *Object::getArray(StringRef K) const {
78 if (auto *V = get(K))
79 return V->getAsArray();
80 return nullptr;
81}
82json::Array *Object::getArray(StringRef K) {
83 if (auto *V = get(K))
84 return V->getAsArray();
85 return nullptr;
86}
87bool operator==(const Object &LHS, const Object &RHS) {
88 if (LHS.size() != RHS.size())
89 return false;
90 for (const auto &L : LHS) {
91 auto R = RHS.find(K: L.first);
92 if (R == RHS.end() || L.second != R->second)
93 return false;
94 }
95 return true;
96}
97
98Array::Array(std::initializer_list<Value> Elements) {
99 V.reserve(n: Elements.size());
100 for (const Value &V : Elements) {
101 emplace_back(A: nullptr);
102 back().moveFrom(M: std::move(V));
103 }
104}
105
106Value::Value(std::initializer_list<Value> Elements)
107 : Value(json::Array(Elements)) {}
108
109void Value::copyFrom(const Value &M) {
110 Type = M.Type;
111 switch (Type) {
112 case T_Null:
113 case T_Boolean:
114 case T_Double:
115 case T_Integer:
116 case T_UINT64:
117 memcpy(dest: &Union, src: &M.Union, n: sizeof(Union));
118 break;
119 case T_StringRef:
120 create<StringRef>(V&: M.as<StringRef>());
121 break;
122 case T_String:
123 create<std::string>(V&: M.as<std::string>());
124 break;
125 case T_Object:
126 create<json::Object>(V&: M.as<json::Object>());
127 break;
128 case T_Array:
129 create<json::Array>(V&: M.as<json::Array>());
130 break;
131 }
132}
133
134void Value::moveFrom(const Value &&M) {
135 Type = M.Type;
136 switch (Type) {
137 case T_Null:
138 case T_Boolean:
139 case T_Double:
140 case T_Integer:
141 case T_UINT64:
142 memcpy(dest: &Union, src: &M.Union, n: sizeof(Union));
143 break;
144 case T_StringRef:
145 create<StringRef>(V&: M.as<StringRef>());
146 break;
147 case T_String:
148 create<std::string>(V: std::move(M.as<std::string>()));
149 M.Type = T_Null;
150 break;
151 case T_Object:
152 create<json::Object>(V: std::move(M.as<json::Object>()));
153 M.Type = T_Null;
154 break;
155 case T_Array:
156 create<json::Array>(V: std::move(M.as<json::Array>()));
157 M.Type = T_Null;
158 break;
159 }
160}
161
162void Value::destroy() {
163 switch (Type) {
164 case T_Null:
165 case T_Boolean:
166 case T_Double:
167 case T_Integer:
168 case T_UINT64:
169 break;
170 case T_StringRef:
171 as<StringRef>().~StringRef();
172 break;
173 case T_String:
174 as<std::string>().~basic_string();
175 break;
176 case T_Object:
177 as<json::Object>().~Object();
178 break;
179 case T_Array:
180 as<json::Array>().~Array();
181 break;
182 }
183}
184
185bool operator==(const Value &L, const Value &R) {
186 if (L.kind() != R.kind())
187 return false;
188 switch (L.kind()) {
189 case Value::Null:
190 return *L.getAsNull() == *R.getAsNull();
191 case Value::Boolean:
192 return *L.getAsBoolean() == *R.getAsBoolean();
193 case Value::Number:
194 // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=323
195 // The same integer must convert to the same double, per the standard.
196 // However we see 64-vs-80-bit precision comparisons with gcc-7 -O3 -m32.
197 // So we avoid floating point promotion for exact comparisons.
198 if (L.Type == Value::T_Integer || R.Type == Value::T_Integer)
199 return L.getAsInteger() == R.getAsInteger();
200 return *L.getAsNumber() == *R.getAsNumber();
201 case Value::String:
202 return *L.getAsString() == *R.getAsString();
203 case Value::Array:
204 return *L.getAsArray() == *R.getAsArray();
205 case Value::Object:
206 return *L.getAsObject() == *R.getAsObject();
207 }
208 llvm_unreachable("Unknown value kind");
209}
210
211void Path::report(llvm::StringLiteral Msg) {
212 // Walk up to the root context, and count the number of segments.
213 unsigned Count = 0;
214 const Path *P;
215 for (P = this; P->Parent != nullptr; P = P->Parent)
216 ++Count;
217 Path::Root *R = P->Seg.root();
218 // Fill in the error message and copy the path (in reverse order).
219 R->ErrorMessage = Msg;
220 R->ErrorPath.resize(new_size: Count);
221 auto It = R->ErrorPath.begin();
222 for (P = this; P->Parent != nullptr; P = P->Parent)
223 *It++ = P->Seg;
224}
225
226Error Path::Root::getError() const {
227 std::string S;
228 raw_string_ostream OS(S);
229 OS << (ErrorMessage.empty() ? "invalid JSON contents" : ErrorMessage);
230 if (ErrorPath.empty()) {
231 if (!Name.empty())
232 OS << " when parsing " << Name;
233 } else {
234 OS << " at " << (Name.empty() ? "(root)" : Name);
235 for (const Path::Segment &S : llvm::reverse(C: ErrorPath)) {
236 if (S.isField())
237 OS << '.' << S.field();
238 else
239 OS << '[' << S.index() << ']';
240 }
241 }
242 return createStringError(EC: llvm::inconvertibleErrorCode(), S: OS.str());
243}
244
245namespace {
246
247std::vector<const Object::value_type *> sortedElements(const Object &O) {
248 std::vector<const Object::value_type *> Elements;
249 for (const auto &E : O)
250 Elements.push_back(x: &E);
251 llvm::sort(C&: Elements,
252 Comp: [](const Object::value_type *L, const Object::value_type *R) {
253 return L->first < R->first;
254 });
255 return Elements;
256}
257
258// Prints a one-line version of a value that isn't our main focus.
259// We interleave writes to OS and JOS, exploiting the lack of extra buffering.
260// This is OK as we own the implementation.
261void abbreviate(const Value &V, OStream &JOS) {
262 switch (V.kind()) {
263 case Value::Array:
264 JOS.rawValue(Contents: V.getAsArray()->empty() ? "[]" : "[ ... ]");
265 break;
266 case Value::Object:
267 JOS.rawValue(Contents: V.getAsObject()->empty() ? "{}" : "{ ... }");
268 break;
269 case Value::String: {
270 llvm::StringRef S = *V.getAsString();
271 if (S.size() < 40) {
272 JOS.value(V);
273 } else {
274 std::string Truncated = fixUTF8(S: S.take_front(N: 37));
275 Truncated.append(s: "...");
276 JOS.value(V: Truncated);
277 }
278 break;
279 }
280 default:
281 JOS.value(V);
282 }
283}
284
285// Prints a semi-expanded version of a value that is our main focus.
286// Array/Object entries are printed, but not recursively as they may be huge.
287void abbreviateChildren(const Value &V, OStream &JOS) {
288 switch (V.kind()) {
289 case Value::Array:
290 JOS.array(Contents: [&] {
291 for (const auto &I : *V.getAsArray())
292 abbreviate(V: I, JOS);
293 });
294 break;
295 case Value::Object:
296 JOS.object(Contents: [&] {
297 for (const auto *KV : sortedElements(O: *V.getAsObject())) {
298 JOS.attributeBegin(Key: KV->first);
299 abbreviate(V: KV->second, JOS);
300 JOS.attributeEnd();
301 }
302 });
303 break;
304 default:
305 JOS.value(V);
306 }
307}
308
309} // namespace
310
311void Path::Root::printErrorContext(const Value &R, raw_ostream &OS) const {
312 OStream JOS(OS, /*IndentSize=*/2);
313 // PrintValue recurses down the path, printing the ancestors of our target.
314 // Siblings of nodes along the path are printed with abbreviate(), and the
315 // target itself is printed with the somewhat richer abbreviateChildren().
316 // 'Recurse' is the lambda itself, to allow recursive calls.
317 auto PrintValue = [&](const Value &V, ArrayRef<Segment> Path, auto &Recurse) {
318 // Print the target node itself, with the error as a comment.
319 // Also used if we can't follow our path, e.g. it names a field that
320 // *should* exist but doesn't.
321 auto HighlightCurrent = [&] {
322 std::string Comment = "error: ";
323 Comment.append(s: ErrorMessage.data(), n: ErrorMessage.size());
324 JOS.comment(Comment);
325 abbreviateChildren(V, JOS);
326 };
327 if (Path.empty()) // We reached our target.
328 return HighlightCurrent();
329 const Segment &S = Path.back(); // Path is in reverse order.
330 if (S.isField()) {
331 // Current node is an object, path names a field.
332 llvm::StringRef FieldName = S.field();
333 const Object *O = V.getAsObject();
334 if (!O || !O->get(K: FieldName))
335 return HighlightCurrent();
336 JOS.object(Contents: [&] {
337 for (const auto *KV : sortedElements(O: *O)) {
338 JOS.attributeBegin(Key: KV->first);
339 if (FieldName.equals(RHS: KV->first))
340 Recurse(KV->second, Path.drop_back(), Recurse);
341 else
342 abbreviate(V: KV->second, JOS);
343 JOS.attributeEnd();
344 }
345 });
346 } else {
347 // Current node is an array, path names an element.
348 const Array *A = V.getAsArray();
349 if (!A || S.index() >= A->size())
350 return HighlightCurrent();
351 JOS.array(Contents: [&] {
352 unsigned Current = 0;
353 for (const auto &V : *A) {
354 if (Current++ == S.index())
355 Recurse(V, Path.drop_back(), Recurse);
356 else
357 abbreviate(V, JOS);
358 }
359 });
360 }
361 };
362 PrintValue(R, ErrorPath, PrintValue);
363}
364
365namespace {
366// Simple recursive-descent JSON parser.
367class Parser {
368public:
369 Parser(StringRef JSON)
370 : Start(JSON.begin()), P(JSON.begin()), End(JSON.end()) {}
371
372 bool checkUTF8() {
373 size_t ErrOffset;
374 if (isUTF8(S: StringRef(Start, End - Start), ErrOffset: &ErrOffset))
375 return true;
376 P = Start + ErrOffset; // For line/column calculation.
377 return parseError(Msg: "Invalid UTF-8 sequence");
378 }
379
380 bool parseValue(Value &Out);
381
382 bool assertEnd() {
383 eatWhitespace();
384 if (P == End)
385 return true;
386 return parseError(Msg: "Text after end of document");
387 }
388
389 Error takeError() {
390 assert(Err);
391 return std::move(*Err);
392 }
393
394private:
395 void eatWhitespace() {
396 while (P != End && (*P == ' ' || *P == '\r' || *P == '\n' || *P == '\t'))
397 ++P;
398 }
399
400 // On invalid syntax, parseX() functions return false and set Err.
401 bool parseNumber(char First, Value &Out);
402 bool parseString(std::string &Out);
403 bool parseUnicode(std::string &Out);
404 bool parseError(const char *Msg); // always returns false
405
406 char next() { return P == End ? 0 : *P++; }
407 char peek() { return P == End ? 0 : *P; }
408 static bool isNumber(char C) {
409 return C == '0' || C == '1' || C == '2' || C == '3' || C == '4' ||
410 C == '5' || C == '6' || C == '7' || C == '8' || C == '9' ||
411 C == 'e' || C == 'E' || C == '+' || C == '-' || C == '.';
412 }
413
414 std::optional<Error> Err;
415 const char *Start, *P, *End;
416};
417
418bool Parser::parseValue(Value &Out) {
419 eatWhitespace();
420 if (P == End)
421 return parseError(Msg: "Unexpected EOF");
422 switch (char C = next()) {
423 // Bare null/true/false are easy - first char identifies them.
424 case 'n':
425 Out = nullptr;
426 return (next() == 'u' && next() == 'l' && next() == 'l') ||
427 parseError(Msg: "Invalid JSON value (null?)");
428 case 't':
429 Out = true;
430 return (next() == 'r' && next() == 'u' && next() == 'e') ||
431 parseError(Msg: "Invalid JSON value (true?)");
432 case 'f':
433 Out = false;
434 return (next() == 'a' && next() == 'l' && next() == 's' && next() == 'e') ||
435 parseError(Msg: "Invalid JSON value (false?)");
436 case '"': {
437 std::string S;
438 if (parseString(Out&: S)) {
439 Out = std::move(S);
440 return true;
441 }
442 return false;
443 }
444 case '[': {
445 Out = Array{};
446 Array &A = *Out.getAsArray();
447 eatWhitespace();
448 if (peek() == ']') {
449 ++P;
450 return true;
451 }
452 for (;;) {
453 A.emplace_back(A: nullptr);
454 if (!parseValue(Out&: A.back()))
455 return false;
456 eatWhitespace();
457 switch (next()) {
458 case ',':
459 eatWhitespace();
460 continue;
461 case ']':
462 return true;
463 default:
464 return parseError(Msg: "Expected , or ] after array element");
465 }
466 }
467 }
468 case '{': {
469 Out = Object{};
470 Object &O = *Out.getAsObject();
471 eatWhitespace();
472 if (peek() == '}') {
473 ++P;
474 return true;
475 }
476 for (;;) {
477 if (next() != '"')
478 return parseError(Msg: "Expected object key");
479 std::string K;
480 if (!parseString(Out&: K))
481 return false;
482 eatWhitespace();
483 if (next() != ':')
484 return parseError(Msg: "Expected : after object key");
485 eatWhitespace();
486 if (!parseValue(Out&: O[std::move(K)]))
487 return false;
488 eatWhitespace();
489 switch (next()) {
490 case ',':
491 eatWhitespace();
492 continue;
493 case '}':
494 return true;
495 default:
496 return parseError(Msg: "Expected , or } after object property");
497 }
498 }
499 }
500 default:
501 if (isNumber(C))
502 return parseNumber(First: C, Out);
503 return parseError(Msg: "Invalid JSON value");
504 }
505}
506
507bool Parser::parseNumber(char First, Value &Out) {
508 // Read the number into a string. (Must be null-terminated for strto*).
509 SmallString<24> S;
510 S.push_back(Elt: First);
511 while (isNumber(C: peek()))
512 S.push_back(Elt: next());
513 char *End;
514 // Try first to parse as integer, and if so preserve full 64 bits.
515 // We check for errno for out of bounds errors and for End == S.end()
516 // to make sure that the numeric string is not malformed.
517 errno = 0;
518 int64_t I = std::strtoll(nptr: S.c_str(), endptr: &End, base: 10);
519 if (End == S.end() && errno != ERANGE) {
520 Out = int64_t(I);
521 return true;
522 }
523 // strtroull has a special handling for negative numbers, but in this
524 // case we don't want to do that because negative numbers were already
525 // handled in the previous block.
526 if (First != '-') {
527 errno = 0;
528 uint64_t UI = std::strtoull(nptr: S.c_str(), endptr: &End, base: 10);
529 if (End == S.end() && errno != ERANGE) {
530 Out = UI;
531 return true;
532 }
533 }
534 // If it's not an integer
535 Out = std::strtod(nptr: S.c_str(), endptr: &End);
536 return End == S.end() || parseError(Msg: "Invalid JSON value (number?)");
537}
538
539bool Parser::parseString(std::string &Out) {
540 // leading quote was already consumed.
541 for (char C = next(); C != '"'; C = next()) {
542 if (LLVM_UNLIKELY(P == End))
543 return parseError(Msg: "Unterminated string");
544 if (LLVM_UNLIKELY((C & 0x1f) == C))
545 return parseError(Msg: "Control character in string");
546 if (LLVM_LIKELY(C != '\\')) {
547 Out.push_back(c: C);
548 continue;
549 }
550 // Handle escape sequence.
551 switch (C = next()) {
552 case '"':
553 case '\\':
554 case '/':
555 Out.push_back(c: C);
556 break;
557 case 'b':
558 Out.push_back(c: '\b');
559 break;
560 case 'f':
561 Out.push_back(c: '\f');
562 break;
563 case 'n':
564 Out.push_back(c: '\n');
565 break;
566 case 'r':
567 Out.push_back(c: '\r');
568 break;
569 case 't':
570 Out.push_back(c: '\t');
571 break;
572 case 'u':
573 if (!parseUnicode(Out))
574 return false;
575 break;
576 default:
577 return parseError(Msg: "Invalid escape sequence");
578 }
579 }
580 return true;
581}
582
583static void encodeUtf8(uint32_t Rune, std::string &Out) {
584 if (Rune < 0x80) {
585 Out.push_back(c: Rune & 0x7F);
586 } else if (Rune < 0x800) {
587 uint8_t FirstByte = 0xC0 | ((Rune & 0x7C0) >> 6);
588 uint8_t SecondByte = 0x80 | (Rune & 0x3F);
589 Out.push_back(c: FirstByte);
590 Out.push_back(c: SecondByte);
591 } else if (Rune < 0x10000) {
592 uint8_t FirstByte = 0xE0 | ((Rune & 0xF000) >> 12);
593 uint8_t SecondByte = 0x80 | ((Rune & 0xFC0) >> 6);
594 uint8_t ThirdByte = 0x80 | (Rune & 0x3F);
595 Out.push_back(c: FirstByte);
596 Out.push_back(c: SecondByte);
597 Out.push_back(c: ThirdByte);
598 } else if (Rune < 0x110000) {
599 uint8_t FirstByte = 0xF0 | ((Rune & 0x1F0000) >> 18);
600 uint8_t SecondByte = 0x80 | ((Rune & 0x3F000) >> 12);
601 uint8_t ThirdByte = 0x80 | ((Rune & 0xFC0) >> 6);
602 uint8_t FourthByte = 0x80 | (Rune & 0x3F);
603 Out.push_back(c: FirstByte);
604 Out.push_back(c: SecondByte);
605 Out.push_back(c: ThirdByte);
606 Out.push_back(c: FourthByte);
607 } else {
608 llvm_unreachable("Invalid codepoint");
609 }
610}
611
612// Parse a UTF-16 \uNNNN escape sequence. "\u" has already been consumed.
613// May parse several sequential escapes to ensure proper surrogate handling.
614// We do not use ConvertUTF.h, it can't accept and replace unpaired surrogates.
615// These are invalid Unicode but valid JSON (RFC 8259, section 8.2).
616bool Parser::parseUnicode(std::string &Out) {
617 // Invalid UTF is not a JSON error (RFC 8529§8.2). It gets replaced by U+FFFD.
618 auto Invalid = [&] { Out.append(/* UTF-8 */ l: {'\xef', '\xbf', '\xbd'}); };
619 // Decodes 4 hex digits from the stream into Out, returns false on error.
620 auto Parse4Hex = [this](uint16_t &Out) -> bool {
621 Out = 0;
622 char Bytes[] = {next(), next(), next(), next()};
623 for (unsigned char C : Bytes) {
624 if (!std::isxdigit(C))
625 return parseError(Msg: "Invalid \\u escape sequence");
626 Out <<= 4;
627 Out |= (C > '9') ? (C & ~0x20) - 'A' + 10 : (C - '0');
628 }
629 return true;
630 };
631 uint16_t First; // UTF-16 code unit from the first \u escape.
632 if (!Parse4Hex(First))
633 return false;
634
635 // We loop to allow proper surrogate-pair error handling.
636 while (true) {
637 // Case 1: the UTF-16 code unit is already a codepoint in the BMP.
638 if (LLVM_LIKELY(First < 0xD800 || First >= 0xE000)) {
639 encodeUtf8(Rune: First, Out);
640 return true;
641 }
642
643 // Case 2: it's an (unpaired) trailing surrogate.
644 if (LLVM_UNLIKELY(First >= 0xDC00)) {
645 Invalid();
646 return true;
647 }
648
649 // Case 3: it's a leading surrogate. We expect a trailing one next.
650 // Case 3a: there's no trailing \u escape. Don't advance in the stream.
651 if (LLVM_UNLIKELY(P + 2 > End || *P != '\\' || *(P + 1) != 'u')) {
652 Invalid(); // Leading surrogate was unpaired.
653 return true;
654 }
655 P += 2;
656 uint16_t Second;
657 if (!Parse4Hex(Second))
658 return false;
659 // Case 3b: there was another \u escape, but it wasn't a trailing surrogate.
660 if (LLVM_UNLIKELY(Second < 0xDC00 || Second >= 0xE000)) {
661 Invalid(); // Leading surrogate was unpaired.
662 First = Second; // Second escape still needs to be processed.
663 continue;
664 }
665 // Case 3c: a valid surrogate pair encoding an astral codepoint.
666 encodeUtf8(Rune: 0x10000 | ((First - 0xD800) << 10) | (Second - 0xDC00), Out);
667 return true;
668 }
669}
670
671bool Parser::parseError(const char *Msg) {
672 int Line = 1;
673 const char *StartOfLine = Start;
674 for (const char *X = Start; X < P; ++X) {
675 if (*X == 0x0A) {
676 ++Line;
677 StartOfLine = X + 1;
678 }
679 }
680 Err.emplace(
681 args: std::make_unique<ParseError>(args&: Msg, args&: Line, args: P - StartOfLine, args: P - Start));
682 return false;
683}
684} // namespace
685
686Expected<Value> parse(StringRef JSON) {
687 Parser P(JSON);
688 Value E = nullptr;
689 if (P.checkUTF8())
690 if (P.parseValue(Out&: E))
691 if (P.assertEnd())
692 return std::move(E);
693 return P.takeError();
694}
695char ParseError::ID = 0;
696
697bool isUTF8(llvm::StringRef S, size_t *ErrOffset) {
698 // Fast-path for ASCII, which is valid UTF-8.
699 if (LLVM_LIKELY(isASCII(S)))
700 return true;
701
702 const UTF8 *Data = reinterpret_cast<const UTF8 *>(S.data()), *Rest = Data;
703 if (LLVM_LIKELY(isLegalUTF8String(&Rest, Data + S.size())))
704 return true;
705
706 if (ErrOffset)
707 *ErrOffset = Rest - Data;
708 return false;
709}
710
711std::string fixUTF8(llvm::StringRef S) {
712 // This isn't particularly efficient, but is only for error-recovery.
713 std::vector<UTF32> Codepoints(S.size()); // 1 codepoint per byte suffices.
714 const UTF8 *In8 = reinterpret_cast<const UTF8 *>(S.data());
715 UTF32 *Out32 = Codepoints.data();
716 ConvertUTF8toUTF32(sourceStart: &In8, sourceEnd: In8 + S.size(), targetStart: &Out32, targetEnd: Out32 + Codepoints.size(),
717 flags: lenientConversion);
718 Codepoints.resize(new_size: Out32 - Codepoints.data());
719 std::string Res(4 * Codepoints.size(), 0); // 4 bytes per codepoint suffice
720 const UTF32 *In32 = Codepoints.data();
721 UTF8 *Out8 = reinterpret_cast<UTF8 *>(&Res[0]);
722 ConvertUTF32toUTF8(sourceStart: &In32, sourceEnd: In32 + Codepoints.size(), targetStart: &Out8, targetEnd: Out8 + Res.size(),
723 flags: strictConversion);
724 Res.resize(n: reinterpret_cast<char *>(Out8) - Res.data());
725 return Res;
726}
727
728static void quote(llvm::raw_ostream &OS, llvm::StringRef S) {
729 OS << '\"';
730 for (unsigned char C : S) {
731 if (C == 0x22 || C == 0x5C)
732 OS << '\\';
733 if (C >= 0x20) {
734 OS << C;
735 continue;
736 }
737 OS << '\\';
738 switch (C) {
739 // A few characters are common enough to make short escapes worthwhile.
740 case '\t':
741 OS << 't';
742 break;
743 case '\n':
744 OS << 'n';
745 break;
746 case '\r':
747 OS << 'r';
748 break;
749 default:
750 OS << 'u';
751 llvm::write_hex(S&: OS, N: C, Style: llvm::HexPrintStyle::Lower, Width: 4);
752 break;
753 }
754 }
755 OS << '\"';
756}
757
758void llvm::json::OStream::value(const Value &V) {
759 switch (V.kind()) {
760 case Value::Null:
761 valueBegin();
762 OS << "null";
763 return;
764 case Value::Boolean:
765 valueBegin();
766 OS << (*V.getAsBoolean() ? "true" : "false");
767 return;
768 case Value::Number:
769 valueBegin();
770 if (V.Type == Value::T_Integer)
771 OS << *V.getAsInteger();
772 else if (V.Type == Value::T_UINT64)
773 OS << *V.getAsUINT64();
774 else
775 OS << format(Fmt: "%.*g", Vals: std::numeric_limits<double>::max_digits10,
776 Vals: *V.getAsNumber());
777 return;
778 case Value::String:
779 valueBegin();
780 quote(OS, S: *V.getAsString());
781 return;
782 case Value::Array:
783 return array(Contents: [&] {
784 for (const Value &E : *V.getAsArray())
785 value(V: E);
786 });
787 case Value::Object:
788 return object(Contents: [&] {
789 for (const Object::value_type *E : sortedElements(O: *V.getAsObject()))
790 attribute(Key: E->first, Contents: E->second);
791 });
792 }
793}
794
795void llvm::json::OStream::valueBegin() {
796 assert(Stack.back().Ctx != Object && "Only attributes allowed here");
797 if (Stack.back().HasValue) {
798 assert(Stack.back().Ctx != Singleton && "Only one value allowed here");
799 OS << ',';
800 }
801 if (Stack.back().Ctx == Array)
802 newline();
803 flushComment();
804 Stack.back().HasValue = true;
805}
806
807void OStream::comment(llvm::StringRef Comment) {
808 assert(PendingComment.empty() && "Only one comment per value!");
809 PendingComment = Comment;
810}
811
812void OStream::flushComment() {
813 if (PendingComment.empty())
814 return;
815 OS << (IndentSize ? "/* " : "/*");
816 // Be sure not to accidentally emit "*/". Transform to "* /".
817 while (!PendingComment.empty()) {
818 auto Pos = PendingComment.find(Str: "*/");
819 if (Pos == StringRef::npos) {
820 OS << PendingComment;
821 PendingComment = "";
822 } else {
823 OS << PendingComment.take_front(N: Pos) << "* /";
824 PendingComment = PendingComment.drop_front(N: Pos + 2);
825 }
826 }
827 OS << (IndentSize ? " */" : "*/");
828 // Comments are on their own line unless attached to an attribute value.
829 if (Stack.size() > 1 && Stack.back().Ctx == Singleton) {
830 if (IndentSize)
831 OS << ' ';
832 } else {
833 newline();
834 }
835}
836
837void llvm::json::OStream::newline() {
838 if (IndentSize) {
839 OS.write(C: '\n');
840 OS.indent(NumSpaces: Indent);
841 }
842}
843
844void llvm::json::OStream::arrayBegin() {
845 valueBegin();
846 Stack.emplace_back();
847 Stack.back().Ctx = Array;
848 Indent += IndentSize;
849 OS << '[';
850}
851
852void llvm::json::OStream::arrayEnd() {
853 assert(Stack.back().Ctx == Array);
854 Indent -= IndentSize;
855 if (Stack.back().HasValue)
856 newline();
857 OS << ']';
858 assert(PendingComment.empty());
859 Stack.pop_back();
860 assert(!Stack.empty());
861}
862
863void llvm::json::OStream::objectBegin() {
864 valueBegin();
865 Stack.emplace_back();
866 Stack.back().Ctx = Object;
867 Indent += IndentSize;
868 OS << '{';
869}
870
871void llvm::json::OStream::objectEnd() {
872 assert(Stack.back().Ctx == Object);
873 Indent -= IndentSize;
874 if (Stack.back().HasValue)
875 newline();
876 OS << '}';
877 assert(PendingComment.empty());
878 Stack.pop_back();
879 assert(!Stack.empty());
880}
881
882void llvm::json::OStream::attributeBegin(llvm::StringRef Key) {
883 assert(Stack.back().Ctx == Object);
884 if (Stack.back().HasValue)
885 OS << ',';
886 newline();
887 flushComment();
888 Stack.back().HasValue = true;
889 Stack.emplace_back();
890 Stack.back().Ctx = Singleton;
891 if (LLVM_LIKELY(isUTF8(Key))) {
892 quote(OS, S: Key);
893 } else {
894 assert(false && "Invalid UTF-8 in attribute key");
895 quote(OS, S: fixUTF8(S: Key));
896 }
897 OS.write(C: ':');
898 if (IndentSize)
899 OS.write(C: ' ');
900}
901
902void llvm::json::OStream::attributeEnd() {
903 assert(Stack.back().Ctx == Singleton);
904 assert(Stack.back().HasValue && "Attribute must have a value");
905 assert(PendingComment.empty());
906 Stack.pop_back();
907 assert(Stack.back().Ctx == Object);
908}
909
910raw_ostream &llvm::json::OStream::rawValueBegin() {
911 valueBegin();
912 Stack.emplace_back();
913 Stack.back().Ctx = RawValue;
914 return OS;
915}
916
917void llvm::json::OStream::rawValueEnd() {
918 assert(Stack.back().Ctx == RawValue);
919 Stack.pop_back();
920}
921
922} // namespace json
923} // namespace llvm
924
925void llvm::format_provider<llvm::json::Value>::format(
926 const llvm::json::Value &E, raw_ostream &OS, StringRef Options) {
927 unsigned IndentAmount = 0;
928 if (!Options.empty() && Options.getAsInteger(/*Radix=*/10, Result&: IndentAmount))
929 llvm_unreachable("json::Value format options should be an integer");
930 json::OStream(OS, IndentAmount).value(V: E);
931}
932
933

source code of llvm/lib/Support/JSON.cpp