// https://github.com/tidwall/json.c

//

// Copyright 2023 Joshua J Baker. All rights reserved.

// Use of this source code is governed by an MIT-style

// license that can be found in the LICENSE file.

#include <limits.h>

#include <stdlib.h>

#include <string.h>

#ifndef JSON_STATIC

#include "json.h"

#else

enum json_type {

JSON_NULL,

JSON_FALSE,

JSON_NUMBER,

JSON_STRING,

JSON_TRUE,

JSON_ARRAY,

JSON_OBJECT,

};

struct json { void *priv[4]; };

struct json_valid {

bool valid;

size_t pos;

};

#define JSON_EXTERN static

#endif

#ifndef JSON_EXTERN

#define JSON_EXTERN

#endif

#ifndef JSON_MAXDEPTH

#define JSON_MAXDEPTH 1024

#endif

struct vutf8res { int n; uint32_t cp; };

// parse and validate a single utf8 codepoint.

// The first byte has already been checked from the vstring function.

static inline struct vutf8res vutf8(const uint8_t data[], int64_t len) {

uint32_t cp;

int n = 0;

if (data[0]>>4 == 14) {

if (len < 3) goto fail;

if (((data[1]>>6)|(data[2]>>6<<2)) != 10) goto fail;

cp = ((uint32_t)(data[0]&15)<<12)|((uint32_t)(data[1]&63)<<6)|

((uint32_t)(data[2]&63));

n = 3;

} else if (data[0]>>3 == 30) {

if (len < 4) goto fail;

if (((data[1]>>6)|(data[2]>>6<<2)|(data[3]>>6<<4)) != 42) goto fail;

cp = ((uint32_t)(data[0]&7)<<18)|((uint32_t)(data[1]&63)<<12)|

((uint32_t)(data[2]&63)<<6)|((uint32_t)(data[3]&63));

n = 4;

} else if (data[0]>>5 == 6) {

if (len < 2) goto fail;

if (data[1]>>6 != 2) goto fail;

cp = ((uint32_t)(data[0]&31)<<6)|((uint32_t)(data[1]&63));

n = 2;

} else {

goto fail;

}

if (cp < 128) goto fail; // don't allow multibyte ascii characters

if (cp >= 0x10FFFF) goto fail; // restricted to utf-16

if (cp >= 0xD800 && cp <= 0xDFFF) goto fail; // needs surrogate pairs

return (struct vutf8res) { .n = n, .cp = cp };

fail:

return (struct vutf8res) { 0 };

}

static inline int64_t vesc(const uint8_t *json, int64_t jlen, int64_t i) {

// The first byte has already been checked from the vstring function.

i += 1;

if (i == jlen) return -(i+1);

switch (json[i]) {

case '"': case '\\': case '/': case 'b': case 'f': case 'n':

case 'r': case 't': return i+1;

case 'u':

for (int j = 0; j < 4; j++) {

i++;

if (i == jlen) return -(i+1);

if (!((json[i] >= '0' && json[i] <= '9') ||

(json[i] >= 'a' && json[i] <= 'f') ||

(json[i] >= 'A' && json[i] <= 'F'))) return -(i+1);

}

return i+1;

}

return -(i+1);

}

#ifndef ludo

#define ludo

#define ludo1(i,f) f; i++;

#define ludo2(i,f) ludo1(i,f); ludo1(i,f);

#define ludo4(i,f) ludo2(i,f); ludo2(i,f);

#define ludo8(i,f) ludo4(i,f); ludo4(i,f);

#define ludo16(i,f) ludo8(i,f); ludo8(i,f);

#define ludo32(i,f) ludo16(i,f); ludo16(i,f);

#define ludo64(i,f) ludo32(i,f); ludo32(i,f);

#define for1(i,n,f) while(i+1<=(n)) { ludo1(i,f); }

#define for2(i,n,f) while(i+2<=(n)) { ludo2(i,f); } for1(i,n,f);

#define for4(i,n,f) while(i+4<=(n)) { ludo4(i,f); } for1(i,n,f);

