FGCOM/jansson
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
4601bf71e5
jansson/src/pack_unpack.c

648 lines
15 KiB
C
Raw Normal View History

Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
/*
Update copyright notices for 2012
2012-03-21 02:55:55 +08:00
* Copyright (c) 2009-2012 Petri Lehtinen <petri@digip.org>
* Copyright (c) 2011-2012 Graeme Smecher <graeme.smecher@mail.mcgill.ca>
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
*
* Jansson is free software; you can redistribute it and/or modify
* it under the terms of the MIT license. See LICENSE for details.
*/
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
#include <string.h>
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
#include <jansson.h>
#include "jansson_private.h"
Fix packing of invalid UTF-8 strings
2011-02-28 03:34:12 +08:00
#include "utf.h"
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
typedef struct {
Refactor decoder input stream - Add a new field position to the json_error_t structure. This is the position in bytes from the beginning of the input. - Keep track of line, column and input position in the stream level. Previously, only line was tracked, and it was in the lexer level, so this info was not available for UTF-8 decoding errors. - While at it, refactor tests so that no separate "stripped" tests are required. json_process is now able to strip whitespace from its input, and the "valid" and "invalid" test suites now use this to test both non-stripped and stripped input. Closes GH-9.
2011-02-22 16:47:02 +08:00
const char *start;
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
const char *fmt;
char token;
json_error_t *error;
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
size_t flags;
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
int line;
int column;
} scanner_t;
unpack: Unify and enhance error messages Give the type name instead of its enum index in the error message when an unexpected value is encountered while unpacking.
2011-01-26 02:37:53 +08:00
static const char *type_names[] = {
"object",
"array",
"string",
"integer",
"real",
"true",
"false",
"null"
};
#define type_name(x) type_names[json_typeof(x)]
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
static const char *unpack_value_starters = "{[siIbfFOon";
static void scanner_init(scanner_t *s, json_error_t *error,
size_t flags, const char *fmt)
{
s->error = error;
s->flags = flags;
s->fmt = s->start = fmt;
s->line = 1;
s->column = 0;
}
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
static void next_token(scanner_t *s)
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
{
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
const char *t = s->fmt;
s->column++;
/* skip space and ignored chars */
while(*t == ' ' || *t == '\t' || *t == '\n' || *t == ',' || *t == ':') {
if(*t == '\n') {
s->line++;
s->column = 1;
}
else
s->column++;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
t++;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
s->token = *t;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
t++;
s->fmt = t;
}
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
static void set_error(scanner_t *s, const char *source, const char *fmt, ...)
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
{
va_list ap;
Refactor decoder input stream - Add a new field position to the json_error_t structure. This is the position in bytes from the beginning of the input. - Keep track of line, column and input position in the stream level. Previously, only line was tracked, and it was in the lexer level, so this info was not available for UTF-8 decoding errors. - While at it, refactor tests so that no separate "stripped" tests are required. json_process is now able to strip whitespace from its input, and the "valid" and "invalid" test suites now use this to test both non-stripped and stripped input. Closes GH-9.
2011-02-22 16:47:02 +08:00
size_t pos;
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
va_start(ap, fmt);
Refactor decoder input stream - Add a new field position to the json_error_t structure. This is the position in bytes from the beginning of the input. - Keep track of line, column and input position in the stream level. Previously, only line was tracked, and it was in the lexer level, so this info was not available for UTF-8 decoding errors. - While at it, refactor tests so that no separate "stripped" tests are required. json_process is now able to strip whitespace from its input, and the "valid" and "invalid" test suites now use this to test both non-stripped and stripped input. Closes GH-9.
2011-02-22 16:47:02 +08:00
pos = (size_t)(s->fmt - s->start);
jsonp_error_vset(s->error, s->line, s->column, pos, fmt, ap);
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
jsonp_error_set_source(s->error, source);
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
va_end(ap);
}
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
static json_t *pack(scanner_t *s, va_list *ap);
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
static json_t *pack_object(scanner_t *s, va_list *ap)
{
json_t *object = json_object();
next_token(s);
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
while(s->token != '}') {
const char *key;
json_t *value;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
if(!s->token) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<format>", "Unexpected end of format string");
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
goto error;
}
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
if(s->token != 's') {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<format>", "Expected format 's', got '%c'", s->token);
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
goto error;
}
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
key = va_arg(*ap, const char *);
if(!key) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<args>", "NULL object key");
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
goto error;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Fix packing of invalid UTF-8 strings
2011-02-28 03:34:12 +08:00
if(!utf8_check_string(key, -1)) {
set_error(s, "<args>", "Invalid UTF-8 in object key");
goto error;
}
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
next_token(s);
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
value = pack(s, ap);
if(!value)
goto error;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Fix packing of invalid UTF-8 strings
2011-02-28 03:34:12 +08:00
if(json_object_set_new_nocheck(object, key, value)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<internal>", "Unable to add key \"%s\"", key);
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
goto error;
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
next_token(s);
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
return object;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
error:
json_decref(object);
return NULL;
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
static json_t *pack_array(scanner_t *s, va_list *ap)
{
json_t *array = json_array();
next_token(s);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
while(s->token != ']') {
json_t *value;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
if(!s->token) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<format>", "Unexpected end of format string");
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
goto error;
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
value = pack(s, ap);
if(!value)
goto error;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
if(json_array_append_new(array, value)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<internal>", "Unable to append to array");
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
goto error;
}
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
next_token(s);
}
return array;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
error:
json_decref(array);
return NULL;
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
static json_t *pack(scanner_t *s, va_list *ap)
{
switch(s->token) {
case '{':
return pack_object(s, ap);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
case '[':
return pack_array(s, ap);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
case 's': /* string */
{
const char *str = va_arg(*ap, const char *);
unpack: Unify and enhance error messages Give the type name instead of its enum index in the error message when an unexpected value is encountered while unpacking.
2011-01-26 02:37:53 +08:00
if(!str) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<args>", "NULL string argument");
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
return NULL;
}
Fix packing of invalid UTF-8 strings
2011-02-28 03:34:12 +08:00
if(!utf8_check_string(str, -1)) {
set_error(s, "<args>", "Invalid UTF-8 string");
return NULL;
}
return json_string_nocheck(str);
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
case 'n': /* null */
return json_null();
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
case 'b': /* boolean */
return va_arg(*ap, int) ? json_true() : json_false();
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Add the 'I' format for both pack and unpack
2011-01-26 03:41:35 +08:00
case 'i': /* integer from int */
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
return json_integer(va_arg(*ap, int));
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Add the 'I' format for both pack and unpack
2011-01-26 03:41:35 +08:00
case 'I': /* integer from json_int_t */
return json_integer(va_arg(*ap, json_int_t));
unpack: Unify and enhance error messages Give the type name instead of its enum index in the error message when an unexpected value is encountered while unpacking.
2011-01-26 02:37:53 +08:00
case 'f': /* real */
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
return json_real(va_arg(*ap, double));
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
case 'O': /* a json_t object; increments refcount */
return json_incref(va_arg(*ap, json_t *));
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
case 'o': /* a json_t object; doesn't increment refcount */
return va_arg(*ap, json_t *);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
unpack: Unify and enhance error messages Give the type name instead of its enum index in the error message when an unexpected value is encountered while unpacking.
2011-01-26 02:37:53 +08:00
default:
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<format>", "Unexpected format character '%c'",
s->token);
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
return NULL;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
}
}
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
static int unpack(scanner_t *s, json_t *root, va_list *ap);
static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
{
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
int ret = -1;
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
int strict = 0;
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
/* Use a set (emulated by a hashtable) to check that all object
keys are accessed. Checking that the correct number of keys
were accessed is not enough, as the same key can be unpacked
multiple times.
*/
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
hashtable_t key_set;
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Make hashtable less generic This will make it possible to implement json_object_foreach(). It should also have some (positive) effect on speed.
2012-01-25 02:36:31 +08:00
if(hashtable_init(&key_set)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<internal>", "Out of memory");
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
return -1;
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
}
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && !json_is_object(root)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "Expected object, got %s",
type_name(root));
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
goto out;
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
}
next_token(s);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
while(s->token != '}') {
const char *key;
json_t *value;
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
int opt = 0;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
if(strict != 0) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<format>", "Expected '}' after '%c', got '%c'",
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
(strict == 1 ? '!' : '*'), s->token);
goto out;
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
}
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
if(!s->token) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<format>", "Unexpected end of format string");
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
goto out;
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
}
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
if(s->token == '!' || s->token == '*') {
strict = (s->token == '!' ? 1 : -1);
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
next_token(s);
continue;
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
if(s->token != 's') {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<format>", "Expected format 's', got '%c'", s->token);
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
goto out;
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
key = va_arg(*ap, const char *);
if(!key) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<args>", "NULL object key");
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
goto out;
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
next_token(s);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(s->token == '?') {
opt = 1;
next_token(s);
}
if(!root) {
/* skipping */
value = NULL;
}
else {
value = json_object_get(root, key);
if(!value && !opt) {
set_error(s, "<validation>", "Object item not found: %s", key);
goto out;
}
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
}
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
if(unpack(s, value, ap))
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
goto out;
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Make hashtable less generic This will make it possible to implement json_object_foreach(). It should also have some (positive) effect on speed.
2012-01-25 02:36:31 +08:00
hashtable_set(&key_set, key, 0, json_null());
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
next_token(s);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
}
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
if(strict == 0 && (s->flags & JSON_STRICT))
strict = 1;
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && strict == 1 && key_set.size != json_object_size(root)) {
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
long diff = (long)json_object_size(root) - (long)key_set.size;
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "%li object item(s) left unpacked", diff);
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
goto out;
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
}
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
ret = 0;
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
out:
hashtable_close(&key_set);
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
return ret;
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
}
static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
{
size_t i = 0;
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
int strict = 0;
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && !json_is_array(root)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "Expected array, got %s", type_name(root));
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
next_token(s);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
while(s->token != ']') {
json_t *value;
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
if(strict != 0) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<format>", "Expected ']' after '%c', got '%c'",
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
(strict == 1 ? '!' : '*'),
s->token);
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
return -1;
}
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
if(!s->token) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<format>", "Unexpected end of format string");
Unify style
2011-01-21 03:09:14 +08:00
return -1;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
if(s->token == '!' || s->token == '*') {
strict = (s->token == '!' ? 1 : -1);
Add validation features to json_unpack() * By default, json_unpack() now checks that all items of arrays and objects are unpacked. This is useful for validation. * Add format specifier '*' to suppress this check for individual arrays and objects. '*' must appear as the last format specifier before the closing ']' or '}'.
2011-01-25 03:45:54 +08:00
next_token(s);
continue;
}
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
if(!strchr(unpack_value_starters, s->token)) {
set_error(s, "<format>", "Unexpected format character '%c'",
s->token);
return -1;
}
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(!root) {
/* skipping */
value = NULL;
}
else {
value = json_array_get(root, i);
if(!value) {
set_error(s, "<validation>", "Array index %lu out of range",
(unsigned long)i);
return -1;
}
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
if(unpack(s, value, ap))
return -1;
next_token(s);
i++;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Tweak the default validation behaviour of the unpack API Now, by default, unpacking doesn't check that all array and object items are accessed. The check can be enabled globally by using the JSON_STRICT flag (formerly JSON_UNPACK_ONLY), or on a per-value basis by using the new '!' format character. The '*' format character is still available to disable the global check on a per-value basis.
2011-01-30 03:38:07 +08:00
if(strict == 0 && (s->flags & JSON_STRICT))
strict = 1;
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && strict == 1 && i != json_array_size(root)) {
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
long diff = (long)json_array_size(root) - (long)i;
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "%li array item(s) left unpacked", diff);
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return 0;
}
static int unpack(scanner_t *s, json_t *root, va_list *ap)
{
switch(s->token)
{
case '{':
return unpack_object(s, root, ap);
case '[':
return unpack_array(s, root, ap);
case 's':
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && !json_is_string(root)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "Expected string, got %s",
type_name(root));
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
}
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
if(!(s->flags & JSON_VALIDATE_ONLY)) {
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
const char **target;
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
target = va_arg(*ap, const char **);
if(!target) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<args>", "NULL string argument");
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
return -1;
}
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root)
*target = json_string_value(root);
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
}
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return 0;
case 'i':
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && !json_is_integer(root)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "Expected integer, got %s",
type_name(root));
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
}
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(!(s->flags & JSON_VALIDATE_ONLY)) {
int *target = va_arg(*ap, int*);
if(root)
*target = json_integer_value(root);
}
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return 0;
Add the 'I' format for both pack and unpack
2011-01-26 03:41:35 +08:00
case 'I':
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && !json_is_integer(root)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "Expected integer, got %s",
type_name(root));
Add the 'I' format for both pack and unpack
2011-01-26 03:41:35 +08:00
return -1;
}
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(!(s->flags & JSON_VALIDATE_ONLY)) {
json_int_t *target = va_arg(*ap, json_int_t*);
if(root)
*target = json_integer_value(root);
}
Add the 'I' format for both pack and unpack
2011-01-26 03:41:35 +08:00
return 0;
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
case 'b':
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && !json_is_boolean(root)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "Expected true or false, got %s",
type_name(root));
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
}
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(!(s->flags & JSON_VALIDATE_ONLY)) {
int *target = va_arg(*ap, int*);
if(root)
*target = json_is_true(root);
}
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return 0;
case 'f':
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && !json_is_real(root)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "Expected real, got %s",
type_name(root));
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
}
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(!(s->flags & JSON_VALIDATE_ONLY)) {
double *target = va_arg(*ap, double*);
if(root)
*target = json_real_value(root);
}
Use 'f' for real and 'F' for number (real or integer) in unpack
2011-01-26 02:42:41 +08:00
return 0;
case 'F':
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && !json_is_number(root)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "Expected real or integer, got %s",
Use 'f' for real and 'F' for number (real or integer) in unpack
2011-01-26 02:42:41 +08:00
type_name(root));
return -1;
}
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(!(s->flags & JSON_VALIDATE_ONLY)) {
double *target = va_arg(*ap, double*);
if(root)
*target = json_number_value(root);
}
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return 0;
case 'O':
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && !(s->flags & JSON_VALIDATE_ONLY))
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
json_incref(root);
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
/* Fall through */
case 'o':
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(!(s->flags & JSON_VALIDATE_ONLY)) {
json_t **target = va_arg(*ap, json_t**);
if(root)
*target = root;
}
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return 0;
case 'n':
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
/* Never assign, just validate */
Add support for optional object keys for json_unpack() and friends Initial patch by Andrew Thompson.
2012-01-27 03:13:07 +08:00
if(root && !json_is_null(root)) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<validation>", "Expected null, got %s",
type_name(root));
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
}
return 0;
default:
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(s, "<format>", "Unexpected format character '%c'",
s->token);
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
}
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
json_t *json_vpack_ex(json_error_t *error, size_t flags,
const char *fmt, va_list ap)
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
{
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
scanner_t s;
Resolve __va_list_tag ** -> va_list * type errors with clang and future GCCs Functions taking va_args are munged to receive arguments of type '__va_list_tag *'. This patch uses va_copy to coerce them to the expected type so we don't get compiler errors. Tested on x86_64, both 32-bit and 64-bit compiles. Reported-By: Basile Starynkevitch <basile@starynkevitch.net>
2011-02-03 23:51:26 +08:00
va_list ap_copy;
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
json_t *value;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
if(!fmt || !*fmt) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
jsonp_error_init(error, "<format>");
jsonp_error_set(error, -1, -1, 0, "NULL or empty format string");
Unify style
2011-01-21 03:09:14 +08:00
return NULL;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
jsonp_error_init(error, NULL);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
scanner_init(&s, error, flags, fmt);
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
next_token(&s);
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
Resolve __va_list_tag ** -> va_list * type errors with clang and future GCCs Functions taking va_args are munged to receive arguments of type '__va_list_tag *'. This patch uses va_copy to coerce them to the expected type so we don't get compiler errors. Tested on x86_64, both 32-bit and 64-bit compiles. Reported-By: Basile Starynkevitch <basile@starynkevitch.net>
2011-02-03 23:51:26 +08:00
va_copy(ap_copy, ap);
value = pack(&s, &ap_copy);
va_end(ap_copy);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
if(!value)
return NULL;
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
next_token(&s);
if(s.token) {
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
json_decref(value);
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(&s, "<format>", "Garbage after format string");
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
return NULL;
}
return value;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...)
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
{
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
json_t *value;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
va_list ap;
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
va_start(ap, fmt);
value = json_vpack_ex(error, flags, fmt, ap);
va_end(ap);
return value;
}
json_t *json_pack(const char *fmt, ...)
{
json_t *value;
va_list ap;
va_start(ap, fmt);
value = json_vpack_ex(NULL, 0, fmt, ap);
va_end(ap);
return value;
}
int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags,
const char *fmt, va_list ap)
{
scanner_t s;
Resolve __va_list_tag ** -> va_list * type errors with clang and future GCCs Functions taking va_args are munged to receive arguments of type '__va_list_tag *'. This patch uses va_copy to coerce them to the expected type so we don't get compiler errors. Tested on x86_64, both 32-bit and 64-bit compiles. Reported-By: Basile Starynkevitch <basile@starynkevitch.net>
2011-02-03 23:51:26 +08:00
va_list ap_copy;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
if(!root) {
jsonp_error_init(error, "<root>");
jsonp_error_set(error, -1, -1, 0, "NULL root value");
return -1;
}
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
if(!fmt || !*fmt) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
jsonp_error_init(error, "<format>");
jsonp_error_set(error, -1, -1, 0, "NULL or empty format string");
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
}
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
jsonp_error_init(error, NULL);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
scanner_init(&s, error, flags, fmt);
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
next_token(&s);
Resolve __va_list_tag ** -> va_list * type errors with clang and future GCCs Functions taking va_args are munged to receive arguments of type '__va_list_tag *'. This patch uses va_copy to coerce them to the expected type so we don't get compiler errors. Tested on x86_64, both 32-bit and 64-bit compiles. Reported-By: Basile Starynkevitch <basile@starynkevitch.net>
2011-02-03 23:51:26 +08:00
va_copy(ap_copy, ap);
if(unpack(&s, root, &ap_copy)) {
va_end(ap_copy);
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
Resolve __va_list_tag ** -> va_list * type errors with clang and future GCCs Functions taking va_args are munged to receive arguments of type '__va_list_tag *'. This patch uses va_copy to coerce them to the expected type so we don't get compiler errors. Tested on x86_64, both 32-bit and 64-bit compiles. Reported-By: Basile Starynkevitch <basile@starynkevitch.net>
2011-02-03 23:51:26 +08:00
}
va_end(ap_copy);
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
next_token(&s);
if(s.token) {
Add lots of tests for pack/unpack code, fix bugs found Closes GH-12.
2011-02-23 01:08:41 +08:00
set_error(&s, "<format>", "Garbage after format string");
Refactor json_unpack() * Use the format string scanner from the previous commit (with the simpler separator skipping semantics) * Split json_vnunpack() to three separate functions for unpacking objects, arrays and "simple" values * Always return 0 on success, 1 on error This shaves around 100 more lines from the original implementation.
2011-01-25 03:20:56 +08:00
return -1;
}
return 0;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
}
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, ...)
{
int ret;
va_list ap;
va_start(ap, fmt);
ret = json_vunpack_ex(root, error, flags, fmt, ap);
va_end(ap);
return ret;
}
int json_unpack(json_t *root, const char *fmt, ...)
{
int ret;
va_list ap;
va_start(ap, fmt);
ret = json_vunpack_ex(root, NULL, 0, fmt, ap);
va_end(ap);
return ret;
}
Reference in New Issue Copy Permalink