Index: include/llvm/Support/JSON.h =================================================================== --- /dev/null +++ include/llvm/Support/JSON.h @@ -0,0 +1,572 @@ +//===--- JSON.h - JSON expressions, parsing and serialization - C++ ----*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===---------------------------------------------------------------------===// + +#ifndef LLVM_SUPPORT_JSON_H +#define LLVM_SUPPORT_JSON_H + +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/Error.h" +#include "llvm/Support/FormatVariadic.h" +#include "llvm/Support/raw_ostream.h" +#include + +namespace llvm { +namespace json { + +// An Expr is an JSON value of unknown type. +// They can be copied, but should generally be moved. +// +// === Composing expressions === +// +// You can implicitly construct Exprs from: +// - strings: std::string, SmallString, formatv, StringRef, char* +// (char*, and StringRef are references, not copies!) +// - numbers +// - booleans +// - null: nullptr +// - arrays: {"foo", 42.0, false} +// - serializable things: types with toJSON(const T&)->Expr, found by ADL +// +// They can also be constructed from object/array helpers: +// - json::obj is a type like map +// - json::ary is a type like vector +// These can be list-initialized, or used to build up collections in a loop. +// json::ary(Collection) converts all items in a collection to Exprs. +// +// === Inspecting expressions === +// +// Each Expr is one of the JSON kinds: +// null (nullptr_t) +// boolean (bool) +// number (double) +// string (StringRef) +// array (json::ary) +// object (json::obj) +// +// The kind can be queried directly, or implicitly via the typed accessors: +// if (Optional S = E.asString() +// assert(E.kind() == Expr::String); +// +// Array and Object also have typed indexing accessors for easy traversal: +// Expected E = parse(R"( {"options": {"font": "sans-serif"}} )"); +// if (json::obj* O = E->asObject()) +// if (json::obj* Opts = O->getObject("options")) +// if (Optional Font = Opts->getString("font")) +// assert(Opts->at("font").kind() == Expr::String); +// +// === Converting expressions to objects === +// +// The convention is to have a deserializer function findable via ADL: +// fromJSON(const json::Expr&, T&)->bool +// Deserializers are provided for: +// - bool +// - int +// - double +// - std::string +// - vector, where T is deserializable +// - map, where T is deserializable +// - Optional, where T is deserializable +// +// ObjectMapper can help writing fromJSON() functions for object types: +// bool fromJSON(const Expr &E, MyStruct &R) { +// ObjectMapper O(E); +// if (!O || !O.map("mandatory_field", R.MandatoryField)) +// return false; +// O.map("optional_field", R.OptionalField); +// return true; +// } +// +// === Serialization === +// +// Exprs can be serialized to JSON: +// 1) raw_ostream << Expr // Basic formatting. +// 2) raw_ostream << formatv("{0}", Expr) // Basic formatting. +// 3) raw_ostream << formatv("{0:2}", Expr) // Pretty-print with indent 2. +// +// And parsed: +// Expected E = json::parse("[1, 2, null]"); +// assert(E && E->kind() == Expr::Array); +class Expr { +public: + enum Kind { + Null, + Boolean, + Number, + String, + Array, + Object, + }; + class ObjectExpr; + class ObjectKey; + class ArrayExpr; + + // It would be nice to have Expr() be null. But that would make {} null too... + Expr(const Expr &M) { copyFrom(M); } + Expr(Expr &&M) { moveFrom(std::move(M)); } + // "cheating" move-constructor for moving from initializer_list. + Expr(const Expr &&M) { moveFrom(std::move(M)); } + Expr(std::initializer_list Elements) : Expr(ArrayExpr(Elements)) {} + Expr(ArrayExpr &&Elements) : Type(T_Array) { + create(std::move(Elements)); + } + Expr(ObjectExpr &&Properties) : Type(T_Object) { + create(std::move(Properties)); + } + // Strings: types with value semantics. + Expr(std::string &&V) : Type(T_String) { create(std::move(V)); } + Expr(const std::string &V) : Type(T_String) { create(V); } + Expr(const llvm::SmallVectorImpl &V) : Type(T_String) { + create(V.begin(), V.end()); + } + Expr(const llvm::formatv_object_base &V) : Expr(V.str()){}; + // Strings: types with reference semantics. + Expr(llvm::StringRef V) : Type(T_StringRef) { create(V); } + Expr(const char *V) : Type(T_StringRef) { create(V); } + Expr(std::nullptr_t) : Type(T_Null) {} + // Prevent implicit conversions to boolean. + template ::value>::type> + Expr(T B) : Type(T_Boolean) { + create(B); + } + // Numbers: arithmetic types that are not boolean. + template < + typename T, + typename = typename std::enable_if::value>::type, + typename = typename std::enable_if::value>::value>::type> + Expr(T D) : Type(T_Number) { + create(D); + } + // Types with a toJSON(const T&)->Expr function, found by ADL. + template ::value>> + Expr(const T &V) : Expr(toJSON(V)) {} + + Expr &operator=(const Expr &M) { + destroy(); + copyFrom(M); + return *this; + } + Expr &operator=(Expr &&M) { + destroy(); + moveFrom(std::move(M)); + return *this; + } + ~Expr() { destroy(); } + + Kind kind() const { + switch (Type) { + case T_Null: + return Null; + case T_Boolean: + return Boolean; + case T_Number: + return Number; + case T_String: + case T_StringRef: + return String; + case T_Object: + return Object; + case T_Array: + return Array; + } + llvm_unreachable("Unknown kind"); + } + + // Typed accessors return None/nullptr if the Expr is not of this type. + llvm::Optional asNull() const { + if (LLVM_LIKELY(Type == T_Null)) + return nullptr; + return llvm::None; + } + llvm::Optional asBoolean() const { + if (LLVM_LIKELY(Type == T_Boolean)) + return as(); + return llvm::None; + } + llvm::Optional asNumber() const { + if (LLVM_LIKELY(Type == T_Number)) + return as(); + return llvm::None; + } + llvm::Optional asInteger() const { + if (LLVM_LIKELY(Type == T_Number)) { + double D = as(); + if (LLVM_LIKELY(std::modf(D, &D) == 0 && + D >= std::numeric_limits::min() && + D <= std::numeric_limits::max())) + return D; + } + return llvm::None; + } + llvm::Optional asString() const { + if (Type == T_String) + return llvm::StringRef(as()); + if (LLVM_LIKELY(Type == T_StringRef)) + return as(); + return llvm::None; + } + const ObjectExpr *asObject() const { + return LLVM_LIKELY(Type == T_Object) ? &as() : nullptr; + } + ObjectExpr *asObject() { + return LLVM_LIKELY(Type == T_Object) ? &as() : nullptr; + } + const ArrayExpr *asArray() const { + return LLVM_LIKELY(Type == T_Array) ? &as() : nullptr; + } + ArrayExpr *asArray() { + return LLVM_LIKELY(Type == T_Array) ? &as() : nullptr; + } + + friend llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Expr &); + +private: + void destroy(); + void copyFrom(const Expr &M); + // We allow moving from *const* Exprs, by marking all members as mutable! + // This hack is needed to support initializer-list syntax efficiently. + // (std::initializer_list is a container of const T). + void moveFrom(const Expr &&M); + + template void create(U &&... V) { + new (&as()) T(std::forward(V)...); + } + template T &as() const { + return *reinterpret_cast(Union.buffer); + } + + template + void print(llvm::raw_ostream &, const Indenter &) const; + friend struct llvm::format_provider; + + enum ExprType : char { + T_Null, + T_Boolean, + T_Number, + T_StringRef, + T_String, + T_Object, + T_Array, + }; + mutable ExprType Type; + +public: + // ObjectKey is a used to capture keys in Expr::ObjectExpr. Like Expr but: + // - only strings are allowed + // - it's optimized for the string literal case (Owned == nullptr) + class ObjectKey { + public: + ObjectKey(const char *S) : Data(S) {} + ObjectKey(llvm::StringRef S) : Data(S) {} + ObjectKey(std::string &&V) + : Owned(new std::string(std::move(V))), Data(*Owned) {} + ObjectKey(const std::string &V) : Owned(new std::string(V)), Data(*Owned) {} + ObjectKey(const llvm::SmallVectorImpl &V) + : ObjectKey(std::string(V.begin(), V.end())) {} + ObjectKey(const llvm::formatv_object_base &V) : ObjectKey(V.str()) {} + + ObjectKey(const ObjectKey &C) { *this = C; } + ObjectKey(ObjectKey &&C) : ObjectKey(static_cast(C)) {} + ObjectKey &operator=(const ObjectKey &C) { + if (C.Owned) { + Owned.reset(new std::string(*C.Owned)); + Data = *Owned; + } else { + Data = C.Data; + } + return *this; + } + ObjectKey &operator=(ObjectKey &&) = default; + + operator llvm::StringRef() const { return Data; } + + friend bool operator<(const ObjectKey &L, const ObjectKey &R) { + return L.Data < R.Data; + } + + // "cheating" move-constructor for moving from initializer_list. + ObjectKey(const ObjectKey &&V) { + Owned = std::move(V.Owned); + Data = V.Data; + } + + private: + mutable std::unique_ptr Owned; // mutable for cheating. + llvm::StringRef Data; + }; + + class ObjectExpr : public std::map { + public: + explicit ObjectExpr() {} + // Use a custom struct for list-init, because pair forces extra copies. + struct KV; + explicit ObjectExpr(std::initializer_list Properties); + + // Allow [] as if Expr was default-constructible as null. + Expr &operator[](const ObjectKey &K) { + return emplace(K, Expr(nullptr)).first->second; + } + Expr &operator[](ObjectKey &&K) { + return emplace(std::move(K), Expr(nullptr)).first->second; + } + + // Look up a property, returning nullptr if it doesn't exist. + json::Expr *get(const ObjectKey &K) { + auto I = find(K); + if (I == end()) + return nullptr; + return &I->second; + } + const json::Expr *get(const ObjectKey &K) const { + auto I = find(K); + if (I == end()) + return nullptr; + return &I->second; + } + // Typed accessors return None/nullptr if + // - the property doesn't exist + // - or it has the wrong type + llvm::Optional getNull(const ObjectKey &K) const { + if (auto *V = get(K)) + return V->asNull(); + return llvm::None; + } + llvm::Optional getBoolean(const ObjectKey &K) const { + if (auto *V = get(K)) + return V->asBoolean(); + return llvm::None; + } + llvm::Optional getNumber(const ObjectKey &K) const { + if (auto *V = get(K)) + return V->asNumber(); + return llvm::None; + } + llvm::Optional getInteger(const ObjectKey &K) const { + if (auto *V = get(K)) + return V->asInteger(); + return llvm::None; + } + llvm::Optional getString(const ObjectKey &K) const { + if (auto *V = get(K)) + return V->asString(); + return llvm::None; + } + const ObjectExpr *getObject(const ObjectKey &K) const { + if (auto *V = get(K)) + return V->asObject(); + return nullptr; + } + ObjectExpr *getObject(const ObjectKey &K) { + if (auto *V = get(K)) + return V->asObject(); + return nullptr; + } + const ArrayExpr *getArray(const ObjectKey &K) const { + if (auto *V = get(K)) + return V->asArray(); + return nullptr; + } + ArrayExpr *getArray(const ObjectKey &K) { + if (auto *V = get(K)) + return V->asArray(); + return nullptr; + } + }; + + class ArrayExpr : public std::vector { + public: + explicit ArrayExpr() {} + explicit ArrayExpr(std::initializer_list Elements) { + reserve(Elements.size()); + for (const Expr &V : Elements) + emplace_back(std::move(V)); + }; + template explicit ArrayExpr(const Collection &C) { + for (const auto &V : C) + emplace_back(V); + } + + // Typed accessors return None/nullptr if the element has the wrong type. + llvm::Optional getNull(size_t I) const { + return (*this)[I].asNull(); + } + llvm::Optional getBoolean(size_t I) const { + return (*this)[I].asBoolean(); + } + llvm::Optional getNumber(size_t I) const { + return (*this)[I].asNumber(); + } + llvm::Optional getInteger(size_t I) const { + return (*this)[I].asInteger(); + } + llvm::Optional getString(size_t I) const { + return (*this)[I].asString(); + } + const ObjectExpr *getObject(size_t I) const { + return (*this)[I].asObject(); + } + ObjectExpr *getObject(size_t I) { return (*this)[I].asObject(); } + const ArrayExpr *getArray(size_t I) const { return (*this)[I].asArray(); } + ArrayExpr *getArray(size_t I) { return (*this)[I].asArray(); } + }; + +private: + mutable llvm::AlignedCharArrayUnion + Union; +}; + +bool operator==(const Expr &, const Expr &); +inline bool operator!=(const Expr &L, const Expr &R) { return !(L == R); } +inline bool operator==(const Expr::ObjectKey &L, const Expr::ObjectKey &R) { + return llvm::StringRef(L) == llvm::StringRef(R); +} +inline bool operator!=(const Expr::ObjectKey &L, const Expr::ObjectKey &R) { + return !(L == R); +} + +struct Expr::ObjectExpr::KV { + ObjectKey K; + Expr V; +}; + +inline Expr::ObjectExpr::ObjectExpr(std::initializer_list Properties) { + for (const auto &P : Properties) + emplace(std::move(P.K), std::move(P.V)); +} + +// Give Expr::{Object,Array} more convenient names for literal use. +using obj = Expr::ObjectExpr; +using ary = Expr::ArrayExpr; + +// Standard deserializers. +inline bool fromJSON(const json::Expr &E, std::string &Out) { + if (auto S = E.asString()) { + Out = *S; + return true; + } + return false; +} +inline bool fromJSON(const json::Expr &E, int &Out) { + if (auto S = E.asInteger()) { + Out = *S; + return true; + } + return false; +} +inline bool fromJSON(const json::Expr &E, double &Out) { + if (auto S = E.asNumber()) { + Out = *S; + return true; + } + return false; +} +inline bool fromJSON(const json::Expr &E, bool &Out) { + if (auto S = E.asBoolean()) { + Out = *S; + return true; + } + return false; +} +template +bool fromJSON(const json::Expr &E, llvm::Optional &Out) { + if (E.asNull()) { + Out = llvm::None; + return true; + } + T Result; + if (!fromJSON(E, Result)) + return false; + Out = std::move(Result); + return true; +} +template bool fromJSON(const json::Expr &E, std::vector &Out) { + if (auto *A = E.asArray()) { + Out.clear(); + Out.resize(A->size()); + for (size_t I = 0; I < A->size(); ++I) + if (!fromJSON((*A)[I], Out[I])) + return false; + return true; + } + return false; +} +template +bool fromJSON(const json::Expr &E, std::map &Out) { + if (auto *O = E.asObject()) { + Out.clear(); + for (const auto &KV : *O) + if (!fromJSON(KV.second, Out[llvm::StringRef(KV.first)])) + return false; + return true; + } + return false; +} + +// Helper for mapping JSON objects onto protocol structs. +// See file header for example. +class ObjectMapper { +public: + ObjectMapper(const json::Expr &E) : O(E.asObject()) {} + + // True if the expression is an object. + // Must be checked before calling map(). + operator bool() { return O; } + + // Maps a property to a field, if it exists. + template bool map(const char *Prop, T &Out) { + assert(*this && "Must check this is an object before calling map()"); + if (const json::Expr *E = O->get(Prop)) + return fromJSON(*E, Out); + return false; + } + + // Optional requires special handling, because missing keys are OK. + template bool map(const char *Prop, llvm::Optional &Out) { + assert(*this && "Must check this is an object before calling map()"); + if (const json::Expr *E = O->get(Prop)) + return fromJSON(*E, Out); + Out = llvm::None; + return true; + } + +private: + const json::obj *O; +}; + +llvm::Expected parse(llvm::StringRef JSON); + +class ParseError : public llvm::ErrorInfo { + const char *Msg; + unsigned Line, Column, Offset; + +public: + static char ID; + ParseError(const char *Msg, unsigned Line, unsigned Column, unsigned Offset) + : Msg(Msg), Line(Line), Column(Column), Offset(Offset) {} + void log(llvm::raw_ostream &OS) const override { + OS << llvm::formatv("[{0}:{1}, byte={2}]: {3}", Line, Column, Offset, Msg); + } + std::error_code convertToErrorCode() const override { + return llvm::inconvertibleErrorCode(); + } +}; + +} // namespace json + +template <> struct format_provider { + static void format(const llvm::json::Expr &, raw_ostream &, StringRef); +}; +} // namespace llvm + +#endif Index: lib/Support/CMakeLists.txt =================================================================== --- lib/Support/CMakeLists.txt +++ lib/Support/CMakeLists.txt @@ -80,6 +80,7 @@ IntEqClasses.cpp IntervalMap.cpp JamCRC.cpp + JSON.cpp KnownBits.cpp LEB128.cpp LineIterator.cpp Index: lib/Support/JSON.cpp =================================================================== --- /dev/null +++ lib/Support/JSON.cpp @@ -0,0 +1,550 @@ +//=== JSON.cpp - JSON expressions, parsing and serialization - C++ -----*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===---------------------------------------------------------------------===// + +#include "llvm/Support/JSON.h" +#include "llvm/Support/Format.h" +#include + +namespace llvm { +namespace json { + +void Expr::copyFrom(const Expr &M) { + Type = M.Type; + switch (Type) { + case T_Null: + case T_Boolean: + case T_Number: + memcpy(Union.buffer, M.Union.buffer, sizeof(Union.buffer)); + break; + case T_StringRef: + create(M.as()); + break; + case T_String: + create(M.as()); + break; + case T_Object: + create(M.as()); + break; + case T_Array: + create(M.as()); + break; + } +} + +void Expr::moveFrom(const Expr &&M) { + Type = M.Type; + switch (Type) { + case T_Null: + case T_Boolean: + case T_Number: + memcpy(Union.buffer, M.Union.buffer, sizeof(Union.buffer)); + break; + case T_StringRef: + create(M.as()); + break; + case T_String: + create(std::move(M.as())); + M.Type = T_Null; + break; + case T_Object: + create(std::move(M.as())); + M.Type = T_Null; + break; + case T_Array: + create(std::move(M.as())); + M.Type = T_Null; + break; + } +} + +void Expr::destroy() { + switch (Type) { + case T_Null: + case T_Boolean: + case T_Number: + break; + case T_StringRef: + as().~StringRef(); + break; + case T_String: + as().~basic_string(); + break; + case T_Object: + as().~ObjectExpr(); + break; + case T_Array: + as().~ArrayExpr(); + break; + } +} + +namespace { +// Simple recursive-descent JSON parser. +class Parser { +public: + Parser(StringRef JSON) + : Start(JSON.begin()), P(JSON.begin()), End(JSON.end()) {} + + bool parseExpr(Expr &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, double &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 == '.'; + } + static void encodeUtf8(uint32_t Rune, std::string &Out); + + Optional Err; + const char *Start, *P, *End; +}; + +bool Parser::parseExpr(Expr &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 bareword"); + case 't': + Out = true; + return (next() == 'r' && next() == 'u' && next() == 'e') || + parseError("Invalid bareword"); + case 'f': + Out = false; + return (next() == 'a' && next() == 'l' && next() == 's' && next() == 'e') || + parseError("Invalid bareword"); + case '"': { + std::string S; + if (parseString(S)) { + Out = std::move(S); + return true; + } + return false; + } + case '[': { + Out = json::ary{}; + json::ary &A = *Out.asArray(); + eatWhitespace(); + if (peek() == ']') { + ++P; + return true; + } + for (;;) { + A.emplace_back(nullptr); + if (!parseExpr(A.back())) + return false; + eatWhitespace(); + switch (next()) { + case ',': + eatWhitespace(); + continue; + case ']': + return true; + default: + return parseError("Expected , or ] after array element"); + } + } + } + case '{': { + Out = json::obj{}; + json::obj &O = *Out.asObject(); + 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 (!parseExpr(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)) { + double Num; + if (parseNumber(C, Num)) { + Out = Num; + return true; + } else { + return false; + } + } + return parseError("Expected JSON value"); + } +} + +bool Parser::parseNumber(char First, double &Out) { + SmallString<24> S; + S.push_back(First); + while (isNumber(peek())) + S.push_back(next()); + char *End; + Out = std::strtod(S.c_str(), &End); + return End == S.end() || parseError("Invalid 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; +} + +void Parser::encodeUtf8(uint32_t Rune, std::string &Out) { + if (Rune <= 0x7F) { + Out.push_back(Rune & 0x7F); + } else if (Rune <= 0x7FF) { + uint8_t FirstByte = 0xC0 | ((Rune & 0x7C0) >> 6); + uint8_t SecondByte = 0x80 | (Rune & 0x3F); + Out.push_back(FirstByte); + Out.push_back(SecondByte); + } else if (Rune <= 0xFFFF) { + 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 <= 0x10FFFF) { + 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 \uNNNN escape sequence, the \u have already been consumed. +// May parse multiple escapes in the presence of surrogate pairs. +bool Parser::parseUnicode(std::string &Out) { + // Note that invalid unicode is not a JSON error. It gets replaced by U+FFFD. + auto Invalid = [&] { Out.append(/* UTF-8 */ {'\xef', '\xbf', '\xbd'}); }; + auto Parse4Hex = [this](uint16_t &Out) { + 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; + if (!Parse4Hex(First)) + return false; + + // We loop to allow proper surrogate-pair error handling. + while (true) { + if (LLVM_LIKELY(First < 0xD800 || First >= 0xE000)) { // BMP. + encodeUtf8(First, Out); + return true; + } + + if (First >= 0xDC00) { + Invalid(); // Lone trailing surrogate. + return true; + } + + // We have a leading surrogate, and need a trailing one. + // Don't advance P: a lone surrogate is valid JSON (but invalid unicode) + if (P + 2 > End || *P != '\\' || *(P + 1) != 'u') { + Invalid(); // Lone leading not followed by \u... + return true; + } + P += 2; + uint16_t Second; + if (!Parse4Hex(Second)) + return false; + if (Second < 0xDC00 || Second >= 0xE000) { + Invalid(); // Leading surrogate not followed by trailing. + First = Second; // Second escape still needs to be processed. + continue; + } + + // Valid surrogate pair. + 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( + llvm::make_unique(Msg, Line, P - StartOfLine, P - Start)); + return false; +} +} // namespace + +Expected parse(StringRef JSON) { + Parser P(JSON); + json::Expr E = nullptr; + if (P.parseExpr(E)) + if (P.assertEnd()) + return std::move(E); + return P.takeError(); +} +char ParseError::ID = 0; + +} // namespace json +} // namespace llvm + +namespace { +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 << '\"'; +} + +enum IndenterAction { + Indent, + Outdent, + Newline, + Space, +}; +} // namespace + +// Prints JSON. The indenter can be used to control formatting. +template +void llvm::json::Expr::print(raw_ostream &OS, + const Indenter &I) const { + switch (Type) { + case T_Null: + OS << "null"; + break; + case T_Boolean: + OS << (as() ? "true" : "false"); + break; + case T_Number: + OS << format("%g", as()); + break; + case T_StringRef: + quote(OS, as()); + break; + case T_String: + quote(OS, as()); + break; + case T_Object: { + bool Comma = false; + OS << '{'; + I(Indent); + for (const auto &P : as()) { + if (Comma) + OS << ','; + Comma = true; + I(Newline); + quote(OS, P.first); + OS << ':'; + I(Space); + P.second.print(OS, I); + } + I(Outdent); + if (Comma) + I(Newline); + OS << '}'; + break; + } + case T_Array: { + bool Comma = false; + OS << '['; + I(Indent); + for (const auto &E : as()) { + if (Comma) + OS << ','; + Comma = true; + I(Newline); + E.print(OS, I); + } + I(Outdent); + if (Comma) + I(Newline); + OS << ']'; + break; + } + } +} + +namespace llvm { +namespace json { +llvm::raw_ostream &operator<<(raw_ostream &OS, const Expr &E) { + E.print(OS, [](IndenterAction A) { /*ignore*/ }); + return OS; +} + +bool operator==(const Expr &L, const Expr &R) { + if (L.kind() != R.kind()) + return false; + switch (L.kind()) { + case Expr::Null: + return *L.asNull() == *R.asNull(); + case Expr::Boolean: + return *L.asBoolean() == *R.asBoolean(); + case Expr::Number: + return *L.asNumber() == *R.asNumber(); + case Expr::String: + return *L.asString() == *R.asString(); + case Expr::Array: + return *L.asArray() == *R.asArray(); + case Expr::Object: + return *L.asObject() == *R.asObject(); + } + llvm_unreachable("Unknown expression kind"); +} +} // namespace json +} // namespace llvm + +void llvm::format_provider::format(const llvm::json::Expr &E, + raw_ostream &OS, + StringRef Options) { + if (Options.empty()) { + OS << E; + return; + } + unsigned IndentAmount = 0; + if (Options.getAsInteger(/*Radix=*/10, IndentAmount)) + assert(false && "json::Expr format options should be an integer"); + unsigned IndentLevel = 0; + E.print(OS, [&](IndenterAction A) { + switch (A) { + case Newline: + OS << '\n'; + OS.indent(IndentLevel); + break; + case Space: + OS << ' '; + break; + case Indent: + IndentLevel += IndentAmount; + break; + case Outdent: + IndentLevel -= IndentAmount; + break; + }; + }); +} Index: unittests/Support/CMakeLists.txt =================================================================== --- unittests/Support/CMakeLists.txt +++ unittests/Support/CMakeLists.txt @@ -30,6 +30,7 @@ FormatVariadicTest.cpp GlobPatternTest.cpp Host.cpp + JSONTest.cpp LEB128Test.cpp LineIteratorTest.cpp LockFileManagerTest.cpp Index: unittests/Support/JSONTest.cpp =================================================================== --- /dev/null +++ unittests/Support/JSONTest.cpp @@ -0,0 +1,289 @@ +//===-- JSONTest.cpp - JSON expression unit tests ---------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Support/JSON.h" + +#include "gmock/gmock.h" +#include "gtest/gtest.h" + +namespace llvm { +namespace json { + +namespace { + +std::string s(const Expr &E) { return llvm::formatv("{0}", E).str(); } +std::string sp(const Expr &E) { return llvm::formatv("{0:2}", E).str(); } + +TEST(JSONExprTests, Types) { + EXPECT_EQ("true", s(true)); + EXPECT_EQ("null", s(nullptr)); + EXPECT_EQ("2.5", s(2.5)); + EXPECT_EQ(R"("foo")", s("foo")); + EXPECT_EQ("[1,2,3]", s({1, 2, 3})); + EXPECT_EQ(R"({"x":10,"y":20})", s(obj{{"x", 10}, {"y", 20}})); +} + +TEST(JSONExprTests, Constructors) { + // Lots of edge cases around empty and singleton init lists. + EXPECT_EQ("[[[3]]]", s({{{3}}})); + EXPECT_EQ("[[[]]]", s({{{}}})); + EXPECT_EQ("[[{}]]", s({{obj{}}})); + EXPECT_EQ(R"({"A":{"B":{}}})", s(obj{{"A", obj{{"B", obj{}}}}})); + EXPECT_EQ(R"({"A":{"B":{"X":"Y"}}})", + s(obj{{"A", obj{{"B", obj{{"X", "Y"}}}}}})); +} + +TEST(JSONExprTests, StringOwnership) { + char X[] = "Hello"; + Expr Alias = static_cast(X); + X[1] = 'a'; + EXPECT_EQ(R"("Hallo")", s(Alias)); + + std::string Y = "Hello"; + Expr Copy = Y; + Y[1] = 'a'; + EXPECT_EQ(R"("Hello")", s(Copy)); +} + +TEST(JSONExprTests, CanonicalOutput) { + // Objects are sorted (but arrays aren't)! + EXPECT_EQ(R"({"a":1,"b":2,"c":3})", s(obj{{"a", 1}, {"c", 3}, {"b", 2}})); + EXPECT_EQ(R"(["a","c","b"])", s({"a", "c", "b"})); + EXPECT_EQ("3", s(3.0)); +} + +TEST(JSONExprTests, Escaping) { + std::string test = { + 0, // Strings may contain nulls. + '\b', '\f', // Have mnemonics, but we escape numerically. + '\r', '\n', '\t', // Escaped with mnemonics. + 'S', '\"', '\\', // Printable ASCII characters. + '\x7f', // Delete is not escaped. + '\xce', '\x94', // Non-ASCII UTF-8 is not escaped. + }; + + std::string teststring = R"("\u0000\u0008\u000c\r\n\tS\"\\)" + "\x7f\xCE\x94\""; + + EXPECT_EQ(teststring, s(test)); + + EXPECT_EQ(R"({"object keys are\nescaped":true})", + s(obj{{"object keys are\nescaped", true}})); +} + +TEST(JSONExprTests, PrettyPrinting) { + const char str[] = R"({ + "empty_array": [], + "empty_object": {}, + "full_array": [ + 1, + null + ], + "full_object": { + "nested_array": [ + { + "property": "value" + } + ] + } +})"; + + EXPECT_EQ(str, sp(obj{ + {"empty_object", obj{}}, + {"empty_array", {}}, + {"full_array", {1, nullptr}}, + {"full_object", + obj{ + {"nested_array", + {obj{ + {"property", "value"}, + }}}, + }}, + })); +} + +TEST(JSONTest, Parse) { + auto Compare = [](llvm::StringRef S, Expr Expected) { + if (auto E = parse(S)) { + // Compare both string forms and with operator==, in case we have bugs. + EXPECT_EQ(*E, Expected); + EXPECT_EQ(sp(*E), sp(Expected)); + } else { + handleAllErrors(E.takeError(), [S](const llvm::ErrorInfoBase &E) { + FAIL() << "Failed to parse JSON >>> " << S << " <<<: " << E.message(); + }); + } + }; + + Compare(R"(true)", true); + Compare(R"(false)", false); + Compare(R"(null)", nullptr); + + Compare(R"(42)", 42); + Compare(R"(2.5)", 2.5); + Compare(R"(2e50)", 2e50); + Compare(R"(1.2e3456789)", std::numeric_limits::infinity()); + + Compare(R"("foo")", "foo"); + Compare(R"("\"\\\b\f\n\r\t")", "\"\\\b\f\n\r\t"); + Compare(R"("\u0000")", llvm::StringRef("\0", 1)); + Compare("\"\x7f\"", "\x7f"); + Compare(R"("\ud801\udc37")", u8"\U00010437"); // UTF16 surrogate pair escape. + Compare("\"\xE2\x82\xAC\xF0\x9D\x84\x9E\"", u8"\u20ac\U0001d11e"); // UTF8 + Compare( + R"("LoneLeading=\ud801, LoneTrailing=\udc01, LeadingLeadingTrailing=\ud801\ud801\udc37")", + u8"LoneLeading=\ufffd, LoneTrailing=\ufffd, " + u8"LeadingLeadingTrailing=\ufffd\U00010437"); // Invalid unicode. + + Compare(R"({"":0,"":0})", obj{{"", 0}}); + Compare(R"({"obj":{},"arr":[]})", obj{{"obj", obj{}}, {"arr", {}}}); + Compare(R"({"\n":{"\u0000":[[[[]]]]}})", + obj{{"\n", obj{ + {llvm::StringRef("\0", 1), {{{{}}}}}, + }}}); + Compare("\r[\n\t] ", {}); +} + +TEST(JSONTest, ParseErrors) { + auto ExpectErr = [](llvm::StringRef Msg, llvm::StringRef S) { + if (auto E = parse(S)) { + // Compare both string forms and with operator==, in case we have bugs. + FAIL() << "Parsed JSON >>> " << S << " <<< but wanted error: " << Msg; + } else { + handleAllErrors(E.takeError(), [S, Msg](const llvm::ErrorInfoBase &E) { + EXPECT_THAT(E.message(), testing::HasSubstr(Msg)) << S; + }); + } + }; + ExpectErr("Unexpected EOF", ""); + ExpectErr("Unexpected EOF", "["); + ExpectErr("Text after end of document", "[][]"); + ExpectErr("Invalid bareword", "fuzzy"); + ExpectErr("Expected , or ]", "[2?]"); + ExpectErr("Expected object key", "{a:2}"); + ExpectErr("Expected : after object key", R"({"a",2})"); + ExpectErr("Expected , or } after object property", R"({"a":2 "b":3})"); + ExpectErr("Expected JSON value", R"([&%!])"); + ExpectErr("Invalid number", "1e1.0"); + ExpectErr("Unterminated string", R"("abc\"def)"); + ExpectErr("Control character in string", "\"abc\ndef\""); + ExpectErr("Invalid escape sequence", R"("\030")"); + ExpectErr("Invalid \\u escape sequence", R"("\usuck")"); + ExpectErr("[3:3, byte=19]", R"({ + "valid": 1, + invalid: 2 +})"); +} + +TEST(JSONTest, Inspection) { + llvm::Expected Doc = parse(R"( + { + "null": null, + "boolean": false, + "number": 2.78, + "string": "json", + "array": [null, true, 3.14, "hello", [1,2,3], {"time": "arrow"}], + "object": {"fruit": "banana"} + } + )"); + EXPECT_TRUE(!!Doc); + + obj *O = Doc->asObject(); + ASSERT_TRUE(O); + + EXPECT_FALSE(O->getNull("missing")); + EXPECT_FALSE(O->getNull("boolean")); + EXPECT_TRUE(O->getNull("null")); + + EXPECT_EQ(O->getNumber("number"), llvm::Optional(2.78)); + EXPECT_FALSE(O->getInteger("number")); + EXPECT_EQ(O->getString("string"), llvm::Optional("json")); + ASSERT_FALSE(O->getObject("missing")); + ASSERT_FALSE(O->getObject("array")); + ASSERT_TRUE(O->getObject("object")); + EXPECT_EQ(*O->getObject("object"), (obj{{"fruit", "banana"}})); + + ary *A = O->getArray("array"); + ASSERT_TRUE(A); + EXPECT_EQ(A->getBoolean(1), llvm::Optional(true)); + ASSERT_TRUE(A->getArray(4)); + EXPECT_EQ(*A->getArray(4), (ary{1, 2, 3})); + EXPECT_EQ(A->getArray(4)->getInteger(1), llvm::Optional(2)); + int I = 0; + for (Expr &E : *A) { + if (I++ == 5) { + ASSERT_TRUE(E.asObject()); + EXPECT_EQ(E.asObject()->getString("time"), + llvm::Optional("arrow")); + } else + EXPECT_FALSE(E.asObject()); + } +} + +// Sample struct with typical JSON-mapping rules. +struct CustomStruct { + CustomStruct() : B(false) {} + CustomStruct(std::string S, llvm::Optional I, bool B) + : S(S), I(I), B(B) {} + std::string S; + llvm::Optional I; + bool B; +}; +inline bool operator==(const CustomStruct &L, const CustomStruct &R) { + return L.S == R.S && L.I == R.I && L.B == R.B; +} +inline std::ostream &operator<<(std::ostream &OS, const CustomStruct &S) { + return OS << "(" << S.S << ", " << (S.I ? std::to_string(*S.I) : "None") + << ", " << S.B << ")"; +} +bool fromJSON(const json::Expr &E, CustomStruct &R) { + ObjectMapper O(E); + if (!O || !O.map("str", R.S) || !O.map("int", R.I)) + return false; + O.map("bool", R.B); + return true; +} + +TEST(JSONTest, Deserialize) { + std::map> R; + CustomStruct ExpectedStruct = {"foo", 42, true}; + std::map> Expected; + Expr J = obj{{"foo", ary{ + obj{ + {"str", "foo"}, + {"int", 42}, + {"bool", true}, + {"unknown", "ignored"}, + }, + obj{{"str", "bar"}}, + obj{ + {"str", "baz"}, + {"bool", "string"}, // OK, deserialize ignores. + }, + }}}; + Expected["foo"] = { + CustomStruct("foo", 42, true), + CustomStruct("bar", llvm::None, false), + CustomStruct("baz", llvm::None, false), + }; + ASSERT_TRUE(fromJSON(J, R)); + EXPECT_EQ(R, Expected); + + CustomStruct V; + EXPECT_FALSE(fromJSON(nullptr, V)) << "Not an object " << V; + EXPECT_FALSE(fromJSON(obj{}, V)) << "Missing required field " << V; + EXPECT_FALSE(fromJSON(obj{{"str", 1}}, V)) << "Wrong type " << V; + // Optional must parse as the correct type if present. + EXPECT_FALSE(fromJSON(obj{{"str", 1}, {"int", "string"}}, V)) + << "Wrong type for Optional " << V; +} + +} // namespace +} // namespace json +} // namespace llvm