| //=== JSON.cpp - JSON value, parsing and serialization - C++ -----------*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===---------------------------------------------------------------------===// |
| |
| #include "llvm/Support/JSON.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/Support/ConvertUTF.h" |
| #include "llvm/Support/Error.h" |
| #include "llvm/Support/Format.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include <cctype> |
| |
| namespace llvm { |
| namespace json { |
| |
| Value &Object::operator[](const ObjectKey &K) { |
| return try_emplace(K, nullptr).first->getSecond(); |
| } |
| Value &Object::operator[](ObjectKey &&K) { |
| return try_emplace(std::move(K), nullptr).first->getSecond(); |
| } |
| Value *Object::get(StringRef K) { |
| auto I = find(K); |
| if (I == end()) |
| return nullptr; |
| return &I->second; |
| } |
| const Value *Object::get(StringRef K) const { |
| auto I = find(K); |
| if (I == end()) |
| return nullptr; |
| return &I->second; |
| } |
| llvm::Optional<std::nullptr_t> Object::getNull(StringRef K) const { |
| if (auto *V = get(K)) |
| return V->getAsNull(); |
| return llvm::None; |
| } |
| llvm::Optional<bool> Object::getBoolean(StringRef K) const { |
| if (auto *V = get(K)) |
| return V->getAsBoolean(); |
| return llvm::None; |
| } |
| llvm::Optional<double> Object::getNumber(StringRef K) const { |
| if (auto *V = get(K)) |
| return V->getAsNumber(); |
| return llvm::None; |
| } |
| llvm::Optional<int64_t> Object::getInteger(StringRef K) const { |
| if (auto *V = get(K)) |
| return V->getAsInteger(); |
| return llvm::None; |
| } |
| llvm::Optional<llvm::StringRef> Object::getString(StringRef K) const { |
| if (auto *V = get(K)) |
| return V->getAsString(); |
| return llvm::None; |
| } |
| const json::Object *Object::getObject(StringRef K) const { |
| if (auto *V = get(K)) |
| return V->getAsObject(); |
| return nullptr; |
| } |
| json::Object *Object::getObject(StringRef K) { |
| if (auto *V = get(K)) |
| return V->getAsObject(); |
| return nullptr; |
| } |
| const json::Array *Object::getArray(StringRef K) const { |
| if (auto *V = get(K)) |
| return V->getAsArray(); |
| return nullptr; |
| } |
| json::Array *Object::getArray(StringRef K) { |
| if (auto *V = get(K)) |
| return V->getAsArray(); |
| return nullptr; |
| } |
| bool operator==(const Object &LHS, const Object &RHS) { |
| if (LHS.size() != RHS.size()) |
| return false; |
| for (const auto &L : LHS) { |
| auto R = RHS.find(L.first); |
| if (R == RHS.end() || L.second != R->second) |
| return false; |
| } |
| return true; |
| } |
| |
| Array::Array(std::initializer_list<Value> Elements) { |
| V.reserve(Elements.size()); |
| for (const Value &V : Elements) { |
| emplace_back(nullptr); |
| back().moveFrom(std::move(V)); |
| } |
| } |
| |
| Value::Value(std::initializer_list<Value> Elements) |
| : Value(json::Array(Elements)) {} |
| |
| void Value::copyFrom(const Value &M) { |
| Type = M.Type; |
| switch (Type) { |
| case T_Null: |
| case T_Boolean: |
| case T_Double: |
| case T_Integer: |
| case T_UINT64: |
| memcpy(&Union, &M.Union, sizeof(Union)); |
| break; |
| case T_StringRef: |
| create<StringRef>(M.as<StringRef>()); |
| break; |
| case T_String: |
| create<std::string>(M.as<std::string>()); |
| break; |
| case T_Object: |
| create<json::Object>(M.as<json::Object>()); |
| break; |
| case T_Array: |
| create<json::Array>(M.as<json::Array>()); |
| break; |
| } |
| } |
| |
| void Value::moveFrom(const Value &&M) { |
| Type = M.Type; |
| switch (Type) { |
| case T_Null: |
| case T_Boolean: |
| case T_Double: |
| case T_Integer: |
| case T_UINT64: |
| memcpy(&Union, &M.Union, sizeof(Union)); |
| break; |
| case T_StringRef: |
| create<StringRef>(M.as<StringRef>()); |
| break; |
| case T_String: |
| create<std::string>(std::move(M.as<std::string>())); |
| M.Type = T_Null; |
| break; |
| case T_Object: |
| create<json::Object>(std::move(M.as<json::Object>())); |
| M.Type = T_Null; |
| break; |
| case T_Array: |
| create<json::Array>(std::move(M.as<json::Array>())); |
| M.Type = T_Null; |
| break; |
| } |
| } |
| |
| void Value::destroy() { |
| switch (Type) { |
| case T_Null: |
| case T_Boolean: |
| case T_Double: |
| case T_Integer: |
| case T_UINT64: |
| break; |
| case T_StringRef: |
| as<StringRef>().~StringRef(); |
| break; |
| case T_String: |
| as<std::string>().~basic_string(); |
| break; |
| case T_Object: |
| as<json::Object>().~Object(); |
| break; |
| case T_Array: |
| as<json::Array>().~Array(); |
| break; |
| } |
| } |
| |
| bool operator==(const Value &L, const Value &R) { |
| if (L.kind() != R.kind()) |
| return false; |
| switch (L.kind()) { |
| case Value::Null: |
| return *L.getAsNull() == *R.getAsNull(); |
| case Value::Boolean: |
| return *L.getAsBoolean() == *R.getAsBoolean(); |
| case Value::Number: |
| // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=323 |
| // The same integer must convert to the same double, per the standard. |
| // However we see 64-vs-80-bit precision comparisons with gcc-7 -O3 -m32. |
| // So we avoid floating point promotion for exact comparisons. |
| if (L.Type == Value::T_Integer || R.Type == Value::T_Integer) |
| return L.getAsInteger() == R.getAsInteger(); |
| return *L.getAsNumber() == *R.getAsNumber(); |
| case Value::String: |
| return *L.getAsString() == *R.getAsString(); |
| case Value::Array: |
| return *L.getAsArray() == *R.getAsArray(); |
| case Value::Object: |
| return *L.getAsObject() == *R.getAsObject(); |
| } |
| llvm_unreachable("Unknown value kind"); |
| } |
| |
| void Path::report(llvm::StringLiteral Msg) { |
| // Walk up to the root context, and count the number of segments. |
| unsigned Count = 0; |
| const Path *P; |
| for (P = this; P->Parent != nullptr; P = P->Parent) |
| ++Count; |
| Path::Root *R = P->Seg.root(); |
| // Fill in the error message and copy the path (in reverse order). |
| R->ErrorMessage = Msg; |
| R->ErrorPath.resize(Count); |
| auto It = R->ErrorPath.begin(); |
| for (P = this; P->Parent != nullptr; P = P->Parent) |
| *It++ = P->Seg; |
| } |
| |
| Error Path::Root::getError() const { |
| std::string S; |
| raw_string_ostream OS(S); |
| OS << (ErrorMessage.empty() ? "invalid JSON contents" : ErrorMessage); |
| if (ErrorPath.empty()) { |
| if (!Name.empty()) |
| OS << " when parsing " << Name; |
| } else { |
| OS << " at " << (Name.empty() ? "(root)" : Name); |
| for (const Path::Segment &S : llvm::reverse(ErrorPath)) { |
| if (S.isField()) |
| OS << '.' << S.field(); |
| else |
| OS << '[' << S.index() << ']'; |
| } |
| } |
| return createStringError(llvm::inconvertibleErrorCode(), OS.str()); |
| } |
| |
| namespace { |
| |
| std::vector<const Object::value_type *> sortedElements(const Object &O) { |
| std::vector<const Object::value_type *> Elements; |
| for (const auto &E : O) |
| Elements.push_back(&E); |
| llvm::sort(Elements, |
| [](const Object::value_type *L, const Object::value_type *R) { |
| return L->first < R->first; |
| }); |
| return Elements; |
| } |
| |
| // Prints a one-line version of a value that isn't our main focus. |
| // We interleave writes to OS and JOS, exploiting the lack of extra buffering. |
| // This is OK as we own the implementation. |
| void abbreviate(const Value &V, OStream &JOS) { |
| switch (V.kind()) { |
| case Value::Array: |
| JOS.rawValue(V.getAsArray()->empty() ? "[]" : "[ ... ]"); |
| break; |
| case Value::Object: |
| JOS.rawValue(V.getAsObject()->empty() ? "{}" : "{ ... }"); |
| break; |
| case Value::String: { |
| llvm::StringRef S = *V.getAsString(); |
| if (S.size() < 40) { |
| JOS.value(V); |
| } else { |
| std::string Truncated = fixUTF8(S.take_front(37)); |
| Truncated.append("..."); |
| JOS.value(Truncated); |
| } |
| break; |
| } |
| default: |
| JOS.value(V); |
| } |
| } |
| |
| // Prints a semi-expanded version of a value that is our main focus. |
| // Array/Object entries are printed, but not recursively as they may be huge. |
| void abbreviateChildren(const Value &V, OStream &JOS) { |
| switch (V.kind()) { |
| case Value::Array: |
| JOS.array([&] { |
| for (const auto &I : *V.getAsArray()) |
| abbreviate(I, JOS); |
| }); |
| break; |
| case Value::Object: |
| JOS.object([&] { |
| for (const auto *KV : sortedElements(*V.getAsObject())) { |
| JOS.attributeBegin(KV->first); |
| abbreviate(KV->second, JOS); |
| JOS.attributeEnd(); |
| } |
| }); |
| break; |
| default: |
| JOS.value(V); |
| } |
| } |
| |
| } // namespace |
| |
| void Path::Root::printErrorContext(const Value &R, raw_ostream &OS) const { |
| OStream JOS(OS, /*IndentSize=*/2); |
| // PrintValue recurses down the path, printing the ancestors of our target. |
| // Siblings of nodes along the path are printed with abbreviate(), and the |
| // target itself is printed with the somewhat richer abbreviateChildren(). |
| // 'Recurse' is the lambda itself, to allow recursive calls. |
| auto PrintValue = [&](const Value &V, ArrayRef<Segment> Path, auto &Recurse) { |
| // Print the target node itself, with the error as a comment. |
| // Also used if we can't follow our path, e.g. it names a field that |
| // *should* exist but doesn't. |
| auto HighlightCurrent = [&] { |
| std::string Comment = "error: "; |
| Comment.append(ErrorMessage.data(), ErrorMessage.size()); |
| JOS.comment(Comment); |
| abbreviateChildren(V, JOS); |
| }; |
| if (Path.empty()) // We reached our target. |
| return HighlightCurrent(); |
| const Segment &S = Path.back(); // Path is in reverse order. |
| if (S.isField()) { |
| // Current node is an object, path names a field. |
| llvm::StringRef FieldName = S.field(); |
| const Object *O = V.getAsObject(); |
| if (!O || !O->get(FieldName)) |
| return HighlightCurrent(); |
| JOS.object([&] { |
| for (const auto *KV : sortedElements(*O)) { |
| JOS.attributeBegin(KV->first); |
| if (FieldName.equals(KV->first)) |
| Recurse(KV->second, Path.drop_back(), Recurse); |
| else |
| abbreviate(KV->second, JOS); |
| JOS.attributeEnd(); |
| } |
| }); |
| } else { |
| // Current node is an array, path names an element. |
| const Array *A = V.getAsArray(); |
| if (!A || S.index() >= A->size()) |
| return HighlightCurrent(); |
| JOS.array([&] { |
| unsigned Current = 0; |
| for (const auto &V : *A) { |
| if (Current++ == S.index()) |
| Recurse(V, Path.drop_back(), Recurse); |
| else |
| abbreviate(V, JOS); |
| } |
| }); |
| } |
| }; |
| PrintValue(R, ErrorPath, PrintValue); |
| } |
| |
| namespace { |
| // Simple recursive-descent JSON parser. |
| class Parser { |
| public: |
| Parser(StringRef JSON) |
| : Start(JSON.begin()), P(JSON.begin()), End(JSON.end()) {} |
| |
| bool checkUTF8() { |
| size_t ErrOffset; |
| if (isUTF8(StringRef(Start, End - Start), &ErrOffset)) |
| return true; |
| P = Start + ErrOffset; // For line/column calculation. |
| return parseError("Invalid UTF-8 sequence"); |
| } |
| |
| bool parseValue(Value &Out); |
| |
| bool assertEnd() { |
| eatWhitespace(); |
| if (P == End) |
| return true; |
| return parseError("Text after end of document"); |
| } |
| |
| Error takeError() { |
| assert(Err); |
| return std::move(*Err); |
| } |
| |
| private: |
| void eatWhitespace() { |
| while (P != End && (*P == ' ' || *P == '\r' || *P == '\n' || *P == '\t')) |
| ++P; |
| } |
| |
| // On invalid syntax, parseX() functions return false and set Err. |
| bool parseNumber(char First, Value &Out); |
| bool parseString(std::string &Out); |
| bool parseUnicode(std::string &Out); |
| bool parseError(const char *Msg); // always returns false |
| |
| char next() { return P == End ? 0 : *P++; } |
| char peek() { return P == End ? 0 : *P; } |
| static bool isNumber(char C) { |
| return C == '0' || C == '1' || C == '2' || C == '3' || C == '4' || |
| C == '5' || C == '6' || C == '7' || C == '8' || C == '9' || |
| C == 'e' || C == 'E' || C == '+' || C == '-' || C == '.'; |
| } |
| |
| Optional<Error> Err; |
| const char *Start, *P, *End; |
| }; |
| |
| bool Parser::parseValue(Value &Out) { |
| eatWhitespace(); |
| if (P == End) |
| return parseError("Unexpected EOF"); |
| switch (char C = next()) { |
| // Bare null/true/false are easy - first char identifies them. |
| case 'n': |
| Out = nullptr; |
| return (next() == 'u' && next() == 'l' && next() == 'l') || |
| parseError("Invalid JSON value (null?)"); |
| case 't': |
| Out = true; |
| return (next() == 'r' && next() == 'u' && next() == 'e') || |
| parseError("Invalid JSON value (true?)"); |
| case 'f': |
| Out = false; |
| return (next() == 'a' && next() == 'l' && next() == 's' && next() == 'e') || |
| parseError("Invalid JSON value (false?)"); |
| case '"': { |
| std::string S; |
| if (parseString(S)) { |
| Out = std::move(S); |
| return true; |
| } |
| return false; |
| } |
| case '[': { |
| Out = Array{}; |
| Array &A = *Out.getAsArray(); |
| eatWhitespace(); |
| if (peek() == ']') { |
| ++P; |
| return true; |
| } |
| for (;;) { |
| A.emplace_back(nullptr); |
| if (!parseValue(A.back())) |
| return false; |
| eatWhitespace(); |
| switch (next()) { |
| case ',': |
| eatWhitespace(); |
| continue; |
| case ']': |
| return true; |
| default: |
| return parseError("Expected , or ] after array element"); |
| } |
| } |
| } |
| case '{': { |
| Out = Object{}; |
| Object &O = *Out.getAsObject(); |
| eatWhitespace(); |
| if (peek() == '}') { |
| ++P; |
| return true; |
| } |
| for (;;) { |
| if (next() != '"') |
| return parseError("Expected object key"); |
| std::string K; |
| if (!parseString(K)) |
| return false; |
| eatWhitespace(); |
| if (next() != ':') |
| return parseError("Expected : after object key"); |
| eatWhitespace(); |
| if (!parseValue(O[std::move(K)])) |
| return false; |
| eatWhitespace(); |
| switch (next()) { |
| case ',': |
| eatWhitespace(); |
| continue; |
| case '}': |
| return true; |
| default: |
| return parseError("Expected , or } after object property"); |
| } |
| } |
| } |
| default: |
| if (isNumber(C)) |
| return parseNumber(C, Out); |
| return parseError("Invalid JSON value"); |
| } |
| } |
| |
| bool Parser::parseNumber(char First, Value &Out) { |
| // Read the number into a string. (Must be null-terminated for strto*). |
| SmallString<24> S; |
| S.push_back(First); |
| while (isNumber(peek())) |
| S.push_back(next()); |
| char *End; |
| // Try first to parse as integer, and if so preserve full 64 bits. |
| // strtoll returns long long >= 64 bits, so check it's in range too. |
| auto I = std::strtoll(S.c_str(), &End, 10); |
| if (End == S.end() && I >= std::numeric_limits<int64_t>::min() && |
| I <= std::numeric_limits<int64_t>::max()) { |
| Out = int64_t(I); |
| return true; |
| } |
| // If it's not an integer |
| Out = std::strtod(S.c_str(), &End); |
| return End == S.end() || parseError("Invalid JSON value (number?)"); |
| } |
| |
| bool Parser::parseString(std::string &Out) { |
| // leading quote was already consumed. |
| for (char C = next(); C != '"'; C = next()) { |
| if (LLVM_UNLIKELY(P == End)) |
| return parseError("Unterminated string"); |
| if (LLVM_UNLIKELY((C & 0x1f) == C)) |
| return parseError("Control character in string"); |
| if (LLVM_LIKELY(C != '\\')) { |
| Out.push_back(C); |
| continue; |
| } |
| // Handle escape sequence. |
| switch (C = next()) { |
| case '"': |
| case '\\': |
| case '/': |
| Out.push_back(C); |
| break; |
| case 'b': |
| Out.push_back('\b'); |
| break; |
| case 'f': |
| Out.push_back('\f'); |
| break; |
| case 'n': |
| Out.push_back('\n'); |
| break; |
| case 'r': |
| Out.push_back('\r'); |
| break; |
| case 't': |
| Out.push_back('\t'); |
| break; |
| case 'u': |
| if (!parseUnicode(Out)) |
| return false; |
| break; |
| default: |
| return parseError("Invalid escape sequence"); |
| } |
| } |
| return true; |
| } |
| |
| static void encodeUtf8(uint32_t Rune, std::string &Out) { |
| if (Rune < 0x80) { |
| Out.push_back(Rune & 0x7F); |
| } else if (Rune < 0x800) { |
| uint8_t FirstByte = 0xC0 | ((Rune & 0x7C0) >> 6); |
| uint8_t SecondByte = 0x80 | (Rune & 0x3F); |
| Out.push_back(FirstByte); |
| Out.push_back(SecondByte); |
| } else if (Rune < 0x10000) { |
| uint8_t FirstByte = 0xE0 | ((Rune & 0xF000) >> 12); |
| uint8_t SecondByte = 0x80 | ((Rune & 0xFC0) >> 6); |
| uint8_t ThirdByte = 0x80 | (Rune & 0x3F); |
| Out.push_back(FirstByte); |
| Out.push_back(SecondByte); |
| Out.push_back(ThirdByte); |
| } else if (Rune < 0x110000) { |
| uint8_t FirstByte = 0xF0 | ((Rune & 0x1F0000) >> 18); |
| uint8_t SecondByte = 0x80 | ((Rune & 0x3F000) >> 12); |
| uint8_t ThirdByte = 0x80 | ((Rune & 0xFC0) >> 6); |
| uint8_t FourthByte = 0x80 | (Rune & 0x3F); |
| Out.push_back(FirstByte); |
| Out.push_back(SecondByte); |
| Out.push_back(ThirdByte); |
| Out.push_back(FourthByte); |
| } else { |
| llvm_unreachable("Invalid codepoint"); |
| } |
| } |
| |
| // Parse a UTF-16 \uNNNN escape sequence. "\u" has already been consumed. |
| // May parse several sequential escapes to ensure proper surrogate handling. |
| // We do not use ConvertUTF.h, it can't accept and replace unpaired surrogates. |
| // These are invalid Unicode but valid JSON (RFC 8259, section 8.2). |
| bool Parser::parseUnicode(std::string &Out) { |
| // Invalid UTF is not a JSON error (RFC 8529§8.2). It gets replaced by U+FFFD. |
| auto Invalid = [&] { Out.append(/* UTF-8 */ {'\xef', '\xbf', '\xbd'}); }; |
| // Decodes 4 hex digits from the stream into Out, returns false on error. |
| auto Parse4Hex = [this](uint16_t &Out) -> bool { |
| Out = 0; |
| char Bytes[] = {next(), next(), next(), next()}; |
| for (unsigned char C : Bytes) { |
| if (!std::isxdigit(C)) |
| return parseError("Invalid \\u escape sequence"); |
| Out <<= 4; |
| Out |= (C > '9') ? (C & ~0x20) - 'A' + 10 : (C - '0'); |
| } |
| return true; |
| }; |
| uint16_t First; // UTF-16 code unit from the first \u escape. |
| if (!Parse4Hex(First)) |
| return false; |
| |
| // We loop to allow proper surrogate-pair error handling. |
| while (true) { |
| // Case 1: the UTF-16 code unit is already a codepoint in the BMP. |
| if (LLVM_LIKELY(First < 0xD800 || First >= 0xE000)) { |
| encodeUtf8(First, Out); |
| return true; |
| } |
| |
| // Case 2: it's an (unpaired) trailing surrogate. |
| if (LLVM_UNLIKELY(First >= 0xDC00)) { |
| Invalid(); |
| return true; |
| } |
| |
| // Case 3: it's a leading surrogate. We expect a trailing one next. |
| // Case 3a: there's no trailing \u escape. Don't advance in the stream. |
| if (LLVM_UNLIKELY(P + 2 > End || *P != '\\' || *(P + 1) != 'u')) { |
| Invalid(); // Leading surrogate was unpaired. |
| return true; |
| } |
| P += 2; |
| uint16_t Second; |
| if (!Parse4Hex(Second)) |
| return false; |
| // Case 3b: there was another \u escape, but it wasn't a trailing surrogate. |
| if (LLVM_UNLIKELY(Second < 0xDC00 || Second >= 0xE000)) { |
| Invalid(); // Leading surrogate was unpaired. |
| First = Second; // Second escape still needs to be processed. |
| continue; |
| } |
| // Case 3c: a valid surrogate pair encoding an astral codepoint. |
| encodeUtf8(0x10000 | ((First - 0xD800) << 10) | (Second - 0xDC00), Out); |
| return true; |
| } |
| } |
| |
| bool Parser::parseError(const char *Msg) { |
| int Line = 1; |
| const char *StartOfLine = Start; |
| for (const char *X = Start; X < P; ++X) { |
| if (*X == 0x0A) { |
| ++Line; |
| StartOfLine = X + 1; |
| } |
| } |
| Err.emplace( |
| std::make_unique<ParseError>(Msg, Line, P - StartOfLine, P - Start)); |
| return false; |
| } |
| } // namespace |
| |
| Expected<Value> parse(StringRef JSON) { |
| Parser P(JSON); |
| Value E = nullptr; |
| if (P.checkUTF8()) |
| if (P.parseValue(E)) |
| if (P.assertEnd()) |
| return std::move(E); |
| return P.takeError(); |
| } |
| char ParseError::ID = 0; |
| |
| bool isUTF8(llvm::StringRef S, size_t *ErrOffset) { |
| // Fast-path for ASCII, which is valid UTF-8. |
| if (LLVM_LIKELY(isASCII(S))) |
| return true; |
| |
| const UTF8 *Data = reinterpret_cast<const UTF8 *>(S.data()), *Rest = Data; |
| if (LLVM_LIKELY(isLegalUTF8String(&Rest, Data + S.size()))) |
| return true; |
| |
| if (ErrOffset) |
| *ErrOffset = Rest - Data; |
| return false; |
| } |
| |
| std::string fixUTF8(llvm::StringRef S) { |
| // This isn't particularly efficient, but is only for error-recovery. |
| std::vector<UTF32> Codepoints(S.size()); // 1 codepoint per byte suffices. |
| const UTF8 *In8 = reinterpret_cast<const UTF8 *>(S.data()); |
| UTF32 *Out32 = Codepoints.data(); |
| ConvertUTF8toUTF32(&In8, In8 + S.size(), &Out32, Out32 + Codepoints.size(), |
| lenientConversion); |
| Codepoints.resize(Out32 - Codepoints.data()); |
| std::string Res(4 * Codepoints.size(), 0); // 4 bytes per codepoint suffice |
| const UTF32 *In32 = Codepoints.data(); |
| UTF8 *Out8 = reinterpret_cast<UTF8 *>(&Res[0]); |
| ConvertUTF32toUTF8(&In32, In32 + Codepoints.size(), &Out8, Out8 + Res.size(), |
| strictConversion); |
| Res.resize(reinterpret_cast<char *>(Out8) - Res.data()); |
| return Res; |
| } |
| |
| static void quote(llvm::raw_ostream &OS, llvm::StringRef S) { |
| OS << '\"'; |
| for (unsigned char C : S) { |
| if (C == 0x22 || C == 0x5C) |
| OS << '\\'; |
| if (C >= 0x20) { |
| OS << C; |
| continue; |
| } |
| OS << '\\'; |
| switch (C) { |
| // A few characters are common enough to make short escapes worthwhile. |
| case '\t': |
| OS << 't'; |
| break; |
| case '\n': |
| OS << 'n'; |
| break; |
| case '\r': |
| OS << 'r'; |
| break; |
| default: |
| OS << 'u'; |
| llvm::write_hex(OS, C, llvm::HexPrintStyle::Lower, 4); |
| break; |
| } |
| } |
| OS << '\"'; |
| } |
| |
| void llvm::json::OStream::value(const Value &V) { |
| switch (V.kind()) { |
| case Value::Null: |
| valueBegin(); |
| OS << "null"; |
| return; |
| case Value::Boolean: |
| valueBegin(); |
| OS << (*V.getAsBoolean() ? "true" : "false"); |
| return; |
| case Value::Number: |
| valueBegin(); |
| if (V.Type == Value::T_Integer) |
| OS << *V.getAsInteger(); |
| else if (V.Type == Value::T_UINT64) |
| OS << *V.getAsUINT64(); |
| else |
| OS << format("%.*g", std::numeric_limits<double>::max_digits10, |
| *V.getAsNumber()); |
| return; |
| case Value::String: |
| valueBegin(); |
| quote(OS, *V.getAsString()); |
| return; |
| case Value::Array: |
| return array([&] { |
| for (const Value &E : *V.getAsArray()) |
| value(E); |
| }); |
| case Value::Object: |
| return object([&] { |
| for (const Object::value_type *E : sortedElements(*V.getAsObject())) |
| attribute(E->first, E->second); |
| }); |
| } |
| } |
| |
| void llvm::json::OStream::valueBegin() { |
| assert(Stack.back().Ctx != Object && "Only attributes allowed here"); |
| if (Stack.back().HasValue) { |
| assert(Stack.back().Ctx != Singleton && "Only one value allowed here"); |
| OS << ','; |
| } |
| if (Stack.back().Ctx == Array) |
| newline(); |
| flushComment(); |
| Stack.back().HasValue = true; |
| } |
| |
| void OStream::comment(llvm::StringRef Comment) { |
| assert(PendingComment.empty() && "Only one comment per value!"); |
| PendingComment = Comment; |
| } |
| |
| void OStream::flushComment() { |
| if (PendingComment.empty()) |
| return; |
| OS << (IndentSize ? "/* " : "/*"); |
| // Be sure not to accidentally emit "*/". Transform to "* /". |
| while (!PendingComment.empty()) { |
| auto Pos = PendingComment.find("*/"); |
| if (Pos == StringRef::npos) { |
| OS << PendingComment; |
| PendingComment = ""; |
| } else { |
| OS << PendingComment.take_front(Pos) << "* /"; |
| PendingComment = PendingComment.drop_front(Pos + 2); |
| } |
| } |
| OS << (IndentSize ? " */" : "*/"); |
| // Comments are on their own line unless attached to an attribute value. |
| if (Stack.size() > 1 && Stack.back().Ctx == Singleton) { |
| if (IndentSize) |
| OS << ' '; |
| } else { |
| newline(); |
| } |
| } |
| |
| void llvm::json::OStream::newline() { |
| if (IndentSize) { |
| OS.write('\n'); |
| OS.indent(Indent); |
| } |
| } |
| |
| void llvm::json::OStream::arrayBegin() { |
| valueBegin(); |
| Stack.emplace_back(); |
| Stack.back().Ctx = Array; |
| Indent += IndentSize; |
| OS << '['; |
| } |
| |
| void llvm::json::OStream::arrayEnd() { |
| assert(Stack.back().Ctx == Array); |
| Indent -= IndentSize; |
| if (Stack.back().HasValue) |
| newline(); |
| OS << ']'; |
| assert(PendingComment.empty()); |
| Stack.pop_back(); |
| assert(!Stack.empty()); |
| } |
| |
| void llvm::json::OStream::objectBegin() { |
| valueBegin(); |
| Stack.emplace_back(); |
| Stack.back().Ctx = Object; |
| Indent += IndentSize; |
| OS << '{'; |
| } |
| |
| void llvm::json::OStream::objectEnd() { |
| assert(Stack.back().Ctx == Object); |
| Indent -= IndentSize; |
| if (Stack.back().HasValue) |
| newline(); |
| OS << '}'; |
| assert(PendingComment.empty()); |
| Stack.pop_back(); |
| assert(!Stack.empty()); |
| } |
| |
| void llvm::json::OStream::attributeBegin(llvm::StringRef Key) { |
| assert(Stack.back().Ctx == Object); |
| if (Stack.back().HasValue) |
| OS << ','; |
| newline(); |
| flushComment(); |
| Stack.back().HasValue = true; |
| Stack.emplace_back(); |
| Stack.back().Ctx = Singleton; |
| if (LLVM_LIKELY(isUTF8(Key))) { |
| quote(OS, Key); |
| } else { |
| assert(false && "Invalid UTF-8 in attribute key"); |
| quote(OS, fixUTF8(Key)); |
| } |
| OS.write(':'); |
| if (IndentSize) |
| OS.write(' '); |
| } |
| |
| void llvm::json::OStream::attributeEnd() { |
| assert(Stack.back().Ctx == Singleton); |
| assert(Stack.back().HasValue && "Attribute must have a value"); |
| assert(PendingComment.empty()); |
| Stack.pop_back(); |
| assert(Stack.back().Ctx == Object); |
| } |
| |
| raw_ostream &llvm::json::OStream::rawValueBegin() { |
| valueBegin(); |
| Stack.emplace_back(); |
| Stack.back().Ctx = RawValue; |
| return OS; |
| } |
| |
| void llvm::json::OStream::rawValueEnd() { |
| assert(Stack.back().Ctx == RawValue); |
| Stack.pop_back(); |
| } |
| |
| } // namespace json |
| } // namespace llvm |
| |
| void llvm::format_provider<llvm::json::Value>::format( |
| const llvm::json::Value &E, raw_ostream &OS, StringRef Options) { |
| unsigned IndentAmount = 0; |
| if (!Options.empty() && Options.getAsInteger(/*Radix=*/10, IndentAmount)) |
| llvm_unreachable("json::Value format options should be an integer"); |
| json::OStream(OS, IndentAmount).value(E); |
| } |
| |