cozis/cWEB
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b79b62ade82776f359bf22f092a4456f9f1adc42
cWEB/3p/json.c
T
cozis b79b62ade8 Add JSON support
2025-10-19 18:12:08 +02:00

1006 lines
24 KiB
C
Raw Blame History

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdarg.h>
#include "json.h"
////////////////////////////////////////////////////////////////////
// PARSER
////////////////////////////////////////////////////////////////////
typedef struct {
char* src;
size_t len;
size_t cur;
JSON_Arena *arena;
JSON_Error *error;
} Context;
static bool is_wspace(char c)
{
return c == ' ' || c == '\t' || c == '\r' || c == '\n';
}
static bool is_digit(char c)
{
return c >= '0' && c <= '9';
}
static bool is_control(char c)
{
return c >= 0 && c < ' '; // TODO: is this correct?
}
static void consume_wspace(Context *ctx)
{
while (ctx->cur < ctx->len && is_wspace(ctx->src[ctx->cur]))
ctx->cur++;
}
static void *alloc(JSON_Arena *arena, size_t len, size_t align)
{
size_t pad = -(uintptr_t) (arena->ptr + arena->cur) & (align-1);
if (arena->len - arena->cur < len + pad)
return NULL;
arena->cur += pad;
void *ptr = arena->ptr + arena->cur;
arena->cur += len;
arena->last = ptr;
return ptr;
}
static bool grow_alloc(JSON_Arena *arena, void *ptr, size_t new_len)
{
if (ptr == NULL || arena->last != ptr)
return false;
size_t old_len = (arena->ptr + arena->cur) - arena->last;
if (new_len < old_len)
return false;
size_t increase_len = new_len - old_len;
if (arena->len - arena->cur < increase_len)
return false;
arena->cur += increase_len;
return true;
}
typedef struct {
JSON_Arena *arena;
char* ptr;
size_t len;
bool err;
} GrowingBuffer;
static GrowingBuffer gbinit(JSON_Arena *arena)
{
return (GrowingBuffer) { arena, NULL, 0, false };
}
static void gbappends(GrowingBuffer *gb, char *str, size_t len)
{
if (gb->err)
return;
if (len == 0)
return;
if (gb->ptr == NULL) {
gb->ptr = alloc(gb->arena, len, 1);
if (gb->ptr == NULL) {
gb->err = true;
return;
}
} else {
if (!grow_alloc(gb->arena, gb->ptr, gb->len + len)) {
gb->err = true;
return;
}
}
memcpy(gb->ptr + gb->len, str, len);
gb->len += len;
}
static void gbappendc(GrowingBuffer *gb, char c)
{
gbappends(gb, &c, 1);
}
static JSON *parse_any(Context *ctx);
static void
consume_unescaped_string_contents(Context *ctx)
{
while (ctx->cur < ctx->len
&& ctx->src[ctx->cur] != '"'
&& ctx->src[ctx->cur] != '\\'
&& !is_control(ctx->src[ctx->cur]))
ctx->cur++;
}
static char *parse_string_raw(Context *ctx, size_t *plen)
{
assert(ctx->cur < ctx->len && ctx->src[ctx->cur] == '"');
ctx->cur++;
GrowingBuffer gb = gbinit(ctx->arena);
for (;;) {
size_t off = ctx->cur;
consume_unescaped_string_contents(ctx);
gbappends(&gb,
ctx->src + off,
ctx->cur - off
);
if (ctx->cur == ctx->len)
return NULL;
char c = ctx->src[ctx->cur++];
if (is_control(c))
return NULL;
if (c == '"')
break;
assert(c == '\\');
if (ctx->cur == ctx->len)
return NULL;
c = ctx->src[ctx->cur++];
switch (c) {
case '"': gbappendc(&gb, '"'); break;
case '\\': gbappendc(&gb, '\\'); break;
case '/': gbappendc(&gb, '/'); break;
case 'b': gbappendc(&gb, '\b'); break;
case 'f': gbappendc(&gb, '\f'); break;
case 'n': gbappendc(&gb, '\n'); break;
case 'r': gbappendc(&gb, '\r'); break;
case 't': gbappendc(&gb, '\t'); break;
case 'u':
// TODO: not implemented yet
return NULL;
default:
return NULL;
}
}
if (gb.err)
return NULL;
*plen = gb.len;
return gb.ptr;
}
static JSON *parse_string(Context *ctx)
{
size_t len;
char *ptr = parse_string_raw(ctx, &len);
if (ptr == NULL)
return NULL;
JSON *val = alloc(ctx->arena, sizeof(JSON), _Alignof(JSON));
if (val == NULL)
return NULL;
val->type = JSON_TYPE_STRING;
val->len = len;
val->sval = ptr;
return val;
}
static bool node_with_key_exists(JSON *head, char *key, size_t key_len)
{
if (head == NULL)
return false;
JSON *cursor = head;
while (cursor) {
if (cursor->key_len == key_len && memcmp(cursor->key, key, key_len) == 0)
return true;
cursor = cursor->next;
}
return false;
}
static JSON *parse_object(Context *ctx)
{
assert(ctx->cur < ctx->len && ctx->src[ctx->cur] == '{');
ctx->cur++;
consume_wspace(ctx);
int count = 0;
JSON *head = NULL;
JSON **tail = &head;
if (ctx->src[ctx->cur] != '}') {
for (;;) {
if (ctx->cur == ctx->len || ctx->src[ctx->cur] != '"')
return NULL;
size_t key_len;
char *key = parse_string_raw(ctx, &key_len);
if (key == NULL)
return NULL;
if (node_with_key_exists(head, key, key_len))
return NULL;
consume_wspace(ctx);
if (ctx->cur == ctx->len || ctx->src[ctx->cur] != ':')
return NULL;
ctx->cur++;
consume_wspace(ctx);
JSON *val = parse_any(ctx);
if (val == NULL)
return NULL;
val->next = NULL;
val->key = key;
val->key_len = key_len;
*tail = val;
tail = &val->next;
count++;
consume_wspace(ctx);
if (ctx->cur == ctx->len)
return NULL;
if (ctx->src[ctx->cur] == '}')
break;
if (ctx->src[ctx->cur] != ',')
return NULL;
ctx->cur++;
consume_wspace(ctx);
}
}
assert(ctx->cur < ctx->len && ctx->src[ctx->cur] == '}');
ctx->cur++;
JSON *obj = alloc(ctx->arena, sizeof(JSON), _Alignof(JSON));
if (obj == NULL)
return NULL;
obj->type = JSON_TYPE_OBJECT;
obj->len = (size_t) count;
obj->head = head;
return obj;
}
static JSON *parse_array(Context *ctx)
{
assert(ctx->cur < ctx->len && ctx->src[ctx->cur] == '[');
ctx->cur++;
consume_wspace(ctx);
int count = 0;
JSON *head = NULL;
JSON **tail = &head;
if (ctx->src[ctx->cur] != ']') {
for (;;) {
JSON *val = parse_any(ctx);
if (val == NULL)
return NULL;
val->next = NULL;
val->key = NULL;
val->key_len = 0;
*tail = val;
tail = &val->next;
count++;
consume_wspace(ctx);
if (ctx->cur == ctx->len)
return NULL;
if (ctx->src[ctx->cur] == ']')
break;
if (ctx->src[ctx->cur] != ',')
return NULL;
ctx->cur++;
consume_wspace(ctx);
}
}
assert(ctx->cur < ctx->len && ctx->src[ctx->cur] == ']');
ctx->cur++;
JSON *arr = alloc(ctx->arena, sizeof(JSON), _Alignof(JSON));
if (arr == NULL)
return NULL;
arr->type = JSON_TYPE_ARRAY;
arr->len = (size_t) count;
arr->head = head;
return arr;
}
static JSON *parse_float(Context *ctx)
{
bool neg = false;
if (ctx->src[ctx->cur] == '-') {
ctx->cur++;
if (ctx->cur == ctx->len || !is_digit(ctx->src[ctx->cur]))
return NULL;
neg = true;
}
double x = 0;
do {
assert(ctx->cur < ctx->len && is_digit(ctx->src[ctx->cur]));
int d = ctx->src[ctx->cur++] - '0';
if (neg) d = -d;
x *= 10;
x += d;
} while (ctx->src[ctx->cur] != '.');
// Consume dot
ctx->cur++;
if (ctx->cur == ctx->len || !is_digit(ctx->src[ctx->cur]))
return NULL;
double s = 0.1;
do {
int d = ctx->src[ctx->cur++] - '0';
if (neg) d = -d;
x += s * d;
s /= 10;
} while (ctx->cur < ctx->len && is_digit(ctx->src[ctx->cur]));
JSON *val = alloc(ctx->arena, sizeof(JSON), _Alignof(JSON));
if (val == NULL)
return NULL;
val->type = JSON_TYPE_FLOAT;
val->fval = x;
return val;
}
static JSON *parse_int(Context *ctx)
{
assert(ctx->cur < ctx->len && (is_digit(ctx->src[ctx->cur]) || ctx->src[ctx->cur] == '-'));
bool neg = false;
if (ctx->src[ctx->cur] == '-') {
ctx->cur++;
if (ctx->cur == ctx->len || !is_digit(ctx->src[ctx->cur]))
return NULL;
neg = true;
}
int64_t x = 0;
do {
int d = ctx->src[ctx->cur++] - '0';
if (neg) {
if (x < (INT64_MIN + d) / 10)
return NULL;
d = -d;
} else {
if (x > (INT64_MAX - d) / 10)
return NULL;
}
x *= 10;
x += d;
} while (ctx->cur < ctx->len && is_digit(ctx->src[ctx->cur]));
JSON *val = alloc(ctx->arena, sizeof(JSON), _Alignof(JSON));
if (val == NULL)
return NULL;
val->type = JSON_TYPE_INT;
val->ival = x;
return val;
}
static bool follows_float(Context *ctx)
{
assert(ctx->cur < ctx->len && (is_digit(ctx->src[ctx->cur]) || ctx->src[ctx->cur] == '-'));
size_t peek = ctx->cur;
if (peek < ctx->len && ctx->src[peek] == '-') {
peek++;
if (peek == ctx->len || !is_digit(ctx->src[peek]))
return false;
}
do
peek++;
while (peek < ctx->len && is_digit(ctx->src[peek]));
return peek < ctx->len && ctx->src[peek] == '.';
}
static JSON *parse_number(Context *ctx)
{
if (follows_float(ctx))
return parse_float(ctx);
return parse_int(ctx);
}
static JSON *parse_true(Context *ctx)
{
assert(ctx->cur < ctx->len && ctx->src[ctx->cur] == 't');
ctx->cur++;
if (ctx->len - ctx->cur <= 2
|| ctx->src[ctx->cur+0] != 'r'
|| ctx->src[ctx->cur+1] != 'u'
|| ctx->src[ctx->cur+2] != 'e')
return NULL;
ctx->cur += 3;
JSON *val = alloc(ctx->arena, sizeof(JSON), _Alignof(JSON));
if (val == NULL)
return NULL;
val->type = JSON_TYPE_BOOL;
val->bval = true;
return val;
}
static JSON *parse_false(Context *ctx)
{
assert(ctx->cur < ctx->len && ctx->src[ctx->cur] == 'f');
ctx->cur++;
if (ctx->len - ctx->cur <= 3
|| ctx->src[ctx->cur+0] != 'a'
|| ctx->src[ctx->cur+1] != 'l'
|| ctx->src[ctx->cur+2] != 's'
|| ctx->src[ctx->cur+3] != 'e')
return NULL;
ctx->cur += 4;
JSON *val = alloc(ctx->arena, sizeof(JSON), _Alignof(JSON));
if (val == NULL)
return NULL;
val->type = JSON_TYPE_BOOL;
val->bval = false;
return val;
}
static JSON *parse_null(Context *ctx)
{
assert(ctx->cur < ctx->len && ctx->src[ctx->cur] == 'n');
ctx->cur++;
if (ctx->len - ctx->cur <= 2
|| ctx->src[ctx->cur+0] != 'u'
|| ctx->src[ctx->cur+1] != 'l'
|| ctx->src[ctx->cur+2] != 'l')
return NULL;
ctx->cur += 3;
JSON *val = alloc(ctx->arena, sizeof(JSON), _Alignof(JSON));
if (val == NULL)
return NULL;
val->type = JSON_TYPE_NULL;
return val;
}
static JSON *parse_any(Context *ctx)
{
if (ctx->cur == ctx->len)
return NULL;
char c = ctx->src[ctx->cur];
if (c == '"')
return parse_string(ctx);
if (c == '{')
return parse_object(ctx);
if (c == '[')
return parse_array(ctx);
if (is_digit(c) || c == '-')
return parse_number(ctx);
if (c == 't')
return parse_true(ctx);
if (c == 'f')
return parse_false(ctx);
if (c == 'n')
return parse_null(ctx);
return NULL;
}
static JSON *decode(Context *ctx)
{
consume_wspace(ctx);
JSON *x = parse_any(ctx);
if (x == NULL)
return NULL;
x->key = NULL;
x->key_len = 0;
x->next = NULL;
consume_wspace(ctx);
if (ctx->cur < ctx->len)
return NULL;
return x;
}
JSON_Arena json_arena_init(char *ptr, size_t len)
{
return (JSON_Arena) { NULL, ptr, len, 0 };
}
JSON *json_decode(char *src, int len, JSON_Arena *arena, JSON_Error *error)
{
if (src == NULL) src = "";
if (len < 0) len = strlen(src);
Context ctx = { src, len, 0, arena, error };
return decode(&ctx);
}
////////////////////////////////////////////////////////////////////
// UTILITIES
////////////////////////////////////////////////////////////////////
const char *json_type_name(JSON_Type type)
{
switch (type) {
case JSON_TYPE_BOOL : return "bool";
case JSON_TYPE_NULL : return "null";
case JSON_TYPE_OBJECT: return "object";
case JSON_TYPE_ARRAY : return "array";
case JSON_TYPE_FLOAT : return "float";
case JSON_TYPE_INT : return "int";
case JSON_TYPE_STRING: return "string";
}
return "???";
}
JSON_Type json_get_type(JSON *json)
{
assert(json);
return json->type;
}
JSON_String json_get_key(JSON *json)
{
if (json == NULL || json->key == NULL)
return (JSON_String) { NULL, 0 };
return (JSON_String) { json->key, json->key_len };
}
bool json_get_bool(JSON *json, bool fallback)
{
if (json == NULL || json->type != JSON_TYPE_BOOL)
return fallback;
return json->bval;
}
int64_t json_get_int(JSON *json, int64_t fallback)
{
if (json == NULL || json->type != JSON_TYPE_INT)
return fallback;
return json->ival;
}
double json_get_float(JSON *json, double fallback)
{
if (json == NULL || json->type != JSON_TYPE_FLOAT)
return fallback;
return json->fval;
}
JSON_String json_get_string(JSON *json)
{
if (json == NULL || json->type != JSON_TYPE_STRING)
return (JSON_String) { NULL, 0 };
return (JSON_String) { json->sval, json->len };
}
JSON *json_get_field(JSON *obj, JSON_String key)
{
if (obj == NULL)
return NULL;
if (obj->type != JSON_TYPE_OBJECT)
return NULL;
JSON *child = obj->head;
while (child) {
if (child->key_len == (size_t) key.len &&
!memcmp(child->key, key.ptr, key.len))
return child;
child = child->next;
}
return NULL;
}
////////////////////////////////////////////////////////////////////
// PATTERN MATCHING
////////////////////////////////////////////////////////////////////
typedef struct {
char *src;
int len;
int cur;
int cur_arg;
JSON_MatchArgs args;
JSON_Error *err;
} MatchContext;
static int match_any(MatchContext *ctx, JSON *json);
static void report_match_error(MatchContext *ctx, char *fmt, ...)
{
char *dst = ctx->err->msg;
int cap = (int) sizeof(ctx->err->msg);
va_list args;
va_start(args, fmt);
int ret = vsnprintf(dst, cap, fmt, args);
va_end(args);
if (ret < 0)
ret = 0;
if (ret >= cap)
ret = cap-1;
dst[ret] = '\0';
}
static int match_obj(MatchContext *ctx, JSON *json)
{
assert(json->type == JSON_TYPE_OBJECT);
while (ctx->cur < ctx->len && is_wspace(ctx->src[ctx->cur]))
ctx->cur++;
if (ctx->cur == ctx->len) {
report_match_error(ctx, "Pattern string ended inside an object");
return -1;
}
// Empty object?
if (ctx->cur < ctx->len && ctx->src[ctx->cur] == '}') {
ctx->cur++;
return 0;
}
for (;;) {
assert(ctx->cur < ctx->len && !is_wspace(ctx->src[ctx->cur]));
if (ctx->src[ctx->cur] != '\'') {
report_match_error(ctx, "Invalid character inside object, where key was expected");
return -1;
}
ctx->cur++;
char key[128];
int key_len = 0;
for (;;) {
int off = ctx->cur;
while (ctx->cur < ctx->len
&& ctx->src[ctx->cur] != '\''
&& ctx->src[ctx->cur] != '\\')
ctx->cur++;
char *substr_ptr = ctx->src + off;
int substr_len = ctx->cur - off;
if (substr_len > 0) {
if (sizeof(key) - key_len <= (size_t) substr_len) {
report_match_error(ctx, "Key buffer limit reached (you can't have keys longer than %d bytes)", (int) sizeof(key)-1);
return -1;
}
memcpy(key + key_len, substr_ptr, substr_len);
key_len += substr_len;
}
if (ctx->cur == ctx->len) {
report_match_error(ctx, "Pattern string ended inside a string");
return -1;
}
if (ctx->src[ctx->cur] == '\'') {
ctx->cur++;
break;
}
assert(ctx->src[ctx->cur] == '\\');
ctx->cur++;
if (ctx->cur == ctx->len) {
report_match_error(ctx, "Pattern string ended inside a string");
return -1;
}
if (sizeof(key) - key_len <= 1) {
report_match_error(ctx, "Key buffer limit reached (you can't have keys longer than %d bytes)", (int) sizeof(key)-1);
return -1;
}
switch (ctx->src[ctx->cur]) {
case '\'': key[key_len++] = '\''; break;
case '\\': key[key_len++] = '\\'; break;
default:
report_match_error(ctx, "Invalid escape character");
return -1;
}
}
// Consume spaces to the next separator
while (ctx->cur < ctx->len && is_wspace(ctx->src[ctx->cur]))
ctx->cur++;
if (ctx->cur == ctx->len || ctx->src[ctx->cur] != ':') {
report_match_error(ctx, "Missing ':' after key");
return -1;
}
ctx->cur++;
// Look for a field with the given key in the object
JSON *child = json->head;
while (child) {
if (child->key_len == (size_t) key_len &&
!memcmp(child->key, key, key_len))
break;
child = child->next;
}
if (child == NULL) {
report_match_error(ctx, "Field '%.*s' is missing", key_len, key);
return 1;
}
int ret = match_any(ctx, child);
if (ret < 0)
return ret;
while (ctx->cur < ctx->len && is_wspace(ctx->src[ctx->cur]))
ctx->cur++;
if (ctx->cur == ctx->len) {
report_match_error(ctx, "Pattern string ended inside an object");
return -1;
}
if (ctx->src[ctx->cur] == '}') {
ctx->cur++;
break;
}
if (ctx->src[ctx->cur] != ',') {
report_match_error(ctx, "Invalid character where ',' or '}' were expected");
return -1;
}
ctx->cur++;
while (ctx->cur < ctx->len && is_wspace(ctx->src[ctx->cur]))
ctx->cur++;
if (ctx->cur == ctx->len) {
report_match_error(ctx, "Pattern string ended inside an object");
return -1;
}
}
return 0;
}
static int match_any(MatchContext *ctx, JSON *json)
{
while (ctx->cur < ctx->len && is_wspace(ctx->src[ctx->cur]))
ctx->cur++;
if (ctx->cur == ctx->len) {
report_match_error(ctx, "Pattern string ended where a value was expected");
return -1;
}
// The * character matches anything but doesn't extract any value
if (ctx->src[ctx->cur] == '*') {
ctx->cur++;
return 0;
}
// The ? character matches anything and writes it to output
if (ctx->src[ctx->cur] == '?') {
ctx->cur++;
if (ctx->cur_arg == ctx->args.len) {
report_match_error(ctx, "Missing output arguments");
return -1;
}
JSON_MatchArg arg = ctx->args.ptr[ctx->cur_arg++];
switch (arg.type) {
case JSON_MATCH_ARG_TYPE_BOOL:
if (json->type != JSON_TYPE_BOOL) {
report_match_error(ctx, "Expected boolean, got %s instead", json_type_name(json->type));
return 1;
}
*arg.bptr = json->bval;
break;
case JSON_MATCH_ARG_TYPE_INT:
if (json->type != JSON_TYPE_INT) {
report_match_error(ctx, "Expected integer, got %s instead", json_type_name(json->type));
return 1;
}
*arg.iptr = json->ival;
break;
case JSON_MATCH_ARG_TYPE_FLOAT:
if (json->type != JSON_TYPE_FLOAT) {
report_match_error(ctx, "Expected float, got %s instead", json_type_name(json->type));
return 1;
}
*arg.fptr = json->fval;
break;
case JSON_MATCH_ARG_TYPE_STRING:
if (json->type != JSON_TYPE_STRING) {
report_match_error(ctx, "Expected string, got %s instead", json_type_name(json->type));
return 1;
}
*arg.sptr = (JSON_String) { json->sval, json->len };
break;
case JSON_MATCH_ARG_TYPE_ANY:
*arg.anyptr = json;
break;
}
return 0;
}
if (ctx->src[ctx->cur] == '{') {
ctx->cur++;
if (json->type != JSON_TYPE_OBJECT) {
report_match_error(ctx, "Expected object, got %s instead", json_type_name(json->type));
return 1;
}
return match_obj(ctx, json);
}
char c = ctx->src[ctx->cur];
if (c >= ' ' && c <= '~') report_match_error(ctx, "Unexpected character '%c' in pattern", c);
else report_match_error(ctx, "Unexpected byte %x in pattern", c);
return -1;
}
int json_match_impl(JSON *json, JSON_Error *err, char *pattern, JSON_MatchArgs args)
{
MatchContext ctx = {
.src = pattern,
.len = strlen(pattern),
.cur = 0,
.cur_arg = 0,
.args = args,
.err = err,
};
return match_any(&ctx, json);
}
JSON_MatchArg json_match_arg_bool (bool *x) { return (JSON_MatchArg) { .type=JSON_MATCH_ARG_TYPE_BOOL, .bptr=x }; }
JSON_MatchArg json_match_arg_int (int64_t *x) { return (JSON_MatchArg) { .type=JSON_MATCH_ARG_TYPE_INT, .iptr=x }; }
JSON_MatchArg json_match_arg_float (double *x) { return (JSON_MatchArg) { .type=JSON_MATCH_ARG_TYPE_FLOAT, .fptr=x }; }
JSON_MatchArg json_match_arg_string(JSON_String *x) { return (JSON_MatchArg) { .type=JSON_MATCH_ARG_TYPE_STRING, .sptr=x }; }
JSON_MatchArg json_match_arg_any (JSON **x) { return (JSON_MatchArg) { .type=JSON_MATCH_ARG_TYPE_ANY, .anyptr=x }; }
////////////////////////////////////////////////////////////////////
// STRING ESCAPING
////////////////////////////////////////////////////////////////////
JSON_String json_escape(JSON_Arena *arena, JSON_String str)
{
// TODO: This is just a best-effort implementation. Should handle UTF-8 precisely.
char *src = str.ptr;
int len = str.len;
int cur = 0;
char *dst = arena->ptr + arena->cur;
int cap = arena->len - arena->cur;
int num = 0;
for (;;) {
int off = cur;
while (cur < len && (src[cur] >= ' ' && src[cur] <= '~' && src[cur] != '"' && src[cur] != '\\'))
cur++;
char *substr_ptr = src + off;
int substr_len = cur - off;
if (substr_len > 0) {
if (substr_len > cap - num)
return (JSON_String) { NULL, 0 };
memcpy(dst + num, substr_ptr, substr_len);
num += substr_len;
}
if (cur == len)
break;
if (2 > cap - num)
return (JSON_String) { NULL, 0 };
cur++;
if (src[cur-1] == '"') {
dst[num++] = '\\';
dst[num++] = '"';
} else if (src[cur-1] == '\\') {
dst[num++] = '\\';
dst[num++] = '\\';
} else if (src[cur-1] == '\n') {
dst[num++] = '\\';
dst[num++] = 'n';
} else if (src[cur-1] == '\r') {
dst[num++] = '\\';
dst[num++] = 'r';
} else if (src[cur-1] == '\t') {
dst[num++] = '\\';
dst[num++] = 't';
} else {
return (JSON_String) { NULL, 0 };
}
}
arena->cur += num;
return (JSON_String) { dst, num };
}
Reference in New Issue View Git Blame Copy Permalink