lawful-bytes

Search uses release 0.1.1.0 · 578 definitions

Releases (2)

def grow.fin
def growThe same bytes in a block of 2^e words (for e at least the current depth).
def find.gohit says byte j is c; r holds byte j + 1; n counts positions left from j.
def find.start
def findThe first index j with from <= j < to where byte j is c; to if none.
def find2.go
def find2.start
def find2The first index j with from <= j < to where byte j is c1 or c2; to if none.
def same.gora, rb hold byte i of a and byte j of b; acc says all bytes so far matched.
def sameBytes i ..
def lenThe number of bytes in use.
def capacity.fin
def capacityHow many bytes fit (4 per word).
def truncateOnly the first n bytes kept (for n <= len).
def shift.goBytes j + k onwards moved to j; r holds byte j + k.
def shiftThe first k bytes dropped, the rest moved to the start (for k <= len).
def of_list.go
def of_listA Bytes in a block of 2^d words holding the bytes of xs (Base's file reads give such lists).
def to_list.gon more bytes put in front of acc, from byte j down; r holds byte j.
def to_listBytes s ..
def at2.fin2
def at2.fin
def at2Bytes i and j.
def same1.gor holds bytes i and j; acc says all bytes so far matched.
def same1Bytes i ..

type BytesBytes packed four to a word, little-endian, in a block of 2^d words: byte i is byte i & 3 of word i >> 2.
def unpackThe four bytes of each word, in order.
def viewWhat a Bytes holds: its first len bytes.
def sizeThe number of bytes in use.
def capHow many bytes fit: four per word.
def okb is well formed with a block of depth d: a perfect block of 2^d words, d <= 29, and len within the block.
def all_bytesEvery element is a byte (below 256).
def slicen elements from index i.
def run_lenHow many leading elements are not c.
def run_len2How many leading elements are neither c1 nor c2.
def firstThe first index j with from <= j < to where xs has c; to if there is none (for from <= to <= length(xs), as the laws assume).
def first2The same for either of two values (same assumptions).
def list_eqTwo lists are equal, element by element.
def is_somexs has c at index k.
def has
def has2xs has c1 or c2 at index k.

def zb0x80 at each byte of v that is 0, exact at the lowest such byte (a byte above a 0 byte may be flagged too).
def repc in all four bytes of a word.
def b2u
def bidxThe place (0-3) of the lowest flagged byte of a nonzero mask.
def lowThe bytes of a word at or above byte i's place.
def wordsHow many words hold bytes from ..
def find.fin
def find.gom flags word wi's hits; z: m is 0; r holds word wi + 1; n counts the words left, wi's included.
def find.start
def find.k
def findThe first index j with from <= j < to where byte j is c; to if none.
def find2.go
def find2.start
def find2The first index j with from <= j < to where byte j is c1 or c2; to if none.
def append.wordsn words to dst from word di on, taken from src's bytes at a shift of sh bits: lo is src word si, r holds word si + 1.
def append.fin
def append.w
def append.kdst's length is now a multiple of 4: n more bytes of src from q, a word at a time (up to 3 bytes past the new length are overwritten too).
def appenddst with bytes s ..