dymokomi/luce-raster
Source of release 0.4.0
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)