text: /*
   * 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;
  }
  