Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / src / serialization / text_reader.lucb

from serialization.location import Location, capture
## Serialization text reader.
import memory
import strings
from luce_std import math
from animation import Sample, insert_sample
from model import DocumentData
from path import joined, parent_path, require_slot, valid_name
from serialization.lexer import Parser, tokenize
from serialization.type_names import TypeSpec, type_spec
from storage import Buffer, List, set_pair, text_copy
from types import DType, Interpolation, invalid, limit_exceeded, max_depth, max_items, unsupported
from value import ValueData, append_number, dtype_width, floating, value_header

pub func parse_leaf(parser: Parser*, value: ValueData*) -> !:
    let kind = parser.kind()
    let token = try parser.take()
    if value.kind == DType.string:
        if kind != 2:
            try Parser.fail("expected a string value")
        try value.payload.sized(token)
    elif value.kind == DType.character:
        if kind != 3:
            try Parser.fail("expected a byte character")
        try value.payload.byte(token.bytes[0])
    elif value.kind == DType.boolean:
        if kind != 1 or (token != "true" and token != "false"):
            try Parser.fail("expected a boolean")
        try value.payload.byte(1 if token == "true" else 0)
    elif floating(value.kind):
        if kind != 1:
            try Parser.fail("expected a number")
        var number = try strings.parse_f64(token)
        if not math.is_finite(number):
            number = 0.0
        try append_number(&value.payload, value.kind, number)
    elif value.kind == DType.int8 or value.kind == DType.int16 or value.kind == DType.int32 or value.kind == DType.int64:
        if kind != 1:
            try Parser.fail("expected an integer")
        let number = strings.parse_i64(token) else error(invalid, "invalid Prism signed integer")
        let width = dtype_width(value.kind)
        if width < 8:
            let maximum = ((i64)1 << (width * 8 - 1)) - 1
            if number < -maximum - 1 or number > maximum:
                try Parser.fail("signed integer exceeds its dtype")
        try value.payload.uint((u64)number, width)
    else:
        if kind != 1:
            try Parser.fail("expected an unsigned integer")
        let number = strings.parse_u64(token) else error(invalid, "invalid Prism unsigned integer")
        let width = dtype_width(value.kind)
        if width < 8 and number >= ((u64)1 << (width * 8)):
            try Parser.fail("unsigned integer exceeds its dtype")
        try value.payload.uint(number, width)

pub func parse_nested(parser: Parser*, value: ValueData*, depth: usize) -> !:
    try parser.expect("[")
    let count = (usize)value.shape.items[depth]
    for i in 0..<count:
        if depth + 1 == value.shape.count:
            try parse_leaf(parser, value)
        else:
            try parse_nested(parser, value, depth + 1)
        if i + 1 < count:
            try parser.expect(",")
        else:
            _ = try parser.accept(",")
    try parser.expect("]")

pub func parse_tuple(parser: Parser*, value: ValueData*, count: usize) -> !:
    try parser.expect("(")
    for i in 0..<count:
        try parse_leaf(parser, value)
        if i + 1 < count:
            try parser.expect(",")
        else:
            _ = try parser.accept(",")
    try parser.expect(")")

pub func parse_value(parser: Parser*, spec: const TypeSpec*) -> ValueData!:
    var value = try value_header(spec.kind, spec.shape.span())
    errdefer value.close()
    if spec.dynamic:
        try parser.expect("[")
        var count: u32 = 0
        while not parser.at("]"):
            if count >= (u32)max_items:
                error(limit_exceeded, "Prism dynamic array limit exceeded")
            if spec.tuple_width > 0:
                try parse_tuple(parser, &value, spec.tuple_width)
            else:
                try parse_leaf(parser, &value)
            count += 1
            if not (try parser.accept(",")):
                break
        try parser.expect("]")
        value.shape.items[0] = count
    elif spec.tuple_width > 0:
        try parse_tuple(parser, &value, spec.tuple_width)
    elif value.shape.count > 0:
        if value.count() > parser.remaining():
            error(invalid, "Prism shape exceeds remaining source bytes")
        try parse_nested(parser, &value, 0)
    else:
        try parse_leaf(parser, &value)
    return value

pub func parse_handles(parser: Parser*, values: List[f64]*) -> !:
    try parser.expect("[")
    while not parser.at("]"):
        let number = try strings.parse_f64(try parser.take())
        if not math.is_finite(number):
            try Parser.fail("non-finite handle")
        try values.push(number)
        if not (try parser.accept(",")):
            break
    try parser.expect("]")
    if values.count % 2 != 0:
        try Parser.fail("handles need time/value pairs")

