cosmopolitan/tool/net/ljson.c

/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
│                                                                              │
│ Permission to use, copy, modify, and/or distribute this software for         │
│ any purpose with or without fee is hereby granted, provided that the         │
│ above copyright notice and this permission notice appear in all copies.      │
│                                                                              │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
│ PERFORMANCE OF THIS SOFTWARE.                                                │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/bits/bits.h"
#include "libc/bits/likely.h"
#include "libc/intrin/kprintf.h"
#include "libc/log/check.h"
#include "libc/log/log.h"
#include "libc/str/str.h"
#include "libc/str/tpenc.h"
#include "libc/str/utf16.h"
#include "third_party/double-conversion/wrapper.h"
#include "third_party/lua/cosmo.h"
#include "third_party/lua/lauxlib.h"
#include "third_party/lua/ltests.h"
#include "third_party/lua/lua.h"
#include "tool/net/ljson.h"

#define TOP_LEVEL  0
#define ARRAY_VAL  1
#define OBJECT_KEY 2
#define OBJECT_VAL 3

static struct DecodeJson Parse(struct lua_State *L, const char *p,
                               const char *e, int context, int depth) {
  long x;
  char w[4];
  const char *a;
  luaL_Buffer b;
  const char *reason;
  struct DecodeJson r;
  int A, B, C, D, c, d, i, u;
  if (UNLIKELY(!depth)) {
    return (struct DecodeJson){-1, "maximum depth exceeded"};
  }
  for (a = p, d = +1; p < e;) {
    switch ((c = *p++ & 255)) {
      case ' ':  // spaces
      case '\n':
      case '\r':
      case '\t':
        a = p;
        break;

      case ',':  // present in list and object
        if (context == ARRAY_VAL || context == OBJECT_KEY) {
          a = p;
          break;
        } else {
          return (struct DecodeJson){-1, "unexpected ','"};
        }

      case ':':  // present only in object after key
        if (context == OBJECT_VAL) {
          a = p;
          break;
        } else {
          return (struct DecodeJson){-1, "unexpected ':'"};
        }

      case 'n':  // null
        if (UNLIKELY(context == OBJECT_KEY)) goto BadObjectKey;
        if (p + 3 <= e && READ32LE(p - 1) == READ32LE("null")) {
          lua_pushnil(L);
          return (struct DecodeJson){1, p + 3};
        } else {
          goto IllegalCharacter;
        }

      case 'f':  // false
        if (UNLIKELY(context == OBJECT_KEY)) goto BadObjectKey;
        if (p + 4 <= e && READ32LE(p) == READ32LE("alse")) {
          lua_pushboolean(L, false);
          return (struct DecodeJson){1, p + 4};
        } else {
          goto IllegalCharacter;
        }

      case 't':  // true
        if (UNLIKELY(context == OBJECT_KEY)) goto BadObjectKey;
        if (p + 3 <= e && READ32LE(p - 1) == READ32LE("true")) {
          lua_pushboolean(L, true);
          return (struct DecodeJson){1, p + 3};
        } else {
          goto IllegalCharacter;
        }

      BadObjectKey:
        return (struct DecodeJson){-1, "object key must be string"};

      case '-':  // negative
        if (UNLIKELY(context == OBJECT_KEY)) goto BadObjectKey;
        if (p < e && isdigit(*p)) {
          d = -1;
          break;
        } else {
          return (struct DecodeJson){-1, "bad negative"};
        }

      case '0':  // zero or number
        if (UNLIKELY(context == OBJECT_KEY)) goto BadObjectKey;
        if (p < e) {
          if ((*p == '.' || *p == 'e' || *p == 'E')) {
            goto UseDubble;
          } else if (isdigit(*p)) {
            return (struct DecodeJson){-1, "unexpected octal"};
          }
        }
        lua_pushinteger(L, 0);
        return (struct DecodeJson){1, p};

      case '1' ... '9':  // integer
        if (UNLIKELY(context == OBJECT_KEY)) goto BadObjectKey;
        for (x = (c - '0') * d; p < e; ++p) {
          c = *p & 255;
          if (isdigit(c)) {
            if (__builtin_mul_overflow(x, 10, &x) ||
                __builtin_add_overflow(x, (c - '0') * d, &x)) {
              goto UseDubble;
            }
          } else if (c == '.' || c == 'e' || c == 'E') {
            goto UseDubble;
          } else {
            break;
          }
        }
        lua_pushinteger(L, x);
        return (struct DecodeJson){1, p};

      UseDubble:  // number
        lua_pushnumber(L, StringToDouble(a, e - a, &c));
        DCHECK(c > 0, "paranoid avoiding infinite loop");
        return (struct DecodeJson){1, a + c};

      case '[':  // Array
        if (UNLIKELY(context == OBJECT_KEY)) goto BadObjectKey;
        lua_newtable(L);
        i = 0;
        for (;;) {
          r = Parse(L, p, e, ARRAY_VAL, depth - 1);
          if (UNLIKELY(r.rc == -1)) {
            lua_pop(L, 1);
            return r;
          }
          p = r.p;
          if (!r.rc) {
            break;
          }
          lua_rawseti(L, -2, i++ + 1);
        }
        if (!i) {
          // we need this kludge so `[]` won't round-trip as `{}`
          lua_pushboolean(L, false);
          lua_rawseti(L, -2, 0);
        }
        return (struct DecodeJson){1, p};

      case ']':
        if (context == ARRAY_VAL) {
          return (struct DecodeJson){0, p};
        } else {
          return (struct DecodeJson){-1, "unexpected ']'"};
        }

      case '}':
        if (context == OBJECT_KEY) {
          return (struct DecodeJson){0, p};
        } else {
          return (struct DecodeJson){-1, "unexpected '}'"};
        }

      case '{':  // Object
        if (UNLIKELY(context == OBJECT_KEY)) goto BadObjectKey;
        lua_newtable(L);
        for (;;) {
          r = Parse(L, p, e, OBJECT_KEY, depth - 1);
          if (r.rc == -1) {
            lua_pop(L, 1);
            return r;
          }
          p = r.p;
          if (!r.rc) {
            break;
          }
          r = Parse(L, p, e, OBJECT_VAL, depth - 1);
          if (r.rc == -1) {
            lua_pop(L, 2);
            return r;
          }
          if (!r.rc) {
            lua_pop(L, 2);
            return (struct DecodeJson){-1, "unexpected eof in object"};
          }
          p = r.p;
          lua_settable(L, -3);
        }
        return (struct DecodeJson){1, p};

      case '"':  // string
        luaL_buffinit(L, &b);
        for (;;) {
          if (UNLIKELY(p >= e)) {
          UnexpectedEofString:
            reason = "unexpected eof in string";
            goto StringFailureWithReason;
          }
          c = *p++ & 255;
          if (c == '"') {
            luaL_pushresult(&b);
            return (struct DecodeJson){1, p};
          } else if (c == '\\') {
            goto HandleEscape;
          } else if (UNLIKELY(c <= 0x1F)) {
            reason = "non-del c0 in string";
            goto StringFailureWithReason;
          } else {
            luaL_addchar(&b, c);
          }
          continue;
        HandleEscape:
          if (UNLIKELY(p >= e)) {
            goto UnexpectedEofString;
          }
          switch ((c = *p++ & 255)) {
            case '"':
            case '/':
            case '\\':
              luaL_addchar(&b, c);
              break;
            case 'b':
              luaL_addchar(&b, '\b');
              break;
            case 'f':
              luaL_addchar(&b, '\f');
              break;
            case 'n':
              luaL_addchar(&b, '\n');
              break;
            case 'r':
              luaL_addchar(&b, '\r');
              break;
            case 't':
              luaL_addchar(&b, '\t');
              break;
            case 'x':
              if (p + 2 <= e &&                         //
                  (A = kHexToInt[p[0] & 255]) != -1 &&  // HEX
                  (B = kHexToInt[p[1] & 255]) != -1) {  //
                c = A << 4 | B;
                if (!(0x20 <= c && c <= 0x7E)) {
                  reason = "hex escape not printable";
                  goto StringFailureWithReason;
                }
                p += 2;
                luaL_addchar(&b, c);
                break;
              } else {
                reason = "invalid hex escape";
                goto StringFailureWithReason;
              }
            case 'u':
              if (p + 4 <= e &&                         //
                  (A = kHexToInt[p[0] & 255]) != -1 &&  //
                  (B = kHexToInt[p[1] & 255]) != -1 &&  // UCS-2
                  (C = kHexToInt[p[2] & 255]) != -1 &&  //
                  (D = kHexToInt[p[3] & 255]) != -1) {  //
                c = A << 12 | B << 8 | C << 4 | D;
                if (!IsSurrogate(c)) {
                  p += 4;
                } else if (IsHighSurrogate(c)) {
                  if (p + 4 + 6 <= e &&                     //
                      p[4] == '\\' &&                       //
                      p[5] == 'u' &&                        //
                      (A = kHexToInt[p[6] & 255]) != -1 &&  // UTF-16
                      (B = kHexToInt[p[7] & 255]) != -1 &&  //
                      (C = kHexToInt[p[8] & 255]) != -1 &&  //
                      (D = kHexToInt[p[9] & 255]) != -1) {  //
                    u = A << 12 | B << 8 | C << 4 | D;
                    if (IsLowSurrogate(u)) {
                      p += 4 + 6;
                      c = MergeUtf16(c, u);
                    } else {
                      goto BadUnicode;
                    }
                  } else {
                    goto BadUnicode;
                  }
                } else {
                  goto BadUnicode;
                }
                // UTF-8
                if (c <= 0x7f) {
                  w[0] = c;
                  i = 1;
                } else if (c <= 0x7ff) {
                  w[0] = 0300 | (c >> 6);
                  w[1] = 0200 | (c & 077);
                  i = 2;
                } else if (c <= 0xffff) {
                  if (UNLIKELY(IsSurrogate(c))) {
                  ReplacementCharacter:
                    c = 0xfffd;
                  }
                  w[0] = 0340 | (c >> 12);
                  w[1] = 0200 | ((c >> 6) & 077);
                  w[2] = 0200 | (c & 077);
                  i = 3;
                } else if (~(c >> 18) & 007) {
                  w[0] = 0360 | (c >> 18);
                  w[1] = 0200 | ((c >> 12) & 077);
                  w[2] = 0200 | ((c >> 6) & 077);
                  w[3] = 0200 | (c & 077);
                  i = 4;
                } else {
                  goto ReplacementCharacter;
                }
                luaL_addlstring(&b, w, i);
              } else {
                reason = "invalid unicode escape";
                goto StringFailureWithReason;
              BadUnicode:
                // Echo invalid \uXXXX sequences
                // Rather than corrupting UTF-8!
                luaL_addstring(&b, "\\u");
              }
              break;
            default:
              reason = "invalid escape character";
              goto StringFailureWithReason;
          }
        }
        unreachable;
      StringFailureWithReason:
        luaL_pushresultsize(&b, 0);
        lua_pop(L, 1);
        return (struct DecodeJson){-1, reason};

      default:
      IllegalCharacter:
        return (struct DecodeJson){-1, "illegal character"};
    }
  }
  if (UNLIKELY(context == TOP_LEVEL)) {
    return (struct DecodeJson){0, 0};
  } else {
    return (struct DecodeJson){-1, "unexpected eof"};
  }
}

