# json.ludic — a small JSON reader for the Ludic tooling (vocabulary check,
# docs generator). Enough of JSON to read the editor grammar and the docs
# config: objects, arrays, strings (with \uXXXX + surrogates), numbers, the
# literals. Values are a JVal tree; object member order is preserved.

property JVal { t: int = 0, num: int = 0, b: int = 0, s: pointer = null, kids: []JVal, keys: []pointer }

const JV_NULL: int = 0
const JV_BOOL: int = 1
const JV_NUM: int = 2
const JV_STR: int = 3
const JV_ARR: int = 4
const JV_OBJ: int = 5

function jval_new(t: int) -> JVal {
  let v = new JVal
  v.t = t
  v.s = ""
  v.kids = new []JVal
  v.keys = new []pointer
  return v
}

var jbuf: pointer = ""
var jpos: int = 0
var jerr: bool = false

function j_ws() -> void {
  while jbuf[jpos] == ' ' or jbuf[jpos] == '\t' or jbuf[jpos] == '\n' or jbuf[jpos] == '\r' { jpos += 1 }
}

function j_hex(c: int) -> int {
  if c >= '0' and c <= '9' { return c - 48 }
  if c >= 'a' and c <= 'f' { return c - 97 + 10 }
  if c >= 'A' and c <= 'F' { return c - 65 + 10 }
  return 0
}
function j_hex4() -> int {
  var v = 0;  var i = 0
  while i < 4 { v = v * 16 + j_hex(jbuf[jpos]);  jpos += 1;  i += 1 }
  return v
}

# append codepoint cp to buffer b at *n (UTF-8); returns new n
function utf8_put(b: pointer, n: int, cp: int) -> int {
  if cp < 128 { b[n] = cp;  return n + 1 }
  if cp < 2048 { b[n] = 192 + (cp >> 6);  b[n + 1] = 128 + (cp & 63);  return n + 2 }
  if cp < 65536 { b[n] = 224 + (cp >> 12);  b[n + 1] = 128 + ((cp >> 6) & 63);  b[n + 2] = 128 + (cp & 63);  return n + 3 }
  b[n] = 240 + (cp >> 18);  b[n + 1] = 128 + ((cp >> 12) & 63);  b[n + 2] = 128 + ((cp >> 6) & 63);  b[n + 3] = 128 + (cp & 63)
  return n + 4
}

# parse a JSON string starting at the opening quote; returns a fresh buffer
function j_string() -> pointer {
  jpos += 1                                   # opening quote
  # over-allocate: escapes only ever shrink the byte count
  let cap = slen(jbuf) - jpos + 1
  let out = bytes(cap + 4)
  var n = 0
  while jbuf[jpos] != 0 and jbuf[jpos] != '"' {
    if jbuf[jpos] == '\\' {
      jpos += 1
      let c = jbuf[jpos];  jpos += 1
      if c == 'n' { out[n] = '\n';  n += 1 }
      else { if c == 't' { out[n] = '\t';  n += 1 }
      else { if c == 'r' { out[n] = '\r';  n += 1 }
      else { if c == 'b' { out[n] = 8;  n += 1 }
      else { if c == 'f' { out[n] = 12;  n += 1 }
      else { if c == 'u' {
        var cp = j_hex4()
        if cp >= 55296 and cp < 56320 and jbuf[jpos] == '\\' and jbuf[jpos + 1] == 'u' {
          jpos += 2
          let lo = j_hex4()
          cp = 65536 + ((cp - 55296) << 10) + (lo - 56320)
        }
        n = utf8_put(out, n, cp)
      } else { out[n] = c;  n += 1 } } } } } }
    } else { out[n] = jbuf[jpos];  n += 1;  jpos += 1 }
  }
  if jbuf[jpos] == '"' { jpos += 1 }
  out[n] = 0
  return out
}

