Debian Codegraph @

modules/lsp-runtime-lib/src/main/fmt/json/dom.cpp

raw
1 /*
2 * Copyright (C) 2024 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2024 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 15 февр. 2021 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/fmt/json/dom.h>
23 #include <lsp-plug.in/fmt/json/Parser.h>
24 #include <lsp-plug.in/fmt/json/Serializer.h>
25
26 namespace lsp
27 {
28 namespace json
29 {
30 //---------------------------------------------------------------------
31 // JSON DOM deserialization routines
32 status_t dom_drop_stack(lltl::parray<Node> *stack, status_t res)
33 {
34 for (size_t i=0, n=stack->size(); i<n; ++i)
35 {
36 Node *node = stack->uget(i);
37 if (node != NULL)
38 delete node;
39 }
40 stack->flush();
41
42 return res;
43 }
44
45 status_t dom_parse_item(Node **dst, lltl::parray<Node> *stack, const event_t *ev)
46 {
47 Node *out = NULL;
48
49 switch (ev->type)
50 {
51 case JE_OBJECT_START:
52 out = json::Object::allocate();
53 break;
54 case JE_ARRAY_START:
55 out = json::Array::allocate();
56 break;
57 case JE_STRING:
58 out = json::String::allocate(&ev->sValue);
59 break;
60 case JE_INTEGER:
61 out = json::Integer::allocate(ev->iValue);
62 break;
63 case JE_DOUBLE:
64 out = json::Double::allocate(ev->fValue);
65 break;
66 case JE_BOOL:
67 out = json::Boolean::allocate(ev->bValue);
68 break;
69 case JE_NULL:
70 out = json::Node::allocate();
71 break;
72 default:
73 return STATUS_BAD_FORMAT;
74 }
75
76 // Check result
77 if (out == NULL)
78 return STATUS_NO_MEM;
79 *dst = out;
80
81 return STATUS_OK;
82 }
83
84 status_t dom_parse(Parser *p, Node *node, bool strict)
85 {
86 Node out, *xnode = NULL;
87 event_t ev;
88 status_t res;
89 lltl::parray<Node> stack;
90
91 // Initialize tree
92 do
93 {
94 Node *last = stack.last();
95 Node::node_type_t type = (last != NULL) ? last->type() : Node::JN_NULL;
96
97 // Read next event
98 if ((res = p->read_next(&ev)) != STATUS_OK)
99 return dom_drop_stack(&stack, res);
100
101 switch (type)
102 {
103 case Node::JN_ARRAY:
104 {
105 // Pre-check tokens
106 if (ev.type == JE_ARRAY_END)
107 {
108 stack.pop();
109 if (stack.is_empty())
110 out.assign(last);
111 delete last;
112 break;
113 }
114 else if ((ev.type == JE_OBJECT_END) || (ev.type == JE_PROPERTY))
115 return dom_drop_stack(&stack, STATUS_BAD_FORMAT);
116
117 Array ao(last);
118
119 // Parse simple item from event
120 if ((res = dom_parse_item(&xnode, &stack, &ev)) != STATUS_OK)
121 return dom_drop_stack(&stack, res);
122
123 if ((res = ao.add(xnode)) != STATUS_OK)
124 {
125 delete xnode;
126 return dom_drop_stack(&stack, res);
127 }
128
129 break;
130 }
131 case Node::JN_OBJECT:
132 {
133 // Pre-check tokens
134 if (ev.type == JE_OBJECT_END)
135 {
136 stack.pop();
137 if (stack.is_empty())
138 out.assign(last);
139 delete last;
140 break;
141 }
142 else if (ev.type != JE_PROPERTY)
143 return dom_drop_stack(&stack, STATUS_BAD_FORMAT);
144
145 // Validate and remember the property name
146 Object jo(last);
147 if (jo.contains(&ev.sValue)) // Check that object already contains such key
148 return dom_drop_stack(&stack, STATUS_BAD_FORMAT);
149 LSPString key;
150 if (!key.set(&ev.sValue))
151 return dom_drop_stack(&stack, STATUS_NO_MEM);
152
153 // Read next event
154 if ((res = p->read_next(&ev)) != STATUS_OK)
155 return dom_drop_stack(&stack, res);
156
157 // Parse simple item from event
158 if ((res = dom_parse_item(&xnode, &stack, &ev)) != STATUS_OK)
159 return dom_drop_stack(&stack, res);
160 if ((res = jo.set(&key, xnode)) != STATUS_OK)
161 {
162 delete xnode;
163 return dom_drop_stack(&stack, res);
164 }
165
166 break;
167 }
168
169 default:
170 {
171 // Parse simple item
172 if ((res = dom_parse_item(&xnode, &stack, &ev)) != STATUS_OK)
173 return dom_drop_stack(&stack, res);
174
175 break;
176 }
177 }
178
179 // Add extra node to the stack if it is present
180 if (xnode != NULL)
181 {
182 if ((xnode->is_array()) || (xnode->is_object()))
183 {
184 if (!stack.push(xnode))
185 {
186 delete xnode;
187 return dom_drop_stack(&stack, STATUS_NO_MEM);
188 }
189 }
190 else
191 delete xnode;
192 xnode = NULL;
193 }
194
195 } while (stack.size() > 0);
196
197 // Check for EOF
198 if (strict)
199 {
200 if ((res = p->read_next(&ev)) != STATUS_EOF)
201 return dom_drop_stack(&stack, STATUS_BAD_FORMAT);
202 }
203
204 // Assign node and return
205 node->assign(out);
206
207 return STATUS_OK;
208 }
209
210 status_t dom_load(const char *path, Node *node, json_version_t version, const char *charset)
211 {
212 Parser p;
213 Node tmp;
214 status_t res = p.open(path, version, charset);
215 if (res == STATUS_OK)
216 res = dom_parse(&p, &tmp, true);
217
218 if (res == STATUS_OK)
219 res = p.close();
220 else
221 p.close();
222
223 if (res == STATUS_OK)
224 node->assign(tmp);
225
226 return res;
227 }
228
229 status_t dom_load(const LSPString *path, Node *node, json_version_t version, const char *charset)
230 {
231 Parser p;
232 Node tmp;
233 status_t res = p.open(path, version, charset);
234 if (res == STATUS_OK)
235 res = dom_parse(&p, &tmp, true);
236
237 if (res == STATUS_OK)
238 res = p.close();
239 else
240 p.close();
241
242 if (res == STATUS_OK)
243 node->assign(tmp);
244
245 return res;
246 }
247
248 status_t dom_load(const io::Path *path, Node *node, json_version_t version, const char *charset)
249 {
250 Parser p;
251 Node tmp;
252 status_t res = p.open(path, version, charset);
253 if (res == STATUS_OK)
254 res = dom_parse(&p, &tmp, true);
255
256 if (res == STATUS_OK)
257 res = p.close();
258 else
259 p.close();
260
261 if (res == STATUS_OK)
262 node->assign(tmp);
263
264 return res;
265 }
266
267 size_t build_wflags(size_t flags)
268 {
269 size_t wflags = 0;
270 if (flags & DOM_CLOSE)
271 wflags |= WRAP_CLOSE;
272 if (flags & DOM_DELETE)
273 wflags |= WRAP_DELETE;
274 return wflags;
275 }
276
277 status_t dom_parse(io::IInStream *is, Node *node, json_version_t version, size_t flags, const char *charset)
278 {
279 Parser p;
280 Node tmp;
281
282 size_t wflags = build_wflags(flags);
283 status_t res = p.wrap(is, version, wflags, charset);
284 if (res == STATUS_OK)
285 res = dom_parse(&p, &tmp, !(flags & DOM_FLEXIBLE));
286
287 if (res == STATUS_OK)
288 res = p.close();
289 else
290 p.close();
291
292 if (res == STATUS_OK)
293 node->assign(tmp);
294
295 return res;
296 }
297
298 status_t dom_parse(const LSPString *data, Node *node, json_version_t version)
299 {
300 Parser p;
301 Node tmp;
302
303 status_t res = p.wrap(data, version);
304 if (res == STATUS_OK)
305 res = dom_parse(&p, &tmp, true);
306
307 if (res == STATUS_OK)
308 res = p.close();
309 else
310 p.close();
311
312 if (res == STATUS_OK)
313 node->assign(tmp);
314
315 return res;
316 }
317
318 status_t dom_parse(const char *data, Node *node, json_version_t version, size_t flags, const char *charset)
319 {
320 Parser p;
321 Node tmp;
322
323 status_t res = p.wrap(data, version, charset);
324 if (res == STATUS_OK)
325 res = dom_parse(&p, &tmp, true);
326
327 if (res == STATUS_OK)
328 res = p.close();
329 else
330 p.close();
331
332 if (res == STATUS_OK)
333 node->assign(tmp);
334
335 return res;
336 }
337
338 status_t dom_parse(io::IInSequence *is, Node *node, json_version_t version, size_t flags)
339 {
340 Parser p;
341 Node tmp;
342
343 size_t wflags = build_wflags(flags);
344 status_t res = p.wrap(is, version, wflags);
345 if (res == STATUS_OK)
346 res = dom_parse(&p, &tmp, !(flags & DOM_FLEXIBLE));
347
348 if (res == STATUS_OK)
349 res = p.close();
350 else
351 p.close();
352
353 if (res == STATUS_OK)
354 node->assign(tmp);
355
356 return res;
357 }
358
359 //---------------------------------------------------------------------
360 // JSON DOM serialization routines
361 status_t dom_serialize(Serializer *s, const Node *node)
362 {
363 status_t res;
364
365 switch (node->type())
366 {
367 case Node::JN_NULL: return s->write_null();
368 case Node::JN_INT: return s->write_int(lsp::fixed_int(node->as_int().get()));
369 case Node::JN_DOUBLE: return s->write_double(node->as_double().get());
370 case Node::JN_BOOL: return s->write_bool(node->as_bool().get());
371 case Node::JN_STRING:
372 {
373 LSPString str;
374 if ((res = node->as_string().get(&str)) != STATUS_OK)
375 return res;
376 return s->write_string(&str);
377 }
378
379 case Node::JN_ARRAY:
380 {
381 // Start the array
382 if ((res = s->start_array()) != STATUS_OK)
383 return res;
384
385 // Serialize the array
386 Array av = node;
387 for (size_t i=0, n=av.size(); i<n; ++i)
388 {
389 Node an = av.get(i);
390 if ((res = dom_serialize(s, &an)) != STATUS_OK)
391 return res;
392 }
393
394 // Complete the array
395 return s->end_array();
396 }
397
398 case Node::JN_OBJECT:
399 {
400 // Start the object
401 if ((res = s->start_object()) != STATUS_OK)
402 return res;
403
404 lltl::parray<LSPString> fields;
405
406 // Serialize the object
407 Object ov = node;
408 if ((res = ov.fields(&fields)) != STATUS_OK)
409 return res;
410
411 // Sort list of fields
412 fields.qsort();
413
414 for (size_t i=0, n=fields.size(); i<n; ++i)
415 {
416 const LSPString *field = fields.uget(i);
417 if (field == NULL)
418 return STATUS_CORRUPTED;
419
420 // Property name
421 if ((res = s->write_property(field)) != STATUS_OK)
422 return res;
423
424 // Property value
425 Node on = ov.get(field);
426 if ((res = dom_serialize(s, &on)) != STATUS_OK)
427 return res;
428 }
429
430 // Complete the object
431 return s->end_object();
432 }
433
434 default:
435 break;
436 }
437
438 return STATUS_CORRUPTED;
439 }
440
441 status_t dom_save(const char *path, const Node *node, const serial_flags_t *settings, const char *charset)
442 {
443 Serializer s;
444
445 status_t res = s.open(path, settings, charset);
446 if (res == STATUS_OK)
447 res = dom_serialize(&s, node);
448
449 status_t xres = s.close();
450 return (res != STATUS_OK) ? res : xres;
451 }
452
453 status_t dom_save(const LSPString *path, const Node *node, const serial_flags_t *settings, const char *charset)
454 {
455 Serializer s;
456
457 status_t res = s.open(path, settings, charset);
458 if (res == STATUS_OK)
459 res = dom_serialize(&s, node);
460
461 status_t xres = s.close();
462 return (res != STATUS_OK) ? res : xres;
463 }
464
465 status_t dom_save(const io::Path *path, const Node *node, const serial_flags_t *settings, const char *charset)
466 {
467 Serializer s;
468
469 status_t res = s.open(path, settings, charset);
470 if (res == STATUS_OK)
471 res = dom_serialize(&s, node);
472
473 status_t xres = s.close();
474 return (res != STATUS_OK) ? res : xres;
475 }
476
477 status_t dom_write(io::IOutStream *os, const Node *node, const serial_flags_t *settings, size_t flags, const char *charset)
478 {
479 Serializer s;
480
481 status_t res = s.wrap(os, settings, flags, charset);
482 if (res == STATUS_OK)
483 res = dom_serialize(&s, node);
484
485 status_t xres = s.close();
486 return (res != STATUS_OK) ? res : xres;
487 }
488
489 status_t dom_write(LSPString *data, const Node *node, const serial_flags_t *settings)
490 {
491 Serializer s;
492
493 status_t res = s.wrap(data, settings);
494 if (res == STATUS_OK)
495 res = dom_serialize(&s, node);
496
497 status_t xres = s.close();
498 return (res != STATUS_OK) ? res : xres;
499 }
500
501 status_t dom_write(io::IOutSequence *os, const Node *node, const serial_flags_t *settings, size_t flags)
502 {
503 Serializer s;
504
505 status_t res = s.wrap(os, settings, flags);
506 if (res == STATUS_OK)
507 res = dom_serialize(&s, node);
508
509 status_t xres = s.close();
510 return (res != STATUS_OK) ? res : xres;
511 }
512
513 } /* namespace json */
514 } /* namespace lsp */
515