#define for8(i,n,f) while(i+8<=(n)) { ludo8(i,f); } for1(i,n,f);

#define for16(i,n,f) while(i+16<=(n)) { ludo16(i,f); } for1(i,n,f);

#define for32(i,n,f) while(i+32<=(n)) { ludo32(i,f); } for1(i,n,f);

#define for64(i,n,f) while(i+64<=(n)) { ludo64(i,f); } for1(i,n,f);

#endif

static const uint8_t strtoksu[256] = {

6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,

0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

#ifndef JSON_NOVALIDATEUTF8

6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,

6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,

3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,

4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,

//0=ascii, 1=quote, 2=escape, 3=utf82, 4=utf83, 5=utf84, 6=error

#endif

};

static int64_t vstring(const uint8_t *json, int64_t jlen, int64_t i) {

while (1) {

for8(i, jlen, { if (strtoksu[json[i]]) goto tok; })

break;

tok:

if (json[i] == '"') {

return i+1;

#ifndef JSON_NOVALIDATEUTF8

} else if (json[i] > 127) {

struct vutf8res res = vutf8(json+i, jlen-i);

if (res.n == 0) break;

i += res.n;

#endif

} else if (json[i] == '\\') {

if ((i = vesc(json, jlen, i)) < 0) break;

} else {

break;

}

}

return -(i+1);

}

static int64_t vnumber(const uint8_t *data, int64_t dlen, int64_t i) {

i--;

// sign

if (data[i] == '-') {

i++;

if (i == dlen) return -(i+1);

if (data[i] < '0' || data[i] > '9') return -(i+1);

}

// int

if (data[i] == '0') {

i++;

} else {

for (; i < dlen; i++) {

if (data[i] >= '0' && data[i] <= '9') continue;

break;

}

}

// frac

if (i == dlen) return i;

if (data[i] == '.') {

i++;

if (i == dlen) return -(i+1);

if (data[i] < '0' || data[i] > '9') return -(i+1);

i++;

for (; i < dlen; i++) {

if (data[i] >= '0' && data[i] <= '9') continue;

break;

}

}

// exp

if (i == dlen) return i;

if (data[i] == 'e' || data[i] == 'E') {

i++;

if (i == dlen) return -(i+1);

if (data[i] == '+' || data[i] == '-') i++;

if (i == dlen) return -(i+1);

if (data[i] < '0' || data[i] > '9') return -(i+1);

i++;

for (; i < dlen; i++) {

if (data[i] >= '0' && data[i] <= '9') continue;

break;

}

}

return i;

}

static int64_t vnull(const uint8_t *data, int64_t dlen, int64_t i) {

return i+3 <= dlen && data[i] == 'u' && data[i+1] == 'l' &&

data[i+2] == 'l' ? i+3 : -(i+1);

}

static int64_t vtrue(const uint8_t *data, int64_t dlen, int64_t i) {

return i+3 <= dlen && data[i] == 'r' && data[i+1] == 'u' &&

data[i+2] == 'e' ? i+3 : -(i+1);

}

static int64_t vfalse(const uint8_t *data, int64_t dlen, int64_t i) {

return i+4 <= dlen && data[i] == 'a' && data[i+1] == 'l' &&

data[i+2] == 's' && data[i+3] == 'e' ? i+4 : -(i+1);

}

static int64_t vcolon(const uint8_t *json, int64_t len, int64_t i) {

if (i == len) return -(i+1);

if (json[i] == ':') return i+1;

do {

switch (json[i]) {

case ' ': case '\t': case '\n': case '\r': continue;

case ':': return i+1;

default: return -(i+1);

}

} while (++i < len);

return -(i+1);

}

static int64_t vcomma(const uint8_t *json, int64_t len, int64_t i, uint8_t end)

{

if (i == len) return -(i+1);

if (json[i] == ',') return i;

do {

switch (json[i]) {

case ' ': case '\t': case '\n': case '\r': continue;

case ',': return i;

default: return json[i] == end ? i : -(i+1);

}

} while (++i < len);

return -(i+1);

}

