From d77a173d5ca32b61d0c897c25ef61e5da17616bb Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Mon, 7 Aug 2023 09:50:25 -0500 Subject: [PATCH] Changed source to consistently use rid for rbyd ids Originally it made sense to name the rbyd ids, well, ids, at least in the internals of the rbyd functions. But this doesn't work well outside of the rbyd code, where littlefs has to juggle several different id types with different purposes: - rid => rbyd-id, 31-bit index into an rbyd - bid => btree-id, 31-bit index into a btree - mid => mdir-id, 15-bit+15-bit index into the mtree - did => directory-id, 31-bit unique identifier for directories Even though context makes it clear which id the id refers to in the rbyd internals, updating the name to rid makes it clearer that these are the same type of id when looking at code both inside and outside the rbyd functions. --- lfs.c | 533 +++--- scripts/dbgbtree.py | 28 +- scripts/dbglfs.py | 20 +- scripts/dbgmtree.py | 26 +- scripts/dbgrbyd.py | 72 +- tests/test_btree.toml | 720 ++++----- tests/test_rbyd.toml | 3588 ++++++++++++++++++++--------------------- 7 files changed, 2495 insertions(+), 2492 deletions(-) diff --git a/lfs.c b/lfs.c index 4d38ea54..f449433a 100644 --- a/lfs.c +++ b/lfs.c @@ -808,14 +808,14 @@ static inline lfsr_tag_t lfsr_tag_key(lfsr_tag_t tag) { static inline bool lfsr_tag_follow(lfsr_tag_t alt, lfs_size_t weight, lfs_ssize_t lower, lfs_ssize_t upper, - lfs_ssize_t id, lfsr_tag_t tag) { + lfs_ssize_t rid, lfsr_tag_t tag) { if (lfsr_tag_isgt(alt)) { - return id > upper - (lfs_ssize_t)weight - 1 - || (id == upper - (lfs_ssize_t)weight - 1 + return rid > upper - (lfs_ssize_t)weight - 1 + || (rid == upper - (lfs_ssize_t)weight - 1 && lfsr_tag_key(tag) > lfsr_tag_key(alt)); } else { - return id < lower + (lfs_ssize_t)weight - || (id == lower + (lfs_ssize_t)weight + return rid < lower + (lfs_ssize_t)weight + || (rid == lower + (lfs_ssize_t)weight && lfsr_tag_key(tag) <= lfsr_tag_key(alt)); } } @@ -824,31 +824,31 @@ static inline bool lfsr_tag_follow2( lfsr_tag_t alt, lfs_size_t weight, lfsr_tag_t alt2, lfs_size_t weight2, lfs_ssize_t lower, lfs_ssize_t upper, - lfs_ssize_t id, lfsr_tag_t tag) { + lfs_ssize_t rid, lfsr_tag_t tag) { if (lfsr_tag_isred(alt2) && lfsr_tag_isparallel(alt, alt2)) { weight += weight2; } - return lfsr_tag_follow(alt, weight, lower, upper, id, tag); + return lfsr_tag_follow(alt, weight, lower, upper, rid, tag); } static inline bool lfsr_tag_prune2( lfsr_tag_t alt, lfs_ssize_t weight, lfsr_tag_t alt2, lfs_ssize_t weight2, - lfs_ssize_t lower_id, lfs_ssize_t upper_id, + lfs_ssize_t lower_rid, lfs_ssize_t upper_rid, lfsr_tag_t lower_tag, lfsr_tag_t upper_tag) { if (lfsr_tag_isgt(alt)) { return lfsr_tag_follow2( alt, weight, alt2, weight2, - lower_id, upper_id, - lower_id, lower_tag); + lower_rid, upper_rid, + lower_rid, lower_tag); } else { return lfsr_tag_follow2( alt, weight, alt2, weight2, - lower_id, upper_id, - upper_id-1, upper_tag-0x1); + lower_rid, upper_rid, + upper_rid-1, upper_tag-0x1); } } @@ -870,15 +870,15 @@ static inline void lfsr_tag_flip2(lfsr_tag_t *alt, lfs_size_t *weight, static inline void lfsr_tag_trim( lfsr_tag_t alt, lfs_size_t weight, - lfs_ssize_t *lower_id, lfs_ssize_t *upper_id, + lfs_ssize_t *lower_rid, lfs_ssize_t *upper_rid, lfsr_tag_t *lower_tag, lfsr_tag_t *upper_tag) { if (lfsr_tag_isgt(alt)) { - *upper_id -= weight; + *upper_rid -= weight; if (upper_tag) { *upper_tag = alt + 0x1; } } else { - *lower_id += weight; + *lower_rid += weight; if (lower_tag) { *lower_tag = alt + 0x1; } @@ -888,24 +888,28 @@ static inline void lfsr_tag_trim( static inline void lfsr_tag_trim2( lfsr_tag_t alt, lfs_size_t weight, lfsr_tag_t alt2, lfs_size_t weight2, - lfs_ssize_t *lower_id, lfs_ssize_t *upper_id, + lfs_ssize_t *lower_rid, lfs_ssize_t *upper_rid, lfsr_tag_t *lower_tag, lfsr_tag_t *upper_tag) { if (lfsr_tag_isred(alt2)) { - lfsr_tag_trim(alt2, weight2, lower_id, upper_id, lower_tag, upper_tag); + lfsr_tag_trim(alt2, weight2, + lower_rid, upper_rid, + lower_tag, upper_tag); } - lfsr_tag_trim(alt, weight, lower_id, upper_id, lower_tag, upper_tag); + lfsr_tag_trim(alt, weight, + lower_rid, upper_rid, + lower_tag, upper_tag); } // support for encoding/decoding tags on disk // each piece of metadata in an rbyd tree is prefixed with a 4-piece tag: // -// - 8-bit suptype => 1 byte -// - 8-bit subtype => 1 byte -// - 32-bit id/weight => 5 byte leb128 (worst case) -// - 32-bit size/jump => 5 byte leb128 (worst case) -// => 12 bytes total +// - 8-bit suptype => 1 byte +// - 8-bit subtype => 1 byte +// - 32-bit rid/weight => 5 byte leb128 (worst case) +// - 32-bit size/jump => 5 byte leb128 (worst case) +// => 12 bytes total // #define LFSR_TAG_DSIZE (2+5+5) @@ -967,10 +971,8 @@ static lfs_ssize_t lfsr_bd_readtag(lfs_t *lfs, *csum_ = lfs_crc32c(*csum_, buf, d); } - // save what we found, note we make a few tweaks on-disk => in-device - // - clear the valid bit from tag, we checked this earlier - // - adjust id so reserved id is -1, so we don't have mixed zero/one indexed - // + // save what we found, clearing the valid bit from the tag, note we + // checked this earlier *tag_ = tag & 0x7fff; *weight_ = weight; *size_ = size; @@ -1251,7 +1253,7 @@ static int lfsr_bd_progdata(lfs_t *lfs, // sizeof((struct lfs_mattr[]){__VA_ARGS__}) / sizeof(struct lfs_mattr) typedef struct lfsr_attr { - lfs_ssize_t id; + lfs_ssize_t rid; lfsr_tag_t tag; lfs_ssize_t delta; union { @@ -1265,47 +1267,47 @@ typedef struct lfsr_attr { } d; } lfsr_attr_t; -#define LFSR_ATTR_DATA_(_id, _tag, _delta, _data) \ - ((const lfsr_attr_t){_id, _tag, _delta, {.data=_data}}) +#define LFSR_ATTR_DATA_(_rid, _tag, _delta, _data) \ + ((const lfsr_attr_t){_rid, _tag, _delta, {.data=_data}}) -#define LFSR_ATTR_DATA(_id, _type, _delta, _data) \ - LFSR_ATTR_DATA_(_id, LFSR_TAG_##_type, _delta, _data) +#define LFSR_ATTR_DATA(_rid, _type, _delta, _data) \ + LFSR_ATTR_DATA_(_rid, LFSR_TAG_##_type, _delta, _data) -#define LFSR_ATTR_MOVE_(_new_id, _type, _delta, _mdir) \ - ((const lfsr_attr_t){_new_id, _type, _delta, {.mdir=_mdir}}) +#define LFSR_ATTR_MOVE_(_new_rid, _type, _delta, _mdir) \ + ((const lfsr_attr_t){_new_rid, _type, _delta, {.mdir=_mdir}}) -#define LFSR_ATTR_MOVE(_new_id, _type, _delta, _mdir) \ - LFSR_ATTR_MOVE_(_new_id, LFSR_TAG_##_type, _delta, _mdir) +#define LFSR_ATTR_MOVE(_new_rid, _type, _delta, _mdir) \ + LFSR_ATTR_MOVE_(_new_rid, LFSR_TAG_##_type, _delta, _mdir) -#define LFSR_ATTR_GRM_(_new_id, _type, _delta, _grm) \ - ((const lfsr_attr_t){_new_id, _type, _delta, {.grm=_grm}}) +#define LFSR_ATTR_GRM_(_new_rid, _type, _delta, _grm) \ + ((const lfsr_attr_t){_new_rid, _type, _delta, {.grm=_grm}}) -#define LFSR_ATTR_GRM(_new_id, _type, _delta, _grm) \ - LFSR_ATTR_GRM_(_new_id, LFSR_TAG_##_type, _delta, _grm) +#define LFSR_ATTR_GRM(_new_rid, _type, _delta, _grm) \ + LFSR_ATTR_GRM_(_new_rid, LFSR_TAG_##_type, _delta, _grm) -#define LFSR_ATTR_NAME_(_id, _tag, _delta, _did, _buffer, _size) \ - LFSR_ATTR_DATA_(_id, _tag, _delta, LFSR_DATA_NAME(_did, _buffer, _size)) +#define LFSR_ATTR_NAME_(_rid, _tag, _delta, _did, _buffer, _size) \ + LFSR_ATTR_DATA_(_rid, _tag, _delta, LFSR_DATA_NAME(_did, _buffer, _size)) -#define LFSR_ATTR_NAME(_id, _type, _delta, _did, _buffer, _size) \ - LFSR_ATTR_NAME_(_id, LFSR_TAG_##_type, _delta, _did, _buffer, _size) +#define LFSR_ATTR_NAME(_rid, _type, _delta, _did, _buffer, _size) \ + LFSR_ATTR_NAME_(_rid, LFSR_TAG_##_type, _delta, _did, _buffer, _size) -#define LFSR_ATTR_LEB128_(_id, _tag, _delta, _did) \ - LFSR_ATTR_DATA_(_id, _tag, _delta, LFSR_DATA_LEB128(_did)) +#define LFSR_ATTR_LEB128_(_rid, _tag, _delta, _did) \ + LFSR_ATTR_DATA_(_rid, _tag, _delta, LFSR_DATA_LEB128(_did)) -#define LFSR_ATTR_LEB128(_id, _type, _delta, _did) \ - LFSR_ATTR_LEB128_(_id, LFSR_TAG_##_type, _delta, _did) +#define LFSR_ATTR_LEB128(_rid, _type, _delta, _did) \ + LFSR_ATTR_LEB128_(_rid, LFSR_TAG_##_type, _delta, _did) -#define LFSR_ATTR_(_id, _tag, _delta, _buffer, _size) \ - LFSR_ATTR_DATA_(_id, _tag, _delta, LFSR_DATA_BUF(_buffer, _size)) +#define LFSR_ATTR_(_rid, _tag, _delta, _buffer, _size) \ + LFSR_ATTR_DATA_(_rid, _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(_rid, _type, _delta, _buffer, _size) \ + LFSR_ATTR_(_rid, LFSR_TAG_##_type, _delta, _buffer, _size) -#define LFSR_ATTR_DISK_(_id, _tag, _delta, _block, _off, _size) \ - LFSR_ATTR_DATA_(_id, _tag, _delta, LFSR_DATA_DISK(_block, _off, _size)) +#define LFSR_ATTR_DISK_(_rid, _tag, _delta, _block, _off, _size) \ + LFSR_ATTR_DATA_(_rid, _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) +#define LFSR_ATTR_DISK(_rid, _type, _delta, _block, _off, _size) \ + LFSR_ATTR_DISK_(_rid, LFSR_TAG_##_type, _delta, _block, _off, _size) #define LFSR_ATTR_NOOP LFSR_ATTR(-1, UNR, 0, NULL, 0) @@ -1965,8 +1967,8 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd, } static int lfsr_rbyd_lookupnext(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_, + lfs_ssize_t rid, lfsr_tag_t tag, + lfs_ssize_t *rid_, lfsr_tag_t *tag_, lfs_size_t *weight_, lfsr_data_t *data_) { // tag must be valid at this point LFS_ASSERT(lfsr_tag_isvalid(tag)); @@ -2001,7 +2003,7 @@ static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // found an alt? if (lfsr_tag_isalt(alt)) { - if (lfsr_tag_follow(alt, weight, lower, upper, id, tag)) { + if (lfsr_tag_follow(alt, weight, lower, upper, rid, tag)) { lfsr_tag_flip(&alt, &weight, lower, upper); lfsr_tag_trim(alt, weight, &lower, &upper, NULL, NULL); branch = branch - jump; @@ -2012,28 +2014,28 @@ static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // found end of tree? } else { - // update the tag id - lfs_ssize_t id__ = upper-1; + // update the tag rid + lfs_ssize_t rid__ = upper-1; lfsr_tag_t tag__ = alt; LFS_ASSERT(lfsr_tag_mode(tag__) == 0x0000); // not what we're looking for? if (!tag__ - || id__ < id - || (id__ == id && tag__ < tag)) { + || rid__ < rid + || (rid__ == rid && tag__ < tag)) { return LFS_ERR_NOENT; } // save what we found // TODO how many of these need to be conditional? - if (id_) { - *id_ = id__; + if (rid_) { + *rid_ = rid__; } if (tag_) { *tag_ = tag__; } if (weight_) { - *weight_ = id__ - lower; + *weight_ = rid__ - lower; } if (data_) { *data_ = LFSR_DATA_DISK(rbyd->block, branch + d, jump); @@ -2044,12 +2046,12 @@ static int lfsr_rbyd_lookupnext(lfs_t *lfs, const 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 rid, lfsr_tag_t tag, lfsr_tag_t *tag_, lfsr_data_t *data_) { - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_tag_t tag__; - int err = lfsr_rbyd_lookupnext(lfs, rbyd, id, lfsr_tag_clearwide(tag), - &id_, &tag__, NULL, data_); + int err = lfsr_rbyd_lookupnext(lfs, rbyd, rid, lfsr_tag_clearwide(tag), + &rid_, &tag__, NULL, data_); if (err) { return err; } @@ -2059,7 +2061,7 @@ static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // // we accept either exact matches or suptype matches depending on the // wide bit - if (id_ != id + if (rid_ != rid || (lfsr_tag_iswide(tag) ? lfsr_tag_suptype(tag__) != lfsr_tag_clearwide(tag) : tag__ != tag)) { @@ -2075,9 +2077,9 @@ static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // TODO still need this? // TODO move this into the tests? 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 rid, lfsr_tag_t tag, void *buffer, lfs_size_t size) { lfsr_data_t data; - int err = lfsr_rbyd_lookup(lfs, rbyd, id, tag, NULL, &data); + int err = lfsr_rbyd_lookup(lfs, rbyd, rid, tag, NULL, &data); if (err) { return err; } @@ -2218,7 +2220,7 @@ static void lfsr_rbyd_p_red( // core rbyd algorithm static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfs_ssize_t id, lfsr_tag_t tag, lfs_ssize_t delta, + lfs_ssize_t rid, lfsr_tag_t tag, lfs_ssize_t delta, lfsr_data_t data) { // must fetch before mutating! LFS_ASSERT(lfsr_rbyd_isfetched(rbyd)); @@ -2255,29 +2257,29 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, // // several lower bits are reserved, so we repurpose these // to keep track of some append state - lfs_ssize_t id_; - lfs_ssize_t other_id_; + lfs_ssize_t rid_; + lfs_ssize_t other_rid_; lfsr_tag_t tag_; lfsr_tag_t other_tag_; if (delta != 0 && !lfsr_tag_isgrow(tag)) { LFS_ASSERT(!lfsr_tag_iswide(tag)); if (delta > 0) { - LFS_ASSERT(id <= (lfs_ssize_t)rbyd->weight); + LFS_ASSERT(rid <= (lfs_ssize_t)rbyd->weight); - // it's a bit ugly, but adjusting the id here makes the following + // it's a bit ugly, but adjusting the rid here makes the following // logic work out more consistently - id -= 1; - id_ = id + 1; - other_id_ = id + 1; + rid -= 1; + rid_ = rid + 1; + other_rid_ = rid + 1; } else { - LFS_ASSERT(id < (lfs_ssize_t)rbyd->weight); + LFS_ASSERT(rid < (lfs_ssize_t)rbyd->weight); - // it's a bit ugly, but adjusting the id here makes the following + // it's a bit ugly, but adjusting the rid here makes the following // logic work out more consistently - id += 1; - id_ = id - lfs_smax32(-delta, 0); - other_id_ = id; + rid += 1; + rid_ = rid - lfs_smax32(-delta, 0); + other_rid_ = rid; } // note these tags MUST NOT be zero, due to unreachable tag holes @@ -2285,10 +2287,10 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, other_tag_ = tag_; } else { - LFS_ASSERT(id < (lfs_ssize_t)rbyd->weight); + LFS_ASSERT(rid < (lfs_ssize_t)rbyd->weight); - id_ = id - lfs_smax32(-delta, 0); - other_id_ = id; + rid_ = rid - lfs_smax32(-delta, 0); + other_rid_ = rid; // note both normal and rm wide-tags have the same bounds, really it's // the normal non-wide-tags that are an outlier here @@ -2313,8 +2315,8 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, // track of both the lower and upper bounds of diverging paths // in the case of range deletions lfs_off_t branch = rbyd->trunk; - lfs_ssize_t lower_id = -1; - lfs_ssize_t upper_id = rbyd->weight; + lfs_ssize_t lower_rid = -1; + lfs_ssize_t upper_rid = rbyd->weight; lfsr_tag_t lower_tag = 0; lfsr_tag_t upper_tag = 0xffff; @@ -2326,8 +2328,8 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, // note we can't just perform two searches sequentially, or else our tree // will end up very unbalanced. lfs_off_t other_branch = 0; - lfs_ssize_t other_lower_id = 0; - lfs_ssize_t other_upper_id = 0; + lfs_ssize_t other_lower_rid = 0; + lfs_ssize_t other_upper_rid = 0; lfsr_tag_t other_lower_tag = 0; lfsr_tag_t other_upper_tag = 0; @@ -2374,12 +2376,12 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, if (!lfsr_tag_hasdiverged(tag_) && lfsr_tag_follow2(alt, weight, p_alts[0], p_weights[0], - lower_id, upper_id, - id_, tag_) + lower_rid, upper_rid, + rid_, tag_) != lfsr_tag_follow2(alt, weight, p_alts[0], p_weights[0], - lower_id, upper_id, - other_id_, other_tag_)) { + lower_rid, upper_rid, + other_rid_, other_tag_)) { // first take care of any lingering red alts if (lfsr_tag_isred(p_alts[0])) { alt = lfsr_tag_setblack(p_alts[0]); @@ -2391,8 +2393,8 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, tag_ = lfsr_tag_setdivergedlower(tag_); other_tag_ = lfsr_tag_setdivergedupper(other_tag_); other_branch = branch; - other_lower_id = lower_id; - other_upper_id = upper_id; + other_lower_rid = lower_rid; + other_upper_rid = upper_rid; other_lower_tag = lower_tag; other_upper_tag = upper_tag; } @@ -2418,7 +2420,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, if (lfsr_tag_prune2( alt, weight, p_alts[0], p_weights[0], - lower_id, upper_id, + lower_rid, upper_rid, lower_tag, upper_tag)) { if (lfsr_tag_isred(p_alts[0])) { alt = lfsr_tag_setblack(p_alts[0]); @@ -2448,11 +2450,11 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, if (lfsr_tag_follow2( alt, weight, p_alts[0], p_weights[0], - lower_id, upper_id, - id_, tag_)) { + lower_rid, upper_rid, + rid_, tag_)) { lfsr_tag_flip2(&alt, &weight, p_alts[0], p_weights[0], - lower_id, upper_id); + lower_rid, upper_rid); lfs_swap32(&jump, &branch_); lfs_swap16(&p_alts[0], &alt); @@ -2462,7 +2464,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_tag_trim( p_alts[0], p_weights[0], - &lower_id, &upper_id, + &lower_rid, &upper_rid, &lower_tag, &upper_tag); lfsr_rbyd_p_red(p_alts, p_weights, p_jumps); @@ -2485,7 +2487,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_tag_trim( p_alts[0], p_weights[0], - &lower_id, &upper_id, + &lower_rid, &upper_rid, &lower_tag, &upper_tag); lfsr_rbyd_p_red(p_alts, p_weights, p_jumps); @@ -2502,11 +2504,11 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, && lfsr_tag_follow2( alt, weight, p_alts[0], p_weights[0], - lower_id, upper_id, - id_, tag_)) { + lower_rid, upper_rid, + rid_, tag_)) { lfsr_tag_flip2(&alt, &weight, p_alts[0], p_weights[0], - lower_id, upper_id); + lower_rid, upper_rid); lfs_swap32(&jump, &branch_); } @@ -2518,8 +2520,8 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, // 1 2 3 1 2 3 1 if (lfsr_tag_isred(p_alts[0]) && lfsr_tag_follow(p_alts[0], p_weights[0], - lower_id, upper_id, - id_, tag_)) { + lower_rid, upper_rid, + rid_, tag_)) { lfs_swap16(&p_alts[0], &alt); lfs_swap32(&p_weights[0], &weight); lfs_swap32(&p_jumps[0], &jump); @@ -2528,7 +2530,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_tag_flip2(&alt, &weight, p_alts[0], p_weights[0], - lower_id, upper_id); + lower_rid, upper_rid); lfs_swap32(&jump, &branch_); } @@ -2537,7 +2539,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_tag_trim2( alt, weight, p_alts[0], p_weights[0], - &lower_id, &upper_id, + &lower_rid, &upper_rid, &lower_tag, &upper_tag); } // continue to next alt @@ -2560,14 +2562,14 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, // found end of tree? } else { - // update the found tag/id + // update the found tag/rid // // note we: // - clear valid bit, marking the tag as found // - preserve diverged state LFS_ASSERT(lfsr_tag_mode(alt) == 0x0000); tag_ = lfsr_tag_setvalid(lfsr_tag_mode(tag_) | alt); - id_ = upper_id-1; + rid_ = upper_rid-1; // done? if (!lfsr_tag_hasdiverged(tag_) || lfsr_tag_isvalid(other_tag_)) { @@ -2578,10 +2580,10 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, // switch to the other path if we have diverged if (lfsr_tag_hasdiverged(tag_) || !lfsr_tag_isalt(alt)) { lfs_swap16(&tag_, &other_tag_); - lfs_sswap32(&id_, &other_id_); + lfs_sswap32(&rid_, &other_rid_); lfs_swap32(&branch, &other_branch); - lfs_sswap32(&lower_id, &other_lower_id); - lfs_sswap32(&upper_id, &other_upper_id); + lfs_sswap32(&lower_rid, &other_lower_rid); + lfs_sswap32(&upper_rid, &other_upper_rid); lfs_swap16(&lower_tag, &other_lower_tag); lfs_swap16(&upper_tag, &other_upper_tag); } @@ -2597,12 +2599,12 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, if (lfsr_tag_isdivergedlower(tag_)) { // finished on lower path tag_ = other_tag_; - id_ = other_id_; + rid_ = other_rid_; branch = other_branch; - upper_id = other_upper_id; + upper_rid = other_upper_rid; } else { // finished on upper path - lower_id = other_lower_id; + lower_rid = other_lower_rid; } } @@ -2624,8 +2626,8 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_tag_t alt = 0; lfs_size_t weight = 0; if (lfsr_tag_key(tag_) - && (id_ < id-lfs_smax32(-delta, 0) - || (id_ == id-lfs_smax32(-delta, 0) + && (rid_ < rid-lfs_smax32(-delta, 0) + || (rid_ == rid-lfs_smax32(-delta, 0) && ((delta > 0 && !lfsr_tag_isgrow(tag)) || (lfsr_tag_iswide(tag) ? lfsr_tag_suptype(lfsr_tag_key(tag_)) @@ -2635,20 +2637,20 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, if (lfsr_tag_isrm(tag)) { // if removed, make our tag unreachable alt = LFSR_TAG_ALTGT(false, 0); - weight = upper_id - lower_id - 1 + delta; - upper_id -= weight; + weight = upper_rid - lower_rid - 1 + delta; + upper_rid -= weight; } else { // split less than alt = LFSR_TAG_ALTLE( !lfsr_tag_hasdiverged(tag_), lfsr_tag_key(tag_)); - weight = id_ - lower_id; - lower_id += weight; + weight = rid_ - lower_rid; + lower_rid += weight; } } else if (lfsr_tag_key(tag_) - && (id_ > id - || (id_ == id + && (rid_ > rid + || (rid_ == rid && ((delta > 0 && !lfsr_tag_isgrow(tag)) || (lfsr_tag_iswide(tag) ? lfsr_tag_suptype(lfsr_tag_key(tag_)) @@ -2658,15 +2660,15 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, if (lfsr_tag_isrm(tag)) { // if removed, make our tag unreachable alt = LFSR_TAG_ALTGT(false, 0); - weight = upper_id - lower_id - 1 + delta; - upper_id -= weight; + weight = upper_rid - lower_rid - 1 + delta; + upper_rid -= weight; } else { // split greater than alt = LFSR_TAG_ALTGT( !lfsr_tag_hasdiverged(tag_), lfsr_tag_key(tag)); - weight = upper_id - id - 1; - upper_id -= weight; + weight = upper_rid - rid - 1; + upper_rid -= weight; } } @@ -2699,7 +2701,7 @@ leaf:; lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->off, // rm => null, otherwise strip off control bits (lfsr_tag_isrm(tag) ? LFSR_TAG_NULL : lfsr_tag_key(tag)), - upper_id - lower_id - 1 + delta, + upper_rid - lower_rid - 1 + delta, lfsr_data_size(data), &rbyd->crc); if (d < 0) { @@ -2726,7 +2728,7 @@ failed:; } static int lfsr_rbyd_appendall(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfs_ssize_t start_id, lfs_ssize_t end_id, + lfs_ssize_t start_rid, lfs_ssize_t end_rid, const lfsr_attr_t *attrs, lfs_size_t attr_count) { // append each tag to the tree for (lfs_size_t i = 0; i < attr_count; i++) { @@ -2737,7 +2739,8 @@ static int lfsr_rbyd_appendall(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // don't write tags outside of the requested range - if (attrs[i].id >= start_id && (end_id < 0 || attrs[i].id < end_id)) { + if (attrs[i].rid >= start_rid + && (end_rid < 0 || attrs[i].rid < end_rid)) { // this is a bit of a hack, but ignore any gstate tags here, // these need to be handled specially by upper-layers if (lfsr_tag_suptype(attrs[i].tag) == LFSR_TAG_GSTATE) { @@ -2767,7 +2770,7 @@ static int lfsr_rbyd_appendall(lfs_t *lfs, lfsr_rbyd_t *rbyd, // append the attr err = lfsr_rbyd_append(lfs, rbyd, - attrs[i].id-lfs_smax32(start_id, 0), + attrs[i].rid-lfs_smax32(start_rid, 0), tag, 0, data); if (err) { return err; @@ -2779,7 +2782,7 @@ static int lfsr_rbyd_appendall(lfs_t *lfs, lfsr_rbyd_t *rbyd, LFS_ASSERT(!lfsr_tag_isinternal(attrs[i].tag)); int err = lfsr_rbyd_append(lfs, rbyd, - attrs[i].id-lfs_smax32(start_id, 0), + attrs[i].rid-lfs_smax32(start_rid, 0), attrs[i].tag, attrs[i].delta, attrs[i].d.data); if (err) { return err; @@ -2787,13 +2790,13 @@ static int lfsr_rbyd_appendall(lfs_t *lfs, lfsr_rbyd_t *rbyd, } } - // we need to make sure we keep start_id/end_id updated with + // we need to make sure we keep start_rid/end_rid updated with // weight changes - if (attrs[i].id < start_id) { - start_id += attrs[i].delta; + if (attrs[i].rid < start_rid) { + start_rid += attrs[i].delta; } - if (attrs[i].id < end_id) { - end_id += attrs[i].delta; + if (attrs[i].rid < end_rid) { + end_rid += attrs[i].delta; } } @@ -2841,7 +2844,7 @@ static int lfsr_rbyd_appendgdelta(lfs_t *lfs, lfsr_rbyd_t *rbyd) { static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfs_ssize_t start_id, lfs_ssize_t end_id, + lfs_ssize_t start_rid, lfs_ssize_t end_rid, const lfsr_rbyd_t *source) { #ifndef LFSR_NO_REBALANCE // must fetch before mutating! @@ -2868,17 +2871,17 @@ static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd, // first copy over raw tags, note this doesn't create a tree lfs_off_t layer_start = rbyd->off; - lfs_ssize_t id = start_id; + lfs_ssize_t rid = start_rid; lfsr_tag_t tag = 0; while (true) { lfs_size_t w; lfsr_data_t data; - int err = lfsr_rbyd_lookupnext(lfs, source, id, lfsr_tag_next(tag), - &id, &tag, &w, &data); + int err = lfsr_rbyd_lookupnext(lfs, source, rid, lfsr_tag_next(tag), + &rid, &tag, &w, &data); if (err && err != LFS_ERR_NOENT) { return err; } - if (err == LFS_ERR_NOENT || (end_id >= 0 && id >= end_id)) { + if (err == LFS_ERR_NOENT || (end_rid >= 0 && rid >= end_rid)) { break; } @@ -3009,17 +3012,17 @@ failed:; #else // try to copy over tags - lfs_ssize_t id = start_id; + lfs_ssize_t rid = start_rid; lfsr_tag_t tag = 0; while (true) { lfs_size_t w; lfsr_data_t data; - int err = lfsr_rbyd_lookupnext(lfs, source, id, lfsr_tag_next(tag), - &id, &tag, &w, &data); + int err = lfsr_rbyd_lookupnext(lfs, source, rid, lfsr_tag_next(tag), + &rid, &tag, &w, &data); if (err && err != LFS_ERR_NOENT) { return err; } - if (err == LFS_ERR_NOENT || (end_id >= 0 && id >= end_id)) { + if (err == LFS_ERR_NOENT || (end_rid >= 0 && rid >= end_rid)) { return 0; } @@ -3031,7 +3034,7 @@ failed:; // append the attr err = lfsr_rbyd_append(lfs, rbyd, - id-lfs_smax32(w-1, 0)-lfs_smax32(start_id, 0), + rid-lfs_smax32(w-1, 0)-lfs_smax32(start_rid, 0), tag, +w, data); if (err) { return err; @@ -3077,19 +3080,19 @@ static int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd, // // - 9-word crc with fcrc to check following prog (middle of block) // - fcrc tag type => 2 byte le16 - // - fcrc tag id => 1 byte leb128 + // - fcrc tag rid => 1 byte leb128 // - fcrc tag size => 1 byte leb128 (worst case) // - fcrc crc => 4 byte le32 // - fcrc size => 5 byte leb128 (worst case) // - crc tag type => 2 byte le16 - // - crc tag id => 1 byte leb128 + // - crc tag rid => 1 byte leb128 // - crc tag size => 5 byte leb128 (worst case) // - crc crc => 4 byte le32 // => 25 bytes total // // - 4-word crc with no following prog (end of block) // - crc tag type => 2 byte le16 - // - crc tag id => 1 byte leb128 + // - crc tag rid => 1 byte leb128 // - crc tag size => 5 byte leb128 (worst case) // - crc crc => 4 byte le32 // => 12 bytes total @@ -3223,32 +3226,32 @@ failed:; // the following are mostly btree helpers, but since they operate on rbyds, // exist in the rbyd namespace -// Calculate the maximum possible disk usage required by this id after +// Calculate the maximum possible disk usage required by this rid after // compaction. This uses a conservative estimate so the actual on-disk cost // should be smaller. // static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, - lfs_ssize_t id, - lfs_ssize_t *id_, lfs_size_t *weight_) { + lfs_ssize_t rid, + lfs_ssize_t *rid_, lfs_size_t *weight_) { lfsr_tag_t tag = 0; lfs_size_t w = 0; lfs_size_t dsize = 0; while (true) { - lfs_ssize_t id__; + lfs_ssize_t rid__; lfs_size_t w_; lfsr_data_t data; int err = lfsr_rbyd_lookupnext(lfs, rbyd, - id, lfsr_tag_next(tag), - &id__, &tag, &w_, &data); + rid, lfsr_tag_next(tag), + &rid__, &tag, &w_, &data); if (err && err != LFS_ERR_NOENT) { return err; } - if (err == LFS_ERR_NOENT || id__ > id+lfs_smax32(w_-1, 0)) { + if (err == LFS_ERR_NOENT || rid__ > rid+lfs_smax32(w_-1, 0)) { break; } - // keep track of id and weight - id = id__; + // keep track of rid and weight + rid = rid__; w += w_; // determine the upper-bound of alt pointers, tags, and data @@ -3270,8 +3273,8 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, #endif } - if (id_) { - *id_ = id; + if (rid_) { + *rid_ = rid; } if (weight_) { *weight_ = w; @@ -3279,49 +3282,49 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, return dsize; } -// Calculate the maximum possible disk usage required by this id after +// Calculate the maximum possible disk usage required by this rid after // compaction. This uses a conservative estimate so the actual on-disk cost // should be smaller. // -// This also returns a good split_id in case the rbyd needs to be split. +// This also returns a good split_rid in case the rbyd needs to be split. // // TODO do we need to include commit overhead here? static lfs_ssize_t lfsr_rbyd_estimateall(lfs_t *lfs, const lfsr_rbyd_t *rbyd, - lfs_ssize_t start_id, lfs_ssize_t end_id, - lfs_size_t *split_id_) { + lfs_ssize_t start_rid, lfs_ssize_t end_rid, + lfs_size_t *split_rid_) { // calculate dsize by starting from the outside ids and working inwards, - // this naturally gives us a split id + // this naturally gives us a split rid // // note that we don't include -1 tags yet, -1 tags are always cleaned up - // during a split so they shouldn't affect the split_id + // during a split so they shouldn't affect the split_rid // - lfs_ssize_t lower_id = (start_id < 0 ? 0 : start_id); - lfs_ssize_t upper_id = (end_id < 0 + lfs_ssize_t lower_rid = (start_rid < 0 ? 0 : start_rid); + lfs_ssize_t upper_rid = (end_rid < 0 ? (lfs_ssize_t)rbyd->weight-1 - : end_id-1); + : end_rid-1); lfs_size_t lower_dsize = 0; lfs_size_t upper_dsize = 0; - while (lower_id <= upper_id) { + while (lower_rid <= upper_rid) { if (lower_dsize <= upper_dsize) { lfs_size_t w; - lfs_ssize_t dsize = lfsr_rbyd_estimate(lfs, rbyd, lower_id, + lfs_ssize_t dsize = lfsr_rbyd_estimate(lfs, rbyd, lower_rid, NULL, &w); if (dsize < 0) { return dsize; } - lower_id += w; + lower_rid += w; lower_dsize += dsize; } else { lfs_size_t w; - lfs_ssize_t dsize = lfsr_rbyd_estimate(lfs, rbyd, upper_id, + lfs_ssize_t dsize = lfsr_rbyd_estimate(lfs, rbyd, upper_rid, NULL, &w); if (dsize < 0) { return dsize; } - upper_id -= w; + upper_rid -= w; upper_dsize += dsize; } } @@ -3332,8 +3335,8 @@ static lfs_ssize_t lfsr_rbyd_estimateall(lfs_t *lfs, const lfsr_rbyd_t *rbyd, return dsize; } - if (split_id_) { - *split_id_ = lower_id; + if (split_rid_) { + *split_rid_ = lower_rid; } #ifndef LFSR_NO_REBALANCE @@ -3368,11 +3371,11 @@ static int lfsr_rbyd_isdegenerate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } // count ids until we exceed our cutoff - lfs_ssize_t id = -1; + lfs_ssize_t rid = -1; lfs_size_t count = 0; while (true) { - int err = lfsr_rbyd_lookupnext(lfs, rbyd, id+1, 0, - &id, NULL, NULL, NULL); + int err = lfsr_rbyd_lookupnext(lfs, rbyd, rid+1, 0, + &rid, NULL, NULL, NULL); if (err && err != LFS_ERR_NOENT) { return err; } @@ -3392,15 +3395,15 @@ static int lfsr_rbyd_isdegenerate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // // names in littlefs are tuples of directory-ids + ascii/utf8 strings -// binary search an rbyd for a name, leaving the id_/weight_ with the best +// binary search an rbyd for a name, leaving the rid_/weight_ with the best // matching name if not found static int lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfs_size_t did, const char *name, lfs_size_t name_size, - lfs_ssize_t *id_, lfsr_tag_t *tag_, lfs_size_t *weight_, + lfs_ssize_t *rid_, lfsr_tag_t *tag_, lfs_size_t *weight_, lfsr_data_t *data_) { - // if we have an empty mdir, default to id = -1 - if (id_) { - *id_ = -1; + // if we have an empty mdir, default to rid = -1 + if (rid_) { + *rid_ = -1; } if (tag_) { *tag_ = 0; @@ -3417,22 +3420,22 @@ static int lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfs_ssize_t upper = rbyd->weight; while (lower < upper) { lfsr_tag_t tag__; - lfs_ssize_t id__; + lfs_ssize_t rid__; lfs_size_t weight__; lfsr_data_t data__; int err = lfsr_rbyd_lookupnext(lfs, rbyd, - // lookup ~middle id, note we may end up in the middle - // of a weighted id with this + // lookup ~middle rid, note we may end up in the middle + // of a weighted rid with this lower + (upper-1-lower)/2, 0, - &id__, &tag__, &weight__, &data__); + &rid__, &tag__, &weight__, &data__); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); return err; } - // if we have no name or a vestigial name, treat this id as always lt + // if we have no name or a vestigial name, treat this rid as always lt lfs_scmp_t cmp; - if ((tag__ == LFSR_TAG_BRANCH && id__-(weight__-1) == 0) + if ((tag__ == LFSR_TAG_BRANCH && rid__-(weight__-1) == 0) || lfsr_tag_suptype(tag__) != LFSR_TAG_NAME) { cmp = LFS_CMP_LT; @@ -3446,14 +3449,14 @@ static int lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // bisect search space if (lfs_cmp(cmp) > 0) { - upper = id__ - (weight__-1); + upper = rid__ - (weight__-1); } else if (lfs_cmp(cmp) < 0) { - lower = id__ + 1; + lower = rid__ + 1; - // keep track of best-matching id >= our target - if (id_) { - *id_ = id__; + // keep track of best-matching rid >= our target + if (rid_) { + *rid_ = rid__; } if (tag_) { *tag_ = tag__; @@ -3467,8 +3470,8 @@ static int lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } else { // found a match? - if (id_) { - *id_ = id__; + if (rid_) { + *rid_ = rid__; } if (tag_) { *tag_ = tag__; @@ -3483,7 +3486,7 @@ static int lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } } - // no match, at least update id_/tag_/weight_/data_ with the best + // no match, at least update rid_/tag_/weight_/data_ with the best // match so far return LFS_ERR_NOENT; } @@ -3779,7 +3782,7 @@ static int lfsr_btree_parent(lfs_t *lfs, return LFS_ERR_NOENT; } - // descend down the btree looking for our id + // descend down the btree looking for our rid lfsr_rbyd_t branch = btree->u.r.rbyd; lfs_ssize_t rid = bid; while (true) { @@ -3946,7 +3949,7 @@ static int lfsr_btree_commit(lfs_t *lfs, compact:; // can't commit, try to compact lfsr_rbyd_t rbyd_; - lfs_size_t split_id; + lfs_size_t split_rid; // first check if we are a degenerate root and can be reverted to // an inlined btree @@ -3969,7 +3972,7 @@ static int lfsr_btree_commit(lfs_t *lfs, // check if we're within our compaction threshold, otherwise we // need to split lfs_ssize_t estimate = lfsr_rbyd_estimateall(lfs, rbyd, -1, -1, - &split_id); + &split_rid); if (estimate < 0) { return estimate; } @@ -4056,7 +4059,7 @@ static int lfsr_btree_commit(lfs_t *lfs, split:; // we should have something to split here - LFS_ASSERT(split_id > 0 && split_id < rbyd->weight); + LFS_ASSERT(split_rid > 0 && split_rid < rbyd->weight); // allocate a new rbyd err = lfsr_rbyd_alloc(lfs, &rbyd_); @@ -4071,18 +4074,18 @@ static int lfsr_btree_commit(lfs_t *lfs, return err; } - // copy over tags < split_id - err = lfsr_rbyd_compact(lfs, &rbyd_, 0, split_id, rbyd); + // copy over tags < split_rid + err = lfsr_rbyd_compact(lfs, &rbyd_, 0, split_rid, rbyd); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; } - // append pending attrs < split_id + // append pending attrs < split_rid // // upper layers should make sure this can't fail by limiting the // maximum commit size - err = lfsr_rbyd_appendall(lfs, &rbyd_, 0, split_id, + err = lfsr_rbyd_appendall(lfs, &rbyd_, 0, split_rid, attrs, attr_count); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -4096,18 +4099,18 @@ static int lfsr_btree_commit(lfs_t *lfs, return err; } - // copy over tags >= split_id - err = lfsr_rbyd_compact(lfs, &sibling, split_id, -1, rbyd); + // copy over tags >= split_rid + err = lfsr_rbyd_compact(lfs, &sibling, split_rid, -1, rbyd); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; } - // append pending attrs >= split_id + // append pending attrs >= split_rid // // upper layers should make sure this can't fail by limiting the // maximum commit size - err = lfsr_rbyd_appendall(lfs, &sibling, split_id, -1, + err = lfsr_rbyd_appendall(lfs, &sibling, split_rid, -1, attrs, attr_count); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -4291,13 +4294,13 @@ static int lfsr_btree_commit(lfs_t *lfs, // try to add our sibling's tags to our rbyd lfs_size_t rweight_ = rbyd_.weight; - lfs_ssize_t id = 0; + lfs_ssize_t rid = 0; lfsr_tag_t tag = 0; while (true) { lfs_size_t w; lfsr_data_t data; - err = lfsr_rbyd_lookupnext(lfs, &sibling, id, lfsr_tag_next(tag), - &id, &tag, &w, &data); + err = lfsr_rbyd_lookupnext(lfs, &sibling, rid, lfsr_tag_next(tag), + &rid, &tag, &w, &data); if (err && err != LFS_ERR_NOENT) { return err; } @@ -4307,7 +4310,7 @@ static int lfsr_btree_commit(lfs_t *lfs, // append the attr err = lfsr_rbyd_append(lfs, &rbyd_, - sdelta+id-lfs_smax32(w-1, 0), tag, +w, + sdelta+rid-lfs_smax32(w-1, 0), tag, +w, data); if (err) { return err; @@ -4340,18 +4343,18 @@ static int lfsr_btree_commit(lfs_t *lfs, } if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { - // lookup the id (weight really) of the previously-split entry - lfs_ssize_t split_id; + // lookup the rid (weight really) of the previously-split entry + lfs_ssize_t split_rid; err = lfsr_rbyd_lookupnext(lfs, &rbyd_, (sdelta == 0 ? sweight : rweight_), LFSR_TAG_NAME, - &split_id, NULL, NULL, NULL); + &split_rid, NULL, NULL, NULL); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); return err; } err = lfsr_rbyd_append(lfs, &rbyd_, - split_id, LFSR_TAG_BRANCH, 0, split_data); + split_rid, LFSR_TAG_BRANCH, 0, split_data); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -4449,10 +4452,10 @@ static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree, // a normal btree } else { - // lookup in which leaf our id resides + // lookup in which leaf our rid resides // // for lfsr_btree_commit operations to work out, we need to - // limit our bid to an id in the tree, which is what this min + // limit our bid to an rid in the tree, which is what this min // is doing // // note it is possible for our btree to have a weight of zero here, @@ -4475,7 +4478,7 @@ static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree, rid -= rweight-1; } - // commit our id into the tree, letting lfsr_btree_commit take care + // commit our rid into the tree, letting lfsr_btree_commit take care // of the rest int degenerate = lfsr_btree_commit(lfs, btree, bid_, 0, &rbyd, LFSR_BTREE_ATTRS( @@ -4527,7 +4530,7 @@ static int lfsr_btree_set(lfs_t *lfs, lfsr_btree_t *btree, // a normal btree } else { - // lookup in which leaf our id resides + // lookup in which leaf our rid resides lfsr_rbyd_t rbyd; lfsr_tag_t rtag; lfs_ssize_t rid; @@ -4538,7 +4541,7 @@ static int lfsr_btree_set(lfs_t *lfs, lfsr_btree_t *btree, return err; } - // commit our id into the tree, letting lfsr_btree_commit take care + // commit our rid into the tree, letting lfsr_btree_commit take care // of the rest int degenerate = lfsr_btree_commit(lfs, btree, bid, 1, &rbyd, LFSR_BTREE_ATTRS( @@ -4582,7 +4585,7 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t bid) { // a normal btree } else { - // lookup in which leaf our id resides + // lookup in which leaf our rid resides lfsr_rbyd_t rbyd; lfsr_tag_t rtag; lfs_ssize_t rid; @@ -4593,7 +4596,7 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t bid) { return err; } - // remove our id, letting lfsr_btree_commit take care + // remove our rid, letting lfsr_btree_commit take care // of the rest // // note we use a cutoff of 2 here, if we have 2 entries before @@ -4796,7 +4799,7 @@ static int lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree, } LFS_ASSERT(branch.weight == weight__); - // found our id + // found our rid } else { // TODO how many of these should be conditional? if (bid_) { @@ -5120,23 +5123,23 @@ static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir, } static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, - lfs_ssize_t id, lfsr_tag_t tag, - lfs_ssize_t *id_, lfsr_tag_t *tag_, lfsr_data_t *data_) { - return lfsr_rbyd_lookupnext(lfs, &mdir->u.r.rbyd, id, tag, - id_, tag_, NULL, data_); + lfs_ssize_t rid, lfsr_tag_t tag, + lfs_ssize_t *rid_, lfsr_tag_t *tag_, lfsr_data_t *data_) { + return lfsr_rbyd_lookupnext(lfs, &mdir->u.r.rbyd, rid, tag, + rid_, tag_, NULL, data_); } static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir, - lfs_ssize_t id, lfsr_tag_t tag, + lfs_ssize_t rid, lfsr_tag_t tag, lfsr_tag_t *tag_, lfsr_data_t *data_) { - return lfsr_rbyd_lookup(lfs, &mdir->u.r.rbyd, id, tag, tag_, data_); + return lfsr_rbyd_lookup(lfs, &mdir->u.r.rbyd, rid, tag, tag_, data_); } // TODO do we need this? // TODO move this into the tests? static lfs_ssize_t lfsr_mdir_get(lfs_t *lfs, const lfsr_mdir_t *mdir, - lfs_ssize_t id, lfsr_tag_t tag, void *buffer, lfs_size_t size) { - return lfsr_rbyd_get(lfs, &mdir->u.r.rbyd, id, tag, buffer, size); + lfs_ssize_t rid, lfsr_tag_t tag, void *buffer, lfs_size_t size) { + return lfsr_rbyd_get(lfs, &mdir->u.r.rbyd, rid, tag, buffer, size); } @@ -5287,7 +5290,7 @@ enum { // low-level mdir compaction static int lfsr_mdir_compact_(lfs_t *lfs, lfsr_mdir_t *mdir_, lfs_ssize_t reason, - lfs_ssize_t start_id, lfs_ssize_t end_id, + lfs_ssize_t start_rid, lfs_ssize_t end_rid, const lfsr_mdir_t *mdir, const lfsr_attr_t *attr1s, lfs_size_t attr1_count, const lfsr_attr_t *attr2s, lfs_size_t attr2_count) { @@ -5370,7 +5373,7 @@ static int lfsr_mdir_compact_(lfs_t *lfs, lfsr_mdir_t *mdir_, // copy over attrs err = lfsr_rbyd_compact(lfs, &mdir_->u.r.rbyd, - start_id, end_id, &mdir->u.r.rbyd); + start_rid, end_rid, &mdir->u.r.rbyd); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -5380,7 +5383,7 @@ static int lfsr_mdir_compact_(lfs_t *lfs, lfsr_mdir_t *mdir_, // // upper layers should make sure this can't fail by limiting the // maximum commit size - err = lfsr_rbyd_appendall(lfs, &mdir_->u.r.rbyd, start_id, end_id, + err = lfsr_rbyd_appendall(lfs, &mdir_->u.r.rbyd, start_rid, end_rid, attr1s, attr1_count); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -5445,8 +5448,8 @@ static int lfsr_mdir_compact_(lfs_t *lfs, lfsr_mdir_t *mdir_, // low-level mdir commit, does not handle mtree/mlist updates static int lfsr_mdir_commit_(lfs_t *lfs, lfsr_mdir_t *mdir, - lfs_ssize_t start_id, lfs_ssize_t end_id, - lfs_size_t *split_id_, + lfs_ssize_t start_rid, lfs_ssize_t end_rid, + lfs_size_t *split_rid_, const lfsr_attr_t *attrs, lfs_size_t attr_count) { // try to append a commit lfsr_mdir_t mdir_ = *mdir; @@ -5454,7 +5457,7 @@ static int lfsr_mdir_commit_(lfs_t *lfs, lfsr_mdir_t *mdir, // TODO let the lower rbyd layer handle this somehow? // mark mdir as unerased in case we fail mdir->u.r.rbyd.off = lfs->cfg->block_size; - int err = lfsr_rbyd_appendall(lfs, &mdir_.u.r.rbyd, start_id, end_id, + int err = lfsr_rbyd_appendall(lfs, &mdir_.u.r.rbyd, start_rid, end_rid, attrs, attr_count); if (err && err != LFS_ERR_RANGE) { return err; @@ -5508,8 +5511,8 @@ compact:; // check if we're within our compaction threshold lfs_ssize_t estimate = lfsr_rbyd_estimateall(lfs, &mdir->u.r.rbyd, - start_id, end_id, - split_id_); + start_rid, end_rid, + split_rid_); if (estimate < 0) { return estimate; } @@ -5521,7 +5524,7 @@ compact:; // try to compact err = lfsr_mdir_compact_(lfs, &mdir_, LFSR_MDIR_COMPACTING, - start_id, end_id, mdir, + start_rid, end_rid, mdir, attrs, attr_count, NULL, 0); if (err) { @@ -5564,8 +5567,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // attempt to commit/compact the mdir normally lfsr_mdir_t mdir_ = *mdir; - lfs_size_t split_id; - int err = lfsr_mdir_commit_(lfs, &mdir_, -1, -1, &split_id, + lfs_size_t split_rid; + int err = lfsr_mdir_commit_(lfs, &mdir_, -1, -1, &split_rid, attrs, attr_count); if (err && err != LFS_ERR_RANGE) { return err; @@ -5619,17 +5622,17 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } } - // compact into new mdir tags < split_id + // compact into new mdir tags < split_rid lfsr_smbid_t mbid = lfs_smax32(mdir->mid.bid, 0); - int err = lfsr_mdir_compact_(lfs, &mdir_, mbid, 0, split_id, + int err = lfsr_mdir_compact_(lfs, &mdir_, mbid, 0, split_rid, mdir, attrs, attr_count, NULL, 0); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; } - // compact into new mdir tags >= split_id - err = lfsr_mdir_compact_(lfs, &msibling_, mbid, split_id, -1, + // compact into new mdir tags >= split_rid + err = lfsr_mdir_compact_(lfs, &msibling_, mbid, split_rid, -1, mdir, attrs, attr_count, NULL, 0); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -6028,10 +6031,10 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // TODO clean this up a bit? // adjust opened mdirs? if (opened_mdir->mid.bid == mdir->mid.bid - && opened_mdir->mid.rid >= attrs[i].id) { + && opened_mdir->mid.rid >= attrs[i].rid) { // removed? if (opened_mdir->mid.rid - < attrs[i].id - attrs[i].delta) { + < attrs[i].rid - attrs[i].delta) { // normal mdirs mark as dropped if (j == 0) { opened_mdir->u.r.rbyd.trunk = 0; @@ -6039,7 +6042,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } // for dir's second mdir (the position mdir), move // on to the next rid - opened_mdir->mid.rid = attrs[i].id; + opened_mdir->mid.rid = attrs[i].rid; } else { opened_mdir->mid.rid += attrs[i].delta; // adjust dir position? @@ -6107,17 +6110,17 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // lookup names in our mtree static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir, lfs_size_t did, const char *name, lfs_size_t name_size, - lfs_ssize_t *id_, lfsr_tag_t *tag_, lfsr_data_t *data_) { + lfs_ssize_t *rid_, lfsr_tag_t *tag_, lfsr_data_t *data_) { int err = lfsr_rbyd_namelookup(lfs, &mdir->u.r.rbyd, did, name, name_size, - id_, tag_, NULL, data_); + rid_, tag_, NULL, data_); - // When not found, lfsr_rbyd_namelookup returns the id smaller than our + // When not found, lfsr_rbyd_namelookup returns the rid smaller than our // expected name. This is correct for btree lookups, but not correct for // mdir insertions. For mdirs we need to adjust this by 1 so we insert - // _after_ the smaller id. - if (id_ && err == LFS_ERR_NOENT) { - *id_ += 1; + // _after_ the smaller rid. + if (rid_ && err == LFS_ERR_NOENT) { + *rid_ += 1; } return err; @@ -7208,7 +7211,7 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { return LFS_ERR_NAMETOOLONG; } - // Our directory needs an arbitrary directory-id. To find one with + // Our directory needs an arbitrary directory-rid. To find one with // hopefully few collisions, we use a hash of the full path using our CRC, // since we have it handy. // diff --git a/scripts/dbgbtree.py b/scripts/dbgbtree.py index e46215d2..f023d85c 100755 --- a/scripts/dbgbtree.py +++ b/scripts/dbgbtree.py @@ -310,7 +310,7 @@ class Rbyd: return cls(block, data, rev, off, trunk_, weight) - def lookup(self, id, tag): + def lookup(self, rid, tag): if not self: return True, 0, -1, 0, 0, 0, b'', [] @@ -326,9 +326,9 @@ class Rbyd: # found an alt? if alt & 0x4000: # follow? - if ((id, tag & 0xfff) > (upper-weight_-1, alt & 0xfff) + if ((rid, tag & 0xfff) > (upper-weight_-1, alt & 0xfff) if alt & 0x2000 - else ((id, tag & 0xfff) + else ((rid, tag & 0xfff) <= (lower+weight_, alt & 0xfff))): lower += upper-lower-1-weight_ if alt & 0x2000 else 0 upper -= upper-lower-1-weight_ if not alt & 0x2000 else 0 @@ -362,13 +362,13 @@ class Rbyd: # found tag else: - id_ = upper-1 + rid_ = upper-1 tag_ = alt - w_ = id_-lower + w_ = rid_-lower - done = not tag_ or (id_, tag_) < (id, tag) + done = not tag_ or (rid_, tag_) < (rid, tag) - return done, id_, tag_, w_, j, d, self.data[j+d:j+d+jump], path + return done, rid_, tag_, w_, j, d, self.data[j+d:j+d+jump], path def __bool__(self): return bool(self.trunk) @@ -381,29 +381,29 @@ class Rbyd: def __iter__(self): tag = 0 - id = -1 + rid = -1 while True: - done, id, tag, w, j, d, data, _ = self.lookup(id, tag+0x1) + done, rid, tag, w, j, d, data, _ = self.lookup(rid, tag+0x1) if done: break - yield id, tag, w, j, d, data + yield rid, tag, w, j, d, data # create tree representation for debugging def tree(self): trunks = co.defaultdict(lambda: (-1, 0)) alts = co.defaultdict(lambda: {}) - id, tag = -1, 0 + rid, tag = -1, 0 while True: - done, id, tag, w, j, d, data, path = self.lookup(id, tag+0x1) + done, rid, tag, w, j, d, data, path = self.lookup(rid, tag+0x1) # found end of tree? if done: break # keep track of trunks/alts - trunks[j] = (id, tag) + trunks[j] = (rid, tag) for j_, j__, followed, c in path: if followed: @@ -510,7 +510,7 @@ def main(disk, roots=None, *, print('btree %s, rev %d, weight %d' % ( btree.addr(), btree.rev, btree.weight)) - # look up an id, while keeping track of the search path + # look up a bid, while keeping track of the search path def btree_lookup(bid, *, depth=None): rbyd = btree diff --git a/scripts/dbglfs.py b/scripts/dbglfs.py index 6ba6b2df..cffc617f 100755 --- a/scripts/dbglfs.py +++ b/scripts/dbglfs.py @@ -316,7 +316,7 @@ class Rbyd: return cls(block, data, rev, off, trunk_, weight) - def lookup(self, id, tag): + def lookup(self, rid, tag): if not self: return True, 0, -1, 0, 0, 0, b'', [] @@ -332,9 +332,9 @@ class Rbyd: # found an alt? if alt & 0x4000: # follow? - if ((id, tag & 0xfff) > (upper-weight_-1, alt & 0xfff) + if ((rid, tag & 0xfff) > (upper-weight_-1, alt & 0xfff) if alt & 0x2000 - else ((id, tag & 0xfff) + else ((rid, tag & 0xfff) <= (lower+weight_, alt & 0xfff))): lower += upper-lower-1-weight_ if alt & 0x2000 else 0 upper -= upper-lower-1-weight_ if not alt & 0x2000 else 0 @@ -368,13 +368,13 @@ class Rbyd: # found tag else: - id_ = upper-1 + rid_ = upper-1 tag_ = alt - w_ = id_-lower + w_ = rid_-lower - done = not tag_ or (id_, tag_) < (id, tag) + done = not tag_ or (rid_, tag_) < (rid, tag) - return done, id_, tag_, w_, j, d, self.data[j+d:j+d+jump], path + return done, rid_, tag_, w_, j, d, self.data[j+d:j+d+jump], path def __bool__(self): return bool(self.trunk) @@ -387,14 +387,14 @@ class Rbyd: def __iter__(self): tag = 0 - id = -1 + rid = -1 while True: - done, id, tag, w, j, d, data, _ = self.lookup(id, tag+0x1) + done, rid, tag, w, j, d, data, _ = self.lookup(rid, tag+0x1) if done: break - yield id, tag, w, j, d, data + yield rid, tag, w, j, d, data # btree lookup with this rbyd as the root def btree_lookup(self, f, block_size, bid, *, diff --git a/scripts/dbgmtree.py b/scripts/dbgmtree.py index c40bf418..815ed5b7 100755 --- a/scripts/dbgmtree.py +++ b/scripts/dbgmtree.py @@ -318,7 +318,7 @@ class Rbyd: return cls(block, data, rev, off, trunk_, weight) - def lookup(self, id, tag): + def lookup(self, rid, tag): if not self: return True, 0, -1, 0, 0, 0, b'', [] @@ -334,9 +334,9 @@ class Rbyd: # found an alt? if alt & 0x4000: # follow? - if ((id, tag & 0xfff) > (upper-weight_-1, alt & 0xfff) + if ((rid, tag & 0xfff) > (upper-weight_-1, alt & 0xfff) if alt & 0x2000 - else ((id, tag & 0xfff) + else ((rid, tag & 0xfff) <= (lower+weight_, alt & 0xfff))): lower += upper-lower-1-weight_ if alt & 0x2000 else 0 upper -= upper-lower-1-weight_ if not alt & 0x2000 else 0 @@ -370,13 +370,13 @@ class Rbyd: # found tag else: - id_ = upper-1 + rid_ = upper-1 tag_ = alt - w_ = id_-lower + w_ = rid_-lower - done = not tag_ or (id_, tag_) < (id, tag) + done = not tag_ or (rid_, tag_) < (rid, tag) - return done, id_, tag_, w_, j, d, self.data[j+d:j+d+jump], path + return done, rid_, tag_, w_, j, d, self.data[j+d:j+d+jump], path def __bool__(self): return bool(self.trunk) @@ -389,29 +389,29 @@ class Rbyd: def __iter__(self): tag = 0 - id = -1 + rid = -1 while True: - done, id, tag, w, j, d, data, _ = self.lookup(id, tag+0x1) + done, rid, tag, w, j, d, data, _ = self.lookup(rid, tag+0x1) if done: break - yield id, tag, w, j, d, data + yield rid, tag, w, j, d, data # create tree representation for debugging def tree(self): trunks = co.defaultdict(lambda: (-1, 0)) alts = co.defaultdict(lambda: {}) - id, tag = -1, 0 + rid, tag = -1, 0 while True: - done, id, tag, w, j, d, data, path = self.lookup(id, tag+0x1) + done, rid, tag, w, j, d, data, path = self.lookup(rid, tag+0x1) # found end of tree? if done: break # keep track of trunks/alts - trunks[j] = (id, tag) + trunks[j] = (rid, tag) for j_, j__, followed, c in path: if followed: diff --git a/scripts/dbgrbyd.py b/scripts/dbgrbyd.py index 8a1dfbc2..85273c51 100755 --- a/scripts/dbgrbyd.py +++ b/scripts/dbgrbyd.py @@ -275,14 +275,14 @@ def dbg_log(data, block_size, rev, off, weight, *, return bool(self.tags) - # first figure out where each id comes from + # first figure out where each rid comes from weights = [] lifetimes = [] - def index(weights, id): + def index(weights, rid): for i, w in enumerate(weights): - if id < w: - return i, id - id -= w + if rid < w: + return i, rid + rid -= w return len(weights), 0 checkpoint_js = [0] @@ -317,18 +317,18 @@ def dbg_log(data, block_size, rev, off, weight, *, if not tag & 0x4000: wastrunk = False - # derive the current tag's id from alt weights + # derive the current tag's rid from alt weights delta = (lower_+upper_) - weight_ weight_ = lower_+upper_ - id = lower_ + w-1 + rid = lower_ + w-1 if (tag & 0xe000) != 0x2000 and not tag & 0x4000: # note we ignore out-of-bounds here for debugging if delta > 0: # grow lifetimes - i, id_ = index(weights, lower_) - if id_ > 0: - weights[i:i+1] = [id_, delta, weights[i]-id_] + i, rid_ = index(weights, lower_) + if rid_ > 0: + weights[i:i+1] = [rid_, delta, weights[i]-rid_] lifetimes[i:i+1] = [ lifetimes[i], Lifetime(j), lifetimes[i]] else: @@ -339,18 +339,18 @@ def dbg_log(data, block_size, rev, off, weight, *, elif delta < 0: # shrink lifetimes - i, id_ = index(weights, lower_) + i, rid_ = index(weights, lower_) delta_ = -delta weights_ = weights.copy() lifetimes_ = lifetimes.copy() shrinks = set() while delta_ > 0 and i < len(weights_): if weights_[i] > delta_: - delta__ = min(delta_, weights_[i]-id_) + delta__ = min(delta_, weights_[i]-rid_) delta_ -= delta__ weights_[i] -= delta__ i += 1 - id_ = 0 + rid_ = 0 else: delta_ -= weights_[i] weights_[i:i+1] = [] @@ -361,9 +361,9 @@ def dbg_log(data, block_size, rev, off, weight, *, weights = weights_ lifetimes = lifetimes_ - if id >= 0: + if rid >= 0: # attach tag to lifetime - i, id_ = index(weights, id) + i, rid_ = index(weights, rid) if i < len(weights): lifetimes[i].add(j) @@ -473,8 +473,8 @@ def dbg_log(data, block_size, rev, off, weight, *, if not tag & 0x4000: wastrunk = False - # derive the current tag's id from alt weights - id = lower_ + w-1 + # derive the current tag's rid from alt weights + rid = lower_ + w-1 # show human-readable tag representation print('%s%08x:%s %*s%s%*s %-57s%s%s' % ( @@ -484,8 +484,8 @@ def dbg_log(data, block_size, rev, off, weight, *, lifetime_width, lifetimerepr(j) if args.get('lifetimes') else '', '\x1b[90m' if color and j >= off else '', w_width, '' if (tag & 0xe000) != 0x0000 - else '%d-%d' % (id-(w-1), id) if w > 1 - else id, + else '%d-%d' % (rid-(w-1), rid) if w > 1 + else rid, '%-22s%s' % ( tagrepr(tag, w, size, j), ' %s' % next(xxd( @@ -548,7 +548,7 @@ def dbg_tree(data, block_size, rev, trunk, weight, *, # lookup a tag, returning also the search path for decoration # purposes - def lookup(id, tag): + def lookup(rid, tag): lower = -1 upper = weight path = [] @@ -561,9 +561,9 @@ def dbg_tree(data, block_size, rev, trunk, weight, *, # found an alt? if alt & 0x4000: # follow? - if ((id, tag & 0xfff) > (upper-w-1, alt & 0xfff) + if ((rid, tag & 0xfff) > (upper-w-1, alt & 0xfff) if alt & 0x2000 - else ((id, tag & 0xfff) <= (lower+w, alt & 0xfff))): + else ((rid, tag & 0xfff) <= (lower+w, alt & 0xfff))): lower += upper-lower-1-w if alt & 0x2000 else 0 upper -= upper-lower-1-w if not alt & 0x2000 else 0 j = j - jump @@ -596,13 +596,13 @@ def dbg_tree(data, block_size, rev, trunk, weight, *, # found tag else: - id_ = upper-1 + rid_ = upper-1 tag_ = alt - w_ = id_-lower + w_ = rid_-lower - done = not tag_ or (id_, tag_) < (id, tag) + done = not tag_ or (rid_, tag_) < (rid, tag) - return done, id_, tag_, w_, j, d, jump, path + return done, rid_, tag_, w_, j, d, jump, path # precompute tree t_width = 0 @@ -610,15 +610,15 @@ def dbg_tree(data, block_size, rev, trunk, weight, *, trunks = co.defaultdict(lambda: (-1, 0)) alts = co.defaultdict(lambda: {}) - id, tag = -1, 0 + rid, tag = -1, 0 while True: - done, id, tag, w, j, d, size, path = lookup(id, tag+0x1) + done, rid, tag, w, j, d, size, path = lookup(rid, tag+0x1) # found end of tree? if done: break # keep track of trunks/alts - trunks[j] = (id, tag) + trunks[j] = (rid, tag) for j_, j__, followed, c in path: if followed: @@ -698,7 +698,7 @@ def dbg_tree(data, block_size, rev, trunk, weight, *, if t_depth > 0: t_width = 2*t_depth + 2 - def treerepr(id, tag): + def treerepr(rid, tag): if t_depth == 0: return '' @@ -732,7 +732,7 @@ def dbg_tree(data, block_size, rev, trunk, weight, *, trunk = [] was = None for d in range(t_depth): - t, c, was = branchrepr((id, tag), d, was) + t, c, was = branchrepr((rid, tag), d, was) trunk.append('%s%s%s%s' % ( '\x1b[33m' if color and c == 'y' @@ -756,9 +756,9 @@ def dbg_tree(data, block_size, rev, trunk, weight, *, 'data (truncated)' if not args.get('no_truncate') else '')) - id, tag = -1, 0 + rid, tag = -1, 0 while True: - done, id, tag, w, j, d, size, path = lookup(id, tag+0x1) + done, rid, tag, w, j, d, size, path = lookup(rid, tag+0x1) # found end of tree? if done: break @@ -766,10 +766,10 @@ def dbg_tree(data, block_size, rev, trunk, weight, *, # show human-readable tag representation print('%08x: %s%-57s' % ( j, - treerepr(id, tag) if args.get('tree') else '', + treerepr(rid, tag) if args.get('tree') else '', '%*s %-22s%s' % ( - w_width, '%d-%d' % (id-(w-1), id) - if w > 1 else id + w_width, '%d-%d' % (rid-(w-1), rid) + if w > 1 else rid if w > 0 else '', tagrepr(tag, w, size, j), ' %s' % next(xxd( diff --git a/tests/test_btree.toml b/tests/test_btree.toml index 2904d2e3..4f4435cd 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -414,11 +414,11 @@ code = ''' uint32_t prng = SEED; for (lfs_size_t i = 0; i < N; i++) { - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % (sim_size+1); + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - int err = lfsr_btree_push(&lfs, &btree, id, LFSR_TAG_INLINED, 1, + int err = lfsr_btree_push(&lfs, &btree, bid, LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -427,8 +427,8 @@ code = ''' assert(err == 0); // add to sim - memmove(&sim[id+1], &sim[id], sim_size-id); - sim[id] = alphas[i % 26]; + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + sim[bid] = alphas[i % 26]; sim_size += 1; } @@ -522,20 +522,20 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t id_ = -1; + lfs_size_t bid_ = -1; lfsr_data_t data_; for (lfs_size_t i = 0; i < n; i++) { - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == i*W+W-1); + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => 0; + assert(bid_ == i*W+W-1); assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == W); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_push_sparse_fuzz] @@ -571,20 +571,20 @@ code = ''' uint32_t prng = SEED; for (lfs_size_t i = 0; i < N; i++) { - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % (sim_size+1); + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // choose a pseudo-random weight lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); - // calculate actual id in btree space - lfs_size_t weighted_id = 0; - for (lfs_size_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; + for (lfs_size_t j = 0; j < bid; j++) { + weighted_bid += sim_weights[j]; } // add to btree int err = lfsr_btree_push(&lfs, &btree, - weighted_id, LFSR_TAG_INLINED, weight, + weighted_bid, LFSR_TAG_INLINED, weight, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -593,11 +593,11 @@ code = ''' assert(err == 0); // add to sim - memmove(&sim[id+1], &sim[id], sim_size-id); - memmove(&sim_weights[id+1], &sim_weights[id], - (sim_size-id)*sizeof(lfs_size_t)); - sim[id] = alphas[i % 26]; - sim_weights[id] = weight; + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + memmove(&sim_weights[bid+1], &sim_weights[bid], + (sim_size-bid)*sizeof(lfs_size_t)); + sim[bid] = alphas[i % 26]; + sim_weights[bid] = weight; sim_size += 1; } @@ -605,17 +605,17 @@ code = ''' printf("expd: ["); bool first = true; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } if (!first) { printf(", "); } first = false; - printf("%dw%d=%c", weighted_id+sim_weights[i]-1, + printf("%dw%d=%c", weighted_bid+sim_weights[i]-1, sim_weights[i], sim[i]); } printf("]\n"); @@ -634,13 +634,13 @@ code = ''' lfsr_tag_t tag_; lfs_size_t weight_; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } - lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1, + lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == sim_weights[i]); @@ -652,26 +652,26 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t id_ = -1; + lfs_size_t bid_ = -1; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == weighted_id+sim_weights[i]-1); + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => 0; + assert(bid_ == weighted_bid+sim_weights[i]-1); assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -949,11 +949,11 @@ code = ''' uint32_t prng = SEED; for (lfs_size_t i = 0; i < N; i++) { - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % N; + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % N; // update btree - int err = lfsr_btree_set(&lfs, &btree, id, LFSR_TAG_INLINED, 1, + int err = lfsr_btree_set(&lfs, &btree, bid, LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&uppers[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -962,7 +962,7 @@ code = ''' assert(err == 0); // update sim - sim[id] = uppers[i % 26]; + sim[bid] = uppers[i % 26]; } // check that btree matches sim @@ -1071,20 +1071,20 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t id_ = -1; + lfs_size_t bid_ = -1; lfsr_data_t data_; for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == i*W+W-1); + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => 0; + assert(bid_ == i*W+W-1); assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == W); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &uppers[i % 26], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_update_sparse_fuzz] @@ -1135,20 +1135,20 @@ code = ''' uint32_t prng = SEED; for (lfs_size_t i = 0; i < N; i++) { - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % N; + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % N; // choose a pseudo-random weight lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); - // calculate actual id in btree space - lfs_size_t weighted_id = 0; - for (lfs_size_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; + for (lfs_size_t j = 0; j < bid; j++) { + weighted_bid += sim_weights[j]; } // update btree int err = lfsr_btree_set(&lfs, &btree, - weighted_id+sim_weights[id]-1, LFSR_TAG_INLINED, weight, + weighted_bid+sim_weights[bid]-1, LFSR_TAG_INLINED, weight, LFSR_DATA_BUF(&uppers[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1157,25 +1157,25 @@ code = ''' assert(err == 0); // update sim - sim[id] = uppers[i % 26]; - sim_weights[id] = weight; + sim[bid] = uppers[i % 26]; + sim_weights[bid] = weight; } // check that btree matches sim printf("expd: ["); bool first = true; for (lfs_size_t i = 0; i < N; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } if (!first) { printf(", "); } first = false; - printf("%dw%d=%c", weighted_id+sim_weights[i]-1, + printf("%dw%d=%c", weighted_bid+sim_weights[i]-1, sim_weights[i], sim[i]); } printf("]\n"); @@ -1194,13 +1194,13 @@ code = ''' lfsr_tag_t tag_; lfs_size_t weight_; for (lfs_size_t i = 0; i < N; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } - lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1, + lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == sim_weights[i]); @@ -1212,26 +1212,26 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t id_ = -1; + lfs_size_t bid_ = -1; lfsr_data_t data_; for (lfs_size_t i = 0; i < N; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == weighted_id+sim_weights[i]-1); + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => 0; + assert(bid_ == weighted_bid+sim_weights[i]-1); assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -1738,11 +1738,11 @@ code = ''' uint32_t prng = SEED; for (lfs_size_t i = 0; i < (N-REMAINING); i++) { - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % sim_size; + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % sim_size; // remove from btree - int err = lfsr_btree_pop(&lfs, &btree, id); + int err = lfsr_btree_pop(&lfs, &btree, bid); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -1750,7 +1750,7 @@ code = ''' assert(err == 0); // remove from sim - memmove(&sim[id], &sim[id+1], sim_size-(id+1)); + memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); sim_size -= 1; } @@ -1881,12 +1881,12 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t id_ = -1; + lfs_size_t bid_ = -1; lfsr_data_t data_; for (lfs_size_t i = 0; i < REMAINING; i++) { - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == i*W+W-1); + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => 0; + assert(bid_ == i*W+W-1); assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == W); @@ -1894,17 +1894,17 @@ code = ''' assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == REMAINING*W+W-1); + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => 0; + assert(bid_ == REMAINING*W+W-1); assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == W); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "R", 1) == 0); - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_pop_sparse_fuzz] @@ -1944,14 +1944,14 @@ code = ''' // choose a pseudo-random weight lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } int err = lfsr_btree_push(&lfs, &btree, - weighted_id, LFSR_TAG_INLINED, weight, + weighted_bid, LFSR_TAG_INLINED, weight, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1969,18 +1969,18 @@ code = ''' } for (lfs_size_t i = 0; i < (N-REMAINING); i++) { - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % sim_size; + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % sim_size; - // calculate actual id in btree space - lfs_size_t weighted_id = 0; - for (lfs_size_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; + for (lfs_size_t j = 0; j < bid; j++) { + weighted_bid += sim_weights[j]; } // remove from btree int err = lfsr_btree_pop(&lfs, &btree, - weighted_id+sim_weights[id]-1); + weighted_bid+sim_weights[bid]-1); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -1988,9 +1988,9 @@ code = ''' assert(err == 0); // remove from sim - memmove(&sim[id], &sim[id+1], sim_size-(id+1)); - memmove(&sim_weights[id], &sim_weights[id+1], - (sim_size-(id+1))*sizeof(lfs_size_t)); + memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); + memmove(&sim_weights[bid], &sim_weights[bid+1], + (sim_size-(bid+1))*sizeof(lfs_size_t)); sim_size -= 1; } @@ -1998,17 +1998,17 @@ code = ''' printf("expd: ["); bool first = true; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } if (!first) { printf(", "); } first = false; - printf("%dw%d=%c", weighted_id+sim_weights[i]-1, + printf("%dw%d=%c", weighted_bid+sim_weights[i]-1, sim_weights[i], sim[i]); } printf("]\n"); @@ -2027,13 +2027,13 @@ code = ''' lfsr_tag_t tag_; lfs_size_t weight_; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } - lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1, + lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == sim_weights[i]); @@ -2045,26 +2045,26 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t id_ = -1; + lfs_size_t bid_ = -1; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == weighted_id+sim_weights[i]-1); + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => 0; + assert(bid_ == weighted_bid+sim_weights[i]-1); assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -2161,11 +2161,11 @@ code = ''' uint32_t prng = SEED; for (lfs_size_t i = 1; i < N; i++) { - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % sim_size; + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % sim_size; // split btree - int err = lfsr_btree_split(&lfs, &btree, id, LFSR_DATA_NULL, + int err = lfsr_btree_split(&lfs, &btree, bid, LFSR_DATA_NULL, LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&alphas[i % 26], 1), LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&uppers[i % 26], 1)); // ignore space issues @@ -2175,9 +2175,9 @@ code = ''' assert(err == 0); // split sim - memmove(&sim[id+1], &sim[id], sim_size-id); - sim[id+0] = alphas[i % 26]; - sim[id+1] = uppers[i % 26]; + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + sim[bid+0] = alphas[i % 26]; + sim[bid+1] = uppers[i % 26]; sim_size += 1; } @@ -2312,21 +2312,21 @@ code = ''' uint32_t prng = SEED; for (lfs_size_t i = 1; i < N; i++) { - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % sim_size; + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % sim_size; // choose pseudo-random weights lfs_size_t weight1 = 1 + (TEST_PRNG(&prng) % W); lfs_size_t weight2 = 1 + (TEST_PRNG(&prng) % W); - // calculate actual id in btree space - lfs_size_t weighted_id = 0; - for (lfs_size_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; + for (lfs_size_t j = 0; j < bid; j++) { + weighted_bid += sim_weights[j]; } // split btree int err = lfsr_btree_split(&lfs, &btree, - weighted_id+sim_weights[id]-1, LFSR_DATA_NULL, + weighted_bid+sim_weights[bid]-1, LFSR_DATA_NULL, LFSR_TAG_INLINED, weight1, LFSR_DATA_BUF(&alphas[i % 26], 1), LFSR_TAG_INLINED, weight2, @@ -2338,13 +2338,13 @@ code = ''' assert(err == 0); // add to sim - memmove(&sim[id+1], &sim[id], sim_size-id); - memmove(&sim_weights[id+1], &sim_weights[id], - (sim_size-id)*sizeof(lfs_size_t)); - sim[id+0] = alphas[i % 26]; - sim[id+1] = uppers[i % 26]; - sim_weights[id+0] = weight1; - sim_weights[id+1] = weight2; + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + memmove(&sim_weights[bid+1], &sim_weights[bid], + (sim_size-bid)*sizeof(lfs_size_t)); + sim[bid+0] = alphas[i % 26]; + sim[bid+1] = uppers[i % 26]; + sim_weights[bid+0] = weight1; + sim_weights[bid+1] = weight2; sim_size += 1; } @@ -2352,17 +2352,17 @@ code = ''' printf("expd: ["); bool first = true; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } if (!first) { printf(", "); } first = false; - printf("%dw%d=%c", weighted_id+sim_weights[i]-1, + printf("%dw%d=%c", weighted_bid+sim_weights[i]-1, sim_weights[i], sim[i]); } printf("]\n"); @@ -2381,13 +2381,13 @@ code = ''' lfsr_tag_t tag_; lfs_size_t weight_; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } - lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1, + lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == sim_weights[i]); @@ -2399,26 +2399,26 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t id_ = -1; + lfs_size_t bid_ = -1; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == weighted_id+sim_weights[i]-1); + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => 0; + assert(bid_ == weighted_bid+sim_weights[i]-1); assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -2459,12 +2459,12 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { // choose a pseudo-random op uint8_t op = TEST_PRNG(&prng) % 3; - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % (sim_size+1); + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); - if (op == 0 || id == sim_size) { + if (op == 0 || bid == sim_size) { // push to btree - int err = lfsr_btree_push(&lfs, &btree, id, + int err = lfsr_btree_push(&lfs, &btree, bid, LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues @@ -2474,13 +2474,13 @@ code = ''' assert(err == 0); // push to sim - memmove(&sim[id+1], &sim[id], sim_size-id); - sim[id] = alphas[i % 26]; + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + sim[bid] = alphas[i % 26]; sim_size += 1; } else if (op == 1) { // update btree - int err = lfsr_btree_set(&lfs, &btree, id, + int err = lfsr_btree_set(&lfs, &btree, bid, LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues @@ -2490,11 +2490,11 @@ code = ''' assert(err == 0); // update sim - sim[id] = alphas[i % 26]; + sim[bid] = alphas[i % 26]; } else { // pop from btree - int err = lfsr_btree_pop(&lfs, &btree, id); + int err = lfsr_btree_pop(&lfs, &btree, bid); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2502,7 +2502,7 @@ code = ''' assert(err == 0); // pop from sim - memmove(&sim[id], &sim[id+1], sim_size-(id+1)); + memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); sim_size -= 1; } } @@ -2578,20 +2578,20 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { // choose a pseudo-random op uint8_t op = TEST_PRNG(&prng) % 3; - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % (sim_size+1); + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // choose a pseudo-random weight lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); - // calculate actual id in btree space - lfs_size_t weighted_id = 0; - for (lfs_size_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; + for (lfs_size_t j = 0; j < bid; j++) { + weighted_bid += sim_weights[j]; } - if (op == 0 || id == sim_size) { + if (op == 0 || bid == sim_size) { // push to btree - int err = lfsr_btree_push(&lfs, &btree, weighted_id, + int err = lfsr_btree_push(&lfs, &btree, weighted_bid, LFSR_TAG_INLINED, weight, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues @@ -2601,17 +2601,17 @@ code = ''' assert(err == 0); // push to sim - memmove(&sim[id+1], &sim[id], sim_size-id); - memmove(&sim_weights[id+1], &sim_weights[id], - (sim_size-id)*sizeof(lfs_size_t)); - sim[id] = alphas[i % 26]; - sim_weights[id] = weight; + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + memmove(&sim_weights[bid+1], &sim_weights[bid], + (sim_size-bid)*sizeof(lfs_size_t)); + sim[bid] = alphas[i % 26]; + sim_weights[bid] = weight; sim_size += 1; } else if (op == 1) { // update btree int err = lfsr_btree_set(&lfs, &btree, - weighted_id+sim_weights[id]-1, LFSR_TAG_INLINED, weight, + weighted_bid+sim_weights[bid]-1, LFSR_TAG_INLINED, weight, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -2620,13 +2620,13 @@ code = ''' assert(err == 0); // update sim - sim[id] = alphas[i % 26]; - sim_weights[id] = weight; + sim[bid] = alphas[i % 26]; + sim_weights[bid] = weight; } else { // remove from btree int err = lfsr_btree_pop(&lfs, &btree, - weighted_id+sim_weights[id]-1); + weighted_bid+sim_weights[bid]-1); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2634,9 +2634,9 @@ code = ''' assert(err == 0); // remove from sim - memmove(&sim[id], &sim[id+1], sim_size-(id+1)); - memmove(&sim_weights[id], &sim_weights[id+1], - (sim_size-(id+1))*sizeof(lfs_size_t)); + memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); + memmove(&sim_weights[bid], &sim_weights[bid+1], + (sim_size-(bid+1))*sizeof(lfs_size_t)); sim_size -= 1; } } @@ -2645,17 +2645,17 @@ code = ''' printf("expd: ["); bool first = true; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } if (!first) { printf(", "); } first = false; - printf("%dw%d=%c", weighted_id+sim_weights[i]-1, + printf("%dw%d=%c", weighted_bid+sim_weights[i]-1, sim_weights[i], sim[i]); } printf("]\n"); @@ -2674,13 +2674,13 @@ code = ''' lfsr_tag_t tag_; lfs_size_t weight_; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } - lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1, + lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == sim_weights[i]); @@ -2692,26 +2692,26 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // also test that we can traverse the tree without prior knowledge - lfs_size_t id_ = -1; + lfs_size_t bid_ = -1; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == weighted_id+sim_weights[i]-1); + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => 0; + assert(bid_ == weighted_bid+sim_weights[i]-1); assert(tag_ == LFSR_TAG_INLINED); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); } - lfsr_btree_lookupnext(&lfs, &btree, id_+1, - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_lookupnext(&lfs, &btree, bid_+1, + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // clean up sim free(sim); @@ -2742,12 +2742,12 @@ code = ''' // try to find tags lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3, - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_btree_find_one] @@ -2778,22 +2778,22 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 0); + assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 0); + assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); @@ -2830,30 +2830,30 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 0); + assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); lfsr_btree_namelookup(&lfs, &btree, 0, "aab", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 1); + assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); lfsr_btree_namelookup(&lfs, &btree, 0, "aac", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 1); + assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); @@ -2893,38 +2893,38 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 0); + assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 1); + assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 2); + assert(bid_ == 2); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "2", 1) == 0); lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 2); + assert(bid_ == 2); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "2", 1) == 0); @@ -2964,38 +2964,38 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 0); + assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 1); + assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 2); + assert(bid_ == 2); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "2", 1) == 0); lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == 2); + assert(bid_ == 2); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, "2", 1) == 0); @@ -3048,7 +3048,7 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; @@ -3058,9 +3058,9 @@ code = ''' }; lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == i); + assert(bid_ == i); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &nums[i % 10], 1) == 0); @@ -3111,17 +3111,17 @@ code = ''' }; // find where to split - lfs_size_t id = 0; - while (id+1 < sim_size && memcmp(sim_names[id+1], name, 3) <= 0) { - id += 1; + lfs_size_t bid = 0; + while (bid+1 < sim_size && memcmp(sim_names[bid+1], name, 3) <= 0) { + bid += 1; } // just skip exact matches for now - if (memcmp(sim_names[id], name, 3) == 0) { + if (memcmp(sim_names[bid], name, 3) == 0) { continue; } // split btree - int err = lfsr_btree_split(&lfs, &btree, id, + int err = lfsr_btree_split(&lfs, &btree, bid, LFSR_DATA_NAME(0, name, 3), LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&nums[i % 10], 1), LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&nums[i % 10], 1)); @@ -3132,11 +3132,11 @@ code = ''' assert(err == 0); // split sim - memmove(&sim[id+1], &sim[id], sim_size-id); - memmove(&sim_names[id+1], &sim_names[id], (sim_size-id)*3); - sim[id+0] = nums[i % 10]; - sim[id+1] = nums[i % 10]; - memcpy(&sim_names[id+1], name, 3); + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + memmove(&sim_names[bid+1], &sim_names[bid], (sim_size-bid)*3); + sim[bid+0] = nums[i % 10]; + sim[bid+1] = nums[i % 10]; + memcpy(&sim_names[bid+1], name, 3); sim_size += 1; } @@ -3159,14 +3159,14 @@ code = ''' uint8_t buffer[4]; lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == i); + assert(bid_ == i); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); @@ -3226,7 +3226,7 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; @@ -3236,9 +3236,9 @@ code = ''' }; lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == i*W+W-1); + assert(bid_ == i*W+W-1); assert(weight_ == W); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &nums[i % 10], 1) == 0); @@ -3296,24 +3296,24 @@ code = ''' lfs_size_t weight2 = 1 + (TEST_PRNG(&prng) % W); // find where to split - lfs_size_t id = 0; - while (id+1 < sim_size && memcmp(sim_names[id+1], name, 3) <= 0) { - id += 1; + lfs_size_t bid = 0; + while (bid+1 < sim_size && memcmp(sim_names[bid+1], name, 3) <= 0) { + bid += 1; } // just skip exact matches for now - if (memcmp(sim_names[id], name, 3) == 0) { + if (memcmp(sim_names[bid], name, 3) == 0) { continue; } - // calculate actual id in btree space - lfs_size_t weighted_id = 0; - for (lfs_size_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; + for (lfs_size_t j = 0; j < bid; j++) { + weighted_bid += sim_weights[j]; } // split btree int err = lfsr_btree_split(&lfs, &btree, - weighted_id+sim_weights[id]-1, + weighted_bid+sim_weights[bid]-1, LFSR_DATA_NAME(0, name, 3), LFSR_TAG_INLINED, weight1, LFSR_DATA_BUF(&nums[i % 10], 1), LFSR_TAG_INLINED, weight2, LFSR_DATA_BUF(&nums[i % 10], 1)); @@ -3324,15 +3324,15 @@ code = ''' assert(err == 0); // split sim - memmove(&sim[id+1], &sim[id], sim_size-id); - memmove(&sim_names[id+1], &sim_names[id], (sim_size-id)*3); - memmove(&sim_weights[id+1], &sim_weights[id], - (sim_size-id)*sizeof(lfs_size_t)); - sim[id+0] = nums[i % 10]; - sim[id+1] = nums[i % 10]; - memcpy(&sim_names[id+1], name, 3); - sim_weights[id+0] = weight1; - sim_weights[id+1] = weight2; + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + memmove(&sim_names[bid+1], &sim_names[bid], (sim_size-bid)*3); + memmove(&sim_weights[bid+1], &sim_weights[bid], + (sim_size-bid)*sizeof(lfs_size_t)); + sim[bid+0] = nums[i % 10]; + sim[bid+1] = nums[i % 10]; + memcpy(&sim_names[bid+1], name, 3); + sim_weights[bid+0] = weight1; + sim_weights[bid+1] = weight2; sim_size += 1; } @@ -3340,10 +3340,10 @@ code = ''' printf("expd: ["); bool first = true; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } if (!first) { @@ -3352,7 +3352,7 @@ code = ''' first = false; printf("%.3sid%dw%d=%c", sim_names[i], - weighted_id+sim_weights[i]-1, + weighted_bid+sim_weights[i]-1, sim_weights[i], sim[i]); } @@ -3370,20 +3370,20 @@ code = ''' uint8_t buffer[4]; lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == weighted_id+sim_weights[i]-1); + assert(bid_ == weighted_bid+sim_weights[i]-1); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); @@ -3436,8 +3436,8 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { // choose a pseudo-random op uint8_t op = TEST_PRNG(&prng) % 3; - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % (sim_size == 0 ? 1 : sim_size); + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % (sim_size == 0 ? 1 : sim_size); // choose a pseudo-random name lfs_size_t x = TEST_PRNG(&prng) % (26*26*26); char name[3] = { @@ -3447,27 +3447,27 @@ code = ''' // don't let sim drop below one element if (op == 0 || sim_size <= 1) { // find where to split - lfs_size_t id = 0; - while (id+1 < sim_size - && memcmp(sim_names[id+1], name, 3) <= 0) { - id += 1; + lfs_size_t bid = 0; + while (bid+1 < sim_size + && memcmp(sim_names[bid+1], name, 3) <= 0) { + bid += 1; } // just skip exact matches for now - if (memcmp(sim_names[id], name, 3) == 0) { + if (memcmp(sim_names[bid], name, 3) == 0) { continue; } // split btree - lfs_size_t split_id; + lfs_size_t split_bid; lfsr_data_t split_data; lfsr_btree_namelookup(&lfs, &btree, 0, name, 3, - &split_id, NULL, NULL, &split_data) => 0; + &split_bid, NULL, NULL, &split_data) => 0; uint8_t split_buf[4]; lfsr_data_read(&lfs, split_data, 0, split_buf, 4) => 1; - if (split_id > id) { + if (split_bid > bid) { int err = lfsr_btree_split(&lfs, &btree, - split_id, - LFSR_DATA_NAME(0, sim_names[id+1], 3), + split_bid, + LFSR_DATA_NAME(0, sim_names[bid+1], 3), LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&nums[i % 10], 1), LFSR_TAG_INLINED, 1, @@ -3479,7 +3479,7 @@ code = ''' assert(err == 0); } else { int err = lfsr_btree_split(&lfs, &btree, - split_id, LFSR_DATA_NAME(0, name, 3), + split_bid, LFSR_DATA_NAME(0, name, 3), LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(split_buf, 1), LFSR_TAG_INLINED, 1, @@ -3492,15 +3492,15 @@ code = ''' } // split sim - memmove(&sim[id+1], &sim[id], sim_size-id); - memmove(&sim_names[id+1], &sim_names[id], (sim_size-id)*3); - sim[id+1] = nums[i % 10]; - memcpy(&sim_names[id+1], name, 3); + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + memmove(&sim_names[bid+1], &sim_names[bid], (sim_size-bid)*3); + sim[bid+1] = nums[i % 10]; + memcpy(&sim_names[bid+1], name, 3); sim_size += 1; } else if (op == 1) { // update btree - int err = lfsr_btree_set(&lfs, &btree, id, + int err = lfsr_btree_set(&lfs, &btree, bid, LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&nums[i % 10], 1)); // ignore space issues @@ -3510,11 +3510,11 @@ code = ''' assert(err == 0); // update sim - sim[id] = nums[i % 10]; + sim[bid] = nums[i % 10]; } else { // pop from btree - int err = lfsr_btree_pop(&lfs, &btree, id); + int err = lfsr_btree_pop(&lfs, &btree, bid); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3522,13 +3522,13 @@ code = ''' assert(err == 0); // pop from sim - memmove(&sim[id], &sim[id+1], sim_size-(id+1)); - memmove(&sim_names[id], &sim_names[id+1], (sim_size-(id+1))*3); + memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); + memmove(&sim_names[bid], &sim_names[bid+1], (sim_size-(bid+1))*3); sim_size -= 1; // our B-tree doesn't actually track the name of id0, so we need // mirror this in our sim - if (id == 0) { + if (bid == 0) { memcpy(&sim_names[0], "___", 3); } } @@ -3553,14 +3553,14 @@ code = ''' uint8_t buffer[4]; lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == i); + assert(bid_ == i); assert(weight_ == 1); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); @@ -3614,8 +3614,8 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { // choose a pseudo-random op uint8_t op = TEST_PRNG(&prng) % 3; - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % (sim_size == 0 ? 1 : sim_size); + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % (sim_size == 0 ? 1 : sim_size); // choose a pseudo-random name lfs_size_t x = TEST_PRNG(&prng) % (26*26*26); char name[3] = { @@ -3624,43 +3624,43 @@ code = ''' // choose a pseudo-random weight lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); - // calculate actual id in btree space - lfs_size_t weighted_id = 0; - for (lfs_size_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; + for (lfs_size_t j = 0; j < bid; j++) { + weighted_bid += sim_weights[j]; } // don't let sim drop below one element if (op == 0 || sim_size <= 1) { // find where to split - lfs_size_t id = 0; - while (id+1 < sim_size - && memcmp(sim_names[id+1], name, 3) <= 0) { - id += 1; + lfs_size_t bid = 0; + while (bid+1 < sim_size + && memcmp(sim_names[bid+1], name, 3) <= 0) { + bid += 1; } // just skip exact matches for now - if (memcmp(sim_names[id], name, 3) == 0) { + if (memcmp(sim_names[bid], name, 3) == 0) { continue; } - // calculate actual id in btree space - lfs_size_t weighted_id = 0; - for (lfs_size_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; + for (lfs_size_t j = 0; j < bid; j++) { + weighted_bid += sim_weights[j]; } // split btree - lfs_size_t split_id; + lfs_size_t split_bid; lfs_size_t split_weight; lfsr_data_t split_data; lfsr_btree_namelookup(&lfs, &btree, 0, name, 3, - &split_id, NULL, &split_weight, + &split_bid, NULL, &split_weight, &split_data) => 0; uint8_t split_buf[4]; lfsr_data_read(&lfs, split_data, 0, split_buf, 4) => 1; - if (split_id > weighted_id+sim_weights[id]-1) { + if (split_bid > weighted_bid+sim_weights[bid]-1) { int err = lfsr_btree_split(&lfs, &btree, - split_id, LFSR_DATA_NAME(0, sim_names[id+1], 3), + split_bid, LFSR_DATA_NAME(0, sim_names[bid+1], 3), LFSR_TAG_INLINED, weight, LFSR_DATA_BUF(&nums[i % 10], 1), LFSR_TAG_INLINED, split_weight, @@ -3672,7 +3672,7 @@ code = ''' assert(err == 0); } else { int err = lfsr_btree_split(&lfs, &btree, - split_id, LFSR_DATA_NAME(0, name, 3), + split_bid, LFSR_DATA_NAME(0, name, 3), LFSR_TAG_INLINED, split_weight, LFSR_DATA_BUF(split_buf, 1), LFSR_TAG_INLINED, weight, @@ -3685,19 +3685,19 @@ code = ''' } // split sim - memmove(&sim[id+1], &sim[id], sim_size-id); - memmove(&sim_names[id+1], &sim_names[id], (sim_size-id)*3); - memmove(&sim_weights[id+1], &sim_weights[id], - (sim_size-id)*sizeof(lfs_size_t)); - sim[id+1] = nums[i % 10]; - memcpy(&sim_names[id+1], name, 3); - sim_weights[id+1] = weight; + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + memmove(&sim_names[bid+1], &sim_names[bid], (sim_size-bid)*3); + memmove(&sim_weights[bid+1], &sim_weights[bid], + (sim_size-bid)*sizeof(lfs_size_t)); + sim[bid+1] = nums[i % 10]; + memcpy(&sim_names[bid+1], name, 3); + sim_weights[bid+1] = weight; sim_size += 1; } else if (op == 1) { // update btree int err = lfsr_btree_set(&lfs, &btree, - weighted_id+sim_weights[id]-1, LFSR_TAG_INLINED, weight, + weighted_bid+sim_weights[bid]-1, LFSR_TAG_INLINED, weight, LFSR_DATA_BUF(&nums[i % 10], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -3706,13 +3706,13 @@ code = ''' assert(err == 0); // update sim - sim[id] = nums[i % 10]; - sim_weights[id] = weight; + sim[bid] = nums[i % 10]; + sim_weights[bid] = weight; } else { // pop from btree int err = lfsr_btree_pop(&lfs, &btree, - weighted_id+sim_weights[id]-1); + weighted_bid+sim_weights[bid]-1); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3720,15 +3720,15 @@ code = ''' assert(err == 0); // pop from sim - memmove(&sim[id], &sim[id+1], sim_size-(id+1)); - memmove(&sim_names[id], &sim_names[id+1], (sim_size-(id+1))*3); - memmove(&sim_weights[id], &sim_weights[id+1], - (sim_size-(id+1))*sizeof(lfs_size_t)); + memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); + memmove(&sim_names[bid], &sim_names[bid+1], (sim_size-(bid+1))*3); + memmove(&sim_weights[bid], &sim_weights[bid+1], + (sim_size-(bid+1))*sizeof(lfs_size_t)); sim_size -= 1; // our B-tree doesn't actually track the name of id0, so we need // mirror this in our sim - if (id == 0) { + if (bid == 0) { memcpy(&sim_names[0], "___", 3); } } @@ -3738,10 +3738,10 @@ code = ''' printf("expd: ["); bool first = true; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } if (!first) { @@ -3750,7 +3750,7 @@ code = ''' first = false; printf("%.3sid%dw%d=%c", sim_names[i], - weighted_id+sim_weights[i]-1, + weighted_bid+sim_weights[i]-1, sim_weights[i], sim[i]); } @@ -3768,20 +3768,20 @@ code = ''' uint8_t buffer[4]; lfsr_tag_t tag_; - lfs_size_t id_; + lfs_size_t bid_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - // calculate actual id in btree space - lfs_size_t weighted_id = 0; + // calculate actual bid in btree space + lfs_size_t weighted_bid = 0; for (lfs_size_t j = 0; j < i; j++) { - weighted_id += sim_weights[j]; + weighted_bid += sim_weights[j]; } lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, - &id_, &tag_, &weight_, &data_) => 0; + &bid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_INLINED); - assert(id_ == weighted_id+sim_weights[i]-1); + assert(bid_ == weighted_bid+sim_weights[i]-1); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, data_, 0, buffer, 4) => 1; assert(memcmp(buffer, &sim[i], 1) == 0); @@ -3945,11 +3945,11 @@ code = ''' uint32_t prng = SEED; for (lfs_size_t i = 0; i < N; i++) { - // choose a pseudo-random id - lfs_size_t id = TEST_PRNG(&prng) % (sim_size+1); + // choose a pseudo-random bid + lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - int err = lfsr_btree_push(&lfs, &btree, id, LFSR_TAG_INLINED, 1, + int err = lfsr_btree_push(&lfs, &btree, bid, LFSR_TAG_INLINED, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -3958,8 +3958,8 @@ code = ''' assert(err == 0); // add to sim - memmove(&sim[id+1], &sim[id], sim_size-id); - sim[id] = alphas[i % 26]; + memmove(&sim[bid+1], &sim[bid], sim_size-bid); + sim[bid] = alphas[i % 26]; sim_size += 1; } diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 72b28b90..27561790 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -124,7 +124,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // commit with one attribute @@ -134,21 +134,21 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; @@ -158,31 +158,31 @@ code = ''' LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; @@ -192,31 +192,31 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_lookup] @@ -234,7 +234,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // commit with one attribute @@ -244,21 +244,21 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; @@ -269,31 +269,31 @@ code = ''' LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; @@ -304,31 +304,31 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_get] @@ -506,7 +506,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // create a split in the leaves @@ -521,14 +521,14 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // split the other direction @@ -543,14 +543,14 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); ''' @@ -569,7 +569,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // ignore a black edge @@ -585,14 +585,14 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // flip a black edge @@ -608,14 +608,14 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); ''' @@ -634,7 +634,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // ignore a black edge @@ -652,19 +652,19 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // flip a black edge @@ -682,19 +682,19 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); ''' @@ -713,7 +713,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // ignore a red edge and black edge @@ -732,19 +732,19 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // ignore a red edge, flip a black edge @@ -763,19 +763,19 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // flip a red edge and black edge @@ -794,19 +794,19 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // flip a red edge, ignore a black edge @@ -825,19 +825,19 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); ''' @@ -856,7 +856,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // ignore a red edge and black edge @@ -877,24 +877,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // ignore a red edge, flip a black edge @@ -915,24 +915,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // flip a red edge and black edge @@ -953,24 +953,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // flip a red edge, ignore a black edge @@ -991,24 +991,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); ''' @@ -1027,7 +1027,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // all three the same @@ -1048,24 +1048,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // yellow and red alt the same @@ -1086,24 +1086,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // yellow and black alt the same @@ -1124,24 +1124,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // red and black alt the same @@ -1162,24 +1162,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); ''' @@ -1198,7 +1198,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // split a yellow triple, not taking any alt @@ -1222,24 +1222,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the black alt @@ -1263,24 +1263,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the red alt @@ -1302,24 +1302,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the yellow alt @@ -1341,24 +1341,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); ''' @@ -1377,7 +1377,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // split a yellow triple, not taking any alt @@ -1403,29 +1403,29 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the black alt @@ -1451,29 +1451,29 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the red alt @@ -1497,29 +1497,29 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // split a yellow triple, taking the yellow alt @@ -1543,29 +1543,29 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); ''' @@ -1584,7 +1584,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // don't prune @@ -1611,29 +1611,29 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // prune by taking a red alt @@ -1660,29 +1660,29 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // prune by taking a yellow alt (this needs to prune during the rflip) @@ -1709,29 +1709,29 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); ''' @@ -1750,7 +1750,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // don't prune @@ -1779,34 +1779,34 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(6), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(6)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // prune by taking a red alt @@ -1833,34 +1833,34 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(6), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(6)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); // prune by taking a yellow alt (this needs to prune during the rflip) @@ -1887,34 +1887,34 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(6), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(6)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); ''' @@ -1937,7 +1937,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // keep track of the worst case log size @@ -1979,9 +1979,9 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); } @@ -2028,7 +2028,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // keep track of the worst case log size @@ -2066,9 +2066,9 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); } @@ -2109,7 +2109,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // traverse requires correct biasing of the weights in the rbyd tree @@ -2122,31 +2122,31 @@ code = ''' LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -2156,31 +2156,31 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_traverse] @@ -2198,7 +2198,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // traverse requires correct biasing of the weights in the rbyd tree @@ -2212,31 +2212,31 @@ code = ''' LFSR_ATTR(-1, UATTR(2), 0, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -2247,31 +2247,31 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_traverse_permutations] @@ -2293,7 +2293,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // test all permutations of a given size @@ -2331,16 +2331,16 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; // try traversing all tags tag_ = 0; - id_ = -1; + rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -2365,7 +2365,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // test all permutations of a given size @@ -2400,16 +2400,16 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; // try traversing all tags tag_ = 0; - id_ = -1; + rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -2436,7 +2436,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // keep track of the worst case log size @@ -2495,9 +2495,9 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 6); } @@ -2546,7 +2546,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // create the rbyd tree @@ -2583,9 +2583,9 @@ code = ''' : (ORDER == 1) ? (((lfs_size_t)-1) - i) : TEST_PRNG(&prng); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(x & 0x7f), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(x & 0x7f)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); } ''' @@ -2608,7 +2608,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // add and remove one attribute @@ -2620,15 +2620,15 @@ code = ''' LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, remove the first one rbyd = init_rbyd; @@ -2640,31 +2640,31 @@ code = ''' LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, remove the second one rbyd = init_rbyd; @@ -2676,25 +2676,25 @@ code = ''' LFSR_ATTR(-1, RMUATTR(2), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' # NOTE if we separate physical/logical block sizes we may be able to @@ -2720,7 +2720,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // keep track of the worst case log size @@ -2780,7 +2780,7 @@ code = ''' for (unsigned k = 0; k < N; k++) { int err = lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(k+1), - &id_, &tag_, NULL, &data_); + &rid_, &tag_, NULL, &data_); assert(!err || err == LFS_ERR_NOENT); if (k == j) { if (j == N-1) { @@ -2788,12 +2788,12 @@ code = ''' } else { assert(!err); assert(tag_ == LFSR_TAG_UATTR(j+1+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); } } else { assert(tag_ == LFSR_TAG_UATTR(k+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); } } @@ -2809,14 +2809,14 @@ code = ''' for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(k+1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; if (k == j) { assert(tag_ == LFSR_TAG_UATTR(k+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 6); } else { assert(tag_ == LFSR_TAG_UATTR(k+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); } } @@ -2870,7 +2870,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // test all permutations of a given size @@ -2925,23 +2925,23 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; tag_ = 0; - id_ = -1; + rid_ = -1; for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; if (k >= j) { assert(tag_ == LFSR_TAG_UATTR(k+1+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); } else { assert(tag_ == LFSR_TAG_UATTR(k+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } // cleanup @@ -2964,7 +2964,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // create a tree two attributes @@ -2974,128 +2974,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_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &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_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(3), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(5), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // one last fetch to make sure nothing was broken lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_remove_again] @@ -3113,7 +3113,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // create a tree @@ -3132,205 +3132,205 @@ code = ''' LFSR_ATTR(-1, RMUATTR(5), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &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_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(3), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(5), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &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_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(3), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RMUATTR(5), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // one last fetch to make sure nothing was broken lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(4), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_remove_all] @@ -3348,7 +3348,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // commit with one attribute, remove it @@ -3360,15 +3360,15 @@ code = ''' LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, remove both rbyd = init_rbyd; @@ -3381,15 +3381,15 @@ code = ''' LFSR_ATTR(-1, RMUATTR(2), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // commit with two attributes, remove both in the other order rbyd = init_rbyd; @@ -3402,15 +3402,15 @@ code = ''' LFSR_ATTR(-1, RMUATTR(1), 0, NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' # NOTE if we separate physical/logical block sizes we may be able to @@ -3436,7 +3436,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; // keep track of the worst case log size @@ -3494,7 +3494,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } // try resuming from all tags being removed @@ -3504,13 +3504,13 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 6); for (unsigned j = 1; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } // keep track of the worst size @@ -3668,7 +3668,7 @@ code = ''' lfsr_rbyd_t rbyd; uint8_t buffer[4]; - // try to create one id + // try to create one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -3815,7 +3815,7 @@ code = ''' lfsr_rbyd_t rbyd; uint8_t buffer[4]; - // try to create one id + // try to create one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -4010,16 +4010,16 @@ code = ''' // build the attribute list for the current permutation struct lfsr_attr attrs[N]; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } attrs[j] = LFSR_ATTR( - id, REG, +1, names[perm[j] % 6], 4); + rid, REG, +1, names[perm[j] % 6], 4); } // test the given permutation @@ -4113,16 +4113,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; @@ -4170,7 +4170,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -4184,39 +4184,39 @@ code = ''' LFSR_ATTR(1, REG, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -4226,39 +4226,39 @@ code = ''' LFSR_ATTR(0, REG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_create_traverse] @@ -4276,7 +4276,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -4291,39 +4291,39 @@ code = ''' LFSR_ATTR(1, REG, +1, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -4334,39 +4334,39 @@ code = ''' LFSR_ATTR(0, REG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_create_traverse_permutations] @@ -4396,7 +4396,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -4422,16 +4422,16 @@ code = ''' // build the attribute list for the current permutation struct lfsr_attr attrs[N]; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } attrs[j] = LFSR_ATTR( - id, REG, +1, names[perm[j] % 6], 4); + rid, REG, +1, names[perm[j] % 6], 4); } // test the given permutation @@ -4443,19 +4443,19 @@ code = ''' assert(rbyd.weight == N); // try traversing all tags tag_ = 0; - id_ = -1; + rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == j); + assert(rid_ == j); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -4488,7 +4488,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -4515,35 +4515,35 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; assert(rbyd.weight == N); // try traversing all tags tag_ = 0; - id_ = -1; + rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == j); + assert(rid_ == j); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -4605,14 +4605,14 @@ code = ''' // // note with random order we can't check that stored values reliably lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, x, LFSR_TAG_REG, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == x); + assert(rid_ == x); assert(lfsr_data_size(data_) == 4); } ''' @@ -4636,7 +4636,7 @@ code = ''' lfsr_rbyd_t rbyd; uint8_t buffer[4]; - // try to create one id + // try to create one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -4870,7 +4870,7 @@ code = ''' lfsr_rbyd_t rbyd; uint8_t buffer[4]; - // try to create one id + // try to create one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -5165,20 +5165,20 @@ code = ''' // build the attribute list for the current permutation struct lfsr_attr attrs[(1+M)*N]; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } attrs[(1+M)*j] = LFSR_ATTR( - id, REG, +1, names[perm[j] % 6], 4); + rid, REG, +1, names[perm[j] % 6], 4); // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { attrs[(1+M)*j+1+u] = LFSR_ATTR( - id, UATTR(u+1), 0, names[perm[j] % 6], 2); + rid, UATTR(u+1), 0, names[perm[j] % 6], 2); } } @@ -5280,20 +5280,20 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UATTR(u+1), 0, + LFSR_ATTR(rid, UATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } @@ -5348,7 +5348,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -5364,67 +5364,67 @@ code = ''' LFSR_ATTR(1, UATTR(1), 0, "\xbb\xbb", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -5436,67 +5436,67 @@ code = ''' LFSR_ATTR(0, UATTR(1), 0, "\xaa\xaa", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_mixed_traverse] @@ -5514,7 +5514,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -5533,67 +5533,67 @@ code = ''' LFSR_ATTR(1, UATTR(1), 0, "\xbb\xbb", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -5608,67 +5608,67 @@ code = ''' LFSR_ATTR(0, UATTR(1), 0, "\xaa\xaa", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 1); + assert(rid_ == 1); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_mixed_traverse_permutations] @@ -5699,7 +5699,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -5725,20 +5725,20 @@ code = ''' // build the attribute list for the current permutation struct lfsr_attr attrs[(1+M)*N]; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } attrs[(1+M)*j] = LFSR_ATTR( - id, REG, +1, names[perm[j] % 6], 4); + rid, REG, +1, names[perm[j] % 6], 4); // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { attrs[(1+M)*j+1+u] = LFSR_ATTR( - id, UATTR(u+1), 0, names[perm[j] % 6], 2); + rid, UATTR(u+1), 0, names[perm[j] % 6], 2); } } @@ -5752,30 +5752,30 @@ code = ''' // try traversing all tags tag_ = 0; - id_ = -1; + rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == j); + assert(rid_ == j); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); - assert(id_ == j); + assert(rid_ == j); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, names[j % 6], 2) == 0); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -5809,7 +5809,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -5836,20 +5836,20 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UATTR(u+1), 0, + LFSR_ATTR(rid, UATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } @@ -5859,30 +5859,30 @@ code = ''' // try traversing all tags tag_ = 0; - id_ = -1; + rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == j); + assert(rid_ == j); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); - assert(id_ == j); + assert(rid_ == j); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, names[j % 6], 2) == 0); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } ''' @@ -6046,7 +6046,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -6077,20 +6077,20 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UATTR(u+1), 0, + LFSR_ATTR(rid, UATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } @@ -6104,7 +6104,7 @@ code = ''' // try removing each tag for (unsigned j = 0; j < N*M; j++) { // print what we are removing to help debugging - printf("--- remove: id%jd, %jd ---\n", j/M, (j%M)+1); + printf("--- remove: rid%jd, %jd ---\n", j/M, (j%M)+1); rbyd = backup_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; @@ -6123,7 +6123,7 @@ code = ''' for (unsigned u = 0; u < M; u++) { int err = lfsr_rbyd_lookupnext(&lfs, &rbyd, k, LFSR_TAG_UATTR(u+1), - &id_, &tag_, NULL, &data_); + &rid_, &tag_, NULL, &data_); assert(!err || err == LFS_ERR_NOENT); if (k == j/M && u == j%M) { if (u == M-1 && k == N-1) { @@ -6131,27 +6131,27 @@ code = ''' } else if (u == M-1) { assert(!err); assert(tag_ == LFSR_TAG_REG); - assert(id_ == k+1); + assert(rid_ == k+1); assert(lfsr_data_size(data_) == 4); } else { assert(!err); assert(tag_ == LFSR_TAG_UATTR(u+1+1)); - assert(id_ == k); + assert(rid_ == k); assert(lfsr_data_size(data_) == 2); } } else { assert(tag_ == LFSR_TAG_UATTR(u+1)); - assert(id_ == k); + assert(rid_ == k); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, names[k % 6], 2) == 0); } } } // try append the tag back to make sure things still work - printf("--- append: id%jd, %jd ---\n", j/M, (j%M)+1); + printf("--- append: rid%jd, %jd ---\n", j/M, (j%M)+1); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(j/M, UATTR((j%M)+1), 0, names[(j/M)%6], 3))) => 0; @@ -6163,20 +6163,20 @@ code = ''' for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k, LFSR_TAG_UATTR(u+1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; if (k == j/M && u == j%M) { assert(tag_ == LFSR_TAG_UATTR(u+1)); - assert(id_ == k); + assert(rid_ == k); assert(lfsr_data_size(data_) == 3); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 3; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 3; assert(memcmp(buffer, names[k % 6], 3) == 0); } else { assert(tag_ == LFSR_TAG_UATTR(u+1)); - assert(id_ == k); + assert(rid_ == k); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, names[k % 6], 2) == 0); } } @@ -6403,28 +6403,28 @@ code = ''' // // note with random order we can't check that stored values reliably lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, x, LFSR_TAG_REG, - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == x); + assert(rid_ == x); assert(lfsr_data_size(data_) == 4); for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, x, LFSR_TAG_UATTR(u+1), - &id_, &tag_, NULL, &data_) => 0; + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); - assert(id_ == x); + assert(rid_ == x); assert(lfsr_data_size(data_) == 2); } } ''' -### Test unrelated no-id tags ### +### Test unrelated no-rid tags ### [cases.test_rbyd_unrelated_create_permutations] defines.N = 'range(1, 8)' @@ -6483,11 +6483,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } @@ -6497,7 +6497,7 @@ code = ''' names[perm[j] % 6], 1))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; } @@ -6517,30 +6517,30 @@ code = ''' // try traversing tags lfsr_tag_t tag_ = 0; - lfs_ssize_t id_ = -1; + lfs_ssize_t rid_ = -1; lfsr_data_t data_; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 1); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 1; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 1; assert(memcmp(buffer, names[j % 6], 1) == 0); } for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == j); + assert(rid_ == j); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // keep track of the worst size if (rbyd.off > worst_size) { @@ -6622,11 +6622,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } @@ -6636,11 +6636,11 @@ code = ''' names[perm[j] % 6], 1))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UATTR(u+1), 0, + LFSR_ATTR(rid, UATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } @@ -6666,41 +6666,41 @@ code = ''' // try traversing tags lfsr_tag_t tag_ = 0; - lfs_ssize_t id_ = -1; + lfs_ssize_t rid_ = -1; lfsr_data_t data_; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); - assert(id_ == -1); + assert(rid_ == -1); assert(lfsr_data_size(data_) == 1); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 1; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 1; assert(memcmp(buffer, names[j % 6], 1) == 0); } for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == j); + assert(rid_ == j); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); - assert(id_ == j); + assert(rid_ == j); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; assert(memcmp(buffer, names[j % 6], 2) == 0); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // keep track of the worst size if (rbyd.off > worst_size) { @@ -6743,7 +6743,7 @@ code = ''' lfsr_rbyd_t rbyd; uint8_t buffer[4]; - // try to delete one id + // try to delete one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -6763,7 +6763,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - // try to delete the other id + // try to delete the other rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -6869,7 +6869,7 @@ code = ''' lfsr_rbyd_t rbyd; uint8_t buffer[4]; - // try to delete one id + // try to delete one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -6905,7 +6905,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => LFS_ERR_NOENT; - // try to delete the other id + // try to delete the other rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -7151,16 +7151,16 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -7170,7 +7170,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try deleting each id + // try deleting each rid for (unsigned j = 0; j < N; j++) { // print what we are deleting to help debugging printf("--- delete: %d ---\n", j); @@ -7198,7 +7198,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, N-1, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - // try recreating the id to make sure things still work + // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(j, REG, +1, names[j % 6], 6))) => 0; @@ -7305,20 +7305,20 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UATTR(u+1), 0, + LFSR_ATTR(rid, UATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } @@ -7330,7 +7330,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try deleting each id + // try deleting each rid for (unsigned j = 0; j < N; j++) { // print what we are deleting to help debugging printf("--- delete: %d ---\n", j); @@ -7370,7 +7370,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, N-1, LFSR_TAG_UATTR(1), buffer, 4) => LFS_ERR_NOENT; - // try recreating the id to make sure things still work + // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(j, REG, +1, names[j % 6], 6))) => 0; @@ -7466,7 +7466,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -7494,16 +7494,16 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -7513,7 +7513,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try deleting each id + // try deleting each rid for (unsigned j = 0; j < N; j++) { // print what we are deleting to help debugging printf("--- delete: %d ---\n", j); @@ -7533,15 +7533,15 @@ code = ''' assert(rbyd.weight == N-1); tag_ = 0; - id_ = -1; + rid_ = -1; for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k); + assert(rid_ == k); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { @@ -7549,8 +7549,8 @@ code = ''' } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } // cleanup @@ -7590,7 +7590,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfsr_data_t data_; uint8_t buffer[4]; @@ -7618,20 +7618,20 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UATTR(u+1), 0, + LFSR_ATTR(rid, UATTR(u+1), 0, names[perm[j] % 6], 2))) => 0; } } @@ -7643,7 +7643,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try deleting each id + // try deleting each rid for (unsigned j = 0; j < N; j++) { // print what we are deleting to help debugging printf("--- delete: %d ---\n", j); @@ -7663,15 +7663,15 @@ code = ''' assert(rbyd.weight == N-1); tag_ = 0; - id_ = -1; + rid_ = -1; for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k); + assert(rid_ == k); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { @@ -7679,13 +7679,13 @@ code = ''' } for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); - assert(id_ == k); + assert(rid_ == k); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 2) == 0); } else { @@ -7694,8 +7694,8 @@ code = ''' } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; } // cleanup @@ -7721,7 +7721,7 @@ code = ''' lfsr_rbyd_t rbyd; uint8_t buffer[4]; - // create and delete one id + // create and delete one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -7835,7 +7835,7 @@ code = ''' lfsr_rbyd_t rbyd; uint8_t buffer[4]; - // create and delete one id + // create and delete one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -8022,19 +8022,19 @@ code = ''' rbyd.block, 0, backup_block, rbyd.off) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; - // delete each id in permutation order + // delete each rid in permutation order for (unsigned j = 0; j < N; j++) { - // adjust id based on previous deletions - uint16_t id = perm[j]; + // adjust rid based on previous deletions + uint16_t rid = perm[j]; for (unsigned k = 0; k < j; k++) { if (perm[k] < perm[j]) { - id -= 1; + rid -= 1; } } lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UNR, -1, NULL, 0))) => 0; + LFSR_ATTR(rid, UNR, -1, NULL, 0))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -8169,19 +8169,19 @@ code = ''' rbyd.block, 0, backup_block, rbyd.off) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; - // delete each id in permutation order + // delete each rid in permutation order for (unsigned j = 0; j < N; j++) { - // adjust id based on previous deletions - uint16_t id = perm[j]; + // adjust rid based on previous deletions + uint16_t rid = perm[j]; for (unsigned k = 0; k < j; k++) { if (perm[k] < perm[j]) { - id -= 1; + rid -= 1; } } lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UNR, -1, NULL, 0))) => 0; + LFSR_ATTR(rid, UNR, -1, NULL, 0))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -8272,14 +8272,14 @@ code = ''' uint32_t prng = SEED; lfs_size_t count = 0; for (unsigned i = 0; i < N; i++) { - // choose an id - lfs_ssize_t id = TEST_PRNG(&prng) % (count+1); + // choose an rid + lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose create or delete - if (id == (lfs_ssize_t)count || (TEST_PRNG(&prng) & 1)) { - printf("c%d=%c", id, alpha[i % 26]); + if (rid == (lfs_ssize_t)count || (TEST_PRNG(&prng) & 1)) { + printf("c%d=%c", rid, alpha[i % 26]); count += 1; } else { - printf("d%d", id); + printf("d%d", rid); count -= 1; } if (i < N-1) { @@ -8300,55 +8300,55 @@ code = ''' prng = SEED; count = 0; for (unsigned i = 0; i < N; i++) { - // choose an id - lfs_ssize_t id = TEST_PRNG(&prng) % (count+1); + // choose an rid + lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose create or delete - if (id == (lfs_ssize_t)count || (TEST_PRNG(&prng) & 1)) { + if (rid == (lfs_ssize_t)count || (TEST_PRNG(&prng) & 1)) { // update our sim - memmove(sim+id+1, sim+id, count-id); - sim[id] = alpha[i % 26]; + memmove(sim+rid+1, sim+rid, count-rid); + sim[rid] = alpha[i % 26]; count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, &alpha[i % 26], 1))) => 0; + LFSR_ATTR(rid, REG, +1, &alpha[i % 26], 1))) => 0; } else { // update our sim - memmove(sim+id, sim+id+1, count-id-1); + memmove(sim+rid, sim+rid+1, count-rid-1); count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UNR, -1, NULL, 0))) => 0; + LFSR_ATTR(rid, UNR, -1, NULL, 0))) => 0; } } // compare rbyd vs simulation printf("expd: ["); - for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) { - printf("%c", sim[id]); - if (id < (lfs_ssize_t)count-1) { + for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + printf("%c", sim[rid]); + if (rid < (lfs_ssize_t)count-1) { printf(", "); } } printf("]\n"); printf("rbyd: ["); - for (lfs_ssize_t id = 0; id < (lfs_ssize_t)rbyd.weight; id++) { + for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)rbyd.weight; rid++) { lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd, - id, LFSR_TAG_REG, buffer, 4); + rid, LFSR_TAG_REG, buffer, 4); if (size >= 0) { printf("%.*s", size, buffer); } else { printf("?"); } - if (id < (lfs_ssize_t)count-1) { + if (rid < (lfs_ssize_t)count-1) { printf(", "); } } printf("]\n"); assert(count == rbyd.weight); - for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) { - lfsr_rbyd_get(&lfs, &rbyd, id, LFSR_TAG_REG, buffer, 4) => 1; - assert(memcmp(&sim[id], buffer, 1) == 0); + for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + lfsr_rbyd_get(&lfs, &rbyd, rid, LFSR_TAG_REG, buffer, 4) => 1; + assert(memcmp(&sim[rid], buffer, 1) == 0); } // cleanup @@ -8372,7 +8372,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; @@ -8383,17 +8383,17 @@ code = ''' LFSR_ATTR(0, REG, +1, "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); @@ -8402,29 +8402,29 @@ code = ''' LFSR_ATTR(1, REG, +2, "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); @@ -8433,41 +8433,41 @@ code = ''' LFSR_ATTR(3, REG, +3, "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); @@ -8476,53 +8476,53 @@ code = ''' LFSR_ATTR(6, REG, +4, "\xdd\xdd\xdd\xdd", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); @@ -8531,65 +8531,65 @@ code = ''' LFSR_ATTR(10, REG, +5, "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 5); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 5); assert(lfsr_data_size(data_) == 4); ''' @@ -8609,7 +8609,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; @@ -8629,71 +8629,71 @@ code = ''' // traverse, finding tags and weights lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 5); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 5); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_sparse_permutations] @@ -8726,7 +8726,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[4]; @@ -8754,25 +8754,25 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, REG, +W, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid*W, REG, +W, names[perm[j] % 6], 4))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; assert(rbyd.weight == N*W); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == j*W+W-1); + assert(rid_ == j*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); @@ -8812,7 +8812,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[4]; @@ -8840,36 +8840,36 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, REG, +W, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid*W, REG, +W, names[perm[j] % 6], 4))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; assert(rbyd.weight == N*W); // try traversing all tags tag_ = 0; - id_ = -1; + rid_ = -1; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == j*W+W-1); + assert(rid_ == j*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; } ''' @@ -8889,7 +8889,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; @@ -8903,53 +8903,53 @@ code = ''' LFSR_ATTR(0, UATTR(2), 0, "\xaa\xaa", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); @@ -8961,89 +8961,89 @@ code = ''' LFSR_ATTR(2, UATTR(2), 0, "\xbb\xbb", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); @@ -9055,125 +9055,125 @@ code = ''' LFSR_ATTR(5, UATTR(2), 0, "\xcc\xcc", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); @@ -9185,161 +9185,161 @@ code = ''' LFSR_ATTR(9, UATTR(2), 0, "\xdd\xdd", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); @@ -9351,197 +9351,197 @@ code = ''' LFSR_ATTR(14, UATTR(2), 0, "\xee\xee", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 5); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 2, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 5, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 9, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 5); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, 14, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); ''' @@ -9561,7 +9561,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; @@ -9596,203 +9596,203 @@ code = ''' // traverse, finding tags and weights lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 5); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 0); + assert(rid_ == 0); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 2); + assert(rid_ == 2); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 3); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 5); + assert(rid_ == 5); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 4); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 9); + assert(rid_ == 9); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 5); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == 14); + assert(rid_ == 14); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_sparse_mixed_permutations] @@ -9825,7 +9825,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[4]; @@ -9856,47 +9856,47 @@ code = ''' LFSR_ATTR(-1, UATTR(3), 0, "unrelated", 9))) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, REG, +1, names[perm[j] % 6], 4), - LFSR_ATTR(id*W, UATTR(1), 0, names[perm[j] % 6], 2), - LFSR_ATTR(id*W, UNR, +W-1, NULL, 0), - LFSR_ATTR(id*W+W-1, UATTR(2), 0, + LFSR_ATTR(rid*W, REG, +1, names[perm[j] % 6], 4), + LFSR_ATTR(rid*W, UATTR(1), 0, names[perm[j] % 6], 2), + LFSR_ATTR(rid*W, UNR, +W-1, NULL, 0), + LFSR_ATTR(rid*W+W-1, UATTR(2), 0, names[perm[j] % 6], 2))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == j*W+W-1); + assert(rid_ == j*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); lfsr_rbyd_lookupnext(&lfs, &rbyd, j*W+W-1, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == j*W+W-1); + assert(rid_ == j*W+W-1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); lfsr_rbyd_lookupnext(&lfs, &rbyd, j*W+W-1, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == j*W+W-1); + assert(rid_ == j*W+W-1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); @@ -9936,7 +9936,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[4]; @@ -9967,19 +9967,19 @@ code = ''' LFSR_ATTR(-1, UATTR(3), 0, "unrelated", 9))) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, REG, +1, names[perm[j] % 6], 4), - LFSR_ATTR(id*W, UATTR(1), 0, names[perm[j] % 6], 2), - LFSR_ATTR(id*W, UNR, +W-1, NULL, 0), - LFSR_ATTR(id*W+W-1, UATTR(2), 0, + LFSR_ATTR(rid*W, REG, +1, names[perm[j] % 6], 4), + LFSR_ATTR(rid*W, UATTR(1), 0, names[perm[j] % 6], 2), + LFSR_ATTR(rid*W, UNR, +W-1, NULL, 0), + LFSR_ATTR(rid*W+W-1, UATTR(2), 0, names[perm[j] % 6], 2))) => 0; } @@ -9987,39 +9987,39 @@ code = ''' assert(rbyd.weight == N*W); // try traversing all tags tag_ = 0; - id_ = -1; - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + rid_ = -1; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); - assert(id_ == -1); + assert(rid_ == -1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 9); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == j*W+W-1); + assert(rid_ == j*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == j*W+W-1); + assert(rid_ == j*W+W-1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == j*W+W-1); + assert(rid_ == j*W+W-1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; } ''' @@ -10057,7 +10057,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[4]; @@ -10085,16 +10085,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, REG, +W, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid*W, REG, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -10104,7 +10104,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try growing each id + // try growing each rid for (unsigned j = 0; j < N; j++) { // print what we are growing to help debugging printf("--- growing: %d ---\n", j); @@ -10124,28 +10124,28 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1+D); + assert(rid_ == k*W+W-1+D); assert(weight_ == W+D); assert(lfsr_data_size(data_) == 4); } else if (k > j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1+D); + assert(rid_ == k*W+W-1+D); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); } else { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); } - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -10183,7 +10183,7 @@ code = ''' "\xff\xff\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[6]; @@ -10211,16 +10211,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, REG, +W, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid*W, REG, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -10230,7 +10230,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try growing each id + // try growing each rid for (unsigned j = 0; j < N; j++) { // print what we are growing to help debugging printf("--- growing: %d ---\n", j); @@ -10251,33 +10251,33 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1+D); + assert(rid_ == k*W+W-1+D); assert(weight_ == W+D); assert(lfsr_data_size(data_) == 6); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 6; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else if (k > j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1+D); + assert(rid_ == k*W+W-1+D); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -10318,7 +10318,7 @@ code = ''' "\xff\xff\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[6]; @@ -10346,16 +10346,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, UATTR(2), +W, + LFSR_ATTR(rid*W, UATTR(2), +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -10366,7 +10366,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try growing each id + // try growing each rid for (unsigned j = 0; j < N; j++) { // print what we are growing to help debugging printf("--- growing: %d ---\n", j); @@ -10388,46 +10388,46 @@ code = ''' if (k == j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == k*W+W-1+D); + assert(rid_ == k*W+W-1+D); assert(weight_ == W+D); assert(lfsr_data_size(data_) == 6); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 6; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == k*W+W-1+D); + assert(rid_ == k*W+W-1+D); assert(weight_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else if (k > j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1+D, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == k*W+W-1+D); + assert(rid_ == k*W+W-1+D); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -10466,7 +10466,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[4]; @@ -10494,16 +10494,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, REG, +W, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid*W, REG, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -10513,7 +10513,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try shrinking each id + // try shrinking each rid for (unsigned j = 0; j < N; j++) { // print what we are shrinking to help debugging printf("--- shrinking: %d ---\n", j); @@ -10533,28 +10533,28 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1-D); + assert(rid_ == k*W+W-1-D); assert(weight_ == W-D); assert(lfsr_data_size(data_) == 4); } else if (k > j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1-D); + assert(rid_ == k*W+W-1-D); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); } else { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); } - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -10592,7 +10592,7 @@ code = ''' "\xff\xff\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[6]; @@ -10620,16 +10620,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, REG, +W, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid*W, REG, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -10639,7 +10639,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try shrinking each id + // try shrinking each rid for (unsigned j = 0; j < N; j++) { // print what we are shrinking to help debugging printf("--- shrinking: %d ---\n", j); @@ -10660,33 +10660,33 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1-D); + assert(rid_ == k*W+W-1-D); assert(weight_ == W-D); assert(lfsr_data_size(data_) == 6); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 6; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else if (k > j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1-D); + assert(rid_ == k*W+W-1-D); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -10727,7 +10727,7 @@ code = ''' "\xff\xff\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[6]; @@ -10755,16 +10755,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, UATTR(2), +W, + LFSR_ATTR(rid*W, UATTR(2), +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -10775,7 +10775,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try shrinking each id + // try shrinking each rid for (unsigned j = 0; j < N; j++) { // print what we are shrinking to help debugging printf("--- shrinking: %d ---\n", j); @@ -10797,46 +10797,46 @@ code = ''' if (k == j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == k*W+W-1-D); + assert(rid_ == k*W+W-1-D); assert(weight_ == W-D); assert(lfsr_data_size(data_) == 6); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 6; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == k*W+W-1-D); + assert(rid_ == k*W+W-1-D); assert(weight_ == 0); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else if (k > j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1-D, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == k*W+W-1-D); + assert(rid_ == k*W+W-1-D); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } else { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_UATTR(2), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -10874,7 +10874,7 @@ code = ''' "\xff\xff\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[6]; @@ -10902,16 +10902,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, REG, +W, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid*W, REG, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -10921,7 +10921,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try deleting each id + // try deleting each rid for (unsigned j = 0; j < N; j++) { // print what we are deleting to help debugging printf("--- deleting: %d ---\n", j); @@ -10941,28 +10941,28 @@ code = ''' for (unsigned k = 0; k < N-1; k++) { if (k >= j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } - // try recreating the id to make sure things still work + // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(j*W, REG, +W, names[j % 6], 6))) => 0; @@ -10973,23 +10973,23 @@ code = ''' for (unsigned k = 0; k < N; k++) { if (k == j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 6); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 6; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 6) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } } @@ -11027,7 +11027,7 @@ code = ''' "\xff\xff\xff\xff", }; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; uint8_t buffer[4]; @@ -11055,16 +11055,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id*W, REG, +W, names[perm[j] % 6], 4))) => 0; + LFSR_ATTR(rid*W, REG, +W, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -11074,7 +11074,7 @@ code = ''' lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; - // try appending an attr to each id, this should not affect + // try appending an attr to each rid, this should not affect // weights at all! for (unsigned j = 0; j < N; j++) { // print what we are appending to help debugging @@ -11094,21 +11094,21 @@ code = ''' assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); if (k == j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); } @@ -11124,13 +11124,13 @@ code = ''' assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); if (k == j) { @@ -11149,21 +11149,21 @@ code = ''' assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); if (k == j) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_UATTR(1), - &id_, &tag_, &weight_, &data_) => 0; + &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); - assert(id_ == k*W+W-1); + assert(rid_ == k*W+W-1); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); } @@ -11203,21 +11203,21 @@ code = ''' for (unsigned i = 0; i < N; i++) { // choose create/delete or attr append/remove uint8_t op = TEST_PRNG(&prng) % 4; - // choose an id - lfs_ssize_t id = TEST_PRNG(&prng) % (count+1); + // choose an rid + lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose an attr uint8_t u = TEST_PRNG(&prng) % M; - if (id == (lfs_ssize_t)count || op == 0) { - printf("c%d=%c", id, alpha[i % 26]); + if (rid == (lfs_ssize_t)count || op == 0) { + printf("c%d=%c", rid, alpha[i % 26]); count += 1; } else if (op == 1) { - printf("d%d", id); + printf("d%d", rid); count -= 1; } else if (op == 2) { - printf("a%d,%d=%c", id, u, alpha[i % 26]); + printf("a%d,%d=%c", rid, u, alpha[i % 26]); } else if (op == 3) { - printf("r%d,%d", id, u); + printf("r%d,%d", rid, u); } if (i < N-1) { printf(", "); @@ -11239,63 +11239,63 @@ code = ''' for (unsigned i = 0; i < N; i++) { // choose create/delete or attr append/remove uint8_t op = TEST_PRNG(&prng) % 4; - // choose an id - lfs_ssize_t id = TEST_PRNG(&prng) % (count+1); + // choose an rid + lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose an attr uint8_t u = TEST_PRNG(&prng) % M; - if (id == (lfs_ssize_t)count || op == 0) { + if (rid == (lfs_ssize_t)count || op == 0) { // update our sim - memmove(sim+(id+1)*(M+1), sim+id*(M+1), (count-id)*(M+1)); - memset(&sim[id*(M+1)], 0, M+1); - sim[id*(M+1)] = alpha[i % 26]; + memmove(sim+(rid+1)*(M+1), sim+rid*(M+1), (count-rid)*(M+1)); + memset(&sim[rid*(M+1)], 0, M+1); + sim[rid*(M+1)] = alpha[i % 26]; count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, &alpha[i % 26], 1))) => 0; + LFSR_ATTR(rid, REG, +1, &alpha[i % 26], 1))) => 0; } else if (op == 1) { // update our sim - memmove(sim+id*(M+1), sim+(id+1)*(M+1), (count-id-1)*(M+1)); + memmove(sim+rid*(M+1), sim+(rid+1)*(M+1), (count-rid-1)*(M+1)); count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UNR, -1, NULL, 0))) => 0; + LFSR_ATTR(rid, UNR, -1, NULL, 0))) => 0; } else if (op == 2) { // update our sim - sim[id*(M+1) + u+1] = alpha[i % 26]; + sim[rid*(M+1) + u+1] = alpha[i % 26]; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UATTR(u), 0, &alpha[i % 26], 1))) => 0; + LFSR_ATTR(rid, UATTR(u), 0, &alpha[i % 26], 1))) => 0; } else if (op == 3) { // update our sim - sim[id*(M+1) + u+1] = '\0'; + sim[rid*(M+1) + u+1] = '\0'; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, RMUATTR(u), 0, NULL, 0))) => 0; + LFSR_ATTR(rid, RMUATTR(u), 0, NULL, 0))) => 0; } } // compare rbyd vs simulation printf("expd: ["); - for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) { - printf("%c", sim[id*(M+1)]); + for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + printf("%c", sim[rid*(M+1)]); for (uint8_t u = 0; u < M; u++) { - if (sim[id*(M+1) + u+1]) { - printf("%c", sim[id*(M+1) + u+1]); + if (sim[rid*(M+1) + u+1]) { + printf("%c", sim[rid*(M+1) + u+1]); } else { printf("_"); } } - if (id < (lfs_ssize_t)count-1) { + if (rid < (lfs_ssize_t)count-1) { printf(", "); } } printf("]\n"); printf("rbyd: ["); - for (lfs_ssize_t id = 0; id < (lfs_ssize_t)rbyd.weight; id++) { + for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)rbyd.weight; rid++) { lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd, - id, LFSR_TAG_REG, buffer, 4); + rid, LFSR_TAG_REG, buffer, 4); if (size >= 0) { printf("%.*s", size, buffer); } else { @@ -11303,23 +11303,23 @@ code = ''' } for (uint8_t u = 0; u < M; u++) { lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd, - id, LFSR_TAG_UATTR(u), buffer, 4); + rid, LFSR_TAG_UATTR(u), buffer, 4); if (size >= 0) { printf("%.*s", size, buffer); } else { printf("_"); } } - if (id < (lfs_ssize_t)count-1) { + if (rid < (lfs_ssize_t)count-1) { printf(", "); } } printf("]\n"); assert(count == rbyd.weight); - for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) { - lfsr_rbyd_get(&lfs, &rbyd, id, LFSR_TAG_REG, buffer, 4) => 1; - assert(memcmp(&sim[id*(M+1)], buffer, 1) == 0); + for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + lfsr_rbyd_get(&lfs, &rbyd, rid, LFSR_TAG_REG, buffer, 4) => 1; + assert(memcmp(&sim[rid*(M+1)], buffer, 1) == 0); } // cleanup @@ -11346,7 +11346,7 @@ code = ''' }; lfsr_rbyd_t rbyd; lfsr_tag_t tag_; - lfs_ssize_t id_; + lfs_ssize_t rid_; lfs_size_t weight_; lfsr_data_t data_; const char *alpha = "abcdefghijklmnopqrstuvwxyz"; @@ -11358,21 +11358,21 @@ code = ''' for (unsigned i = 0; i < N; i++) { // choose create/delete/grow/shrink uint8_t op = TEST_PRNG(&prng) % 4; - // choose an id - lfs_ssize_t id = TEST_PRNG(&prng) % (count+1); + // choose an rid + lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose a weight lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); - if (id == (lfs_ssize_t)count || op == 0) { - printf("c%dw%d=%c", id, weight, alpha[i % 26]); + if (rid == (lfs_ssize_t)count || op == 0) { + printf("c%dw%d=%c", rid, weight, alpha[i % 26]); count += 1; } else if (op == 1) { - printf("d%d", id); + printf("d%d", rid); count -= 1; } else if (op == 2) { - printf("g%dw%d", id, weight); + printf("g%dw%d", rid, weight); } else if (op == 3) { - printf("s%dw%d", id, weight); + printf("s%dw%d", rid, weight); } if (i < N-1) { printf(", "); @@ -11396,88 +11396,88 @@ code = ''' for (unsigned i = 0; i < N; i++) { // choose create/delete/grow/shrink uint8_t op = TEST_PRNG(&prng) % 4; - // choose an id - lfs_ssize_t id = TEST_PRNG(&prng) % (count+1); + // choose an rid + lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); // choose a weight lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W); - // calculate actual id in rbyd space - lfs_ssize_t weighted_id = 0; - for (lfs_ssize_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + // calculate actual rid in rbyd space + lfs_ssize_t weighted_rid = 0; + for (lfs_ssize_t j = 0; j < rid; j++) { + weighted_rid += sim_weights[j]; } - if (id == (lfs_ssize_t)count || op == 0) { + if (rid == (lfs_ssize_t)count || op == 0) { // update our sim - memmove(sim+id+1, sim+id, count-id); - memmove(sim_weights+id+1, sim_weights+id, - (count-id)*sizeof(lfs_size_t)); - sim[id] = alpha[i % 26]; - sim_weights[id] = weight; + memmove(sim+rid+1, sim+rid, count-rid); + memmove(sim_weights+rid+1, sim_weights+rid, + (count-rid)*sizeof(lfs_size_t)); + sim[rid] = alpha[i % 26]; + sim_weights[rid] = weight; count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(weighted_id, REG, + LFSR_ATTR(weighted_rid, REG, +weight, &alpha[i % 26], 1))) => 0; } else if (op == 1) { // get the correct weight from the sim - weight_ = sim_weights[id]; + weight_ = sim_weights[rid]; // update our sim - memmove(sim+id, sim+id+1, count-id-1); - memmove(sim_weights+id, sim_weights+id+1, - (count-id-1)*sizeof(lfs_size_t)); + memmove(sim+rid, sim+rid+1, count-rid-1); + memmove(sim_weights+rid, sim_weights+rid+1, + (count-rid-1)*sizeof(lfs_size_t)); count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(weighted_id+weight_-1, UNR, + LFSR_ATTR(weighted_rid+weight_-1, UNR, -weight_, NULL, 0))) => 0; } else if (op == 2) { // get the correct weight from the sim - weight_ = sim_weights[id]; + weight_ = sim_weights[rid]; // update our sim - sim_weights[id] += weight; + sim_weights[rid] += weight; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(weighted_id+weight_-1, GROW, + LFSR_ATTR(weighted_rid+weight_-1, GROW, +weight, NULL, 0))) => 0; } else if (op == 3) { // get the correct weight from the sim - weight_ = sim_weights[id]; + weight_ = sim_weights[rid]; // don't let shrink go to zero here! this is already hard enough // to simulate weight = lfs_min(weight, weight_-1); // update our sim - sim_weights[id] -= weight; + sim_weights[rid] -= weight; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(weighted_id+weight_-1, GROW, + LFSR_ATTR(weighted_rid+weight_-1, GROW, -weight, NULL, 0))) => 0; } } // compare rbyd vs simulation printf("expd: ["); - for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) { - printf("%cw%d", sim[id], sim_weights[id]); - if (id < (lfs_ssize_t)count-1) { + for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + printf("%cw%d", sim[rid], sim_weights[rid]); + if (rid < (lfs_ssize_t)count-1) { printf(", "); } } printf("]\n"); printf("rbyd: ["); - for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) { - // calculate actual id in rbyd space - lfs_ssize_t weighted_id = 0; - for (lfs_ssize_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + // calculate actual rid in rbyd space + lfs_ssize_t weighted_rid = 0; + for (lfs_ssize_t j = 0; j < rid; j++) { + weighted_rid += sim_weights[j]; } int err = lfsr_rbyd_lookupnext(&lfs, &rbyd, - weighted_id, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_); + weighted_rid, LFSR_TAG_REG, + &rid_, &tag_, &weight_, &data_); if (!err) { lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd, - id_, tag_, buffer, 4); + rid_, tag_, buffer, 4); if (size >= 0) { printf("%.*sw%d", size, buffer, weight_); } else { @@ -11486,7 +11486,7 @@ code = ''' } else { printf("?"); } - if (id < (lfs_ssize_t)count-1) { + if (rid < (lfs_ssize_t)count-1) { printf(", "); } } @@ -11499,18 +11499,18 @@ code = ''' } assert(total_weight == rbyd.weight); - for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) { - // calculate actual id in rbyd space - lfs_ssize_t weighted_id = 0; - for (lfs_ssize_t j = 0; j < id; j++) { - weighted_id += sim_weights[j]; + for (lfs_ssize_t rid = 0; rid < (lfs_ssize_t)count; rid++) { + // calculate actual rid in rbyd space + lfs_ssize_t weighted_rid = 0; + for (lfs_ssize_t j = 0; j < rid; j++) { + weighted_rid += sim_weights[j]; } lfsr_rbyd_lookupnext(&lfs, &rbyd, - weighted_id, LFSR_TAG_REG, - &id_, &tag_, &weight_, &data_) => 0; - lfsr_rbyd_get(&lfs, &rbyd, id_, tag_, buffer, 4) => 1; - assert(memcmp(&sim[id], buffer, 1) == 0); + weighted_rid, LFSR_TAG_REG, + &rid_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 1; + assert(memcmp(&sim[rid], buffer, 1) == 0); } // cleanup @@ -11572,18 +11572,18 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } - // give each attr a subtype based on its id + SHIFT + // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4), - LFSR_ATTR(id, UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4), + LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); @@ -11659,18 +11659,18 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } - // give each attr a subtype based on its id + SHIFT + // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4), - LFSR_ATTR(id, UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4), + LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); @@ -11699,28 +11699,28 @@ code = ''' // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; lfsr_tag_t tag_ = 0; - lfs_ssize_t id_ = -1; + lfs_ssize_t rid_ = -1; lfs_size_t weight_; lfsr_data_t data_; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == k); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; + assert(rid_ == k); assert(tag_ == LFSR_TAG_REG); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); if (k != j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == k); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; + assert(rid_ == k); assert(tag_ == LFSR_TAG_UATTR((k + SHIFT) & 0x7f)); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { @@ -11796,18 +11796,18 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } - // give each attr a subtype based on its id + SHIFT + // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4), - LFSR_ATTR(id, UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4), + LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); @@ -11837,33 +11837,33 @@ code = ''' // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; lfsr_tag_t tag_ = 0; - lfs_ssize_t id_ = -1; + lfs_ssize_t rid_ = -1; lfs_size_t weight_; lfsr_data_t data_; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == k); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; + assert(rid_ == k); assert(tag_ == LFSR_TAG_REG); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; if (k == j) { - assert(id_ == k); + assert(rid_ == k); assert(tag_ == LFSR_TAG_UATTR(~(k + SHIFT) & 0x7f)); assert(weight_ == 0); assert(lfsr_data_size(data_) == 3); } else { - assert(id_ == k); + assert(rid_ == k); assert(tag_ == LFSR_TAG_UATTR((k + SHIFT) & 0x7f)); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { @@ -11935,20 +11935,20 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } - // give each attr a subtype based on its id + SHIFT + // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4), - LFSR_ATTR(id, UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4), + LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2), - LFSR_ATTR(id, SATTR(0), 0, names[perm[j] % 6], 1))) => 0; + LFSR_ATTR(rid, SATTR(0), 0, names[perm[j] % 6], 1))) => 0; } assert(rbyd.weight == N); @@ -12023,20 +12023,20 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } - // give each attr a subtype based on its id + SHIFT + // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4), - LFSR_ATTR(id, UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4), + LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2), - LFSR_ATTR(id, SATTR(0), 0, names[perm[j] % 6], 1))) => 0; + LFSR_ATTR(rid, SATTR(0), 0, names[perm[j] % 6], 1))) => 0; } assert(rbyd.weight == N); @@ -12064,35 +12064,35 @@ code = ''' // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; lfsr_tag_t tag_ = 0; - lfs_ssize_t id_ = -1; + lfs_ssize_t rid_ = -1; lfs_size_t weight_; lfsr_data_t data_; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == k); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; + assert(rid_ == k); assert(tag_ == LFSR_TAG_REG); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); if (k != j) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == k); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; + assert(rid_ == k); assert(tag_ == LFSR_TAG_UATTR((k + SHIFT) & 0x7f)); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == k); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; + assert(rid_ == k); assert(tag_ == LFSR_TAG_SATTR(0)); assert(weight_ == 0); assert(lfsr_data_size(data_) == 1); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { @@ -12168,20 +12168,20 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } - // give each attr a subtype based on its id + SHIFT + // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, REG, +1, names[perm[j] % 6], 4), - LFSR_ATTR(id, UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_ATTR(rid, REG, +1, names[perm[j] % 6], 4), + LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, names[perm[j] % 6], 2), - LFSR_ATTR(id, SATTR(0), 0, names[perm[j] % 6], 1))) => 0; + LFSR_ATTR(rid, SATTR(0), 0, names[perm[j] % 6], 1))) => 0; } assert(rbyd.weight == N); @@ -12210,40 +12210,40 @@ code = ''' // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; lfsr_tag_t tag_ = 0; - lfs_ssize_t id_ = -1; + lfs_ssize_t rid_ = -1; lfs_size_t weight_; lfsr_data_t data_; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == k); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; + assert(rid_ == k); assert(tag_ == LFSR_TAG_REG); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; if (k == j) { - assert(id_ == k); + assert(rid_ == k); assert(tag_ == LFSR_TAG_UATTR(~(k + SHIFT) & 0x7f)); assert(weight_ == 0); assert(lfsr_data_size(data_) == 3); } else { - assert(id_ == k); + assert(rid_ == k); assert(tag_ == LFSR_TAG_UATTR((k + SHIFT) & 0x7f)); assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; - assert(id_ == k); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; + assert(rid_ == k); assert(tag_ == LFSR_TAG_SATTR(0)); assert(weight_ == 0); assert(lfsr_data_size(data_) == 1); } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { @@ -12315,17 +12315,17 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } - // give each attr a subtype based on its id + SHIFT + // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UATTR((perm[j] + SHIFT) & 0x7f), +1, + LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), +1, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -12401,17 +12401,17 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } - // give each attr a subtype based on its id + SHIFT + // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UATTR((perm[j] + SHIFT) & 0x7f), +1, + LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), +1, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -12440,31 +12440,31 @@ code = ''' // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; lfsr_tag_t tag_ = 0; - lfs_ssize_t id_ = -1; + lfs_ssize_t rid_ = -1; lfs_size_t weight_; lfsr_data_t data_; for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; if (k == j) { - assert(id_ == k+1); + assert(rid_ == k+1); assert(tag_ == LFSR_TAG_UATTR((k+1 + SHIFT) & 0x7f)); assert(weight_ == 2); assert(lfsr_data_size(data_) == 4); } else if (k > j) { - assert(id_ == k+1); + assert(rid_ == k+1); assert(tag_ == LFSR_TAG_UATTR((k+1 + SHIFT) & 0x7f)); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); } else { - assert(id_ == k); + assert(rid_ == k); assert(tag_ == LFSR_TAG_UATTR((k + SHIFT) & 0x7f)); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { @@ -12540,17 +12540,17 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - // adjust id based on future insertions - uint16_t id = perm[j]; + // adjust rid based on future insertions + uint16_t rid = perm[j]; for (unsigned k = j+1; k < N; k++) { if (perm[j] > perm[k]) { - id -= 1; + rid -= 1; } } - // give each attr a subtype based on its id + SHIFT + // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(id, UATTR((perm[j] + SHIFT) & 0x7f), +1, + LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), +1, names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -12580,26 +12580,26 @@ code = ''' // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; lfsr_tag_t tag_ = 0; - lfs_ssize_t id_ = -1; + lfs_ssize_t rid_ = -1; lfs_size_t weight_; lfsr_data_t data_; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => 0; if (k == j) { - assert(id_ == k); + assert(rid_ == k); assert(tag_ == LFSR_TAG_UATTR(~(k + SHIFT) & 0x7f)); assert(weight_ == 1); assert(lfsr_data_size(data_) == 6); } else { - assert(id_ == k); + assert(rid_ == k); assert(tag_ == LFSR_TAG_UATTR((k + SHIFT) & 0x7f)); assert(weight_ == 1); assert(lfsr_data_size(data_) == 4); } } - lfsr_rbyd_lookupnext(&lfs, &rbyd, id_, lfsr_tag_next(tag_), - &id_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, lfsr_tag_next(tag_), + &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) {