Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-raster

Source of release 0.4.0

0.4.0 / src / binary.lucb

import memory
from errors import corrupt, limit

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 image data")
        let result = self.data[self.position..<self.position + count]
        self.position += count
        return result

    pub func byte() -> u8!:
        # Keep the slice in a local: the pinned C emitter evaluates a call in
        # subscript position twice. See tests/regressions/c_span_call.lucb.
        let bytes = try self.take(1)
        return bytes[0]

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

    pub func cstring(maximum: usize = 255) -> str!:
        let start = self.position
        while true:
            if try self.byte() == 0:
                return (str)self.data[start..<self.position - 1]
            if self.position - start > maximum:
                error(corrupt, "unterminated or excessive image string")

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

    pub func reserve(count: usize) -> !:
        if count > self.maximum or self.used > self.maximum - count:
            error(limit, "encoded buffer exceeds byte limit")
        let needed = self.used + count
        if needed <= self.data.length:
            return
        var capacity = 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 grown = try new u8[capacity] --- in memory.heap
        memory.copy(grown, self.data, self.used)
        if self.data.length > 0:
            free(self.data) in memory.heap
        self.data = grown

    pub func put(bytes: const u8[]) -> !:
        try self.reserve(bytes.length)
        memory.copy(self.data[self.used..], bytes, bytes.length)
        self.used += bytes.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) -> !:
        for i in 0..<count:
            let shift = i * 8 if little else (count - 1 - i) * 8
            try self.byte((u8)(value >> shift))

    pub func text(value: str, terminated: bool = false) -> !:
        try self.put(value.bytes)
        if terminated:
            try self.byte(0)

    pub func view() -> const u8[]:
        return self.data[..<self.used]

    pub func close():
        if self.data.length > 0:
            free(self.data) in memory.heap
        self = Buffer()

pub func slice(data: const u8[], offset: u64, size: u64) -> const u8[]!:
    if offset > (u64)data.length or size > (u64)data.length - offset:
        error(corrupt, "image offset or extent outside file")
    return data[(usize)offset..<(usize)(offset + size)]

pub union FloatBits:
    pub bits: u32
    pub value: f32

pub union DoubleBits:
    pub bits: u64
    pub value: f64

pub func float_value(bits: u32) -> f64:
    var value: FloatBits
    value.bits = bits
    return (f64)value.value

pub func float_bits(value: f64) -> u32:
    var result: FloatBits
    result.value = (f32)value
    return result.bits

pub func double_value(bits: u64) -> f64:
    var value: DoubleBits
    value.bits = bits
    return value.value

pub func double_bits(value: f64) -> u64:
    var result: DoubleBits
    result.value = value
    return result.bits

pub func half(bits: u16) -> f64:
    let sign = (u32)(bits & 32768) << 16
    let exponent = (u32)(bits >> 10) & 31
    var fraction = (u32)(bits & 1023)
    if exponent == 0:
        if fraction == 0:
            return float_value(sign)
        var e: u32 = 113
        while (fraction & 1024) == 0:
            fraction <<= 1
            e -= 1
        return float_value(sign | (e << 23) | ((fraction & 1023) << 13))
    if exponent == 31:
        return float_value(sign | 2139095040 | (fraction << 13))
    return float_value(sign | ((exponent + 112) << 23) | (fraction << 13))

pub func to_half(value: f64) -> u16:
    let bits = float_bits(value)
    let sign = (u16)(bits >> 16) & 32768
    let exponent = (i32)((bits >> 23) & 255) - 127
    let fraction = bits & 8388607
    if exponent == 128:
        return sign | (u16)31744 | ((u16)512 if fraction != 0 else (u16)0)
    if exponent > 15:
        return sign | (u16)31744
    if exponent < -25:
        return sign
    var mantissa = fraction | 8388608
    let shift: u32 = (u32)(-exponent - 1) if exponent < -14 else 13
    var rounded = mantissa >> shift
    let remainder = mantissa & (((u32)1 << shift) - 1)
    let halfway = (u32)1 << (shift - 1)
    if remainder > halfway or (remainder == halfway and (rounded & 1) != 0):
        rounded += 1
    if exponent < -14:
        return sign | (u16)rounded
    return sign | (u16)(((u32)(exponent + 14) << 10) + rounded)