/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/BinaryFormat/MsgPackTypes.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===- MsgPackTypes.cpp - MsgPack Types -------------------------*- 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 | | /// \file |
10 | | /// Implementation of types representing MessagePack "documents". |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #include "llvm/BinaryFormat/MsgPackTypes.h" |
15 | | #include "llvm/Support/Error.h" |
16 | | |
17 | | using namespace llvm; |
18 | | using namespace msgpack; |
19 | | |
20 | | namespace llvm { |
21 | | namespace msgpack { |
22 | 0 | void ScalarNode::anchor() {} |
23 | 0 | void ArrayNode::anchor() {} |
24 | 0 | void MapNode::anchor() {} |
25 | | } |
26 | | } |
27 | | |
28 | 275 | Expected<OptNodePtr> Node::readArray(Reader &MPReader, size_t Length) { |
29 | 275 | auto A = std::make_shared<ArrayNode>(); |
30 | 1.65k | for (size_t I = 0; I < Length; ++I1.37k ) { |
31 | 1.37k | auto OptNodeOrErr = Node::read(MPReader); |
32 | 1.37k | if (auto Err = OptNodeOrErr.takeError()) |
33 | 0 | return std::move(Err); |
34 | 1.37k | if (!*OptNodeOrErr) |
35 | 0 | return make_error<StringError>( |
36 | 0 | "Insufficient array elements", |
37 | 0 | std::make_error_code(std::errc::invalid_argument)); |
38 | 1.37k | A->push_back(std::move(**OptNodeOrErr)); |
39 | 1.37k | } |
40 | 275 | return OptNodePtr(std::move(A)); |
41 | 275 | } |
42 | | |
43 | 1.12k | Expected<OptNodePtr> Node::readMap(Reader &MPReader, size_t Length) { |
44 | 1.12k | auto M = std::make_shared<MapNode>(); |
45 | 7.94k | for (size_t I = 0; I < Length; ++I6.82k ) { |
46 | 6.82k | auto OptKeyOrErr = Node::read(MPReader); |
47 | 6.82k | if (auto Err = OptKeyOrErr.takeError()) |
48 | 0 | return std::move(Err); |
49 | 6.82k | if (!*OptKeyOrErr) |
50 | 0 | return make_error<StringError>( |
51 | 0 | "Insufficient map elements", |
52 | 0 | std::make_error_code(std::errc::invalid_argument)); |
53 | 6.82k | auto OptValOrErr = Node::read(MPReader); |
54 | 6.82k | if (auto Err = OptValOrErr.takeError()) |
55 | 0 | return std::move(Err); |
56 | 6.82k | if (!*OptValOrErr) |
57 | 0 | return make_error<StringError>( |
58 | 0 | "Insufficient map elements", |
59 | 0 | std::make_error_code(std::errc::invalid_argument)); |
60 | 6.82k | auto *Key = dyn_cast<ScalarNode>((*OptKeyOrErr)->get()); |
61 | 6.82k | if (!Key) |
62 | 0 | return make_error<StringError>( |
63 | 0 | "Only string map keys are supported", |
64 | 0 | std::make_error_code(std::errc::invalid_argument)); |
65 | 6.82k | if (Key->getScalarKind() != ScalarNode::SK_String) |
66 | 0 | return make_error<StringError>( |
67 | 0 | "Only string map keys are supported", |
68 | 0 | std::make_error_code(std::errc::invalid_argument)); |
69 | 6.82k | M->try_emplace(Key->getString(), std::move(**OptValOrErr)); |
70 | 6.82k | } |
71 | 1.12k | return OptNodePtr(std::move(M)); |
72 | 1.12k | } |
73 | | |
74 | 15.0k | Expected<OptNodePtr> Node::read(Reader &MPReader) { |
75 | 15.0k | Object Obj; |
76 | 15.0k | |
77 | 15.0k | auto ContinueOrErr = MPReader.read(Obj); |
78 | 15.0k | if (auto Err = ContinueOrErr.takeError()) |
79 | 0 | return std::move(Err); |
80 | 15.0k | if (!*ContinueOrErr) |
81 | 0 | return None; |
82 | 15.0k | |
83 | 15.0k | switch (Obj.Kind) { |
84 | 15.0k | case Type::Int: |
85 | 4 | return OptNodePtr(std::make_shared<ScalarNode>(Obj.Int)); |
86 | 15.0k | case Type::UInt: |
87 | 3.46k | return OptNodePtr(std::make_shared<ScalarNode>(Obj.UInt)); |
88 | 15.0k | case Type::Nil: |
89 | 1 | return OptNodePtr(std::make_shared<ScalarNode>()); |
90 | 15.0k | case Type::Boolean: |
91 | 14 | return OptNodePtr(std::make_shared<ScalarNode>(Obj.Bool)); |
92 | 15.0k | case Type::Float: |
93 | 0 | return OptNodePtr(std::make_shared<ScalarNode>(Obj.Float)); |
94 | 15.0k | case Type::String: |
95 | 10.1k | return OptNodePtr(std::make_shared<ScalarNode>(Obj.Raw)); |
96 | 15.0k | case Type::Binary: |
97 | 0 | return OptNodePtr(std::make_shared<ScalarNode>(Obj.Raw)); |
98 | 15.0k | case Type::Array: |
99 | 275 | return Node::readArray(MPReader, Obj.Length); |
100 | 15.0k | case Type::Map: |
101 | 1.12k | return Node::readMap(MPReader, Obj.Length); |
102 | 15.0k | case Type::Extension: |
103 | 0 | return make_error<StringError>( |
104 | 0 | "Extension types are not supported", |
105 | 0 | std::make_error_code(std::errc::invalid_argument)); |
106 | 0 | } |
107 | 0 | llvm_unreachable("msgpack::Type not handled"); |
108 | 0 | } |
109 | | |
110 | 83.9k | void ScalarNode::destroy() { |
111 | 83.9k | switch (SKind) { |
112 | 83.9k | case SK_String: |
113 | 37.5k | case SK_Binary: |
114 | 37.5k | StringValue.~basic_string(); |
115 | 37.5k | break; |
116 | 46.4k | default: |
117 | 46.4k | // POD types do not require destruction |
118 | 46.4k | break; |
119 | 83.9k | } |
120 | 83.9k | } |
121 | | |
122 | | ScalarNode::ScalarNode(int64_t IntValue) |
123 | 11 | : Node(NK_Scalar), SKind(SK_Int), IntValue(IntValue) {} |
124 | | |
125 | | ScalarNode::ScalarNode(int32_t IntValue) |
126 | 0 | : ScalarNode(static_cast<int64_t>(IntValue)) {} Unexecuted instantiation: llvm::msgpack::ScalarNode::ScalarNode(int) Unexecuted instantiation: llvm::msgpack::ScalarNode::ScalarNode(int) |
127 | | |
128 | | ScalarNode::ScalarNode(uint64_t UIntValue) |
129 | 37.5k | : Node(NK_Scalar), SKind(SK_UInt), UIntValue(UIntValue) {} |
130 | | |
131 | | ScalarNode::ScalarNode(uint32_t IntValue) |
132 | 23.4k | : ScalarNode(static_cast<uint64_t>(IntValue)) {} Unexecuted instantiation: llvm::msgpack::ScalarNode::ScalarNode(unsigned int) llvm::msgpack::ScalarNode::ScalarNode(unsigned int) Line | Count | Source | 132 | 23.4k | : ScalarNode(static_cast<uint64_t>(IntValue)) {} |
|
133 | | |
134 | 5.75k | ScalarNode::ScalarNode() : Node(NK_Scalar), SKind(SK_Nil) {} |
135 | | |
136 | | ScalarNode::ScalarNode(bool BoolValue) |
137 | 53 | : Node(NK_Scalar), SKind(SK_Boolean), BoolValue(BoolValue) {} |
138 | | |
139 | | ScalarNode::ScalarNode(double FloatValue) |
140 | 0 | : Node(NK_Scalar), SKind(SK_Float), BoolValue(FloatValue) {} |
141 | | |
142 | | ScalarNode::ScalarNode(StringRef StringValue) |
143 | 32.6k | : Node(NK_Scalar), SKind(SK_String) { |
144 | 32.6k | new (&this->StringValue) std::string(StringValue); |
145 | 32.6k | } |
146 | | |
147 | | ScalarNode::ScalarNode(const char *StringValue) |
148 | 219 | : ScalarNode(StringRef(StringValue)) {} Unexecuted instantiation: llvm::msgpack::ScalarNode::ScalarNode(char const*) llvm::msgpack::ScalarNode::ScalarNode(char const*) Line | Count | Source | 148 | 219 | : ScalarNode(StringRef(StringValue)) {} |
|
149 | | |
150 | | ScalarNode::ScalarNode(std::string &&StringValue) |
151 | 2.03k | : Node(NK_Scalar), SKind(SK_String) { |
152 | 2.03k | new (&this->StringValue) std::string(StringValue); |
153 | 2.03k | } |
154 | | |
155 | | ScalarNode::ScalarNode(MemoryBufferRef BinaryValue) |
156 | 0 | : Node(NK_Scalar), SKind(SK_Binary) { |
157 | 0 | new (&StringValue) std::string(BinaryValue.getBuffer()); |
158 | 0 | } |
159 | | |
160 | 78.0k | ScalarNode::~ScalarNode() { destroy(); } |
161 | | |
162 | 5.94k | ScalarNode &ScalarNode::operator=(ScalarNode &&RHS) { |
163 | 5.94k | destroy(); |
164 | 5.94k | switch (SKind = RHS.SKind) { |
165 | 5.94k | case SK_Int: |
166 | 0 | IntValue = RHS.IntValue; |
167 | 0 | break; |
168 | 5.94k | case SK_UInt: |
169 | 3.07k | UIntValue = RHS.UIntValue; |
170 | 3.07k | break; |
171 | 5.94k | case SK_Boolean: |
172 | 12 | BoolValue = RHS.BoolValue; |
173 | 12 | break; |
174 | 5.94k | case SK_Float: |
175 | 0 | FloatValue = RHS.FloatValue; |
176 | 0 | break; |
177 | 5.94k | case SK_String: |
178 | 2.86k | case SK_Binary: |
179 | 2.86k | new (&StringValue) std::string(std::move(RHS.StringValue)); |
180 | 2.86k | break; |
181 | 2.86k | case SK_Nil: |
182 | 0 | // pass |
183 | 0 | break; |
184 | 5.94k | } |
185 | 5.94k | return *this; |
186 | 5.94k | } |
187 | | |
188 | 5.94k | StringRef ScalarNode::inputYAML(StringRef ScalarStr) { |
189 | 5.94k | switch (SKind) { |
190 | 5.94k | case SK_Int: |
191 | 0 | return yaml::ScalarTraits<int64_t>::input(ScalarStr, nullptr, IntValue); |
192 | 5.94k | case SK_UInt: |
193 | 3.07k | return yaml::ScalarTraits<uint64_t>::input(ScalarStr, nullptr, UIntValue); |
194 | 5.94k | case SK_Nil: |
195 | 0 | return StringRef(); |
196 | 5.94k | case SK_Boolean: |
197 | 12 | return yaml::ScalarTraits<bool>::input(ScalarStr, nullptr, BoolValue); |
198 | 5.94k | case SK_Float: |
199 | 0 | return yaml::ScalarTraits<double>::input(ScalarStr, nullptr, FloatValue); |
200 | 5.94k | case SK_Binary: |
201 | 2.86k | case SK_String: |
202 | 2.86k | return yaml::ScalarTraits<std::string>::input(ScalarStr, nullptr, |
203 | 2.86k | StringValue); |
204 | 0 | } |
205 | 0 | llvm_unreachable("unrecognized ScalarKind"); |
206 | 0 | } |
207 | | |
208 | 105k | void ScalarNode::outputYAML(raw_ostream &OS) const { |
209 | 105k | switch (SKind) { |
210 | 105k | case SK_Int: |
211 | 3 | yaml::ScalarTraits<int64_t>::output(IntValue, nullptr, OS); |
212 | 3 | break; |
213 | 105k | case SK_UInt: |
214 | 61.9k | yaml::ScalarTraits<uint64_t>::output(UIntValue, nullptr, OS); |
215 | 61.9k | break; |
216 | 105k | case SK_Nil: |
217 | 0 | yaml::ScalarTraits<StringRef>::output("", nullptr, OS); |
218 | 0 | break; |
219 | 105k | case SK_Boolean: |
220 | 53 | yaml::ScalarTraits<bool>::output(BoolValue, nullptr, OS); |
221 | 53 | break; |
222 | 105k | case SK_Float: |
223 | 0 | yaml::ScalarTraits<double>::output(FloatValue, nullptr, OS); |
224 | 0 | break; |
225 | 105k | case SK_Binary: |
226 | 43.1k | case SK_String: |
227 | 43.1k | yaml::ScalarTraits<std::string>::output(StringValue, nullptr, OS); |
228 | 43.1k | break; |
229 | 105k | } |
230 | 105k | } |
231 | | |
232 | 105k | yaml::QuotingType ScalarNode::mustQuoteYAML(StringRef ScalarStr) const { |
233 | 105k | switch (SKind) { |
234 | 105k | case SK_Int: |
235 | 3 | return yaml::ScalarTraits<int64_t>::mustQuote(ScalarStr); |
236 | 105k | case SK_UInt: |
237 | 61.9k | return yaml::ScalarTraits<uint64_t>::mustQuote(ScalarStr); |
238 | 105k | case SK_Nil: |
239 | 0 | return yaml::ScalarTraits<StringRef>::mustQuote(ScalarStr); |
240 | 105k | case SK_Boolean: |
241 | 53 | return yaml::ScalarTraits<bool>::mustQuote(ScalarStr); |
242 | 105k | case SK_Float: |
243 | 0 | return yaml::ScalarTraits<double>::mustQuote(ScalarStr); |
244 | 105k | case SK_Binary: |
245 | 43.1k | case SK_String: |
246 | 43.1k | return yaml::ScalarTraits<std::string>::mustQuote(ScalarStr); |
247 | 0 | } |
248 | 0 | llvm_unreachable("unrecognized ScalarKind"); |
249 | 0 | } |
250 | | |
251 | | const char *ScalarNode::IntTag = "!int"; |
252 | | const char *ScalarNode::NilTag = "!nil"; |
253 | | const char *ScalarNode::BooleanTag = "!bool"; |
254 | | const char *ScalarNode::FloatTag = "!float"; |
255 | | const char *ScalarNode::StringTag = "!str"; |
256 | | const char *ScalarNode::BinaryTag = "!bin"; |
257 | | |
258 | 58.1k | StringRef ScalarNode::getYAMLTag() const { |
259 | 58.1k | switch (SKind) { |
260 | 58.1k | case SK_Int: |
261 | 3 | return IntTag; |
262 | 58.1k | case SK_UInt: |
263 | 33.9k | return IntTag; |
264 | 58.1k | case SK_Nil: |
265 | 0 | return NilTag; |
266 | 58.1k | case SK_Boolean: |
267 | 39 | return BooleanTag; |
268 | 58.1k | case SK_Float: |
269 | 0 | return FloatTag; |
270 | 58.1k | case SK_String: |
271 | 24.1k | return StringTag; |
272 | 58.1k | case SK_Binary: |
273 | 0 | return BinaryTag; |
274 | 0 | } |
275 | 0 | llvm_unreachable("unrecognized ScalarKind"); |
276 | 0 | } |
277 | | |
278 | 12.7k | void ScalarNode::write(Writer &MPWriter) { |
279 | 12.7k | switch (SKind) { |
280 | 12.7k | case SK_Int: |
281 | 4 | MPWriter.write(IntValue); |
282 | 4 | break; |
283 | 12.7k | case SK_UInt: |
284 | 6.61k | MPWriter.write(UIntValue); |
285 | 6.61k | break; |
286 | 12.7k | case SK_Nil: |
287 | 1 | MPWriter.writeNil(); |
288 | 1 | break; |
289 | 12.7k | case SK_Boolean: |
290 | 26 | MPWriter.write(BoolValue); |
291 | 26 | break; |
292 | 12.7k | case SK_Float: |
293 | 0 | MPWriter.write(FloatValue); |
294 | 0 | break; |
295 | 12.7k | case SK_String: |
296 | 6.09k | MPWriter.write(StringValue); |
297 | 6.09k | break; |
298 | 12.7k | case SK_Binary: |
299 | 0 | MPWriter.write(MemoryBufferRef(StringValue, "")); |
300 | 0 | break; |
301 | 12.7k | } |
302 | 12.7k | } |