## A property one element's block sets, by its name and whether it is the samples
## (`name.timeSamples`) or the value.
pub struct Assigned:
    pub var name: str
    pub var animated: bool

## A property set twice in one `def` or `over` block is refused at its second setting: the
## text would say two things and keep only one. A later block may set it again.
pub func parse_property(parser: Parser*, document: DocumentData*, path: str, assigned: List[Assigned]*) -> !:
    let start = parser.token_start
    let type_name = try parser.name()
    var spec = try type_spec(type_name)
    defer spec.close()
    if try parser.accept("["):
        if spec.label != "":
            try Parser.fail("catalog aliases have fixed shapes")
        if try parser.accept("]"):
            spec.dynamic = true
            var shape: List[u32]
            errdefer shape.close()
            try shape.push(0)
            for dimension in spec.shape.span():
                try shape.push(dimension)
            spec.shape.close()
            spec.shape = shape
        else:
            if spec.shape.count > 0:
                try Parser.fail("legacy aggregate already has a shape")
            while true:
                let dimension = strings.parse_u64(try parser.take()) else error(invalid, "invalid Prism dimension")
                if dimension > 4294967295 or spec.shape.count >= 16:
                    try Parser.fail("invalid Prism rank or dimension")
                try spec.shape.push((u32)dimension)
                if not (try parser.accept(",")):
                    break
            try parser.expect("]")
    let quoted_name = parser.kind() == 2
    var name = try parser.name()
    var animated = false
    if not quoted_name and strings.ends_with(name, ".timeSamples"):
        animated = true
        name = (str)name.bytes[..<name.length - 12]
    elif try parser.accept(".timeSamples"):
        animated = true
    for earlier in assigned.span():
        if earlier.name == name and earlier.animated == animated:
            parser.token_start = start
            try Parser.fail("a property is set twice in one element")
    try assigned.push(Assigned(name = name, animated = animated))
    try parser.expect("=")
    if not animated:
        let value = try parse_value(parser, &spec)
        try document.put_value(path, name, value, spec.label)
        return
    let element_index = try document.require(path)
    if document.elements.items[element_index].property(name) == none:
        var zero = try value_header(spec.kind, spec.shape.span())
        zero.payload.reserve(zero.count() * (4 if spec.kind == DType.string else dtype_width(spec.kind))) catch failure:
            zero.close()
            error(failure.code, failure.message)
        zero.payload.used = zero.count() * (4 if spec.kind == DType.string else dtype_width(spec.kind))
        memory.set(zero.payload.data[..<zero.payload.used], 0)
        if type_name == "matrix":
            memory.write[f32](&zero.payload.data[0], 1.0)
            memory.write[f32](&zero.payload.data[12], 1.0)
        try document.put_value(path, name, zero, spec.label)
    let prop_index = document.elements.items[element_index].property(name) else trap("Prism sample default missing")
    let prop = &document.elements.items[element_index].properties.items[prop_index]
    try parser.expect("{")
    while not parser.at("}"):
        var sample = Sample()
        errdefer sample.close()
        sample.time = try strings.parse_f64(try parser.take())
        if not math.is_finite(sample.time):
            try Parser.fail("non-finite keyframe time")
        try parser.expect(":")
        sample.value = try parse_value(parser, &spec)
        if try parser.accept("("):
            while not parser.at(")"):
                let key = try parser.name()
                try parser.expect("=")
                if key == "interp":
                    let mode = try parser.name()
                    if mode != "held" and mode != "linear" and mode != "bezier":
                        try Parser.fail("unknown interpolation")
                    sample.interpolation = Interpolation.held if mode == "held" else (Interpolation.linear if mode == "linear" else Interpolation.bezier)
                elif key == "handle":
                    let mode = try parser.name()
                    if mode != "auto" and mode != "vector" and mode != "aligned" and mode != "free":
                        try Parser.fail("unknown handle type")
                    sample.handle = 0 if mode == "auto" else (1 if mode == "vector" else (2 if mode == "aligned" else 3))
                elif key == "left":
                    try parse_handles(parser, &sample.left)
                elif key == "right":
                    try parse_handles(parser, &sample.right)
                else:
                    try Parser.fail("unknown keyframe option")
                if not (try parser.accept(",")):
                    break
            try parser.expect(")")
        try insert_sample(prop, sample)
        if not (try parser.accept(",")):
            break
    try parser.expect("}")

