Ameya Keshava Mallya
497 satır
13 KiB
C++
497 satır
13 KiB
C++
#include "json.h"
|
||
#include <assert.h>
|
||
#include <math.h>
|
||
#include <pthread.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
|
||
const char* jsonErrorString(jsonResult_t res) {
|
||
switch (res) {
|
||
case jsonSuccess:
|
||
return "jsonSuccess";
|
||
case jsonFileError:
|
||
return "jsonFileError";
|
||
case jsonUnknownStateError:
|
||
return "jsonUnknownStateError";
|
||
case jsonEmptyStateError:
|
||
return "jsonEmptyStateError";
|
||
case jsonExpectedNonNoneStateError:
|
||
return "jsonExpectedNonNoneStateError";
|
||
case jsonMemoryError:
|
||
return "jsonMemoryError";
|
||
case jsonStringOverflowError:
|
||
return "jsonStringOverflowError";
|
||
case jsonStringBadChar:
|
||
return "jsonStringBadChar";
|
||
case jsonLockError:
|
||
return "jsonLockError";
|
||
default:
|
||
return "unknown json error";
|
||
}
|
||
}
|
||
|
||
// We use these statics to mantain a stack of states where we are writing.
|
||
typedef struct jsonFileOutput {
|
||
jsonState_t* states;
|
||
size_t state_cap; // Allocated stack capacity
|
||
size_t state_n; // # of items in the stack.
|
||
FILE* fp;
|
||
pthread_mutex_t mutex;
|
||
} jsonFileOutput;
|
||
|
||
jsonResult_t jsonInitFileOutput(jsonFileOutput** jfo, const char* outfile) {
|
||
jsonFileOutput* new_jfo = (jsonFileOutput*)malloc(sizeof(jsonFileOutput));
|
||
if (new_jfo == NULL) {
|
||
return jsonMemoryError;
|
||
}
|
||
if (pthread_mutex_init(&new_jfo->mutex, NULL) != 0) {
|
||
free(new_jfo);
|
||
*jfo = 0;
|
||
return jsonLockError;
|
||
}
|
||
new_jfo->states = NULL;
|
||
new_jfo->state_cap = 0;
|
||
new_jfo->state_n = 0;
|
||
new_jfo->fp = fopen(outfile, "w");
|
||
if (new_jfo->fp == NULL) {
|
||
free(new_jfo);
|
||
*jfo = 0;
|
||
return jsonFileError;
|
||
}
|
||
*jfo = new_jfo;
|
||
return jsonSuccess;
|
||
}
|
||
|
||
jsonResult_t jsonNewline(jsonFileOutput* jfo) {
|
||
fprintf(jfo->fp, "\n");
|
||
return jsonSuccess;
|
||
}
|
||
|
||
jsonResult_t jsonFlushOutput(jsonFileOutput* jfo) {
|
||
fflush(jfo->fp);
|
||
return jsonSuccess;
|
||
}
|
||
|
||
jsonResult_t jsonLockOutput(jsonFileOutput* jfo) {
|
||
if (pthread_mutex_lock(&jfo->mutex) != 0) {
|
||
return jsonLockError;
|
||
}
|
||
return jsonSuccess;
|
||
}
|
||
|
||
jsonResult_t jsonUnlockOutput(jsonFileOutput* jfo) {
|
||
if (pthread_mutex_unlock(&jfo->mutex) != 0) {
|
||
return jsonLockError;
|
||
}
|
||
return jsonSuccess;
|
||
}
|
||
|
||
jsonResult_t jsonFinalizeFileOutput(jsonFileOutput* jfo) {
|
||
// Really should probably complain if we aren't in a valid state
|
||
|
||
if (pthread_mutex_destroy(&jfo->mutex) != 0) {
|
||
free(jfo);
|
||
return jsonLockError;
|
||
}
|
||
if (jfo->states != NULL) {
|
||
free(jfo->states);
|
||
}
|
||
jfo->states = NULL;
|
||
jfo->state_cap = 0;
|
||
jfo->state_n = 0;
|
||
if (jfo->fp) {
|
||
fclose(jfo->fp);
|
||
jfo->fp = 0;
|
||
}
|
||
|
||
free(jfo);
|
||
return jsonSuccess;
|
||
}
|
||
|
||
static int utf8copy(unsigned char* out, int out_lim, const unsigned char* in) {
|
||
int copy_len;
|
||
if ((in[0] & 0xE0) == 0xC0) {
|
||
// 2-byte sequence
|
||
if ((in[1] & 0xC0) != 0x80 || out_lim < 2) {
|
||
return 0;
|
||
}
|
||
copy_len = 2;
|
||
} else if ((in[0] & 0xF0) == 0xE0) {
|
||
// 3-byte sequence
|
||
if ((in[1] & 0xC0) != 0x80 || (in[2] & 0xC0) != 0x80 || out_lim < 3) {
|
||
return 0;
|
||
}
|
||
copy_len = 3;
|
||
} else if ((in[0] & 0xF8) == 0xF0) {
|
||
// 4-byte sequence
|
||
if ((in[1] & 0xC0) != 0x80 || (in[2] & 0xC0) != 0x80 || (in[3] & 0xC0) != 0x80 || out_lim < 4) {
|
||
return 0;
|
||
}
|
||
copy_len = 4;
|
||
} else {
|
||
// Invalid start byte
|
||
return 0;
|
||
}
|
||
|
||
for (int i = 0; i < copy_len; ++i) {
|
||
out[i] = in[i];
|
||
}
|
||
|
||
return copy_len;
|
||
}
|
||
|
||
// This tries to sanitize/quote a string from 'in' into 'out',
|
||
// assuming 'out' has length 'lim'. We mainly quote ",/,\,\t,\n, and
|
||
// bail if we encounter non-printable stuff or non-ASCII stuff.
|
||
// 'in' should be null-terminated, of course.
|
||
//
|
||
// We return false if we were not able to copy all of 'in', either for
|
||
// length reasons or for unhandled characters.
|
||
static jsonResult_t sanitizeJson(unsigned char out[], int lim, const unsigned char* in) {
|
||
int c = 0;
|
||
while (*in) {
|
||
if (c + 1 >= lim) {
|
||
out[c] = 0;
|
||
return jsonStringOverflowError;
|
||
}
|
||
switch (*in) {
|
||
case '"':
|
||
case '\\':
|
||
case '/':
|
||
case '\t':
|
||
case '\n':
|
||
if (c + 2 > lim) {
|
||
out[c] = 0;
|
||
return jsonStringOverflowError;
|
||
}
|
||
|
||
out[c++] = '\\';
|
||
if (*in == '\n') {
|
||
out[c++] = 'n';
|
||
} else if (*in == '\t') {
|
||
out[c++] = 't';
|
||
} else {
|
||
out[c++] = *in;
|
||
}
|
||
++in;
|
||
break;
|
||
default:
|
||
if (*in <= 0x1F) {
|
||
out[c] = 0;
|
||
return jsonStringBadChar;
|
||
} else if (*in <= 0x7F) {
|
||
out[c++] = *in;
|
||
++in;
|
||
} else {
|
||
const int utf8len = utf8copy(out + c, lim - c - 1, in);
|
||
if (utf8len == 0) {
|
||
out[c] = 0;
|
||
return jsonStringBadChar;
|
||
}
|
||
c += utf8len;
|
||
in += utf8len;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
out[c] = 0;
|
||
return jsonSuccess;
|
||
}
|
||
|
||
static size_t max(size_t a, size_t b) {
|
||
if (a < b) {
|
||
return b;
|
||
}
|
||
return a;
|
||
}
|
||
|
||
// Push state onto the state stack. Reallocate for extra storage if needed.
|
||
// Because JSON_NONE is a pseudo-state, don't allow it to be pushed.
|
||
static jsonResult_t jsonPushState(jsonFileOutput* jfo, jsonState_t state) {
|
||
if (state == JSON_NONE) {
|
||
return jsonExpectedNonNoneStateError;
|
||
}
|
||
if (jfo->state_cap <= (jfo->state_n + 1)) {
|
||
jfo->state_cap = max((size_t)16, jfo->state_cap * 2);
|
||
jfo->states = (jsonState_t*)realloc(jfo->states, sizeof(jsonState_t) * jfo->state_cap);
|
||
if (jfo->states == 0) {
|
||
return jsonMemoryError;
|
||
}
|
||
}
|
||
jfo->states[jfo->state_n++] = state;
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Return the current state at the top of the stack
|
||
static jsonState_t jsonCurrState(const jsonFileOutput* jfo) {
|
||
if (jfo->state_n == 0) {
|
||
return JSON_NONE;
|
||
}
|
||
return jfo->states[jfo->state_n - 1];
|
||
}
|
||
|
||
// Replace the stack with state (equivalent to a pop & push if stack is not empty)
|
||
static jsonResult_t jsonReplaceState(jsonFileOutput* jfo, jsonState_t state) {
|
||
if (state == JSON_NONE) {
|
||
return jsonExpectedNonNoneStateError;
|
||
}
|
||
if (jfo->state_n == 0) {
|
||
return jsonEmptyStateError;
|
||
}
|
||
jfo->states[jfo->state_n - 1] = state;
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Pop the top state off the stack, or return that the state is empty
|
||
static jsonState_t jsonPopState(jsonFileOutput* jfo) {
|
||
if (jfo->state_n == 0) {
|
||
return JSON_NONE;
|
||
}
|
||
return jfo->states[--jfo->state_n];
|
||
}
|
||
|
||
// Emit a key and separator. Santize the key.
|
||
// This is only acceptable if the top state is an object
|
||
// Emit a ',' separator of we aren't the first item.
|
||
jsonResult_t jsonKey(jsonFileOutput* jfo, const char* name) {
|
||
switch (jsonCurrState(jfo)) {
|
||
case JSON_OBJECT_EMPTY:
|
||
jsonReplaceState(jfo, JSON_OBJECT_SOME);
|
||
break;
|
||
case JSON_OBJECT_SOME:
|
||
fprintf(jfo->fp, ",");
|
||
break;
|
||
default:
|
||
return jsonUnknownStateError;
|
||
}
|
||
unsigned char tmp[2048];
|
||
const jsonResult_t res = sanitizeJson(tmp, sizeof(tmp), (const unsigned char*)name);
|
||
if (res != jsonSuccess) {
|
||
return res;
|
||
}
|
||
fprintf(jfo->fp, "\"%s\":", tmp);
|
||
jsonPushState(jfo, JSON_KEY);
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Helper function for inserting values.
|
||
// Only acceptable after keys, top-level, or in lists.
|
||
// Emit preceeding ',' if in a list and not first item.
|
||
static jsonResult_t jsonValHelper(jsonFileOutput* jfo) {
|
||
switch (jsonCurrState(jfo)) {
|
||
case JSON_LIST_EMPTY:
|
||
jsonReplaceState(jfo, JSON_LIST_SOME);
|
||
break;
|
||
case JSON_LIST_SOME:
|
||
fprintf(jfo->fp, ",");
|
||
break;
|
||
case JSON_KEY:
|
||
jsonPopState(jfo);
|
||
break;
|
||
case JSON_NONE:
|
||
break;
|
||
default:
|
||
return jsonUnknownStateError;
|
||
}
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Start an object
|
||
jsonResult_t jsonStartObject(jsonFileOutput* jfo) {
|
||
const jsonResult_t res = jsonValHelper(jfo);
|
||
if (res != jsonSuccess) {
|
||
return res;
|
||
}
|
||
fprintf(jfo->fp, "{");
|
||
return jsonPushState(jfo, JSON_OBJECT_EMPTY);
|
||
}
|
||
|
||
// Close an object
|
||
jsonResult_t jsonFinishObject(jsonFileOutput* jfo) {
|
||
switch (jsonPopState(jfo)) {
|
||
case JSON_OBJECT_EMPTY:
|
||
case JSON_OBJECT_SOME:
|
||
break;
|
||
default:
|
||
return jsonUnknownStateError;
|
||
}
|
||
fprintf(jfo->fp, "}");
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Start a list
|
||
jsonResult_t jsonStartList(jsonFileOutput* jfo) {
|
||
const jsonResult_t res = jsonValHelper(jfo);
|
||
if (res != jsonSuccess) {
|
||
return res;
|
||
}
|
||
fprintf(jfo->fp, "[");
|
||
return jsonPushState(jfo, JSON_LIST_EMPTY);
|
||
}
|
||
|
||
// Close a list
|
||
jsonResult_t jsonFinishList(jsonFileOutput* jfo) {
|
||
switch (jsonPopState(jfo)) {
|
||
case JSON_LIST_EMPTY:
|
||
case JSON_LIST_SOME:
|
||
break;
|
||
default:
|
||
return jsonUnknownStateError;
|
||
}
|
||
fprintf(jfo->fp, "]");
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Write a null value
|
||
jsonResult_t jsonNull(jsonFileOutput* jfo) {
|
||
const jsonResult_t res = jsonValHelper(jfo);
|
||
if (res != jsonSuccess) {
|
||
return res;
|
||
}
|
||
fprintf(jfo->fp, "null");
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Write a (sanititzed) string
|
||
jsonResult_t jsonStr(jsonFileOutput* jfo, const char* str) {
|
||
if (str == NULL) {
|
||
jsonNull(jfo);
|
||
return jsonSuccess;
|
||
}
|
||
const jsonResult_t res = jsonValHelper(jfo);
|
||
if (res != jsonSuccess) {
|
||
return res;
|
||
}
|
||
unsigned char tmp[2048];
|
||
const jsonResult_t san_res = sanitizeJson(tmp, sizeof(tmp), (const unsigned char*)str);
|
||
if (san_res != jsonSuccess) {
|
||
return san_res;
|
||
}
|
||
fprintf(jfo->fp, "\"%s\"", tmp);
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Write a bool as "true" or "false" strings.
|
||
jsonResult_t jsonBool(jsonFileOutput* jfo, bool val) {
|
||
return jsonStr(jfo, val ? "true" : "false");
|
||
}
|
||
|
||
// Write an integer value
|
||
jsonResult_t jsonInt(jsonFileOutput* jfo, const int val) {
|
||
const jsonResult_t res = jsonValHelper(jfo);
|
||
if (res != jsonSuccess) {
|
||
return res;
|
||
}
|
||
fprintf(jfo->fp, "%d", val);
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Write an integer value
|
||
jsonResult_t jsonUint32(jsonFileOutput* jfo, const uint32_t val) {
|
||
const jsonResult_t res = jsonValHelper(jfo);
|
||
if (res != jsonSuccess) {
|
||
return res;
|
||
}
|
||
fprintf(jfo->fp, "%u", val);
|
||
return jsonSuccess;
|
||
}
|
||
|
||
|
||
// Write an integer value
|
||
jsonResult_t jsonUint64(jsonFileOutput* jfo, const uint64_t val) {
|
||
const jsonResult_t res = jsonValHelper(jfo);
|
||
if (res != jsonSuccess) {
|
||
return res;
|
||
}
|
||
fprintf(jfo->fp, "%lu", val);
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Write a size_t value
|
||
jsonResult_t jsonSize_t(jsonFileOutput* jfo, const size_t val) {
|
||
const jsonResult_t res = jsonValHelper(jfo);
|
||
if (res != jsonSuccess) {
|
||
return res;
|
||
}
|
||
fprintf(jfo->fp, "%zu", val);
|
||
return jsonSuccess;
|
||
}
|
||
|
||
// Write a double value
|
||
jsonResult_t jsonDouble(jsonFileOutput* jfo, const double val) {
|
||
const jsonResult_t res = jsonValHelper(jfo);
|
||
if (res != jsonSuccess) {
|
||
return res;
|
||
}
|
||
if (val != val) {
|
||
fprintf(jfo->fp, "\"nan\"");
|
||
} else {
|
||
fprintf(jfo->fp, "%lf", val);
|
||
}
|
||
return jsonSuccess;
|
||
}
|
||
|
||
#ifdef DO_JSON_TEST
|
||
// compile with
|
||
// gcc json.cc -Iinclude/ -DDO_JSON_TEST -o json_test
|
||
// run with:
|
||
// ./json_test
|
||
// if something fails, it will print out the error
|
||
// if it all works, print out "output matches reference"
|
||
#define JSONCHECK(expr) \
|
||
do { \
|
||
const jsonResult_t res = (expr); \
|
||
if (res != jsonSuccess) { \
|
||
fprintf(stderr, "jsonError: %s\n", jsonErrorString(res)); \
|
||
exit(1); \
|
||
} \
|
||
} while (0)
|
||
|
||
int main() {
|
||
|
||
const char refstr[] =
|
||
"{\"number\":123,\"utfstring\":\"∮ E⋅da = Q, n → ∞, ∑ f(i) = ∏ g(i), ∀x∈ℝ: ⌈x⌉ = −⌊−x⌋, α ∧ "
|
||
"¬β = ¬(¬α ∨ β),\",\"list\":[\"true\",null,9423812381231,3123111,0.694234]}";
|
||
|
||
jsonFileOutput* jfo;
|
||
JSONCHECK(jsonInitFileOutput(&jfo, "test.json"));
|
||
JSONCHECK(jsonStartObject(jfo));
|
||
JSONCHECK(jsonKey(jfo, "number"));
|
||
JSONCHECK(jsonInt(jfo, 123));
|
||
JSONCHECK(jsonKey(jfo, "utfstring"));
|
||
JSONCHECK(
|
||
jsonStr(jfo, "∮ E⋅da = Q, n → ∞, ∑ f(i) = ∏ g(i), ∀x∈ℝ: ⌈x⌉ = −⌊−x⌋, α ∧ ¬β = ¬(¬α ∨ β),"));
|
||
JSONCHECK(jsonKey(jfo, "list"));
|
||
JSONCHECK(jsonStartList(jfo));
|
||
JSONCHECK(jsonBool(jfo, true));
|
||
JSONCHECK(jsonNull(jfo));
|
||
JSONCHECK(jsonUint64(jfo, 9423812381231ULL));
|
||
JSONCHECK(jsonSize_t(jfo, 3123111));
|
||
JSONCHECK(jsonDouble(jfo, 0.69423413));
|
||
JSONCHECK(jsonFinishList(jfo));
|
||
JSONCHECK(jsonFinishObject(jfo));
|
||
JSONCHECK(jsonFinalizeFileOutput(jfo));
|
||
|
||
FILE* fp = fopen("test.json", "r");
|
||
|
||
const size_t reflen = sizeof(refstr) / sizeof(char);
|
||
|
||
char buffer[reflen];
|
||
|
||
fread(buffer, sizeof(char), reflen, fp);
|
||
|
||
fclose(fp);
|
||
|
||
if (memcmp(buffer, refstr, reflen) == 0) {
|
||
printf("output matches reference\n");
|
||
} else {
|
||
printf("output %s\nreference %s\n", buffer, refstr);
|
||
return 1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
#endif
|