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++) {