Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / src / codecs / json_tree.lucb

## Insertion-ordered JSON syntax tree. One arena owns nodes; indices survive growth.
import strings
from luce_std import math
from storage import Buffer, List
from types import invalid, limit_exceeded
from codecs.common import utf8

pub enum Kind as u8:
    null = 0
    boolean = 1
    number = 2
    string = 3
    array = 4
    object = 5

pub struct Entry:
    pub var key: Buffer
    pub var node: usize

pub struct Node:
    pub var kind: Kind
    pub var text: Buffer
    pub var number: f64
    pub var boolean: bool
    pub var children: List[Entry]

    pub func close():
        self.text.close()
        for i in 0..<self.children.count:
            self.children.items[i].key.close()
        self.children.close()

pub struct Tree:
    pub var nodes: List[Node]

    pub func close():
        for i in 0..<self.nodes.count:
            self.nodes.items[i].close()
        self.nodes.close()

struct Parser:
    var text: str
    var pos: usize
    var tree: Tree

    func space():
        while self.pos < self.text.length:
            let c = self.text.bytes[self.pos]
            if c != ' ' and c != '\t' and c != '\n' and c != '\r':
                return
            self.pos += 1

    func take(byte: u8) -> bool:
        self.space()
        if self.pos < self.text.length and self.text.bytes[self.pos] == byte:
            self.pos += 1
            return true
        return false

    func expect(byte: u8) -> !:
        if not self.take(byte):
            error(invalid, "malformed JSON delimiter")

    func hex4() -> u32!:
        if self.text.length - self.pos < 4:
            error(invalid, "truncated JSON Unicode escape")
        var output: u32 = 0
        for i in 0..<4:
            let c = self.text.bytes[self.pos]
            self.pos += 1
            var digit: u32 = 16
            if c >= '0' and c <= '9':
                digit = (u32)(c - '0')
            elif c >= 'a' and c <= 'f':
                digit = (u32)(c - 'a' + 10)
            elif c >= 'A' and c <= 'F':
                digit = (u32)(c - 'A' + 10)
            if digit == 16:
                error(invalid, "invalid JSON Unicode escape")
            output = output * 16 + digit
        return output

    func string() -> Buffer!:
        try self.expect('"')
        var output: Buffer
        errdefer output.close()
        while self.pos < self.text.length:
            let c = self.text.bytes[self.pos]
            self.pos += 1
            if c == '"':
                _ = try str(output.bytes())
                return output
            if c == '\\':
                if self.pos == self.text.length:
                    error(invalid, "truncated JSON escape")
                let escape = self.text.bytes[self.pos]
                self.pos += 1
                if escape == '"' or escape == '\\' or escape == '/':
                    try output.byte(escape)
                elif escape == 'n':
                    try output.byte('\n')
                elif escape == 'r':
                    try output.byte('\r')
                elif escape == 't':
                    try output.byte('\t')
                elif escape == 'b':
                    try output.byte(8)
                elif escape == 'f':
                    try output.byte(12)
                elif escape == 'u':
                    var cp = try self.hex4()
                    if cp >= 55296 and cp <= 56319:
                        if self.text.length - self.pos < 6 or self.text.bytes[self.pos] != '\\' or self.text.bytes[self.pos + 1] != 'u':
                            error(invalid, "unpaired JSON high surrogate")
                        self.pos += 2
                        let low = try self.hex4()
                        if low < 56320 or low > 57343:
                            error(invalid, "invalid JSON surrogate pair")
                        cp = 65536 + ((cp - 55296) << 10) + low - 56320
                    try utf8(&output, cp)
                else:
                    error(invalid, "unknown JSON string escape")
            else:
                # The legacy parser preserves literal controls inside strings.
                try output.byte(c)
        error(invalid, "unterminated JSON string")

    func literal(text: str) -> bool:
        if self.text.length - self.pos < text.length:
            return false
        if (str)self.text.bytes[self.pos..<self.pos + text.length] != text:
            return false
        self.pos += text.length
        return true

    func value(depth: usize) -> usize!:
        if depth > 200:
            error(limit_exceeded, "JSON nesting exceeds 200")
        self.space()
        if self.pos == self.text.length:
            error(invalid, "missing JSON value")
        let index = self.tree.nodes.count
        try self.tree.nodes.push(Node())
        let c = self.text.bytes[self.pos]
        if c == '{' or c == '[':
            self.tree.nodes.items[index].kind = Kind.object if c == '{' else Kind.array
            self.pos += 1
            let end: u8 = '}' if c == '{' else ']'
            if self.take(end):
                return index
            while true:
                var key: Buffer
                defer key.close()
                if c == '{':
                    key = try self.string()
                    try self.expect(':')
                let child = try self.value(depth + 1)
                let node = &self.tree.nodes.items[index]
                var existing: usize? = none
                if c == '{':
                    for i in 0..<node.children.count:
                        if node.children.items[i].key.view() == key.view():
                            existing = i
                            break
                if let position = existing:
                    node.children.items[position].node = child
                else:
                    try node.children.push(Entry(key = key, node = child))
                    key = Buffer()
                if self.take(end):
                    return index
                try self.expect(',')
        elif c == '"':
            self.tree.nodes.items[index].kind = Kind.string
            self.tree.nodes.items[index].text = try self.string()
        elif c == '-' or (c >= '0' and c <= '9'):
            let start = self.pos
            if c == '-':
                self.pos += 1
            var digits = false
            while self.pos < self.text.length and self.text.bytes[self.pos] >= '0' and self.text.bytes[self.pos] <= '9':
                digits = true
                self.pos += 1
            if self.pos < self.text.length and self.text.bytes[self.pos] == '.':
                self.pos += 1
                while self.pos < self.text.length and self.text.bytes[self.pos] >= '0' and self.text.bytes[self.pos] <= '9':
                    digits = true
                    self.pos += 1
            if not digits:
                error(invalid, "missing JSON number digits")
            if self.pos < self.text.length and (self.text.bytes[self.pos] == 'e' or self.text.bytes[self.pos] == 'E'):
                self.pos += 1
                if self.pos < self.text.length and (self.text.bytes[self.pos] == '+' or self.text.bytes[self.pos] == '-'):
                    self.pos += 1
                let exponent = self.pos
                while self.pos < self.text.length and self.text.bytes[self.pos] >= '0' and self.text.bytes[self.pos] <= '9':
                    self.pos += 1
                if exponent == self.pos:
                    error(invalid, "missing JSON exponent digits")
            self.tree.nodes.items[index].kind = Kind.number
            self.tree.nodes.items[index].number = try strings.parse_f64((str)self.text.bytes[start..<self.pos])
        elif self.literal("true"):
            self.tree.nodes.items[index].kind = Kind.boolean
            self.tree.nodes.items[index].boolean = true
        elif self.literal("false"):
            self.tree.nodes.items[index].kind = Kind.boolean
        elif not self.literal("null"):
            error(invalid, "invalid JSON value")
        return index

