///|
/// A checked cursor; offsets refer to the original file, including its header.
pub struct Reader {
data : Bytes
order : ByteOrder
base : Int32
mut pos : Int32
}
///|
pub fn Reader::new(data : Bytes, order : ByteOrder, base : Int32) -> Reader {
{ data, order, base, pos: 0, }
}
///|
pub fn Reader::take(self : Reader, n : Int32) -> Bytes raise StdfError {
if n < 0 || n > self.data.length() - self.pos {
raise StdfError(self.base + self.pos, "partial or missing field")
}
let data = self.data[self.pos:self.pos + n].to_owned()
self.pos += n
data
}
///|
pub fn Reader::u1(self : Reader) -> Int32 raise StdfError {
self.take(1)[0].to_int()
}
///|
pub fn Reader::u2(self : Reader) -> Int32 raise StdfError {
let a = self.u1()
let b = self.u1()
if self.order != Big {
a | (b << 8)
} else {
(a << 8) | b
}
}
///|
pub fn Reader::u4(self : Reader) -> UInt32 raise StdfError {
let a = self.u2().reinterpret_as_uint()
let b = self.u2().reinterpret_as_uint()
if self.order != Big {
a | (b << 16)
} else {
(a << 16) | b
}
}
///|
pub fn Reader::i1(self : Reader) -> Int32 raise StdfError {
let x = self.u1()
if x >= 128 {
x - 256
} else {
x
}
}
///|
pub fn Reader::i2(self : Reader) -> Int32 raise StdfError {
let x = self.u2()
if x >= 32768 {
x - 65536
} else {
x
}
}
///|
pub fn Reader::r4(self : Reader) -> Double raise StdfError {
if self.order == Vax {
return self.vax_real(2)
}
Float::reinterpret_from_uint(self.u4()).to_double()
}
///|
pub fn Reader::r8(self : Reader) -> Double raise StdfError {
if self.order == Vax {
return self.vax_real(4)
}
let a = self.u4().to_uint64()
let b = self.u4().to_uint64()
let bits = if self.order == Little { a | (b << 32) } else { (a << 32) | b }
bits.reinterpret_as_double()
}
///|
/// VAX F and D store the sign/exponent word first, with little-endian bytes
/// within each 16-bit word. The implicit mantissa is 0.1 binary, bias 128.
/// D's 56 significant bits round to the host's IEEE binary64 precision.
fn Reader::vax_real(self : Reader, words : Int32) -> Double raise StdfError {
let first = self.u2()
let exponent = (first >> 7) & 255
let negative = (first & 32768) != 0
// Keep all 24/56 significant bits as an integer until the sole rounding
// to binary64, avoiding double rounding around a binary64 midpoint.
let mut mantissa = (128 | (first & 127)).to_uint64()
for _ in 1..= 128 {
for _ in 0..<(exponent - 128) {
value *= 2.0
}
} else {
for _ in 0..<(128 - exponent) {
value /= 2.0
}
}
if negative {
-value
} else {
value
}
}
///|
/// C*n byte strings are mapped losslessly as Latin-1, never guessed as UTF-8.
pub fn Reader::cn(self : Reader) -> String raise StdfError {
let data = self.take(self.u1())
let s = StringBuilder()
for b in data {
s.write_char(b.to_int().to_char().unwrap())
}
s.to_string()
}
///|
pub fn Reader::remaining(self : Reader) -> Int32 {
self.data.length() - self.pos
}
///|
/// Absence at a legal optional suffix boundary differs from a partial field.
pub fn[T] Reader::optional(
self : Reader,
read : (Reader) -> T raise StdfError,
) -> T? raise StdfError {
if self.remaining() == 0 {
None
} else {
Some(read(self))
}
}
///|
pub fn Reader::end(self : Reader) -> Unit raise StdfError {
if self.remaining() != 0 {
raise StdfError(
self.base + self.pos,
"unexpected trailing bytes in V4 record",
)
}
}
///|
fn validate_frame(frame : Frame) -> Unit raise StdfError {
if frame.offset < 0 ||
frame.offset > 2147418108 ||
frame.typ < 0 ||
frame.typ > 255 ||
frame.sub < 0 ||
frame.sub > 255 ||
frame.body.length() > 65535 {
raise StdfError(frame.offset, "invalid V4 record bounds")
}
}