1 //===- MsgPackWriter.cpp - Simple MsgPack writer ----------------*- 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 file implements a MessagePack writer. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/BinaryFormat/MsgPackWriter.h" 16 #include "llvm/BinaryFormat/MsgPack.h" 17 18 using namespace llvm; 19 using namespace msgpack; 20 21 Writer::Writer(raw_ostream &OS, bool Compatible) 22 : EW(OS, Endianness), Compatible(Compatible) {} 23 24 void Writer::writeNil() { EW.write(FirstByte::Nil); } 25 26 void Writer::write(bool b) { EW.write(b ? FirstByte::True : FirstByte::False); } 27 28 void Writer::write(int64_t i) { 29 if (i >= 0) { 30 write(static_cast<uint64_t>(i)); 31 return; 32 } 33 34 if (i >= FixMin::NegativeInt) { 35 EW.write(static_cast<int8_t>(i)); 36 return; 37 } 38 39 if (i >= INT8_MIN) { 40 EW.write(FirstByte::Int8); 41 EW.write(static_cast<int8_t>(i)); 42 return; 43 } 44 45 if (i >= INT16_MIN) { 46 EW.write(FirstByte::Int16); 47 EW.write(static_cast<int16_t>(i)); 48 return; 49 } 50 51 if (i >= INT32_MIN) { 52 EW.write(FirstByte::Int32); 53 EW.write(static_cast<int32_t>(i)); 54 return; 55 } 56 57 EW.write(FirstByte::Int64); 58 EW.write(i); 59 } 60 61 void Writer::write(uint64_t u) { 62 if (u <= FixMax::PositiveInt) { 63 EW.write(static_cast<uint8_t>(u)); 64 return; 65 } 66 67 if (u <= UINT8_MAX) { 68 EW.write(FirstByte::UInt8); 69 EW.write(static_cast<uint8_t>(u)); 70 return; 71 } 72 73 if (u <= UINT16_MAX) { 74 EW.write(FirstByte::UInt16); 75 EW.write(static_cast<uint16_t>(u)); 76 return; 77 } 78 79 if (u <= UINT32_MAX) { 80 EW.write(FirstByte::UInt32); 81 EW.write(static_cast<uint32_t>(u)); 82 return; 83 } 84 85 EW.write(FirstByte::UInt64); 86 EW.write(u); 87 } 88 89 void Writer::write(double d) { 90 // If no loss of precision, encode as a Float32. 91 float f = static_cast<float>(d); 92 if (static_cast<double>(f) == d) { 93 EW.write(FirstByte::Float32); 94 EW.write(f); 95 } else { 96 EW.write(FirstByte::Float64); 97 EW.write(d); 98 } 99 } 100 101 void Writer::write(StringRef s) { 102 size_t Size = s.size(); 103 104 if (Size <= FixMax::String) 105 EW.write(static_cast<uint8_t>(FixBits::String | Size)); 106 else if (!Compatible && Size <= UINT8_MAX) { 107 EW.write(FirstByte::Str8); 108 EW.write(static_cast<uint8_t>(Size)); 109 } else if (Size <= UINT16_MAX) { 110 EW.write(FirstByte::Str16); 111 EW.write(static_cast<uint16_t>(Size)); 112 } else { 113 assert(Size <= UINT32_MAX && "String object too long to be encoded"); 114 EW.write(FirstByte::Str32); 115 EW.write(static_cast<uint32_t>(Size)); 116 } 117 118 EW.OS << s; 119 } 120 121 void Writer::write(MemoryBufferRef Buffer) { 122 assert(!Compatible && "Attempt to write Bin format in compatible mode"); 123 124 size_t Size = Buffer.getBufferSize(); 125 126 if (Size <= UINT8_MAX) { 127 EW.write(FirstByte::Bin8); 128 EW.write(static_cast<uint8_t>(Size)); 129 } else if (Size <= UINT16_MAX) { 130 EW.write(FirstByte::Bin16); 131 EW.write(static_cast<uint16_t>(Size)); 132 } else { 133 assert(Size <= UINT32_MAX && "Binary object too long to be encoded"); 134 EW.write(FirstByte::Bin32); 135 EW.write(static_cast<uint32_t>(Size)); 136 } 137 138 EW.OS.write(Buffer.getBufferStart(), Size); 139 } 140 141 void Writer::writeArraySize(uint32_t Size) { 142 if (Size <= FixMax::Array) { 143 EW.write(static_cast<uint8_t>(FixBits::Array | Size)); 144 return; 145 } 146 147 if (Size <= UINT16_MAX) { 148 EW.write(FirstByte::Array16); 149 EW.write(static_cast<uint16_t>(Size)); 150 return; 151 } 152 153 EW.write(FirstByte::Array32); 154 EW.write(Size); 155 } 156 157 void Writer::writeMapSize(uint32_t Size) { 158 if (Size <= FixMax::Map) { 159 EW.write(static_cast<uint8_t>(FixBits::Map | Size)); 160 return; 161 } 162 163 if (Size <= UINT16_MAX) { 164 EW.write(FirstByte::Map16); 165 EW.write(static_cast<uint16_t>(Size)); 166 return; 167 } 168 169 EW.write(FirstByte::Map32); 170 EW.write(Size); 171 } 172 173 void Writer::writeExt(int8_t Type, MemoryBufferRef Buffer) { 174 size_t Size = Buffer.getBufferSize(); 175 176 switch (Size) { 177 case FixLen::Ext1: 178 EW.write(FirstByte::FixExt1); 179 break; 180 case FixLen::Ext2: 181 EW.write(FirstByte::FixExt2); 182 break; 183 case FixLen::Ext4: 184 EW.write(FirstByte::FixExt4); 185 break; 186 case FixLen::Ext8: 187 EW.write(FirstByte::FixExt8); 188 break; 189 case FixLen::Ext16: 190 EW.write(FirstByte::FixExt16); 191 break; 192 default: 193 if (Size <= UINT8_MAX) { 194 EW.write(FirstByte::Ext8); 195 EW.write(static_cast<uint8_t>(Size)); 196 } else if (Size <= UINT16_MAX) { 197 EW.write(FirstByte::Ext16); 198 EW.write(static_cast<uint16_t>(Size)); 199 } else { 200 assert(Size <= UINT32_MAX && "Ext size too large to be encoded"); 201 EW.write(FirstByte::Ext32); 202 EW.write(static_cast<uint32_t>(Size)); 203 } 204 } 205 206 EW.write(Type); 207 EW.OS.write(Buffer.getBufferStart(), Size); 208 } 209