P4C
The P4 Compiler
Loading...
Searching...
No Matches
json_loader.h
1/*
2 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
3 * Copyright 2013-present Barefoot Networks, Inc.
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 */
7
8#ifndef IR_JSON_LOADER_H_
9#define IR_JSON_LOADER_H_
10
11#include <map>
12#include <memory>
13#include <optional>
14#include <string>
15#include <string_view>
16#include <unordered_map>
17#include <utility>
18#include <variant>
19
20#include "absl/container/flat_hash_set.h"
21#include "ir.h"
22#include "json_parser.h"
23#include "lib/bitvec.h"
24#include "lib/cstring.h"
25#include "lib/ltbitmatrix.h"
26#include "lib/match.h"
27#include "lib/null.h"
28#include "lib/ordered_map.h"
29#include "lib/ordered_set.h"
30#include "lib/safe_vector.h"
31
32namespace P4 {
33
34class JSONLoader {
35 template <typename T>
36 class has_fromJSON {
37 typedef char small;
38 typedef struct {
39 char c[2];
40 } big;
41
42 template <typename C>
43 static small test(decltype(&C::fromJSON));
44 template <typename C>
45 static big test(...);
46
47 public:
48 static const bool value = sizeof(test<T>(0)) == sizeof(char);
49 };
50
51 using NodeReferences = std::unordered_map<int, IR::Node *>;
52 std::shared_ptr<NodeReferences> node_refs;
53 std::unique_ptr<JsonData> json_root;
54 const JsonData *json = nullptr;
55 JsonData::LocationInfo *locinfo = nullptr;
56 std::unique_ptr<absl::flat_hash_set<P4::cstring, Util::Hash>> decoded;
57 bool (*errfn)(const JSONLoader &, std::string_view msg) = nullptr;
58
59 JSONLoader(const JsonData *json, std::shared_ptr<NodeReferences> refs,
61 : node_refs(std::move(refs)), json(json), locinfo(locinfo) {}
62
63 public:
64 explicit JSONLoader(std::istream &in, JsonData::LocationInfo *li = nullptr)
65 : node_refs(std::make_shared<NodeReferences>()), locinfo(li) {
66 in >> json_root;
67 json = json_root.get();
68 }
69
70 JSONLoader(const JSONLoader &unpacker, std::string_view field)
71 : node_refs(unpacker.node_refs), json(nullptr), locinfo(unpacker.locinfo) {
72 if (!unpacker) return;
73 if (auto *obj = unpacker.json->to<JsonObject>()) {
74 if (auto it = obj->find(field); it != obj->end()) {
75 if (unpacker.decoded) unpacker.decoded->emplace(field);
76 json = it->second.get();
77 }
78 }
79 }
80
81 explicit operator bool() const { return json != nullptr; }
82 template <typename T>
83 [[nodiscard]] bool is() const {
84 return json && json->is<T>();
85 }
86 template <typename T>
87 [[nodiscard]] const T &as() const {
88 if (!is<T>()) error("type mismatch in json");
89 return json->as<T>();
90 }
91 template <typename T>
92 [[nodiscard]] const T *to() const {
93 return json ? json->to<T>() : nullptr;
94 }
95
96 std::string locdesc(const JsonData &d) const {
97 if (!locinfo) return "";
98 return locinfo->desc(d);
99 }
100 std::string locdesc() const {
101 if (!json) return "";
102 return locdesc(*json);
103 }
104 std::string locdesc(std::string_view field) const {
105 if (!locinfo || !json) return "";
106 if (auto *obj = json->to<JsonObject>())
107 if (auto it = obj->find(field); it != obj->end()) return locinfo->desc(*it->second);
108 return locdesc();
109 }
110
111 bool error(std::string_view msg) const {
112 if ((!errfn || errfn(*this, msg)) && JsonData::strict) throw JsonData::error(msg, json);
113 return false;
114 }
115
116 void track_decode() {
117 BUG_CHECK(json && json->is<JsonObject>(), "JSONLoader::track_decode on non-JsonObject");
118 if (!decoded) decoded = std::make_unique<absl::flat_hash_set<P4::cstring, Util::Hash>>();
119 }
120
121 template <typename FN>
122 void undecoded(FN fn) {
123 BUG_CHECK(decoded, "Called JSONLoader::undecoded without track_decode");
124 for (auto &el : *json->to<JsonObject>())
125 if (!decoded->count(el.first)) fn(*this, el.first, *el.second);
126 }
127
128 private:
129 const IR::Node *get_node(NodeFactoryFn factory = nullptr) {
130 if (!json || !json->is<JsonObject>()) {
131 error("node is not a JsonObject");
132 return nullptr;
133 }
134 track_decode();
135 int id = -1; // load() leaves id untouched if Node_ID is absent.
136 auto success = load("Node_ID", id) || error("missing field Node_ID");
137 if (!success) return nullptr;
138 if (id >= 0) {
139 if (node_refs->find(id) == node_refs->end()) {
140 cstring type;
141 if (!factory) {
142 auto success = load("Node_Type", type) || error("missing field Node_Type");
143 if (!success) return nullptr;
144 factory = get(IR::unpacker_table, type);
145 }
146 if (factory) {
147 auto *node = factory(*this)->to<IR::Node>();
148 CHECK_NULL(node);
149 node_refs->emplace(id, node);
150 // Creating JsonObject from source_info read from jsonFile
151 // and setting SourceInfo for each node
152 // when "--fromJSON" flag is used
153 node->sourceInfoFromJSON(*this);
154 } else {
155 error("no Node factory for " + type);
156 return nullptr;
157 }
158 }
159 return node_refs->at(id);
160 }
161 error("invalid Node_ID " + std::to_string(id));
162 return nullptr;
163 }
164
165 template <typename T>
166 void unpack_json(safe_vector<T> &v) {
167 T temp;
168 v.clear();
169 for (auto &e : as<JsonVector>()) {
170 load(e, temp);
171 v.push_back(temp);
172 }
173 }
174
175 template <typename T>
176 void unpack_json(std::set<T> &v) {
177 T temp;
178 v.clear();
179 for (auto &e : as<JsonVector>()) {
180 load(e, temp);
181 v.insert(temp);
182 }
183 }
184
185 template <typename T>
186 void unpack_json(ordered_set<T> &v) {
187 T temp;
188 v.clear();
189 for (auto &e : as<JsonVector>()) {
190 load(e, temp);
191 v.insert(temp);
192 }
193 }
194
195 template <typename T>
196 void unpack_json(IR::Vector<T> &v) {
197 v = get_node(NodeFactoryFn(&IR::Vector<T>::fromJSON))->as<IR::Vector<T>>();
198 }
199 template <typename T>
200 void unpack_json(const IR::Vector<T> *&v) {
201 v = get_node(NodeFactoryFn(&IR::Vector<T>::fromJSON))->checkedTo<IR::Vector<T>>();
202 }
203 template <typename T>
204 void unpack_json(IR::IndexedVector<T> &v) {
205 v = get_node(NodeFactoryFn(&IR::IndexedVector<T>::fromJSON))->as<IR::IndexedVector<T>>();
206 }
207 template <typename T>
208 void unpack_json(const IR::IndexedVector<T> *&v) {
209 v = get_node(NodeFactoryFn(&IR::IndexedVector<T>::fromJSON))
210 ->checkedTo<IR::IndexedVector<T>>();
211 }
212 template <class T, template <class K, class V, class COMP, class ALLOC> class MAP, class COMP,
213 class ALLOC>
214 void unpack_json(IR::NameMap<T, MAP, COMP, ALLOC> &m) {
215 m = get_node(NodeFactoryFn(&IR::NameMap<T, MAP, COMP, ALLOC>::fromJSON))
217 }
218 template <class T, template <class K, class V, class COMP, class ALLOC> class MAP, class COMP,
219 class ALLOC>
220 void unpack_json(const IR::NameMap<T, MAP, COMP, ALLOC> *&m) {
221 m = get_node(NodeFactoryFn(&IR::NameMap<T, MAP, COMP, ALLOC>::fromJSON))
223 }
224
225 template <typename K, typename V>
226 void unpack_json(std::map<K, V> &v) {
227 std::pair<K, V> temp;
228 v.clear();
229 if (is<JsonVector>()) {
230 for (auto &e : as<JsonVector>()) {
231 load(e, temp);
232 v.insert(temp);
233 }
234 } else {
235 for (auto &e : as<JsonObject>()) {
236 load(JsonString(e.first), temp.first);
237 load(e.second, temp.second);
238 v.insert(temp);
239 }
240 }
241 }
242 template <typename K, typename V>
243 void unpack_json(ordered_map<K, V> &v) {
244 std::pair<K, V> temp;
245 v.clear();
246 if (is<JsonVector>()) {
247 for (auto &e : as<JsonVector>()) {
248 load(e, temp);
249 v.insert(temp);
250 }
251 } else {
252 for (auto &e : as<JsonObject>()) {
253 load(JsonString(e.first), temp.first);
254 load(e.second, temp.second);
255 v.insert(temp);
256 }
257 }
258 }
259 template <typename V>
260 void unpack_json(string_map<V> &v) {
261 std::pair<cstring, V> temp;
262 v.clear();
263 for (auto &e : as<JsonObject>()) {
264 temp.first = e.first;
265 load(e.second, temp.second);
266 v.insert(temp);
267 }
268 }
269
270 template <typename K, typename V>
271 void unpack_json(std::multimap<K, V> &v) {
272 std::pair<K, V> temp;
273 v.clear();
274 if (is<JsonVector>()) {
275 for (auto &e : as<JsonVector>()) {
276 load(e, temp);
277 v.insert(temp);
278 }
279 } else {
280 for (auto &e : as<JsonObject>()) {
281 load(JsonString(e.first), temp.first);
282 load(e.second, temp.second);
283 v.insert(temp);
284 }
285 }
286 }
287
288 template <typename T>
289 void unpack_json(std::vector<T> &v) {
290 T temp;
291 v.clear();
292 for (auto &e : as<JsonVector>()) {
293 load(e, temp);
294 v.push_back(temp);
295 }
296 }
297
298 template <typename T, typename U>
299 void unpack_json(std::pair<T, U> &v) {
300 load("first", v.first) || error("missing field first");
301 load("second", v.second) || error("missing field second");
302 }
303
304 template <typename T>
305 void unpack_json(std::optional<T> &v) {
306 bool isValid = false;
307 load("valid", isValid) || error("missing field valid");
308 if (!isValid) {
309 v = std::nullopt;
310 return;
311 }
312 T value;
313 auto success = load("value", value) || error("missing field value");
314 if (!success) {
315 v = std::nullopt;
316 return;
317 }
318 v = std::move(value);
319 }
320
321 template <int N, class Variant>
322 std::enable_if_t<N == std::variant_size_v<Variant>> unpack_variant(int /*target*/,
323 Variant & /*variant*/) {
324 BUG("Error traversing variant during load");
325 }
326
327 template <int N, class Variant>
328 std::enable_if_t<(N < std::variant_size_v<Variant>)> unpack_variant(int target,
329 Variant &variant) {
330 if (N == target) {
331 variant.template emplace<N>();
332 load("value", std::get<N>(variant)) || error("missing field value");
333 } else
334 unpack_variant<N + 1>(target, variant);
335 }
336
337 template <class... Types>
338 void unpack_json(std::variant<Types...> &v) {
339 int index = -1;
340 load("variant_index", index) || error("missing field variant_index");
341 unpack_variant<0>(index, v);
342 }
343
344 void unpack_json(bool &v) { v = as<JsonBoolean>(); }
345
346 template <typename T>
347 std::enable_if_t<std::is_integral_v<T>> unpack_json(T &v) {
348 // Use the full-precision value to avoid truncation through int.
349 v = static_cast<T>(as<JsonNumber>().val);
350 }
351 void unpack_json(big_int &v) { v = as<JsonNumber>().val; }
352 void unpack_json(std::string &v) {
353 if (is<JsonString>()) v = as<JsonString>();
354 }
355 void unpack_json(cstring &v) {
356 if (is<JsonString>())
357 v = cstring(as<JsonString>());
358 else if (is<JsonNull>())
359 v = cstring();
360 }
361 void unpack_json(IR::ID &v) {
362 if (!json->is<JsonNull>()) v.name = as<JsonString>();
363 }
364
365 void unpack_json(LTBitMatrix &m) {
366 if (auto *s = json->to<JsonString>())
367 s->c_str() >> m;
368 else
369 error("bit matrix value not a string");
370 }
371
372 void unpack_json(bitvec &v) {
373 if (auto *s = json->to<JsonString>())
374 s->c_str() >> v;
375 else
376 error("bitvec value not a string");
377 }
378
379 template <typename T>
380 std::enable_if_t<std::is_enum_v<T>> unpack_json(T &v) {
381 if (auto *s = json->to<JsonString>())
382 *s >> v;
383 else
384 error("enum tag not a string");
385 }
386
387 void unpack_json(match_t &v) {
388 if (auto *s = json->to<JsonString>())
389 s->c_str() >> v;
390 else
391 error("match name not a string");
392 }
393
394 template <typename T>
395 std::enable_if_t<has_fromJSON<T>::value && !std::is_base_of_v<IR::INode, T> &&
396 std::is_pointer_v<decltype(T::fromJSON(std::declval<JSONLoader &>()))>>
397 unpack_json(T *&v) {
398 v = T::fromJSON(*this);
399 }
400
401 template <typename T>
402 std::enable_if_t<has_fromJSON<T>::value && !std::is_base_of_v<IR::INode, T> &&
403 std::is_pointer_v<decltype(T::fromJSON(std::declval<JSONLoader &>()))>>
404 unpack_json(T &v) {
405 v = *(T::fromJSON(*this));
406 }
407
408 template <typename T>
409 std::enable_if_t<has_fromJSON<T>::value && !std::is_base_of<IR::INode, T>::value &&
410 !std::is_pointer_v<decltype(T::fromJSON(std::declval<JSONLoader &>()))>>
411 unpack_json(T &v) {
412 v = T::fromJSON(*this);
413 }
414
415 template <typename T>
416 std::enable_if_t<has_fromJSON<T>::value && !std::is_base_of<IR::INode, T>::value &&
417 !std::is_pointer_v<decltype(T::fromJSON(std::declval<JSONLoader &>()))>>
418 unpack_json(T *&v) {
419 v = new T(T::fromJSON(*this));
420 }
421
422 template <typename T>
423 std::enable_if_t<std::is_base_of_v<IR::INode, T>> unpack_json(T &v) {
424 v = get_node()->as<T>();
425 }
426 template <typename T>
427 std::enable_if_t<std::is_base_of_v<IR::INode, T>> unpack_json(const T *&v) {
428 v = get_node()->checkedTo<T>();
429 }
430
431 template <typename T, size_t N>
432 void unpack_json(T (&v)[N]) {
433 if (auto *j = json->to<JsonVector>()) {
434 for (size_t i = 0; i < N && i < j->size(); ++i) {
435 load(j->at(i), v[i]);
436 }
437 }
438 }
439
440 public:
441 template <typename T>
442 void load(const JsonData &json, T &v) {
443 JSONLoader(&json, node_refs, locinfo).unpack_json(v);
444 }
445
446 template <typename T>
447 void load(const std::unique_ptr<JsonData> &json, T &v) {
448 JSONLoader(json.get(), node_refs, locinfo).unpack_json(v);
449 }
450
451 template <typename T>
452 bool load(std::string_view field, T *&v) {
453 if (auto loader = JSONLoader(*this, field)) {
454 loader.unpack_json(v);
455 return true;
456 } else {
457 v = nullptr;
458 return false;
459 }
460 }
461
462 template <typename T>
463 bool load(std::string_view field, T &v) {
464 if (auto loader = JSONLoader(*this, field)) {
465 loader.unpack_json(v);
466 return true;
467 }
468 return false;
469 }
470
471 template <typename T>
472 JSONLoader &operator>>(T &v) {
473 unpack_json(v);
474 return *this;
475 }
476};
477
478template <class T>
479IR::Vector<T>::Vector(JSONLoader &json) : VectorBase(json) {
480 json.load("vec", vec) || json.error("missing field vec");
481}
482template <class T>
483IR::Node *IR::Vector<T>::fromJSON(JSONLoader &json) {
484 return new Vector<T>(json);
485}
486template <class T>
487IR::IndexedVector<T>::IndexedVector(JSONLoader &json) : Vector<T>(json) {
488 json.load("declarations", declarations) || json.error("missing field declarations");
489}
490template <class T>
491IR::Node *IR::IndexedVector<T>::fromJSON(JSONLoader &json) {
492 return new IndexedVector<T>(json);
493}
494template <class T, template <class K, class V, class COMP, class ALLOC> class MAP /*= std::map */,
495 class COMP /*= std::less<cstring>*/,
496 class ALLOC /*= std::allocator<std::pair<cstring, const T*>>*/>
497IR::NameMap<T, MAP, COMP, ALLOC>::NameMap(JSONLoader &json) : Node(json) {
498 json.load("symbols", symbols) || json.error("missing field symbols");
499}
500template <class T, template <class K, class V, class COMP, class ALLOC> class MAP /*= std::map */,
501 class COMP /*= std::less<cstring>*/,
502 class ALLOC /*= std::allocator<std::pair<cstring, const T*>>*/>
503IR::Node *IR::NameMap<T, MAP, COMP, ALLOC>::fromJSON(JSONLoader &json) {
504 return new IR::NameMap<T, MAP, COMP, ALLOC>(json);
505}
506
507} // namespace P4
508
509#endif /* IR_JSON_LOADER_H_ */
const T & as() const
Tries to convert the class to type T. A BUG occurs if the cast fails.
Definition castable.h:33
Definition indexed_vector.h:31
Definition namemap.h:29
Definition node.h:44
Definition ir/vector.h:50
Definition json_loader.h:34
Definition json_parser.h:46
Definition json_parser.h:22
Definition json_parser.h:117
Definition json_parser.h:106
Definition json_parser.h:82
Definition json_parser.h:95
Definition ltbitmatrix.h:16
Definition bitvec.h:111
Definition cstring.h:76
Definition ordered_map.h:23
Definition ordered_set.h:23
Definition safe_vector.h:18
Definition string_map.h:41
TODO: this is not really specific to BMV2, it should reside somewhere else.
Definition applyOptionsPragmas.cpp:13
Definition bson.cpp:69
Definition id.h:19
Definition json_parser.h:37
T * to() noexcept
Definition rtti.h:226
Definition match.h:27