static int64_t vany(const uint8_t *data, int64_t dlen, int64_t i, int depth);

static int64_t varray(const uint8_t *data, int64_t dlen, int64_t i, int depth) {

for (; i < dlen; i++) {

switch (data[i]) {

case ' ': case '\t': case '\n': case '\r': continue;

case ']': return i+1;

default:

for (; i < dlen; i++) {

if ((i = vany(data, dlen, i, depth+1)) < 0) return i;

if ((i = vcomma(data, dlen, i, ']')) < 0) return i;

if (data[i] == ']') return i+1;

}

}

}

return -(i+1);

}

static int64_t vkey(const uint8_t *json, int64_t len, int64_t i) {

for16(i, len, { if (strtoksu[json[i]]) goto tok; })

return -(i+1);

tok:

if (json[i] == '"') return i+1;

return vstring(json, len, i);

}

static int64_t vobject(const uint8_t *data, int64_t dlen, int64_t i, int depth)

{

for (; i < dlen; i++) {

switch (data[i]) {

case '"':

key:

if ((i = vkey(data, dlen, i+1)) < 0) return i;

if ((i = vcolon(data, dlen, i)) < 0) return i;

if ((i = vany(data, dlen, i, depth+1)) < 0) return i;

if ((i = vcomma(data, dlen, i, '}')) < 0) return i;

if (data[i] == '}') return i+1;

i++;

for (; i < dlen; i++) {

switch (data[i]) {

case ' ': case '\t': case '\n': case '\r': continue;

case '"': goto key;

default: return -(i+1);

}

}

return -(i+1);

case ' ': case '\t': case '\n': case '\r': continue;

case '}': return i+1;

default:

return -(i+1);

}

}

return -(i+1);

}

static int64_t vany(const uint8_t *data, int64_t dlen, int64_t i, int depth) {

if (depth > JSON_MAXDEPTH) return -(i+1);

for (; i < dlen; i++) {

switch (data[i]) {

case ' ': case '\t': case '\n': case '\r': continue;

case '{': return vobject(data, dlen, i+1, depth);

case '[': return varray(data, dlen, i+1, depth);

case '"': return vstring(data, dlen, i+1);

case 't': return vtrue(data, dlen, i+1);

case 'f': return vfalse(data, dlen, i+1);

case 'n': return vnull(data, dlen, i+1);

case '-': case '0': case '1': case '2': case '3': case '4':

case '5': case '6': case '7': case '8': case '9':

return vnumber(data, dlen, i+1);

}

break;

}

return -(i+1);

}

static int64_t vpayload(const uint8_t *data, int64_t dlen, int64_t i) {

for (; i < dlen; i++) {

switch (data[i]) {

case ' ': case '\t': case '\n': case '\r': continue;

default:

if ((i = vany(data, dlen, i, 1)) < 0) return i;

for (; i < dlen; i++) {

switch (data[i]) {

case ' ': case '\t': case '\n': case '\r': continue;

default: return -(i+1);

}

}

return i;

}

}

return -(i+1);

}

JSON_EXTERN

struct json_valid json_validn_ex(const char *json_str, size_t len, int opts) {

(void)opts; // for future use

int64_t ilen = len;

if (ilen < 0) return (struct json_valid) { 0 };

int64_t pos = vpayload((uint8_t*)json_str, len, 0);

if (pos > 0) return (struct json_valid) { .valid = true };

return (struct json_valid) { .pos = (-pos)-1 };

}

JSON_EXTERN struct json_valid json_valid_ex(const char *json_str, int opts) {

return json_validn_ex(json_str, json_str?strlen(json_str):0, opts);

}

JSON_EXTERN bool json_validn(const char *json_str, size_t len) {

return json_validn_ex(json_str, len, 0).valid;

}

JSON_EXTERN bool json_valid(const char *json_str) {

return json_validn(json_str, json_str?strlen(json_str):0);

}

