2 * Copyright (c) 2009-2011 Petri Lehtinen <petri@digip.org>
3 * Copyright (c) 2011 Graeme Smecher <graeme.smecher@mail.mcgill.ca>
5 * Jansson is free software; you can redistribute it and/or modify
6 * it under the terms of the MIT license. See LICENSE for details.
11 #include "jansson_private.h"
24 static const char *type_names[] = {
35 #define type_name(x) type_names[json_typeof(x)]
37 static const char *unpack_value_starters = "{[siIbfFOon";
40 static void scanner_init(scanner_t *s, json_error_t *error,
41 size_t flags, const char *fmt)
45 s->fmt = s->start = fmt;
50 static void next_token(scanner_t *s)
52 const char *t = s->fmt;
55 /* skip space and ignored chars */
56 while(*t == ' ' || *t == '\t' || *t == '\n' || *t == ',' || *t == ':') {
73 static void set_error(scanner_t *s, const char *source, const char *fmt, ...)
79 pos = (size_t)(s->fmt - s->start);
80 jsonp_error_vset(s->error, s->line, s->column, pos, fmt, ap);
82 jsonp_error_set_source(s->error, source);
87 static json_t *pack(scanner_t *s, va_list *ap);
89 static json_t *pack_object(scanner_t *s, va_list *ap)
91 json_t *object = json_object();
94 while(s->token != '}') {
99 set_error(s, "<format>", "Unexpected end of format string");
103 if(s->token != 's') {
104 set_error(s, "<format>", "Expected format 's', got '%c'", s->token);
108 key = va_arg(*ap, const char *);
110 set_error(s, "<args>", "NULL object key");
114 if(!utf8_check_string(key, -1)) {
115 set_error(s, "<args>", "Invalid UTF-8 in object key");
125 if(json_object_set_new_nocheck(object, key, value)) {
126 set_error(s, "<internal>", "Unable to add key \"%s\"", key);
140 static json_t *pack_array(scanner_t *s, va_list *ap)
142 json_t *array = json_array();
145 while(s->token != ']') {
149 set_error(s, "<format>", "Unexpected end of format string");
157 if(json_array_append_new(array, value)) {
158 set_error(s, "<internal>", "Unable to append to array");
171 static json_t *pack(scanner_t *s, va_list *ap)
175 return pack_object(s, ap);
178 return pack_array(s, ap);
180 case 's': /* string */
182 const char *str = va_arg(*ap, const char *);
184 set_error(s, "<args>", "NULL string argument");
187 if(!utf8_check_string(str, -1)) {
188 set_error(s, "<args>", "Invalid UTF-8 string");
191 return json_string_nocheck(str);
197 case 'b': /* boolean */
198 return va_arg(*ap, int) ? json_true() : json_false();
200 case 'i': /* integer from int */
201 return json_integer(va_arg(*ap, int));
203 case 'I': /* integer from json_int_t */
204 return json_integer(va_arg(*ap, json_int_t));
207 return json_real(va_arg(*ap, double));
209 case 'O': /* a json_t object; increments refcount */
210 return json_incref(va_arg(*ap, json_t *));
212 case 'o': /* a json_t object; doesn't increment refcount */
213 return va_arg(*ap, json_t *);
216 set_error(s, "<format>", "Unexpected format character '%c'",
222 static int unpack(scanner_t *s, json_t *root, va_list *ap);
224 static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
229 /* Use a set (emulated by a hashtable) to check that all object
230 keys are accessed. Checking that the correct number of keys
231 were accessed is not enough, as the same key can be unpacked
236 if(hashtable_init(&key_set)) {
237 set_error(s, "<internal>", "Out of memory");
241 if(root && !json_is_object(root)) {
242 set_error(s, "<validation>", "Expected object, got %s",
248 while(s->token != '}') {
254 set_error(s, "<format>", "Expected '}' after '%c', got '%c'",
255 (strict == 1 ? '!' : '*'), s->token);
260 set_error(s, "<format>", "Unexpected end of format string");
264 if(s->token == '!' || s->token == '*') {
265 strict = (s->token == '!' ? 1 : -1);
270 if(s->token != 's') {
271 set_error(s, "<format>", "Expected format 's', got '%c'", s->token);
275 key = va_arg(*ap, const char *);
277 set_error(s, "<args>", "NULL object key");
283 if(s->token == '?') {
293 value = json_object_get(root, key);
295 set_error(s, "<validation>", "Object item not found: %s", key);
300 if(unpack(s, value, ap))
303 hashtable_set(&key_set, key, 0, json_null());
307 if(strict == 0 && (s->flags & JSON_STRICT))
310 if(root && strict == 1 && key_set.size != json_object_size(root)) {
311 long diff = (long)json_object_size(root) - (long)key_set.size;
312 set_error(s, "<validation>", "%li object item(s) left unpacked", diff);
319 hashtable_close(&key_set);
323 static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
328 if(root && !json_is_array(root)) {
329 set_error(s, "<validation>", "Expected array, got %s", type_name(root));
334 while(s->token != ']') {
338 set_error(s, "<format>", "Expected ']' after '%c', got '%c'",
339 (strict == 1 ? '!' : '*'),
345 set_error(s, "<format>", "Unexpected end of format string");
349 if(s->token == '!' || s->token == '*') {
350 strict = (s->token == '!' ? 1 : -1);
355 if(!strchr(unpack_value_starters, s->token)) {
356 set_error(s, "<format>", "Unexpected format character '%c'",
366 value = json_array_get(root, i);
368 set_error(s, "<validation>", "Array index %lu out of range",
374 if(unpack(s, value, ap))
381 if(strict == 0 && (s->flags & JSON_STRICT))
384 if(root && strict == 1 && i != json_array_size(root)) {
385 long diff = (long)json_array_size(root) - (long)i;
386 set_error(s, "<validation>", "%li array item(s) left unpacked", diff);
393 static int unpack(scanner_t *s, json_t *root, va_list *ap)
398 return unpack_object(s, root, ap);
401 return unpack_array(s, root, ap);
404 if(root && !json_is_string(root)) {
405 set_error(s, "<validation>", "Expected string, got %s",
410 if(!(s->flags & JSON_VALIDATE_ONLY)) {
413 target = va_arg(*ap, const char **);
415 set_error(s, "<args>", "NULL string argument");
420 *target = json_string_value(root);
425 if(root && !json_is_integer(root)) {
426 set_error(s, "<validation>", "Expected integer, got %s",
431 if(!(s->flags & JSON_VALIDATE_ONLY)) {
432 int *target = va_arg(*ap, int*);
434 *target = json_integer_value(root);
440 if(root && !json_is_integer(root)) {
441 set_error(s, "<validation>", "Expected integer, got %s",
446 if(!(s->flags & JSON_VALIDATE_ONLY)) {
447 json_int_t *target = va_arg(*ap, json_int_t*);
449 *target = json_integer_value(root);
455 if(root && !json_is_boolean(root)) {
456 set_error(s, "<validation>", "Expected true or false, got %s",
461 if(!(s->flags & JSON_VALIDATE_ONLY)) {
462 int *target = va_arg(*ap, int*);
464 *target = json_is_true(root);
470 if(root && !json_is_real(root)) {
471 set_error(s, "<validation>", "Expected real, got %s",
476 if(!(s->flags & JSON_VALIDATE_ONLY)) {
477 double *target = va_arg(*ap, double*);
479 *target = json_real_value(root);
485 if(root && !json_is_number(root)) {
486 set_error(s, "<validation>", "Expected real or integer, got %s",
491 if(!(s->flags & JSON_VALIDATE_ONLY)) {
492 double *target = va_arg(*ap, double*);
494 *target = json_number_value(root);
500 if(root && !(s->flags & JSON_VALIDATE_ONLY))
505 if(!(s->flags & JSON_VALIDATE_ONLY)) {
506 json_t **target = va_arg(*ap, json_t**);
514 /* Never assign, just validate */
515 if(root && !json_is_null(root)) {
516 set_error(s, "<validation>", "Expected null, got %s",
523 set_error(s, "<format>", "Unexpected format character '%c'",
529 json_t *json_vpack_ex(json_error_t *error, size_t flags,
530 const char *fmt, va_list ap)
537 jsonp_error_init(error, "<format>");
538 jsonp_error_set(error, -1, -1, 0, "NULL or empty format string");
541 jsonp_error_init(error, NULL);
543 scanner_init(&s, error, flags, fmt);
546 va_copy(ap_copy, ap);
547 value = pack(&s, &ap_copy);
556 set_error(&s, "<format>", "Garbage after format string");
563 json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...)
569 value = json_vpack_ex(error, flags, fmt, ap);
575 json_t *json_pack(const char *fmt, ...)
581 value = json_vpack_ex(NULL, 0, fmt, ap);
587 int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags,
588 const char *fmt, va_list ap)
594 jsonp_error_init(error, "<root>");
595 jsonp_error_set(error, -1, -1, 0, "NULL root value");
600 jsonp_error_init(error, "<format>");
601 jsonp_error_set(error, -1, -1, 0, "NULL or empty format string");
604 jsonp_error_init(error, NULL);
606 scanner_init(&s, error, flags, fmt);
609 va_copy(ap_copy, ap);
610 if(unpack(&s, root, &ap_copy)) {
618 set_error(&s, "<format>", "Garbage after format string");
625 int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, ...)
631 ret = json_vunpack_ex(root, error, flags, fmt, ap);
637 int json_unpack(json_t *root, const char *fmt, ...)
643 ret = json_vunpack_ex(root, NULL, 0, fmt, ap);