Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / src / codecs / diagnostics.lucb

## Located parse results preserve failures as data for editors and import dialogs.
import interop
import memory
import codecs.api as codecs
from serialization.encoding import detect
from serialization.text_reader import read_text
from serialization.location import Location
from document import Document, own_document
from model import DocumentData
from storage import Buffer, text_copy
from types import Encoding, invalid, max_bytes, limit_exceeded

pub struct DecodeResult:
    var data: DocumentData
    var parsed: bool
    var location: Location = Location()
    var message: Buffer

    pub func init():
        return

    pub func ok() -> bool:
        return self.parsed

    pub func line() -> usize:
        return 0 if self.parsed else self.location.line

    pub func column() -> usize:
        return 0 if self.parsed else self.location.column

    pub func error_message() -> str:
        return self.message.view()

    pub func document() -> interop.Reference[Document]!:
        if not self.parsed:
            error(invalid, "Prism decode failed; inspect the located diagnosis")
        return try own_document(try self.data.copy())

    func decode(bytes: const u8[], codec: codecs.Codec) -> !:
        self.location = Location(line = 1, column = 1)
        if bytes.length > max_bytes:
            error(limit_exceeded, "Prism input exceeds the byte limit")
        if (codec == codecs.Codec.auto or codec == codecs.Codec.prisma or codec == codecs.Codec.prism) and detect(bytes) == Encoding.text:
            try read_text(bytes, &self.data, &self.location)
        else:
            let decoded = try codecs.decode(bytes, codec)
            defer decoded.release()
            self.data = try (try decoded.get()).view_data().copy()
        self.parsed = true

    pub func close():
        self.data.close()
        self.message.close()

pub let decode_result_type = interop.Type[DecodeResult]("Prism decode result", DecodeResult.close, closeable = true)

pub func decode_diagnosed(bytes: const u8[], codec: codecs.Codec = codecs.Codec.auto) -> interop.Reference[DecodeResult]!:
    var result = DecodeResult()
    errdefer result.close()
    result.decode(bytes, codec) catch failure:
        if failure.code == memory.exhausted:
            error(failure.code, failure.message)
        result.data.close()
        result.data = DocumentData()
        result.message = try text_copy(failure.message)
    let owned = try new DecodeResult() in memory.heap
    owned[0] = result
    result = DecodeResult()
    return try interop.Reference[DecodeResult].adopt(owned, decode_result_type, memory.heap)