pub func parse(text: str) -> Tree!:
    var parser = Parser(text = text)
    errdefer parser.tree.close()
    _ = try parser.value(0)
    parser.space()
    if parser.pos != text.length:
        error(invalid, "trailing JSON input")
    return parser.tree

pub func quote(output: Buffer*, text: str) -> !:
    try output.byte('"')
    for byte in text.bytes:
        if byte == '"' or byte == '\\':
            try output.byte('\\')
            try output.byte(byte)
        elif byte == '\n':
            try output.text("\\n")
        elif byte == '\r':
            try output.text("\\r")
        elif byte == '\t':
            try output.text("\\t")
        elif byte == 8:
            try output.text("\\b")
        elif byte == 12:
            try output.text("\\f")
        elif byte < 32:
            try output.text("\\u00")
            try output.byte("0123456789abcdef".bytes[(usize)(byte >> 4)])
            try output.byte("0123456789abcdef".bytes[(usize)(byte & 15)])
        else:
            try output.byte(byte)
    try output.byte('"')

pub func number(output: Buffer*, value: f64) -> !:
    var scratch: u8[64]
    if not math.is_finite(value):
        try output.byte('0')
    elif value == math.floor(value) and math.abs(value) < 1000000000000000.0:
        let integer = (i64)value
        try output.text(try strings.format(scratch, f"{integer}"))
    else:
        try output.text(try strings.format_f64(value, scratch))