// don't changes these flags without changing the numtoks table too.

enum iflags { IESC = 1, IDOT = 2, ISCI = 4, ISIGN = 8 };

#define jmake(info, raw, end, len) ((struct json) { .priv = { \

(void*)(uintptr_t)(info), (void*)(uintptr_t)(raw), \

(void*)(uintptr_t)(end), (void*)(uintptr_t)(len) } })

#define jinfo(json) ((int)(uintptr_t)((json).priv[0]))

#define jraw(json) ((uint8_t*)(uintptr_t)((json).priv[1]))

#define jend(json) ((uint8_t*)(uintptr_t)((json).priv[2]))

#define jlen(json) ((size_t)(uintptr_t)((json).priv[3]))

static const uint8_t strtoksa[256] = {

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,

};

static inline size_t count_string(uint8_t *raw, uint8_t *end, int *infoout) {

size_t len = end-raw;

size_t i = 1;

int info = 0;

bool e = false;

while (1) {

for8(i, len, {

if (strtoksa[raw[i]]) goto tok;

e = false;

});

break;

tok:

if (raw[i] == '"') {

i++;

if (!e) {

break;

}

e = false;

continue;

}

if (raw[i] == '\\') {

info |= IESC;

e = !e;

}

i++;

}

*infoout = info;

return i;

}

static struct json take_string(uint8_t *raw, uint8_t *end) {

int info = 0;

size_t i = count_string(raw, end, &info);

return jmake(info, raw, end, i);

}

static const uint8_t numtoks[256] = {

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,1,0,1,3,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,

0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

// don't changes these flags without changing enum iflags too.

};

static struct json take_number(uint8_t *raw, uint8_t *end) {

int64_t len = end-raw;

int info = raw[0] == '-' ? ISIGN : 0;

int64_t i = 1;

for16(i, len, {

if (!numtoks[raw[i]]) goto done;

info |= (numtoks[raw[i]]-1);

});

done:

return jmake(info, raw, end, i);

}

static const uint8_t nesttoks[256] = {

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,2,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,2,0,0,

};

static size_t count_nested(uint8_t *raw, uint8_t *end) {

size_t len = end-raw;

size_t i = 1;

int depth = 1;

int kind = 0;

if (i >= len) return i;

while (depth) {

for16(i, len, { if (nesttoks[raw[i]]) goto tok0; });

break;

tok0:

kind = nesttoks[raw[i]];

i++;

if (kind-1) {

depth += kind-3;

} else {

while (1) {

for16(i, len, { if (raw[i]=='"') goto tok1; });

break;

tok1:

i++;

if (raw[i-2] == '\\') {

size_t j = i-3;

size_t e = 1;

while (j > 0 && raw[j] == '\\') {

e = (e+1)&1;

j--;

}

if (e) continue;

}

break;

}

}

}

return i;

}

static struct json take_literal(uint8_t *raw, uint8_t *end, size_t litlen) {

size_t rlen = end-raw;

return jmake(0, raw, end, rlen < litlen ? rlen : litlen);

}

static struct json peek_any(uint8_t *raw, uint8_t *end) {

while (raw < end) {

switch (*raw){

case '}': case ']': return (struct json){ 0 };

case '{': case '[': return jmake(0, raw, end, 0);

case '"': return take_string(raw, end);

case 'n': return take_literal(raw, end, 4);

case 't': return take_literal(raw, end, 4);

case 'f': return take_literal(raw, end, 5);

case '-': case '0': case '1': case '2': case '3': case '4': case '5':

case '6': case '7': case '8': case '9': return take_number(raw, end);

}

raw++;

}

return (struct json){ 0 };

}

JSON_EXTERN struct json json_first(struct json json) {

uint8_t *raw = jraw(json);

uint8_t *end = jend(json);

if (end <= raw || (*raw != '{' && *raw != '[')) return (struct json){0};

return peek_any(raw+1, end);

}

