1 //===- MsgPackReader.h - Simple MsgPack reader ------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 /// 10 /// \file 11 /// This is a MessagePack reader. 12 /// 13 /// See https://github.com/msgpack/msgpack/blob/master/spec.md for the full 14 /// standard. 15 /// 16 /// Typical usage: 17 /// \code 18 /// StringRef input = GetInput(); 19 /// msgpack::Reader MPReader(input); 20 /// msgpack::Object Obj; 21 /// 22 /// while (MPReader.read(Obj)) { 23 /// switch (Obj.Kind) { 24 /// case msgpack::Type::Int: 25 // // Use Obj.Int 26 /// break; 27 /// // ... 28 /// } 29 /// } 30 /// \endcode 31 /// 32 //===----------------------------------------------------------------------===// 33 34 #ifndef LLVM_SUPPORT_MSGPACKREADER_H 35 #define LLVM_SUPPORT_MSGPACKREADER_H 36 37 #include "llvm/Support/MemoryBuffer.h" 38 #include "llvm/Support/raw_ostream.h" 39 #include <cstdint> 40 41 namespace llvm { 42 namespace msgpack { 43 44 /// MessagePack types as defined in the standard, with the exception of Integer 45 /// being divided into a signed Int and unsigned UInt variant in order to map 46 /// directly to C++ types. 47 /// 48 /// The types map onto corresponding union members of the \c Object struct. 49 enum class Type : uint8_t { 50 Int, 51 UInt, 52 Nil, 53 Boolean, 54 Float, 55 String, 56 Binary, 57 Array, 58 Map, 59 Extension, 60 }; 61 62 /// Extension types are composed of a user-defined type ID and an uninterpreted 63 /// sequence of bytes. 64 struct ExtensionType { 65 /// User-defined extension type. 66 int8_t Type; 67 /// Raw bytes of the extension object. 68 StringRef Bytes; 69 }; 70 71 /// MessagePack object, represented as a tagged union of C++ types. 72 /// 73 /// All types except \c Type::Nil (which has only one value, and so is 74 /// completely represented by the \c Kind itself) map to a exactly one union 75 /// member. 76 struct Object { 77 Type Kind; 78 union { 79 /// Value for \c Type::Int. 80 int64_t Int; 81 /// Value for \c Type::Uint. 82 uint64_t UInt; 83 /// Value for \c Type::Boolean. 84 bool Bool; 85 /// Value for \c Type::Float. 86 double Float; 87 /// Value for \c Type::String and \c Type::Binary. 88 StringRef Raw; 89 /// Value for \c Type::Array and \c Type::Map. 90 size_t Length; 91 /// Value for \c Type::Extension. 92 ExtensionType Extension; 93 }; 94 ObjectObject95 Object() : Kind(Type::Int), Int(0) {} 96 }; 97 98 /// Reads MessagePack objects from memory, one at a time. 99 class Reader { 100 public: 101 /// Construct a reader, keeping a reference to the \p InputBuffer. 102 Reader(MemoryBufferRef InputBuffer); 103 /// Construct a reader, keeping a reference to the \p Input. 104 Reader(StringRef Input); 105 106 Reader(const Reader &) = delete; 107 Reader &operator=(const Reader &) = delete; 108 109 /// Read one object from the input buffer, advancing past it. 110 /// 111 /// The \p Obj is updated with the kind of the object read, and the 112 /// corresponding union member is updated. 113 /// 114 /// For the collection objects (Array and Map), only the length is read, and 115 /// the caller must make and additional \c N calls (in the case of Array) or 116 /// \c N*2 calls (in the case of Map) to \c Read to retrieve the collection 117 /// elements. 118 /// 119 /// \param [out] Obj filled with next object on success. 120 /// 121 /// \returns true when object successfully read, false when at end of 122 /// input (and so \p Obj was not updated), otherwise an error. 123 Expected<bool> read(Object &Obj); 124 125 private: 126 MemoryBufferRef InputBuffer; 127 StringRef::iterator Current; 128 StringRef::iterator End; 129 remainingSpace()130 size_t remainingSpace() { 131 // The rest of the code maintains the invariant that End >= Current, so 132 // that this cast is always defined behavior. 133 return static_cast<size_t>(End - Current); 134 } 135 136 template <class T> Expected<bool> readRaw(Object &Obj); 137 template <class T> Expected<bool> readInt(Object &Obj); 138 template <class T> Expected<bool> readUInt(Object &Obj); 139 template <class T> Expected<bool> readLength(Object &Obj); 140 template <class T> Expected<bool> readExt(Object &Obj); 141 Expected<bool> createRaw(Object &Obj, uint32_t Size); 142 Expected<bool> createExt(Object &Obj, uint32_t Size); 143 }; 144 145 } // end namespace msgpack 146 } // end namespace llvm 147 148 #endif // LLVM_SUPPORT_MSGPACKREADER_H 149