Low-level byte buffer helpers for big-endian encoding / bulk copy. Only depends on pg_errors (itself dependency-free) so it stays importable from pg_protocol and pg_types/* without cycles.
The fixed-width helpers (writeBE*, fromBE*, decodeFloat*BE) do not check bounds: the caller keeps pos/offset plus the width inside the buffer. An overrun is an IndexDefect, which except PgError does not catch, and under -d:danger an unchecked out-of-bounds access. The copy helpers (writeBytesAt, readString, readBytes) raise PgProtocolError instead.
Procs
func decodeFloat32BE(data: openArray[byte]; offset = 0): float32 {.inline, ...raises: [], tags: [], forbids: [].}
- Decode a big-endian IEEE-754 32-bit float from data at offset, unchecked.
func decodeFloat64BE(data: openArray[byte]; offset = 0): float64 {.inline, ...raises: [], tags: [], forbids: [].}
- Decode a big-endian IEEE-754 64-bit float from data at offset, unchecked.
func fromBE16(data: openArray[byte]; offset = 0): int16 {.inline, ...raises: [], tags: [], forbids: [].}
- Decode a big-endian 16-bit integer from data at offset, unchecked.
func fromBE32(data: openArray[byte]; offset = 0): int32 {.inline, ...raises: [], tags: [], forbids: [].}
- Decode a big-endian 32-bit integer from data at offset, unchecked.
func fromBE64(data: openArray[byte]; offset = 0): int64 {.inline, ...raises: [], tags: [], forbids: [].}
- Decode a big-endian 64-bit integer from data at offset, unchecked.
proc readBytes(src: openArray[byte]; off, len: int): seq[byte] {. ...raises: [PgProtocolError], tags: [], forbids: [].}
- Copy len bytes from src at off into a new seq[byte]. Same guards as readString.
proc readString(src: openArray[byte]; off, len: int): string {. ...raises: [PgProtocolError], tags: [], forbids: [].}
- Copy len bytes from src at off into a new string. Raises PgProtocolError on out-of-range slice: newString(-1) is an uncatchable RangeDefect, and -d:danger skips the src[off] bounds check.
func toBE16(v: int16): array[2, byte] {.inline, ...raises: [], tags: [], forbids: [].}
- Encode a 16-bit integer as big-endian bytes.
func toBE32(v: int32): array[4, byte] {.inline, ...raises: [], tags: [], forbids: [].}
- Encode a 32-bit integer as big-endian bytes.
func toBE64(v: int64): array[8, byte] {.inline, ...raises: [], tags: [], forbids: [].}
- Encode a 64-bit integer as big-endian bytes.
Templates
template appendBytes(buf: var seq[byte]; src: openArray[byte])
- Append src bytes to the end of buf. No-op when src is empty.
template writeBE16(buf: var openArray[byte]; pos: int; v: int16)
- Write v big-endian at buf[pos ..< pos + 2], unchecked.
template writeBE32(buf: var openArray[byte]; pos: int; v: int32)
- Write v big-endian at buf[pos ..< pos + 4], unchecked.
template writeBE64(buf: var openArray[byte]; pos: int; v: int64)
- Write v big-endian at buf[pos ..< pos + 8], unchecked.
template writeBytesAt(dst: var openArray[byte]; pos: int; src: openArray[byte])
- Copy src bytes into dst starting at pos. No-op when src is empty. Raises PgProtocolError on out-of-range slice: under -d:danger addr dst[pos] skips bounds checks, so guard here.