Debian Codegraph @

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

raw
1 /*
2 * Copyright (C) 2026 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2026 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 16 окт. 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/InStringSequence.h>
23 #include <lsp-plug.in/io/InSequence.h>
24 #include <lsp-plug.in/io/InFileStream.h>
25 #include <lsp-plug.in/fmt/json/Parser.h>
26
27 namespace lsp
28 {
29 namespace json
30 {
31
32 Parser::Parser()
33 {
34 pTokenizer = NULL;
35 pSequence = NULL;
36 nWFlags = 0;
37 enVersion = JSON_LEGACY;
38 sState.mode = READ_ROOT;
39 sState.flags = 0;
40 sCurrent.type = JE_UNKNOWN;
41 }
42
43 Parser::~Parser()
44 {
45 close();
46 }
47
48 status_t Parser::open(const char *path, json_version_t version, const char *charset)
49 {
50 if (pTokenizer != NULL)
51 return STATUS_BAD_STATE;
52 else if (path == NULL)
53 return STATUS_BAD_ARGUMENTS;
54
55 io::InFileStream *ifs = new io::InFileStream();
56 if (ifs == NULL)
57 return STATUS_NO_MEM;
58 status_t res = ifs->open(path);
59 if (res == STATUS_OK)
60 {
61 res = wrap(ifs, version, WRAP_CLOSE | WRAP_DELETE, charset);
62 if (res == STATUS_OK)
63 return res;
64 ifs->close();
65 }
66 delete ifs;
67
68 return res;
69 }
70
71 status_t Parser::open(const LSPString *path, json_version_t version, const char *charset)
72 {
73 if (pTokenizer != NULL)
74 return STATUS_BAD_STATE;
75 else if (path == NULL)
76 return STATUS_BAD_ARGUMENTS;
77
78 io::InFileStream *ifs = new io::InFileStream();
79 if (ifs == NULL)
80 return STATUS_NO_MEM;
81 status_t res = ifs->open(path);
82 if (res == STATUS_OK)
83 {
84 res = wrap(ifs, version, WRAP_CLOSE | WRAP_DELETE, charset);
85 if (res == STATUS_OK)
86 return res;
87 ifs->close();
88 }
89 delete ifs;
90
91 return res;
92 }
93
94 status_t Parser::open(const io::Path *path, json_version_t version, const char *charset)
95 {
96 if (pTokenizer != NULL)
97 return STATUS_BAD_STATE;
98 else if (path == NULL)
99 return STATUS_BAD_ARGUMENTS;
100
101 io::InFileStream *ifs = new io::InFileStream();
102 if (ifs == NULL)
103 return STATUS_NO_MEM;
104 status_t res = ifs->open(path);
105 if (res == STATUS_OK)
106 {
107 res = wrap(ifs, version, WRAP_CLOSE | WRAP_DELETE, charset);
108 if (res == STATUS_OK)
109 return res;
110 ifs->close();
111 }
112 delete ifs;
113
114 return res;
115 }
116
117 status_t Parser::wrap(const char *str, json_version_t version, const char *charset)
118 {
119 if (pTokenizer != NULL)
120 return STATUS_BAD_STATE;
121 else if (str == NULL)
122 return STATUS_BAD_ARGUMENTS;
123
124 io::InStringSequence *seq = new io::InStringSequence();
125 if (seq == NULL)
126 return STATUS_NO_MEM;
127
128 status_t res = seq->wrap(str, charset);
129 if (res == STATUS_OK)
130 {
131 if ((res = wrap(seq, version, WRAP_CLOSE | WRAP_DELETE)) == STATUS_OK)
132 return res;
133 seq->close();
134 }
135
136 delete seq;
137 return res;
138 }
139
140 status_t Parser::wrap(const LSPString *str, json_version_t version)
141 {
142 if (pTokenizer != NULL)
143 return STATUS_BAD_STATE;
144 else if (str == NULL)
145 return STATUS_BAD_ARGUMENTS;
146
147 io::InStringSequence *seq = new io::InStringSequence();
148 if (seq == NULL)
149 return STATUS_NO_MEM;
150
151 status_t res = seq->wrap(str);
152 if (res == STATUS_OK)
153 {
154 if ((res = wrap(seq, version, WRAP_CLOSE | WRAP_DELETE)) == STATUS_OK)
155 return res;
156 seq->close();
157 }
158
159 delete seq;
160 return res;
161 }
162
163 status_t Parser::wrap(io::IInStream *is, json_version_t version, size_t flags, const char *charset)
164 {
165 if (pTokenizer != NULL)
166 return STATUS_BAD_STATE;
167 else if (is == NULL)
168 return STATUS_BAD_ARGUMENTS;
169
170 io::InSequence *seq = new io::InSequence();
171 if (seq == NULL)
172 return STATUS_NO_MEM;
173
174 status_t res = seq->wrap(is, flags, charset);
175 if (res == STATUS_OK)
176 {
177 if ((res = wrap(seq, version, WRAP_CLOSE | WRAP_DELETE)) == STATUS_OK)
178 return res;
179 seq->close();
180 }
181
182 delete seq;
183 return res;
184 }
185
186 status_t Parser::wrap(io::IInSequence *seq, json_version_t version, size_t flags)
187 {
188 if (pTokenizer != NULL)
189 return STATUS_BAD_STATE;
190 else if (seq == NULL)
191 return STATUS_BAD_ARGUMENTS;
192
193 Tokenizer *tok = new Tokenizer(seq);
194 if (tok == NULL)
195 return STATUS_NO_MEM;
196
197 pTokenizer = tok;
198 pSequence = seq;
199 nWFlags = flags;
200 enVersion = version;
201 sState.mode = READ_ROOT;
202 sState.flags = 0;
203
204 return STATUS_OK;
205 }
206
207 status_t Parser::close()
208 {
209 status_t res = STATUS_OK;
210
211 if (pTokenizer != NULL)
212 {
213 delete pTokenizer;
214 pTokenizer = NULL;
215 }
216
217 if (pSequence != NULL)
218 {
219 if (nWFlags & WRAP_CLOSE)
220 res = update_status(res, pSequence->close());
221
222 if (nWFlags & WRAP_DELETE)
223 delete pSequence;
224
225 pSequence = NULL;
226 }
227
228 sCurrent.type = JE_UNKNOWN;
229 sCurrent.sValue.truncate();
230 sStack.flush();
231
232 return res;
233 }
234
235 status_t Parser::push_state(pmode_t mode)
236 {
237 if (!sStack.add(&sState))
238 return STATUS_NO_MEM;
239
240 sState.mode = mode;
241 sState.flags = 0;
242 return STATUS_OK;
243 }
244
245 status_t Parser::pop_state()
246 {
247 state_t *st = sStack.last();
248 if (st == NULL)
249 return STATUS_BAD_STATE;
250 sState = *st;
251 return (sStack.pop()) ? STATUS_OK : STATUS_BAD_STATE;
252 }
253
254 token_t Parser::lookup_token()
255 {
256 return pTokenizer->get_token(true);
257 }
258
259 status_t Parser::get_current(event_t *ev)
260 {
261 if (pTokenizer == NULL)
262 return STATUS_BAD_STATE;
263 if (ev == NULL)
264 return STATUS_BAD_ARGUMENTS;
265
266 switch (sCurrent.type)
267 {
268 case JE_OBJECT_START:
269 case JE_OBJECT_END:
270 case JE_ARRAY_START:
271 case JE_ARRAY_END:
272 case JE_UNKNOWN:
273 case JE_NULL:
274 break;
275
276 case JE_PROPERTY:
277 case JE_STRING:
278 if (!ev->sValue.set(&sCurrent.sValue))
279 return STATUS_NO_MEM;
280 break;
281 case JE_INTEGER:
282 ev->iValue = sCurrent.iValue;
283 break;
284 case JE_DOUBLE:
285 ev->fValue = sCurrent.fValue;
286 break;
287 case JE_BOOL:
288 ev->bValue = sCurrent.bValue;
289 break;
290
291 default:
292 return STATUS_BAD_STATE;
293 }
294
295 ev->type = sCurrent.type;
296 return STATUS_OK;
297 }
298
299 status_t Parser::read_primitive(token_t tok)
300 {
301 switch (tok)
302 {
303 case JT_DQ_STRING:
304 if (!sCurrent.sValue.set(pTokenizer->text_value()))
305 return STATUS_NO_MEM;
306 sCurrent.type = JE_STRING;
307 break;
308
309 case JT_TRUE:
310 case JT_FALSE:
311 sCurrent.bValue = (tok == JT_TRUE);
312 sCurrent.type = JE_BOOL;
313 break;
314
315 case JT_NULL:
316 sCurrent.type = JE_NULL;
317 break;
318
319 case JT_DECIMAL:
320 sCurrent.iValue = pTokenizer->int_value();
321 sCurrent.type = JE_INTEGER;
322 break;
323
324 case JT_DOUBLE:
325 sCurrent.fValue = pTokenizer->float_value();
326 sCurrent.type = JE_DOUBLE;
327 break;
328
329 case JT_SQ_STRING: // Single-quoted strings are allowed since JSON5
330 case JT_IDENTIFIER:
331 if (enVersion < JSON_VERSION5)
332 return STATUS_BAD_TOKEN;
333 if (!sCurrent.sValue.set(pTokenizer->text_value()))
334 return STATUS_NO_MEM;
335 sCurrent.type = JE_STRING;
336 break;
337
338 case JT_HEXADECIMAL: // Hexadecimals are allowed since JSON5
339 if (enVersion < JSON_VERSION5)
340 return STATUS_BAD_TOKEN;
341 sCurrent.iValue = pTokenizer->int_value();
342 sCurrent.type = JE_INTEGER;
343 break;
344
345 default:
346 return STATUS_BAD_TOKEN;
347 }
348
349 return STATUS_OK;
350 }
351
352 status_t Parser::read_root()
353 {
354 while (true)
355 {
356 // Get token
357 token_t tok = lookup_token();
358
359 // Analyze token
360 switch (tok)
361 {
362 case JT_EOF: // End of input
363 return STATUS_EOF;
364 case JT_ERROR: // Error input
365 return pTokenizer->error();
366
367 case JT_SL_COMMENT: // Skip comments
368 case JT_ML_COMMENT:
369 if (enVersion < JSON_VERSION5) // Only JSON5 allows comments
370 return STATUS_BAD_TOKEN;
371 break;
372
373 case JT_LQ_BRACE: // Start of array
374 if (sState.flags & PF_VALUE)
375 return STATUS_BAD_TOKEN;
376 sCurrent.type = JE_ARRAY_START;
377 sState.flags |= PF_VALUE;
378 return push_state(READ_ARRAY);
379
380 case JT_LC_BRACE: // Start of object
381 if (sState.flags & PF_VALUE)
382 return STATUS_BAD_TOKEN;
383 sCurrent.type = JE_OBJECT_START;
384 sState.flags |= PF_VALUE;
385 return push_state(READ_OBJECT);
386
387 case JT_SQ_STRING:
388 case JT_DQ_STRING:
389 case JT_TRUE:
390 case JT_FALSE:
391 case JT_NULL:
392 case JT_DECIMAL:
393 case JT_DOUBLE:
394 case JT_HEXADECIMAL:
395 if (sState.flags & PF_VALUE)
396 return STATUS_BAD_TOKEN;
397 sState.flags |= PF_VALUE;
398 return read_primitive(tok);
399
400 default:
401 return STATUS_BAD_TOKEN;
402 }
403 }
404 }
405
406 status_t Parser::read_array()
407 {
408 while (true)
409 {
410 // Get token
411 token_t tok = lookup_token();
412
413 // Analyze token
414 switch (tok)
415 {
416 case JT_EOF: // End of input
417 return STATUS_CORRUPTED;
418 case JT_ERROR: // Error input
419 return pTokenizer->error();
420
421 case JT_SL_COMMENT: // Skip comments
422 case JT_ML_COMMENT:
423 if (enVersion < JSON_VERSION5) // Only JSON5 allows comments
424 return STATUS_BAD_TOKEN;
425 break;
426
427 case JT_COMMA: // Comma
428 if ((sState.flags & PF_ARRAY_ALL) != PF_VALUE)
429 return STATUS_BAD_TOKEN;
430 sState.flags |= PF_COMMA; // Add comma flag
431 break;
432
433 case JT_RQ_BRACE: // End of current array
434 // Closing brace after comma is allowed only since JSON5
435 if ((sState.flags & PF_COMMA) && (enVersion < JSON_VERSION5))
436 return STATUS_BAD_TOKEN;
437 sCurrent.type = JE_ARRAY_END;
438 return pop_state();
439
440 case JT_LQ_BRACE: // Start of sub-array
441 {
442 size_t flags = sState.flags & PF_ARRAY_ALL;
443 if ((flags != 0) && (flags != (PF_VALUE | PF_COMMA)))
444 return STATUS_BAD_TOKEN;
445 sState.flags = PF_VALUE;
446 sCurrent.type = JE_ARRAY_START;
447 return push_state(READ_ARRAY);
448 }
449
450 case JT_LC_BRACE: // Start of nested object
451 {
452 size_t flags = sState.flags & PF_ARRAY_ALL;
453 if ((flags != 0) && (flags != (PF_VALUE | PF_COMMA)))
454 return STATUS_BAD_TOKEN;
455 sState.flags = PF_VALUE;
456 sCurrent.type = JE_OBJECT_START;
457 return push_state(READ_OBJECT);
458 }
459
460 case JT_SQ_STRING:
461 case JT_DQ_STRING:
462 case JT_TRUE:
463 case JT_FALSE:
464 case JT_NULL:
465 case JT_DECIMAL:
466 case JT_DOUBLE:
467 case JT_HEXADECIMAL: // Read primitive type
468 {
469 size_t flags = sState.flags & PF_ARRAY_ALL;
470 if ((flags != 0) && (flags != (PF_VALUE | PF_COMMA)))
471 return STATUS_BAD_TOKEN;
472 sState.flags = PF_VALUE;
473 return read_primitive(tok);
474 }
475
476 default:
477 return STATUS_BAD_TOKEN;
478 }
479 }
480 }
481
482 status_t Parser::read_object()
483 {
484 status_t res;
485
486 while (true)
487 {
488 // Get token
489 token_t tok = lookup_token();
490
491 // Analyze token
492 switch (tok)
493 {
494 case JT_EOF: // End of input
495 return STATUS_CORRUPTED;
496 case JT_ERROR: // Error input
497 return pTokenizer->error();
498
499 case JT_SL_COMMENT: // Skip comments
500 case JT_ML_COMMENT:
501 if (enVersion < JSON_VERSION5) // Only JSON5 allows comments
502 return STATUS_BAD_TOKEN;
503 break;
504
505 case JT_COMMA: // Comma
506 if ((sState.flags & PF_OBJECT_ALL) != (PF_PROPERTY | PF_COLON | PF_VALUE))
507 return STATUS_BAD_TOKEN;
508 sState.flags |= PF_COMMA; // Add comma flag
509 break;
510
511 case JT_COLON: // Colon
512 if ((sState.flags & PF_OBJECT_ALL) != PF_PROPERTY)
513 return STATUS_BAD_TOKEN;
514 sState.flags |= PF_COLON;
515 break;
516
517 case JT_RC_BRACE: // End of current object
518 {
519 size_t flags = sState.flags & PF_OBJECT_ALL;
520
521 // If property is present, there should be a corresponding value
522 // JSON5 allows a comma before closing brace
523 if (flags == PF_OBJECT_ALL)
524 {
525 if (enVersion < JSON_VERSION5)
526 return STATUS_BAD_TOKEN;
527 }
528 else if ((flags != 0) && (flags != (PF_PROPERTY | PF_COLON | PF_VALUE)))
529 return STATUS_BAD_TOKEN;
530
531 sCurrent.type = JE_OBJECT_END;
532 return pop_state();
533 }
534
535 case JT_LQ_BRACE: // Start of array value
536 // Property should be defined first
537 if ((sState.flags & PF_OBJECT_ALL) != (PF_PROPERTY | PF_COLON))
538 return STATUS_BAD_TOKEN;
539 sCurrent.type = JE_ARRAY_START;
540 sState.flags |= PF_VALUE;
541 return push_state(READ_ARRAY);
542
543 case JT_LC_BRACE: // Start of object value
544 // Property should be defined first
545 if ((sState.flags & PF_OBJECT_ALL) != (PF_PROPERTY | PF_COLON))
546 return STATUS_BAD_TOKEN;
547 sCurrent.type = JE_OBJECT_START;
548 sState.flags |= PF_VALUE;
549 return push_state(READ_OBJECT);
550
551 case JT_SQ_STRING:
552 case JT_DQ_STRING:
553 case JT_IDENTIFIER: // Property name
554 {
555 size_t flags = sState.flags & PF_OBJECT_ALL;
556 if ((flags == 0) || (flags == PF_OBJECT_ALL)) // Property name?
557 {
558 if ((res = read_primitive(tok)) == STATUS_OK)
559 {
560 sState.flags = PF_PROPERTY;
561 sCurrent.type = JE_PROPERTY; // Override type of event
562 }
563 }
564 else if (flags == (PF_PROPERTY | PF_COLON)) // Value?
565 {
566 if ((res = read_primitive(tok)) == STATUS_OK)
567 sState.flags |= PF_VALUE;
568 }
569 else
570 res = STATUS_BAD_STATE;
571
572 return res;
573 }
574
575 case JT_TRUE:
576 case JT_FALSE:
577 case JT_NULL:
578 case JT_DECIMAL:
579 case JT_DOUBLE:
580 case JT_HEXADECIMAL: // Read primitive type
581 {
582 if ((sState.flags & PF_OBJECT_ALL) != (PF_PROPERTY | PF_COLON))
583 return STATUS_BAD_TOKEN;
584 sState.flags |= PF_VALUE;
585 return read_primitive(tok);
586 }
587
588 default:
589 return STATUS_BAD_TOKEN;
590 }
591 }
592 }
593
594 status_t Parser::read_next(event_t *ev)
595 {
596 if (pTokenizer == NULL)
597 return STATUS_BAD_STATE;
598
599 status_t res;
600
601 // Root position?
602 switch (sState.mode)
603 {
604 case READ_ROOT:
605 res = read_root();
606 break;
607
608 case READ_ARRAY:
609 res = read_array();
610 break;
611
612 case READ_OBJECT:
613 res = read_object();
614 break;
615
616 default:
617 return STATUS_BAD_STATE;
618 }
619
620 // Deploy result if there is place to deploy
621 if ((res == STATUS_OK) && (ev != NULL))
622 res = get_current(ev);
623
624 return res;
625 }
626
627 status_t Parser::read_next_type(event_type_t *type)
628 {
629 event_t ev;
630 status_t res = read_next(&ev);
631 if ((res == STATUS_OK) && (type != NULL))
632 *type = ev.type;
633 return res;
634 }
635
636 status_t Parser::read_string(LSPString *dst)
637 {
638 event_t ev;
639 status_t res = read_next(&ev);
640 if (res != STATUS_OK)
641 return res;
642 switch (ev.type)
643 {
644 case JE_STRING: break;
645 case JE_NULL: return STATUS_NULL;
646 default: return STATUS_BAD_TYPE;
647 }
648 if (dst != NULL)
649 dst->swap(&ev.sValue);
650 return STATUS_OK;
651 }
652
653 status_t Parser::read_double(double *dst)
654 {
655 event_t ev;
656 status_t res = read_next(&ev);
657 if (res != STATUS_OK)
658 return res;
659 switch (ev.type)
660 {
661 case JE_DOUBLE: break;
662 case JE_NULL: return STATUS_NULL;
663 default: return STATUS_BAD_TYPE;
664 }
665 if (dst != NULL)
666 *dst = ev.fValue;
667 return STATUS_OK;
668 }
669
670 status_t Parser::read_int(ssize_t *dst)
671 {
672 event_t ev;
673 status_t res = read_next(&ev);
674 if (res != STATUS_OK)
675 return res;
676 switch (ev.type)
677 {
678 case JE_INTEGER: break;
679 case JE_NULL: return STATUS_NULL;
680 default: return STATUS_BAD_TYPE;
681 }
682 if (dst != NULL)
683 *dst = ev.iValue;
684 return STATUS_OK;
685 }
686
687 status_t Parser::read_int(size_t *dst)
688 {
689 event_t ev;
690 status_t res = read_next(&ev);
691 if (res != STATUS_OK)
692 return res;
693 switch (ev.type)
694 {
695 case JE_INTEGER: break;
696 case JE_NULL: return STATUS_NULL;
697 default: return STATUS_BAD_TYPE;
698 }
699 if (ev.iValue < 0)
700 return STATUS_UNDERFLOW;
701 if (dst != NULL)
702 *dst = size_t(ev.iValue);
703 return STATUS_OK;
704 }
705
706 status_t Parser::read_bool(bool *dst)
707 {
708 event_t ev;
709 status_t res = read_next(&ev);
710 if (res != STATUS_OK)
711 return res;
712 switch (ev.type)
713 {
714 case JE_BOOL: break;
715 case JE_NULL: return STATUS_NULL;
716 default: return STATUS_BAD_TYPE;
717 }
718 if (dst != NULL)
719 *dst = ev.bValue;
720 return STATUS_OK;
721 }
722
723 status_t Parser::get_string(LSPString *dst)
724 {
725 if (pTokenizer == NULL)
726 return STATUS_BAD_STATE;
727 switch (sCurrent.type)
728 {
729 case JE_STRING: break;
730 case JE_NULL: return STATUS_NULL;
731 default: return STATUS_BAD_TYPE;
732 }
733 if (dst != NULL)
734 return (dst->set(&sCurrent.sValue)) ? STATUS_OK : STATUS_NO_MEM;
735 return STATUS_OK;
736 }
737
738 status_t Parser::get_double(double *dst)
739 {
740 if (pTokenizer == NULL)
741 return STATUS_BAD_STATE;
742 switch (sCurrent.type)
743 {
744 case JE_DOUBLE: break;
745 case JE_NULL: return STATUS_NULL;
746 default: return STATUS_BAD_TYPE;
747 }
748 if (dst != NULL)
749 *dst = sCurrent.fValue;
750 return STATUS_OK;
751 }
752
753 status_t Parser::get_int(ssize_t *dst)
754 {
755 if (pTokenizer == NULL)
756 return STATUS_BAD_STATE;
757 switch (sCurrent.type)
758 {
759 case JE_INTEGER: break;
760 case JE_NULL: return STATUS_NULL;
761 default: return STATUS_BAD_TYPE;
762 }
763 if (dst != NULL)
764 *dst = sCurrent.iValue;
765 return STATUS_OK;
766 }
767
768 status_t Parser::get_bool(bool *dst)
769 {
770 if (pTokenizer == NULL)
771 return STATUS_BAD_STATE;
772 switch (sCurrent.type)
773 {
774 case JE_BOOL: break;
775 case JE_NULL: return STATUS_NULL;
776 default: return STATUS_BAD_TYPE;
777 }
778 if (dst != NULL)
779 *dst = sCurrent.bValue;
780 return STATUS_OK;
781 }
782
783 status_t Parser::skip_next()
784 {
785 status_t res = read_next(NULL);
786 if (res == STATUS_OK)
787 res = skip_current();
788 return res;
789 }
790
791 status_t Parser::skip_current()
792 {
793 status_t res;
794
795 switch (sCurrent.type)
796 {
797 case JE_OBJECT_START:
798 while (true)
799 {
800 // Get next event
801 if ((res = read_next(NULL)) != STATUS_OK)
802 return res;
803
804 // Analyze event type
805 if (sCurrent.type != JE_PROPERTY)
806 return (sCurrent.type == JE_OBJECT_END) ? STATUS_OK : STATUS_BAD_TOKEN;
807
808 // Skip the value after property
809 if ((res = read_next(NULL)) != STATUS_OK)
810 return res;
811 if ((res = skip_current()) != STATUS_OK)
812 return res;
813 }
814 break;
815
816 case JE_ARRAY_START:
817 while (true)
818 {
819 // Get next event
820 if ((res = read_next(NULL)) != STATUS_OK)
821 return res;
822
823 // Analyze event type
824 if (sCurrent.type == JE_ARRAY_END)
825 return STATUS_OK;
826
827 // Skip the value after property
828 if ((res = skip_current()) != STATUS_OK)
829 return res;
830 }
831 break;
832
833 case JE_PROPERTY:
834 // Skip the value after property
835 if ((res = read_next(NULL)) != STATUS_OK)
836 return res;
837 if ((res = skip_current()) != STATUS_OK)
838 return res;
839 break;
840
841 default:
842 break;
843 }
844
845 return STATUS_OK;
846 }
847
848 } /* namespace json */
849 } /* namespace lsp */