summaryrefslogtreecommitdiff
path: root/libs
diff options
context:
space:
mode:
Diffstat (limited to 'libs')
-rw-r--r--libs/Json.c462
-rw-r--r--libs/Json.h83
2 files changed, 545 insertions, 0 deletions
diff --git a/libs/Json.c b/libs/Json.c
new file mode 100644
index 0000000..c260bb3
--- /dev/null
+++ b/libs/Json.c
@@ -0,0 +1,462 @@
+/*
+ Copyright (c) 2009, Dave Gamble
+ Copyright (c) 2013, Esoteric Software
+
+ Permission is hereby granted, dispose of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+
+/* Json */
+/* JSON parser in C. */
+
+#ifndef _DEFAULT_SOURCE
+/* Bring strings.h definitions into string.h, where appropriate */
+#define _DEFAULT_SOURCE
+#endif
+
+#ifndef _BSD_SOURCE
+/* Bring strings.h definitions into string.h, where appropriate */
+#define _BSD_SOURCE
+#endif
+
+#include "Json.h"
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h> /* strtod (C89), strtof (C99) */
+#include <string.h> /* strcasecmp (4.4BSD - compatibility), _stricmp (_WIN32) */
+#include <spine/extension.h>
+
+#ifndef SPINE_JSON_DEBUG
+/* Define this to do extra NULL and expected-character checking */
+#define SPINE_JSON_DEBUG 0
+#endif
+
+static const char* ep;
+
+const char* Json_getError (void) {
+ return ep;
+}
+
+static int Json_strcasecmp (const char* s1, const char* s2) {
+ /* TODO we may be able to elide these NULL checks if we can prove
+ * the graph and input (only callsite is Json_getItem) should not have NULLs
+ */
+ if (s1 && s2) {
+#if defined(_WIN32)
+ return _stricmp(s1, s2);
+#else
+ return strcasecmp( s1, s2 );
+#endif
+ } else {
+ if (s1 < s2)
+ return -1; /* s1 is null, s2 is not */
+ else if (s1 == s2)
+ return 0; /* both are null */
+ else
+ return 1; /* s2 is nul s1 is not */
+ }
+}
+
+/* Internal constructor. */
+static Json *Json_new (void) {
+ return (Json*)CALLOC(Json, 1);
+}
+
+/* Delete a Json structure. */
+void Json_dispose (Json *c) {
+ Json *next;
+ while (c) {
+ next = c->next;
+ if (c->child) Json_dispose(c->child);
+ if (c->valueString) FREE(c->valueString);
+ if (c->name) FREE(c->name);
+ FREE(c);
+ c = next;
+ }
+}
+
+/* Parse the input text to generate a number, and populate the result into item. */
+static const char* parse_number (Json *item, const char* num) {
+ double result = 0.0;
+ int negative = 0;
+ char* ptr = (char*)num;
+
+ if (*ptr == '-') {
+ negative = -1;
+ ++ptr;
+ }
+
+ while (*ptr >= '0' && *ptr <= '9') {
+ result = result * 10.0 + (*ptr - '0');
+ ++ptr;
+ }
+
+ if (*ptr == '.') {
+ double fraction = 0.0;
+ int n = 0;
+ ++ptr;
+
+ while (*ptr >= '0' && *ptr <= '9') {
+ fraction = (fraction * 10.0) + (*ptr - '0');
+ ++ptr;
+ ++n;
+ }
+ result += fraction / POW(10.0, n);
+ }
+ if (negative) result = -result;
+
+ if (*ptr == 'e' || *ptr == 'E') {
+ double exponent = 0;
+ int expNegative = 0;
+ int n = 0;
+ ++ptr;
+
+ if (*ptr == '-') {
+ expNegative = -1;
+ ++ptr;
+ } else if (*ptr == '+') {
+ ++ptr;
+ }
+
+ while (*ptr >= '0' && *ptr <= '9') {
+ exponent = (exponent * 10.0) + (*ptr - '0');
+ ++ptr;
+ ++n;
+ }
+
+ if (expNegative)
+ result = result / POW(10, exponent);
+ else
+ result = result * POW(10, exponent);
+ }
+
+ if (ptr != num) {
+ /* Parse success, number found. */
+ item->valueFloat = result;
+ item->valueInt = (int)result;
+ item->type = Json_Number;
+ return ptr;
+ } else {
+ /* Parse failure, ep is set. */
+ ep = num;
+ return 0;
+ }
+}
+
+/* Parse the input text into an unescaped cstring, and populate item. */
+static const unsigned char firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC};
+static const char* parse_string (Json *item, const char* str) {
+ const char* ptr = str + 1;
+ char* ptr2;
+ char* out;
+ int len = 0;
+ unsigned uc, uc2;
+ if (*str != '\"') { /* TODO: don't need this check when called from parse_value, but do need from parse_object */
+ ep = str;
+ return 0;
+ } /* not a string! */
+
+ while (*ptr != '\"' && *ptr && ++len)
+ if (*ptr++ == '\\') ptr++; /* Skip escaped quotes. */
+
+ out = MALLOC(char, len + 1); /* The length needed for the string, roughly. */
+ if (!out) return 0;
+
+ ptr = str + 1;
+ ptr2 = out;
+ while (*ptr != '\"' && *ptr) {
+ if (*ptr != '\\')
+ *ptr2++ = *ptr++;
+ else {
+ ptr++;
+ switch (*ptr) {
+ case 'b':
+ *ptr2++ = '\b';
+ break;
+ case 'f':
+ *ptr2++ = '\f';
+ break;
+ case 'n':
+ *ptr2++ = '\n';
+ break;
+ case 'r':
+ *ptr2++ = '\r';
+ break;
+ case 't':
+ *ptr2++ = '\t';
+ break;
+ case 'u': /* transcode utf16 to utf8. */
+ sscanf(ptr + 1, "%4x", &uc);
+ ptr += 4; /* get the unicode char. */
+
+ if ((uc >= 0xDC00 && uc <= 0xDFFF) || uc == 0) break; /* check for invalid. */
+
+ /* TODO provide an option to ignore surrogates, use unicode replacement character? */
+ if (uc >= 0xD800 && uc <= 0xDBFF) /* UTF16 surrogate pairs. */
+ {
+ if (ptr[1] != '\\' || ptr[2] != 'u') break; /* missing second-half of surrogate. */
+ sscanf(ptr + 3, "%4x", &uc2);
+ ptr += 6;
+ if (uc2 < 0xDC00 || uc2 > 0xDFFF) break; /* invalid second-half of surrogate. */
+ uc = 0x10000 + (((uc & 0x3FF) << 10) | (uc2 & 0x3FF));
+ }
+
+ len = 4;
+ if (uc < 0x80)
+ len = 1;
+ else if (uc < 0x800)
+ len = 2;
+ else if (uc < 0x10000) len = 3;
+ ptr2 += len;
+
+ switch (len) {
+ case 4:
+ *--ptr2 = ((uc | 0x80) & 0xBF);
+ uc >>= 6;
+ /* fallthrough */
+ case 3:
+ *--ptr2 = ((uc | 0x80) & 0xBF);
+ uc >>= 6;
+ /* fallthrough */
+ case 2:
+ *--ptr2 = ((uc | 0x80) & 0xBF);
+ uc >>= 6;
+ /* fallthrough */
+ case 1:
+ *--ptr2 = (uc | firstByteMark[len]);
+ }
+ ptr2 += len;
+ break;
+ default:
+ *ptr2++ = *ptr;
+ break;
+ }
+ ptr++;
+ }
+ }
+ *ptr2 = 0;
+ if (*ptr == '\"') ptr++; /* TODO error handling if not \" or \0 ? */
+ item->valueString = out;
+ item->type = Json_String;
+ return ptr;
+}
+
+/* Predeclare these prototypes. */
+static const char* parse_value (Json *item, const char* value);
+static const char* parse_array (Json *item, const char* value);
+static const char* parse_object (Json *item, const char* value);
+
+/* Utility to jump whitespace and cr/lf */
+static const char* skip (const char* in) {
+ if (!in) return 0; /* must propagate NULL since it's often called in skip(f(...)) form */
+ while (*in && (unsigned char)*in <= 32)
+ in++;
+ return in;
+}
+
+/* Parse an object - create a new root, and populate. */
+Json *Json_create (const char* value) {
+ Json *c;
+ ep = 0;
+ if (!value) return 0; /* only place we check for NULL other than skip() */
+ c = Json_new();
+ if (!c) return 0; /* memory fail */
+
+ value = parse_value(c, skip(value));
+ if (!value) {
+ Json_dispose(c);
+ return 0;
+ } /* parse failure. ep is set. */
+
+ return c;
+}
+
+/* Parser core - when encountering text, process appropriately. */
+static const char* parse_value (Json *item, const char* value) {
+ /* Referenced by Json_create(), parse_array(), and parse_object(). */
+ /* Always called with the result of skip(). */
+#if SPINE_JSON_DEBUG /* Checked at entry to graph, Json_create, and after every parse_ call. */
+ if (!value) return 0; /* Fail on null. */
+#endif
+
+ switch (*value) {
+ case 'n': {
+ if (!strncmp(value + 1, "ull", 3)) {
+ item->type = Json_NULL;
+ return value + 4;
+ }
+ break;
+ }
+ case 'f': {
+ if (!strncmp(value + 1, "alse", 4)) {
+ item->type = Json_False;
+ /* calloc prevents us needing item->type = Json_False or valueInt = 0 here */
+ return value + 5;
+ }
+ break;
+ }
+ case 't': {
+ if (!strncmp(value + 1, "rue", 3)) {
+ item->type = Json_True;
+ item->valueInt = 1;
+ return value + 4;
+ }
+ break;
+ }
+ case '\"':
+ return parse_string(item, value);
+ case '[':
+ return parse_array(item, value);
+ case '{':
+ return parse_object(item, value);
+ case '-': /* fallthrough */
+ case '0': /* fallthrough */
+ case '1': /* fallthrough */
+ case '2': /* fallthrough */
+ case '3': /* fallthrough */
+ case '4': /* fallthrough */
+ case '5': /* fallthrough */
+ case '6': /* fallthrough */
+ case '7': /* fallthrough */
+ case '8': /* fallthrough */
+ case '9':
+ return parse_number(item, value);
+ default:
+ break;
+ }
+
+ ep = value;
+ return 0; /* failure. */
+}
+
+/* Build an array from input text. */
+static const char* parse_array (Json *item, const char* value) {
+ Json *child;
+
+#if SPINE_JSON_DEBUG /* unnecessary, only callsite (parse_value) verifies this */
+ if (*value != '[') {
+ ep = value;
+ return 0;
+ } /* not an array! */
+#endif
+
+ item->type = Json_Array;
+ value = skip(value + 1);
+ if (*value == ']') return value + 1; /* empty array. */
+
+ item->child = child = Json_new();
+ if (!item->child) return 0; /* memory fail */
+ value = skip(parse_value(child, skip(value))); /* skip any spacing, get the value. */
+ if (!value) return 0;
+ item->size = 1;
+
+ while (*value == ',') {
+ Json *new_item = Json_new();
+ if (!new_item) return 0; /* memory fail */
+ child->next = new_item;
+#if SPINE_JSON_HAVE_PREV
+ new_item->prev = child;
+#endif
+ child = new_item;
+ value = skip(parse_value(child, skip(value + 1)));
+ if (!value) return 0; /* parse fail */
+ item->size++;
+ }
+
+ if (*value == ']') return value + 1; /* end of array */
+ ep = value;
+ return 0; /* malformed. */
+}
+
+/* Build an object from the text. */
+static const char* parse_object (Json *item, const char* value) {
+ Json *child;
+
+#if SPINE_JSON_DEBUG /* unnecessary, only callsite (parse_value) verifies this */
+ if (*value != '{') {
+ ep = value;
+ return 0;
+ } /* not an object! */
+#endif
+
+ item->type = Json_Object;
+ value = skip(value + 1);
+ if (*value == '}') return value + 1; /* empty array. */
+
+ item->child = child = Json_new();
+ if (!item->child) return 0;
+ value = skip(parse_string(child, skip(value)));
+ if (!value) return 0;
+ child->name = child->valueString;
+ child->valueString = 0;
+ if (*value != ':') {
+ ep = value;
+ return 0;
+ } /* fail! */
+ value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */
+ if (!value) return 0;
+ item->size = 1;
+
+ while (*value == ',') {
+ Json *new_item = Json_new();
+ if (!new_item) return 0; /* memory fail */
+ child->next = new_item;
+#if SPINE_JSON_HAVE_PREV
+ new_item->prev = child;
+#endif
+ child = new_item;
+ value = skip(parse_string(child, skip(value + 1)));
+ if (!value) return 0;
+ child->name = child->valueString;
+ child->valueString = 0;
+ if (*value != ':') {
+ ep = value;
+ return 0;
+ } /* fail! */
+ value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */
+ if (!value) return 0;
+ item->size++;
+ }
+
+ if (*value == '}') return value + 1; /* end of array */
+ ep = value;
+ return 0; /* malformed. */
+}
+
+Json *Json_getItem (Json *object, const char* string) {
+ Json *c = object->child;
+ while (c && Json_strcasecmp(c->name, string))
+ c = c->next;
+ return c;
+}
+
+const char* Json_getString (Json* object, const char* name, const char* defaultValue) {
+ object = Json_getItem(object, name);
+ if (object) return object->valueString;
+ return defaultValue;
+}
+
+float Json_getFloat (Json* value, const char* name, float defaultValue) {
+ value = Json_getItem(value, name);
+ return value ? value->valueFloat : defaultValue;
+}
+
+int Json_getInt (Json* value, const char* name, int defaultValue) {
+ value = Json_getItem(value, name);
+ return value ? value->valueInt : defaultValue;
+}
diff --git a/libs/Json.h b/libs/Json.h
new file mode 100644
index 0000000..078a5a7
--- /dev/null
+++ b/libs/Json.h
@@ -0,0 +1,83 @@
+/*
+ Copyright (c) 2009 Dave Gamble
+
+ Permission is hereby granted, dispose of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+
+/* Esoteric Software: Removed everything except parsing, shorter method names, more get methods, double to float, formatted. */
+
+#ifndef SPINE_JSON_H_
+#define SPINE_JSON_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Json Types: */
+#define Json_False 0
+#define Json_True 1
+#define Json_NULL 2
+#define Json_Number 3
+#define Json_String 4
+#define Json_Array 5
+#define Json_Object 6
+
+#ifndef SPINE_JSON_HAVE_PREV
+/* Spine doesn't use the "prev" link in the Json sibling lists. */
+#define SPINE_JSON_HAVE_PREV 0
+#endif
+
+/* The Json structure: */
+typedef struct Json {
+ struct Json* next;
+#if SPINE_JSON_HAVE_PREV
+ struct Json* prev; /* next/prev allow you to walk array/object chains. Alternatively, use getSize/getItem */
+#endif
+ struct Json* child; /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+
+ int type; /* The type of the item, as above. */
+ int size; /* The number of children. */
+
+ const char* valueString; /* The item's string, if type==Json_String */
+ int valueInt; /* The item's number, if type==Json_Number */
+ float valueFloat; /* The item's number, if type==Json_Number */
+
+ const char* name; /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+} Json;
+
+/* Supply a block of JSON, and this returns a Json object you can interrogate. Call Json_dispose when finished. */
+Json* Json_create (const char* value);
+
+/* Delete a Json entity and all subentities. */
+void Json_dispose (Json* json);
+
+/* Get item "string" from object. Case insensitive. */
+Json* Json_getItem (Json* json, const char* string);
+const char* Json_getString (Json* json, const char* name, const char* defaultValue);
+float Json_getFloat (Json* json, const char* name, float defaultValue);
+int Json_getInt (Json* json, const char* name, int defaultValue);
+
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when Json_create() returns 0. 0 when Json_create() succeeds. */
+const char* Json_getError (void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SPINE_JSON_H_ */
generated by cgit v1.2.3 (git 2.39.1) at 2025-10-20 17:00:08 +0000