Add working webpage for unix v4

1 files changed, 464 insertions, 0 deletions

diff --git a/jslinux-2019-12-21/tinyemu-2019-12-21/json.c b/jslinux-2019-12-21/tinyemu-2019-12-21/json.c
new file mode 100644
index 0000000..d1ebe82
--- /dev/null
+++ b/jslinux-2019-12-21/tinyemu-2019-12-21/json.c
@@ -0,0 +1,464 @@
+/*
+ * Pseudo JSON parser
+ * 
+ * Copyright (c) 2017 Fabrice Bellard
+ *
+ * Permission is hereby granted, free 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.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <inttypes.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <time.h>
+#include <ctype.h>
+
+#include "cutils.h"
+#include "json.h"
+#include "fs_utils.h"
+
+static JSONValue parse_string(const char **pp)
+{
+    char buf[4096], *q;
+    const char *p;
+    int c, h;
+    
+    q = buf;
+    p = *pp;
+    p++;
+    for(;;) {
+        c = *p++;
+        if (c == '\0' || c == '\n') {
+            return json_error_new("unterminated string");
+        } else if (c == '\"') {
+            break;
+            } else if (c == '\\') {
+                c = *p++;
+                switch(c) {
+                case '\'':
+                case '\"':
+                case '\\':
+                    goto add_char;
+                case 'n':
+                    c = '\n';
+                    goto add_char;
+                case 'r':
+                    c = '\r';
+                    goto add_char;
+                case 't':
+                    c = '\t';
+                    goto add_char;
+                case 'x':
+                    h = from_hex(*p++);
+                    if (h < 0)
+                        return json_error_new("invalig hex digit");
+                    c = h << 4;
+                    h = from_hex(*p++);
+                    if (h < 0)
+                        return json_error_new("invalig hex digit");
+                    c |= h;
+                    goto add_char;
+                default:
+                    return json_error_new("unknown escape code");
+                }
+            } else {
+            add_char:
+            if (q >= buf + sizeof(buf) - 1)
+                return json_error_new("string too long");
+            *q++ = c;
+        }
+    }
+    *q = '\0';
+    *pp = p;
+    return json_string_new(buf);
+}
+
+static JSONProperty *json_object_get2(JSONObject *obj, const char *name)
+{
+    JSONProperty *f;
+    int i;
+    for(i = 0; i < obj->len; i++) {
+        f = &obj->props[i];
+        if (!strcmp(f->name.u.str->data, name))
+            return f;
+    }
+    return NULL;
+}
+
+JSONValue json_object_get(JSONValue val, const char *name)
+{
+    JSONProperty *f;
+    JSONObject *obj;
+    
+    if (val.type != JSON_OBJ)
+        return json_undefined_new();
+    obj = val.u.obj;
+    f = json_object_get2(obj, name);
+    if (!f)
+        return json_undefined_new();
+    return f->value;
+}
+
+int json_object_set(JSONValue val, const char *name, JSONValue prop_val)
+{
+    JSONObject *obj;
+    JSONProperty *f;
+    int new_size;
+    
+    if (val.type != JSON_OBJ)
+        return -1;
+    obj = val.u.obj;
+    f = json_object_get2(obj, name);
+    if (f) {
+        json_free(f->value);
+        f->value = prop_val;
+    } else {
+        if (obj->len >= obj->size) {
+            new_size = max_int(obj->len + 1, obj->size * 3 / 2);
+            obj->props = realloc(obj->props, new_size * sizeof(JSONProperty));
+            obj->size = new_size;
+        }
+        f = &obj->props[obj->len++];
+        f->name = json_string_new(name);
+        f->value = prop_val;
+    }
+    return 0;
+}
+
+JSONValue json_array_get(JSONValue val, unsigned int idx)
+{
+    JSONArray *array;
+    
+    if (val.type != JSON_ARRAY)
+        return json_undefined_new();
+    array = val.u.array;
+    if (idx < array->len) {
+        return array->tab[idx];
+    } else {
+        return json_undefined_new();
+    }
+}
+
+int json_array_set(JSONValue val, unsigned int idx, JSONValue prop_val)
+{
+    JSONArray *array;
+    int new_size;
+    
+    if (val.type != JSON_ARRAY)
+        return -1;
+    array = val.u.array;
+    if (idx < array->len) {
+        json_free(array->tab[idx]);
+        array->tab[idx] = prop_val;
+    } else if (idx == array->len) {
+        if (array->len >= array->size) {
+            new_size = max_int(array->len + 1, array->size * 3 / 2);
+            array->tab = realloc(array->tab, new_size * sizeof(JSONValue));
+            array->size = new_size;
+        }
+        array->tab[array->len++] = prop_val;
+    } else {
+        return -1;
+    }
+    return 0;
+}
+
+const char *json_get_str(JSONValue val)
+{
+    if (val.type != JSON_STR)
+        return NULL;
+    return val.u.str->data;
+}
+
+const char *json_get_error(JSONValue val)
+{
+    if (val.type != JSON_EXCEPTION)
+        return NULL;
+    return val.u.str->data;
+}
+
+JSONValue json_string_new2(const char *str, int len)
+{
+    JSONValue val;
+    JSONString *str1;
+
+    str1 = malloc(sizeof(JSONString) + len + 1);
+    str1->len = len;
+    memcpy(str1->data, str, len + 1);
+    val.type = JSON_STR;
+    val.u.str = str1;
+    return val;
+}
+
+JSONValue json_string_new(const char *str)
+{
+    return json_string_new2(str, strlen(str));
+}
+
+JSONValue __attribute__((format(printf, 1, 2))) json_error_new(const char *fmt, ...)
+{
+    JSONValue val;
+    va_list ap;
+    char buf[256];
+    
+    va_start(ap, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+    val = json_string_new(buf);
+    val.type = JSON_EXCEPTION;
+    return val;
+}
+
+JSONValue json_object_new(void)
+{
+    JSONValue val;
+    JSONObject *obj;
+    obj = mallocz(sizeof(JSONObject));
+    val.type = JSON_OBJ;
+    val.u.obj = obj;
+    return val;
+}
+
+JSONValue json_array_new(void)
+{
+    JSONValue val;
+    JSONArray *array;
+    array = mallocz(sizeof(JSONArray));
+    val.type = JSON_ARRAY;
+    val.u.array = array;
+    return val;
+}
+
+void json_free(JSONValue val)
+{
+    switch(val.type) {
+    case JSON_STR:
+    case JSON_EXCEPTION:
+        free(val.u.str);
+        break;
+    case JSON_INT:
+    case JSON_BOOL:
+    case JSON_NULL:
+    case JSON_UNDEFINED:
+        break;
+    case JSON_ARRAY:
+        {
+            JSONArray *array = val.u.array;
+            int i;
+            
+            for(i = 0; i < array->len; i++) {
+                json_free(array->tab[i]);
+            }
+            free(array);
+        }
+        break;
+    case JSON_OBJ:
+        {
+            JSONObject *obj = val.u.obj;
+            JSONProperty *f;
+            int i;
+            
+            for(i = 0; i < obj->len; i++) {
+                f = &obj->props[i];
+                json_free(f->name);
+                json_free(f->value);
+            }
+            free(obj);
+        }
+        break;
+    default:
+        abort();
+    }
+}
+
+static void skip_spaces(const char **pp)
+{
+    const char *p;
+    p = *pp;
+    for(;;) {
+        if (isspace(*p)) {
+            p++;
+        } else if (p[0] == '/' && p[1] == '/') {
+            p += 2;
+            while (*p != '\0' && *p != '\n')
+                p++;
+        } else if (p[0] == '/' && p[1] == '*') {
+            p += 2;
+            while (*p != '\0' && (p[0] != '*' || p[1] != '/'))
+                p++;
+            if (*p != '\0')
+                p += 2;
+        } else {
+            break;
+        }
+    }
+    *pp = p;
+}
+
+static inline BOOL is_ident_first(int c)
+{
+    return (c >= 'a' && c <= 'z') ||
+        (c >= 'A' && c <= 'Z') ||
+        c == '_' || c == '$';
+}
+
+static int parse_ident(char *buf, int buf_size, const char **pp)
+{
+    char *q;
+    const char *p;
+    p = *pp;
+    q = buf;
+    *q++ = *p++; /* first char is already tested */
+    while (is_ident_first(*p) || isdigit(*p)) {
+        if ((q - buf) >= buf_size - 1)
+            return -1;
+        *q++ = *p++;
+    }
+    *pp = p;
+    *q = '\0';
+    return 0;
+}
+
+JSONValue json_parse_value2(const char **pp)
+{
+    char buf[128];
+    const char *p;
+    JSONValue val, val1, tag;
+    
+    p = *pp;
+    skip_spaces(&p);
+    if (*p == '\0') {
+        return json_error_new("unexpected end of file");
+    }
+    if (isdigit(*p)) {
+        val = json_int32_new(strtol(p, (char **)&p, 0));
+    } else if (*p == '"') {
+        val = parse_string(&p);
+    } else if (*p == '{') {
+        p++;
+        val = json_object_new();
+        for(;;) {
+            skip_spaces(&p);
+            if (*p == '}') {
+                p++;
+                break;
+            }
+            if (*p == '"') {
+                tag = parse_string(&p);
+                if (json_is_error(tag))
+                    return tag;
+            } else if (is_ident_first(*p)) {
+                if (parse_ident(buf, sizeof(buf), &p) < 0)
+                    goto invalid_prop;
+                tag = json_string_new(buf);
+            } else {
+                goto invalid_prop;
+            }
+            //            printf("property: %s\n", json_get_str(tag));
+            if (tag.u.str->len == 0) {
+            invalid_prop:
+                return json_error_new("Invalid property name");
+            }
+            skip_spaces(&p);
+            if (*p != ':') {
+                return json_error_new("':' expected");
+            }
+            p++;
+            
+            val1 = json_parse_value2(&p);
+            json_object_set(val, tag.u.str->data, val1);
+
+            skip_spaces(&p);
+            if (*p == ',') {
+                p++;
+            } else if (*p != '}') {
+                return json_error_new("expecting ',' or '}'");
+            }
+        }
+    } else if (*p == '[') {
+        int idx;
+        
+        p++;
+        val = json_array_new();
+        idx = 0;
+        for(;;) {
+            skip_spaces(&p);
+            if (*p == ']') {
+                p++;
+                break;
+            }
+            val1 = json_parse_value2(&p);
+            json_array_set(val, idx++, val1);
+
+            skip_spaces(&p);
+            if (*p == ',') {
+                p++;
+            } else if (*p != ']') {
+                return json_error_new("expecting ',' or ']'");
+            }
+        }
+    } else if (is_ident_first(*p)) {
+        if (parse_ident(buf, sizeof(buf), &p) < 0)
+            goto unknown_id;
+        if (!strcmp(buf, "null")) {
+            val = json_null_new();
+        } else if (!strcmp(buf, "true")) {
+            val = json_bool_new(TRUE);
+        } else if (!strcmp(buf, "false")) {
+            val = json_bool_new(FALSE);
+        } else {
+        unknown_id:
+            return json_error_new("unknown identifier: '%s'", buf);
+        }
+    } else {
+        return json_error_new("unexpected character");
+    }
+    *pp = p;
+    return val;
+}
+
+JSONValue json_parse_value(const char *p)
+{
+    JSONValue val;
+    val = json_parse_value2(&p); 
+    if (json_is_error(val))
+        return val;
+    skip_spaces(&p);
+    if (*p != '\0') {
+        json_free(val);
+        return json_error_new("unexpected characters at the end");
+    }
+    return val;
+}
+
+JSONValue json_parse_value_len(const char *p, int len)
+{
+    char *str;
+    JSONValue val;
+    str = malloc(len + 1);
+    memcpy(str, p, len);
+    str[len] = '\0';
+    val = json_parse_value(str);
+    free(str);
+    return val;
+}