Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-exr

Source of release 0.6.1

0.6.1 / src / manifest.lucb

## Bounded, strict JSON object parser for Cryptomatte manifests.
import memory
import strings
from luce_std import utf8
import crypto_hash as hashing
from luce_raster.binary import Reader, Buffer
from luce_raster.errors import corrupt, invalid, limit

pub struct Entry:
    pub var name: str
    pub var bits: u32
    var next: usize

pub struct Manifest:
    pub var entries: Entry[]
    pub var count: usize
    var buckets: usize[]

    pub func find(name: str) -> usize?:
        if self.buckets.length == 0:
            return none
        var index = self.buckets[(usize)(hashing.murmur(name) & 65535)]
        while index > 0:
            let entry = self.entries[index - 1]
            if entry.name == name:
                return index - 1
            index = entry.next
        return none

    pub func add(name: str, bits: u32) -> !:
        if self.find(name) != none:
            error(invalid, "duplicate manifest name")
        if self.count >= 1048576 or name.length > 1048576 or not utf8.valid(name.bytes):
            error(limit, "manifest name, encoding or entry count exceeds limits")
        with memory.heap:
            if self.buckets.length == 0:
                self.buckets = try new usize[65536]
            if self.count == self.entries.length:
                let grown = try new Entry[64 if self.count == 0 else self.count * 2]
                for i in 0..<self.count:
                    grown[i] = self.entries[i]
                if self.entries.length > 0:
                    free(self.entries)
                self.entries = grown
            let copied = try strings.copy(name)
            let bucket = (usize)(hashing.murmur(name) & 65535)
            self.entries[self.count] = Entry(copied, bits, self.buckets[bucket])
            self.count += 1
            self.buckets[bucket] = self.count

    pub func ensure(name: str) -> u32!:
        if let index = self.find(name):
            return self.entries[index].bits
        let bits = hashing.murmur(name)
        try self.add(name, bits)
        return bits

    pub func resolve(name: str) -> u32:
        if let index = self.find(name):
            return hashing.safe_bits(self.entries[index].bits)
        return hashing.safe_bits(hashing.murmur(name))

    pub func name_for(bits: u32) -> str:
        for i in 0..<self.count:
            if hashing.safe_bits(self.entries[i].bits) == bits:
                return self.entries[i].name
        return ""

    pub func parse(text: str) -> !:
        if self.count != 0 or text.length > 67108864:
            error(invalid, "manifest parser requires empty storage and at most 64 MiB")
        var r = Reader(data = text.bytes)
        skip(&r)
        if try r.byte() != '{':
            error(corrupt, "manifest must be a JSON object")
        skip(&r)
        if r.position < r.data.length and r.data[r.position] == '}':
            r.position += 1
        else:
            while true:
                var name = Buffer(maximum = 1048576)
                defer name.close()
                try string(&r, &name)
                skip(&r)
                if try r.byte() != ':':
                    error(corrupt, "manifest member has no colon")
                skip(&r)
                var value = Buffer(maximum = 32)
                defer value.close()
                try string(&r, &value)
                if value.used != 8:
                    error(corrupt, "manifest ID must have eight hex digits")
                var bits: u32 = 0
                for byte in value.view():
                    bits = (bits << 4) | (try hex_digit(byte))
                try self.add((str)name.view(), bits)
                skip(&r)
                let next = try r.byte()
                if next == '}':
                    break
                if next != ',':
                    error(corrupt, "manifest member separator invalid")
                skip(&r)
        skip(&r)
        if r.position != r.data.length:
            error(corrupt, "trailing data after manifest")

    pub func encode(output: Buffer*) -> !:
        try output.byte('{')
        for i in 0..<self.count:
            if i > 0:
                try output.byte(',')
            try quote(self.entries[i].name, output)
            try output.byte(':')
            var digits_buffer: u8[8]
            try quote(hashing.hexadecimal(self.entries[i].bits, digits_buffer), output)
        try output.byte('}')

    pub func close():
        with memory.heap:
            for i in 0..<self.count:
                strings.release(self.entries[i].name)
            if self.entries.length > 0:
                free(self.entries)
            if self.buckets.length > 0:
                free(self.buckets)
        self = Manifest()

func skip(r: Reader*):
    while r.position < r.data.length:
        let b = r.data[r.position]
        if b != ' ' and b != '\t' and b != '\n' and b != '\r':
            return
        r.position += 1

func hex_digit(byte: u8) -> u32!:
    if byte >= '0' and byte <= '9':
        return (u32)(byte - '0')
    if byte >= 'a' and byte <= 'f':
        return (u32)(byte - 'a') + 10
    if byte >= 'A' and byte <= 'F':
        return (u32)(byte - 'A') + 10
    error(corrupt, "invalid manifest hexadecimal digit")

func hex4(r: Reader*) -> u32!:
    var value: u32 = 0
    for i in 0..<4:
        value = (value << 4) | (try hex_digit(try r.byte()))
    return value

func string(r: Reader*, out: Buffer*) -> !:
    if try r.byte() != '"':
        error(corrupt, "manifest member must be a JSON string")
    while true:
        let b = try r.byte()
        if b == '"':
            break
        if b < 32:
            error(corrupt, "unescaped control character in JSON string")
        if b != '\\':
            try out.byte(b)
            continue
        let escaped = try r.byte()
        if escaped == 'u':
            var scalar = try hex4(r)
            if scalar >= 55296 and scalar <= 56319:
                if try r.byte() != '\\' or try r.byte() != 'u':
                    error(corrupt, "JSON high surrogate has no low surrogate")
                let low = try hex4(r)
                if low < 56320 or low > 57343:
                    error(corrupt, "invalid JSON low surrogate")
                scalar = 65536 + ((scalar - 55296) << 10) + low - 56320
            var encoded: u8[4]
            let count = utf8.encode(scalar, encoded) else error(corrupt, "invalid Unicode scalar in manifest")
            try out.put(encoded[..<count])
        elif escaped == '"' or escaped == '\\' or escaped == '/':
            try out.byte(escaped)
        elif escaped == 'b' or escaped == 'f' or escaped == 'n' or escaped == 'r' or escaped == 't':
            try out.byte(8 if escaped == 'b' else 12 if escaped == 'f' else 10 if escaped == 'n' else 13 if escaped == 'r' else 9)
        else:
            error(corrupt, "invalid JSON escape")
    if not utf8.valid(out.view()):
        error(corrupt, "manifest string is not UTF-8")

func quote(text: str, output: Buffer*) -> !:
    try output.byte('"')
    let digits = "0123456789abcdef"
    for b in text.bytes:
        if b == '"' or b == '\\':
            try output.byte('\\')
            try output.byte(b)
        elif b < 32:
            try output.text("\\u00")
            try output.byte(digits.bytes[b >> 4])
            try output.byte(digits.bytes[b & 15])
        else:
            try output.byte(b)
    try output.byte('"')