diff --git a/lfs.c b/lfs.c index 395f8d52..cbb143d1 100644 --- a/lfs.c +++ b/lfs.c @@ -703,50 +703,57 @@ static inline void lfsr_tag_trim2( } // either an on-disk or in-device data pointer -typedef struct lfsr_data { - // - positive => in-device - // - negative => on-disk - // - zero => same for both, neat! - lfs_ssize_t size; - union { +typedef union lfsr_data { + // sign(size)=0 => in-device + // sign(size)=1 => on-disk + lfs_size_t size; + struct { + lfs_size_t size; const uint8_t *buffer; - struct { - lfs_block_t block; - lfs_off_t off; - } disk; - } u; + } buf; + struct { + lfs_size_t size; + lfs_block_t block; + lfs_off_t off; + } disk; + +// // - positive => in-device +// // - negative => on-disk +// // - zero => same for both, neat! +// lfs_ssize_t size; +// union { +// const uint8_t *buffer; +// struct { +// lfs_block_t block; +// lfs_off_t off; +// } disk; +// } u; } lfsr_data_t; #define LFSR_DATA_NULL \ - ((lfsr_data_t){.u.buffer=NULL, .size=0}) + ((lfsr_data_t){.size=0}) #define LFSR_DATA_BUF(_buffer, _size) \ - ((lfsr_data_t){.u.buffer=(const void*)(_buffer), .size=_size}) + ((lfsr_data_t){.buf={ \ + .size=_size, \ + .buffer=(const void*)(_buffer)}}) #define LFSR_DATA_DISK(_block, _off, _size) \ - ((lfsr_data_t){.u.disk.block=_block, .u.disk.off=_off, .size=-(_size)}) + ((lfsr_data_t){.disk={ \ + .size=(0x80000000 | (_size)), \ + .block=_block, \ + .off=_off}}) static inline bool lfsr_data_ondisk(lfsr_data_t data) { - return data.size < 0; -} - -static inline const uint8_t *lfsr_data_buffer(lfsr_data_t data) { - LFS_ASSERT(data.size >= 0); - return data.u.buffer; -} - -static inline lfs_block_t lfsr_data_block(lfsr_data_t data) { - LFS_ASSERT(data.size <= 0); - return data.u.disk.block; -} - -static inline lfs_off_t lfsr_data_off(lfsr_data_t data) { - LFS_ASSERT(data.size <= 0); - return data.u.disk.off; + return data.size & 0x80000000; } static inline lfs_size_t lfsr_data_size(lfsr_data_t data) { - return lfs_abs32(data.size); + return data.size & 0x7fffffff; +} + +static inline lfs_size_t lfsr_data_setondisk(lfs_size_t size) { + return size | 0x80000000; } @@ -772,18 +779,20 @@ typedef struct lfsr_attr { lfsr_data_t data; } lfsr_attr_t; +#define LFSR_ATTR_DATA_(_id, _tag, _delta, _data) \ + ((const lfsr_attr_t){_id, _tag, _delta, _data}) + +#define LFSR_ATTR_DATA(_id, _type, _delta, _data) \ + LFSR_ATTR_DATA_(_id, LFSR_TAG_##_type, _delta, _data) + #define LFSR_ATTR_(_id, _tag, _delta, _buffer, _size) \ - ((const lfsr_attr_t){ \ - _id, _tag, _delta, \ - LFSR_DATA_BUF(_buffer, _size)}) + LFSR_ATTR_DATA_(_id, _tag, _delta, LFSR_DATA_BUF(_buffer, _size)) #define LFSR_ATTR(_id, _type, _delta, _buffer, _size) \ LFSR_ATTR_(_id, LFSR_TAG_##_type, _delta, _buffer, _size) #define LFSR_ATTR_DISK_(_id, _tag, _delta, _block, _off, _size) \ - ((const lfsr_attr_t){ \ - _id, _tag, _delta, \ - LFSR_DATA_DISK(_block, _off, _size)}) + LFSR_ATTR_DATA_(_id, _tag, _delta, LFSR_DATA_DISK(_block, _off, _size)) #define LFSR_ATTR_DISK(_id, _type, _delta, _block, _off, _size) \ LFSR_ATTR_DISK_(_id, LFSR_TAG_##_type, _delta, _block, _off, _size) @@ -1497,8 +1506,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd, static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfs_ssize_t id, lfsr_tag_t tag, lfs_ssize_t *id_, lfsr_tag_t *tag_, lfs_size_t *weight_, - // TODO should this take lfsr_data_t for consistency? - lfs_off_t *off_, lfs_size_t *size_) { + lfsr_data_t *data_) { // keep track of bounds as we descend down the tree lfs_off_t branch = rbyd->trunk; lfs_ssize_t lower = -1; @@ -1560,13 +1568,9 @@ static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, if (weight_) { *weight_ = id__ - lower; } - if (off_) { - *off_ = branch + d; + if (data_) { + *data_ = LFSR_DATA_DISK(rbyd->block, branch + d, jump); } - if (size_) { - *size_ = jump; - } - return 0; } } @@ -1576,10 +1580,9 @@ static lfs_ssize_t lfsr_rbyd_get(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfs_ssize_t id, lfsr_tag_t tag, void *buffer, lfs_size_t size) { lfs_ssize_t id_; lfsr_tag_t tag_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; int err = lfsr_rbyd_lookup(lfs, rbyd, id, tag, - &id_, &tag_, NULL, &off_, &size_); + &id_, &tag_, NULL, &data_); if (err) { return err; } @@ -1591,15 +1594,15 @@ static lfs_ssize_t lfsr_rbyd_get(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } // TODO should this be its own lfsr_data_ function? - lfs_size_t d = lfs_min(size, size_); + lfs_size_t d = lfs_min(size, lfsr_data_size(data_)); err = lfs_bd_read(lfs, &lfs->pcache, &lfs->rcache, d, - rbyd->block, off_, buffer, d); + data_.disk.block, data_.disk.off, buffer, d); if (err) { return err; } - return size_; + return lfsr_data_size(data_); } // TODO this should be a bd operation of some sort @@ -1652,7 +1655,7 @@ static int lfsr_rbyd_progdata(lfs_t *lfs, lfsr_rbyd_t *rbyd_, for (lfs_size_t i = 0; i < lfsr_data_size(data); i++) { int err = lfs_bd_read(lfs, &lfs->pcache, &lfs->rcache, lfsr_data_size(data)-i, - data.u.disk.block, data.u.disk.off+i, &dat, 1); + data.disk.block, data.disk.off+i, &dat, 1); if (err) { return err; } @@ -1676,7 +1679,8 @@ static int lfsr_rbyd_progdata(lfs_t *lfs, lfsr_rbyd_t *rbyd_, } else { int err = lfs_bd_prog(lfs, &lfs->pcache, &lfs->rcache, false, - rbyd_->block, rbyd_->off, data.u.buffer, lfsr_data_size(data)); + rbyd_->block, rbyd_->off, + data.buf.buffer, lfsr_data_size(data)); if (err) { return err; } @@ -1686,7 +1690,7 @@ static int lfsr_rbyd_progdata(lfs_t *lfs, lfsr_rbyd_t *rbyd_, // lfsr_rbyd_commit? // optionally crc if (crc) { - *crc = lfs_crc32c(*crc, data.u.buffer, lfsr_data_size(data)); + *crc = lfs_crc32c(*crc, data.buf.buffer, lfsr_data_size(data)); } } @@ -2499,7 +2503,7 @@ static int lfsr_rbyd_cutoff(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfs_size_t count = 0; while (true) { int err = lfsr_rbyd_lookup(lfs, rbyd, id+1, 0, - &id, NULL, NULL, NULL, NULL); + &id, NULL, NULL, NULL); if (err && err != LFS_ERR_NOENT) { return err; } @@ -2529,10 +2533,9 @@ static lfs_ssize_t lfsr_rbyd_bisect(lfs_t *lfs, const lfsr_rbyd_t *rbyd) { lfs_ssize_t id = 0; lfs_size_t dsize = 0; while (true) { - lfs_size_t size; - int err = lfsr_rbyd_lookup(lfs, rbyd, - id, lfsr_tag_next(tag), - &id, &tag, NULL, NULL, &size); + lfsr_data_t data_; + int err = lfsr_rbyd_lookup(lfs, rbyd, id, lfsr_tag_next(tag), + &id, &tag, NULL, &data_); if (err && err != LFS_ERR_NOENT) { return err; } @@ -2541,7 +2544,7 @@ static lfs_ssize_t lfsr_rbyd_bisect(lfs_t *lfs, const lfsr_rbyd_t *rbyd) { } // assume worst case tag encoding so many small tags aren't missed - dsize += LFSR_TAG_DSIZE + size; + dsize += LFSR_TAG_DSIZE + lfsr_data_size(data_); } // traverse again to find the actual midpoint, @@ -2549,16 +2552,15 @@ static lfs_ssize_t lfsr_rbyd_bisect(lfs_t *lfs, const lfsr_rbyd_t *rbyd) { id = 0; lfs_size_t bsize = 0; while (true) { - lfs_size_t size; - int err = lfsr_rbyd_lookup(lfs, rbyd, - id, lfsr_tag_next(tag), - &id, &tag, NULL, NULL, &size); + lfsr_data_t data_; + int err = lfsr_rbyd_lookup(lfs, rbyd, id, lfsr_tag_next(tag), + &id, &tag, NULL, &data_); if (err) { return err; } // assume worst case tag encoding so many small tags aren't missed - bsize += LFSR_TAG_DSIZE + size; + bsize += LFSR_TAG_DSIZE + lfsr_data_size(data_); if (bsize >= dsize/2) { // well this shouldn't happen unless attr limits have gone wrong @@ -2618,6 +2620,7 @@ static lfs_ssize_t lfsr_branch_todisk( return d; } +// TODO should our fromdisk functions accept an lfsr_data_t? static lfs_ssize_t lfsr_branch_fromdisk( lfsr_rbyd_t *branch, lfs_size_t weight, @@ -2653,8 +2656,8 @@ static lfs_ssize_t lfsr_branch_fromdisk( static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs, const lfsr_btree_t *btree, lfs_size_t bid, lfs_size_t *bid_, lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_, - lfsr_tag_t *tag_, lfs_size_t *weight_, - void *buffer, lfs_size_t size, bool validate) { + lfsr_tag_t *tag_, lfs_size_t *weight_, lfsr_data_t *data_, + bool validate) { // in range? if (bid >= lfsr_btree_weight(btree)) { return LFS_ERR_NOENT; @@ -2672,10 +2675,10 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs, if (weight_) { *weight_ = lfsr_btree_weight(btree); } - - memcpy(buffer, btree->inlined.buffer, - lfs_min(size, btree->inlined.size)); - return btree->inlined.size; + if (data_) { + *data_ = LFSR_DATA_BUF(btree->inlined.buffer, btree->inlined.size); + } + return 0; } // descend down the btree looking for our bid @@ -2723,10 +2726,9 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs, lfs_ssize_t rid__; lfsr_tag_t tag__; lfs_size_t weight__; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data__; int err = lfsr_rbyd_lookup(lfs, &branch, rid, 0, - &rid__, &tag__, &weight__, &off_, &size_); + &rid__, &tag__, &weight__, &data__); if (err) { return err; } @@ -2734,7 +2736,7 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs, if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { // TODO what if we don't find a struct? ENOENT? err = lfsr_rbyd_lookup(lfs, &branch, rid__, LFSR_TAG_STRUCT, - NULL, &tag__, NULL, &off_, &size_); + NULL, &tag__, NULL, &data__); if (err) { return err; } @@ -2747,10 +2749,10 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs, // fetch the next branch uint8_t buf[LFSR_BRANCH_DSIZE]; - lfs_ssize_t d = lfs_min(LFSR_BRANCH_DSIZE, size_); + lfs_ssize_t d = lfs_min(LFSR_BRANCH_DSIZE, lfsr_data_size(data__)); err = lfs_bd_read(lfs, &lfs->pcache, &lfs->rcache, d, - branch.block, off_, buf, d); + data__.disk.block, data__.disk.off, buf, d); if (err) { return err; } @@ -2778,17 +2780,10 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs, if (weight_) { *weight_ = weight__; } - - // TODO should we make sure this is a noop if buffer size is zero? - lfs_ssize_t d = lfs_min(size, size_); - err = lfs_bd_read(lfs, - &lfs->pcache, &lfs->rcache, d, - branch.block, off_, buffer, d); - if (err) { - return err; + if (data_) { + *data_ = data__; } - - return size_; + return 0; } } } @@ -2813,10 +2808,9 @@ static int lfsr_btree_parent(lfs_t *lfs, lfs_ssize_t rid__; lfsr_tag_t tag__; lfs_size_t weight__; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; int err = lfsr_rbyd_lookup(lfs, &branch, rid, 0, - &rid__, &tag__, &weight__, &off_, &size_); + &rid__, &tag__, &weight__, &data_); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); return err; @@ -2825,7 +2819,7 @@ static int lfsr_btree_parent(lfs_t *lfs, if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { // TODO what if we don't find a struct? ENOENT? err = lfsr_rbyd_lookup(lfs, &branch, rid__, LFSR_TAG_STRUCT, - NULL, &tag__, NULL, &off_, &size_); + NULL, &tag__, NULL, &data_); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); return err; @@ -2842,10 +2836,10 @@ static int lfsr_btree_parent(lfs_t *lfs, // fetch the next branch uint8_t buf[LFSR_BRANCH_DSIZE]; - lfs_ssize_t d = lfs_min(LFSR_BRANCH_DSIZE, size_); + lfs_ssize_t d = lfs_min(LFSR_BRANCH_DSIZE, lfsr_data_size(data_)); err = lfs_bd_read(lfs, &lfs->pcache, &lfs->rcache, d, - branch.block, off_, buf, d); + data_.disk.block, data_.disk.off, buf, d); if (err) { return err; } @@ -2875,20 +2869,38 @@ static int lfsr_btree_parent(lfs_t *lfs, // TODO do we really need this? // TODO why doesn't this match lookup/get in rbyd? static lfs_ssize_t lfsr_btree_get(lfs_t *lfs, - const lfsr_btree_t *btree, lfs_size_t id, - lfs_size_t *id_, lfsr_tag_t *tag_, lfs_size_t *weight_, - void *buffer, lfs_size_t size, bool validate) { - return lfsr_btree_lookup(lfs, btree, id, - id_, NULL, NULL, tag_, weight_, - buffer, size, validate); + const lfsr_btree_t *btree, lfs_size_t bid, + lfs_size_t *bid_, lfsr_tag_t *tag_, lfs_size_t *weight_, + void *buffer, lfs_size_t size, + bool validate) { + lfsr_data_t data_; + int err = lfsr_btree_lookup(lfs, btree, bid, + bid_, NULL, NULL, tag_, weight_, &data_, + validate); + if (err) { + return err; + } + + // TODO we should have a function for this + lfs_size_t d = lfs_min(size, lfsr_data_size(data_)); + if (!lfsr_data_ondisk(data_)) { + memcpy(buffer, data_.buf.buffer, d); + } else { + err = lfs_bd_read(lfs, + &lfs->pcache, &lfs->rcache, d, + data_.disk.block, data_.disk.off, buffer, d); + if (err) { + return err; + } + } + + return lfsr_data_size(data_); } static lfs_ssize_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree, const char *name, lfs_size_t name_size, - lfs_size_t *bid_, - lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_, - lfsr_tag_t *tag_, lfs_size_t *weight_, - void *buffer, lfs_size_t size) { + lfs_size_t *bid_, lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_, + lfsr_tag_t *tag_, lfs_size_t *weight_, lfsr_data_t *data_) { // an empty tree? if (lfsr_btree_weight(btree) == 0) { return LFS_ERR_NOENT; @@ -2906,10 +2918,10 @@ static lfs_ssize_t lfsr_btree_namelookup(lfs_t *lfs, if (weight_) { *weight_ = lfsr_btree_weight(btree); } - - memcpy(buffer, btree->inlined.buffer, - lfs_min(size, btree->inlined.size)); - return btree->inlined.size; + if (data_) { + *data_ = LFSR_DATA_BUF(btree->inlined.buffer, btree->inlined.size); + } + return 0; } // descend down the btree looking for our name @@ -2957,14 +2969,13 @@ static lfs_ssize_t lfsr_btree_namelookup(lfs_t *lfs, // the find may not match exactly, but it will indicate which id we // should follow - // TODO can we actually get weight in follow? + // TODO can we actually get weight in find? lfsr_tag_t tag__; lfs_ssize_t rid__; lfs_size_t weight__; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data__; err = lfsr_rbyd_lookup(lfs, &branch, find.found_id, 0, - &rid__, &tag__, &weight__, &off_, &size_); + &rid__, &tag__, &weight__, &data__); if (err) { return err; } @@ -2972,7 +2983,7 @@ static lfs_ssize_t lfsr_btree_namelookup(lfs_t *lfs, if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { // TODO what if we don't find a struct? ENOENT? err = lfsr_rbyd_lookup(lfs, &branch, rid__, LFSR_TAG_STRUCT, - NULL, &tag__, NULL, &off_, &size_); + NULL, &tag__, NULL, &data__); if (err) { return err; } @@ -2985,10 +2996,10 @@ static lfs_ssize_t lfsr_btree_namelookup(lfs_t *lfs, // fetch the next branch uint8_t buf[LFSR_BRANCH_DSIZE]; - lfs_ssize_t d = lfs_min(LFSR_BRANCH_DSIZE, size_); + lfs_ssize_t d = lfs_min(LFSR_BRANCH_DSIZE, lfsr_data_size(data__)); err = lfs_bd_read(lfs, &lfs->pcache, &lfs->rcache, d, - branch.block, off_, buf, d); + data__.disk.block, data__.disk.off, buf, d); if (err) { return err; } @@ -3016,17 +3027,10 @@ static lfs_ssize_t lfsr_btree_namelookup(lfs_t *lfs, if (weight_) { *weight_ = weight__; } - - // TODO should we make sure this is a noop if buffer size is zero? - lfs_ssize_t d = lfs_min(size, size_); - err = lfs_bd_read(lfs, - &lfs->pcache, &lfs->rcache, d, - branch.block, off_, buffer, d); - if (err) { - return err; + if (data_) { + *data_ = data__; } - - return size_; + return 0; } } } @@ -3035,9 +3039,27 @@ static lfs_ssize_t lfsr_btree_nameget(lfs_t *lfs, const lfsr_btree_t *btree, const char *name, lfs_size_t name_size, lfs_size_t *bid_, lfsr_tag_t *tag_, lfs_size_t *weight_, void *buffer, lfs_size_t size) { - return lfsr_btree_namelookup(lfs, btree, name, name_size, - bid_, NULL, NULL, tag_, weight_, - buffer, size); + lfsr_data_t data_; + int err = lfsr_btree_namelookup(lfs, btree, name, name_size, + bid_, NULL, NULL, tag_, weight_, &data_); + if (err) { + return err; + } + + // TODO we should have a function for this + lfs_size_t d = lfs_min(size, lfsr_data_size(data_)); + if (!lfsr_data_ondisk(data_)) { + memcpy(buffer, data_.buf.buffer, d); + } else { + err = lfs_bd_read(lfs, + &lfs->pcache, &lfs->rcache, d, + data_.disk.block, data_.disk.off, buffer, d); + if (err) { + return err; + } + } + + return lfsr_data_size(data_); } @@ -3143,10 +3165,9 @@ static int lfsr_btree_commit(lfs_t *lfs, lfsr_tag_t tag = 0; lfs_ssize_t id = 0; while (true) { - lfs_off_t off; - lfs_size_t size; + lfsr_data_t data; err = lfsr_rbyd_lookup(lfs, rbyd, id, lfsr_tag_next(tag), - &id, &tag, NULL, &off, &size); + &id, &tag, NULL, &data); if (err && err != LFS_ERR_NOENT) { return err; } @@ -3176,7 +3197,7 @@ static int lfsr_btree_commit(lfs_t *lfs, err = lfsr_rbyd_append(lfs, &rbyd_, id-lfs_smax32(weight-1, 0), lfsr_tag_setmk(tag), +weight, - LFSR_DATA_DISK(rbyd->block, off, size)); + data); if (err) { return err; } @@ -3310,11 +3331,10 @@ static int lfsr_btree_commit(lfs_t *lfs, lfsr_tag_t tag = 0; lfs_ssize_t id = bisect; while (true) { - lfs_off_t off; - lfs_size_t size; lfs_size_t weight; + lfsr_data_t data; err = lfsr_rbyd_lookup(lfs, rbyd, id, lfsr_tag_next(tag), - &id, &tag, &weight, &off, &size); + &id, &tag, &weight, &data); if (err && err != LFS_ERR_NOENT) { return err; } @@ -3326,7 +3346,7 @@ static int lfsr_btree_commit(lfs_t *lfs, err = lfsr_rbyd_append(lfs, &sibling, id-bisect-lfs_smax32(weight-1, 0), lfsr_tag_setmk(tag), +weight, - LFSR_DATA_DISK(rbyd->block, off, size)); + data); if (err) { return err; } @@ -3364,10 +3384,9 @@ static int lfsr_btree_commit(lfs_t *lfs, // they introduce a new name! lfsr_tag_t stag; lfs_ssize_t sid; - lfs_off_t soff; - lfs_size_t ssize; + lfsr_data_t sdata; err = lfsr_rbyd_lookup(lfs, &sibling, 0, LFSR_TAG_NAME, - &sid, &stag, NULL, &soff, &ssize); + &sid, &stag, NULL, &sdata); if (err && err != LFS_ERR_NOENT) { return err; } @@ -3396,9 +3415,9 @@ static int lfsr_btree_commit(lfs_t *lfs, attrs[0] = LFSR_ATTR(0, MKBRANCH, +rbyd_.weight, scratch_buf1, d1); if (lfsr_tag_suptype(stag) == LFSR_TAG_NAME) { - attrs[1] = LFSR_ATTR_DISK( + attrs[1] = LFSR_ATTR_DATA( rbyd_.weight, MKBNAME, +sibling.weight, - sibling.block, soff, ssize); + sdata); attrs[2] = LFSR_ATTR( 0+rbyd_.weight+sibling.weight-1, BRANCH, 0, scratch_buf2, d2); @@ -3419,10 +3438,9 @@ static int lfsr_btree_commit(lfs_t *lfs, pid-(pweight-1)+rbyd_.weight-1, BRANCH, 0, scratch_buf1, d1); if (lfsr_tag_suptype(stag) == LFSR_TAG_NAME) { - attrs[2] = LFSR_ATTR_DISK( - pid-(pweight-1)+rbyd_.weight, MKBNAME, - +sibling.weight, - sibling.block, soff, ssize); + attrs[2] = LFSR_ATTR_DATA( + pid-(pweight-1)+rbyd_.weight, MKBNAME, +sibling.weight, + sdata); attrs[3] = LFSR_ATTR( pid-(pweight-1)+rbyd_.weight+sibling.weight-1, BRANCH, 0, @@ -3466,7 +3484,7 @@ static int lfsr_btree_commit(lfs_t *lfs, // try looking up the sibling lfs_size_t sweight; err = lfsr_rbyd_lookup(lfs, &parent, sid, LFSR_TAG_NAME, - &sid, NULL, &sweight, NULL, NULL); + &sid, NULL, &sweight, NULL); if (err && err != LFS_ERR_NOENT) { return err; } @@ -3476,10 +3494,8 @@ static int lfsr_btree_commit(lfs_t *lfs, goto merge_abort; } - lfs_off_t off; - lfs_size_t size; err = lfsr_rbyd_lookup(lfs, &parent, sid, LFSR_TAG_BRANCH, - NULL, &stag, NULL, &off, &size); + NULL, &stag, NULL, &sdata); if (err && err != LFS_ERR_NOENT) { return err; } @@ -3490,10 +3506,10 @@ static int lfsr_btree_commit(lfs_t *lfs, } uint8_t buf[LFSR_BRANCH_DSIZE]; - d = lfs_min(LFSR_BRANCH_DSIZE, size); + d = lfs_min(LFSR_BRANCH_DSIZE, lfsr_data_size(sdata)); err = lfs_bd_read(lfs, &lfs->pcache, &lfs->rcache, d, - parent.block, off, buf, d); + sdata.disk.block, sdata.disk.off, buf, d); if (err) { return err; } @@ -3509,8 +3525,9 @@ static int lfsr_btree_commit(lfs_t *lfs, id = 0; while (true) { lfs_size_t weight; + lfsr_data_t data; err = lfsr_rbyd_lookup(lfs, &sibling, id, lfsr_tag_next(tag), - &id, &tag, &weight, &off, &size); + &id, &tag, &weight, &data); if (err && err != LFS_ERR_NOENT) { return err; } @@ -3522,7 +3539,7 @@ static int lfsr_btree_commit(lfs_t *lfs, err = lfsr_rbyd_append(lfs, &rbyd_, sdelta+id-lfs_smax32(weight-1, 0), lfsr_tag_setmk(tag), +weight, - LFSR_DATA_DISK(sibling.block, off, size)); + data); if (err) { return err; } @@ -3544,11 +3561,10 @@ static int lfsr_btree_commit(lfs_t *lfs, // bring in name that previously split the siblings lfsr_tag_t split_tag; - lfs_off_t split_off; - lfs_size_t split_size; + lfsr_data_t split_data; err = lfsr_rbyd_lookup(lfs, &parent, (sdelta == 0 ? pid : sid), LFSR_TAG_NAME, - NULL, &split_tag, NULL, &split_off, &split_size); + NULL, &split_tag, NULL, &split_data); if (err) { return err; } @@ -3559,14 +3575,14 @@ static int lfsr_btree_commit(lfs_t *lfs, lfs_ssize_t split_id; err = lfsr_rbyd_lookup(lfs, &rbyd_, (sdelta == 0 ? sweight : rweight_), LFSR_TAG_NAME, - &split_id, NULL, NULL, NULL, NULL); + &split_id, NULL, NULL, NULL); if (err) { return err; } err = lfsr_rbyd_append(lfs, &rbyd_, split_id, LFSR_TAG_BNAME, 0, - LFSR_DATA_DISK(parent.block, split_off, split_size)); + split_data); if (err) { return err; } @@ -3674,10 +3690,11 @@ static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree, lfsr_rbyd_t rbyd = btree->root; lfs_ssize_t rid = -1; lfs_size_t rweight = 0; - lfs_ssize_t rsize = lfsr_btree_lookup(lfs, btree, bid_, - NULL, &rbyd, &rid, NULL, &rweight, NULL, 0, false); - if (rsize < 0 && rsize != LFS_ERR_NOENT) { - return rsize; + int err = lfsr_btree_lookup(lfs, btree, bid_, + NULL, &rbyd, &rid, NULL, &rweight, NULL, + false); + if (err && err != LFS_ERR_NOENT) { + return err; } // adjust rid for push @@ -3737,10 +3754,11 @@ static int lfsr_btree_update(lfs_t *lfs, lfsr_btree_t *btree, lfsr_tag_t rtag; lfs_ssize_t rid; lfs_size_t rweight; - lfs_ssize_t rsize = lfsr_btree_lookup(lfs, btree, bid, - NULL, &rbyd, &rid, &rtag, &rweight, NULL, 0, false); - if (rsize < 0) { - return rsize; + int err = lfsr_btree_lookup(lfs, btree, bid, + NULL, &rbyd, &rid, &rtag, &rweight, NULL, + false); + if (err) { + return err; } // commit our id into the tree, letting lfsr_btree_commit take care @@ -3787,10 +3805,11 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t bid) { lfsr_tag_t rtag; lfs_ssize_t rid; lfs_size_t rweight; - lfs_ssize_t rsize = lfsr_btree_lookup(lfs, btree, bid, - NULL, &rbyd, &rid, &rtag, &rweight, NULL, 0, false); - if (rsize < 0) { - return rsize; + int err = lfsr_btree_lookup(lfs, btree, bid, + NULL, &rbyd, &rid, &rtag, &rweight, NULL, + false); + if (err) { + return err; } // remove our id, letting lfsr_btree_commit take care @@ -3819,10 +3838,9 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t bid) { lfsr_tag_t stag; lfs_size_t sweight; - lfs_off_t off; - lfs_size_t size; + lfsr_data_t sdata; int err = lfsr_rbyd_lookup(lfs, &rbyd, sid, LFSR_TAG_NAME, - &sid, &stag, &sweight, &off, &size); + &sid, &stag, &sweight, &sdata); if (err) { return err; } @@ -3830,7 +3848,7 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t bid) { if (lfsr_tag_suptype(stag) == LFSR_TAG_NAME) { // TODO what if we don't find a struct? ENOENT? err = lfsr_rbyd_lookup(lfs, &rbyd, sid, LFSR_TAG_STRUCT, - NULL, &stag, NULL, &off, &size); + NULL, &stag, NULL, &sdata); if (err) { return err; } @@ -3840,14 +3858,15 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t bid) { btree->weight = lfsr_btree_setinlined(sweight); btree->inlined.tag = stag; - LFS_ASSERT(size <= LFSR_BTREE_INLINESIZE); + LFS_ASSERT(lfsr_data_size(sdata) <= LFSR_BTREE_INLINESIZE); err = lfs_bd_read(lfs, - &lfs->pcache, &lfs->rcache, size, - rbyd.block, off, btree->inlined.buffer, size); + &lfs->pcache, &lfs->rcache, lfsr_data_size(sdata), + sdata.disk.block, sdata.disk.off, + btree->inlined.buffer, lfsr_data_size(sdata)); if (err) { return err; } - btree->inlined.size = size; + btree->inlined.size = lfsr_data_size(sdata); // revert to a null btree } else if (degenerate) { @@ -3903,10 +3922,11 @@ static int lfsr_btree_split(lfs_t *lfs, lfsr_btree_t *btree, lfsr_rbyd_t rbyd; lfs_ssize_t rid; lfs_size_t rweight; - lfs_ssize_t rsize = lfsr_btree_lookup(lfs, btree, bid, - NULL, &rbyd, &rid, NULL, &rweight, NULL, 0, false); - if (rsize < 0) { - return rsize; + int err = lfsr_btree_lookup(lfs, btree, bid, + NULL, &rbyd, &rid, NULL, &rweight, NULL, + false); + if (err) { + return err; } // commit our bid into the tree, letting lfsr_btree_commit take care diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 9eada54e..40e43368 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -141,8 +141,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // try an empty commit rbyd = init_rbyd; @@ -150,11 +149,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, NULL, 0) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with one attribute rbyd = init_rbyd; @@ -163,21 +162,21 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; @@ -187,31 +186,31 @@ code = ''' LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; @@ -221,31 +220,31 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_lookup] @@ -265,8 +264,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // try an empty commit rbyd = init_rbyd; @@ -274,11 +272,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, NULL, 0) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with one attribute rbyd = init_rbyd; @@ -287,21 +285,21 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; @@ -312,31 +310,31 @@ code = ''' LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; @@ -347,31 +345,31 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_get] @@ -577,8 +575,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // create a split in the leaves // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // split the other direction // >b @@ -614,15 +611,15 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_bflips] @@ -642,8 +639,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // ignore a black edge // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // flip a black edge // b @@ -681,15 +677,15 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_trifoliate] @@ -709,8 +705,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // ignore a black edge // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // flip a black edge // >r @@ -757,20 +752,20 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_rflips] @@ -790,8 +785,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // ignore a red edge and black edge // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // ignore a red edge, flip a black edge // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // flip a red edge and black edge // r @@ -871,20 +865,20 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // flip a red edge, ignore a black edge // r @@ -902,20 +896,20 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_quadrifoliate] @@ -935,8 +929,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // ignore a red edge and black edge // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // ignore a red edge, flip a black edge // y @@ -994,25 +987,25 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // flip a red edge and black edge // >y @@ -1032,25 +1025,25 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // flip a red edge, ignore a black edge // >y @@ -1070,25 +1063,25 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_rotations] @@ -1108,8 +1101,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // all three the same // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // yellow and red alt the same // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // yellow and black alt the same // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // red and black alt the same // >y 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_ysplits] @@ -1281,8 +1273,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // split a yellow triple, not taking any alt // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the black alt // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the red alt // b @@ -1385,25 +1376,25 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the yellow alt // b @@ -1424,25 +1415,25 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_quintifoliate] @@ -1462,8 +1453,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // split a yellow triple, not taking any alt // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the black alt // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the red alt // >b @@ -1582,30 +1572,30 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the yellow alt // >b @@ -1628,30 +1618,30 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_prunes] @@ -1671,8 +1661,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // don't prune // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // prune by taking a red alt // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // prune by taking a yellow alt (this needs to prune during the rflip) // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_sextifoliate] @@ -1839,8 +1828,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // don't prune // 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(6), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(6)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // prune by taking a red alt // b @@ -1922,35 +1910,35 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(6), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(6)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // prune by taking a yellow alt (this needs to prune during the rflip) // b @@ -1976,35 +1964,35 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(6), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(6)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_permutations] @@ -2028,8 +2016,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // keep track of the worst case log size lfs_size_t worst_size = 0; @@ -2070,10 +2057,10 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } // keep track of the worst size @@ -2121,8 +2108,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // keep track of the worst case log size lfs_size_t worst_size = 0; @@ -2159,10 +2145,10 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } // keep track of the worst size @@ -2204,8 +2190,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // traverse requires correct biasing of the weights in the rbyd tree // so that lookups return strictly the tag greater than or equal to @@ -2217,31 +2202,31 @@ code = ''' LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -2251,31 +2236,31 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_traverse] @@ -2295,8 +2280,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // traverse requires correct biasing of the weights in the rbyd tree // so that lookups return strictly the tag greater than or equal to @@ -2309,31 +2293,31 @@ code = ''' LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -2344,31 +2328,31 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_traverse_permutations] @@ -2392,8 +2376,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -2433,13 +2416,13 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -2466,8 +2449,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -2504,13 +2486,13 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -2539,8 +2521,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // keep track of the worst case log size lfs_size_t worst_size = 0; @@ -2598,10 +2579,10 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); - assert(size_ == 6); + assert(lfsr_data_size(data_) == 6); } // keep track of the worst size @@ -2651,8 +2632,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // create the rbyd tree rbyd = init_rbyd; @@ -2688,10 +2668,10 @@ code = ''' : (ORDER == 1) ? (uint8_t)(((lfs_size_t)-1) - i) : (uint8_t)TEST_PRNG(&prng); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(x), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(x)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } ''' @@ -2715,8 +2695,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // add and remove one attribute rbyd = init_rbyd; @@ -2727,15 +2706,15 @@ code = ''' LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, remove the first one rbyd = init_rbyd; @@ -2747,31 +2726,31 @@ code = ''' LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, remove the second one rbyd = init_rbyd; @@ -2783,25 +2762,25 @@ code = ''' LFSR_ATTR(-1, RMUATTR(2), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' # NOTE if we separate physical/logical block sizes we may be able to @@ -2829,8 +2808,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // keep track of the worst case log size lfs_size_t worst_size = 0; @@ -2890,7 +2868,7 @@ code = ''' for (unsigned k = 0; k < N; k++) { int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(k+1), - &id_, &tag_, NULL, &off_, &size_); + &id_, &tag_, NULL, &data_); assert(!err || err == LFS_ERR_NOENT); if (k == j) { if (j == N-1) { @@ -2899,12 +2877,12 @@ code = ''' assert(!err); assert(tag_ == LFSR_TAG_UATTR(j+1+1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } } else { assert(tag_ == LFSR_TAG_UATTR(k+1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } } @@ -2920,15 +2898,15 @@ code = ''' for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(k+1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; if (k == j) { assert(tag_ == LFSR_TAG_UATTR(k+1)); assert(id_ == -1); - assert(size_ == 6); + assert(lfsr_data_size(data_) == 6); } else { assert(tag_ == LFSR_TAG_UATTR(k+1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } } @@ -2983,8 +2961,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -3042,20 +3019,20 @@ code = ''' id_ = -1; for (unsigned k = 0; k < N-1; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; if (k >= j) { assert(tag_ == LFSR_TAG_UATTR(k+1+1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } else { assert(tag_ == LFSR_TAG_UATTR(k+1)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } // cleanup @@ -3080,8 +3057,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // create a tree two attributes rbyd = init_rbyd; @@ -3090,128 +3066,128 @@ code = ''' LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4), LFSR_ATTR(-1, UATTR(4), 0, "\xdd\xdd\xdd\xdd", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // try to remove tags that aren't there, this should do nothing lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(3), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(5), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // one last fetch to make sure nothing was broken lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_remove_again] @@ -3231,8 +3207,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // create a tree rbyd = init_rbyd; @@ -3250,205 +3225,205 @@ code = ''' LFSR_ATTR(-1, RMUATTR(5), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // try to remove tags that aren't there, this should do nothing lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(3), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(5), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // try to remove the tags again, just to make sure (keep in mind // these removes still commit to the rbyd) lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(3), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(5), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // one last fetch to make sure nothing was broken lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_remove_all] @@ -3468,8 +3443,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // commit with one attribute, remove it rbyd = init_rbyd; @@ -3480,15 +3454,15 @@ code = ''' LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, remove both rbyd = init_rbyd; @@ -3501,15 +3475,15 @@ code = ''' LFSR_ATTR(-1, RMUATTR(2), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, remove both in the other order rbyd = init_rbyd; @@ -3522,15 +3496,15 @@ code = ''' LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' # NOTE if we separate physical/logical block sizes we may be able to @@ -3558,8 +3532,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // keep track of the worst case log size lfs_size_t worst_size = 0; @@ -3616,7 +3589,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } // try resuming from all tags being removed @@ -3626,13 +3599,13 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); - assert(size_ == 6); + assert(lfsr_data_size(data_) == 6); for (unsigned j = 1; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } // keep track of the worst size @@ -4329,8 +4302,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // traverse requires correct biasing of the weights in the rbyd tree @@ -4343,39 +4315,39 @@ code = ''' LFSR_ATTR(1, MKREG, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -4385,39 +4357,39 @@ code = ''' LFSR_ATTR(0, MKREG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_create_traverse] @@ -4437,8 +4409,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // traverse requires correct biasing of the weights in the rbyd tree @@ -4452,39 +4423,39 @@ code = ''' LFSR_ATTR(1, MKREG, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -4495,39 +4466,39 @@ code = ''' LFSR_ATTR(0, MKREG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_create_traverse_permutations] @@ -4559,8 +4530,7 @@ code = ''' }; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -4609,16 +4579,16 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == j); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -4653,8 +4623,7 @@ code = ''' }; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -4699,16 +4668,16 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == j); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -4772,15 +4741,14 @@ code = ''' // note with random order we can't check that stored values reliably lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { lfsr_rbyd_lookup(&lfs, &rbyd, x, LFSR_TAG_REG, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == x); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } ''' @@ -5521,8 +5489,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // traverse requires correct biasing of the weights in the rbyd tree @@ -5537,67 +5504,67 @@ code = ''' LFSR_ATTR(1, UATTR(1), 0, "\xbb\xbb", 2))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -5609,67 +5576,67 @@ code = ''' LFSR_ATTR(0, UATTR(1), 0, "\xaa\xaa", 2))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_mixed_traverse] @@ -5689,8 +5656,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // traverse requires correct biasing of the weights in the rbyd tree @@ -5708,67 +5674,67 @@ code = ''' LFSR_ATTR(1, UATTR(1), 0, "\xbb\xbb", 2))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -5783,67 +5749,67 @@ code = ''' LFSR_ATTR(0, UATTR(1), 0, "\xaa\xaa", 2))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_mixed_traverse_permutations] @@ -5876,8 +5842,7 @@ code = ''' }; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -5932,27 +5897,27 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == j); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == j); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, names[j % 6], 2) == 0); } } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -5988,8 +5953,7 @@ code = ''' }; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -6041,27 +6005,27 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == j); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == j); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, names[j % 6], 2) == 0); } } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -6228,8 +6192,7 @@ code = ''' lfsr_rbyd_t rbyd; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // keep track of the worst case log size @@ -6306,7 +6269,7 @@ code = ''' for (unsigned u = 0; u < M; u++) { int err = lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_UATTR(u+1), - &id_, &tag_, NULL, &off_, &size_); + &id_, &tag_, NULL, &data_); assert(!err || err == LFS_ERR_NOENT); if (k == j/M && u == j%M) { if (u == M-1 && k == N-1) { @@ -6315,17 +6278,17 @@ code = ''' assert(!err); assert(tag_ == LFSR_TAG_REG); assert(id_ == k+1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } else { assert(!err); assert(tag_ == LFSR_TAG_UATTR(u+1+1)); assert(id_ == k); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); } } else { assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == k); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, names[k % 6], 2) == 0); @@ -6347,18 +6310,18 @@ code = ''' for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_UATTR(u+1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; if (k == j/M && u == j%M) { assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == k); - assert(size_ == 3); + assert(lfsr_data_size(data_) == 3); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 3; assert(memcmp(buffer, names[k % 6], 3) == 0); } else { assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == k); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, names[k % 6], 2) == 0); @@ -6590,22 +6553,21 @@ code = ''' // note with random order we can't check that stored values reliably lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { lfsr_rbyd_lookup(&lfs, &rbyd, x, LFSR_TAG_REG, - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == x); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, x, LFSR_TAG_UATTR(u+1), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == x); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); } } ''' @@ -6706,30 +6668,29 @@ code = ''' // try traversing tags lfsr_tag_t tag_ = 0; lfs_ssize_t id_ = -1; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); - assert(size_ == 1); + assert(lfsr_data_size(data_) == 1); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 1; assert(memcmp(buffer, names[j % 6], 1) == 0); } for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == j); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // keep track of the worst size if (rbyd.off > worst_size) { @@ -6857,41 +6818,40 @@ code = ''' // try traversing tags lfsr_tag_t tag_ = 0; lfs_ssize_t id_ = -1; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); - assert(size_ == 1); + assert(lfsr_data_size(data_) == 1); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 1; assert(memcmp(buffer, names[j % 6], 1) == 0); } for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == j); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == j); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; assert(memcmp(buffer, names[j % 6], 2) == 0); } } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // keep track of the worst size if (rbyd.off > worst_size) { @@ -7667,8 +7627,7 @@ code = ''' }; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -7738,10 +7697,10 @@ code = ''' id_ = -1; for (unsigned k = 0; k < N-1; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; if (k >= j) { @@ -7752,7 +7711,7 @@ code = ''' } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } // cleanup @@ -7794,8 +7753,7 @@ code = ''' }; lfsr_tag_t tag_; lfs_ssize_t id_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -7871,10 +7829,10 @@ code = ''' id_ = -1; for (unsigned k = 0; k < N-1; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; if (k >= j) { @@ -7885,10 +7843,10 @@ code = ''' for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => 0; + &id_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == k); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; if (k >= j) { @@ -7900,7 +7858,7 @@ code = ''' } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } // cleanup @@ -8616,8 +8574,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // make id0 with weight w1 rbyd = init_rbyd; @@ -8626,215 +8583,215 @@ code = ''' LFSR_ATTR(0, MKREG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // make id2 with weight w2 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(1, MKREG, +2, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // make id5 with weight w3 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(3, MKREG, +3, "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // make id9 with weight w4 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(6, MKREG, +4, "\xdd\xdd\xdd\xdd", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); // make id14 with weight w5 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(10, MKREG, +5, "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 14, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 14, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); ''' [cases.test_rbyd_grow_traverse] @@ -8855,8 +8812,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; @@ -8874,71 +8830,71 @@ code = ''' // traverse, finding tags and weights lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_grow_permutations] @@ -8974,8 +8930,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -9017,11 +8972,11 @@ code = ''' assert(rbyd.weight == N*W); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == j*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); @@ -9062,8 +9017,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -9108,17 +9062,17 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == j*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; } ''' @@ -9141,8 +9095,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; // make id0 with weight w1 rbyd = init_rbyd; @@ -9154,55 +9107,55 @@ code = ''' LFSR_ATTR(0, UATTR(2), 0, "\xaa\xaa", 2))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); // make id2 with weight w2 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -9212,91 +9165,91 @@ code = ''' LFSR_ATTR(2, UATTR(2), 0, "\xbb\xbb", 2))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); // make id5 with weight w3 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -9306,127 +9259,127 @@ code = ''' LFSR_ATTR(5, UATTR(2), 0, "\xcc\xcc", 2))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); // make id9 with weight w4 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -9436,163 +9389,163 @@ code = ''' LFSR_ATTR(9, UATTR(2), 0, "\xdd\xdd", 2))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); // make id14 with weight w5 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -9602,199 +9555,199 @@ code = ''' LFSR_ATTR(14, UATTR(2), 0, "\xee\xee", 2))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 14, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 14, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 14); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 14, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 14); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 9, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 14, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, 14, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 14); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 14, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 14); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); ''' [cases.test_rbyd_mixed_grow_traverse] @@ -9815,8 +9768,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; @@ -9849,203 +9801,203 @@ code = ''' // traverse, finding tags and weights lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 14); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 14); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, 0, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 0); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 2); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 5); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 9); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 14); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == 14); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_mixed_grow_permutations] @@ -10081,8 +10033,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -10130,30 +10081,30 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0, NULL) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == j*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == j*W+W-1); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == j*W+W-1); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_get(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); @@ -10194,8 +10145,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -10246,37 +10196,37 @@ code = ''' tag_ = 0; id_ = -1; lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(weight_ == 0); - assert(size_ == 9); + assert(lfsr_data_size(data_) == 9); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == j*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == j*W+W-1); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == j*W+W-1); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); } lfsr_rbyd_lookup(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &off_, &size_) => LFS_ERR_NOENT; + &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; } ''' @@ -10317,8 +10267,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -10384,25 +10333,25 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1+D); assert(weight_ == W+D); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } else if (k > j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1+D); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } else { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; @@ -10446,8 +10395,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[6]; // test all permutations of a given size @@ -10513,31 +10461,31 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1+D); assert(weight_ == W+D); - assert(size_ == 6); + assert(lfsr_data_size(data_) == 6); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else if (k > j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1+D); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -10583,8 +10531,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[6]; // test all permutations of a given size @@ -10651,41 +10598,41 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == k*W+W-1+D); assert(weight_ == W+D); - assert(size_ == 6); + assert(lfsr_data_size(data_) == 6); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == k*W+W-1+D); assert(weight_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else if (k > j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == k*W+W-1+D); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -10729,8 +10676,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -10796,25 +10742,25 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1-D); assert(weight_ == W-D); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } else if (k > j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1-D); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } else { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); } lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; @@ -10858,8 +10804,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[6]; // test all permutations of a given size @@ -10925,31 +10870,31 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1-D); assert(weight_ == W-D); - assert(size_ == 6); + assert(lfsr_data_size(data_) == 6); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else if (k > j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1-D); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -10995,8 +10940,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[6]; // test all permutations of a given size @@ -11063,41 +11007,41 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == k*W+W-1-D); assert(weight_ == W-D); - assert(size_ == 6); + assert(lfsr_data_size(data_) == 6); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == k*W+W-1-D); assert(weight_ == 0); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else if (k > j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == k*W+W-1-D); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -11140,8 +11084,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[6]; // test all permutations of a given size @@ -11207,21 +11150,21 @@ code = ''' for (unsigned k = 0; k < N-1; k++) { if (k >= j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -11240,21 +11183,21 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 6); + assert(lfsr_data_size(data_) == 6); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -11297,8 +11240,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; uint8_t buffer[4]; // test all permutations of a given size @@ -11364,22 +11306,22 @@ code = ''' assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); if (k == j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == k*W+W-1); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); } } @@ -11394,11 +11336,11 @@ code = ''' assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -11420,22 +11362,22 @@ code = ''' assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); - assert(size_ == 4); + assert(lfsr_data_size(data_) == 4); lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); if (k == j) { lfsr_rbyd_lookup(&lfs, &rbyd, k*W+W-1, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == k*W+W-1); assert(weight_ == 0); - assert(size_ == 2); + assert(lfsr_data_size(data_) == 2); } } } @@ -11654,8 +11596,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t id_; lfs_size_t weight_; - lfs_off_t off_; - lfs_size_t size_; + lfsr_data_t data_; const char *alpha = "abcdefghijklmnopqrstuvwxyz"; uint8_t buffer[4]; @@ -11790,7 +11731,7 @@ code = ''' int err = lfsr_rbyd_lookup(&lfs, &rbyd, weighted_id, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_); + &id_, &tag_, &weight_, &data_); if (!err) { lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4); @@ -11824,7 +11765,7 @@ code = ''' lfsr_rbyd_lookup(&lfs, &rbyd, weighted_id, LFSR_TAG_REG, - &id_, &tag_, &weight_, &off_, &size_) => 0; + &id_, &tag_, &weight_, &data_) => 0; lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 1; assert(memcmp(&sim[id], buffer, 1) == 0); }