Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / src / serialization / package.lucb

## Serialization package.
from model import DocumentData
from path import require_element, valid_path, element_path
from serialization.binary import read_binary, write_binary
from serialization.encoding import detect
from serialization.text_reader import read_text
from serialization.text_writer import write_text
from storage import Buffer, List, Reader
from types import Encoding, invalid, limit_exceeded, unsupported

pub struct Entry:
    pub var name: str
    pub var mime: str
    pub var kind: u8
    pub var offset: usize
    pub var size: usize

pub func write_package(document: const DocumentData*, compressed: bool, text_scene: bool = false) -> Buffer!:
    var scene = try write_text(document) if text_scene else try write_binary(document, compressed)
    defer scene.close()
    var header_size: usize = 14 + 25 + 5
    for asset in document.assets.span():
        let extra = 25 + asset.path.used + asset.mime.used
        header_size = header_size +? extra else error(limit_exceeded, "Prism package TOC overflow")
    var output: Buffer
    errdefer output.close()
    try output.text("PRSMZ\0")
    try output.uint(4, 2)
    try output.uint(0, 2)
    try output.uint((u64)(document.assets.count + 1), 4)
    var offset = header_size
    for asset in document.assets.span():
        try output.sized(asset.path.view())
        try output.byte(2)
        try output.sized(asset.mime.view())
        try output.uint((u64)offset, 8)
        try output.uint((u64)asset.bytes.used, 8)
        offset = offset +? asset.bytes.used else error(limit_exceeded, "Prism package size overflow")
    try output.sized("scene")
    try output.byte(0 if text_scene else 1)
    try output.sized("")
    try output.uint((u64)offset, 8)
    try output.uint((u64)scene.used, 8)
    for asset in document.assets.span():
        try output.put(asset.bytes.bytes())
    try output.put(scene.bytes())
    return output

pub func read_package(bytes: const u8[], document: DocumentData*) -> !:
    var reader = Reader(data = bytes, pos = 6)
    if try reader.uint(2) != 4:
        error(unsupported, "only Prism v4 packages are supported")
    if try reader.uint(2) != 0:
        error(unsupported, "unknown Prism package flags")
    let count = try reader.count(25)
    var entries: List[Entry]
    defer entries.close()
    var scene: usize? = none
    for i in 0..<count:
        let name = try reader.text()
        let kind = (u8)try reader.uint(1)
        let mime = try reader.text()
        let offset = try reader.uint(8)
        let size = try reader.uint(8)
        if offset > (u64)bytes.length or size > (u64)bytes.length - offset:
            error(invalid, "Prism package blob is outside its input")
        if kind > 2:
            error(unsupported, "unknown Prism package entry kind")
        for entry in entries.span():
            if entry.name == name:
                error(invalid, "duplicate Prism package entry name")
        if kind < 2:
            if scene != none or name != "scene" or mime != "":
                error(invalid, "Prism package must contain one named scene")
            scene = i
        else:
            if not valid_path(name) or element_path(name) != name:
                error(invalid, "invalid Prism asset path")
        try entries.push(Entry(name = name, kind = kind, mime = mime, offset = (usize)offset, size = (usize)size))
    for i in 0..<entries.count:
        let a = entries.items[i]
        if a.offset < reader.pos:
            error(invalid, "Prism package blob overlaps its table")
        for j in 0..<i:
            let b = entries.items[j]
            if a.size > 0 and b.size > 0 and a.offset < b.offset + b.size and b.offset < a.offset + a.size:
                error(invalid, "overlapping Prism package blobs")
    let index = scene else error(invalid, "Prism package has no scene")
    let entry = entries.items[index]
    let payload = bytes[entry.offset..<entry.offset + entry.size]
    let encoding = detect(payload)
    if encoding != (Encoding.text if entry.kind == 0 else Encoding.binary):
        error(invalid, "Prism scene kind does not match its magic")
    # No recursive package scenes: depth and asset ownership stay unambiguous.
    if encoding == Encoding.text:
        try read_text(payload, document)
    else:
        try read_binary(payload, document)
    for asset in entries.span():
        if asset.kind == 2:
            try document.set_asset(asset.name, bytes[asset.offset..<asset.offset + asset.size], asset.mime)