JSON_EXTERN struct json json_next(struct json json) {

uint8_t *raw = jraw(json);

uint8_t *end = jend(json);

if (end <= raw) return (struct json){ 0 };

raw += jlen(json) == 0 ? count_nested(raw, end): jlen(json);

return peek_any(raw, end);

}

JSON_EXTERN struct json json_parsen(const char *json_str, size_t len) {

if (len > 0 && (json_str[0] == '[' || json_str[0] == '{')) {

return jmake(0, json_str, json_str+len, 0);

}

if (len == 0) return (struct json){ 0 };

return peek_any((uint8_t*)json_str, (uint8_t*)json_str+len);

}

JSON_EXTERN struct json json_parse(const char *json_str) {

return json_parsen(json_str, json_str?strlen(json_str):0);

}

JSON_EXTERN bool json_exists(struct json json) {

return jraw(json) && jend(json);

}

JSON_EXTERN const char *json_raw(struct json json) {

return (char*)jraw(json);

}

JSON_EXTERN size_t json_raw_length(struct json json) {

if (jlen(json)) return jlen(json);

if (jraw(json) < jend(json)) return count_nested(jraw(json), jend(json));

return 0;

}

static const uint8_t typetoks[256] = {

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,3,0,0,0,0,0,0,0,0,0,0,2,0,0,2,2,2,2,2,2,2,2,2,2,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,

0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,6,0,0,0,0,

};

JSON_EXTERN enum json_type json_type(struct json json) {

return jraw(json) < jend(json) ? typetoks[*jraw(json)] : JSON_NULL;

}

JSON_EXTERN struct json json_ensure(struct json json) {

return jmake(jinfo(json), jraw(json), jend(json), json_raw_length(json));

}

static int strcmpn(const char *a, size_t alen, const char *b, size_t blen) {

size_t n = alen < blen ? alen : blen;

int cmp = strncmp(a, b, n);

if (cmp == 0) {

cmp = alen < blen ? -1 : alen > blen ? 1 : 0;

}

return cmp;

}

static const uint8_t hextoks[256] = {

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,

0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

};

static uint32_t decode_hex(const uint8_t *str) {

return (((int)hextoks[str[0]])<<12) | (((int)hextoks[str[1]])<<8) |

(((int)hextoks[str[2]])<<4) | (((int)hextoks[str[3]])<<0);

}

static bool is_surrogate(uint32_t cp) {

return cp > 55296 && cp < 57344;

}

static uint32_t decode_codepoint(uint32_t cp1, uint32_t cp2) {

return cp1 > 55296 && cp1 < 56320 && cp2 > 56320 && cp2 < 57344 ?

((cp1 - 55296) << 10) | ((cp2 - 56320) + 65536) :

65533;

}

static inline int encode_codepoint(uint8_t dst[], uint32_t cp) {

if (cp < 128) {

dst[0] = cp;

return 1;

} else if (cp < 2048) {

dst[0] = 192 | (cp >> 6);

dst[1] = 128 | (cp & 63);

return 2;

} else if (cp > 1114111 || is_surrogate(cp)) {

cp = 65533; // error codepoint

}

if (cp < 65536) {

dst[0] = 224 | (cp >> 12);

dst[1] = 128 | ((cp >> 6) & 63);

dst[2] = 128 | (cp & 63);

return 3;

}

dst[0] = 240 | (cp >> 18);

dst[1] = 128 | ((cp >> 12) & 63);

dst[2] = 128 | ((cp >> 6) & 63);

dst[3] = 128 | (cp & 63);

return 4;

}

// for_each_utf8 iterates over each UTF-8 bytes in jstr, unescaping along the

// way. 'f' is a loop expression that will make available the 'ch' char which

// is just a single byte in a UTF-8 series.

#define for_each_utf8(jstr, len, f) { \

size_t nn = (len); \

int ch = 0; \

(void)ch; \

