///|
/// Zero-copy protobuf cursor. Reads never raise (in wasm-gc a call that may raise
/// allocates): a failed read records the first error, returns 0 and jumps to the end
/// so `at_end` loops stop. Check `error` once at a boundary.
pub struct Reader {
priv data : Bytes
priv mut pos : Int32
priv mut end : Int32
priv mut error : PbfError?
}
///|
/// A reader over `view`, at its start.
pub fn Reader::new(view : BytesView) -> Reader {
let start = view.start_offset()
{ data: view.data(), pos: start, end: start + view.length(), error: None, }
}
///|
/// Repositions this reader over `[start, end)` of the same buffer and clears
/// its error; offsets are absolute, as returned by `pos`. Reusing one reader
/// avoids an allocation per message. Out-of-range bounds become an error.
pub fn Reader::reset(self : Reader, start : Int32, end : Int32) -> Unit {
self.error = None
if start < 0 || end < start || end > self.data.length() {
self.pos = 0
self.end = 0
self.error = Some(LengthOutOfRange(pos=start, end - start))
} else {
self.pos = start
self.end = end
}
}
///|
/// Absolute offset of the next byte to read.
pub fn Reader::pos(self : Reader) -> Int32 {
self.pos
}
///|
/// Whether nothing is left: the loop condition of a message, true after an error too.
pub fn Reader::at_end(self : Reader) -> Bool {
self.pos >= self.end
}
///|
/// Bytes left in the current range.
pub fn Reader::remaining(self : Reader) -> Int32 {
self.end - self.pos
}
///|
/// Whether a read has failed since the last `reset`.
pub fn Reader::failed(self : Reader) -> Bool {
self.error is Some(_)
}
///|
/// The first error since the last `reset`.
pub fn Reader::error(self : Reader) -> PbfError? {
self.error
}
///|
fn Reader::fail(self : Reader, err : PbfError) -> Unit {
if self.error is None {
self.error = Some(err)
}
self.pos = self.end
}
///|
fn Reader::byte(self : Reader) -> Int32 {
if self.pos >= self.end {
self.fail(UnexpectedEof(pos=self.pos))
return 0
}
let b = self.data[self.pos].to_int()
self.pos += 1
b
}
///|
/// Reads a field tag (`field << 3 | wire`); see `tag` and `WIRE_*`. Group
/// wire types are an error.
pub fn Reader::read_tag(self : Reader) -> Int32 {
let pos = self.pos
let t = self.read_varint32()
match t & WIRE_MASK {
WIRE_VARINT | WIRE_FIXED64 | WIRE_LEN | WIRE_FIXED32 => t
w => {
self.fail(UnsupportedWireType(pos~, w))
0
}
}
}
///|
/// Reads a varint and keeps its low 32 bits, as protobuf does for `uint32`.
pub fn Reader::read_varint32(self : Reader) -> Int32 {
let p = self.pos
if p < self.end {
let b = self.data[p].to_int()
if b < 0x80 {
self.pos = p + 1
return b
}
}
self.read_varint32_multi()
}
///|
/// General case of `read_varint32`, keeping the cursor in locals.
fn Reader::read_varint32_multi(self : Reader) -> Int32 {
let data = self.data
let end = self.end
let start = self.pos
for p = start, v = 0, shift = 0 {
if p >= end {
self.fail(UnexpectedEof(pos=p))
return 0
}
let b = data[p].to_int()
let v = if shift < 32 { v | ((b & 0x7f) << shift) } else { v }
if b < 0x80 {
self.pos = p + 1
return v
}
if shift >= 63 {
self.fail(VarintTooLong(pos=start))
return 0
}
continue p + 1, v, shift + 7
}
}
///|
/// Reads a varint of at most 10 bytes; longer is an error.
pub fn Reader::read_varint64(self : Reader) -> UInt64 {
let start = self.pos
let mut v = 0UL
for shift = 0; shift < 70; shift = shift + 7 {
let b = self.byte()
v = v | ((b & 0x7f).to_uint64() << shift)
if b < 0x80 {
return v
}
}
self.fail(VarintTooLong(pos=start))
0UL
}
///|
/// Reads a zigzag-encoded `sint32`.
pub fn Reader::read_svarint32(self : Reader) -> Int32 {
zigzag32(self.read_varint32())
}
///|
fn zigzag32(v : Int32) -> Int32 {
(v.reinterpret_as_uint() >> 1).reinterpret_as_int() ^ -(v & 1)
}
///|
/// Reads an `int64`: a varint in two's complement.
pub fn Reader::read_int64(self : Reader) -> Int64 {
self.read_varint64().reinterpret_as_int64()
}
///|
/// Reads a zigzag-encoded `sint64`.
pub fn Reader::read_sint64(self : Reader) -> Int64 {
let v = self.read_varint64()
(v >> 1).reinterpret_as_int64() ^ -(v & 1UL).reinterpret_as_int64()
}
///|
/// Reads a `bool`: any varint but 0 is true.
pub fn Reader::read_bool(self : Reader) -> Bool {
self.read_varint64() != 0UL
}
///|
/// Advances past `n` bytes and returns where they start, or -1 on EOF.
fn Reader::take(self : Reader, n : Int32) -> Int32 {
if self.end - self.pos < n {
self.fail(UnexpectedEof(pos=self.pos))
return -1
}
let p = self.pos
self.pos += n
p
}
///|
/// Reads a little-endian `fixed32`.
pub fn Reader::read_fixed32(self : Reader) -> UInt32 {
let p = self.take(4)
if p < 0 {
return 0
}
let d = self.data
d[p].to_uint() |
(d[p + 1].to_uint() << 8) |
(d[p + 2].to_uint() << 16) |
(d[p + 3].to_uint() << 24)
}
///|
/// Reads a little-endian `fixed64`.
pub fn Reader::read_fixed64(self : Reader) -> UInt64 {
let lo = self.read_fixed32().to_uint64()
let hi = self.read_fixed32().to_uint64()
lo | (hi << 32)
}
///|
/// Reads a `float`: IEEE 754 bits as a `fixed32`.
pub fn Reader::read_float(self : Reader) -> Float {
Float::reinterpret_from_uint(self.read_fixed32())
}
///|
/// Reads a `double`: IEEE 754 bits as a `fixed64`.
pub fn Reader::read_double(self : Reader) -> Double {
self.read_fixed64().reinterpret_as_double()
}
///|
/// Reads a length prefix and checks it fits; returns -1 on error.
fn Reader::read_len(self : Reader) -> Int32 {
let pos = self.pos
let len = self.read_varint32()
if self.error is Some(_) {
return -1
}
if len < 0 || len > self.end - self.pos {
self.fail(LengthOutOfRange(pos~, len))
return -1
}
len
}
///|
/// Narrows the reader to the next length-delimited field, without allocating.
/// Pass the returned token to `exit` once the field has been read.
pub fn Reader::enter(self : Reader) -> Int32 {
let len = self.read_len()
if len < 0 {
return self.end
}
let outer = self.end
self.end = self.pos + len
outer
}
///|
/// Leaves the field entered with `enter`, skipping whatever was not read.
pub fn Reader::exit(self : Reader, token : Int32) -> Unit {
if self.error is None {
self.pos = self.end
self.end = token
}
}
///|
/// Skips over a length-delimited field and returns its absolute start offset;
/// its end is `pos()` afterwards.
pub fn Reader::read_len_start(self : Reader) -> Int32 {
let len = self.read_len()
if len < 0 {
return self.pos
}
let start = self.pos
self.pos += len
start
}
///|
/// Reads a length-delimited field as a view of the original buffer (no copy).
pub fn Reader::read_bytes(self : Reader) -> BytesView {
let start = self.read_len_start()
self.data[start:self.pos]
}
///|
/// Reads a UTF-8 string; invalid sequences become U+FFFD, like `TextDecoder`.
pub fn Reader::read_string(self : Reader) -> String {
decode_lossy(self.read_bytes())
}
///|
/// Skips the value of a field whose tag was just read.
pub fn Reader::skip(self : Reader, tag : Int32) -> Unit {
match tag & WIRE_MASK {
WIRE_VARINT => ignore(self.read_varint64())
WIRE_FIXED64 => ignore(self.take(8))
WIRE_FIXED32 => ignore(self.take(4))
WIRE_LEN => ignore(self.read_len_start())
w => self.fail(UnsupportedWireType(pos=self.pos, w))
}
}