## One directive of the block at `path`; `assigned` holds the properties the block has set.
pub func parse_directive(parser: Parser*, document: DocumentData*, path: str, depth: usize, assigned: List[Assigned]*) -> !:
    if parser.kind() != 1:
        try Parser.fail("expected a directive or value type")
    let directive = parser.peek()
    if directive == "def" or directive == "over":
        if depth >= max_depth:
            error(limit_exceeded, "Prism element nesting limit exceeded")
        _ = try parser.take()
        var kind: str = ""
        var name: str = ""
        var named = false
        if parser.kind() == 2:
            let first = try parser.take()
            if parser.kind() == 2:
                kind = first
                name = try parser.take()
                named = true
            elif valid_name(first):
                name = first
                named = true
            else:
                kind = first
        elif not parser.at("{"):
            kind = try parser.name()
            if parser.kind() == 2:
                name = try parser.take()
                named = true
        var anonymous_name: u8[64]
        if not named:
            let count = document.child_count(path)
            name = try strings.format(anonymous_name, f"[{count}]")
        var child = try joined(path, name)
        defer child.close()
        try document.add(child.view(), kind, directive == "over")
        try parser.expect("{")
        var inside: List[Assigned]
        defer inside.close()
        while not parser.at("}"):
            try parse_directive(parser, document, child.view(), depth + 1, &inside)
        try parser.expect("}")
    elif directive == "delete" or directive == "disconnect":
        _ = try parser.take()
        let target = try parser.quoted()
        if directive == "delete":
            try document.mark_deleted(target)
        else:
            try document.mark_disconnected(target)
    elif directive == "reorder":
        _ = try parser.take()
        let parent = try parser.quoted()
        try parser.expect("=")
        try parser.expect("[")
        var children: List[str]
        defer children.close()
        while not parser.at("]"):
            try children.push(try parser.quoted())
            if not (try parser.accept(",")):
                break
        try parser.expect("]")
        try document.reorder(parent, children.span())
    elif directive == "connect":
        _ = try parser.take()
        var target: Buffer
        defer target.close()
        if parser.kind() == 4:
            target = try text_copy(try parser.path())
        else:
            target = try joined(path, try parser.name(), ".")
        try parser.expect("=")
        let source = try parser.path()
        try require_slot(source)
        if strings.find(target.view(), "*") != none or strings.find(target.view(), "?") != none:
            try document.connect_pattern(source, target.view())
        else:
            try require_slot(target.view())
            try set_pair(&document.connections, target.view(), source)
    elif directive == "string":
        _ = try parser.take()
        let key = try parser.name()
        try parser.expect("=")
        try document.set_metadata(path, key, try parser.quoted())
    elif directive == "reference":
        _ = try parser.take()
        try document.set_metadata(path, "reference", try parser.quoted())
        if parser.kind() == 2:
            try document.set_metadata(path, "referencePath", try parser.quoted())
    elif directive == "unset":
        _ = try parser.take()
        let metadata = try parser.accept("string")
        try document.mark_unset(path, try parser.name(), metadata)
    elif path == "/":
        try Parser.fail("expected a document directive")
    elif strings.ends_with(directive, ".connect"):
        let name = try parser.take()
        var target = try joined(path, (str)name.bytes[..<name.length - 8], ".")
        defer target.close()
        try parser.expect("=")
        let source = try parser.path()
        try require_slot(source)
        try require_slot(target.view())
        try set_pair(&document.connections, target.view(), source)
    else:
        try parse_property(parser, document, path, assigned)

pub func read_text(bytes: const u8[], document: DocumentData*, location: Location*? = none) -> !:
    let trimmed = strings.trim(try str(bytes))
    let end = strings.find(trimmed, "\n") else trimmed.length
    let header = strings.trim((str)trimmed.bytes[..<end])
    if header != "#prisma 1.0" and header != "#prisma 2.0" and header != "#prisma 3.0" and header != "#prisma 4.0":
        error(unsupported, "unsupported Prism text version")
    var parser = Parser(source = bytes)
    defer parser.close()
    errdefer capture(bytes, parser.token_start, location)
    try parser.advance()
    var top: List[Assigned]
    defer top.close()
    while parser.kind() != 0:
        try parse_directive(&parser, document, "/", 0, &top)