function j_value() -> JVal {
  j_ws()
  let c = jbuf[jpos]
  if c == '{' {                                     # '{'
    jpos += 1
    let v = jval_new(JV_OBJ)
    j_ws()
    if jbuf[jpos] == '}' { jpos += 1;  return v }
    while true {
      j_ws()
      var key = ""
      if jbuf[jpos] == '"' { key = j_string() } else { jerr = true }
      j_ws();  if jbuf[jpos] == ':' { jpos += 1 } else { jerr = true }
      let kid = j_value()
      push(v.keys, key);  push(v.kids, kid)
      j_ws()
      if jbuf[jpos] == ',' { jpos += 1 } else { if jbuf[jpos] == '}' { jpos += 1;  return v } else { return v } }
    }
    return v
  }
  if c == '[' {                                      # '['
    jpos += 1
    let v = jval_new(JV_ARR)
    j_ws()
    if jbuf[jpos] == ']' { jpos += 1;  return v }
    while true {
      let kid = j_value()
      push(v.kids, kid)
      j_ws()
      if jbuf[jpos] == ',' { jpos += 1 } else { if jbuf[jpos] == ']' { jpos += 1;  return v } else { return v } }
    }
    return v
  }
  if c == '"' {                                      # '"'
    let v = jval_new(JV_STR)
    v.s = j_string()
    return v
  }
  if c == 't' {                                     # true
    jpos += 4;  let v = jval_new(JV_BOOL);  v.b = 1;  return v
  }
  if c == 'f' {                                     # false
    jpos += 5;  let v = jval_new(JV_BOOL);  v.b = 0;  return v
  }
  if c == 'n' {                                     # null
    jpos += 4;  return jval_new(JV_NULL)
  }
  # number
  let start = jpos
  if jbuf[jpos] == '-' { jpos += 1 }
  if jbuf[jpos] < '0' or jbuf[jpos] > '9' { jerr = true;  if jbuf[jpos] != 0 { jpos += 1 };  return jval_new(JV_NULL) }
  while (jbuf[jpos] >= '0' and jbuf[jpos] <= '9') or jbuf[jpos] == '.' or jbuf[jpos] == 'e' or jbuf[jpos] == 'E' or jbuf[jpos] == '+' or jbuf[jpos] == '-' { jpos += 1 }
  let v = jval_new(JV_NUM)
  v.s = sslice(jbuf, start, jpos)
  v.num = str_to_int(v.s)
  return v
}

# parse whole `text`; returns the root JVal (JV_NULL on empty)
function json_parse(text: pointer) -> JVal {
  jbuf = text;  jpos = 0;  jerr = false
  return j_value()
}

# is `text` well-formed JSON that consumes to the end?
function json_valid(text: pointer) -> bool {
  let v = json_parse(text)
  j_ws()
  if jerr { return false }
  if jpos != slen(text) { return false }
  return true
}

# integer value of a decimal string (ignores any fractional part)
function str_to_int(s: pointer) -> int {
  var i = 0;  var neg = false
  if s[0] == '-' { neg = true;  i = 1 }
  var v = 0
  while s[i] >= '0' and s[i] <= '9' { v = v * 10 + (s[i] - 48);  i += 1 }
  if neg { return -v }
  return v
}

# the lowercase hex digit for 0..15
function j_hexch(v: int) -> int {
  if v < 10 { return '0' + v }
  return 'a' + (v - 10)
}

# `s` as a JSON string literal: quoted, with " \\ and control bytes escaped
function j_quote(s: pointer) -> pointer {
  let b = sb_new()
  sb_putc(b, '"')
  var i = 0
  while s[i] != 0 {
    let c = s[i]
    if c == '"' { sb_puts(b, "\\\"") }
    else if c == '\\' { sb_puts(b, "\\\\") }
    else if c == '\n' { sb_puts(b, "\\n") }
    else if c == '\r' { sb_puts(b, "\\r") }
    else if c == '\t' { sb_puts(b, "\\t") }
    else if c >= 0 and c < ' ' { sb_puts(b, "\\u00");  sb_putc(b, j_hexch(c / 16));  sb_putc(b, j_hexch(c % 16)) }
    else { sb_putc(b, c) }
    i += 1
  }
  sb_putc(b, '"')
  return sb_str(b)
}

# object member lookup by key (JV_NULL if absent or not an object)
function j_get(v: JVal, key: pointer) -> JVal {
  if v.t != JV_OBJ { return jval_new(JV_NULL) }
  var i = 0
  while i < len(v.keys) { if v.keys[i] == key { return v.kids[i] };  i += 1 }
  return jval_new(JV_NULL)
}