for (size_t ii = 0; ii < nn; ii++) { \

if ((jstr)[ii] != '\\') { \

ch = (jstr)[ii]; \

if (1) f \

continue; \

}; \

ii++; \

if (ii == nn) break; \

switch ((jstr)[ii]) { \

case '\\': ch = '\\'; break; \

case '/' : ch = '/'; break; \

case 'b' : ch = '\b'; break; \

case 'f' : ch = '\f'; break; \

case 'n' : ch = '\n'; break; \

case 'r' : ch = '\r'; break; \

case 't' : ch = '\t'; break; \

case '"' : ch = '"'; break; \

case 'u' : \

if (ii+5 > nn) { nn = 0; continue; }; \

uint32_t cp = decode_hex((jstr)+ii+1); \

ii += 5; \

if (is_surrogate(cp)) { \

if (nn-ii >= 6 && (jstr)[ii] == '\\' && (jstr)[ii+1] == 'u') { \

cp = decode_codepoint(cp, decode_hex((jstr)+ii+2)); \

ii += 6; \

} \

} \

uint8_t _bytes[4]; \

int _n = encode_codepoint(_bytes, cp); \

for (int _j = 0; _j < _n; _j++) { \

ch = _bytes[_j]; \

if (1) f \

} \

ii--; \

continue; \

default: \

continue; \

}; \

if (1) f \

} \

}

JSON_EXTERN

int json_raw_comparen(struct json json, const char *str, size_t len) {

char *raw = (char*)jraw(json);

if (!raw) raw = "";

size_t rlen = json_raw_length(json);

return strcmpn(raw, rlen, str, len);

}

JSON_EXTERN int json_raw_compare(struct json json, const char *str) {

return json_raw_comparen(json, str, strlen(str));

}

JSON_EXTERN size_t json_string_length(struct json json) {

size_t len = json_raw_length(json);

if (json_type(json) != JSON_STRING) {

return len;

}

len = len < 2 ? 0 : len - 2;

if ((jinfo(json)&IESC) != IESC) {

return len;

}

uint8_t *raw = jraw(json)+1;

size_t count = 0;

for_each_utf8(raw, len, { count++; });

return count;

}

JSON_EXTERN

int json_string_comparen(struct json json, const char *str, size_t slen) {

if (json_type(json) != JSON_STRING) {

return json_raw_comparen(json, str, slen);

}

uint8_t *raw = jraw(json);

size_t rlen = json_raw_length(json);

raw++;

rlen = rlen < 2 ? 0 : rlen - 2;

if ((jinfo(json)&IESC) != IESC) {

return strcmpn((char*)raw, rlen, str, slen);

}

int cmp = 0;

uint8_t *sp = (uint8_t*)(str ? str : "");

for_each_utf8(raw, rlen, {

if (!*sp || ch > *sp) {

cmp = 1;

goto done;

} else if (ch < *sp) {

cmp = -1;

goto done;

}

sp++;

});

done:

if (cmp == 0 && *sp) cmp = -1;

return cmp;

}

JSON_EXTERN

int json_string_compare(struct json json, const char *str) {

return json_string_comparen(json, str, str?strlen(str):0);

}

JSON_EXTERN size_t json_string_copy(struct json json, char *str, size_t n) {

size_t len = json_raw_length(json);

uint8_t *raw = jraw(json);

bool isjsonstr = json_type(json) == JSON_STRING;

bool isesc = false;

if (isjsonstr) {

raw++;

len = len < 2 ? 0 : len - 2;

isesc = (jinfo(json)&IESC) == IESC;

}

if (!isesc) {

if (n == 0) return len;

n = n-1 < len ? n-1 : len;

memcpy(str, raw, n);

str[n] = '\0';

return len;

}

size_t count = 0;

for_each_utf8(raw, len, {

if (count < n) str[count] = ch;

count++;

});

if (n > count) str[count] = '\0';

else if (n > 0) str[n-1] = '\0';

return count;

}

JSON_EXTERN size_t json_array_count(struct json json) {

size_t count = 0;

if (json_type(json) == JSON_ARRAY) {

json = json_first(json);

while (json_exists(json)) {

count++;

json = json_next(json);

}

}

return count;

}

