blob: 56bf734b12b994e9b59b277bd6f7ffb95fcc1299 [file] [log] [blame]
Radek Krejci50f0c6b2020-06-18 16:31:48 +02001/**
2 * @file json.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Generic JSON format parser for libyang
5 *
6 * Copyright (c) 2020 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
15#include <assert.h>
16#include <ctype.h>
17#include <errno.h>
Radek Krejci50f0c6b2020-06-18 16:31:48 +020018#include <stdlib.h>
Radek Krejci47fab892020-11-05 17:02:41 +010019#include <string.h>
Radek Krejci50f0c6b2020-06-18 16:31:48 +020020#include <sys/types.h>
21
22#include "common.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020023#include "in_internal.h"
Radek Krejci47fab892020-11-05 17:02:41 +010024#include "json.h"
Radek Krejci50f0c6b2020-06-18 16:31:48 +020025
26#define JSON_PUSH_STATUS_RET(CTX, STATUS) \
Radek Krejci3d92e442020-10-12 12:48:13 +020027 LY_CHECK_RET(ly_set_add(&CTX->status, (void*)STATUS, 1, NULL))
Radek Krejci50f0c6b2020-06-18 16:31:48 +020028
29#define JSON_POP_STATUS_RET(CTX) \
30 assert(CTX->status.count); CTX->status.count--;
31
Michal Vasko22df3f02020-08-24 13:29:22 +020032const char *
Radek Krejci50f0c6b2020-06-18 16:31:48 +020033lyjson_token2str(enum LYJSON_PARSER_STATUS status)
34{
35 switch (status) {
36 case LYJSON_ERROR:
37 return "error";
38 case LYJSON_ROOT:
39 return "document root";
40 case LYJSON_FALSE:
41 return "false";
42 case LYJSON_TRUE:
43 return "true";
44 case LYJSON_NULL:
45 return "null";
46 case LYJSON_OBJECT:
47 return "object";
48 case LYJSON_OBJECT_CLOSED:
49 return "object closed";
50 case LYJSON_OBJECT_EMPTY:
51 return "empty object";
52 case LYJSON_ARRAY:
53 return "array";
54 case LYJSON_ARRAY_CLOSED:
55 return "array closed";
56 case LYJSON_ARRAY_EMPTY:
57 return "empty array";
58 case LYJSON_NUMBER:
59 return "number";
60 case LYJSON_STRING:
61 return "string";
62 case LYJSON_END:
63 return "end of input";
64 }
65
66 return "";
67}
68
69static LY_ERR
70skip_ws(struct lyjson_ctx *jsonctx)
71{
72 /* skip leading whitespaces */
73 while (*jsonctx->in->current != '\0' && is_jsonws(*jsonctx->in->current)) {
74 if (*jsonctx->in->current == 0x0a) { /* new line */
75 jsonctx->line++;
76 }
77 ly_in_skip(jsonctx->in, 1);
78 }
79 if (*jsonctx->in->current == '\0') {
80 JSON_PUSH_STATUS_RET(jsonctx, LYJSON_END);
81 }
82
83 return LY_SUCCESS;
84}
85
86/*
87 * @brief Set value corresponding to the current context's status
88 */
89static void
Radek Krejci857189e2020-09-01 13:26:36 +020090lyjson_ctx_set_value(struct lyjson_ctx *jsonctx, const char *value, size_t value_len, ly_bool dynamic)
Radek Krejci50f0c6b2020-06-18 16:31:48 +020091{
92 assert(jsonctx);
93
94 if (dynamic) {
Michal Vasko22df3f02020-08-24 13:29:22 +020095 free((char *)jsonctx->value);
Radek Krejci50f0c6b2020-06-18 16:31:48 +020096 }
97 jsonctx->value = value;
98 jsonctx->value_len = value_len;
99 jsonctx->dynamic = dynamic;
100}
101
102static LY_ERR
103lyjson_check_next(struct lyjson_ctx *jsonctx)
104{
105 if (jsonctx->status.count == 1) {
106 /* top level value (JSON-text), ws expected */
Michal Vasko69730152020-10-09 16:30:07 +0200107 if ((*jsonctx->in->current == '\0') || is_jsonws(*jsonctx->in->current)) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200108 return LY_SUCCESS;
109 }
110 } else if (lyjson_ctx_status(jsonctx, 1) == LYJSON_OBJECT) {
111 LY_CHECK_RET(skip_ws(jsonctx));
Michal Vasko69730152020-10-09 16:30:07 +0200112 if ((*jsonctx->in->current == ',') || (*jsonctx->in->current == '}')) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200113 return LY_SUCCESS;
114 }
115 } else if (lyjson_ctx_status(jsonctx, 1) == LYJSON_ARRAY) {
116 LY_CHECK_RET(skip_ws(jsonctx));
Michal Vasko69730152020-10-09 16:30:07 +0200117 if ((*jsonctx->in->current == ',') || (*jsonctx->in->current == ']')) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200118 return LY_SUCCESS;
119 }
120 } else {
121 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LYVE_SYNTAX,
Michal Vasko69730152020-10-09 16:30:07 +0200122 "Unexpected character \"%c\" after JSON %s.", *jsonctx->in->current, lyjson_token2str(lyjson_ctx_status(jsonctx, 0)));
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200123 }
124
125 return LY_EVALID;
126}
127
128/**
129 * Input is expected to start after the opening quotation-mark.
130 * When succeeds, input is moved after the closing quotation-mark.
131 */
132static LY_ERR
133lyjson_string_(struct lyjson_ctx *jsonctx)
134{
135#define BUFSIZE 24
136#define BUFSIZE_STEP 128
137
138 const char *in = jsonctx->in->current, *start;
139 char *buf = NULL;
140 size_t offset; /* read offset in input buffer */
141 size_t len; /* length of the output string (write offset in output buffer) */
142 size_t size = 0; /* size of the output buffer */
143 size_t u;
144 uint64_t start_line;
145
146 assert(jsonctx);
147
148 /* init */
149 start = in;
150 start_line = jsonctx->line;
151 offset = len = 0;
152
153 /* parse */
154 while (in[offset]) {
155 if (in[offset] == '\\') {
156 /* escape sequence */
157 size_t slash = offset;
158 uint32_t value;
159 uint8_t i = 1;
160
161 if (!buf) {
162 /* prepare output buffer */
163 buf = malloc(BUFSIZE);
164 LY_CHECK_ERR_RET(!buf, LOGMEM(jsonctx->ctx), LY_EMEM);
165 size = BUFSIZE;
166 }
167
168 /* allocate enough for the offset and next character,
169 * we will need 4 bytes at most since we support only the predefined
170 * (one-char) entities and character references */
171 if (len + offset + 4 >= size) {
172 buf = ly_realloc(buf, size + BUFSIZE_STEP);
173 LY_CHECK_ERR_RET(!buf, LOGMEM(jsonctx->ctx), LY_EMEM);
174 size += BUFSIZE_STEP;
175 }
176
177 if (offset) {
178 /* store what we have so far */
179 memcpy(&buf[len], in, offset);
180 len += offset;
181 in += offset;
182 offset = 0;
183 }
184
185 switch (in[++offset]) {
186 case '"':
187 /* quotation mark */
188 value = 0x22;
189 break;
190 case '\\':
191 /* reverse solidus */
192 value = 0x5c;
193 break;
194 case '/':
195 /* solidus */
196 value = 0x2f;
197 break;
198 case 'b':
199 /* backspace */
200 value = 0x08;
201 break;
202 case 'f':
203 /* form feed */
204 value = 0x0c;
205 break;
206 case 'n':
207 /* line feed */
208 value = 0x0a;
209 break;
210 case 'r':
211 /* carriage return */
212 value = 0x0d;
213 break;
214 case 't':
215 /* tab */
216 value = 0x09;
217 break;
218 case 'u':
219 /* Basic Multilingual Plane character \uXXXX */
220 offset++;
221 for (value = i = 0; i < 4; i++) {
222 if (isdigit(in[offset + i])) {
223 u = (in[offset + i] - '0');
224 } else if (in[offset + i] > 'F') {
225 u = 10 + (in[offset + i] - 'a');
226 } else {
227 u = 10 + (in[offset + i] - 'A');
228 }
229 value = (16 * value) + u;
230 }
231 break;
232 default:
233 /* invalid escape sequence */
234 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LYVE_SYNTAX,
Michal Vasko69730152020-10-09 16:30:07 +0200235 "Invalid character escape sequence \\%c.", in[offset]);
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200236 goto error;
237
238 }
239
240 offset += i; /* add read escaped characters */
241 LY_CHECK_ERR_GOTO(ly_pututf8(&buf[len], value, &u),
Michal Vasko69730152020-10-09 16:30:07 +0200242 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LYVE_SYNTAX,
243 "Invalid character reference \"%.*s\" (0x%08x).", offset - slash, &in[slash], value),
244 error);
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200245 len += u; /* update number of bytes in buffer */
246 in += offset; /* move the input by the processed bytes stored in the buffer ... */
247 offset = 0; /* ... and reset the offset index for future moving data into buffer */
248
249 } else if (in[offset] == '"') {
250 /* end of string */
251 if (buf) {
252 /* realloc exact size string */
253 buf = ly_realloc(buf, len + offset + 1);
254 LY_CHECK_ERR_RET(!buf, LOGMEM(jsonctx->ctx), LY_EMEM);
255 size = len + offset + 1;
256 memcpy(&buf[len], in, offset);
257
258 /* set terminating NULL byte */
259 buf[len + offset] = '\0';
260 }
261 len += offset;
262 ++offset;
263 in += offset;
264 goto success;
265 } else {
266 /* get it as UTF-8 character for check */
267 const char *c = &in[offset];
268 uint32_t code = 0;
269 size_t code_len = 0;
270
271 LY_CHECK_ERR_GOTO(ly_getutf8(&c, &code, &code_len),
Michal Vasko69730152020-10-09 16:30:07 +0200272 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LY_VCODE_INCHAR, in[offset]), error);
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200273
274 LY_CHECK_ERR_GOTO(!is_jsonstrchar(code),
Michal Vasko69730152020-10-09 16:30:07 +0200275 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LYVE_SYNTAX,
276 "Invalid character in JSON string \"%.*s\" (0x%08x).", &in[offset] - start + code_len, start, code),
277 error);
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200278
279 /* character is ok, continue */
280 offset += code_len;
281 }
282 }
283
284 /* EOF reached before endchar */
285 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LY_VCODE_EOF);
286 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &start_line, LYVE_SYNTAX, "Missing quotation-mark at the end of a JSON string.");
287
288error:
289 free(buf);
290 return LY_EVALID;
291
292success:
293 ly_in_skip(jsonctx->in, in - jsonctx->in->current);
294 if (buf) {
295 lyjson_ctx_set_value(jsonctx, buf, len, 1);
296 } else {
297 lyjson_ctx_set_value(jsonctx, start, len, 0);
298 }
299
300 return LY_SUCCESS;
301
302#undef BUFSIZE
303#undef BUFSIZE_STEP
304}
305
306/*
307 *
308 * Wrapper around lyjson_string_() adding LYJSON_STRING status into context to allow using lyjson_string_() for parsing object's name.
309 */
310static LY_ERR
311lyjson_string(struct lyjson_ctx *jsonctx)
312{
313 LY_CHECK_RET(lyjson_string_(jsonctx));
314
315 JSON_PUSH_STATUS_RET(jsonctx, LYJSON_STRING);
316 LY_CHECK_RET(lyjson_check_next(jsonctx));
317
318 return LY_SUCCESS;
319}
320
321static LY_ERR
322lyjson_number(struct lyjson_ctx *jsonctx)
323{
324 size_t offset = 0, exponent = 0;
325 const char *in = jsonctx->in->current;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200326 uint8_t minus = 0;
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200327
328 if (in[offset] == '-') {
329 ++offset;
330 minus = 1;
331 }
332
333 if (in[offset] == '0') {
334 ++offset;
335 } else if (isdigit(in[offset])) {
336 ++offset;
337 while (isdigit(in[offset])) {
338 ++offset;
339 }
340 } else {
341invalid_character:
342 if (in[offset]) {
343 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LYVE_SYNTAX, "Invalid character in JSON Number value (\"%c\").", in[offset]);
344 } else {
345 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LY_VCODE_EOF);
346 }
347 return LY_EVALID;
348 }
349
350 if (in[offset] == '.') {
351 ++offset;
352 if (!isdigit(in[offset])) {
353 goto invalid_character;
354 }
355 while (isdigit(in[offset])) {
356 ++offset;
357 }
358 }
359
360 if ((in[offset] == 'e') || (in[offset] == 'E')) {
361 exponent = offset++;
362 if ((in[offset] == '+') || (in[offset] == '-')) {
363 ++offset;
364 }
365 if (!isdigit(in[offset])) {
366 goto invalid_character;
367 }
368 while (isdigit(in[offset])) {
369 ++offset;
370 }
371 }
372
373 if (exponent) {
374 /* convert JSON number with exponent into the representation used by YANG */
375 long int e_val;
376 char *ptr, *dec_point, *num;
377 const char *e_ptr = &in[exponent + 1];
378 size_t num_len, i;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200379 int64_t dp_position; /* final position of the deciaml point */
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200380
381 errno = 0;
382 e_val = strtol(e_ptr, &ptr, 10);
383 if (errno) {
384 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LYVE_SEMANTICS,
Michal Vasko69730152020-10-09 16:30:07 +0200385 "Exponent out-of-bounds in a JSON Number value (%.*s).", offset - minus - (e_ptr - in), e_ptr);
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200386 return LY_EVALID;
387 }
388
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200389 dec_point = ly_strnchr(in, '.', exponent);
390 if (!dec_point) {
391 /* value is integer, we are just ... */
392 if (e_val >= 0) {
393 /* adding zeros at the end */
394 num_len = exponent + e_val;
395 dp_position = num_len; /* decimal point is behind the actual value */
396 } else if ((size_t)labs(e_val) < exponent) {
397 /* adding decimal point between the integer's digits */
398 num_len = exponent + 1;
399 dp_position = exponent + e_val;
400 } else {
401 /* adding decimal point before the integer with adding leading zero(s) */
402 num_len = labs(e_val) + 2;
403 dp_position = exponent + e_val;
404 }
405 dp_position -= minus;
406 } else {
407 /* value is decimal, we are moving the decimal point */
408 dp_position = dec_point - in + e_val - minus;
409 if (dp_position > (ssize_t)exponent) {
410 /* moving decimal point after the decimal value make the integer result */
411 num_len = dp_position;
412 } else if (dp_position < 0) {
413 /* moving decimal point before the decimal value requires additional zero(s)
414 * (decimal point is already count in exponent value) */
415 num_len = exponent + labs(dp_position) + 1;
416 } else {
417 /* moving decimal point just inside the decimal value does not make any change in length */
418 num_len = exponent;
419 }
420 }
421
422 /* allocate buffer for the result (add terminating NULL-byte */
423 num = malloc(num_len + 1);
424 LY_CHECK_ERR_RET(!num, LOGMEM(jsonctx->ctx), LY_EMEM);
425
426 /* compose the resulting vlaue */
427 i = 0;
428 if (minus) {
429 num[i++] = '-';
430 }
431 /* add leading zeros */
432 if (dp_position <= 0) {
433 num[i++] = '0';
434 num[i++] = '.';
Michal Vaskod989ba02020-08-24 10:59:24 +0200435 for ( ; dp_position; dp_position++) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200436 num[i++] = '0';
437 }
438 }
439 /* copy the value */
Radek Krejci857189e2020-09-01 13:26:36 +0200440 ly_bool dp_placed;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200441 size_t j;
442 for (dp_placed = dp_position ? 0 : 1, j = minus; j < exponent; j++) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200443 if (in[j] == '.') {
444 continue;
445 }
446 if (!dp_placed) {
447 if (!dp_position) {
448 num[i++] = '.';
449 dp_placed = 1;
450 } else {
451 dp_position--;
452 if (in[j] == '0') {
453 num_len--;
454 continue;
455 }
456 }
457 }
458
459 num[i++] = in[j];
460 }
461 /* trailing zeros */
462 while (dp_position--) {
463 num[i++] = '0';
464 }
465 /* terminating NULL byte */
466 num[i] = '\0';
467
468 /* store the modified number */
469 lyjson_ctx_set_value(jsonctx, num, num_len, 1);
470 } else {
471 /* store the number */
472 lyjson_ctx_set_value(jsonctx, jsonctx->in->current, offset, 0);
473 }
474 ly_in_skip(jsonctx->in, offset);
475
476 JSON_PUSH_STATUS_RET(jsonctx, LYJSON_NUMBER);
477 LY_CHECK_RET(lyjson_check_next(jsonctx));
478
479 return LY_SUCCESS;
480}
481
482static LY_ERR
483lyjson_object_name(struct lyjson_ctx *jsonctx)
484{
485 if (*jsonctx->in->current != '"') {
486 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LY_VCODE_INSTREXP, LY_VCODE_INSTREXP_len(jsonctx->in->current),
Michal Vasko69730152020-10-09 16:30:07 +0200487 jsonctx->in->current, "a JSON object's member");
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200488 return LY_EVALID;
489 }
490 ly_in_skip(jsonctx->in, 1);
491
492 LY_CHECK_RET(lyjson_string_(jsonctx));
493 LY_CHECK_RET(skip_ws(jsonctx));
Michal Vasko08dc70b2020-10-07 13:58:47 +0200494 if (*jsonctx->in->current != ':') {
495 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LY_VCODE_INSTREXP,
496 LY_VCODE_INSTREXP_len(jsonctx->in->current), jsonctx->in->current, "a JSON object's name-separator ':'");
497 return LY_EVALID;
498 }
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200499 ly_in_skip(jsonctx->in, 1);
500 LY_CHECK_RET(skip_ws(jsonctx));
501
502 return LY_SUCCESS;
503}
504
505static LY_ERR
506lyjson_object(struct lyjson_ctx *jsonctx)
507{
508 LY_CHECK_RET(skip_ws(jsonctx));
509
510 if (*jsonctx->in->current == '}') {
511 /* empty object */
512 ly_in_skip(jsonctx->in, 1);
513 lyjson_ctx_set_value(jsonctx, NULL, 0, 0);
514 JSON_PUSH_STATUS_RET(jsonctx, LYJSON_OBJECT_EMPTY);
515 return LY_SUCCESS;
516 }
517
518 LY_CHECK_RET(lyjson_object_name(jsonctx));
519
520 /* output data are set by lyjson_string_() */
521 JSON_PUSH_STATUS_RET(jsonctx, LYJSON_OBJECT);
522
523 return LY_SUCCESS;
524}
525
526/*
527 * @brief Process JSON array envelope
528 *
529 *
530 *
531 * @param[in] jsonctx JSON parser context
532 * @return LY_SUCCESS or LY_EMEM
533 */
534static LY_ERR
535lyjson_array(struct lyjson_ctx *jsonctx)
536{
537 LY_CHECK_RET(skip_ws(jsonctx));
538
539 if (*jsonctx->in->current == ']') {
540 /* empty array */
541 ly_in_skip(jsonctx->in, 1);
542 JSON_PUSH_STATUS_RET(jsonctx, LYJSON_ARRAY_EMPTY);
543 } else {
544 JSON_PUSH_STATUS_RET(jsonctx, LYJSON_ARRAY);
545 }
546
547 /* erase previous values, array has no value on its own */
548 lyjson_ctx_set_value(jsonctx, NULL, 0, 0);
549
550 return LY_SUCCESS;
551}
552
553static LY_ERR
554lyjson_value(struct lyjson_ctx *jsonctx)
555{
Michal Vasko69730152020-10-09 16:30:07 +0200556 if (jsonctx->status.count && (lyjson_ctx_status(jsonctx, 0) == LYJSON_END)) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200557 return LY_SUCCESS;
558 }
559
Michal Vasko69730152020-10-09 16:30:07 +0200560 if ((*jsonctx->in->current == 'f') && !strncmp(jsonctx->in->current, "false", 5)) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200561 /* false */
562 lyjson_ctx_set_value(jsonctx, jsonctx->in->current, 5, 0);
563 ly_in_skip(jsonctx->in, 5);
564 JSON_PUSH_STATUS_RET(jsonctx, LYJSON_FALSE);
565 LY_CHECK_RET(lyjson_check_next(jsonctx));
566
Michal Vasko69730152020-10-09 16:30:07 +0200567 } else if ((*jsonctx->in->current == 't') && !strncmp(jsonctx->in->current, "true", 4)) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200568 /* true */
569 lyjson_ctx_set_value(jsonctx, jsonctx->in->current, 4, 0);
570 ly_in_skip(jsonctx->in, 4);
571 JSON_PUSH_STATUS_RET(jsonctx, LYJSON_TRUE);
572 LY_CHECK_RET(lyjson_check_next(jsonctx));
573
Michal Vasko69730152020-10-09 16:30:07 +0200574 } else if ((*jsonctx->in->current == 'n') && !strncmp(jsonctx->in->current, "null", 4)) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200575 /* none */
576 lyjson_ctx_set_value(jsonctx, jsonctx->in->current, 0, 0);
577 ly_in_skip(jsonctx->in, 4);
578 JSON_PUSH_STATUS_RET(jsonctx, LYJSON_NULL);
579 LY_CHECK_RET(lyjson_check_next(jsonctx));
580
581 } else if (*jsonctx->in->current == '"') {
582 /* string */
583 ly_in_skip(jsonctx->in, 1);
584 LY_CHECK_RET(lyjson_string(jsonctx));
585
586 } else if (*jsonctx->in->current == '[') {
587 /* array */
588 ly_in_skip(jsonctx->in, 1);
589 LY_CHECK_RET(lyjson_array(jsonctx));
590
591 } else if (*jsonctx->in->current == '{') {
592 /* object */
593 ly_in_skip(jsonctx->in, 1);
594 LY_CHECK_RET(lyjson_object(jsonctx));
595
Michal Vasko69730152020-10-09 16:30:07 +0200596 } else if ((*jsonctx->in->current == '-') || ((*jsonctx->in->current >= '0') && (*jsonctx->in->current <= '9'))) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200597 /* number */
598 LY_CHECK_RET(lyjson_number(jsonctx));
599
600 } else {
601 /* unexpected value */
602 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LY_VCODE_INSTREXP, LY_VCODE_INSTREXP_len(jsonctx->in->current),
Michal Vasko69730152020-10-09 16:30:07 +0200603 jsonctx->in->current, "a JSON value");
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200604 return LY_EVALID;
605 }
606
607 return LY_SUCCESS;
608}
609
610LY_ERR
611lyjson_ctx_new(const struct ly_ctx *ctx, struct ly_in *in, struct lyjson_ctx **jsonctx_p)
612{
613 LY_ERR ret = LY_SUCCESS;
614 struct lyjson_ctx *jsonctx;
615
616 assert(ctx);
617 assert(in);
618 assert(jsonctx_p);
619
620 /* new context */
621 jsonctx = calloc(1, sizeof *jsonctx);
622 LY_CHECK_ERR_RET(!jsonctx, LOGMEM(ctx), LY_EMEM);
623 jsonctx->ctx = ctx;
624 jsonctx->line = 1;
625 jsonctx->in = in;
626
627 /* parse JSON value, if any */
628 LY_CHECK_GOTO(ret = skip_ws(jsonctx), cleanup);
629 if (lyjson_ctx_status(jsonctx, 0) == LYJSON_END) {
630 /* empty data input */
631 goto cleanup;
632 }
633
634 ret = lyjson_value(jsonctx);
635
Michal Vasko69730152020-10-09 16:30:07 +0200636 if ((jsonctx->status.count > 1) && (lyjson_ctx_status(jsonctx, 0) == LYJSON_END)) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200637 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LY_VCODE_EOF);
638 ret = LY_EVALID;
639 }
640
641cleanup:
642 if (ret) {
643 lyjson_ctx_free(jsonctx);
644 } else {
645 *jsonctx_p = jsonctx;
646 }
647 return ret;
648}
649
650void
651lyjson_ctx_backup(struct lyjson_ctx *jsonctx)
652{
653 if (jsonctx->backup.dynamic) {
654 free((char *)jsonctx->backup.value);
655 }
656 jsonctx->backup.status = lyjson_ctx_status(jsonctx, 0);
657 jsonctx->backup.status_count = jsonctx->status.count;
658 jsonctx->backup.value = jsonctx->value;
659 jsonctx->backup.value_len = jsonctx->value_len;
660 jsonctx->backup.input = jsonctx->in->current;
661 jsonctx->backup.dynamic = jsonctx->dynamic;
662 jsonctx->dynamic = 0;
663}
664
665void
666lyjson_ctx_restore(struct lyjson_ctx *jsonctx)
667{
668 if (jsonctx->dynamic) {
669 free((char *)jsonctx->value);
670 }
671 jsonctx->status.count = jsonctx->backup.status_count;
Michal Vasko22df3f02020-08-24 13:29:22 +0200672 jsonctx->status.objs[jsonctx->backup.status_count - 1] = (void *)jsonctx->backup.status;
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200673 jsonctx->value = jsonctx->backup.value;
674 jsonctx->value_len = jsonctx->backup.value_len;
675 jsonctx->in->current = jsonctx->backup.input;
676 jsonctx->dynamic = jsonctx->backup.dynamic;
677 jsonctx->backup.dynamic = 0;
678}
679
680LY_ERR
681lyjson_ctx_next(struct lyjson_ctx *jsonctx, enum LYJSON_PARSER_STATUS *status)
682{
683 LY_ERR ret = LY_SUCCESS;
Radek Krejci857189e2020-09-01 13:26:36 +0200684 ly_bool toplevel = 0;
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200685 enum LYJSON_PARSER_STATUS prev;
686
687 assert(jsonctx);
688
689 prev = lyjson_ctx_status(jsonctx, 0);
690
Michal Vasko69730152020-10-09 16:30:07 +0200691 if ((prev == LYJSON_OBJECT) || (prev == LYJSON_ARRAY)) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200692 /* get value for the object's member OR the first value in the array */
693 ret = lyjson_value(jsonctx);
694 goto result;
695 } else {
696 /* the previous token is closed and should be completely processed */
697 JSON_POP_STATUS_RET(jsonctx);
698 prev = lyjson_ctx_status(jsonctx, 0);
699 }
700
701 if (!jsonctx->status.count) {
702 /* we are done with the top level value */
703 toplevel = 1;
704 }
705 LY_CHECK_RET(skip_ws(jsonctx));
706 if (toplevel && !jsonctx->status.count) {
707 /* EOF expected, but there are some data after the top level token */
708 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LYVE_SYNTAX,
Michal Vasko69730152020-10-09 16:30:07 +0200709 "Expecting end-of-input, but some data follows the top level JSON value.");
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200710 return LY_EVALID;
711 }
712
713 if (toplevel) {
714 /* we are done */
715 return LY_SUCCESS;
716 }
717
718 /* continue with the next token */
719 assert(prev == LYJSON_OBJECT || prev == LYJSON_ARRAY);
720
721 if (*jsonctx->in->current == ',') {
722 /* sibling item in the ... */
723 ly_in_skip(jsonctx->in, 1);
724 LY_CHECK_RET(skip_ws(jsonctx));
725
726 if (prev == LYJSON_OBJECT) {
727 /* ... object - get another object's member */
728 ret = lyjson_object_name(jsonctx);
729 } else { /* LYJSON_ARRAY */
730 /* ... array - get another complete value */
731 ret = lyjson_value(jsonctx);
732 }
Michal Vasko69730152020-10-09 16:30:07 +0200733 } else if (((prev == LYJSON_OBJECT) && (*jsonctx->in->current == '}')) || ((prev == LYJSON_ARRAY) && (*jsonctx->in->current == ']'))) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200734 ly_in_skip(jsonctx->in, 1);
735 JSON_POP_STATUS_RET(jsonctx);
736 JSON_PUSH_STATUS_RET(jsonctx, prev + 1);
737 } else {
738 /* unexpected value */
739 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LY_VCODE_INSTREXP, LY_VCODE_INSTREXP_len(jsonctx->in->current),
Michal Vasko69730152020-10-09 16:30:07 +0200740 jsonctx->in->current, prev == LYJSON_ARRAY ? "another JSON value in array" : "another JSON object's member");
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200741 return LY_EVALID;
742 }
743
744result:
Michal Vasko69730152020-10-09 16:30:07 +0200745 if ((ret == LY_SUCCESS) && (jsonctx->status.count > 1) && (lyjson_ctx_status(jsonctx, 0) == LYJSON_END)) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200746 LOGVAL(jsonctx->ctx, LY_VLOG_LINE, &jsonctx->line, LY_VCODE_EOF);
747 ret = LY_EVALID;
748 }
749
Michal Vasko69730152020-10-09 16:30:07 +0200750 if ((ret == LY_SUCCESS) && status) {
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200751 *status = lyjson_ctx_status(jsonctx, 0);
752 }
753
754 return ret;
755}
756
757enum LYJSON_PARSER_STATUS
758lyjson_ctx_status(struct lyjson_ctx *jsonctx, uint32_t index)
759{
760 assert(jsonctx);
761
762 if (jsonctx->status.count < index) {
763 return LYJSON_ERROR;
764 } else if (jsonctx->status.count == index) {
765 return LYJSON_ROOT;
766 } else {
Michal Vasko27915722020-08-31 14:54:42 +0200767 return (enum LYJSON_PARSER_STATUS)(uintptr_t)jsonctx->status.objs[jsonctx->status.count - (index + 1)];
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200768 }
769}
770
771void
772lyjson_ctx_free(struct lyjson_ctx *jsonctx)
773{
774 if (!jsonctx) {
775 return;
776 }
777
778 if (jsonctx->dynamic) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200779 free((char *)jsonctx->value);
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200780 }
781 if (jsonctx->backup.dynamic) {
782 free((char *)jsonctx->backup.value);
783 }
784
785 ly_set_erase(&jsonctx->status, NULL);
786
787 free(jsonctx);
788}