https://github.com/holixus/nanojson
A small footprint(code and memory) simple JSON parsing C library for embedded projects
https://github.com/holixus/nanojson
json json-parser
Last synced: 2 months ago
JSON representation
A small footprint(code and memory) simple JSON parsing C library for embedded projects
- Host: GitHub
- URL: https://github.com/holixus/nanojson
- Owner: Holixus
- License: gpl-3.0
- Created: 2019-12-16T10:49:26.000Z (over 6 years ago)
- Default Branch: master
- Last Pushed: 2023-02-10T17:35:44.000Z (over 3 years ago)
- Last Synced: 2025-03-25T11:27:41.472Z (over 1 year ago)
- Topics: json, json-parser
- Language: C
- Size: 68.4 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# nanojson
A small footprint(code and memory) simple [JSON](https://www.rfc-editor.org/rfc/rfc8259.html) parsing C library for embedded projects
* 64 bits integers(optional)
* Hexadecimal("0x") integers(optional)
* Good tests coverage
* Buildable without float/double support
* Ability to parse JSON text without malloc usage
# Build
```
# cmake -DJSON_64BITS_INTEGERS=OFF -DJSON_HEX_NUMBERS=OFF -DJSON_FLOATS=OFF.
# make
```
## Build options
* `BUILD_SHARED_LIBRARY`(OFF) -- Build shared library (not only static)
* `JSON_64BITS_INTEGERS`(OFF) -- Enable support of 64 bits integers
* `JSON_HEX_NUMBERS`(OFF) -- Enabled support of 0x integers
* `JSON_FLOATS`(OFF) -- Enable support of Floating point Numbers
* `JSON_SHORT_NEXT`(OFF) -- Use `short` type for next field of jsn_t
* `JSON_PACKED`(OFF) -- Use packed json item structure
* `JSON_AUTO_PARSE_FN`(ON) -- Build json_auto_parse() function
* `JSON_AUTO_PARSE_POOL_START_SIZE`(32) -- Initial jsn_t array size
* `JSON_AUTO_PARSE_POOL_INCREASE`(n+32) -- Increase jsn_t array size formula
* `JSON_STRINGIFY_FN`(ON) -- Build json_stringify() function
* `JSON_GET_FN`(ON) -- Build json_get() function
* `JSON_MAX_ID_LENGTH`(64) -- Maximum identifiers length in path for json_get function
* `BUILD_TESTS`(ON) -- Build tests application
# Include files
```c
#include
```
# Nodes types
```c
typedef
enum {
JS_UNDEFINED=1, JS_NULL, JS_BOOLEAN, JS_NUMBER, JS_FLOAT, JS_STRING, JS_ARRAY, JS_OBJECT
} nj_type_t;
```
# jsn_t
```c
#ifdef JSON_64BITS_INTEGERS
typedef int64_t jsn_number_t;
#else
typedef int32_t jsn_number_t;
#endif
#ifdef JSON_SHORT_NEXT
typedef short jsn_next_t;
#else
typedef int jsn_next_t;
#endif
typedef
struct jsn {
union {
char *string; /* string id of the node in the parent object */
unsigned int number; /* integer index of the node in the parent array */
} id;
union {
jsn_number_t number;
char *string;
jsn_next_t length; /* number of object/array elements */
#ifdef JSON_FLOATS
double floating;
#endif
} data;
jsn_next_t next; /* index offset to next sibling node (0 - parent node offset) */
char id_type; /* type of id. JS_NUMBER(for array) or JS_STRING(for object) */
char type; /* type of data (nj_type_t) */
}
#ifdef JSON_PACKED
__attribute__((packed))
#endif
jsn_t;
```
# Functions
## `int json_parse(jsn_t *pool, size_t size, char *text)`
* `pool` -- pointer to (somewhere allocated) array of `jsn_t` elements
* `size` -- number of pool elements
* `text` -- JSON text source. Will be corrupted because all strings will be stored in this buffer.
Parse JSON text to array of nodes. The first node is always root node. If parsing made succesfully
then source text memory will be used for storing of values identifiers and strings.
Please, don't forget this.
### Return value
The function return a number of used `jsn_t` elements of array pointed by `pool` argument.
On error, negative value is returned, and errno is set appropriately.
### Errors
* `ENOMEM` passed array of `jsn_t` elements is not enough for store parsed JSON data tree.
* `EINVAL` impossible to parse passed JSON text. The returned negative value is offset to broken
place of JSON code and text buffer will not be corrupted by parsing.
### Example
```c
jsn_t json[100];
int len = json_parse(json, sizeof json / sizeof json[0], text);
if (len < 0) {
perror("json_parse");
...
}
...
```
## `jsn_t *json_auto_parse(char *text, char **end)`
* `text` -- JSON text source. Will be corrupted because all strings will be stored in this buffer.
* `end` -- in case of parsing error by the .
Parse JSON `text`.
### Return value
The function return a pointer to array `jsn_t` elements. Should be released by `free()`.
On error, NULL is returned, and errno is set appropriately.
### Errors
* `ENOMEM` Out of memory.
* `EINVAL` impossible to parse passed JSON text. If `end` is not NULL, a pointer to broken
JSON code will be stored in the pointer referenced by `end`. The text buffer will not be corrupted by parser.
### Example
```c
char *err_pos;
jsn_t *json = json_auto_parse(text, &err_pos);
if (!json) {
if (errno == EINVAL) {
char crop[50];
snprintf(crop, sizeof crop, "%s", err_pos);
perror("json_auto_parse: JSON syntax error at the code '%s'", crop);
} else
perror("json_auto_parse");
return -1;
}
...
free(json);
```
## `char *json_stringify(char *out, size_t size, jsn_t *root)`
* `outbuf` -- output buffer for JSON text
* `size` -- size of output buffer including terminating zero
* `root` -- root element of json tree
Convert parsed JSON tree back to text. May be useful for debugging purpose.
### Return value
Return pointer to output buffer.
### Example
```c
int source_len = strlen(source);
jsn_t *json = json_auto_parse(source, NULL);
if (!json)
return -1;
char string[source_len * 2];
json_stringify(string, sizeof string, json);
free(json);
printf("JSON: %s\n", string);
return 0;
```
## `jsn_t *json_item(jsn_t *node, char const *id)`
* `node` -- object json node to search element
* `id` -- string identifier of object element
Returns element of object with `id` or NULL if absent.
### Errors
* `ENOENT` there is no element with `id` value.
* `ENOTDIR` the `node` is not object type.
## `jsn_t *json_cell(jsn_t *node, int index)`
* `node` -- array json node to search element
* `index` -- index of array element
Returns element of array with `index` or NULL if absent.
### Errors
* `ENOENT` there is no element with `index` value.
* `ENOTDIR` the `node` is not array type.
## `jsn_t *json_get(jsn_t *node, char const *path)`
* `node` -- array json node to search element
* `path` -- qualified path of JSON item
Returns element of json with `path` or NULL if absent. If `path` is empty string then returns the `node` value.
### Errors
* `ENOENT` there is no element in `path`.
* `ENOTDIR` wrong node type in path.
* `EINVAL` impossible to parse passed `path`.
### Sample
```c
char const json[] =
"{"
"\"0\":\"value\","
"\"key\":555,"
"\"array\":["
"0,1,2,3,4,5"
"],"
"\"obj\":{"
"\"ololo\":["
"\"a\",\"b\",{"
"\"key\":123"
"}"
"]"
"}"
"}";
jsn_t j[100];
int len = json_parse(j, sizeof j / sizeof j[0], json);
if (len < 0) {
perror("json_parse");
// ...
}
char const *z = json_string(json_get(j, "[\"0\"]")); // "value"
int n0 = json_number(json_get(j, ".key")); // 555
int n1 = json_number(json_get(j, "[\"key\"]")); // 555
jsn_t *array = json_get(j, ".array"); // [0,1,2,3,4,5]
int n2 = json_number(json_get(j, ".array[3]")); // 3
char const *z = json_string(json_get(j, ".obj.ololo[1]"); // "\"b\"",
jsn_t *ololo2 = json_get(j, ".obj.ololo[2]"); // "{\"key\":123}",
int n3 = json_number(json_get(j, ".obj.ololo[2].key"); // "123"
// ...
```
## `char const *json_string(jsn_t *node, char const *missed_value)`
* `node` -- pointer to json node
* `missed_value` -- default value if node is undefined (NULL)
Returns pointer to string value of node. For non JS_STRING node will be casted
to static buffer string.
If node is NULL returns `missed_value`.
## `int json_boolean(jsn_t *node, int missed_value)`
* `node` -- pointer to json node
* `missed_value` -- default value if node is undefined (NULL)
Returns boolean(1 or 0) value of node. Non JS_BOOLEAN node will be casted
to boolean by JS type convertation rules.
If node is NULL returns `missed_value`.
## `int json_number(jsn_t *node, int missed_value)`
* `node` -- pointer to json node
* `missed_value` -- default value if node is undefined (NULL)
Returns integer value of node. Non JS_NUMBER node will be casted
by JS type convertation rules.
If node is NULL returns `missed_value`.
## `double json_float(jsn_t *node, double missed_value)`
* `node` -- pointer to json node
* `missed_value` -- default value if node is undefined (NULL)
Returns floating pointer(double) value of node. Non JS_FLOAT node will be casted
by JS type convertation rules.
If node is NULL returns `missed_value`.
## `json_foreach`
For enumerating of child nodes of JS_OBJECT/JS_ARRAY object you can use `json_foreach` macro-definition.
```c
jsn_t *obj = json_auto_parse("[1,2,3,4,5]");
json_foreach(obj, offset) {
jsn_t *node = obj + offset;
printf("obj[%d] = '%s'\n", node->id.index, json_string(node));
}
free(obj);
```
# Big code example
```c
static int test_gets()
{
char ser[4096];
char *text = strdup("\
[\
{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"capabilities\",\"params\":{}},\
{\"jsonrpc\":\"2.0\",\"id\":\"1\",\"method\":\"ololo\",\"params\":523424}\
]");
printf("test_gets\n");
jsn_t json[100];
int len = json_parse(json, 100, text);
if (len < 0) {
perror("json_obj_scan parse");
free(text);
return 1;
}
printf("parsed %d nodes\n", len);
json_foreach(json, offset) {
jsn_t *node = json + offset;
char const *version = json_string(json_item(node, "jsonrpc"), "0");
char const *method = json_string(json_item(node, "method"), NULL);
int id = json_number(json_item(node, "id"), -1);
jsn_t *params = json_item(node, "params");
printf("[%d]: version: %s, id: %d, method: %s, params: %s\n",
node->id.index, version, id, method, json_stringify(ser, sizeof ser, params));
}
free(text);
return 0;
}
```