JSON_EXTERN struct json json_array_get(struct json json, size_t index) {

if (json_type(json) == JSON_ARRAY) {

json = json_first(json);

while (json_exists(json)) {

if (index == 0) return json;

json = json_next(json);

index--;

}

}

return (struct json) { 0 };

}

JSON_EXTERN

struct json json_object_getn(struct json json, const char *key, size_t len) {

if (json_type(json) == JSON_OBJECT) {

json = json_first(json);

while (json_exists(json)) {

if (json_string_comparen(json, key, len) == 0) {

return json_next(json);

}

json = json_next(json_next(json));

}

}

return (struct json) { 0 };

}

JSON_EXTERN struct json json_object_get(struct json json, const char *key) {

return json_object_getn(json, key, key?strlen(key):0);

}

static double stod(const uint8_t *str, size_t len, char *buf) {

memcpy(buf, str, len);

buf[len] = '\0';

char *ptr;

double x = strtod(buf, &ptr);

return (size_t)(ptr-buf) == len ? x : 0;

}

static double parse_double_big(const uint8_t *str, size_t len) {

char buf[512];

if (len >= sizeof(buf)) return 0;

return stod(str, len, buf);

}

static double parse_double(const uint8_t *str, size_t len) {

char buf[32];

if (len >= sizeof(buf)) return parse_double_big(str, len);

return stod(str, len, buf);

}

static int64_t parse_int64(const uint8_t *s, size_t len) {

char buf[21];

double y;

if (len == 0) return 0;

if (len < sizeof(buf) && sizeof(long long) == sizeof(int64_t)) {

memcpy(buf, s, len);

buf[len] = '\0';

char *ptr = NULL;

int64_t x = strtoll(buf, &ptr, 10);

if ((size_t)(ptr-buf) == len) return x;

y = strtod(buf, &ptr);

if ((size_t)(ptr-buf) == len) goto clamp;

}

y = parse_double(s, len);

clamp:

if (y < (double)INT64_MIN) return INT64_MIN;

if (y > (double)INT64_MAX) return INT64_MAX;

return y;

}

static uint64_t parse_uint64(const uint8_t *s, size_t len) {

char buf[21];

double y;

if (len == 0) return 0;

if (len < sizeof(buf) && sizeof(long long) == sizeof(uint64_t) &&

s[0] != '-')

{

memcpy(buf, s, len);

buf[len] = '\0';

char *ptr = NULL;

uint64_t x = strtoull(buf, &ptr, 10);

if ((size_t)(ptr-buf) == len) return x;

y = strtod(buf, &ptr);

if ((size_t)(ptr-buf) == len) goto clamp;

}

y = parse_double(s, len);

clamp:

if (y < 0) return 0;

if (y > (double)UINT64_MAX) return UINT64_MAX;

return y;

}

JSON_EXTERN double json_double(struct json json) {

switch (json_type(json)) {

case JSON_TRUE:

return 1;

case JSON_STRING:

if (jlen(json) < 3) return 0.0;

return parse_double(jraw(json)+1, jlen(json)-2);

case JSON_NUMBER:

return parse_double(jraw(json), jlen(json));

default:

return 0.0;

}

}

JSON_EXTERN int64_t json_int64(struct json json) {

switch (json_type(json)) {

case JSON_TRUE:

return 1;

case JSON_STRING:

if (jlen(json) < 2) return 0;

return parse_int64(jraw(json)+1, jlen(json)-2);

case JSON_NUMBER:

return parse_int64(jraw(json), jlen(json));

default:

return 0;

}

}

JSON_EXTERN int json_int(struct json json) {

int64_t x = json_int64(json);

if (x < (int64_t)INT_MIN) return INT_MIN;

if (x > (int64_t)INT_MAX) return INT_MAX;

return x;

}