/**
 * Parses JSON data structure string into Lua data structure.
 *
 * This function returns the number of items pushed to the Lua stack,
 * which should be 1, unless no parseable JSON content was found, in
 * which case this will return 0. On error -1 is returned. There's
 * currently no error return condition. This function doesn't do JSON
 * validity enforcement.
 *
 * JSON UTF-16 strings are re-encoded as valid UTF-8. 64-bit integers
 * are supported. If an integer overflows during parsing, it'll be
 * converted to a floating-point number instead. Invalid surrogate
 * escape sequences in strings won't be decoded.
 *
 * @param L is Lua interpreter state
 * @param p is input string
 * @param n is byte length of `p` or -1 for automatic strlen()
 * @return r.rc is 1 if value is pushed on lua stack
 * @return r.rc is 0 on eof
 * @return r.rc is -1 on error
 * @return r.p is is advanced `p` pointer if `rc ≥ 0`
 * @return r.p is string describing error if `rc < 0`
 */
struct DecodeJson DecodeJson(struct lua_State *L, const char *p, size_t n) {
  int depth = 64;
  if (n == -1) n = p ? strlen(p) : 0;
  if (lua_checkstack(L, depth * 4)) {
    return Parse(L, p, p + n, TOP_LEVEL, depth);
  } else {
    return (struct DecodeJson){-1, "can't set stack depth"};
  }
}