bend-kit-tar Releases (3): 0.3.0.0 0x401945c8ec628601b75dd6a3de05ea12 indexed https://jend.leeeet.dev/files.txt?path=bend-kit-tar@0.3.0.0 0.2.0.0 0xf134d14ef1244d08994eac130bd22b62 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-tar@0.2.0.0 0.1.0.0 0x03330e0da0937f54ea73f35891d3540a unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-tar@0.1.0.0 Definitions (115, 1 to 100 shown): Tar.Entry (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=Entry) # An archive is a list of entries in order. Names are raw bytes (UTF-8 by convention), kept byte for byte; # a directory keeps whatever trailing '/' its name has. Nothing here touches the filesystem. # import ./tar/tar.bend as Tar type Entry is Type: File{name: Bytes.Bytes, data: Bytes.Bytes} Dir{name: Bytes.Bytes} Tar.pad (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pad) # n rounded up to a whole 512-byte block; 0 when that would pass U32. def pad(+n: U32) -> U32: Tar.wsum (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=wsum) # The sum of w's four bytes. def wsum(+w: U32) -> U32: Tar.bsum.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=bsum.go) def bsum.go(n: Nat, r: Array & U32, +k: U32, +acc: U32) -> Array & U32: Tar.bsum (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=bsum) # The sum of the 512 bytes from word k: 0 only for a zero block. def bsum(a: Array, +k: U32) -> Array & U32: Tar.oct.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=oct.go) # Octal digits after leading spaces, ended by NUL, space, or the field's end. ph: 0 leading, 1 digits, 2 done. def oct.go(n: Nat, r: Array & U32, +j: U32, +ph: U32, +acc: U32, +ok: Bool) -> Array & U32 & Bool: Tar.oct (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=oct) # The octal field of w bytes at j, and whether it is well formed and fits a U32. def oct(a: Array, +j: U32, +w: U32) -> Array & U32 & Bool: Tar.cstr.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=cstr.go) def cstr.go(n: Nat, r: Array & U32, +j: U32, +k: U32, +done: Bool) -> Array & U32: Tar.cstr (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=cstr) # The count of bytes before the first NUL in the w bytes from j. def cstr(a: Array, +j: U32, +w: U32) -> Array & U32: Tar.Dec (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=Dec) type Dec is Data: Dec{v: U32, digits: U32, stop: U32, ended: Bool, ok: Bool} Tar.DByte (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=DByte) type DByte is Data: DByte{byte: U32, digit: Bool} Tar.dec.byte.of (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=dec.byte.of) def dec.byte.of(+len: U32, r: Array & U32) -> Bytes.Bytes & Maybe<&2, DByte>: Tar.dec.byte (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=dec.byte) def dec.byte(b: Bytes.Bytes, +i: U32) -> Bytes.Bytes & Maybe<&2, DByte>: Tar.dec.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=dec.go) # Consume decimal digits and, when present, their first non-digit delimiter. def dec.go(n: Nat, r: Bytes.Cursor & Maybe<&2, DByte>, +acc: U32, +digits: U32, +ok: Bool) -> Bytes.Cursor & Dec: Tar.dec.start (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=dec.start) def dec.start(r: Bytes.Cursor & U32) -> Bytes.Cursor & Dec: Tar.dec (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=dec) def dec(c: Bytes.Cursor) -> Bytes.Cursor & Dec: Tar.name.fin (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=name.fin) # Header i's name: prefix "/" name when the magic is POSIX ustar and the prefix is not empty. def name.fin(+total: U32, r: Array & Array) -> Array & Bytes.Bytes: Tar.name.join (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=name.join) def name.join(+i: U32, +n: U32, +pl: U32, r: Array & Array) -> Array & Bytes.Bytes: Tar.name.pre (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=name.pre) def name.pre(+i: U32, +n: U32, r: Array & U32) -> Array & Bytes.Bytes: Tar.pfx.len (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pfx.len) def pfx.len(ustar: Bool, a: Array, +i: U32) -> Array & U32: Tar.name.magic (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=name.magic) def name.magic(+i: U32, +n: U32, r: Array & Bool) -> Array & Bytes.Bytes: Tar.name.len (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=name.len) def name.len(+i: U32, r: Array & U32) -> Array & Bytes.Bytes: Tar.header.name (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=header.name) def header.name(a: Array, +i: U32) -> Array & Bytes.Bytes: Tar.Pax (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=Pax) # Records from an 'x' header that apply to the next entry. type Pax is Type: Pax{path: Maybe<&1, Bytes.Bytes>, size: Maybe<&2, U32>} Tar.Pst (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=Pst) type Pst is Type: PGo{pax: Pax} PEnd{pax: Pax} PBad{} Tar.PKey (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=PKey) type PKey is Data: PPath{} PSize{} POther{} Tar.pr.key.size (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.key.size) def pr.key.size(hit: Bool, +len: U32, a: Array) -> Bytes.Bytes & Maybe<&2, PKey>: Tar.pr.key.sized (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.key.sized) def pr.key.sized(+len: U32, r: Array & Bool) -> Bytes.Bytes & Maybe<&2, PKey>: Tar.pr.key.path (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.key.path) def pr.key.path(+i: U32, +len: U32, r: Array & Bool) -> Bytes.Bytes & Maybe<&2, PKey>: Tar.pr.key (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.key) # The cursor bounds both fixed keyword probes; short or unknown bodies are skipped. def pr.key(b: Bytes.Bytes, +i: U32) -> Bytes.Bytes & Maybe<&2, PKey>: Tar.pr.opt (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.opt) def pr.opt(has: Bool, b: Bytes.Bytes) -> Maybe<&1, Bytes.Bytes>: Tar.pr.path.done (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.path.done) # An empty value unsets the keyword, so the header's own name applies. def pr.path.done(+start: U32, +end: U32, +n: U32, pax: Pax, r: Bytes.Bytes & Bytes.Bytes) -> Bytes.Cursor & Pst: Tar.pr.path (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.path) def pr.path(c: Bytes.Cursor, pax: Pax) -> Bytes.Cursor & Pst: Tar.pr.size.valid (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.size.valid) def pr.size.valid(ok: Bool, c: Bytes.Cursor, +v: U32, path: Maybe<&1, Bytes.Bytes>) -> Bytes.Cursor & Pst: Tar.pr.size.done (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.size.done) def pr.size.done(pax: Pax, r: Bytes.Cursor & Dec) -> Bytes.Cursor & Pst: Tar.pr.checked (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.checked) def pr.checked(r: Bytes.Cursor & Bool, pax: Pax) -> Bytes.Cursor & Pst: Tar.pr.skip (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.skip) def pr.skip(c: Bytes.Cursor, pax: Pax) -> Bytes.Cursor & Pst: Tar.pr.value (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.value) def pr.value(pax: Pax, r: Bytes.Cursor & Maybe<&2, PKey>) -> Bytes.Cursor & Pst: Tar.pr.nl (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.nl) def pr.nl(pax: Pax, r: Bytes.Cursor & Maybe<&2, U32>) -> Bytes.Cursor & Pst: Tar.pr.close (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.close) def pr.close(limit: Bytes.CursorLimit, r: Bytes.Cursor & Pst) -> Bytes.Cursor & Pst: Tar.pr.body (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.body) def pr.body(pax: Pax, r: Bytes.Cursor & Maybe<&1, Bytes.CursorLimit>) -> Bytes.Cursor & Pst: Tar.pr.len.valid (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.len.valid) def pr.len.valid(ok: Bool, c: Bytes.Cursor, +body: U32, pax: Pax) -> Bytes.Cursor & Pst: Tar.pr.len (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.len) # Length includes its digits, the space, the bounded body and its final newline. def pr.len(+available: U32, pax: Pax, r: Bytes.Cursor & Dec) -> Bytes.Cursor & Pst: Tar.pr.more.if (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.more.if) def pr.more.if(done: Bool, c: Bytes.Cursor, +n: U32, pax: Pax) -> Bytes.Cursor & Pst: Tar.pr.more (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.more) def pr.more(pax: Pax, r: Bytes.Cursor & U32) -> Bytes.Cursor & Pst: Tar.pr.run (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.run) # Each record consumes at least three bytes; leave fuel for the end transition. def pr.run(fuel: Nat, r: Bytes.Cursor & Pst) -> Bytes.Cursor & Maybe<&1, Pax>: Tar.pr.start (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.start) def pr.start(pax: Pax, r: Bytes.Cursor & U32) -> Bytes.Cursor & Maybe<&1, Pax>: Tar.pr.parse (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=pr.parse) # c is already bounded to exactly the PAX payload, without block padding. def pr.parse(c: Bytes.Cursor, pax: Pax) -> Bytes.Cursor & Maybe<&1, Pax>: Tar.St (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=St) type St is Type: SHead{pax: Pax, acc: List<&1, Entry>} SOk{entries: List<&1, Entry>} SFail{} Tar.Hdr (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=Hdr) # Header metadata is Data so a checked read can advance without copying the header. type Hdr is Data: Hdr{sum: U32, ok: Bool, size: U32, size_ok: Bool, kind: U32} Tar.hdr.kind (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.kind) def hdr.kind(+len: U32, +sum: U32, +ok: Bool, +size: U32, +size_ok: Bool, r: Array & U32) -> Bytes.Bytes & Maybe<&2, Hdr>: Tar.hdr.size (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.size) def hdr.size(+len: U32, +i: U32, +sum: U32, +ok: Bool, r: Array & U32 & Bool) -> Bytes.Bytes & Maybe<&2, Hdr>: Tar.hdr.valid (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.valid) def hdr.valid(ok: Bool, +len: U32, +i: U32, +sum: U32, a: Array) -> Bytes.Bytes & Maybe<&2, Hdr>: Tar.hdr.ck3 (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.ck3) # The checksum's eight bytes count as spaces. def hdr.ck3(+len: U32, +i: U32, +sum: U32, +ck: U32, +ok: Bool, +x: U32, r: Array & U32) -> Bytes.Bytes & Maybe<&2, Hdr>: Tar.hdr.ck2 (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.ck2) def hdr.ck2(+len: U32, +i: U32, +sum: U32, +ck: U32, +ok: Bool, r: Array & U32) -> Bytes.Bytes & Maybe<&2, Hdr>: Tar.hdr.check (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.check) def hdr.check(+len: U32, +i: U32, +sum: U32, r: Array & U32 & Bool) -> Bytes.Bytes & Maybe<&2, Hdr>: Tar.hdr.zero (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.zero) def hdr.zero(zero: Bool, +len: U32, +i: U32, +sum: U32, a: Array) -> Bytes.Bytes & Maybe<&2, Hdr>: Tar.hdr.sum (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.sum) def hdr.sum(+len: U32, +i: U32, r: Array & U32) -> Bytes.Bytes & Maybe<&2, Hdr>: Tar.hdr.read (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.read) # Cursor.read establishes that all fixed offsets below belong to a complete block. def hdr.read(b: Bytes.Bytes, +i: U32) -> Bytes.Bytes & Maybe<&2, Hdr>: Tar.zero.sum (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=zero.sum) def zero.sum(+len: U32, r: Array & U32) -> Bytes.Bytes & Maybe<&2, U32>: Tar.zero.read (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=zero.read) def zero.read(b: Bytes.Bytes, +i: U32) -> Bytes.Bytes & Maybe<&2, U32>: Tar.name.of (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=name.of) def name.of(path: Maybe<&1, Bytes.Bytes>, a: Array, +i: U32) -> Array & Bytes.Bytes: Tar.entry.named (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=entry.named) def entry.named(+len: U32, +pos: U32, start: U32, end: U32, r: Array & Bytes.Bytes) -> Bytes.Cursor & Bytes.Bytes: Tar.entry.name (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=entry.name) # The header begins one block before the payload cursor; no separate header index survives. def entry.name(c: Bytes.Cursor, path: Maybe<&1, Bytes.Bytes>) -> Bytes.Cursor & Bytes.Bytes: Tar.file.data (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=file.data) def file.data(+len: U32, pos: U32, start: U32, end: U32, +size: U32, name: Bytes.Bytes, acc: List<&1, Entry>, r: Array & Array) -> Bytes.Cursor & St: Tar.file.name (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=file.name) def file.name(+size: U32, acc: List<&1, Entry>, r: Bytes.Cursor & Bytes.Bytes) -> Bytes.Cursor & St: Tar.entry.file (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=entry.file) def entry.file(c: Bytes.Cursor, +size: U32, pax: Pax, acc: List<&1, Entry>) -> Bytes.Cursor & St: Tar.dir.name (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=dir.name) def dir.name(acc: List<&1, Entry>, r: Bytes.Cursor & Bytes.Bytes) -> Bytes.Cursor & St: Tar.entry.dir (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=entry.dir) # Leaving the payload region skips a directory's data, as it does global PAX records. def entry.dir(c: Bytes.Cursor, pax: Pax, acc: List<&1, Entry>) -> Bytes.Cursor & St: Tar.step.pax (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=step.pax) def step.pax(acc: List<&1, Entry>, r: Bytes.Cursor & Maybe<&1, Pax>) -> Bytes.Cursor & St: Tar.step.type (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=step.type) # '0'/NUL are files, '5' directories, 'x' local PAX and 'g' ignored global PAX. # Links, devices, FIFOs, GNU extensions and all other types fail. def step.type(+t: U32, c: Bytes.Cursor, +size: U32, pax: Pax, acc: List<&1, Entry>) -> Bytes.Cursor & St: Tar.frame.padded (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=frame.padded) def frame.padded(outer: Bytes.CursorLimit, st: St, r: Bytes.Cursor & Bool) -> Bytes.Cursor & St: Tar.frame.body (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=frame.body) def frame.body(inner: Bytes.CursorLimit, outer: Bytes.CursorLimit, +padding: U32, r: Bytes.Cursor & St) -> Bytes.Cursor & St: Tar.frame.payload (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=frame.payload) def frame.payload(+t: U32, +size: U32, +padding: U32, outer: Bytes.CursorLimit, pax: Pax, acc: List<&1, Entry>, r: Bytes.Cursor & Maybe<&1, Bytes.CursorLimit>) -> Bytes.Cursor & St: Tar.frame.region (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=frame.region) # First bound the complete padded body, then restrict PAX to the exact payload. # Limits are left in reverse order; neither region slices or copies the backing buffer. def frame.region(+t: U32, +size: U32, +pd: U32, pax: Pax, acc: List<&1, Entry>, r: Bytes.Cursor & Maybe<&1, Bytes.CursorLimit>) -> Bytes.Cursor & St: Tar.step.fit (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=step.fit) def step.fit(ok: Bool, +t: U32, c: Bytes.Cursor, +size: U32, +pd: U32, pax: Pax, acc: List<&1, Entry>) -> Bytes.Cursor & St: Tar.step.pad (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=step.pad) def step.pad(+t: U32, c: Bytes.Cursor, +size: U32, +ok: Bool, pax: Pax, acc: List<&1, Entry>) -> Bytes.Cursor & St: Tar.step.size (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=step.size) # A pending PAX size overrides the header field for every type, even when that field is malformed. def step.size(+t: U32, c: Bytes.Cursor, +v: U32, +ok: Bool, pax: Pax, acc: List<&1, Entry>) -> Bytes.Cursor & St: Tar.step.hdr (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=step.hdr) def step.hdr(ok: Bool, +t: U32, c: Bytes.Cursor, +size: U32, +size_ok: Bool, pax: Pax, acc: List<&1, Entry>) -> Bytes.Cursor & St: Tar.end.pax (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=end.pax) # Two zero blocks are required and no local PAX records may remain pending. def end.pax(pax: Pax, acc: List<&1, Entry>) -> St: Tar.end.of (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=end.of) def end.of(ok: Bool, pax: Pax, acc: List<&1, Entry>) -> St: Tar.end.sum (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=end.sum) def end.sum(pax: Pax, acc: List<&1, Entry>, r: Bytes.Cursor & Maybe<&2, U32>) -> Bytes.Cursor & St: Tar.step.zero (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=step.zero) def step.zero(zero: Bool, +ok: Bool, +size: U32, +size_ok: Bool, +t: U32, c: Bytes.Cursor, pax: Pax, acc: List<&1, Entry>) -> Bytes.Cursor & St: Tar.step.read (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=step.read) def step.read(pax: Pax, acc: List<&1, Entry>, r: Bytes.Cursor & Maybe<&2, Hdr>) -> Bytes.Cursor & St: Tar.step (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=step) def step(c: Bytes.Cursor, pax: Pax, acc: List<&1, Entry>) -> Bytes.Cursor & St: Tar.run (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=run) def run(fuel: Nat, r: Bytes.Cursor & St) -> Maybe<&1, List<&1, Entry>>: Tar.decode (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=decode) # The entries in archive order. None for a bad header checksum, a malformed size or PAX record, # an entry or its padding cut short, a missing end (two zero blocks), or any type but file, # directory, and PAX records. Bytes after the end are ignored. # fuel: each header step eats a block, so len / 512 + 2 steps are enough. def decode(archive: Bytes.Bytes) -> Maybe<&1, List<&1, Entry>>: Tar.put.str (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=put.str) def put.str(s: String, a: Array, +j: U32) -> Array: Tar.oct.put (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=oct.put) # n octal digits of v ending at j, written back to front. def oct.put(n: Nat, a: Array, +j: U32, +v: U32) -> Array: Tar.dec.put (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=dec.put) # n decimal digits of v ending at j, written back to front. def dec.put(n: Nat, a: Array, +j: U32, +v: U32) -> Array: Tar.digits.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=digits.go) def digits.go(n: Nat, +v: U32, +c: U32) -> U32: Tar.digits (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=digits) # The count of decimal digits in v. def digits(+v: U32) -> U32: Tar.hdr.fields (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.fields) # mode, uid 0, gid 0, size, mtime 0, the checksum as spaces, type, and the POSIX ustar magic. def hdr.fields(+mode: U32, +size: U32, +t: U32, a: Array) -> Array: Tar.hdr.ck (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.ck) # Six octal digits, NUL, space: the last space stays from the fields. def hdr.ck(r: Array & U32) -> Array: Tar.hdr.of (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr.of) def hdr.of(+mode: U32, +size: U32, +t: U32, r: Array & Array) -> Array & Bytes.Bytes: Tar.hdr (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=hdr) # A header block named by the first n bytes of src, handing src back. def hdr(src: Array, +n: U32, +mode: U32, +size: U32, +t: U32) -> Array & Bytes.Bytes: Tar.blk (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=blk) # b with zero bytes up to the next whole block. Bytes past len are already 0, so only len and room grow. def blk(b: Bytes.Bytes) -> Bytes.Bytes: Tar.zeros (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=zeros) def zeros(b: Bytes.Bytes, +n: U32) -> Bytes.Bytes: Tar.rec.fin (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=rec.fin) def rec.fin(+l: U32, r: Array & Array) -> Array & Bytes.Bytes: Tar.rec.len (https://jend.leeeet.dev/definition.txt?path=bend-kit-tar@0.3.0.0/tar.bend&name=rec.len) # A PAX path record's length: nl + 7 plus its own digits, found as in POSIX pax. def rec.len(+nl: U32) -> U32: More: https://jend.leeeet.dev/packages/bend-kit-tar.txt?definitions_offset=100