JSON_EXTERN uint64_t json_uint64(struct json json) {

switch (json_type(json)) {

case JSON_TRUE:

return 1;

case JSON_STRING:

if (jlen(json) < 2) return 0;

return parse_uint64(jraw(json)+1, jlen(json)-2);

case JSON_NUMBER:

return parse_uint64(jraw(json), jlen(json));

default:

return 0;

}

}

JSON_EXTERN bool json_bool(struct json json) {

switch (json_type(json)) {

case JSON_TRUE:

return true;

case JSON_NUMBER:

return json_double(json) != 0.0;

case JSON_STRING: {

char *trues[] = { "1", "t", "T", "true", "TRUE", "True" };

for (size_t i = 0; i < sizeof(trues)/sizeof(char*); i++) {

if (json_string_compare(json, trues[i]) == 0) return true;

}

return false;

}

default:

return false;

}

}

struct jesc_buf {

uint8_t *esc;

size_t esclen;

size_t count;

};

static void jesc_append(struct jesc_buf *buf, uint8_t ch) {

if (buf->esclen > 1) {

*(buf->esc++) = ch;

buf->esclen--;

}

buf->count++;

}

static void jesc_append2(struct jesc_buf *buf, uint8_t c1, uint8_t c2) {

jesc_append(buf, c1);

jesc_append(buf, c2);

}

static const uint8_t hexchars[] = "0123456789abcdef";

static void

jesc_append_ux(struct jesc_buf *buf, uint8_t c1, uint8_t c2, uint16_t x) {

jesc_append2(buf, c1, c2);

jesc_append2(buf, hexchars[x>>12&0xF], hexchars[x>>8&0xF]);

jesc_append2(buf, hexchars[x>>4&0xF], hexchars[x>>0&0xF]);

}

JSON_EXTERN

size_t json_escapen(const char *str, size_t len, char *esc, size_t n) {

uint8_t cpbuf[4];

struct jesc_buf buf = { .esc = (uint8_t*)esc, .esclen = n };

jesc_append(&buf, '"');

for (size_t i = 0; i < len; i++) {

uint32_t c = (uint8_t)str[i];

if (c < ' ') {

switch (c) {

case '\n': jesc_append2(&buf, '\\', 'n'); break;

case '\b': jesc_append2(&buf, '\\', 'b'); break;

case '\f': jesc_append2(&buf, '\\', 'f'); break;

case '\r': jesc_append2(&buf, '\\', 'r'); break;

case '\t': jesc_append2(&buf, '\\', 't'); break;

default: jesc_append_ux(&buf, '\\', 'u', c);

}

} else if (c == '>' || c == '<' || c == '&') {

// make web safe

jesc_append_ux(&buf, '\\', 'u', c);

} else if (c == '\\') {

jesc_append2(&buf, '\\', '\\');

} else if (c == '"') {

jesc_append2(&buf, '\\', '"');

} else if (c > 127) {

struct vutf8res res = vutf8((uint8_t*)(str+i), len-i);

if (res.n == 0) {

res.n = 1;

res.cp = 0xfffd;

}

int cpn = encode_codepoint(cpbuf, res.cp);

for (int j = 0; j < cpn; j++) {

jesc_append(&buf, cpbuf[j]);

}

i = i + res.n - 1;

} else {

jesc_append(&buf, str[i]);

}

}

jesc_append(&buf, '"');

if (buf.esclen > 0) {

// add to null terminator

*(buf.esc++) = '\0';

buf.esclen--;

}

return buf.count;

}

JSON_EXTERN size_t json_escape(const char *str, char *esc, size_t n) {

return json_escapen(str, str?strlen(str):0, esc, n);

}

JSON_EXTERN

struct json json_getn(const char *json_str, size_t len, const char *path) {

if (!path) return (struct json) { 0 };

struct json json = json_parsen(json_str, len);

int i = 0;

bool end = false;

char *p = (char*)path;

for (; !end && json_exists(json); i++) {

// get the next component

const char *key = p;

while (*p && *p != '.') p++;

size_t klen = p-key;

if (*p == '.') p++;

else if (!*p) end = true;