TermiNexus
2992674783
把此前未提交的 rowptr 迁移整体入库（42 文件，含 ast/llvmlite/hashlib/json/zlib 等签名 rowptr 化）。临时诊断（用后移除）：linkedlist.vp GSList[T].append 链完整性四检、__module.vp PrintModule Function.Params/param 指针野值护栏（[DBGCHAIN] 前缀 + fflush + exit）。
292 lines
7.2 KiB
Plaintext
292 lines
7.2 KiB
Plaintext
import t, c
|
|
from stdint import *
|
|
import memhub
|
|
import string
|
|
from . import (
|
|
JsonValue, JSON_NULL, JSON_BOOL, JSON_INT, JSON_FLOAT,
|
|
JSON_STRING, JSON_ARRAY, JSON_OBJECT,
|
|
null, bool_val, int_val, float_val, string_val, array, object,
|
|
)
|
|
|
|
|
|
class ParseState:
|
|
src: str
|
|
pos: t.CSizeT
|
|
len: t.CSizeT
|
|
pool: rowptr[memhub.MemManager]
|
|
|
|
def __init__(self, src: str, pool: rowptr[memhub.MemManager]):
|
|
self.src = src
|
|
self.pos = 0
|
|
self.len = string.strlen(src) if src != None else 0
|
|
self.pool = pool
|
|
|
|
|
|
def _peek(s: rowptr[ParseState]) -> t.CChar:
|
|
if s.pos >= s.len:
|
|
return '\0'
|
|
return s.src[s.pos]
|
|
|
|
def _advance(s: rowptr[ParseState]) -> t.CChar:
|
|
if s.pos >= s.len:
|
|
return '\0'
|
|
ch: t.CChar = s.src[s.pos]
|
|
s.pos += 1
|
|
return ch
|
|
|
|
def _skip_whitespace(s: rowptr[ParseState]):
|
|
while s.pos < s.len:
|
|
ch: t.CChar = s.src[s.pos]
|
|
if ch == ' ' or ch == '\t' or ch == '\n' or ch == '\r':
|
|
s.pos += 1
|
|
else:
|
|
break
|
|
|
|
def _expect(s: rowptr[ParseState], ch: t.CChar) -> bool:
|
|
_skip_whitespace(s)
|
|
if s.pos >= s.len:
|
|
return False
|
|
if s.src[s.pos] != ch:
|
|
return False
|
|
s.pos += 1
|
|
return True
|
|
|
|
|
|
def _parse_string(s: rowptr[ParseState]) -> str:
|
|
if _peek(s) != '"':
|
|
return None
|
|
_advance(s)
|
|
|
|
start: t.CSizeT = s.pos
|
|
slen: t.CSizeT = 0
|
|
while s.pos < s.len:
|
|
ch: t.CChar = s.src[s.pos]
|
|
if ch == '"':
|
|
break
|
|
if ch == '\\':
|
|
s.pos += 1
|
|
slen += 1
|
|
slen += 1
|
|
s.pos += 1
|
|
|
|
buf: str = s.pool.alloc(slen + 1)
|
|
if buf == None:
|
|
return None
|
|
|
|
s.pos = start
|
|
di: t.CSizeT = 0
|
|
while s.pos < s.len:
|
|
ch: t.CChar = s.src[s.pos]
|
|
if ch == '"':
|
|
s.pos += 1
|
|
break
|
|
if ch == '\\':
|
|
s.pos += 1
|
|
if s.pos < s.len:
|
|
esc: t.CChar = s.src[s.pos]
|
|
if esc == 'n':
|
|
buf[di] = '\n'
|
|
elif esc == 't':
|
|
buf[di] = '\t'
|
|
elif esc == 'r':
|
|
buf[di] = '\r'
|
|
elif esc == '\\':
|
|
buf[di] = '\\'
|
|
elif esc == '"':
|
|
buf[di] = '"'
|
|
elif esc == '/':
|
|
buf[di] = '/'
|
|
else:
|
|
buf[di] = esc
|
|
di += 1
|
|
s.pos += 1
|
|
continue
|
|
buf[di] = ch
|
|
di += 1
|
|
s.pos += 1
|
|
|
|
buf[di] = '\0'
|
|
return buf
|
|
|
|
|
|
def _parse_number(s: rowptr[ParseState]) -> rowptr[JsonValue]:
|
|
_skip_whitespace(s)
|
|
is_float: bool = False
|
|
start: t.CSizeT = s.pos
|
|
|
|
if s.pos < s.len and s.src[s.pos] == '-':
|
|
s.pos += 1
|
|
|
|
while s.pos < s.len:
|
|
ch: t.CChar = s.src[s.pos]
|
|
if ch >= '0' and ch <= '9':
|
|
s.pos += 1
|
|
else:
|
|
break
|
|
|
|
if s.pos < s.len and s.src[s.pos] == '.':
|
|
is_float = True
|
|
s.pos += 1
|
|
while s.pos < s.len:
|
|
ch: t.CChar = s.src[s.pos]
|
|
if ch >= '0' and ch <= '9':
|
|
s.pos += 1
|
|
else:
|
|
break
|
|
|
|
if s.pos < s.len and (s.src[s.pos] == 'e' or s.src[s.pos] == 'E'):
|
|
is_float = True
|
|
s.pos += 1
|
|
if s.pos < s.len and (s.src[s.pos] == '+' or s.src[s.pos] == '-'):
|
|
s.pos += 1
|
|
while s.pos < s.len:
|
|
ch: t.CChar = s.src[s.pos]
|
|
if ch >= '0' and ch <= '9':
|
|
s.pos += 1
|
|
else:
|
|
break
|
|
|
|
num_len: t.CSizeT = s.pos - start
|
|
buf: str = s.pool.alloc(num_len + 1)
|
|
if buf == None:
|
|
return null(s.pool)
|
|
|
|
i: t.CSizeT = 0
|
|
while i < num_len:
|
|
buf[i] = s.src[start + i]
|
|
i += 1
|
|
buf[num_len] = '\0'
|
|
|
|
if is_float:
|
|
val: double = string.atof(buf)
|
|
return float_val(s.pool, val)
|
|
else:
|
|
ival: int64 = string.atoll(buf)
|
|
return int_val(s.pool, ival)
|
|
|
|
|
|
def _parse_value(s: rowptr[ParseState]) -> rowptr[JsonValue]:
|
|
_skip_whitespace(s)
|
|
if s.pos >= s.len:
|
|
return null(s.pool)
|
|
|
|
ch: t.CChar = _peek(s)
|
|
|
|
if ch == '"':
|
|
sv: str = _parse_string(s)
|
|
return string_val(s.pool, sv)
|
|
|
|
if ch == '{':
|
|
return _parse_object(s)
|
|
|
|
if ch == '[':
|
|
return _parse_array(s)
|
|
|
|
if ch == '-' or (ch >= '0' and ch <= '9'):
|
|
return _parse_number(s)
|
|
|
|
if ch == 't':
|
|
if s.pos + 3 < s.len:
|
|
if s.src[s.pos + 1] == 'r' and s.src[s.pos + 2] == 'u' and s.src[s.pos + 3] == 'e':
|
|
s.pos += 4
|
|
return bool_val(s.pool, True)
|
|
return null(s.pool)
|
|
|
|
if ch == 'f':
|
|
if s.pos + 4 < s.len:
|
|
if s.src[s.pos + 1] == 'a' and s.src[s.pos + 2] == 'l' and s.src[s.pos + 3] == 's' and s.src[s.pos + 4] == 'e':
|
|
s.pos += 5
|
|
return bool_val(s.pool, False)
|
|
return null(s.pool)
|
|
|
|
if ch == 'n':
|
|
if s.pos + 3 < s.len:
|
|
if s.src[s.pos + 1] == 'u' and s.src[s.pos + 2] == 'l' and s.src[s.pos + 3] == 'l':
|
|
s.pos += 4
|
|
return null(s.pool)
|
|
return null(s.pool)
|
|
|
|
return null(s.pool)
|
|
|
|
|
|
def _parse_array(s: rowptr[ParseState]) -> rowptr[JsonValue]:
|
|
if not _expect(s, '['):
|
|
return null(s.pool)
|
|
|
|
arr: rowptr[JsonValue] = array(s.pool)
|
|
|
|
_skip_whitespace(s)
|
|
if s.pos < s.len and _peek(s) == ']':
|
|
_advance(s)
|
|
return arr
|
|
|
|
item: rowptr[JsonValue] = _parse_value(s)
|
|
arr._append_child(item)
|
|
|
|
while True:
|
|
_skip_whitespace(s)
|
|
if s.pos >= s.len:
|
|
break
|
|
if _peek(s) != ',':
|
|
break
|
|
_advance(s)
|
|
item = _parse_value(s)
|
|
arr._append_child(item)
|
|
|
|
_expect(s, ']')
|
|
return arr
|
|
|
|
|
|
def _parse_object(s: rowptr[ParseState]) -> rowptr[JsonValue]:
|
|
if not _expect(s, '{'):
|
|
return null(s.pool)
|
|
|
|
obj: rowptr[JsonValue] = object(s.pool)
|
|
|
|
_skip_whitespace(s)
|
|
if s.pos < s.len and _peek(s) == '}':
|
|
_advance(s)
|
|
return obj
|
|
|
|
_skip_whitespace(s)
|
|
key: str = _parse_string(s)
|
|
_expect(s, ':')
|
|
val: rowptr[JsonValue] = _parse_value(s)
|
|
if key != None and val != None:
|
|
klen: t.CSizeT = string.strlen(key)
|
|
kbuf: str = s.pool.alloc(klen + 1)
|
|
if kbuf != None:
|
|
string.memcpy(kbuf, key, klen + 1)
|
|
val.key = kbuf
|
|
obj._append_child(val)
|
|
|
|
while True:
|
|
_skip_whitespace(s)
|
|
if s.pos >= s.len:
|
|
break
|
|
if _peek(s) != ',':
|
|
break
|
|
_advance(s)
|
|
_skip_whitespace(s)
|
|
key = _parse_string(s)
|
|
_expect(s, ':')
|
|
val = _parse_value(s)
|
|
if key != None and val != None:
|
|
klen2: t.CSizeT = string.strlen(key)
|
|
kbuf2: str = s.pool.alloc(klen2 + 1)
|
|
if kbuf2 != None:
|
|
string.memcpy(kbuf2, key, klen2 + 1)
|
|
val.key = kbuf2
|
|
obj._append_child(val)
|
|
|
|
_expect(s, '}')
|
|
return obj
|
|
|
|
|
|
def parse(pool: rowptr[memhub.MemManager], src: str) -> rowptr[JsonValue]:
|
|
"""解析 JSON 字符串，返回 JsonValue 树"""
|
|
if src == None:
|
|
return null(pool)
|
|
s: rowptr[ParseState] = ParseState(src, pool)
|
|
return _parse_value(s)
|