Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-compress

Source of release 0.9.0

0.9.0 / src / binary.lucb

import memory

pub let invalid: ErrorCode = ErrorCode.package(1)
pub let corrupt: ErrorCode = ErrorCode.package(2)
pub let limit: ErrorCode = ErrorCode.package(3)
pub let unsupported: ErrorCode = ErrorCode.package(4)
pub let closed: ErrorCode = ErrorCode.package(5)
## A named entry is not in the archive (zip).
pub let missing: ErrorCode = ErrorCode.package(6)
pub let maximum: usize = 1073741824

pub func checked_limit(value: i64) -> usize!:
    if value < 0 or value > (i64)maximum: error(invalid, "byte limit must be in 0-1073741824")
    return (usize)value

pub struct Reader:
    pub var data: const u8[]
    pub var position: usize
    pub var little: bool = true

    pub func take(count: usize) -> const u8[]!:
        if self.position > self.data.length or count > self.data.length - self.position:
            error(corrupt, "truncated compressed data")
        if count == 0: return b""
        let start = self.position
        self.position += count
        return self.data[start..<self.position]

    pub func byte() -> u8!:
        let data = try self.take(1)
        return data[0]

    pub func uint(count: usize) -> u64!:
        if count > 8: error(invalid, "integer field exceeds eight bytes")
        let data = try self.take(count)
        var result: u64
        for i in 0..<count:
            let index = count - 1 - i if self.little else i
            result = (result << 8) | (u64)data[index]
        return result

pub struct Buffer:
    pub var data: u8[]
    pub var used: usize
    pub var maximum: usize = 67108864

    pub func reserve(count: usize) -> !:
        if count > self.maximum or self.used > self.maximum - count:
            error(limit, "compressed or expanded byte limit exceeded")
        let needed = self.used + count
        if needed <= self.data.length: return
        var capacity: usize = self.data.length if self.data.length > 0 else 256
        if capacity > self.maximum: capacity = self.maximum
        while capacity < needed:
            capacity = self.maximum if capacity > self.maximum // 2 else capacity * 2
        let next = try new u8[capacity] --- in memory.heap
        if self.used > 0: memory.copy(next, self.data, self.used)
        if self.data.length > 0: free(self.data) in memory.heap
        self.data = next

    pub func put(data: const u8[]) -> !:
        if data.length == 0: return
        try self.reserve(data.length)
        memory.copy(self.data[self.used..], data, data.length)
        self.used += data.length

    pub func byte(value: u8) -> !:
        try self.reserve(1)
        self.data[self.used] = value
        self.used += 1

    pub func uint(value: u64, count: usize, little: bool = true) -> !:
        if count > 8: error(invalid, "integer field exceeds eight bytes")
        for i in 0..<count:
            let shift = i * 8 if little else (count - 1 - i) * 8
            try self.byte((u8)(value >> shift))

    pub func view() -> const u8[]:
        if self.used == 0: return b""
        return self.data[..<self.used]

    pub func close():
        if self.data.length > 0: free(self.data) in memory.heap
        var empty: u8[]
        self.data = empty
        self.used = 0