341 lines
11 KiB
Plaintext
341 lines
11 KiB
Plaintext
// no external using required for quick json_query (text-slicing)
|
|
|
|
static box Main {
|
|
main() {
|
|
// Simple JSON query runner: evaluate a few (json, path) pairs and print results
|
|
// Path grammar (subset):
|
|
// <path> := ('.' <ident> | '[' <digits> ']')*
|
|
// Examples: .a.b[1], .c, [0]
|
|
|
|
local cases = new ArrayBox()
|
|
|
|
// Case 1
|
|
local j1 = "{\"a\":{\"b\":[1,2,3]},\"c\":\"x\"}"
|
|
cases.push(j1)
|
|
cases.push(".a.b[1]") // -> 2
|
|
cases.push(j1)
|
|
cases.push(".c") // -> "x"
|
|
cases.push(j1)
|
|
cases.push(".a") // -> {"b":[1,2,3]}
|
|
cases.push(j1)
|
|
cases.push(".a.b") // -> [1,2,3]
|
|
cases.push(j1)
|
|
cases.push(".a.b[10]") // -> null
|
|
cases.push(j1)
|
|
cases.push(".x") // -> null
|
|
cases.push(j1)
|
|
cases.push(".a.b[0]") // -> 1
|
|
|
|
// Case 2
|
|
local j2 = "[ {\"k\":\"v\"}, 10, null ]"
|
|
cases.push(j2)
|
|
cases.push("[0].k") // -> "v"
|
|
cases.push(j2)
|
|
cases.push("[1]") // -> 10
|
|
cases.push(j2)
|
|
cases.push("[2]") // -> null
|
|
cases.push(j2)
|
|
cases.push("[3]") // -> null (out of range)
|
|
|
|
local i = 0
|
|
loop(i < cases.length()) {
|
|
local json_text = cases.get(i)
|
|
local path = cases.get(i + 1)
|
|
// Parser-less path: slice JSON text directly for quick profile stability
|
|
local out_text = this.eval_path_text(json_text, path)
|
|
if out_text == null { print("null") } else { print(out_text) }
|
|
i = i + 2
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// Evaluate a simple JSON path by slicing JSON text directly (no full parse)
|
|
// Returns a JSON substring for the value or null if not found
|
|
eval_path_text(json_text, path) {
|
|
local cur_text = json_text
|
|
local i = 0
|
|
loop(i < path.length()) {
|
|
local ch = path.substring(i, i + 1)
|
|
if ch == "." {
|
|
// parse identifier
|
|
i = i + 1
|
|
local start = i
|
|
loop(i < path.length()) {
|
|
local c = path.substring(i, i + 1)
|
|
if this.is_alnum(c) or c == "_" { i = i + 1 } else { break }
|
|
}
|
|
local key = path.substring(start, i)
|
|
if key.length() == 0 { return null }
|
|
// Get value text directly; then reset window to that text
|
|
local next_text = this.object_get_text(cur_text, 0, cur_text.length(), key)
|
|
if next_text == null { return null }
|
|
cur_text = next_text
|
|
} else {
|
|
if ch == "[" {
|
|
// parse index
|
|
i = i + 1
|
|
local start = i
|
|
loop(i < path.length() and this.is_digit(path.substring(i, i + 1))) { i = i + 1 }
|
|
local idx_str = path.substring(start, i)
|
|
if i >= path.length() or path.substring(i, i + 1) != "]" { return null }
|
|
i = i + 1 // skip ']'
|
|
local idx = this.parse_int(idx_str)
|
|
local next_text = this.array_get_text(cur_text, 0, cur_text.length(), idx)
|
|
if next_text == null { return null }
|
|
cur_text = next_text
|
|
} else {
|
|
return null
|
|
}
|
|
}
|
|
}
|
|
return cur_text
|
|
}
|
|
|
|
// Local helpers (avoid external using in app)
|
|
is_digit(ch) {
|
|
return ch == "0" or ch == "1" or ch == "2" or ch == "3" or ch == "4" or ch == "5" or ch == "6" or ch == "7" or ch == "8" or ch == "9"
|
|
}
|
|
is_alpha(ch) {
|
|
return (ch >= "a" and ch <= "z") or (ch >= "A" and ch <= "Z")
|
|
}
|
|
is_alnum(ch) {
|
|
return this.is_alpha(ch) or this.is_digit(ch)
|
|
}
|
|
parse_int(s) {
|
|
local i = 0
|
|
local neg = false
|
|
if s.length() > 0 and s.substring(0,1) == "-" {
|
|
neg = true
|
|
i = 1
|
|
}
|
|
local acc = 0
|
|
loop(i < s.length()) {
|
|
local ch = s.substring(i, i + 1)
|
|
if not this.is_digit(ch) { break }
|
|
// ch to digit
|
|
// 0..9
|
|
if ch == "0" { acc = acc * 10 + 0 }
|
|
else { if ch == "1" { acc = acc * 10 + 1 }
|
|
else { if ch == "2" { acc = acc * 10 + 2 }
|
|
else { if ch == "3" { acc = acc * 10 + 3 }
|
|
else { if ch == "4" { acc = acc * 10 + 4 }
|
|
else { if ch == "5" { acc = acc * 10 + 5 }
|
|
else { if ch == "6" { acc = acc * 10 + 6 }
|
|
else { if ch == "7" { acc = acc * 10 + 7 }
|
|
else { if ch == "8" { acc = acc * 10 + 8 }
|
|
else { if ch == "9" { acc = acc * 10 + 9 } }}}}}}}}}
|
|
i = i + 1
|
|
}
|
|
if neg { return 0 - acc } else { return acc }
|
|
}
|
|
// --- Minimal JSON slicing helpers (object/array) ---
|
|
// Find a key's value span within an object JSON slice [start,end)
|
|
object_get_span(s, start, end, key) {
|
|
local i = start
|
|
if i < end and s.substring(i, i+1) == "{" { i = i + 1 } else { return null }
|
|
loop(i < end) {
|
|
i = this.skip_ws(s, i, end)
|
|
if i >= end { return null }
|
|
if s.substring(i, i+1) == "}" { return null }
|
|
if s.substring(i, i+1) != "\"" { return null }
|
|
local key_end = this.read_string_end(s, i, end)
|
|
if key_end == -1 { return null }
|
|
local key_text = s.substring(i+1, key_end-1)
|
|
i = key_end
|
|
i = this.skip_ws(s, i, end)
|
|
if i >= end or s.substring(i, i+1) != ":" { return null }
|
|
i = i + 1
|
|
i = this.skip_ws(s, i, end)
|
|
local vspan = this.read_value_span(s, i, end)
|
|
if vspan == null { return null }
|
|
if key_text == key { return vspan }
|
|
i = vspan.get(1)
|
|
i = this.skip_ws(s, i, end)
|
|
if i < end and s.substring(i, i+1) == "," {
|
|
i = i + 1
|
|
continue
|
|
} else {
|
|
return null
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
// Return the value text for a key within an object slice, or null
|
|
object_get_text(s, start, end, key) {
|
|
local sp = this.object_get_span(s, start, end, key)
|
|
if sp == null { return null }
|
|
// sp is ArrayBox [i, j]; re-scan without using .get to avoid VM instance calls
|
|
// Instead, rebuild by scanning again (small overhead, safer on current VM path)
|
|
// We locate the key again and then extract value via read_value_span
|
|
// Directly extracting indices from sp would require .get; so re-use scanner
|
|
// Start from beginning for simplicity
|
|
local i = start
|
|
if i < end and s.substring(i, i+1) == "{" { i = i + 1 } else { return null }
|
|
loop(i < end) {
|
|
i = this.skip_ws(s, i, end)
|
|
if i >= end { return null }
|
|
if s.substring(i, i+1) == "}" { return null }
|
|
if s.substring(i, i+1) != "\"" { return null }
|
|
local key_end = this.read_string_end(s, i, end)
|
|
if key_end == -1 { return null }
|
|
local key_text = s.substring(i+1, key_end-1)
|
|
i = key_end
|
|
i = this.skip_ws(s, i, end)
|
|
if i >= end or s.substring(i, i+1) != ":" { return null }
|
|
i = i + 1
|
|
i = this.skip_ws(s, i, end)
|
|
local vspan = this.read_value_span(s, i, end)
|
|
if vspan == null { return null }
|
|
if key_text == key { return s.substring(i, vspan.get(1)) }
|
|
i = vspan.get(1)
|
|
i = this.skip_ws(s, i, end)
|
|
if i < end and s.substring(i, i+1) == "," { i = i + 1 continue } else { return null }
|
|
}
|
|
return null
|
|
}
|
|
|
|
// Get the span of the idx-th element at top-level of an array slice [start,end)
|
|
array_get_span(s, start, end, idx) {
|
|
local i = start
|
|
if i < end and s.substring(i, i+1) == "[" {
|
|
i = i + 1
|
|
} else {
|
|
return null
|
|
}
|
|
local cur = 0
|
|
loop(i < end) {
|
|
i = this.skip_ws(s, i, end)
|
|
if i >= end { return null }
|
|
if s.substring(i, i+1) == "]" { return null }
|
|
local vspan = this.read_value_span(s, i, end)
|
|
if vspan == null { return null }
|
|
if cur == idx { return vspan }
|
|
i = vspan.get(1)
|
|
i = this.skip_ws(s, i, end)
|
|
if i < end and s.substring(i, i+1) == "," {
|
|
i = i + 1
|
|
cur = cur + 1
|
|
continue
|
|
} else {
|
|
return null
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
// Return the text of idx-th element within an array slice, or null
|
|
array_get_text(s, start, end, idx) {
|
|
local sp = this.array_get_span(s, start, end, idx)
|
|
if sp == null { return null }
|
|
// Re-scan to compute exact [i,j) and return substring without ArrayBox.get
|
|
local i = start
|
|
if i < end and s.substring(i, i+1) == "[" { i = i + 1 } else { return null }
|
|
local cur = 0
|
|
loop(i < end) {
|
|
i = this.skip_ws(s, i, end)
|
|
if i >= end { return null }
|
|
if s.substring(i, i+1) == "]" { return null }
|
|
local vspan = this.read_value_span(s, i, end)
|
|
if vspan == null { return null }
|
|
if cur == idx { return s.substring(i, vspan.get(1)) }
|
|
i = vspan.get(1)
|
|
i = this.skip_ws(s, i, end)
|
|
if i < end and s.substring(i, i+1) == "," { i = i + 1 cur = cur + 1 continue } else { return null }
|
|
}
|
|
return null
|
|
}
|
|
|
|
// Read a JSON value span starting at i; returns [start,end)
|
|
read_value_span(s, i, end) {
|
|
if i >= end { return null }
|
|
local ch = s.substring(i, i+1)
|
|
if ch == "\"" {
|
|
local j = this.read_string_end(s, i, end)
|
|
if j == -1 { return null } else {
|
|
local out = new ArrayBox()
|
|
out.push(i)
|
|
out.push(j)
|
|
return out
|
|
}
|
|
}
|
|
if ch == "{" {
|
|
local j = this.matching_brace(s, i, end, "{", "}")
|
|
if j == -1 { return null } else {
|
|
local out = new ArrayBox()
|
|
out.push(i)
|
|
out.push(j)
|
|
return out
|
|
}
|
|
}
|
|
if ch == "[" {
|
|
local j = this.matching_brace(s, i, end, "[", "]")
|
|
if j == -1 { return null } else {
|
|
local out = new ArrayBox()
|
|
out.push(i)
|
|
out.push(j)
|
|
return out
|
|
}
|
|
}
|
|
// number/bool/null: read until comma or closing
|
|
local j = i
|
|
loop(j < end) {
|
|
local c = s.substring(j, j+1)
|
|
if c == "," or c == "}" or c == "]" or this.is_ws_char(c) { break }
|
|
j = j + 1
|
|
}
|
|
local out = new ArrayBox()
|
|
out.push(i)
|
|
out.push(j)
|
|
return out
|
|
}
|
|
|
|
// Find end index (exclusive) of a JSON string literal starting at i ('"')
|
|
read_string_end(s, i, end) {
|
|
local j = i + 1
|
|
loop(j < end) {
|
|
local c = s.substring(j, j+1)
|
|
if c == "\\" {
|
|
j = j + 2
|
|
continue
|
|
}
|
|
if c == "\"" { return j + 1 }
|
|
j = j + 1
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// Match paired braces/brackets with simple string-awareness; returns end index (exclusive)
|
|
matching_brace(s, i, end, open, close) {
|
|
local depth = 0
|
|
local j = i
|
|
loop(j < end) {
|
|
local c = s.substring(j, j+1)
|
|
if c == "\"" {
|
|
j = this.read_string_end(s, j, end)
|
|
if j == -1 { return -1 }
|
|
continue
|
|
}
|
|
if c == open {
|
|
depth = depth + 1
|
|
} else {
|
|
if c == close {
|
|
depth = depth - 1
|
|
if depth == 0 { return j + 1 }
|
|
}
|
|
}
|
|
j = j + 1
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// Whitespace utilities
|
|
skip_ws(s, i, end) {
|
|
local j = i
|
|
loop(j < end and this.is_ws_char(s.substring(j, j+1))) { j = j + 1 }
|
|
return j
|
|
}
|
|
is_ws_char(ch) { return ch == " " or ch == "\t" or ch == "\n" or ch == "\r" }
|
|
// Note: normalization now lives in JsonNode (object_get/array_get)
|
|
}
|