Debian Codegraph @

modules/lsp-runtime-lib/src/main/fmt/json/Serializer.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: 17 окт. 2019 г.
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/io/File.h>
23 #include <lsp-plug.in/io/OutFileStream.h>
24 #include <lsp-plug.in/io/OutStringSequence.h>
25 #include <lsp-plug.in/io/OutSequence.h>
26 #include <lsp-plug.in/fmt/json/Tokenizer.h>
27 #include <lsp-plug.in/fmt/json/Serializer.h>
28 #include <lsp-plug.in/stdlib/stdio.h>
29 #include <lsp-plug.in/stdlib/math.h>
30 #include <lsp-plug.in/stdlib/locale.h>
31
32 namespace lsp
33 {
34 namespace json
35 {
36
37 Serializer::Serializer()
38 {
39 pOut = NULL;
40 nWFlags = 0;
41 sState.mode = WRITE_ROOT;
42 sState.flags = 0;
43 sState.ident = 0;
44
45 init_serial_flags(&sSettings);
46 }
47
48 Serializer::~Serializer()
49 {
50 close();
51 }
52
53 status_t Serializer::open(const char *path, const serial_flags_t *settings, const char *charset)
54 {
55 if (pOut != NULL)
56 return STATUS_BAD_STATE;
57 else if (path == NULL)
58 return STATUS_BAD_ARGUMENTS;
59
60 io::OutFileStream *ofs = new io::OutFileStream();
61 if (ofs == NULL)
62 return STATUS_NO_MEM;
63 status_t res = ofs->open(path, io::File::FM_WRITE | io::File::FM_TRUNC | io::File::FM_CREATE);
64 if (res == STATUS_OK)
65 {
66 res = wrap(ofs, settings, WRAP_CLOSE | WRAP_DELETE, charset);
67 if (res == STATUS_OK)
68 return res;
69 ofs->close();
70 }
71 delete ofs;
72
73 return res;
74 }
75
76 status_t Serializer::open(const LSPString *path, const serial_flags_t *settings, const char *charset)
77 {
78 if (pOut != NULL)
79 return STATUS_BAD_STATE;
80 else if (path == NULL)
81 return STATUS_BAD_ARGUMENTS;
82
83 io::OutFileStream *ofs = new io::OutFileStream();
84 if (ofs == NULL)
85 return STATUS_NO_MEM;
86 status_t res = ofs->open(path, io::File::FM_WRITE | io::File::FM_TRUNC | io::File::FM_CREATE);
87 if (res == STATUS_OK)
88 {
89 res = wrap(ofs, settings, WRAP_CLOSE | WRAP_DELETE, charset);
90 if (res == STATUS_OK)
91 return res;
92 ofs->close();
93 }
94 delete ofs;
95
96 return res;
97 }
98
99 status_t Serializer::open(const io::Path *path, const serial_flags_t *settings, const char *charset)
100 {
101 if (pOut != NULL)
102 return STATUS_BAD_STATE;
103 else if (path == NULL)
104 return STATUS_BAD_ARGUMENTS;
105
106 io::OutFileStream *ofs = new io::OutFileStream();
107 if (ofs == NULL)
108 return STATUS_NO_MEM;
109 status_t res = ofs->open(path, io::File::FM_WRITE | io::File::FM_TRUNC | io::File::FM_CREATE);
110 if (res == STATUS_OK)
111 {
112 res = wrap(ofs, settings, WRAP_CLOSE | WRAP_DELETE, charset);
113 if (res == STATUS_OK)
114 return res;
115 ofs->close();
116 }
117 delete ofs;
118
119 return res;
120 }
121
122 void Serializer::copy_settings(const serial_flags_t *flags)
123 {
124 if (flags == NULL)
125 init_serial_flags(&sSettings);
126 else
127 sSettings = *flags;
128 }
129
130 status_t Serializer::wrap(LSPString *str, const serial_flags_t *settings)
131 {
132 if (pOut != NULL)
133 return STATUS_BAD_STATE;
134 else if (str == NULL)
135 return STATUS_BAD_ARGUMENTS;
136
137 io::OutStringSequence *seq = new io::OutStringSequence(str, false);
138 if (seq == NULL)
139 return STATUS_NO_MEM;
140
141 status_t res = wrap(seq, settings, WRAP_CLOSE | WRAP_DELETE);
142 if (res == STATUS_OK)
143 return res;
144
145 seq->close();
146 delete seq;
147
148 return res;
149 }
150
151 status_t Serializer::wrap(io::IOutStream *os, const serial_flags_t *settings, size_t flags, const char *charset)
152 {
153 if (pOut != NULL)
154 return STATUS_BAD_STATE;
155 else if (os == NULL)
156 return STATUS_BAD_ARGUMENTS;
157
158 io::OutSequence *seq = new io::OutSequence();
159 if (seq == NULL)
160 return STATUS_NO_MEM;
161
162 status_t res = seq->wrap(os, flags, charset);
163 if (res == STATUS_OK)
164 {
165 if ((res = wrap(seq, settings, WRAP_CLOSE | WRAP_DELETE)) == STATUS_OK)
166 return res;
167 seq->close();
168 }
169
170 delete seq;
171 return res;
172 }
173
174 status_t Serializer::wrap(io::IOutSequence *seq, const serial_flags_t *settings, size_t flags)
175 {
176 if (pOut != NULL)
177 return STATUS_BAD_STATE;
178 else if (seq == NULL)
179 return STATUS_BAD_ARGUMENTS;
180
181 pOut = seq;
182 nWFlags = flags;
183 sState.mode = WRITE_ROOT;
184 sState.flags = 0;
185 copy_settings(settings);
186
187 return STATUS_OK;
188 }
189
190 status_t Serializer::close()
191 {
192 status_t res = STATUS_OK;
193
194 // Close handles
195 if (pOut != NULL)
196 {
197 if (nWFlags & WRAP_CLOSE)
198 res = pOut->close();
199
200 if (nWFlags & WRAP_DELETE)
201 delete pOut;
202
203 pOut = NULL;
204 }
205
206 sStack.flush();
207
208 return res;
209 }
210
211 status_t Serializer::push_state(pmode_t mode)
212 {
213 if (!sStack.add(&sState))
214 return STATUS_NO_MEM;
215
216 sState.mode = mode;
217 sState.flags = 0;
218 sState.ident += sSettings.padding;
219 return STATUS_OK;
220 }
221
222 status_t Serializer::pop_state()
223 {
224 state_t *st = sStack.last();
225 if (st == NULL)
226 return STATUS_BAD_STATE;
227
228 sState = *st;
229 return (sStack.pop()) ? STATUS_OK : STATUS_BAD_STATE;
230 }
231
232 status_t Serializer::write_comma()
233 {
234 if (pOut == NULL)
235 return STATUS_BAD_STATE;
236
237 switch (sState.mode)
238 {
239 case WRITE_ROOT:
240 return STATUS_INVALID_VALUE;
241 case WRITE_ARRAY:
242 case WRITE_OBJECT:
243 if ((sState.flags & (SF_VALUE | SF_COMMA)) != SF_VALUE)
244 return STATUS_INVALID_VALUE;
245 break;
246 default:
247 return STATUS_BAD_STATE;
248 }
249
250 sState.flags |= SF_COMMA;
251 return pOut->write(',');
252 }
253
254 status_t Serializer::writeln()
255 {
256 if (!sSettings.multiline)
257 return STATUS_OK;
258
259 sState.flags &= ~SF_CONTENT;
260 status_t res = pOut->write('\n');
261 if (res != STATUS_OK)
262 return res;
263 for (size_t i=0, n=sState.ident; i<n; ++i)
264 {
265 if ((res = pOut->write(sSettings.ident)) != STATUS_OK)
266 break;
267 }
268
269 return res;
270 }
271
272 char Serializer::hex(int x)
273 {
274 return ((x &= 0x0f) < 10) ? (x + '0') : (x + 'A' - 10);
275 }
276
277 status_t Serializer::write(const event_t *event)
278 {
279 if (event == NULL)
280 return STATUS_BAD_ARGUMENTS;
281
282 switch (event->type)
283 {
284 case JE_OBJECT_START: return start_object();
285 case JE_OBJECT_END: return end_object();
286 case JE_ARRAY_START: return start_array();
287 case JE_ARRAY_END: return end_array();
288 case JE_PROPERTY: return write_property(&event->sValue);
289 case JE_STRING: return write_string(&event->sValue);
290 case JE_INTEGER: return write_int(lsp::fixed_int(event->iValue));
291 case JE_DOUBLE: return write_double(event->fValue);
292 case JE_BOOL: return write_bool(event->bValue);
293 case JE_NULL: return write_null();
294 default: break;
295 }
296
297 return STATUS_BAD_ARGUMENTS;
298 }
299
300 status_t Serializer::emit_comma()
301 {
302 if ((sState.flags & (SF_VALUE | SF_COMMA)) != SF_VALUE)
303 return STATUS_OK;
304 sState.flags |= SF_CONTENT;
305 return pOut->write(',');
306 }
307
308 status_t Serializer::emit_separator()
309 {
310 if ((!sSettings.separator) || (!(sState.flags & SF_CONTENT)))
311 return STATUS_OK;
312 return pOut->write(' ');
313 }
314
315 status_t Serializer::write_raw(const char *buf, int len)
316 {
317 status_t res = STATUS_OK;
318
319 switch (sState.mode)
320 {
321 case WRITE_ROOT:
322 if (sState.flags & SF_VALUE)
323 return STATUS_INVALID_VALUE;
324 break;
325 case WRITE_ARRAY:
326 if ((res = emit_comma()) == STATUS_OK)
327 res = writeln();
328 break;
329 case WRITE_OBJECT:
330 if (!(sState.flags & SF_PROPERTY))
331 return STATUS_INVALID_VALUE;
332 sState.flags &= ~SF_PROPERTY;
333 break;
334 default:
335 return STATUS_BAD_STATE;
336 }
337 if (res == STATUS_OK)
338 res = emit_separator();
339
340 sState.flags &= ~SF_COMMA;
341 sState.flags |= SF_VALUE | SF_CONTENT;
342
343 return (res == STATUS_OK) ? pOut->write_ascii(buf, len) : res;
344 }
345
346 status_t Serializer::write_int(int32_t value)
347 {
348 if (pOut == NULL)
349 return STATUS_BAD_STATE;
350
351 char buf[0x20];
352 int len = ::snprintf(buf, sizeof(buf), "%ld", (long)value);
353 return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
354 }
355
356 status_t Serializer::write_int(uint32_t value)
357 {
358 if (pOut == NULL)
359 return STATUS_BAD_STATE;
360
361 char buf[0x20];
362 int len = ::snprintf(buf, sizeof(buf), "%lu", (unsigned long)value);
363 return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
364 }
365
366 status_t Serializer::write_int(int64_t value)
367 {
368 if (pOut == NULL)
369 return STATUS_BAD_STATE;
370
371 char buf[0x20];
372 int len = ::snprintf(buf, sizeof(buf), "%lld", (long long)value);
373 return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
374 }
375
376 status_t Serializer::write_int(uint64_t value)
377 {
378 if (pOut == NULL)
379 return STATUS_BAD_STATE;
380
381 char buf[0x20];
382 int len = ::snprintf(buf, sizeof(buf), "%llu", (unsigned long long)value);
383 return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
384 }
385
386 status_t Serializer::write_hex(int32_t value)
387 {
388 if (pOut == NULL)
389 return STATUS_BAD_STATE;
390 else if (sSettings.version < JSON_VERSION5)
391 return STATUS_INVALID_VALUE;
392
393 char buf[0x20];
394 int len = (value < 0) ?
395 ::snprintf(buf, sizeof(buf), "-0x%lx", (long)(-value)) :
396 ::snprintf(buf, sizeof(buf), "0x%lx", (long)value);
397 return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
398 }
399
400 status_t Serializer::write_hex(uint32_t value)
401 {
402 if (pOut == NULL)
403 return STATUS_BAD_STATE;
404 else if (sSettings.version < JSON_VERSION5)
405 return STATUS_INVALID_VALUE;
406
407 char buf[0x20];
408 int len = ::snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)value);
409 return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
410 }
411
412 status_t Serializer::write_hex(int64_t value)
413 {
414 if (pOut == NULL)
415 return STATUS_BAD_STATE;
416 else if (sSettings.version < JSON_VERSION5)
417 return STATUS_INVALID_VALUE;
418
419 char buf[0x20];
420 int len = (value < 0) ?
421 ::snprintf(buf, sizeof(buf), "-0x%llx", (long long)(-value)) :
422 ::snprintf(buf, sizeof(buf), "0x%llx", (long long)value);
423 return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
424 }
425
426 status_t Serializer::write_hex(uint64_t value)
427 {
428 if (pOut == NULL)
429 return STATUS_BAD_STATE;
430 else if (sSettings.version < JSON_VERSION5)
431 return STATUS_INVALID_VALUE;
432
433 char buf[0x20];
434 int len = ::snprintf(buf, sizeof(buf), "0x%llx", (unsigned long long)value);
435 return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
436 }
437
438 status_t Serializer::write_double(double value)
439 {
440 if (pOut == NULL)
441 return STATUS_BAD_STATE;
442
443 if (isnan(value))
444 return write_raw("NaN", 3);
445 else if (isinf(value))
446 return (value < 0.0) ? write_raw("-Infinity", 9) : write_raw("Infinity", 8);
447
448 char buf[0x20];
449 const char *fmt = (sSettings.fmt_double != NULL) ? sSettings.fmt_double : "%f";
450 int len = ::snprintf(buf, sizeof(buf), fmt, value);
451 return (len < int(sizeof(buf))) ? write_raw(buf, len) : STATUS_OVERFLOW;
452 }
453
454 status_t Serializer::write_double(double value, const char *fmt)
455 {
456 if (pOut == NULL)
457 return STATUS_BAD_STATE;
458
459 if (isnan(value))
460 return write_raw("NaN", 3);
461 else if (isinf(value))
462 return (value < 0.0) ? write_raw("-Infinity", 9) : write_raw("Infinity", 8);
463
464 SET_LOCALE_SCOPED(LC_NUMERIC, "C"); // For proper decimal point
465
466 char *buf = NULL;
467 int len = asprintf(&buf, fmt, value);
468 if (buf == NULL)
469 return STATUS_NO_MEM;
470
471 status_t res = (len >= 0) ? write_raw(buf, len) : STATUS_NO_DATA;
472 ::free(buf);
473 return res;
474 }
475
476 status_t Serializer::write_bool(bool value)
477 {
478 if (pOut == NULL)
479 return STATUS_BAD_STATE;
480 return (value) ? write_raw("true", 4) : write_raw("false", 5);
481 }
482
483 status_t Serializer::write_null()
484 {
485 if (pOut == NULL)
486 return STATUS_BAD_STATE;
487 return write_raw("null", 4);
488 }
489
490 status_t Serializer::write_string(const char *value, const char *charset)
491 {
492 if (value == NULL)
493 return write_null();
494
495 LSPString tmp;
496 return (tmp.set_native(value, charset)) ? write_string(&tmp) : STATUS_NO_MEM;
497 }
498
499 status_t Serializer::write_string(const char *value)
500 {
501 if (value == NULL)
502 return write_null();
503
504 LSPString tmp;
505 return (tmp.set_utf8(value)) ? write_string(&tmp) : STATUS_NO_MEM;
506 }
507
508 status_t Serializer::write_string(const LSPString *value)
509 {
510 if (value == NULL)
511 return write_null();
512 else if (pOut == NULL)
513 return STATUS_BAD_STATE;
514
515 // Analyze state
516 status_t res = STATUS_OK;
517
518 switch (sState.mode)
519 {
520 case WRITE_ROOT:
521 if (sState.flags & SF_VALUE)
522 return STATUS_INVALID_VALUE;
523 break;
524 case WRITE_ARRAY:
525 if ((res = emit_comma()) == STATUS_OK)
526 res = writeln();
527 break;
528 case WRITE_OBJECT:
529 if (!(sState.flags & SF_PROPERTY))
530 return STATUS_INVALID_VALUE;
531 sState.flags &= ~SF_PROPERTY;
532 break;
533 default:
534 return STATUS_BAD_STATE;
535 }
536 if (res == STATUS_OK)
537 res = emit_separator();
538
539 sState.flags &= ~SF_COMMA;
540 sState.flags |= SF_VALUE | SF_CONTENT;
541
542 return (res == STATUS_OK) ? write_literal(value) : res;
543 }
544
545 status_t Serializer::write_literal(const LSPString *value)
546 {
547 status_t res;
548 size_t last = 0, curr = 0, bl = 1;
549 char xb[0x10];
550 xb[0] = '\\';
551
552 // Output start quote
553 sState.flags |= SF_CONTENT;
554 if ((res = pOut->write('\"')) != STATUS_OK)
555 return res;
556
557 for (size_t n=value->length(); curr<n; ++curr)
558 {
559 lsp_wchar_t ch = value->char_at(curr);
560
561 // Check that we need to escape character
562 switch (ch)
563 {
564 case '\0': xb[bl++] = '0'; break;
565 case '\b': xb[bl++] = 'b'; break;
566 case '\f': xb[bl++] = 'f'; break;
567 case '\r': xb[bl++] = 'r'; break;
568 case '\t': xb[bl++] = 't'; break;
569 case '\v': xb[bl++] = 'v'; break;
570 case '\n': xb[bl++] = 'n'; break;
571 case '\\': xb[bl++] = '\\'; break;
572 case '\"': xb[bl++] = '\"'; break;
573 default:
574 if (ch < 0x20)
575 {
576 xb[1] = 'u';
577 xb[2] = '0';
578 xb[3] = '0';
579 xb[4] = hex(ch >> 4);
580 xb[5] = hex(ch);
581 bl = 6;
582 }
583 else if (ch >= 0x10000)
584 {
585 ch -= 0x10000;
586 lsp_wchar_t hi = 0xd800 | (ch >> 10);
587 lsp_wchar_t lo = 0xdc00 | (ch & 0x3ff);
588
589 xb[1] = 'u';
590 xb[2] = hex(hi >> 12);
591 xb[3] = hex(hi >> 8);
592 xb[4] = hex(hi >> 4);
593 xb[5] = hex(hi);
594 xb[6] = '\\';
595 xb[7] = 'u';
596 xb[8] = hex(lo >> 12);
597 xb[9] = hex(lo >> 8);
598 xb[10] = hex(lo >> 4);
599 xb[11] = hex(lo);
600 bl = 12;
601 }
602 break;
603 }
604
605 // Is there extra escape sequence?
606 if (bl > 1)
607 {
608 // Write string directly to output
609 if (last < curr)
610 {
611 if ((res = pOut->write(value, last, curr)) != STATUS_OK)
612 return res;
613 }
614
615 // Append escape sequence and reset extra buffer size
616 if ((res = pOut->write_ascii(xb, bl)) != STATUS_OK)
617 return res;
618
619 last = curr+1; // Put buffer pointer to the next character
620 bl = 1;
621 }
622 }
623
624 // Need to emit extra data?
625 if (last < curr)
626 {
627 if ((res = pOut->write(value, last, curr)) != STATUS_OK)
628 return res;
629 }
630
631 // Output end quote
632 return pOut->write('\"');
633 }
634
635 status_t Serializer::write_comment(const char *value, const char *charset)
636 {
637 if (value == NULL)
638 return STATUS_BAD_ARGUMENTS;
639 LSPString tmp;
640 return (tmp.set_native(value, charset)) ? write_comment(&tmp) : STATUS_NO_MEM;
641 }
642
643 status_t Serializer::write_comment(const char *value)
644 {
645 if (value == NULL)
646 return STATUS_BAD_ARGUMENTS;
647 LSPString tmp;
648 return (tmp.set_utf8(value)) ? write_comment(&tmp) : STATUS_NO_MEM;
649 }
650
651 status_t Serializer::write_comment(const LSPString *value)
652 {
653 if (pOut == NULL)
654 return STATUS_BAD_STATE;
655 else if (value == NULL)
656 return STATUS_BAD_ARGUMENTS;
657 else if (sSettings.version < JSON_VERSION5)
658 return STATUS_INVALID_VALUE;
659
660 // Comment can be placed everywhere, we don't need to analyze state
661 status_t res;
662 lsp_swchar_t prev = -1;
663 size_t last = 0, curr = 0, bl = 4;
664 char xb[0x10];
665 xb[0] = '\\';
666 xb[1] = 'u';
667 xb[2] = '0';
668 xb[3] = '0';
669
670 // Output start quote
671 if ((res = emit_separator()) != STATUS_OK)
672 return res;
673
674 sState.flags |= SF_CONTENT;
675 if ((res = pOut->write_ascii("/*", 2)) != STATUS_OK)
676 return res;
677
678 for (size_t n=value->length(); curr<n; ++curr)
679 {
680 lsp_wchar_t ch = value->char_at(curr);
681
682 switch (ch)
683 {
684 case '\n':
685 case '\r':
686 if (sSettings.multiline)
687 break;
688 xb[bl++] = hex(ch >> 4);
689 xb[bl++] = hex(ch);
690 break;
691 case '/':
692 if (prev != '*')
693 break;
694 // Asterisk code in unicode
695 xb[bl++] = '2';
696 xb[bl++] = 'F';
697 break;
698 case '*':
699 if (prev != '/')
700 break;
701 // Asterisk code in unicode
702 xb[bl++] = '2';
703 xb[bl++] = 'A';
704 break;
705 default:
706 if (ch < 0x20)
707 {
708 xb[bl++] = hex(ch >> 4);
709 xb[bl++] = hex(ch);
710 }
711 break;
712 }
713
714 // Is there extra escape sequence?
715 if (bl > 4)
716 {
717 // Write string directly to output
718 if (last < curr)
719 {
720 if ((res = pOut->write(value, last, curr)) != STATUS_OK)
721 return res;
722 }
723
724 // Append escape sequence and reset extra buffer size
725 if ((res = pOut->write_ascii(xb, bl)) != STATUS_OK)
726 return res;
727 last = curr+1; // Put buffer pointer to the next character
728 bl = 4;
729 }
730
731 // Store previous character
732 prev = ch;
733 }
734
735 // Need to emit extra data?
736 if (last < curr)
737 {
738 if ((res = pOut->write(value, last, curr)) != STATUS_OK)
739 return res;
740 }
741
742 // Output end quote
743 return pOut->write_ascii("*/", 2);
744 }
745
746 status_t Serializer::write_property(const char *name, const char *charset)
747 {
748 if (name == NULL)
749 return STATUS_BAD_ARGUMENTS;
750 LSPString tmp;
751 return (tmp.set_native(name, charset)) ? write_property(&tmp) : STATUS_NO_MEM;
752 }
753
754 status_t Serializer::write_property(const char *name)
755 {
756 if (name == NULL)
757 return STATUS_BAD_ARGUMENTS;
758 LSPString tmp;
759 return (tmp.set_utf8(name)) ? write_property(&tmp) : STATUS_NO_MEM;
760 }
761
762 status_t Serializer::write_property(const LSPString *name)
763 {
764 if (name == NULL)
765 return STATUS_BAD_ARGUMENTS;
766 else if (pOut == NULL)
767 return STATUS_BAD_STATE;
768
769 status_t res;
770
771 switch (sState.mode)
772 {
773 case WRITE_OBJECT:
774 if (sState.flags & SF_PROPERTY)
775 return STATUS_INVALID_VALUE;
776 if ((res = emit_comma()) == STATUS_OK)
777 res = writeln();
778 if (res != STATUS_OK)
779 return res;
780 break;
781 default:
782 return STATUS_BAD_STATE;
783 }
784
785 sState.flags &= ~SF_COMMA;
786 sState.flags |= SF_PROPERTY | SF_CONTENT;
787
788 // Do we need to prefer identifiers instead of property name?
789 if ((sSettings.identifiers) && (sSettings.version >= JSON_VERSION5))
790 res = (Tokenizer::is_valid_identifier(name)) ? pOut->write(name) : write_literal(name);
791 else
792 res = write_literal(name);
793
794 // Write queued comment, colon and spacing
795 return (res == STATUS_OK) ? pOut->write(':') : res;
796 }
797
798 status_t Serializer::start_object()
799 {
800 if (pOut == NULL)
801 return STATUS_BAD_STATE;
802
803 status_t res = STATUS_OK;
804 switch (sState.mode)
805 {
806 case WRITE_ROOT:
807 if (sState.flags & SF_VALUE)
808 return STATUS_INVALID_VALUE;
809 break;
810 case WRITE_ARRAY:
811 if ((res = emit_comma()) == STATUS_OK)
812 res = writeln();
813 break;
814 case WRITE_OBJECT:
815 if (!(sState.flags & SF_PROPERTY))
816 return STATUS_INVALID_VALUE;
817 sState.flags &= ~SF_PROPERTY;
818 break;
819 default:
820 return STATUS_BAD_STATE;
821 }
822 if (res == STATUS_OK)
823 res = emit_separator();
824
825 sState.flags |= SF_VALUE | SF_CONTENT;
826 if (res == STATUS_OK)
827 res = pOut->write('{');
828 return (res == STATUS_OK) ? push_state(WRITE_OBJECT) : res;
829 }
830
831 status_t Serializer::end_object()
832 {
833 if ((pOut == NULL) || (sState.mode != WRITE_OBJECT) || (sState.flags & SF_PROPERTY))
834 return STATUS_BAD_STATE;
835 else if ((sState.flags & SF_COMMA) && (sSettings.version < JSON_VERSION5))
836 return STATUS_INVALID_VALUE;
837
838 bool data = sState.flags & SF_VALUE;
839 status_t res = pop_state();
840 if ((res == STATUS_OK) && (data))
841 res = writeln();
842
843 sState.flags &= ~SF_COMMA;
844 sState.flags |= SF_CONTENT;
845 return (res == STATUS_OK) ? pOut->write('}') : res;
846 }
847
848 status_t Serializer::start_array()
849 {
850 if (pOut == NULL)
851 return STATUS_BAD_STATE;
852
853 status_t res = STATUS_OK;
854 switch (sState.mode)
855 {
856 case WRITE_ROOT:
857 if (sState.flags & SF_VALUE)
858 return STATUS_INVALID_VALUE;
859 break;
860 case WRITE_ARRAY:
861 if ((res = emit_comma()) == STATUS_OK)
862 res = writeln();
863 break;
864 case WRITE_OBJECT:
865 if (!(sState.flags & SF_PROPERTY))
866 return STATUS_INVALID_VALUE;
867 sState.flags &= ~SF_PROPERTY;
868 break;
869 default:
870 return STATUS_BAD_STATE;
871 }
872 if (res == STATUS_OK)
873 res = emit_separator();
874
875 sState.flags |= SF_VALUE | SF_CONTENT;
876 if (res == STATUS_OK)
877 res = pOut->write('[');
878 return (res == STATUS_OK) ? push_state(WRITE_ARRAY) : res;
879 }
880
881 status_t Serializer::end_array()
882 {
883 if ((pOut == NULL) || (sState.mode != WRITE_ARRAY))
884 return STATUS_BAD_STATE;
885 else if ((sState.flags & SF_COMMA) && (sSettings.version < JSON_VERSION5))
886 return STATUS_INVALID_VALUE;
887
888 bool data = sState.flags & SF_VALUE;
889 status_t res = pop_state();
890 if ((res == STATUS_OK) && (data))
891 res = writeln();
892
893 sState.flags &= ~SF_COMMA;
894 sState.flags |= SF_CONTENT;
895 return (res == STATUS_OK) ? pOut->write(']') : res;
896 }
897
898 status_t Serializer::prop_int(const char *key, int32_t value)
899 {
900 status_t res = write_property(key);
901 return (res == STATUS_OK) ? write_int(value) : res;
902 }
903
904 status_t Serializer::prop_int(const LSPString *key, int32_t value)
905 {
906 status_t res = write_property(key);
907 return (res == STATUS_OK) ? write_int(value) : res;
908 }
909
910 status_t Serializer::prop_int(const char *key, uint32_t value)
911 {
912 status_t res = write_property(key);
913 return (res == STATUS_OK) ? write_int(value) : res;
914 }
915
916 status_t Serializer::prop_int(const LSPString *key, uint32_t value)
917 {
918 status_t res = write_property(key);
919 return (res == STATUS_OK) ? write_int(value) : res;
920 }
921
922 status_t Serializer::prop_int(const char *key, int64_t value)
923 {
924 status_t res = write_property(key);
925 return (res == STATUS_OK) ? write_int(value) : res;
926 }
927
928 status_t Serializer::prop_int(const LSPString *key, int64_t value)
929 {
930 status_t res = write_property(key);
931 return (res == STATUS_OK) ? write_int(value) : res;
932 }
933
934 status_t Serializer::prop_int(const char *key, uint64_t value)
935 {
936 status_t res = write_property(key);
937 return (res == STATUS_OK) ? write_int(value) : res;
938 }
939
940 status_t Serializer::prop_int(const LSPString *key, uint64_t value)
941 {
942 status_t res = write_property(key);
943 return (res == STATUS_OK) ? write_int(value) : res;
944 }
945
946 status_t Serializer::prop_hex(const char *key, int32_t value)
947 {
948 status_t res = write_property(key);
949 return (res == STATUS_OK) ? write_hex(value) : res;
950 }
951
952 status_t Serializer::prop_hex(const LSPString *key, int32_t value)
953 {
954 status_t res = write_property(key);
955 return (res == STATUS_OK) ? write_hex(value) : res;
956 }
957
958 status_t Serializer::prop_hex(const char *key, uint32_t value)
959 {
960 status_t res = write_property(key);
961 return (res == STATUS_OK) ? write_hex(value) : res;
962 }
963
964 status_t Serializer::prop_hex(const LSPString *key, uint32_t value)
965 {
966 status_t res = write_property(key);
967 return (res == STATUS_OK) ? write_hex(value) : res;
968 }
969
970 status_t Serializer::prop_hex(const char *key, int64_t value)
971 {
972 status_t res = write_property(key);
973 return (res == STATUS_OK) ? write_hex(value) : res;
974 }
975
976 status_t Serializer::prop_hex(const LSPString *key, int64_t value)
977 {
978 status_t res = write_property(key);
979 return (res == STATUS_OK) ? write_hex(value) : res;
980 }
981
982 status_t Serializer::prop_hex(const char *key, uint64_t value)
983 {
984 status_t res = write_property(key);
985 return (res == STATUS_OK) ? write_hex(value) : res;
986 }
987
988 status_t Serializer::prop_hex(const LSPString *key, uint64_t value)
989 {
990 status_t res = write_property(key);
991 return (res == STATUS_OK) ? write_hex(value) : res;
992 }
993
994 status_t Serializer::prop_double(const char *key, double value)
995 {
996 status_t res = write_property(key);
997 return (res == STATUS_OK) ? write_double(value) : res;
998 }
999
1000 status_t Serializer::prop_double(const LSPString *key, double value)
1001 {
1002 status_t res = write_property(key);
1003 return (res == STATUS_OK) ? write_double(value) : res;
1004 }
1005
1006 status_t Serializer::prop_double(const char *key, double value, const char *fmt)
1007 {
1008 status_t res = write_property(key);
1009 return (res == STATUS_OK) ? write_double(value, fmt) : res;
1010 }
1011
1012 status_t Serializer::prop_double(const LSPString *key, double value, const char *fmt)
1013 {
1014 status_t res = write_property(key);
1015 return (res == STATUS_OK) ? write_double(value, fmt) : res;
1016 }
1017
1018 status_t Serializer::prop_bool(const char *key, bool value)
1019 {
1020 status_t res = write_property(key);
1021 return (res == STATUS_OK) ? write_bool(value) : res;
1022 }
1023
1024 status_t Serializer::prop_bool(const LSPString *key, bool value)
1025 {
1026 status_t res = write_property(key);
1027 return (res == STATUS_OK) ? write_bool(value) : res;
1028 }
1029
1030 status_t Serializer::prop_string(const char *key, const char *value)
1031 {
1032 status_t res = write_property(key);
1033 return (res == STATUS_OK) ? write_string(value) : res;
1034 }
1035
1036 status_t Serializer::prop_string(const char *key, const LSPString *value)
1037 {
1038 status_t res = write_property(key);
1039 return (res == STATUS_OK) ? write_string(value) : res;
1040 }
1041
1042 status_t Serializer::prop_string(const LSPString *key, const char *value)
1043 {
1044 status_t res = write_property(key);
1045 return (res == STATUS_OK) ? write_string(value) : res;
1046 }
1047
1048 status_t Serializer::prop_string(const LSPString *key, const LSPString *value)
1049 {
1050 status_t res = write_property(key);
1051 return (res == STATUS_OK) ? write_string(value) : res;
1052 }
1053
1054 status_t Serializer::prop_null(const char *key)
1055 {
1056 status_t res = write_property(key);
1057 return (res == STATUS_OK) ? write_null() : res;
1058 }
1059
1060 status_t Serializer::prop_null(const LSPString *key)
1061 {
1062 status_t res = write_property(key);
1063 return (res == STATUS_OK) ? write_null() : res;
1064 }
1065
1066 } /* namespace json */
1067 } /* namespace lsp */