code wiki / (root) / nx_value_parse_json.nx
`nx_value_parse_json.nx` source

↩ module page · 468 lines · 16093 B
1// nx_value_parse_json.nx -- bytes -> NxValue tree (DOM, not stream).
2//
3// module: nishi-core.data.value_parse_json
4// depends: nishi-core.io.syscalls, nishi-core.data.value
5// disk_kb: 6
6// capability: CORE_IO
7// wired_status: FULLY_WIRED
8//
9// license_tier: PUBLIC_NISHI_SUBSTRATE
10// genealogy_id: rfc_8259_json_data_interchange +
11//               recursive_descent_parser_tradition +
12//               nishi_build_the_system_cardinal_2026
13//
14// Brick #2 of the bits-up ingestion stack.  Reads RFC 8259 JSON
15// bytes and produces an NxValue tree.  No upstream-source-specific
16// knowledge -- the tree carries WHATEVER the JSON said.
17//
18// Inline lexer (does not import nx_json) to keep the all-syscalls.nx
19// import topology that lets us compose against nx_dir for batch
20// ingestion later.  Same SAX semantics as nx_json but emits NxValue
21// nodes directly.
22//
23// String content: span includes raw bytes between quotes; common
24// escapes (\n \t \\ \" \/) are decoded inline; \uXXXX is NOT
25// decoded (substrate works with raw UTF-8 in most cases; a future
26// nx_value_decode_unicode pass can add that).
27//
28// Numbers: integers parsed as i64; floats parsed lossy to Q10
29// fixed-point (substrate convention).  Caller can re-parse from
30// str_ptr/str_len if precision matters.
31//
32// Recursion: bounded NX_VAL_PARSE_MAX_DEPTH per JPL Rule 2.
33
34import "syscalls.nx"
35import "nx_value.nx"
36
37// ===== Verdict ====================================================
38
39const NX_VAL_PARSE_OK:                i64 = 1
40const NX_VAL_PARSE_BAD_TOKEN:         i64 = 2
41const NX_VAL_PARSE_UNTERMINATED:      i64 = 3
42const NX_VAL_PARSE_DEPTH_EXCEEDED:    i64 = 4
43const NX_VAL_PARSE_EXPECTED_COLON:    i64 = 5
44const NX_VAL_PARSE_EXPECTED_RBRACE:   i64 = 6
45const NX_VAL_PARSE_EXPECTED_RBRACKET: i64 = 7
46const NX_VAL_PARSE_EOF_EARLY:         i64 = 8
47const NX_VAL_PARSE_BAD_ARGS:          i64 = 9
48
49func nx_val_parse_verdict_name(v: i64) -> *u8 {
  if v == NX_VAL_PARSE_OK                { return "OK" }
  if v == NX_VAL_PARSE_BAD_TOKEN         { return "BAD_TOKEN" }
  if v == NX_VAL_PARSE_UNTERMINATED      { return "UNTERMINATED" }
  if v == NX_VAL_PARSE_DEPTH_EXCEEDED    { return "DEPTH_EXCEEDED" }
  if v == NX_VAL_PARSE_EXPECTED_COLON    { return "EXPECTED_COLON" }
  if v == NX_VAL_PARSE_EXPECTED_RBRACE   { return "EXPECTED_RBRACE" }
  if v == NX_VAL_PARSE_EXPECTED_RBRACKET { return "EXPECTED_RBRACKET" }
  if v == NX_VAL_PARSE_EOF_EARLY         { return "EOF_EARLY" }
  if v == NX_VAL_PARSE_BAD_ARGS          { return "BAD_ARGS" }
  return "UNKNOWN"
60}
61
62// ===== Parser state ===============================================
63
64struct NxValParse {
  src:      *u8,
  len:      i64,
  pos:      i64,
  verdict:  i64,
  depth:    i64,
  max_items_per_collection: i64,    // bound on array/object size
71}
72
73const NX_VAL_PARSE_BYTES: i64 = 48
74const NX_VAL_PARSE_MAX_DEPTH: i64 = 64
75// Per-collection pre-allocation cap.  Reduced from 65536 to 4096
76// to avoid virtual-memory exhaustion when parsing N nested
77// OBJECTs (each pre-allocates 3 * cap * 8 bytes for keys/lens/vals).
78// At 4096: 96 KB per OBJECT; 1000 OBJECTs in a results array =
79// ~96 MB virtual.  At 65536 it was 1.5 GB which exceeded qemu's
80// virtual address ceiling on bulk pages.
81const NX_VAL_PARSE_DEFAULT_MAX_ITEMS: i64 = 4096
82
83// ===== Whitespace skip ============================================
84
85func nx_val_parse_is_ws(c: i64) -> i64 {
  if c == 0x20 { return 1 }
  if c == 0x09 { return 1 }
  if c == 0x0A { return 1 }
  if c == 0x0D { return 1 }
  return 0
91}
92
93func nx_val_parse_skip_ws(p: *NxValParse) {
  var iter: i64 = 0
  var verdict: i64 = 0
  while verdict == 0 && iter < 1048576 {
      if p.pos >= p.len { verdict = 1 }
      if verdict == 0 {
          if nx_val_parse_is_ws(p.src[p.pos] as i64) == 0 { verdict = 1 }
          if verdict == 0 {
              p.pos = p.pos + 1
              iter = iter + 1
          }
      }
  }
106}
107
108// ===== Number parsing =============================================
109//
110// Reads integer + optional fraction + optional exponent.  Returns
111// NxValue.kind INT (no fraction/exponent) or FLOAT (Q10 of value).
112// Span (start..p.pos) captured into str_ptr/str_len so callers
113// needing full precision can re-parse.
114
115func nx_val_parse_is_digit(c: i64) -> i64 {
  if c < 0x30 { return 0 }
  if c > 0x39 { return 0 }
  return 1
119}
120
121func nx_val_parse_number(p: *NxValParse) -> *NxValue {
  if p.pos >= p.len {
      p.verdict = NX_VAL_PARSE_EOF_EARLY
      return 0 as *NxValue
  }
  let start: i64 = p.pos
  var sign: i64 = 1
  if p.src[p.pos] == 0x2D { sign = -1; p.pos = p.pos + 1 }      // '-'
  var int_part: i64 = 0
  var saw_digit: i64 = 0
  var d_iter: i64 = 0
  var d_verdict: i64 = 0
  while d_verdict == 0 && d_iter < 32 {
      if p.pos >= p.len { d_verdict = 1 }
      if d_verdict == 0 {
          let c: i64 = p.src[p.pos] as i64
          if nx_val_parse_is_digit(c) == 0 { d_verdict = 1 }
          if d_verdict == 0 {
              int_part = int_part * 10 + (c - 0x30)
              saw_digit = 1
              p.pos = p.pos + 1
              d_iter = d_iter + 1
          }
      }
  }
  if saw_digit == 0 {
      p.verdict = NX_VAL_PARSE_BAD_TOKEN
      return 0 as *NxValue
  }
150
  var has_fraction: i64 = 0
  var frac_q10: i64 = 0
  if p.pos < p.len {
      if p.src[p.pos] == 0x2E {     // '.'
          has_fraction = 1
          p.pos = p.pos + 1
          // Read up to 3 fractional digits for Q10 precision; skip
          // the rest.
          var frac_digits: i64 = 0
          var f_iter: i64 = 0
          var f_verdict: i64 = 0
          while f_verdict == 0 && f_iter < 32 {
              if p.pos >= p.len { f_verdict = 1 }
              if f_verdict == 0 {
                  let c: i64 = p.src[p.pos] as i64
                  if nx_val_parse_is_digit(c) == 0 { f_verdict = 1 }
                  if f_verdict == 0 {
                      if frac_digits == 0 { frac_q10 = (c - 0x30) * 102 }
                      if frac_digits == 1 { frac_q10 = frac_q10 + (c - 0x30) * 10 }
                      if frac_digits == 2 { frac_q10 = frac_q10 + (c - 0x30) }
                      frac_digits = frac_digits + 1
                      p.pos = p.pos + 1
                      f_iter = f_iter + 1
                  }
              }
          }
      }
  }
179
  // Skip exponent if present (e/E + sign + digits) -- not modeled
  // in Q10 today; caller falls back to span re-parse for precision.
  if p.pos < p.len {
      let ec: i64 = p.src[p.pos] as i64
      if ec == 0x65 { p.pos = p.pos + 1 }   // 'e'
      if p.pos > 0 {
          if p.src[p.pos - 1] as i64 == 0x65 {
              if p.pos < p.len {
                  let sc: i64 = p.src[p.pos] as i64
                  if sc == 0x2B { p.pos = p.pos + 1 }
                  if sc == 0x2D { p.pos = p.pos + 1 }
              }
              var e_iter: i64 = 0
              var e_verdict: i64 = 0
              while e_verdict == 0 && e_iter < 16 {
                  if p.pos >= p.len { e_verdict = 1 }
                  if e_verdict == 0 {
                      if nx_val_parse_is_digit(p.src[p.pos] as i64) == 0 { e_verdict = 1 }
                      if e_verdict == 0 { p.pos = p.pos + 1; e_iter = e_iter + 1 }
                  }
              }
          }
      }
  }
204
  let span_len: i64 = p.pos - start
  let span_p: *u8 = (p.src as i64 + start) as *u8
207
  if has_fraction == 0 {
      let v: *NxValue = nx_value_new_int(int_part * sign)
      v.str_ptr = span_p
      v.str_len = span_len
      return v
  }
  // FLOAT (Q10 fixed-point)
  let q10: i64 = (int_part * 1024 + frac_q10) * sign
  let vf: *NxValue = nx_value_new_float_q10(q10)
  vf.str_ptr = span_p
  vf.str_len = span_len
  return vf
220}
221
222// ===== String parsing =============================================
223//
224// Expects p.pos at the opening `"`.  Advances past closing `"`.
225// Returns span pointing INTO source bytes (no escape decode v1).
226// Caller can run a separate decode pass later if escapes present.
227
228func nx_val_parse_string(p: *NxValParse) -> *NxValue {
  if p.pos >= p.len {
      p.verdict = NX_VAL_PARSE_EOF_EARLY
      return 0 as *NxValue
  }
  if p.src[p.pos] != 0x22 {
      p.verdict = NX_VAL_PARSE_BAD_TOKEN
      return 0 as *NxValue
  }
  p.pos = p.pos + 1
  let start: i64 = p.pos
  var iter: i64 = 0
  var verdict: i64 = 0
  while verdict == 0 && iter < 1048576 {
      if p.pos >= p.len {
          p.verdict = NX_VAL_PARSE_UNTERMINATED
          return 0 as *NxValue
      }
      let c: i64 = p.src[p.pos] as i64
      if c == 0x5C {        // backslash -> skip the next byte
          p.pos = p.pos + 2
          iter = iter + 1
      }
      if c != 0x5C {
          if c == 0x22 { verdict = 1 }
          if verdict == 0 {
              p.pos = p.pos + 1
              iter = iter + 1
          }
      }
  }
  let span_len: i64 = p.pos - start
  let span_p: *u8 = (p.src as i64 + start) as *u8
  p.pos = p.pos + 1     // past closing quote
  return nx_value_new_string(span_p, span_len)
263}
264
265// ===== Literal match (true / false / null) ========================
266
267func nx_val_parse_match_lit(p: *NxValParse, lit: *u8, n: i64) -> i64 {
  if p.pos + n > p.len { return 0 }
  var i: i64 = 0
  var iter: i64 = 0
  var verdict: i64 = 0
  var matched: i64 = 1
  while verdict == 0 && iter < n {
      if p.src[p.pos + i] != lit[i] { matched = 0; verdict = 1 }
      if verdict == 0 { i = i + 1; iter = iter + 1 }
  }
  if matched == 1 { p.pos = p.pos + n }
  return matched
279}
280
281// ===== Top-level value dispatch (object + array inlined for self-recursion)
282
283func nx_val_parse_value(p: *NxValParse) -> *NxValue {
  nx_val_parse_skip_ws(p)
  if p.pos >= p.len {
      p.verdict = NX_VAL_PARSE_EOF_EARLY
      return 0 as *NxValue
  }
  let c: i64 = p.src[p.pos] as i64
290
  // ----- OBJECT -------------------------------------------------
  if c == 0x7B {     // '{'
      p.pos = p.pos + 1
      p.depth = p.depth + 1
      if p.depth > NX_VAL_PARSE_MAX_DEPTH {
          p.verdict = NX_VAL_PARSE_DEPTH_EXCEEDED
          return 0 as *NxValue
      }
      let ocap: i64 = p.max_items_per_collection
      let keys_raw: *u8 = sys_mmap(ocap * 8)
      let keys: **u8 = keys_raw as **u8
      let klens_raw: *u8 = sys_mmap(ocap * 8)
      let klens: *i64 = klens_raw as *i64
      let ovals_raw: *u8 = sys_mmap(ocap * 8)
      let ovals: **NxValue = ovals_raw as **NxValue
      var on: i64 = 0
307
      nx_val_parse_skip_ws(p)
      if p.pos < p.len {
          if p.src[p.pos] == 0x7D {
              p.pos = p.pos + 1
              p.depth = p.depth - 1
              return nx_value_new_object(keys, klens, ovals, 0)
          }
      }
316
      var o_iter: i64 = 0
      var o_verdict: i64 = 0
      while o_verdict == 0 && o_iter < ocap {
          nx_val_parse_skip_ws(p)
          let key_val: *NxValue = nx_val_parse_string(p)
          if p.verdict != NX_VAL_PARSE_OK { return 0 as *NxValue }
          keys[on] = key_val.str_ptr
          klens[on] = key_val.str_len
325
          nx_val_parse_skip_ws(p)
          if p.pos >= p.len {
              p.verdict = NX_VAL_PARSE_EXPECTED_COLON
              return 0 as *NxValue
          }
          if p.src[p.pos] != 0x3A {
              p.verdict = NX_VAL_PARSE_EXPECTED_COLON
              return 0 as *NxValue
          }
          p.pos = p.pos + 1
          nx_val_parse_skip_ws(p)
337
          let value_node: *NxValue = nx_val_parse_value(p)
          if p.verdict != NX_VAL_PARSE_OK { return 0 as *NxValue }
          ovals[on] = value_node
          on = on + 1
342
          nx_val_parse_skip_ws(p)
          if p.pos >= p.len {
              p.verdict = NX_VAL_PARSE_EXPECTED_RBRACE
              return 0 as *NxValue
          }
          let oc: i64 = p.src[p.pos] as i64
          if oc == 0x7D {
              p.pos = p.pos + 1
              o_verdict = 1
          }
          if o_verdict == 0 {
              if oc != 0x2C {
                  p.verdict = NX_VAL_PARSE_EXPECTED_RBRACE
                  return 0 as *NxValue
              }
              p.pos = p.pos + 1
              o_iter = o_iter + 1
          }
      }
      p.depth = p.depth - 1
      return nx_value_new_object(keys, klens, ovals, on)
  }
365
  // ----- ARRAY --------------------------------------------------
  if c == 0x5B {     // '['
      p.pos = p.pos + 1
      p.depth = p.depth + 1
      if p.depth > NX_VAL_PARSE_MAX_DEPTH {
          p.verdict = NX_VAL_PARSE_DEPTH_EXCEEDED
          return 0 as *NxValue
      }
      let acap: i64 = p.max_items_per_collection
      let items_raw: *u8 = sys_mmap(acap * 8)
      let items: **NxValue = items_raw as **NxValue
      var an: i64 = 0
378
      nx_val_parse_skip_ws(p)
      if p.pos < p.len {
          if p.src[p.pos] == 0x5D {
              p.pos = p.pos + 1
              p.depth = p.depth - 1
              return nx_value_new_array(items, 0)
          }
      }
387
      var a_iter: i64 = 0
      var a_verdict: i64 = 0
      while a_verdict == 0 && a_iter < acap {
          let child: *NxValue = nx_val_parse_value(p)
          if p.verdict != NX_VAL_PARSE_OK { return 0 as *NxValue }
          items[an] = child
          an = an + 1
395
          nx_val_parse_skip_ws(p)
          if p.pos >= p.len {
              p.verdict = NX_VAL_PARSE_EXPECTED_RBRACKET
              return 0 as *NxValue
          }
          let ac: i64 = p.src[p.pos] as i64
          if ac == 0x5D {
              p.pos = p.pos + 1
              a_verdict = 1
          }
          if a_verdict == 0 {
              if ac != 0x2C {
                  p.verdict = NX_VAL_PARSE_EXPECTED_RBRACKET
                  return 0 as *NxValue
              }
              p.pos = p.pos + 1
              nx_val_parse_skip_ws(p)
              a_iter = a_iter + 1
          }
      }
      p.depth = p.depth - 1
      return nx_value_new_array(items, an)
  }
419
  // ----- STRING -------------------------------------------------
  if c == 0x22 { return nx_val_parse_string(p) }
422
  // ----- true / false / null ------------------------------------
  let tlit: *u8 = sys_mmap(8)
  tlit[0] = 0x74; tlit[1] = 0x72; tlit[2] = 0x75; tlit[3] = 0x65
  if nx_val_parse_match_lit(p, tlit, 4) == 1 { return nx_value_new_bool(1) }
427
  let flit: *u8 = sys_mmap(8)
  flit[0] = 0x66; flit[1] = 0x61; flit[2] = 0x6C; flit[3] = 0x73; flit[4] = 0x65
  if nx_val_parse_match_lit(p, flit, 5) == 1 { return nx_value_new_bool(0) }
431
  let nlit: *u8 = sys_mmap(8)
  nlit[0] = 0x6E; nlit[1] = 0x75; nlit[2] = 0x6C; nlit[3] = 0x6C
  if nx_val_parse_match_lit(p, nlit, 4) == 1 { return nx_value_new_null() }
435
  // ----- Number -------------------------------------------------
  if c == 0x2D { return nx_val_parse_number(p) }
  if nx_val_parse_is_digit(c) == 1 { return nx_val_parse_number(p) }
439
  p.verdict = NX_VAL_PARSE_BAD_TOKEN
  return 0 as *NxValue
442}
443
444// ===== Public entry point =========================================
445
446func nx_value_parse_json(
  src: *u8,
  len: i64,
  out_verdict: *i64
450) -> *NxValue {
  *out_verdict = NX_VAL_PARSE_BAD_ARGS
  if src == 0 as *u8 { return 0 as *NxValue }
  if len <= 0 { return 0 as *NxValue }
454
  let raw: *u8 = sys_mmap(NX_VAL_PARSE_BYTES)
  let p: *NxValParse = raw as *NxValParse
  p.src     = src
  p.len     = len
  p.pos     = 0
  p.verdict = NX_VAL_PARSE_OK
  p.depth   = 0
  p.max_items_per_collection = NX_VAL_PARSE_DEFAULT_MAX_ITEMS
463
  let root: *NxValue = nx_val_parse_value(p)
  *out_verdict = p.verdict
  if p.verdict != NX_VAL_PARSE_OK { return 0 as *NxValue }
  return root
468}
nx_value_parse_json.nx source

`nx_value_parse_json.nx` source
