From bc587e7166e0c0dfd665c556771f1dafa7fba392 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Fri, 23 Aug 2024 10:41:23 -0500 Subject: [PATCH] Renamed lfsr_attr_t -> lfsr_rattr_t To avoid the obvious conflict with lfs_attr. Unlike lfsr_rattr_t, lfs_attr is user facing, so it gets priority. This name may change in the future if something better comes up, but in the meantime we need to change the name to _something_. Is this the reason Linux/BSD/etc call these xattrs? (Note littlefs's attrs are much more limited than xattrs. We should _not_ call these xattrs in case we want to add true xattrs in the future.) --- lfs.c | 824 ++++++------ lfs.h | 2 +- tests/test_badblocks.toml | 12 +- tests/test_btree.toml | 594 ++++----- tests/test_mount.toml | 64 +- tests/test_mtree.toml | 644 +++++----- tests/test_rbyd.toml | 2546 +++++++++++++++++++------------------ 7 files changed, 2344 insertions(+), 2342 deletions(-) diff --git a/lfs.c b/lfs.c index 88089b87..ea7e7e8d 100644 --- a/lfs.c +++ b/lfs.c @@ -1415,11 +1415,11 @@ enum lfsr_tag { // in-device only tags, these should never get written to disk LFSR_TAG_INTERNAL = 0x0800, - LFSR_TAG_ATTRS = 0x0800, + LFSR_TAG_RATTRS = 0x0800, LFSR_TAG_SHRUBCOMMIT = 0x0801, LFSR_TAG_SHRUBTRUNK = 0x0802, LFSR_TAG_MOVE = 0x0803, - LFSR_TAG_UATTRS = 0x0804, + LFSR_TAG_ATTRS = 0x0804, // some in-device only tag modifiers LFSR_TAG_RM = 0x8000, @@ -2199,7 +2199,7 @@ static int lfsr_bd_progdata(lfs_t *lfs, } // we can also treat leb128/lleb128 encoding has a high-level operation, -// which is useful for building attrs +// which is useful for building rattrs #define LFSR_LEB128_DSIZE 5 @@ -2246,7 +2246,7 @@ static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, // operations on attribute lists -typedef struct lfsr_attr { +typedef struct lfsr_rattr { lfsr_tag_t tag; int16_t count; lfsr_srid_t weight; @@ -2254,51 +2254,51 @@ typedef struct lfsr_attr { // sign(size)=1 => multiple concatenated datas // special tags => other things const void *cat; -} lfsr_attr_t; +} lfsr_rattr_t; -#define LFSR_ATTR_(_tag, _weight, _cat, _count) \ - ((lfsr_attr_t){ \ +#define LFSR_RATTR_(_tag, _weight, _cat, _count) \ + ((lfsr_rattr_t){ \ .tag=_tag, \ .count=(uint16_t){_count}, \ .weight=_weight, \ .cat=_cat}) -#define LFSR_ATTR(_tag, _weight, _data) \ - ((struct {lfsr_attr_t a;}){lfsr_attr(_tag, _weight, _data)}.a) +#define LFSR_RATTR(_tag, _weight, _data) \ + ((struct {lfsr_rattr_t a;}){lfsr_rattr(_tag, _weight, _data)}.a) -static inline lfsr_attr_t lfsr_attr( +static inline lfsr_rattr_t lfsr_rattr( lfsr_tag_t tag, lfsr_srid_t weight, lfsr_data_t data) { // only simple data works here LFS_ASSERT(lfsr_data_isbuf(data)); LFS_ASSERT(lfsr_data_size(data) <= 0x7fff); - return (lfsr_attr_t){ + return (lfsr_rattr_t){ .tag=tag, .count=lfsr_data_size(data), .weight=weight, .cat=data.u.buffer}; } -#define LFSR_ATTR_CAT_(_tag, _weight, _datas, _data_count) \ - ((lfsr_attr_t){ \ +#define LFSR_RATTR_CAT_(_tag, _weight, _datas, _data_count) \ + ((lfsr_rattr_t){ \ .tag=_tag, \ .count=-(uint16_t){_data_count}, \ .weight=_weight, \ .cat=_datas}) -#define LFSR_ATTR_CAT(_tag, _weight, ...) \ - LFSR_ATTR_CAT_( \ +#define LFSR_RATTR_CAT(_tag, _weight, ...) \ + LFSR_RATTR_CAT_( \ _tag, \ _weight, \ ((const lfsr_data_t[]){__VA_ARGS__}), \ sizeof((const lfsr_data_t[]){__VA_ARGS__}) / sizeof(lfsr_data_t)) -#define LFSR_ATTR_NOOP() \ - LFSR_ATTR_(LFSR_TAG_NULL, 0, NULL, 0) +#define LFSR_RATTR_NOOP() \ + LFSR_RATTR_(LFSR_TAG_NULL, 0, NULL, 0) // create an attribute list -#define LFSR_ATTRS(...) \ - (const lfsr_attr_t[]){__VA_ARGS__}, \ - sizeof((const lfsr_attr_t[]){__VA_ARGS__}) / sizeof(lfsr_attr_t) +#define LFSR_RATTRS(...) \ + (const lfsr_rattr_t[]){__VA_ARGS__}, \ + sizeof((const lfsr_rattr_t[]){__VA_ARGS__}) / sizeof(lfsr_rattr_t) // cat helpers static inline lfs_size_t lfsr_cat_size(const void *cat, int16_t count) { @@ -2344,31 +2344,31 @@ static int lfsr_bd_progcat(lfs_t *lfs, } } -// other attr helpers -static inline bool lfsr_attr_isnoop(lfsr_attr_t attr) { - // noop attrs must have zero weight - LFS_ASSERT(attr.tag || attr.weight == 0); - return !attr.tag; +// other rattr helpers +static inline bool lfsr_rattr_isnoop(lfsr_rattr_t rattr) { + // noop rattrs must have zero weight + LFS_ASSERT(rattr.tag || rattr.weight == 0); + return !rattr.tag; } -static inline bool lfsr_attr_isinsert(lfsr_attr_t attr) { - return !lfsr_tag_isgrow(attr.tag) && attr.weight > 0; +static inline bool lfsr_rattr_isinsert(lfsr_rattr_t rattr) { + return !lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0; } -static inline lfsr_srid_t lfsr_attr_nextrid(lfsr_attr_t attr, +static inline lfsr_srid_t lfsr_rattr_nextrid(lfsr_rattr_t rattr, lfsr_srid_t rid) { - if (lfsr_attr_isinsert(attr)) { - return rid + attr.weight-1; + if (lfsr_rattr_isinsert(rattr)) { + return rid + rattr.weight-1; } else { - return rid + attr.weight; + return rid + rattr.weight; } } -static inline lfs_size_t lfsr_attr_size(lfsr_attr_t attr) { - return lfsr_cat_size(attr.cat, attr.count); +static inline lfs_size_t lfsr_rattr_size(lfsr_rattr_t rattr) { + return lfsr_cat_size(rattr.cat, rattr.count); } -// special attrs - here be hacks +// special rattrs - here be hacks // special case for passing names, we need to cat but we don't need the // full lfsr_data_t @@ -2378,8 +2378,8 @@ typedef struct lfsr_data_name { const uint8_t *name; } lfsr_data_name_t; -#define LFSR_ATTR_NAME(_tag, _weight, _did, _name, _name_size) \ - LFSR_ATTR_CAT_( \ +#define LFSR_RATTR_NAME(_tag, _weight, _did, _name, _name_size) \ + LFSR_RATTR_CAT_( \ _tag, \ _weight, \ ((lfsr_data_t*)&(lfsr_data_name_t){ \ @@ -2388,48 +2388,48 @@ typedef struct lfsr_data_name { .name=(const void*)(_name)}), \ 2) -// hacky attrs - these end up handled as special cases in high-level +// hacky rattrs - these end up handled as special cases in high-level // commit layers -// chain another attr-list, only allowed as last attr -#define LFSR_ATTR_ATTRS(_tag, _weight, _attrs, _attr_count) \ - LFSR_ATTR_(_tag, _weight, (const lfsr_attr_t*){_attrs}, _attr_count) +// chain another rattr-list, only allowed as last rattr +#define LFSR_RATTR_RATTRS(_tag, _weight, _rattrs, _rattr_count) \ + LFSR_RATTR_(_tag, _weight, (const lfsr_rattr_t*){_rattrs}, _rattr_count) // chain a list of user attributes, these require a bit of last-minute // reencoding during commits -#define LFSR_ATTR_UATTRS(_tag, _weight, _attrs, _attr_count) \ - LFSR_ATTR_(_tag, _weight, (const struct lfs_attr*){_attrs}, _attr_count) +#define LFSR_RATTR_ATTRS(_tag, _weight, _attrs, _attr_count) \ + LFSR_RATTR_(_tag, _weight, (const struct lfs_attr*){_attrs}, _attr_count) -// a move of all attrs from an mdir entry -#define LFSR_ATTR_MOVE(_tag, _weight, _mdir) \ - LFSR_ATTR_(_tag, _weight, (const lfsr_mdir_t*){_mdir}, 0) +// a move of all rattrs from an mdir entry +#define LFSR_RATTR_MOVE(_tag, _weight, _mdir) \ + LFSR_RATTR_(_tag, _weight, (const lfsr_mdir_t*){_mdir}, 0) // a grm update, note this is mutable! we may update the grm during // mdir commits -#define LFSR_ATTR_GRM(_tag, _weight, _grm) \ - LFSR_ATTR_(_tag, _weight, (const lfsr_grm_t*){_grm}, 0) +#define LFSR_RATTR_GRM(_tag, _weight, _grm) \ + LFSR_RATTR_(_tag, _weight, (const lfsr_grm_t*){_grm}, 0) // writing to an unrelated trunk in the rbyd typedef struct lfsr_shrubcommit lfsr_shrubcommit_t; -#define LFSR_ATTR_SHRUBCOMMIT(_tag, _weight, \ - _shrub, _rid, _attrs, _attr_count) \ - LFSR_ATTR_(_tag, _weight, \ +#define LFSR_RATTR_SHRUBCOMMIT(_tag, _weight, \ + _shrub, _rid, _rattrs, _rattr_count) \ + LFSR_RATTR_(_tag, _weight, \ (&(const lfsr_shrubcommit_t){ \ .shrub=_shrub, \ .rid=_rid, \ - .attrs=_attrs, \ - .attr_count=_attr_count}), \ + .rattrs=_rattrs, \ + .rattr_count=_rattr_count}), \ 0) -#define LFSR_ATTR_SHRUBTRUNK(_tag, _weight, _shrub) \ - LFSR_ATTR_(_tag, _weight, (const lfsr_shrub_t*){_shrub}, 0) +#define LFSR_RATTR_SHRUBTRUNK(_tag, _weight, _shrub) \ + LFSR_RATTR_(_tag, _weight, (const lfsr_shrub_t*){_shrub}, 0) // operations on custom attribute lists // // a slightly different struct because it's user facing -static inline lfs_ssize_t lfsr_uattr_size(const struct lfs_attr *attr) { +static inline lfs_ssize_t lfsr_attr_size(const struct lfs_attr *attr) { // we default to the buffer_size if a mutable size is not provided if (attr->size) { return *attr->size; @@ -2438,22 +2438,22 @@ static inline lfs_ssize_t lfsr_uattr_size(const struct lfs_attr *attr) { } } -static inline bool lfsr_uattr_isnoattr(const struct lfs_attr *attr) { - return lfsr_uattr_size(attr) == LFS_ERR_NOATTR; +static inline bool lfsr_attr_isnoattr(const struct lfs_attr *attr) { + return lfsr_attr_size(attr) == LFS_ERR_NOATTR; } -static lfs_scmp_t lfsr_uattr_cmp(lfs_t *lfs, const struct lfs_attr *attr, +static lfs_scmp_t lfsr_attr_cmp(lfs_t *lfs, const struct lfs_attr *attr, const lfsr_data_t *data) { // note data=NULL => NOATTR if (!data) { - return (lfsr_uattr_isnoattr(attr)) ? LFS_CMP_EQ : LFS_CMP_GT; + return (lfsr_attr_isnoattr(attr)) ? LFS_CMP_EQ : LFS_CMP_GT; } else { - if (lfsr_uattr_isnoattr(attr)) { + if (lfsr_attr_isnoattr(attr)) { return LFS_CMP_LT; } else { return lfsr_data_cmp(lfs, *data, attr->buffer, - lfsr_uattr_size(attr)); + lfsr_attr_size(attr)); } } } @@ -3746,15 +3746,15 @@ static int lfsr_rbyd_appendcat(lfs_t *lfs, lfsr_rbyd_t *rbyd, return 0; } -static int lfsr_rbyd_appendattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_attr_t attr) { +static int lfsr_rbyd_appendrattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd, + lfsr_rattr_t rattr) { int err = lfsr_rbyd_appendtag(lfs, rbyd, - attr.tag, attr.weight, lfsr_attr_size(attr)); + rattr.tag, rattr.weight, lfsr_rattr_size(rattr)); if (err) { return err; } - err = lfsr_rbyd_appendcat(lfs, rbyd, attr.cat, attr.count); + err = lfsr_rbyd_appendcat(lfs, rbyd, rattr.cat, rattr.count); if (err) { return err; } @@ -3784,7 +3784,7 @@ static int lfsr_rbyd_appendinit(lfs_t *lfs, lfsr_rbyd_t *rbyd) { } // helper functions for managing the 3-element fifo used in -// lfsr_rbyd_appendattr +// lfsr_rbyd_appendrattr typedef struct lfsr_alt { lfsr_tag_t alt; lfsr_rid_t weight; @@ -3883,19 +3883,19 @@ static void lfsr_rbyd_p_recolor( } // core rbyd algorithm -static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_srid_t rid, lfsr_attr_t attr) { +static int lfsr_rbyd_appendrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, + lfsr_srid_t rid, lfsr_rattr_t rattr) { // must fetch before mutating! LFS_ASSERT(lfsr_rbyd_isfetched(rbyd)); // tag must not be internal at this point - LFS_ASSERT(!lfsr_tag_isinternal(attr.tag)); + LFS_ASSERT(!lfsr_tag_isinternal(rattr.tag)); // bit 7 is reserved for future subtype extensions - LFS_ASSERT(!(attr.tag & 0x80)); + LFS_ASSERT(!(rattr.tag & 0x80)); // you can't delete more than what's in the rbyd - LFS_ASSERT(attr.weight >= -(lfsr_srid_t)rbyd->weight); + LFS_ASSERT(rattr.weight >= -(lfsr_srid_t)rbyd->weight); // ignore noops - if (lfsr_attr_isnoop(attr)) { + if (lfsr_rattr_isnoop(rattr)) { return 0; } @@ -3910,8 +3910,8 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_srid_t b_rid; lfsr_tag_t a_tag; lfsr_tag_t b_tag; - if (!lfsr_tag_isgrow(attr.tag) && attr.weight != 0) { - if (attr.weight > 0) { + if (!lfsr_tag_isgrow(rattr.tag) && rattr.weight != 0) { + if (rattr.weight > 0) { LFS_ASSERT(rid <= (lfsr_srid_t)rbyd->weight); // it's a bit ugly, but adjusting the rid here makes the following @@ -3925,7 +3925,7 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, // it's a bit ugly, but adjusting the rid here makes the following // logic work out more consistently rid += 1; - a_rid = rid - lfs_smax(-attr.weight, 0); + a_rid = rid - lfs_smax(-rattr.weight, 0); b_rid = rid; } @@ -3935,23 +3935,23 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, } else { LFS_ASSERT(rid < (lfsr_srid_t)rbyd->weight); - a_rid = rid - lfs_smax(-attr.weight, 0); + a_rid = rid - lfs_smax(-rattr.weight, 0); b_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 - if (lfsr_tag_issup(attr.tag)) { + if (lfsr_tag_issup(rattr.tag)) { a_tag = 0x000; b_tag = 0xf00; - } else if (lfsr_tag_issub(attr.tag)) { - a_tag = lfsr_tag_supkey(attr.tag); - b_tag = lfsr_tag_supkey(attr.tag) + 0x100; - } else if (lfsr_tag_isrm(attr.tag)) { - a_tag = lfsr_tag_key(attr.tag); - b_tag = lfsr_tag_key(attr.tag) + 1; + } else if (lfsr_tag_issub(rattr.tag)) { + a_tag = lfsr_tag_supkey(rattr.tag); + b_tag = lfsr_tag_supkey(rattr.tag) + 0x100; + } else if (lfsr_tag_isrm(rattr.tag)) { + a_tag = lfsr_tag_key(rattr.tag); + b_tag = lfsr_tag_key(rattr.tag) + 1; } else { - a_tag = lfsr_tag_key(attr.tag); - b_tag = lfsr_tag_key(attr.tag); + a_tag = lfsr_tag_key(rattr.tag); + b_tag = lfsr_tag_key(rattr.tag); } } a_tag = lfs_max(a_tag, 0x1); @@ -4341,7 +4341,7 @@ trunk:; } // terminate diverged trunk with an unreachable tag - err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR( + err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR( (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | LFSR_TAG_NULL, 0, @@ -4388,20 +4388,20 @@ stem:; lfsr_tag_t alt = 0; lfsr_rid_t weight = 0; if (tag_ - && (upper_rid-1 < rid-lfs_smax(-attr.weight, 0) - || (upper_rid-1 == rid-lfs_smax(-attr.weight, 0) - && ((!lfsr_tag_isgrow(attr.tag) && attr.weight > 0) - || (!lfsr_tag_issup(attr.tag) + && (upper_rid-1 < rid-lfs_smax(-rattr.weight, 0) + || (upper_rid-1 == rid-lfs_smax(-rattr.weight, 0) + && ((!lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0) + || (!lfsr_tag_issup(rattr.tag) && lfsr_tag_supkey(tag_) - < lfsr_tag_supkey(attr.tag)) - || (!lfsr_tag_issup(attr.tag) - && !lfsr_tag_issub(attr.tag) + < lfsr_tag_supkey(rattr.tag)) + || (!lfsr_tag_issup(rattr.tag) + && !lfsr_tag_issub(rattr.tag) && lfsr_tag_key(tag_) - < lfsr_tag_key(attr.tag)))))) { - if (lfsr_tag_isrm(attr.tag) || !lfsr_tag_key(attr.tag)) { + < lfsr_tag_key(rattr.tag)))))) { + if (lfsr_tag_isrm(rattr.tag) || !lfsr_tag_key(rattr.tag)) { // if removed, make our tag unreachable alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, lower_tag); - weight = upper_rid - lower_rid + attr.weight; + weight = upper_rid - lower_rid + rattr.weight; upper_rid -= weight; } else { // split less than @@ -4413,22 +4413,22 @@ stem:; } else if (tag_ && (upper_rid-1 > rid || (upper_rid-1 == rid - && ((!lfsr_tag_isgrow(attr.tag) && attr.weight > 0) - || (!lfsr_tag_issup(attr.tag) + && ((!lfsr_tag_isgrow(rattr.tag) && rattr.weight > 0) + || (!lfsr_tag_issup(rattr.tag) && lfsr_tag_supkey(tag_) - > lfsr_tag_supkey(attr.tag)) - || (!lfsr_tag_issup(attr.tag) - && !lfsr_tag_issub(attr.tag) + > lfsr_tag_supkey(rattr.tag)) + || (!lfsr_tag_issup(rattr.tag) + && !lfsr_tag_issub(rattr.tag) && lfsr_tag_key(tag_) - > lfsr_tag_key(attr.tag)))))) { - if (lfsr_tag_isrm(attr.tag) || !lfsr_tag_key(attr.tag)) { + > lfsr_tag_key(rattr.tag)))))) { + if (lfsr_tag_isrm(rattr.tag) || !lfsr_tag_key(rattr.tag)) { // if removed, make our tag unreachable alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, lower_tag); - weight = upper_rid - lower_rid + attr.weight; + weight = upper_rid - lower_rid + rattr.weight; upper_rid -= weight; } else { // split greater than - alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, attr.tag); + alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, rattr.tag); weight = upper_rid - (rid+1); upper_rid -= weight; } @@ -4456,22 +4456,22 @@ leaf:; // // note we always need a non-alt to terminate the trunk, otherwise we // can't find trunks during fetch - err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR_( + err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR_( // mark as shrub if we are a shrub (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) // rm => null, otherwise strip off control bits - | ((lfsr_tag_isrm(attr.tag)) + | ((lfsr_tag_isrm(rattr.tag)) ? LFSR_TAG_NULL - : lfsr_tag_key(attr.tag)), - upper_rid - lower_rid + attr.weight, - attr.cat, attr.count)); + : lfsr_tag_key(rattr.tag)), + upper_rid - lower_rid + rattr.weight, + rattr.cat, rattr.count)); if (err) { return err; } // update the trunk and weight rbyd->trunk = (rbyd->trunk & LFSR_RBYD_ISSHRUB) | trunk_; - rbyd->weight += attr.weight; + rbyd->weight += rattr.weight; return 0; } @@ -4542,7 +4542,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) { } uint8_t ecksum_buf[LFSR_ECKSUM_DSIZE]; - err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR( + err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR( LFSR_TAG_ECKSUM, 0, LFSR_DATA_ECKSUM_( (&(lfsr_ecksum_t){ .cksize=lfs->cfg->prog_size, @@ -4621,14 +4621,14 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) { return 0; } -static int lfsr_rbyd_appendattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd, +static int lfsr_rbyd_appendrattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_srid_t rid, lfsr_srid_t start_rid, lfsr_srid_t end_rid, - const lfsr_attr_t *attrs, lfs_size_t attr_count) { + const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // append each tag to the tree - for (lfs_size_t i = 0; i < attr_count; i++) { + for (lfs_size_t i = 0; i < rattr_count; i++) { // treat inserts after the first tag as though they are splits, // sequential inserts don't really make sense otherwise - if (i > 0 && lfsr_attr_isinsert(attrs[i])) { + if (i > 0 && lfsr_rattr_isinsert(rattrs[i])) { rid += 1; } @@ -4638,9 +4638,9 @@ static int lfsr_rbyd_appendattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd, // treat end_rid=-1 as "unbounded" in such a way that rid=-1 // is still included && (lfs_size_t)(rid + 1) <= (lfs_size_t)end_rid) { - int err = lfsr_rbyd_appendattr(lfs, rbyd, + int err = lfsr_rbyd_appendrattr(lfs, rbyd, rid - lfs_smax(start_rid, 0), - attrs[i]); + rattrs[i]); if (err) { return err; } @@ -4649,24 +4649,24 @@ static int lfsr_rbyd_appendattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd, // we need to make sure we keep start_rid/end_rid updated with // weight changes if (rid < start_rid) { - start_rid += attrs[i].weight; + start_rid += rattrs[i].weight; } if (rid < end_rid) { - end_rid += attrs[i].weight; + end_rid += rattrs[i].weight; } // adjust rid - rid = lfsr_attr_nextrid(attrs[i], rid); + rid = lfsr_rattr_nextrid(rattrs[i], rid); } return 0; } static int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_srid_t rid, const lfsr_attr_t *attrs, lfs_size_t attr_count) { + lfsr_srid_t rid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // append each tag to the tree - int err = lfsr_rbyd_appendattrs(lfs, rbyd, rid, -1, -1, - attrs, attr_count); + int err = lfsr_rbyd_appendrattrs(lfs, rbyd, rid, -1, -1, + rattrs, rattr_count); if (err) { return err; } @@ -4694,7 +4694,7 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // calculate dsize by starting from the outside ids and working inwards, // this naturally gives us a split rid // - // TODO adopt this a/b naming scheme in lfsr_rbyd_appendattr? + // TODO adopt this a/b naming scheme in lfsr_rbyd_appendrattr? lfsr_srid_t a_rid = start_rid; lfsr_srid_t b_rid = lfs_min(rbyd->weight, end_rid); lfs_size_t a_dsize = 0; @@ -4738,7 +4738,7 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, weight += weight_; // include the cost of this tag - dsize_ += lfs->attr_estimate + lfsr_data_size(data); + dsize_ += lfs->rattr_estimate + lfsr_data_size(data); } if (a_rid == -1) { @@ -4764,9 +4764,9 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // appends a raw tag as a part of compaction, note these must // be appended in order! // -// also note attr.weight here is total weight not delta weight -static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_attr_t attr) { +// also note rattr.weight here is total weight not delta weight +static int lfsr_rbyd_appendcompactrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, + lfsr_rattr_t rattr) { // begin appending int err = lfsr_rbyd_appendinit(lfs, rbyd); if (err) { @@ -4774,10 +4774,10 @@ static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // write the tag - err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR_( - (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | attr.tag, - attr.weight, - attr.cat, attr.count)); + err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR_( + (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | rattr.tag, + rattr.weight, + rattr.cat, rattr.count)); if (err) { return err; } @@ -4810,7 +4810,7 @@ static int lfsr_rbyd_appendcompactrbyd(lfs_t *lfs, lfsr_rbyd_t *rbyd_, } // write the tag - err = lfsr_rbyd_appendcompactattr(lfs, rbyd_, LFSR_ATTR_CAT_( + err = lfsr_rbyd_appendcompactrattr(lfs, rbyd_, LFSR_RATTR_CAT_( tag, weight, &data, 1)); if (err) { return err; @@ -5487,7 +5487,7 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree, // extra state needed for non-terminating lfsr_btree_commit__ calls typedef struct lfsr_bscratch { - lfsr_attr_t attrs[4]; + lfsr_rattr_t rattrs[4]; lfsr_data_t split_data; uint8_t buf[2*LFSR_BRANCH_DSIZE]; } lfsr_bscratch_t; @@ -5501,11 +5501,11 @@ typedef struct lfsr_bscratch { static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, lfsr_bscratch_t *bscratch, lfsr_bid_t *bid, lfsr_rbyd_t *rbyd, lfsr_srid_t rid, - const lfsr_attr_t **attrs, lfs_size_t *attr_count) { + const lfsr_rattr_t **rattrs, lfs_size_t *rattr_count) { lfsr_bid_t bid_ = *bid; LFS_ASSERT(bid_ <= (lfsr_bid_t)btree->weight); - const lfsr_attr_t *attrs_ = *attrs; - lfs_size_t attr_count_ = *attr_count; + const lfsr_rattr_t *rattrs_ = *rattrs; + lfs_size_t rattr_count_ = *rattr_count; // if rbyd is NULL, lookup which leaf our bid resides // @@ -5548,8 +5548,8 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, if (!lfsr_rbyd_trunk(&rbyd_) || lfsr_rbyd_isshrub(btree)) { *bid = rid_; - *attrs = attrs_; - *attr_count = attr_count_; + *rattrs = rattrs_; + *rattr_count = rattr_count_; return (!lfsr_rbyd_trunk(&rbyd_)) ? LFS_ERR_RANGE : 0; } @@ -5588,7 +5588,7 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, // interacting with other references to the rbyd lfsr_rbyd_t rbyd__ = rbyd_; int err = lfsr_rbyd_commit(lfs, &rbyd__, rid_, - attrs_, attr_count_); + rattrs_, rattr_count_); if (err) { if (err == LFS_ERR_RANGE || err == LFS_ERR_CORRUPT) { goto compact; @@ -5743,10 +5743,10 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, return err; } - // append any pending attrs, it's up to upper + // append any pending rattrs, it's up to upper // layers to make sure these always fit err = lfsr_rbyd_commit(lfs, &rbyd__, rid_, - attrs_, attr_count_); + rattrs_, rattr_count_); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); // bad prog? try another block @@ -5781,12 +5781,12 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, return err; } - // append pending attrs < split_rid + // append pending rattrs < split_rid // // upper layers should make sure this can't fail by limiting the // maximum commit size - err = lfsr_rbyd_appendattrs(lfs, &rbyd__, rid_, -1, split_rid, - attrs_, attr_count_); + err = lfsr_rbyd_appendrattrs(lfs, &rbyd__, rid_, -1, split_rid, + rattrs_, rattr_count_); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); // bad prog? try another block @@ -5825,12 +5825,12 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, return err; } - // append pending attrs >= split_rid + // append pending rattrs >= split_rid // // upper layers should make sure this can't fail by limiting the // maximum commit size - err = lfsr_rbyd_appendattrs(lfs, &sibling, rid_, split_rid, -1, - attrs_, attr_count_); + err = lfsr_rbyd_appendrattrs(lfs, &sibling, rid_, split_rid, -1, + rattrs_, rattr_count_); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); // bad prog? try another block @@ -5862,7 +5862,7 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, // lookup first name in sibling to use as the split name // - // note we need to do this after playing out pending attrs in case + // note we need to do this after playing out pending rattrs in case // they introduce a new name! lfsr_tag_t split_tag; err = lfsr_rbyd_lookupnext(lfs, &sibling, 0, LFSR_TAG_NAME, @@ -5875,49 +5875,49 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, // prepare commit to parent, tail recursing upwards LFS_ASSERT(rbyd__.weight > 0); LFS_ASSERT(sibling.weight > 0); - attr_count_ = 0; + rattr_count_ = 0; // new root? if (!lfsr_rbyd_trunk(&parent)) { - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_BRANCH, +rbyd__.weight, LFSR_DATA_BRANCH_( &rbyd__, &bscratch->buf[0*LFSR_BRANCH_DSIZE])); - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_BRANCH, +sibling.weight, LFSR_DATA_BRANCH_( &sibling, &bscratch->buf[1*LFSR_BRANCH_DSIZE])); if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { - bscratch->attrs[attr_count_++] = LFSR_ATTR_CAT_( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR_CAT_( LFSR_TAG_NAME, 0, &bscratch->split_data, 1); } // split root? } else { bid_ -= pid - (rbyd_.weight-1); - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_BRANCH, 0, LFSR_DATA_BRANCH_( &rbyd__, &bscratch->buf[0*LFSR_BRANCH_DSIZE])); if (rbyd__.weight != rbyd_.weight) { - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight, LFSR_DATA_NULL()); } - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_BRANCH, +sibling.weight, LFSR_DATA_BRANCH_( &sibling, &bscratch->buf[1*LFSR_BRANCH_DSIZE])); if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { - bscratch->attrs[attr_count_++] = LFSR_ATTR_CAT_( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR_CAT_( LFSR_TAG_NAME, 0, &bscratch->split_data, 1); } } - attrs_ = bscratch->attrs; + rattrs_ = bscratch->rattrs; rbyd_ = parent; rid_ = pid; @@ -5962,10 +5962,10 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, return err; } - // append any pending attrs, it's up to upper + // append any pending rattrs, it's up to upper // layers to make sure these always fit err = lfsr_rbyd_commit(lfs, &rbyd__, rid_, - attrs_, attr_count_); + rattrs_, rattr_count_); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); // bad prog? try another block @@ -5981,25 +5981,25 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, if (rbyd_.weight+sibling.weight == btree->weight) { // collapse the root, decreasing the height of the tree *btree = rbyd__; - *attr_count = 0; + *rattr_count = 0; return 0; } // prepare commit to parent, tail recursing upwards LFS_ASSERT(rbyd__.weight > 0); - attr_count_ = 0; + rattr_count_ = 0; bid_ -= pid - (rbyd_.weight-1); - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_RM, -sibling.weight, LFSR_DATA_NULL()); - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_BRANCH, 0, LFSR_DATA_BRANCH_(&rbyd__, bscratch->buf)); if (rbyd__.weight != rbyd_.weight) { - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight, LFSR_DATA_NULL()); } - attrs_ = bscratch->attrs; + rattrs_ = bscratch->rattrs; rbyd_ = parent; rid_ = pid + sibling.weight; @@ -6009,7 +6009,7 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, // done? if (!lfsr_rbyd_trunk(&parent)) { *btree = rbyd__; - *attr_count = 0; + *rattr_count = 0; return 0; } @@ -6017,7 +6017,7 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, if (rbyd_.weight == btree->weight) { // collapse the root, decreasing the height of the tree *btree = rbyd__; - *attr_count = 0; + *rattr_count = 0; return 0; } @@ -6025,22 +6025,22 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, // // note that since we defer merges to compaction time, we can // end up removing an rbyd here - attr_count_ = 0; + rattr_count_ = 0; bid_ -= pid - (rbyd_.weight-1); if (rbyd__.weight == 0) { - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_RM, -rbyd_.weight, LFSR_DATA_NULL()); } else { - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_BRANCH, 0, LFSR_DATA_BRANCH_(&rbyd__, bscratch->buf)); if (rbyd__.weight != rbyd_.weight) { - bscratch->attrs[attr_count_++] = LFSR_ATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR( LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight, LFSR_DATA_NULL()); } } - attrs_ = bscratch->attrs; + rattrs_ = bscratch->rattrs; rbyd_ = parent; rid_ = pid; @@ -6051,18 +6051,18 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, // commit to btree with optional rbyd static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, lfsr_bid_t bid, lfsr_rbyd_t *rbyd, lfsr_srid_t rid, - const lfsr_attr_t *attrs, lfs_size_t attr_count) { + const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // try to commit to the btree lfsr_bscratch_t bscratch; int err = lfsr_btree_commit__(lfs, btree, &bscratch, - &bid, rbyd, rid, &attrs, &attr_count); + &bid, rbyd, rid, &rattrs, &rattr_count); if (err && err != LFS_ERR_RANGE) { return err; } // needs a new root? if (err == LFS_ERR_RANGE) { - LFS_ASSERT(attr_count > 0); + LFS_ASSERT(rattr_count > 0); relocate:; lfsr_rbyd_t rbyd_; @@ -6071,7 +6071,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, return err; } - err = lfsr_rbyd_commit(lfs, &rbyd_, bid, attrs, attr_count); + err = lfsr_rbyd_commit(lfs, &rbyd_, bid, rattrs, rattr_count); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); // bad prog? try another block @@ -6090,9 +6090,9 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // commit to a btree, this is atomic static int lfsr_btree_commit(lfs_t *lfs, lfsr_btree_t *btree, - lfsr_bid_t bid, const lfsr_attr_t *attrs, lfs_size_t attr_count) { + lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { return lfsr_btree_commit_(lfs, btree, bid, NULL, -1, - attrs, attr_count); + rattrs, rattr_count); } // lookup in a btree by name @@ -6573,13 +6573,13 @@ static int lfsr_shrub_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd_, struct lfsr_shrubcommit { lfsr_shrub_t *shrub; lfsr_srid_t rid; - const lfsr_attr_t *attrs; - lfs_size_t attr_count; + const lfsr_rattr_t *rattrs; + lfs_size_t rattr_count; }; static int lfsr_shrub_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd_, lfsr_shrub_t *shrub, lfsr_srid_t rid, - const lfsr_attr_t *attrs, lfs_size_t attr_count) { + const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // swap out our trunk/weight temporarily, note we're // operating on a copy so if this fails we shouldn't mess // things up too much @@ -6591,8 +6591,8 @@ static int lfsr_shrub_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd_, rbyd_->weight = shrub->weight; // append any bshrub attributes - int err = lfsr_rbyd_appendattrs(lfs, rbyd_, rid, -1, -1, - attrs, attr_count); + int err = lfsr_rbyd_appendrattrs(lfs, rbyd_, rid, -1, -1, + rattrs, rattr_count); if (err) { return err; } @@ -6830,13 +6830,13 @@ static int lfsr_bshrub_traverse(lfs_t *lfs, // needed in lfsr_bshrub_commit_ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, - const lfsr_attr_t *attrs, lfs_size_t attr_count); + const lfsr_rattr_t *rattrs, lfs_size_t rattr_count); // commit to bshrub with optional rbyd static int lfsr_bshrub_commit_(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_bshrub_t *bshrub, lfsr_bid_t bid, lfsr_rbyd_t *rbyd, lfsr_srid_t rid, - const lfsr_attr_t *attrs, lfs_size_t attr_count) { + const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // file must be a bshrub/btree here LFS_ASSERT(lfsr_bshrub_isbshruborbtree(bshrub)); @@ -6860,16 +6860,16 @@ static int lfsr_bshrub_commit_(lfs_t *lfs, // try to commit to the btree lfsr_bscratch_t bscratch; int err = lfsr_btree_commit__(lfs, &bshrub->u.btree, &bscratch, - &bid, rbyd, rid, &attrs, &attr_count); + &bid, rbyd, rid, &rattrs, &rattr_count); if (err && err != LFS_ERR_RANGE) { return err; } - LFS_ASSERT(!err || attr_count > 0); + LFS_ASSERT(!err || rattr_count > 0); bool alloc = (err == LFS_ERR_RANGE); // when btree is shrubbed, lfsr_btree_commit_ stops at the root - // and returns with pending attrs - if (attr_count > 0) { + // and returns with pending rattrs + if (rattr_count > 0) { // we need to prevent our shrub from overflowing our mdir somehow // // maintaining an accurate estimate is tricky and error-prone, @@ -6882,13 +6882,13 @@ static int lfsr_bshrub_commit_(lfs_t *lfs, // figure out how much data this commit progs lfs_size_t commit_estimate = 0; - for (lfs_size_t i = 0; i < attr_count; i++) { + for (lfs_size_t i = 0; i < rattr_count; i++) { // only include tag overhead if tag is not a grow/rm tag - if (!lfsr_tag_isgrow(attrs[i].tag) - && !lfsr_tag_isrm(attrs[i].tag)) { - commit_estimate += lfs->attr_estimate; + if (!lfsr_tag_isgrow(rattrs[i].tag) + && !lfsr_tag_isrm(rattrs[i].tag)) { + commit_estimate += lfs->rattr_estimate; } - commit_estimate += lfsr_attr_size(attrs[i]); + commit_estimate += lfsr_rattr_size(rattrs[i]); } // does our estimate exceed our shrub_size? need to recalculate an @@ -6922,10 +6922,10 @@ static int lfsr_bshrub_commit_(lfs_t *lfs, estimate += commit_estimate; // commit to shrub - int err = lfsr_mdir_commit(lfs, mdir, LFSR_ATTRS( - LFSR_ATTR_SHRUBCOMMIT( + int err = lfsr_mdir_commit(lfs, mdir, LFSR_RATTRS( + LFSR_RATTR_SHRUBCOMMIT( LFSR_TAG_SHRUBCOMMIT, 0, - &bshrub->u.bshrub, bid, attrs, attr_count))); + &bshrub->u.bshrub, bid, rattrs, rattr_count))); if (err) { return err; } @@ -6969,7 +6969,7 @@ relocate:; } } - err = lfsr_rbyd_commit(lfs, &rbyd_, bid, attrs, attr_count); + err = lfsr_rbyd_commit(lfs, &rbyd_, bid, rattrs, rattr_count); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); // bad prog? try another block @@ -6986,11 +6986,11 @@ relocate:; // commit to a bshrub, this is atomic static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_bshrub_t *bshrub, - lfsr_bid_t bid, const lfsr_attr_t *attrs, lfs_size_t attr_count) { + lfsr_bid_t bid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // file must be a bshrub/btree here LFS_ASSERT(lfsr_bshrub_isbshruborbtree(bshrub)); return lfsr_bshrub_commit_(lfs, mdir, bshrub, bid, NULL, -1, - attrs, attr_count); + rattrs, rattr_count); } @@ -7158,7 +7158,7 @@ static inline bool lfsr_o_iszombie(uint32_t flags) { return flags & LFS_O_ZOMBIE; } -// custom attr flags +// custom rattr flags static inline bool lfsr_a_islazy(uint32_t flags) { return flags & LFS_A_LAZY; } @@ -7533,7 +7533,7 @@ static int lfsr_rbyd_appendgdelta(lfs_t *lfs, lfsr_rbyd_t *rbyd) { // append to our rbyd, replacing any existing delta lfs_size_t size = lfsr_gdelta_size(grm_d, LFSR_GRM_DSIZE); - err = lfsr_rbyd_appendattr(lfs, rbyd, -1, LFSR_ATTR( + err = lfsr_rbyd_appendrattr(lfs, rbyd, -1, LFSR_RATTR( // opportunistically remove this tag if delta is all zero (size == 0) ? LFSR_TAG_RM | LFSR_TAG_GRMDELTA @@ -7983,9 +7983,9 @@ static int lfsr_mdir_swap__(lfs_t *lfs, lfsr_mdir_t *mdir_, // low-level mdir commit, does not handle mtree/mlist/compaction/etc static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_srid_t start_rid, lfsr_srid_t end_rid, - lfsr_smid_t mid, const lfsr_attr_t *attrs, lfs_size_t attr_count) { + lfsr_smid_t mid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // since we only ever commit to one mid or split, we can ignore the - // entire attr-list if our mid is out of range + // entire rattr-list if our mid is out of range lfsr_srid_t rid = lfsr_mid_rid(lfs, mid); if (rid >= start_rid // note the use of rid+1 and unsigned comparison here to @@ -7993,29 +7993,29 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // is still included && (lfs_size_t)(rid + 1) <= (lfs_size_t)end_rid) { - for (lfs_size_t i = 0; i < attr_count; i++) { + for (lfs_size_t i = 0; i < rattr_count; i++) { // we just happen to never split in an mdir commit - LFS_ASSERT(!(i > 0 && lfsr_attr_isinsert(attrs[i]))); + LFS_ASSERT(!(i > 0 && lfsr_rattr_isinsert(rattrs[i]))); - // attr lists can be chained, but only tail-recursively - if (attrs[i].tag == LFSR_TAG_ATTRS) { + // rattr lists can be chained, but only tail-recursively + if (rattrs[i].tag == LFSR_TAG_RATTRS) { // must be the last tag - LFS_ASSERT(i == attr_count-1); + LFS_ASSERT(i == rattr_count-1); // how would weight make sense here? - LFS_ASSERT(attrs[i].weight == 0); - const lfsr_attr_t *attrs_ = attrs[i].cat; - lfs_size_t attr_count_ = attrs[i].count; + LFS_ASSERT(rattrs[i].weight == 0); + const lfsr_rattr_t *rattrs_ = rattrs[i].cat; + lfs_size_t rattr_count_ = rattrs[i].count; - // switch to chained attr-list - attrs = attrs_; - attr_count = attr_count_; + // switch to chained rattr-list + rattrs = rattrs_; + rattr_count = rattr_count_; i = -1; continue; // shrub tags append a set of attributes to an unrelated trunk // in our rbyd - } else if (attrs[i].tag == LFSR_TAG_SHRUBCOMMIT) { - const lfsr_shrubcommit_t *shrubcommit = attrs[i].cat; + } else if (rattrs[i].tag == LFSR_TAG_SHRUBCOMMIT) { + const lfsr_shrubcommit_t *shrubcommit = rattrs[i].cat; // find the staging shrub lfsr_shrub_t *shrub = shrubcommit->shrub; lfsr_shrub_t *shrub_ = &((lfsr_bshrub_t*)shrub + 1)->u.bshrub; @@ -8031,7 +8031,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // commit to shrub int err = lfsr_shrub_commit(lfs, &mdir->rbyd, shrub_, shrubcommit->rid, - shrubcommit->attrs, shrubcommit->attr_count); + shrubcommit->rattrs, shrubcommit->rattr_count); if (err) { return err; } @@ -8041,17 +8041,17 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // // TODO should we preserve mode for all of these? // TODO should we do the same for sprouts? - } else if (lfsr_tag_key(attrs[i].tag) == LFSR_TAG_SHRUBTRUNK) { + } else if (lfsr_tag_key(rattrs[i].tag) == LFSR_TAG_SHRUBTRUNK) { // find the staging shrub - lfsr_shrub_t *shrub = (lfsr_shrub_t*)attrs[i].cat; + lfsr_shrub_t *shrub = (lfsr_shrub_t*)rattrs[i].cat; lfsr_shrub_t *shrub_ = &((lfsr_bshrub_t*)shrub + 1)->u.bshrub; uint8_t shrub_buf[LFSR_SHRUB_DSIZE]; - int err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd, + int err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, rid - lfs_smax(start_rid, 0), - LFSR_ATTR( - lfsr_tag_mode(attrs[i].tag) | LFSR_TAG_BSHRUB, - attrs[i].weight, + LFSR_RATTR( + lfsr_tag_mode(rattrs[i].tag) | LFSR_TAG_BSHRUB, + rattrs[i].weight, // note we use the staged trunk here LFSR_DATA_SHRUB_(shrub_, shrub_buf))); if (err) { @@ -8061,10 +8061,10 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // move tags copy over any tags associated with the source's rid // TODO can this be deduplicated with lfsr_mdir_compact__ more? // it _really_ wants to be deduplicated - } else if (attrs[i].tag == LFSR_TAG_MOVE) { + } else if (rattrs[i].tag == LFSR_TAG_MOVE) { // weighted moves are not supported - LFS_ASSERT(attrs[i].weight == 0); - const lfsr_mdir_t *mdir__ = attrs[i].cat; + LFS_ASSERT(rattrs[i].weight == 0); + const lfsr_mdir_t *mdir__ = rattrs[i].cat; // skip the name tag, this is always replaced by upper layers lfsr_tag_t tag = LFSR_TAG_STRUCT-1; @@ -8082,9 +8082,9 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // found an inlined sprout? we can just copy this like // normal but we need to update any opened inlined files if (tag == LFSR_TAG_DATA) { - err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd, + err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, rid - lfs_smax(start_rid, 0), - LFSR_ATTR_CAT_(tag, 0, &data, 1)); + LFSR_RATTR_CAT_(tag, 0, &data, 1)); if (err) { return err; } @@ -8114,20 +8114,20 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // write our new shrub tag uint8_t shrub_buf[LFSR_SHRUB_DSIZE]; - err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd, + err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, rid - lfs_smax(start_rid, 0), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_BSHRUB, 0, LFSR_DATA_SHRUB_(&shrub, shrub_buf))); if (err) { return err; } - // append the attr + // append the rattr } else { - err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd, + err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, rid - lfs_smax(start_rid, 0), - LFSR_ATTR_CAT_(tag, 0, &data, 1)); + LFSR_RATTR_CAT_(tag, 0, &data, 1)); if (err) { return err; } @@ -8150,8 +8150,8 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // the new block && bshrub->bshrub_.u.bsprout.u.disk.block != mdir->rbyd.blocks[0]) { - int err = lfsr_rbyd_appendcompactattr(lfs, &mdir->rbyd, - LFSR_ATTR_CAT_( + int err = lfsr_rbyd_appendcompactrattr(lfs, &mdir->rbyd, + LFSR_RATTR_CAT_( LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0, &bshrub->bshrub.u.bsprout, 1)); if (err) { @@ -8182,9 +8182,9 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } // custom attributes need to be reencoded into our tag format - } else if (lfsr_tag_key(attrs[i].tag) == LFSR_TAG_UATTRS) { - const struct lfs_attr *attrs_ = attrs[i].cat; - lfs_size_t attr_count_ = attrs[i].count; + } else if (lfsr_tag_key(rattrs[i].tag) == LFSR_TAG_ATTRS) { + const struct lfs_attr *attrs_ = rattrs[i].cat; + lfs_size_t attr_count_ = rattrs[i].count; for (lfs_size_t j = 0; j < attr_count_; j++) { // skip readonly attrs and lazy attrs @@ -8203,7 +8203,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } // does disk match our attr? - lfs_scmp_t cmp = lfsr_uattr_cmp(lfs, &attrs_[j], + lfs_scmp_t cmp = lfsr_attr_cmp(lfs, &attrs_[j], (err != LFS_ERR_NOENT) ? &data : NULL); if (cmp < 0) { return cmp; @@ -8214,19 +8214,19 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } // append the custom attr - err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd, + err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, rid - lfs_smax(start_rid, 0), // removing or updating? - (lfsr_uattr_isnoattr(&attrs_[j])) - ? LFSR_ATTR( + (lfsr_attr_isnoattr(&attrs_[j])) + ? LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(attrs_[j].type), 0, LFSR_DATA_NULL()) - : LFSR_ATTR( + : LFSR_RATTR( LFSR_TAG_ATTR(attrs_[j].type), 0, LFSR_DATA_BUF( attrs_[j].buffer, - lfsr_uattr_size(&attrs_[j])))); + lfsr_attr_size(&attrs_[j])))); if (err) { return err; } @@ -8234,18 +8234,18 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // write out normal tags normally } else { - LFS_ASSERT(!lfsr_tag_isinternal(attrs[i].tag)); + LFS_ASSERT(!lfsr_tag_isinternal(rattrs[i].tag)); - int err = lfsr_rbyd_appendattr(lfs, &mdir->rbyd, + int err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, rid - lfs_smax(start_rid, 0), - attrs[i]); + rattrs[i]); if (err) { return err; } } // adjust rid - rid = lfsr_attr_nextrid(attrs[i], rid); + rid = lfsr_rattr_nextrid(rattrs[i], rid); } } @@ -8338,7 +8338,7 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir, if (dsize__ < 0) { return dsize__; } - dsize_ += lfs->attr_estimate + dsize__; + dsize_ += lfs->rattr_estimate + dsize__; // special handling for shrub trunks, we need to include the // compacted cost of the shrub in our estimate @@ -8360,11 +8360,11 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir, if (dsize__ < 0) { return dsize__; } - dsize_ += lfs->attr_estimate + dsize__; + dsize_ += lfs->rattr_estimate + dsize__; } else { // include the cost of this tag - dsize_ += lfs->attr_estimate + lfsr_data_size(data); + dsize_ += lfs->rattr_estimate + lfsr_data_size(data); } } @@ -8460,8 +8460,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // found an inlined sprout? we can just copy this like normal but // we need to update any opened inlined files if (tag == LFSR_TAG_DATA) { - err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, - LFSR_ATTR_CAT_(tag, weight, &data, 1)); + err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd, + LFSR_RATTR_CAT_(tag, weight, &data, 1)); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -8494,8 +8494,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // write the new shrub tag uint8_t shrub_buf[LFSR_SHRUB_DSIZE]; - err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, - LFSR_ATTR( + err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd, + LFSR_RATTR( tag, weight, LFSR_DATA_SHRUB_(&shrub, shrub_buf))); if (err) { @@ -8505,8 +8505,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, } else { // write the tag - err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, - LFSR_ATTR_CAT_(tag, weight, &data, 1)); + err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd, + LFSR_RATTR_CAT_(tag, weight, &data, 1)); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -8537,8 +8537,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // only compact once, first compact should stage the new block && bshrub->bshrub_.u.bsprout.u.disk.block != mdir_->rbyd.blocks[0]) { - err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, - LFSR_ATTR_CAT_( + err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd, + LFSR_RATTR_CAT_( LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0, &bshrub->bshrub.u.bsprout, 1)); if (err) { @@ -8574,7 +8574,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, static int lfsr_mdir_commit_(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_srid_t start_rid, lfsr_srid_t end_rid, lfsr_srid_t *split_rid_, - lfsr_smid_t mid, const lfsr_attr_t *attrs, lfs_size_t attr_count) { + lfsr_smid_t mid, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // make a copy lfsr_mdir_t mdir_ = *mdir; // mark as erased in case of failure @@ -8582,7 +8582,7 @@ static int lfsr_mdir_commit_(lfs_t *lfs, lfsr_mdir_t *mdir, // try to commit int err = lfsr_mdir_commit__(lfs, &mdir_, start_rid, end_rid, - mid, attrs, attr_count); + mid, rattrs, rattr_count); if (err) { if (err == LFS_ERR_RANGE || err == LFS_ERR_CORRUPT) { goto swap; @@ -8669,7 +8669,7 @@ compact:; // upper layers should make sure this can't fail by limiting the // maximum commit size err = lfsr_mdir_commit__(lfs, &mdir_, start_rid, end_rid, - mid, attrs, attr_count); + mid, rattrs, rattr_count); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); // bad prog? try another block @@ -8732,7 +8732,7 @@ static int lfsr_mroot_parent(lfs_t *lfs, const lfs_block_t mptr[static 2], // state // static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, - const lfsr_attr_t *attrs, lfs_size_t attr_count) { + const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // non-mroot mdirs must have weight LFS_ASSERT(mdir->mid == -1 // note inlined mdirs are mroots with mid != -1 @@ -8744,12 +8744,12 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // lfs->mroot must have mid=-1 LFS_ASSERT(lfs->mroot.mid == -1); - // play out any attrs that affect our grm _before_ committing to disk, + // play out any rattrs that affect our grm _before_ committing to disk, // keep in mind we revert to on-disk gstate if we run into an error lfsr_smid_t mid_ = mdir->mid; - for (lfs_size_t i = 0; i < attr_count; i++) { + for (lfs_size_t i = 0; i < rattr_count; i++) { // automatically create grms for new bookmarks - if (attrs[i].tag == LFSR_TAG_BOOKMARK) { + if (rattrs[i].tag == LFSR_TAG_BOOKMARK) { lfsr_grm_push(lfs, mid_); // adjust pending grms? @@ -8759,16 +8759,16 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, == lfsr_mid_bid(lfs, mid_) && lfs->grm.mids[j] >= mid_) { // deleting a pending grm doesn't really make sense - LFS_ASSERT(lfs->grm.mids[j] >= mid_ - attrs[i].weight); + LFS_ASSERT(lfs->grm.mids[j] >= mid_ - rattrs[i].weight); // adjust the grm - lfs->grm.mids[j] += attrs[i].weight; + lfs->grm.mids[j] += rattrs[i].weight; } } } // adjust mid - mid_ = lfsr_attr_nextrid(attrs[i], mid_); + mid_ = lfsr_rattr_nextrid(rattrs[i], mid_); } // setup any pending gdeltas @@ -8797,7 +8797,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // attempt to commit/compact the mdir normally lfsr_srid_t split_rid; int err = lfsr_mdir_commit_(lfs, &mdir_[0], -1, -1, &split_rid, - mdir->mid, attrs, attr_count); + mdir->mid, rattrs, rattr_count); if (err && err != LFS_ERR_RANGE && err != LFS_ERR_NOENT) { goto failed; @@ -8862,7 +8862,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, err = lfsr_mdir_commit__(lfs, &mdir_[i^left], ((i^left) == 0) ? 0 : split_rid, ((i^left) == 0) ? split_rid : -1, - mdir->mid, attrs, attr_count); + mdir->mid, rattrs, rattr_count); if (err && err != LFS_ERR_NOENT) { LFS_ASSERT(err != LFS_ERR_RANGE); // bad prog? try another block @@ -8877,7 +8877,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } } - // adjust our sibling's mid after committing attrs + // adjust our sibling's mid after committing rattrs mdir_[1].mid += (1 << lfs->mdir_bits); LFS_DEBUG("Splitting mdir %"PRId32" " @@ -8927,7 +8927,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // lookup first name in sibling to use as the split name // - // note we need to do this after playing out pending attrs in + // note we need to do this after playing out pending rattrs in // case they introduce a new name! lfsr_data_t split_data; err = lfsr_rbyd_sublookup(lfs, &mdir_[1].rbyd, 0, LFSR_TAG_NAME, @@ -8943,16 +8943,16 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, uint8_t mdir_buf[2*LFSR_MPTR_DSIZE]; err = lfsr_btree_commit(lfs, &mtree_.u.btree, - 0, LFSR_ATTRS( - LFSR_ATTR( + 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_MDIR, +(1 << lfs->mdir_bits), LFSR_DATA_MPTR_( mdir_[0].rbyd.blocks, &mdir_buf[0*LFSR_MPTR_DSIZE])), - LFSR_ATTR_CAT_( + LFSR_RATTR_CAT_( LFSR_TAG_NAME, +(1 << lfs->mdir_bits), &split_data, 1), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_MDIR, 0, LFSR_DATA_MPTR_( mdir_[1].rbyd.blocks, @@ -8968,16 +8968,16 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, uint8_t mdir_buf[2*LFSR_MPTR_DSIZE]; err = lfsr_btree_commit(lfs, &mtree_.u.btree, - lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS( - LFSR_ATTR( + lfsr_mid_bid(lfs, mdir->mid), LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_MDIR, 0, LFSR_DATA_MPTR_( mdir_[0].rbyd.blocks, &mdir_buf[0*LFSR_MPTR_DSIZE])), - LFSR_ATTR_CAT_( + LFSR_RATTR_CAT_( LFSR_TAG_NAME, +(1 << lfs->mdir_bits), &split_data, 1), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_MDIR, 0, LFSR_DATA_MPTR_( mdir_[1].rbyd.blocks, @@ -9014,8 +9014,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree err = lfsr_btree_commit(lfs, &mtree_.u.btree, - lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS( - LFSR_ATTR( + lfsr_mid_bid(lfs, mdir->mid), LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM, -(1 << lfs->mdir_bits), LFSR_DATA_NULL()))); if (err) { @@ -9046,8 +9046,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree uint8_t mdir_buf[LFSR_MPTR_DSIZE]; err = lfsr_btree_commit(lfs, &mtree_.u.btree, - lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS( - LFSR_ATTR( + lfsr_mid_bid(lfs, mdir->mid), LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_MDIR, 0, LFSR_DATA_MPTR_( mdir_[0].rbyd.blocks, @@ -9116,20 +9116,20 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // in our mroot uint8_t mtree_buf[LFS_MAX(LFSR_MPTR_DSIZE, LFSR_BTREE_DSIZE)]; err = lfsr_mdir_commit_(lfs, &mroot_, -1, 0, NULL, - -1, LFSR_ATTRS( + -1, LFSR_RATTRS( (lfsr_mtree_ismptr(&mtree_)) - ? LFSR_ATTR( + ? LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_MDIR, 0, LFSR_DATA_MPTR_(mtree_.u.mptr.blocks, mtree_buf)) - : LFSR_ATTR( + : LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_MTREE, 0, LFSR_DATA_BTREE_(&mtree_.u.btree, mtree_buf)), - // were we committing to the mroot? include any -1 attrs + // were we committing to the mroot? include any -1 rattrs (mdir->mid == -1) - ? LFSR_ATTR_ATTRS( - LFSR_TAG_ATTRS, 0, - attrs, attr_count) - : LFSR_ATTR_NOOP())); + ? LFSR_RATTR_RATTRS( + LFSR_TAG_RATTRS, 0, + rattrs, rattr_count) + : LFSR_RATTR_NOOP())); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); goto failed; @@ -9169,8 +9169,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // commit mrootchild uint8_t mrootchild_buf[LFSR_MPTR_DSIZE]; err = lfsr_mdir_commit_(lfs, &mrootparent_, -1, -1, NULL, - -1, LFSR_ATTRS( - LFSR_ATTR( + -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_MROOT, 0, LFSR_DATA_MPTR_( mrootchild_.rbyd.blocks, @@ -9218,11 +9218,11 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, uint8_t mrootchild_buf[LFSR_MPTR_DSIZE]; err = lfsr_mdir_commit__(lfs, &mrootanchor_, -1, -1, - -1, LFSR_ATTRS( - LFSR_ATTR( + -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_MAGIC, 0, LFSR_DATA_BUF("littlefs", 8)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_MROOT, 0, LFSR_DATA_MPTR_( mrootchild_.rbyd.blocks, @@ -9270,28 +9270,28 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update any gstate changes lfsr_fs_commitgdelta(lfs); - // play out any attrs that affect internal state + // play out any rattrs that affect internal state mid_ = mdir->mid; - for (lfs_size_t i = 0; i < attr_count; i++) { + for (lfs_size_t i = 0; i < rattr_count; i++) { // adjust any opened mdirs for (lfsr_omdir_t *o = lfs->omdirs; o; o = o->next) { // adjust opened mdirs? if (lfsr_mdir_cmp(&o->mdir, mdir) == 0 && o->mdir.mid >= mid_) { // removed? - if (o->mdir.mid < mid_ - attrs[i].weight) { + if (o->mdir.mid < mid_ - rattrs[i].weight) { // we should not be removing opened regular files LFS_ASSERT(lfsr_o_type(o->flags) != LFS_TYPE_REG); o->flags |= LFS_O_ZOMBIE; o->mdir.mid = mid_; } else { - o->mdir.mid += attrs[i].weight; + o->mdir.mid += rattrs[i].weight; } } } // adjust mid - mid_ = lfsr_attr_nextrid(attrs[i], mid_); + mid_ = lfsr_rattr_nextrid(rattrs[i], mid_); } // update any staged bsprouts/bshrubs @@ -10401,7 +10401,7 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { // // Worst case (or best case?) each directory needs 1 name tag, 1 did // tag, and 1 bookmark. With our current compaction strategy, each tag - // needs 3t+4 bytes for tag+alts (see our attr_estimate). And, if + // needs 3t+4 bytes for tag+alts (see our rattr_estimate). And, if // we assume ~1/2 block utilization due to our mdir split threshold, we // can multiply everything by 2: // @@ -10463,8 +10463,8 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { // commit our bookmark and a grm to self-remove in case of powerloss lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_BOOKMARK, +1, LFSR_DATA_LEB128(did_)))); + err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_BOOKMARK, +1, LFSR_DATA_LEB128(did_)))); if (err) { return err; } @@ -10483,11 +10483,11 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { // process lfsr_grm_pop(lfs); lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR_NAME( + err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_SUP | LFSR_TAG_DIR, (!exists) ? +1 : 0, did, name, name_size), - LFSR_ATTR(LFSR_TAG_DID, 0, LFSR_DATA_LEB128(did_)))); + LFSR_RATTR(LFSR_TAG_DID, 0, LFSR_DATA_LEB128(did_)))); if (err) { return err; } @@ -10621,16 +10621,16 @@ int lfsr_remove(lfs_t *lfs, const char *path) { // remove the metadata entry lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( + err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( // create an orphan if zombied // - // we use a create+delete here to also clear any attrs + // we use a create+delete here to also clear any rattrs // and trim the entry size (zombie) - ? LFSR_ATTR_NAME( + ? LFSR_RATTR_NAME( LFSR_TAG_SUP | LFSR_TAG_ORPHAN, 0, did, name, name_size) - : LFSR_ATTR( + : LFSR_RATTR( LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); if (err) { return err; @@ -10777,11 +10777,11 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) { // rename our entry, copying all tags associated with the old rid to the // new rid, while also marking the old rid for removal lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &new_mdir, LFSR_ATTRS( - LFSR_ATTR_NAME( + err = lfsr_mdir_commit(lfs, &new_mdir, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_SUP | old_tag, (!exists) ? +1 : 0, new_did, new_name, new_name_size), - LFSR_ATTR_MOVE(LFSR_TAG_MOVE, 0, &old_mdir))); + LFSR_RATTR_MOVE(LFSR_TAG_MOVE, 0, &old_mdir))); if (err) { return err; } @@ -11228,8 +11228,8 @@ int lfsr_setattr(lfs_t *lfs, const char *path, uint8_t type, // commit our attr lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR( + err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(type), 0, LFSR_DATA_BUF(buffer, size)))); if (err) { @@ -11280,8 +11280,8 @@ int lfsr_removeattr(lfs_t *lfs, const char *path, uint8_t type) { // commit our removal lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR( + err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(type), 0, LFSR_DATA_NULL()))); if (err) { @@ -11560,8 +11560,8 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file, // mid until first sync if (!err) { lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, &file->o.o.mdir, LFSR_ATTRS( - LFSR_ATTR_NAME( + err = lfsr_mdir_commit(lfs, &file->o.o.mdir, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_ORPHAN, +1, did, name, name_size))); if (err) { @@ -11873,16 +11873,16 @@ lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file, // low-level file writing static int lfsr_file_commit(lfs_t *lfs, lfsr_file_t *file, - lfs_off_t pos, const lfsr_attr_t *attrs, lfs_size_t attr_count) { + lfs_off_t pos, const lfsr_rattr_t *rattrs, lfs_size_t rattr_count) { // file must be a bshrub/btree here LFS_ASSERT(lfsr_bshrub_isbshruborbtree(&file->o.bshrub)); return lfsr_bshrub_commit(lfs, &file->o.o.mdir, &file->o.bshrub, - pos, attrs, attr_count); + pos, rattrs, rattr_count); } static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, - lfs_off_t pos, lfs_off_t weight, lfsr_attr_t attr) { + lfs_off_t pos, lfs_off_t weight, lfsr_rattr_t rattr) { // Note! This function has some rather special constraints: // // 1. We must never allow our btree size to overflow, even temporarily. @@ -11900,8 +11900,8 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // try to merge commits where possible lfsr_bid_t bid = lfsr_bshrub_size(&file->o.bshrub); - lfsr_attr_t attrs[5]; - lfs_size_t attr_count = 0; + lfsr_rattr_t rattrs[5]; + lfs_size_t rattr_count = 0; union { lfsr_data_t data; uint8_t buf[LFSR_BPTR_DSIZE]; @@ -11917,11 +11917,11 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // but note that's already a risk with how file carve deletes // data before insertion if (lfsr_bshrub_isbsprout(&file->o.o.mdir, &file->o.bshrub)) { - attrs[attr_count++] = LFSR_ATTR_CAT_( + rattrs[rattr_count++] = LFSR_RATTR_CAT_( LFSR_TAG_DATA, +lfsr_bshrub_size(&file->o.bshrub), &file->o.bshrub.u.bsprout, 1); } else if (lfsr_bshrub_isbptr(&file->o.o.mdir, &file->o.bshrub)) { - attrs[attr_count++] = LFSR_ATTR( + rattrs[rattr_count++] = LFSR_RATTR( LFSR_TAG_BLOCK, +lfsr_bshrub_size(&file->o.bshrub), LFSR_DATA_BPTR_(&file->o.bshrub.u.bptr, left.buf)); } @@ -11929,17 +11929,17 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, file->o.bshrub.u.bshrub = LFSR_SHRUB_NULL( file->o.o.mdir.rbyd.blocks[0]); - if (attr_count > 0) { - LFS_ASSERT(attr_count <= sizeof(attrs)/sizeof(lfsr_attr_t)); + if (rattr_count > 0) { + LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t)); int err = lfsr_file_commit(lfs, file, 0, - attrs, attr_count); + rattrs, rattr_count); if (err) { return err; } } - attr_count = 0; + rattr_count = 0; } // need a hole? @@ -11947,21 +11947,21 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // can we coalesce? if (lfsr_bshrub_size(&file->o.bshrub) > 0) { bid = lfs_min(bid, lfsr_bshrub_size(&file->o.bshrub)-1); - attrs[attr_count++] = LFSR_ATTR( + rattrs[rattr_count++] = LFSR_RATTR( LFSR_TAG_GROW, +(pos - lfsr_bshrub_size(&file->o.bshrub)), LFSR_DATA_NULL()); // new hole } else { bid = lfs_min(bid, lfsr_bshrub_size(&file->o.bshrub)); - attrs[attr_count++] = LFSR_ATTR( + rattrs[rattr_count++] = LFSR_RATTR( LFSR_TAG_DATA, +(pos - lfsr_bshrub_size(&file->o.bshrub)), LFSR_DATA_NULL()); } } // try to carve any existing data - lfsr_attr_t right_attr_ = {.tag=0}; + lfsr_rattr_t right_rattr_ = {.tag=0}; while (pos < lfsr_bshrub_size(&file->o.bshrub)) { lfsr_tag_t tag_; lfsr_bid_t weight_; @@ -12001,13 +12001,13 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, lfs->cfg->fragment_size, -1); - err = lfsr_file_commit(lfs, file, bid, LFSR_ATTRS( - LFSR_ATTR_CAT( + err = lfsr_file_commit(lfs, file, bid, LFSR_RATTRS( + LFSR_RATTR_CAT( LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA, -(weight_ - lfs->cfg->fragment_size), lfsr_data_truncate(left_slice_, lfs->cfg->fragment_size)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_BLOCK, +(weight_ - lfs->cfg->fragment_size), LFSR_DATA_BPTR_(&bptr_, left.buf)))); @@ -12030,12 +12030,12 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, -1, lfsr_data_size(bptr_.data) - lfs->cfg->fragment_size); - err = lfsr_file_commit(lfs, file, bid, LFSR_ATTRS( - LFSR_ATTR( + err = lfsr_file_commit(lfs, file, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK, -(weight_ - lfsr_data_size(bptr_.data)), LFSR_DATA_BPTR_(&bptr_, right.buf)), - LFSR_ATTR_CAT( + LFSR_RATTR_CAT( LFSR_TAG_DATA, +(weight_ - lfsr_data_size(bptr_.data)), lfsr_data_fruncate(right_slice_, @@ -12055,20 +12055,20 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, if (bid-(weight_-1) < pos) { // can we get away with a grow attribute? if (lfsr_data_size(bptr_.data) == lfsr_data_size(left_slice_)) { - attrs[attr_count++] = LFSR_ATTR( + rattrs[rattr_count++] = LFSR_RATTR( LFSR_TAG_GROW, -(bid+1 - pos), LFSR_DATA_NULL()); // carve fragment? } else if (tag_ == LFSR_TAG_DATA) { left.data = left_slice_; - attrs[attr_count++] = LFSR_ATTR_CAT_( + rattrs[rattr_count++] = LFSR_RATTR_CAT_( LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA, -(bid+1 - pos), &left.data, 1); // carve bptr? } else if (tag_ == LFSR_TAG_BLOCK) { - attrs[attr_count++] = LFSR_ATTR( + rattrs[rattr_count++] = LFSR_RATTR( LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK, -(bid+1 - pos), LFSR_DATA_BPTR_( @@ -12090,7 +12090,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // completely overwriting this entry? } else { - attrs[attr_count++] = LFSR_ATTR( + rattrs[rattr_count++] = LFSR_RATTR( LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()); } @@ -12098,17 +12098,17 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // so commit what we have and move on to next entry if (pos+weight > bid+1) { LFS_ASSERT(lfsr_data_size(right_slice_) == 0); - LFS_ASSERT(attr_count <= sizeof(attrs)/sizeof(lfsr_attr_t)); + LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t)); err = lfsr_file_commit(lfs, file, bid, - attrs, attr_count); + rattrs, rattr_count); if (err) { return err; } - attr.weight += lfs_min(weight, bid+1 - pos); + rattr.weight += lfs_min(weight, bid+1 - pos); weight -= lfs_min(weight, bid+1 - pos); - attr_count = 0; + rattr_count = 0; continue; } @@ -12116,19 +12116,19 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, if (pos+weight < bid+1) { // can we coalesce a hole? if (lfsr_data_size(right_slice_) == 0) { - attr.weight += bid+1 - (pos+weight); + rattr.weight += bid+1 - (pos+weight); // carve fragment? } else if (tag_ == LFSR_TAG_DATA) { right.data = right_slice_; - right_attr_ = LFSR_ATTR_CAT_( + right_rattr_ = LFSR_RATTR_CAT_( tag_, bid+1 - (pos+weight), &right.data, 1); // carve bptr? } else if (tag_ == LFSR_TAG_BLOCK) { - right_attr_ = LFSR_ATTR( + right_rattr_ = LFSR_RATTR( tag_, bid+1 - (pos+weight), LFSR_DATA_BPTR_( @@ -12149,47 +12149,47 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, } } - attr.weight += lfs_min(weight, bid+1 - pos); + rattr.weight += lfs_min(weight, bid+1 - pos); weight -= lfs_min(weight, bid+1 - pos); break; } // append our data - if (weight + attr.weight > 0) { + if (weight + rattr.weight > 0) { // can we coalesce a hole? - if (lfsr_attr_size(attr) == 0 && pos > 0) { + if (lfsr_rattr_size(rattr) == 0 && pos > 0) { bid = lfs_min(bid, lfsr_bshrub_size(&file->o.bshrub)-1); - attrs[attr_count++] = LFSR_ATTR( - LFSR_TAG_GROW, +(weight + attr.weight), + rattrs[rattr_count++] = LFSR_RATTR( + LFSR_TAG_GROW, +(weight + rattr.weight), LFSR_DATA_NULL()); // need a new hole? - } else if (lfsr_attr_size(attr) == 0) { + } else if (lfsr_rattr_size(rattr) == 0) { bid = lfs_min(bid, lfsr_bshrub_size(&file->o.bshrub)); - attrs[attr_count++] = LFSR_ATTR( - LFSR_TAG_DATA, +(weight + attr.weight), + rattrs[rattr_count++] = LFSR_RATTR( + LFSR_TAG_DATA, +(weight + rattr.weight), LFSR_DATA_NULL()); // append new fragment/bptr? } else { bid = lfs_min(bid, lfsr_bshrub_size(&file->o.bshrub)); - attrs[attr_count++] = LFSR_ATTR_( - attr.tag, +(weight + attr.weight), - attr.cat, attr.count); + rattrs[rattr_count++] = LFSR_RATTR_( + rattr.tag, +(weight + rattr.weight), + rattr.cat, rattr.count); } } // and don't forget the right sibling - if (right_attr_.tag) { - attrs[attr_count++] = right_attr_; + if (right_rattr_.tag) { + rattrs[rattr_count++] = right_rattr_; } - // commit pending attrs - if (attr_count > 0) { - LFS_ASSERT(attr_count <= sizeof(attrs)/sizeof(lfsr_attr_t)); + // commit pending rattrs + if (rattr_count > 0) { + LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t)); int err = lfsr_file_commit(lfs, file, bid, - attrs, attr_count); + rattrs, rattr_count); if (err) { return err; } @@ -12590,7 +12590,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, uint8_t bptr_buf[LFSR_BPTR_DSIZE]; err = lfsr_file_carve(lfs, file, block_start, block_end - block_start, - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_BLOCK, 0, LFSR_DATA_BPTR_(&bptr, bptr_buf))); if (err) { @@ -12723,7 +12723,7 @@ fragment:; // our tree int err = lfsr_file_carve(lfs, file, fragment_start, fragment_end - fragment_start, - LFSR_ATTR_CAT_( + LFSR_RATTR_CAT_( LFSR_TAG_DATA, 0, datas, data_count)); if (err && err != LFS_ERR_RANGE) { @@ -12998,8 +12998,8 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { || lfsr_o_isunsync(file->o.o.flags)); // build a commit of any pending file metadata - lfsr_attr_t attrs[3]; - lfs_size_t attr_count = 0; + lfsr_rattr_t rattrs[3]; + lfs_size_t rattr_count = 0; lfsr_data_t name_data; uint8_t buf[LFSR_BTREE_DSIZE]; @@ -13013,7 +13013,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { goto failed; } - attrs[attr_count++] = LFSR_ATTR_CAT_( + rattrs[rattr_count++] = LFSR_RATTR_CAT_( LFSR_TAG_SUB | LFSR_TAG_REG, 0, &name_data, 1); } @@ -13026,24 +13026,24 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { goto failed; } - // null? no attr? + // null? no rattr? if (lfsr_o_isunflush(file->o.o.flags) && file->buffer.size == 0) { - attrs[attr_count++] = LFSR_ATTR( + rattrs[rattr_count++] = LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_STRUCT, 0, LFSR_DATA_NULL()); // small file inlined in mdir? } else if (lfsr_o_isunflush(file->o.o.flags)) { - attrs[attr_count++] = LFSR_ATTR_CAT_( + rattrs[rattr_count++] = LFSR_RATTR_CAT_( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, (const lfsr_data_t*)&file->buffer, 1); // bshrub? } else if (lfsr_bshrub_isbshrub(&file->o.o.mdir, &file->o.bshrub)) { - attrs[attr_count++] = LFSR_ATTR_SHRUBTRUNK( + rattrs[rattr_count++] = LFSR_RATTR_SHRUBTRUNK( LFSR_TAG_SUB | LFSR_TAG_SHRUBTRUNK, 0, &file->o.bshrub.u.bshrub); // btree? } else if (lfsr_bshrub_isbtree(&file->o.o.mdir, &file->o.bshrub)) { - attrs[attr_count++] = LFSR_ATTR( + rattrs[rattr_count++] = LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_BTREE, 0, LFSR_DATA_BTREE_(&file->o.bshrub.u.btree, buf)); } else { @@ -13056,8 +13056,8 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { // this gets real messy, since users can change custom attributes // whenever they want without informing littlefs, the best we can do // is read from disk to manually check if any attributes changed - bool uattrs = lfsr_o_isunsync(file->o.o.flags); - if (!uattrs) { + bool attrs = lfsr_o_isunsync(file->o.o.flags); + if (!attrs) { for (lfs_size_t i = 0; i < file->cfg->attr_count; i++) { // skip readonly attrs and lazy attrs if (lfsr_o_isrdonly(file->cfg->attrs[i].flags) @@ -13075,7 +13075,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { } // does disk match our attr? - lfs_scmp_t cmp = lfsr_uattr_cmp(lfs, &file->cfg->attrs[i], + lfs_scmp_t cmp = lfsr_attr_cmp(lfs, &file->cfg->attrs[i], (err != LFS_ERR_NOENT) ? &data : NULL); if (cmp < 0) { err = cmp; @@ -13083,27 +13083,27 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { } if (cmp != LFS_CMP_EQ) { - uattrs = true; + attrs = true; break; } } } - if (uattrs) { + if (attrs) { // need to append custom attributes - attrs[attr_count++] = LFSR_ATTR_UATTRS( - LFSR_TAG_UATTRS, 0, + rattrs[rattr_count++] = LFSR_RATTR_ATTRS( + LFSR_TAG_ATTRS, 0, file->cfg->attrs, file->cfg->attr_count); } // pending metadata? looks like we need to write to disk - if (attr_count > 0) { + if (rattr_count > 0) { // checkpoint the allocator lfs_alloc_ckpoint(lfs); // commit! - LFS_ASSERT(attr_count <= sizeof(attrs)/sizeof(lfsr_attr_t)); + LFS_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfsr_rattr_t)); err = lfsr_mdir_commit(lfs, &file->o.o.mdir, - attrs, attr_count); + rattrs, rattr_count); if (err) { goto failed; } @@ -13154,13 +13154,13 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { continue; } - if (lfsr_uattr_isnoattr(&file->cfg->attrs[i])) { + if (lfsr_attr_isnoattr(&file->cfg->attrs[i])) { if (file_->cfg->attrs[j].size) { *file_->cfg->attrs[j].size = LFS_ERR_NOATTR; } } else { lfs_size_t d = lfs_min( - lfsr_uattr_size(&file->cfg->attrs[i]), + lfsr_attr_size(&file->cfg->attrs[i]), file_->cfg->attrs[j].buffer_size); memcpy(file_->cfg->attrs[j].buffer, file->cfg->attrs[i].buffer, @@ -13346,7 +13346,7 @@ int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { // truncate our btree err = lfsr_file_carve(lfs, file, lfs_min(size, size_), size - lfs_min(size, size_), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, +size_ - size, LFSR_DATA_NULL())); if (err) { @@ -13468,7 +13468,7 @@ int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { // fruncate our btree err = lfsr_file_carve(lfs, file, 0, lfs_smax(size - size_, 0), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, +size_ - size, LFSR_DATA_NULL())); if (err) { @@ -13811,7 +13811,7 @@ static int lfs_init(lfs_t *lfs, uint32_t flags, + (lfs_nlog2(lfs->file_limit+1)+7-1)/7 + (lfs_nlog2(lfs->cfg->block_size)+7-1)/7; LFS_ASSERT(tag_estimate <= LFSR_TAG_DSIZE); - lfs->attr_estimate = 3*tag_estimate + 4; + lfs->rattr_estimate = 3*tag_estimate + 4; // calculate the number of bits we need to reserve for mdir rids // @@ -14540,30 +14540,30 @@ static int lfsr_formatinited(lfs_t *lfs) { // - our magic string, "littlefs" // - any format-time configuration // - the root's bookmark tag, which reserves did = 0 for the root - err = lfsr_rbyd_commit(lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + err = lfsr_rbyd_commit(lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_MAGIC, 0, LFSR_DATA_BUF("littlefs", 8)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_VERSION, 0, LFSR_DATA_BUF(((const uint8_t[2]){ LFS_DISK_VERSION_MAJOR, LFS_DISK_VERSION_MINOR}), 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_RCOMPAT, 0, LFSR_DATA_RCOMPAT(LFSR_RCOMPAT_COMPAT)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GEOMETRY, 0, LFSR_DATA_GEOMETRY((&(lfsr_geometry_t){ lfs->cfg->block_size, lfs->cfg->block_count}))), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_NAMELIMIT, 0, LFSR_DATA_LLEB128(lfs->name_limit)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_FILELIMIT, 0, LFSR_DATA_LEB128(lfs->file_limit)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_BOOKMARK, +1, LFSR_DATA_LEB128(0)))); if (err) { @@ -14737,8 +14737,8 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) { // checkpoint the allocator lfs_alloc_ckpoint(lfs); // remove the rid while atomically updating our grm - err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); + err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); if (err) { // revert grm manually lfs->grm = grm_p; @@ -14780,8 +14780,8 @@ static int lfsr_fs_fixorphans_(lfs_t *lfs, lfsr_mdir_t *mdir) { lfsr_mid_rid(lfs, mdir->mid)); lfs_alloc_ckpoint(lfs); - err = lfsr_mdir_commit(lfs, mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); + err = lfsr_mdir_commit(lfs, mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); if (err) { goto failed; } @@ -15046,8 +15046,8 @@ int lfsr_fs_grow(lfs_t *lfs, lfs_size_t block_count_) { // update our on-disk config lfs_alloc_ckpoint(lfs); - int err = lfsr_mdir_commit(lfs, &lfs->mroot, LFSR_ATTRS( - LFSR_ATTR( + int err = lfsr_mdir_commit(lfs, &lfs->mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_GEOMETRY, 0, LFSR_DATA_GEOMETRY((&(lfsr_geometry_t){ lfs->cfg->block_size, diff --git a/lfs.h b/lfs.h index 946b5228..23dc74c3 100644 --- a/lfs.h +++ b/lfs.h @@ -826,7 +826,7 @@ typedef struct lfs { lfs_off_t file_limit; int8_t recycle_bits; - uint8_t attr_estimate; + uint8_t rattr_estimate; uint8_t mdir_bits; // linked-list of opened mdirs diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml index 5ba7c332..4c2461ad 100644 --- a/tests/test_badblocks.toml +++ b/tests/test_badblocks.toml @@ -74,8 +74,8 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; @@ -1848,8 +1848,8 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; @@ -3622,8 +3622,8 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; diff --git a/tests/test_btree.toml b/tests/test_btree.toml index aed49bcb..287d212f 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -52,8 +52,8 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -93,10 +93,10 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -142,10 +142,10 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -192,12 +192,12 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -250,12 +250,12 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -313,8 +313,8 @@ code = ''' lfsr_btree_t btree = LFSR_BTREE_NULL(); lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; n += 1; @@ -363,8 +363,8 @@ code = ''' lfsr_btree_t btree = LFSR_BTREE_NULL(); lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1)))) => 0; n += 1; @@ -428,8 +428,8 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; @@ -497,8 +497,8 @@ code = ''' lfsr_btree_t btree = LFSR_BTREE_NULL(); lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +W, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; n += 1; @@ -588,8 +588,8 @@ code = ''' } // add to btree - lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +weight, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; @@ -698,11 +698,11 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; // update the tree - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF("A", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", @@ -743,17 +743,17 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; // update the tree - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF("A", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF("B", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", @@ -801,23 +801,23 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; // update the tree - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF("A", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF("B", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF("C", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", @@ -874,15 +874,15 @@ code = ''' // create a tree with N elements lfsr_btree_t btree = LFSR_BTREE_NULL(); for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } // update the tree for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0; } @@ -931,8 +931,8 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL(); for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } @@ -952,8 +952,8 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % N; // update btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0; @@ -1017,15 +1017,15 @@ code = ''' // create a tree with N elements lfsr_btree_t btree = LFSR_BTREE_NULL(); for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +W, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } // update the tree for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0; } @@ -1090,8 +1090,8 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL(); for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +W, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } @@ -1122,11 +1122,11 @@ code = ''' // update btree lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR( + weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +weight-sim_weights[bid], LFSR_DATA_NULL()))) => 0; @@ -1232,11 +1232,11 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; // pop! - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1253,8 +1253,8 @@ code = ''' &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1288,13 +1288,13 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; // pop! - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1318,8 +1318,8 @@ code = ''' &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("B", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("B", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1360,13 +1360,13 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; // pop! - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1390,8 +1390,8 @@ code = ''' &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1432,15 +1432,15 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; // pop! - lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1471,8 +1471,8 @@ code = ''' &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("C", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("C", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1524,15 +1524,15 @@ code = ''' // create a tree with N elements lfsr_btree_t btree = LFSR_BTREE_NULL(); for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { - lfsr_btree_commit(&lfs, &btree, N-1-i, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, N-1-i, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } printf("btree: w%d 0x%x.%x\n", @@ -1561,8 +1561,8 @@ code = ''' &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try recovering - lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0; for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_lookup(&lfs, &btree, i, @@ -1603,15 +1603,15 @@ code = ''' // create a tree with N elements lfsr_btree_t btree = LFSR_BTREE_NULL(); for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -1640,8 +1640,8 @@ code = ''' &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try recovering - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0; lfsr_btree_lookup(&lfs, &btree, 0, &tag_, &weight_, &data_) => 0; @@ -1685,8 +1685,8 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL(); for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } @@ -1707,8 +1707,8 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % sim_size; // remove from btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // remove from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -1773,15 +1773,15 @@ code = ''' // create a tree with N elements lfsr_btree_t btree = LFSR_BTREE_NULL(); for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +W, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { - lfsr_btree_commit(&lfs, &btree, (N-1-i)*W+W-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, (N-1-i)*W+W-1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0; } printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -1809,8 +1809,8 @@ code = ''' &tag_, &weight_, &data_) => LFS_ERR_NOENT; // try recovering - lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("R", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("R", 1)))) => 0; for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_lookup(&lfs, &btree, i*W+W-1, @@ -1899,8 +1899,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +weight, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; @@ -1921,8 +1921,8 @@ code = ''' // remove from btree lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR( + weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM, -sim_weights[bid], LFSR_DATA_NULL()))) => 0; @@ -2028,17 +2028,17 @@ code = ''' // create a tree with N elements lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))) => 0; n += 1; @@ -2087,8 +2087,8 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -2105,11 +2105,11 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % sim_size; // split btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0; @@ -2176,17 +2176,17 @@ code = ''' // create a tree with N elements lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +W, LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, +W, LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))) => 0; n += 1; @@ -2236,8 +2236,8 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("_", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -2267,14 +2267,14 @@ code = ''' // split btree lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR( + weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_GROW, +weight1-sim_weights[bid], LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, +weight2, LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0; @@ -2416,28 +2416,28 @@ code = ''' // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf2, SIZE)))) => 0; assert(btree.weight == 2); // now remove one entry, since this brings the rbyd down to zero, // this should force one of the blocks to drop - lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2483,20 +2483,20 @@ code = ''' // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf2, SIZE)))) => 0; assert(btree.weight == 2); @@ -2506,8 +2506,8 @@ code = ''' // // do this while forcing a compaction btree.eoff = -1; - lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2553,15 +2553,15 @@ code = ''' // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; // force compaction, causing a split, but while we're splitting, // also remove an entry, bringing the split rbyd down to zero mid split @@ -2569,8 +2569,8 @@ code = ''' // messy, isn't it? this is why we need an explicit test // btree.eoff = -1; - lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2616,39 +2616,39 @@ code = ''' // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf2, SIZE)))) => 0; assert(btree.weight == 2); // now make both entries small so they should be merged if either compacts - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF("a", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF("b", 1)))) => 0; // force compaction, while removing one entry, this drops the rbyd // down to zero while also triggering a merge btree.eoff = -1; - lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2710,8 +2710,8 @@ code = ''' if (op == 0 || bid == sim_size) { // push to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; @@ -2722,8 +2722,8 @@ code = ''' } else if (op == 1) { // update btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; @@ -2732,8 +2732,8 @@ code = ''' } else { // pop from btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -2826,8 +2826,8 @@ code = ''' if (op == 0 || bid == sim_size) { // push to btree - lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +weight, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; @@ -2842,11 +2842,11 @@ code = ''' } else if (op == 1) { // update btree lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR( + weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +weight-sim_weights[bid], LFSR_DATA_NULL()))) => 0; @@ -2857,8 +2857,8 @@ code = ''' } else { // remove from btree lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR( + weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM, -sim_weights[bid], LFSR_DATA_NULL()))) => 0; @@ -2997,11 +2997,11 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, "aaa", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3049,17 +3049,17 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, "aaa", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), - LFSR_ATTR_NAME( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, "aab", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3115,23 +3115,23 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, "aaa", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), - LFSR_ATTR_NAME( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 1*DID, "aab", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), - LFSR_ATTR_NAME( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 2*DID, "aac", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3195,23 +3195,23 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, "aaa", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), - LFSR_ATTR_NAME( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 2*DID, "aac", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), - LFSR_ATTR_NAME( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 1*DID, "aab", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3279,11 +3279,11 @@ code = ''' char name[3] = { 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, name, 3), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; lfs_size_t n = 1; @@ -3291,14 +3291,14 @@ code = ''' char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; - lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), - LFSR_ATTR_NAME( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, i*DID, name, 3), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))) => 0; n += 1; @@ -3349,11 +3349,11 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, "___", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3386,14 +3386,14 @@ code = ''' } // split btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), - LFSR_ATTR_NAME( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, name, 3), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0; @@ -3466,11 +3466,11 @@ code = ''' char name[3] = { 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +W, 0, name, 3), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; lfs_size_t n = 1; @@ -3478,14 +3478,14 @@ code = ''' char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; - lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), - LFSR_ATTR_NAME( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +W, i*DID, name, 3), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))) => 0; n += 1; @@ -3537,11 +3537,11 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +W, 0, "___", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3587,17 +3587,17 @@ code = ''' // split btree lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR( + weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_GROW, +weight1-sim_weights[bid], LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), - LFSR_ATTR_NAME( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +weight2, 0, name, 3), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0; @@ -3693,11 +3693,11 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, "___", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3744,23 +3744,23 @@ code = ''' assert(cmp != LFS_CMP_EQ); if (cmp > LFS_CMP_EQ) { lfsr_btree_commit(&lfs, &btree, - split_bid, LFSR_ATTRS( - LFSR_ATTR_NAME( + split_bid, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, name, 3), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF( &(uint8_t){'0'+(i % 10)}, 1)))) => 0; } else { - lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS( - LFSR_ATTR_CAT_( + lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( + LFSR_RATTR_CAT_( LFSR_TAG_DATA, 0, &split_data, 1), - LFSR_ATTR_NAME( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +1, 0, name, 3), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0; } @@ -3774,8 +3774,8 @@ code = ''' } else if (op == 1) { // update btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0; @@ -3784,8 +3784,8 @@ code = ''' } else { // pop from btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -3850,11 +3850,11 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL(); - lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +W, 0, "___", 3), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3913,23 +3913,23 @@ code = ''' assert(cmp != LFS_CMP_EQ); if (cmp > LFS_CMP_EQ) { lfsr_btree_commit(&lfs, &btree, - split_bid-(split_weight-1), LFSR_ATTRS( - LFSR_ATTR_NAME( + split_bid-(split_weight-1), LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +weight, 0, name, 3), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF( &(uint8_t){'0'+(i % 10)}, 1)))) => 0; } else { - lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS( - LFSR_ATTR_CAT_( + lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( + LFSR_RATTR_CAT_( LFSR_TAG_DATA, 0, &split_data, 1), - LFSR_ATTR_NAME( + LFSR_RATTR_NAME( LFSR_TAG_NAME, +weight, 0, name, 3), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0; } @@ -3947,11 +3947,11 @@ code = ''' } else if (op == 1) { // update btree lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR( + weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +weight-sim_weights[bid], LFSR_DATA_NULL()))) => 0; @@ -3962,8 +3962,8 @@ code = ''' } else { // pop from btree lfsr_btree_commit(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR( + weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM, -sim_weights[bid], LFSR_DATA_NULL()))) => 0; @@ -4057,8 +4057,8 @@ code = ''' lfsr_btree_t btree = LFSR_BTREE_NULL(); lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { - lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; n += 1; @@ -4193,8 +4193,8 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_DATA, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; diff --git a/tests/test_mount.toml b/tests/test_mount.toml index d16f1c39..2fbea650 100644 --- a/tests/test_mount.toml +++ b/tests/test_mount.toml @@ -515,8 +515,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_MAGIC, 0, LFSR_DATA_NULL()))) => 0; lfsr_unmount(&lfs) => 0; @@ -539,8 +539,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_MAGIC, 0, LFSR_DATA_BUF("lottlefs", 8)))) => 0; lfsr_unmount(&lfs) => 0; @@ -563,8 +563,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_VERSION, 0, LFSR_DATA_BUF(((const uint8_t[2]){ LFS_DISK_VERSION_MAJOR+1, @@ -589,8 +589,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_VERSION, 0, LFSR_DATA_BUF(((const uint8_t[2]){ LFS_DISK_VERSION_MAJOR, @@ -616,8 +616,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RCOMPAT, 0, LFSR_DATA_RCOMPAT( LFSR_RCOMPAT_COMPAT @@ -643,8 +643,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_WCOMPAT, 0, LFSR_DATA_WCOMPAT( LFSR_WCOMPAT_COMPAT @@ -673,8 +673,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_OCOMPAT, 0, LFSR_DATA_OCOMPAT( LFSR_OCOMPAT_COMPAT @@ -701,8 +701,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR_CAT( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR_CAT( LFSR_TAG_RCOMPAT, 0, LFSR_DATA_RCOMPAT(LFSR_RCOMPAT_COMPAT), LFSR_DATA_BUF("\x00\x00\x00\x00\x80", 5)))) => 0; @@ -725,8 +725,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR_CAT( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR_CAT( LFSR_TAG_WCOMPAT, 0, LFSR_DATA_WCOMPAT(LFSR_WCOMPAT_COMPAT), LFSR_DATA_BUF("\x00\x00\x00\x00\x80", 5)))) => 0; @@ -752,8 +752,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR_CAT( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR_CAT( LFSR_TAG_OCOMPAT, 0, LFSR_DATA_OCOMPAT(LFSR_OCOMPAT_COMPAT), LFSR_DATA_BUF("\x00\x00\x00\x00\x80", 5)))) => 0; @@ -780,8 +780,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_GEOMETRY, 0, LFSR_DATA_GEOMETRY((&(lfsr_geometry_t){ INC_BLOCK_SIZE, @@ -807,8 +807,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_GEOMETRY, 0, LFSR_DATA_GEOMETRY((&(lfsr_geometry_t){ BLOCK_SIZE, @@ -834,8 +834,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_NAMELIMIT, 0, LFSR_DATA_LLEB128(INC_NAME_LIMIT)))) => 0; lfsr_unmount(&lfs) => 0; @@ -858,8 +858,8 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR_CAT( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR_CAT( LFSR_TAG_FILELIMIT, 0, // it's a bit difficult to test this since file limit // is usually our integer limit, but we can force a @@ -884,8 +884,8 @@ code = ''' // create an unknown config lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_CONFIG + 0x13, 0, LFSR_DATA_BUF("oh no!", strlen("oh no!"))))) => 0; lfsr_unmount(&lfs) => 0; @@ -932,8 +932,8 @@ code = ''' lfsr_mtree_pathlookup(&lfs, "b", &mdir, NULL, &did, &name, &name_size) => LFS_ERR_EXIST; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR_NAME( + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR_NAME( LFSR_TAG_SUB | (LFSR_TAG_NAME + 0x13), 0, did, name, name_size))) => 0; lfsr_unmount(&lfs) => 0; diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index bcb938d2..68bca3d5 100644 --- a/tests/test_mtree.toml +++ b/tests/test_mtree.toml @@ -15,7 +15,7 @@ code = ''' ''' # test a single mroot with attributes -[cases.test_mtree_mroot_attrs] +[cases.test_mtree_mroot_rattrs] defines.N = [1, 3] in = 'lfs.c' code = ''' @@ -25,8 +25,8 @@ code = ''' lfs_alloc_ckpoint(&lfs); for (lfs_size_t i = 0; i < N; i++) { - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(i), 0, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } @@ -70,8 +70,8 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(i), 0, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } @@ -112,8 +112,8 @@ code = ''' lfs_alloc_ckpoint(&lfs); for (lfs_size_t i = 0; i < N; i++) { - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; lfsr_data_t data; @@ -158,29 +158,29 @@ code = ''' lfs_alloc_ckpoint(&lfs); lfsr_data_t data; - // create a 2 large attrs that needs to be uninlined + // create a 2 large rattrs that needs to be uninlined uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined assert(lfsr_mtree_weight_(&lfs.mtree) == (1 << lfs.mdir_bits)); // assert mroot now has no entries assert(lfs.mroot.rbyd.weight == 0); - // assert that our attrs are still in the mroot/mtree + // assert that our rattrs are still in the mroot/mtree lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); @@ -204,7 +204,7 @@ code = ''' // assert mroot now has no entries assert(lfs.mroot.rbyd.weight == 0); - // assert that our attrs are still in the mroot/mtree + // assert that our rattrs are still in the mroot/mtree lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); @@ -240,21 +240,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -325,21 +325,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -350,14 +350,14 @@ code = ''' memset(buffer+1, 'd', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mdir to compact mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("e", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("e", 1)))) => 0; // assert mdir was split correctly assert(lfsr_mtree_weight_(&lfs.mtree) == (3 << lfs.mdir_bits)); @@ -455,8 +455,8 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; uint8_t buffer[256]; @@ -553,8 +553,8 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -636,21 +636,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -661,8 +661,8 @@ code = ''' memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped @@ -722,21 +722,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -749,8 +749,8 @@ code = ''' &mdir, NULL, NULL) => 0; // force mdir to compact while we're removing mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped @@ -810,15 +810,15 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // remove an entry, forcing the mdir to be dropped @@ -828,8 +828,8 @@ code = ''' // force mdir to compact while we're removing lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 2); // assert split/drop worked out @@ -881,21 +881,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -906,8 +906,8 @@ code = ''' memset(buffer+1, 'd', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // remove an entry, forcing the mdir to be dropped @@ -916,8 +916,8 @@ code = ''' &mdir, NULL, NULL) => 0; // force mdir to compact while we're removing mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 1); // assert split/drop worked out @@ -989,21 +989,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -1014,8 +1014,8 @@ code = ''' memset(buffer+1, 'd', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // remove an entry, forcing the mdir to be dropped @@ -1024,8 +1024,8 @@ code = ''' &mdir, NULL, NULL) => 0; // force mdir to compact while we're removing mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 1); // assert split/drop worked out @@ -1124,8 +1124,8 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -1152,8 +1152,8 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } } @@ -1224,22 +1224,22 @@ code = ''' lfs_alloc_ckpoint(&lfs); lfsr_data_t data; - // create a 2 large attrs that needs to be uninlined + // create a 2 large rattrs that needs to be uninlined uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined assert(lfsr_mtree_weight_(&lfs.mtree) == (1 << lfs.mdir_bits)); @@ -1250,11 +1250,11 @@ code = ''' lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("d", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("d", 1)))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("e", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("e", 1)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1263,7 +1263,7 @@ code = ''' // assert mroot now has no entries assert(lfs.mroot.rbyd.weight == 0); - // assert that our attrs are still in the mroot/mtree + // assert that our rattrs are still in the mroot/mtree lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); @@ -1297,7 +1297,7 @@ code = ''' // assert mroot now has no entries assert(lfs.mroot.rbyd.weight == 0); - // assert that our attrs are still in the mroot/mtree + // assert that our rattrs are still in the mroot/mtree lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); @@ -1345,21 +1345,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -1372,11 +1372,11 @@ code = ''' &mdir, NULL, NULL) => 0; lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1471,21 +1471,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -1498,11 +1498,11 @@ code = ''' &mdir, NULL, NULL) => 0; lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1597,18 +1597,18 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -1631,7 +1631,7 @@ code = ''' lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - // assert that our attr is still in the mroot + // assert that our rattr is still in the mroot lfsr_mtree_lookup(&lfs, (0 << lfs.mdir_bits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; @@ -1672,18 +1672,18 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -1691,21 +1691,21 @@ code = ''' // twice, forcing a second mroot extension old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("d", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("d", 1)))) => 0; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("e", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("e", 1)))) => 0; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("f", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("f", 1)))) => 0; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("g", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("g", 1)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); - // assert that our attr is still in the mroot + // assert that our rattr is still in the mroot lfsr_mtree_lookup(&lfs, (0 << lfs.mdir_bits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; @@ -1740,7 +1740,7 @@ code = ''' lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - // assert that our attr is still in the mroot + // assert that our rattr is still in the mroot lfsr_mtree_lookup(&lfs, (0 << lfs.mdir_bits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; @@ -1794,29 +1794,29 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // force mroot to compact twice again, this should relocate the mroot old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("d", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("d", 1)))) => 0; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("e", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("e", 1)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -1847,7 +1847,7 @@ code = ''' lfsr_unmount(&lfs) => 0; lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - // assert that our attr is still in the mroot + // assert that our rattr is still in the mroot lfsr_mtree_lookup(&lfs, (0 << lfs.mdir_bits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; @@ -1893,21 +1893,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -1923,11 +1923,11 @@ code = ''' &mdir, NULL, NULL) => 0; lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated @@ -2024,21 +2024,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -2049,8 +2049,8 @@ code = ''' memset(buffer+1, 'd', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // setup mroot to compact and relocate on next commit @@ -2059,11 +2059,11 @@ code = ''' // force mdir to compact twice, this should relocate lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("e", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("e", 1)))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("f", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("f", 1)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated @@ -2168,21 +2168,21 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mdirs were unininlined and split assert(lfsr_mtree_weight_(&lfs.mtree) == (2 << lfs.mdir_bits)); @@ -2198,12 +2198,12 @@ code = ''' &mdir, NULL, NULL) => 0; // force mdir to compact twice, this should relocate mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; // force mdir to compact while we're removing mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 0); // assert mroot relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2265,23 +2265,23 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; lfsr_data_t data; - // create a 2 large attrs that needs to be uninlined + // create a 2 large rattrs that needs to be uninlined uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact, this should both uninline and relocate lfsr_mdir_t old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mroot relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2290,7 +2290,7 @@ code = ''' // assert mroot now has no entries assert(lfs.mroot.rbyd.weight == 0); - // assert that our attrs are still in the mroot/mtree + // assert that our rattrs are still in the mroot/mtree lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); @@ -2314,7 +2314,7 @@ code = ''' // assert mroot now has no entries assert(lfs.mroot.rbyd.weight == 0); - // assert that our attrs are still in the mroot/mtree + // assert that our rattrs are still in the mroot/mtree lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); @@ -2357,22 +2357,22 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact, this should both split and relocate lfsr_mdir_t old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; // assert mroot relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2474,8 +2474,8 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -2503,8 +2503,8 @@ code = ''' } // we can't really change metadata names, but commits still // trigger writes to the mdir - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(name, 4)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -2531,8 +2531,8 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } } @@ -2601,16 +2601,16 @@ code = ''' lfsr_omdir_t left = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_omdir_open(&lfs, &left); lfsr_omdir_t right = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "c", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0c", 2)))) => 0; + lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0c", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_omdir_open(&lfs, &right); @@ -2618,8 +2618,8 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, "b", 1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; assert(mdir.rbyd.weight == 4); lfsr_data_t data; @@ -2660,16 +2660,16 @@ code = ''' lfsr_omdir_t left = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_omdir_open(&lfs, &left); lfsr_omdir_t right = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "b", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; + lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_omdir_open(&lfs, &right); @@ -2677,8 +2677,8 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &mdir, NULL, NULL) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 2); // assert neighbor was removed @@ -2710,16 +2710,16 @@ code = ''' lfsr_omdir_t left = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_omdir_open(&lfs, &left); lfsr_omdir_t right = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "b", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; + lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_omdir_open(&lfs, &right); @@ -2727,8 +2727,8 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, "b", 1, &mdir, NULL, NULL) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 2); // assert neighbor was removed @@ -2762,16 +2762,16 @@ code = ''' lfsr_omdir_t left = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_omdir_open(&lfs, &left); lfsr_omdir_t right = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "d", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; + lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_omdir_open(&lfs, &right); @@ -2782,15 +2782,15 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'c', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -2835,16 +2835,16 @@ code = ''' lfsr_omdir_t left = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_omdir_open(&lfs, &left); lfsr_omdir_t right = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "e", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0; + lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_omdir_open(&lfs, &right); @@ -2855,15 +2855,15 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'd', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -2874,8 +2874,8 @@ code = ''' memset(buffer+1, 'c', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); // force mdir to compact @@ -2920,16 +2920,16 @@ code = ''' lfsr_omdir_t left = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_omdir_open(&lfs, &left); lfsr_omdir_t right = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "b", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; + lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_omdir_open(&lfs, &right); @@ -2978,16 +2978,16 @@ code = ''' lfsr_omdir_t left = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_omdir_open(&lfs, &left); lfsr_omdir_t right = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "d", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; + lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_omdir_open(&lfs, &right); @@ -2998,15 +2998,15 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'c', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -3024,11 +3024,11 @@ code = ''' &mdir, NULL, NULL) => 0; lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -3067,16 +3067,16 @@ code = ''' lfsr_omdir_t left = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_omdir_open(&lfs, &left); lfsr_omdir_t right = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "d", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; + lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_omdir_open(&lfs, &right); @@ -3087,15 +3087,15 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'c', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -3113,11 +3113,11 @@ code = ''' &mdir, NULL, NULL) => 0; lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; mdir.rbyd.eoff = -1; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -3154,16 +3154,16 @@ code = ''' lfsr_omdir_t left = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_omdir_open(&lfs, &left); lfsr_omdir_t right = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "f", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0f", 2)))) => 0; + lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0f", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_omdir_open(&lfs, &right); @@ -3174,15 +3174,15 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'e', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -3193,8 +3193,8 @@ code = ''' memset(buffer+1, 'c', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); // force mdir to compact @@ -3210,8 +3210,8 @@ code = ''' memset(buffer+1, 'd', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mdir to compact @@ -3256,16 +3256,16 @@ code = ''' lfsr_omdir_t left = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &left.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_omdir_open(&lfs, &left); lfsr_omdir_t right = {.flags=0}; lfsr_mtree_namelookup(&lfs, 0, "e", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0; + lfsr_mdir_commit(&lfs, &right.mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_omdir_open(&lfs, &right); @@ -3276,15 +3276,15 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); memset(buffer+1, 'd', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -3295,8 +3295,8 @@ code = ''' memset(buffer+1, 'c', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); // force mdir to compact @@ -3309,8 +3309,8 @@ code = ''' assert(lfs.mroot.rbyd.weight == 0); // now remove the middle entry, forcing a drop - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped correctly @@ -3354,8 +3354,8 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(mdir.rbyd.weight == 2); // test that we can traverse the tree, keeping track of all blocks we see @@ -3453,17 +3453,17 @@ code = ''' lfs_alloc_ckpoint(&lfs); lfsr_data_t data; - // create a 2 large attrs that needs to be uninlined + // create a 2 large rattrs that needs to be uninlined uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -3539,7 +3539,7 @@ code = ''' // assert mroot now has no entries assert(lfs.mroot.rbyd.weight == 0); - // assert that our attrs are still in the mroot/mtree + // assert that our rattrs are still in the mroot/mtree lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); @@ -3559,7 +3559,7 @@ code = ''' // assert mroot now has no entries assert(lfs.mroot.rbyd.weight == 0); - // assert that our attrs are still in the mroot/mtree + // assert that our rattrs are still in the mroot/mtree lfsr_mdir_lookup(&lfs, &lfs.mroot, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, SIZE) => SIZE; assert(buffer[0] == 'a'); @@ -3592,15 +3592,15 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -3734,15 +3734,15 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -3758,8 +3758,8 @@ code = ''' memset(buffer+1, 'c', SIZE-1); lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mdir to compact @@ -3901,8 +3901,8 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, "a", 1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot @@ -4025,8 +4025,8 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; uint8_t buffer[256]; @@ -4186,8 +4186,8 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; } - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -4323,8 +4323,8 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; lfs_alloc_ckpoint(&lfs); - lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR( + lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_MROOT, 0, LFSR_DATA_MPTR(LFSR_MPTR_MROOTANCHOR())))) => 0; @@ -4408,8 +4408,8 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot @@ -4465,8 +4465,8 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; - lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mroot to compact twice, this should extend the mroot @@ -4492,7 +4492,7 @@ code = ''' // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); - // assert that our attr is still in the mroot + // assert that our rattr is still in the mroot lfsr_mtree_lookup(&lfs, (0 << lfs.mdir_bits)+1, &mdir) => 0; assert(mdir.rbyd.weight == 2); lfsr_mdir_lookup(&lfs, &mdir, LFSR_TAG_REG, &data) => 0; diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index b9e61faa..0a6d0808 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -31,8 +31,8 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -40,11 +40,11 @@ code = ''' // commit with two attributes rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -68,8 +68,8 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -77,12 +77,12 @@ code = ''' // commit with two attributes rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -106,8 +106,8 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -115,8 +115,8 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with the second attribute - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -148,8 +148,8 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -173,11 +173,11 @@ code = ''' // commit with two attributes rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -211,11 +211,11 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -268,8 +268,8 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -293,12 +293,12 @@ code = ''' // commit with two attributes rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -332,12 +332,12 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -389,8 +389,8 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -410,11 +410,11 @@ code = ''' // commit with two attributes rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -436,11 +436,11 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0; @@ -479,8 +479,8 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -500,12 +500,12 @@ code = ''' // commit with two attributes rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -527,12 +527,12 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0; @@ -575,11 +575,11 @@ code = ''' // 1 1 2 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -601,11 +601,11 @@ code = ''' // 2 2 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -646,14 +646,14 @@ code = ''' // 1 2 1 2 2 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -675,14 +675,14 @@ code = ''' // 1 2 1 2 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -725,14 +725,14 @@ code = ''' // 1 2 1 2 3 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -761,14 +761,14 @@ code = ''' // 2 3 2 3 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -816,17 +816,17 @@ code = ''' // 1 2 3 1 2 3 3 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -855,17 +855,17 @@ code = ''' // 1 2 3 1 2 3 2 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -894,17 +894,17 @@ code = ''' // 1 2 3 1 2 3 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -933,17 +933,17 @@ code = ''' // 3 1 2 3 1 2 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -993,17 +993,17 @@ code = ''' // 1 2 3 1 2 3 4 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; @@ -1039,17 +1039,17 @@ code = ''' // 1 3 4 1 3 4 2 1 3 4 2 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -1085,17 +1085,17 @@ code = ''' // 2 3 4 2 3 4 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -1131,17 +1131,17 @@ code = ''' // 4 2 3 4 2 3 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -1196,17 +1196,17 @@ code = ''' // 1 2 3 1 2 3 4 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; @@ -1242,17 +1242,17 @@ code = ''' // 1 2 4 1 2 4 3 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -1288,17 +1288,17 @@ code = ''' // 1 4 2 1 4 2 3 1 4 2 3 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -1334,17 +1334,17 @@ code = ''' // 4 1 2 4 1 2 3 4 1 2 3 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -1401,20 +1401,20 @@ code = ''' // 1 2 3 4 1 2 3 4 4 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; @@ -1452,20 +1452,20 @@ code = ''' // 1 2 3 4 1 2 3 4 3 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -1501,20 +1501,20 @@ code = ''' // 1 2 3 4 1 2 3 4 2 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -1550,20 +1550,20 @@ code = ''' // 1 2 3 4 1 2 3 4 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -1622,20 +1622,20 @@ code = ''' // 1 2 3 4 1 2 3 4 5 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; @@ -1680,20 +1680,20 @@ code = ''' // 1 2 4 5 1 2 4 5 3 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -1736,20 +1736,20 @@ code = ''' // 1 3 4 5 1 3 4 5 2 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -1792,20 +1792,20 @@ code = ''' // 2 3 4 5 2 3 4 5 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -1869,23 +1869,23 @@ code = ''' // 1 2 3 4 5 1 2 3 4 5 5 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; @@ -1930,23 +1930,23 @@ code = ''' // 1 2 3 4 5 1 2 3 4 5 2 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -1991,23 +1991,23 @@ code = ''' // 1 2 3 4 5 1 2 3 4 5 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -2073,23 +2073,23 @@ code = ''' // 1 2 3 4 5 1 2 3 4 5 6 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xff\xff\xff\xff", 4)))) => 0; @@ -2139,23 +2139,23 @@ code = ''' // 1 3 4 5 6 1 3 4 5 6 2 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xff\xff\xff\xff", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -2205,23 +2205,23 @@ code = ''' // 2 3 4 5 6 2 3 4 5 6 1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xff\xff\xff\xff", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -2304,9 +2304,9 @@ code = ''' printf("] ---\n"); // build the attribute list for the current permutation - struct lfsr_attr attrs[N]; + struct lfsr_rattr rattrs[N]; for (unsigned j = 0; j < N; j++) { - attrs[j] = LFSR_ATTR( + rattrs[j] = LFSR_RATTR( LFSR_TAG_ATTR(perm[j]+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)); } @@ -2314,7 +2314,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, attrs, N) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, rattrs, N) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { @@ -2398,8 +2398,8 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(perm[j]+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } @@ -2458,11 +2458,11 @@ code = ''' // the tag requested rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -2496,11 +2496,11 @@ code = ''' // also try the other direction rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -2555,12 +2555,12 @@ code = ''' // the tag requested rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -2594,12 +2594,12 @@ code = ''' // also try the other direction rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -2673,9 +2673,9 @@ code = ''' printf("] ---\n"); // build the attribute list for the current permutation - struct lfsr_attr attrs[N]; + struct lfsr_rattr rattrs[N]; for (unsigned j = 0; j < N; j++) { - attrs[j] = LFSR_ATTR( + rattrs[j] = LFSR_RATTR( LFSR_TAG_ATTR(perm[j]+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)); } @@ -2683,7 +2683,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, attrs, N) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, rattrs, N) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // try traversing all tags @@ -2749,8 +2749,8 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(perm[j]+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } @@ -2806,8 +2806,8 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(j+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } @@ -2848,8 +2848,8 @@ code = ''' // update each tag in permutation order for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(perm[j]+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; } @@ -2927,8 +2927,8 @@ code = ''' = (ORDER == 0) ? i : (ORDER == 1) ? (((lfs_size_t)-1) - i) : TEST_PRNG(&prng); - int err = lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + int err = lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(x & 0x7f), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))); if (err == LFS_ERR_RANGE) { @@ -2979,12 +2979,12 @@ code = ''' // add and remove one attribute rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()))) => 0; @@ -3002,15 +3002,15 @@ code = ''' // commit with two attributes, remove the first one rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()))) => 0; @@ -3044,15 +3044,15 @@ code = ''' // commit with two attributes, remove the second one rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0, LFSR_DATA_NULL()))) => 0; @@ -3131,8 +3131,8 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(perm[j]+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } @@ -3156,8 +3156,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(j+1), 0, LFSR_DATA_NULL()))) => 0; @@ -3185,8 +3185,8 @@ code = ''' // try appending the tag back to make sure things still work printf("--- append: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(j+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; @@ -3281,8 +3281,8 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(perm[j]+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } @@ -3306,8 +3306,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(j+1), 0, LFSR_DATA_NULL()))) => 0; @@ -3360,11 +3360,11 @@ code = ''' // create a tree two attributes rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -3391,8 +3391,8 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // try to remove tags that aren't there, this should do nothing - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -3418,8 +3418,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -3445,8 +3445,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -3519,31 +3519,31 @@ code = ''' // create a tree rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; // remove several attributes - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0, LFSR_DATA_NULL()))) => 0; @@ -3571,8 +3571,8 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // try to remove tags that aren't there, this should do nothing - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -3598,8 +3598,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -3625,8 +3625,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -3654,8 +3654,8 @@ code = ''' // 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, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -3681,8 +3681,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -3708,8 +3708,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -3782,12 +3782,12 @@ code = ''' // commit with one attribute, remove it rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()))) => 0; @@ -3805,18 +3805,18 @@ code = ''' // commit with two attributes, remove both rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0, LFSR_DATA_NULL()))) => 0; @@ -3834,18 +3834,18 @@ code = ''' // commit with two attributes, remove both in the other order rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()))) => 0; @@ -3896,8 +3896,8 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(j+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } @@ -3938,8 +3938,8 @@ code = ''' // remove each tag in permutation order for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(perm[j]+1), 0, LFSR_DATA_NULL()))) => 0; } @@ -3952,8 +3952,8 @@ code = ''' } // try resuming from all tags being removed - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; @@ -4020,13 +4020,13 @@ code = ''' printf("perm: ["); uint32_t prng = SEED; for (unsigned i = 0; i < N; i++) { - // choose an attr - uint8_t attr = TEST_PRNG(&prng) % N; + // choose an rattr + uint8_t rattr = TEST_PRNG(&prng) % N; // choose append or remove if (TEST_PRNG(&prng) & 1) { - printf("a0x%02x=%c", attr, 'a'+(i % 26)); + printf("a0x%02x=%c", rattr, 'a'+(i % 26)); } else { - printf("r0x%02x", attr); + printf("r0x%02x", rattr); } if (i < N-1) { printf(", "); @@ -4044,24 +4044,24 @@ code = ''' prng = SEED; for (unsigned i = 0; i < N; i++) { - // choose an attr - uint8_t attr = TEST_PRNG(&prng) % N; + // choose an rattr + uint8_t rattr = TEST_PRNG(&prng) % N; // choose append or remove if (TEST_PRNG(&prng) & 1) { // update our sim - sim[attr] = 'a'+(i % 26); + sim[rattr] = 'a'+(i % 26); // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( - LFSR_TAG_ATTR(attr), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( + LFSR_TAG_ATTR(rattr), 0, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else { // update our sim - sim[attr] = '\0'; + sim[rattr] = '\0'; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( - LFSR_TAG_RM | LFSR_TAG_ATTR(attr), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( + LFSR_TAG_RM | LFSR_TAG_ATTR(rattr), 0, LFSR_DATA_NULL()))) => 0; } } @@ -4069,20 +4069,20 @@ code = ''' // compare rbyd vs simulation printf("expd: ["); bool first = true; - for (unsigned attr = 0; attr < N; attr++) { - if (sim[attr]) { + for (unsigned rattr = 0; rattr < N; rattr++) { + if (sim[rattr]) { if (!first) { printf(", "); } first = false; - printf("0x%02x=%c", attr, sim[attr]); + printf("0x%02x=%c", rattr, sim[rattr]); } } printf("]\n"); printf("rbyd: ["); first = true; - for (unsigned attr = 0; attr < N; attr++) { - int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(attr), + for (unsigned rattr = 0; rattr < N; rattr++) { + int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(rattr), &data); if (!err) { lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4); @@ -4090,19 +4090,19 @@ code = ''' printf(", "); } first = false; - printf("0x%02x=%.*s", attr, size, buffer); + printf("0x%02x=%.*s", rattr, size, buffer); } } printf("]\n"); - for (unsigned attr = 0; attr < N; attr++) { - int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(attr), + for (unsigned rattr = 0; rattr < N; rattr++) { + int err = lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(rattr), &data); - if (sim[attr]) { + if (sim[rattr]) { assert(err == 0); lfs_ssize_t size = lfsr_data_read(&lfs, &data, buffer, 4); assert(size == 1); - assert(memcmp(&sim[attr], buffer, 1) == 0); + assert(memcmp(&sim[rattr], buffer, 1) == 0); } else { assert(err == LFS_ERR_NOENT); } @@ -4135,8 +4135,8 @@ code = ''' // try to create one rid rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -4154,11 +4154,11 @@ code = ''' // try to create two ids rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -4182,14 +4182,14 @@ code = ''' // create a third to the right rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -4237,8 +4237,8 @@ code = ''' // try to create one rid rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -4256,12 +4256,12 @@ code = ''' // try to create two ids rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -4285,12 +4285,12 @@ code = ''' // try to create two in the other direction rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -4314,16 +4314,16 @@ code = ''' // create a third to the right rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -4353,16 +4353,16 @@ code = ''' // create a third to the left rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -4392,16 +4392,16 @@ code = ''' // create a third in the middle rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -4495,8 +4495,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -4557,11 +4557,11 @@ code = ''' // the tag requested rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 00000000, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 00000000, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -4630,12 +4630,12 @@ code = ''' // the tag requested rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -4681,12 +4681,12 @@ code = ''' // also try the other direction rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -4795,8 +4795,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -4868,8 +4868,8 @@ code = ''' : (uint16_t)TEST_PRNG(&prng); x = x % (rbyd.weight+1); - int err = lfsr_rbyd_commit(&lfs, &rbyd, x, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[x % 6], 4)))); + int err = lfsr_rbyd_commit(&lfs, &rbyd, x, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[x % 6], 4)))); if (err == LFS_ERR_RANGE) { break; } @@ -4893,7 +4893,7 @@ code = ''' ''' -### Mixed create and attr testing ### +### Mixed create and rattr testing ### [cases.test_rbyd_atomic_mixed] in = 'lfs.c' @@ -4915,11 +4915,11 @@ code = ''' // try to create one rid rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; @@ -4943,17 +4943,17 @@ code = ''' // try to create two ids rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; @@ -4989,23 +4989,23 @@ code = ''' // create a third to the right rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; @@ -5094,12 +5094,12 @@ code = ''' // try to create one rid rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; @@ -5123,20 +5123,20 @@ code = ''' // try to create two ids rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; @@ -5172,20 +5172,20 @@ code = ''' // try to create two in the other direction rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; @@ -5221,28 +5221,28 @@ code = ''' // create a third to the right rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; @@ -5313,28 +5313,28 @@ code = ''' // create a third to the left rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; @@ -5382,28 +5382,28 @@ code = ''' // create a third in the middle rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; @@ -5516,14 +5516,14 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; - // note uattrs have a smaller size to help debugging + // note urattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -5591,17 +5591,17 @@ code = ''' // the tag requested rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; @@ -5702,20 +5702,20 @@ code = ''' // the tag requested rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; @@ -5793,20 +5793,20 @@ code = ''' // also try the other direction rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; @@ -5948,14 +5948,14 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; - // note uattrs have a smaller size to help debugging + // note urattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -6038,14 +6038,14 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[j % 6], 4)))) => 0; - // note uattrs have a smaller size to help debugging + // note urattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[j % 6], 2)))) => 0; } @@ -6087,8 +6087,8 @@ code = ''' // update each tag in permutation order for (unsigned j = 0; j < N*M; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(perm[j]%M+1), 0, LFSR_DATA_BUF(names[(perm[j]/M) % 6], 3)))) => 0; } @@ -6205,14 +6205,14 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; - // note uattrs have a smaller size to help debugging + // note urattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -6237,8 +6237,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR((j%M)+1), 0, LFSR_DATA_NULL()))) => 0; @@ -6281,8 +6281,8 @@ code = ''' // try append the tag back to make sure things still work printf("--- append: rid%jd, %jd ---\n", j/M, (j%M)+1); - lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR((j%M)+1), 0, LFSR_DATA_BUF(names[(j/M)%6], 3)))) => 0; @@ -6385,14 +6385,14 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[j % 6], 4)))) => 0; - // note uattrs have a smaller size to help debugging + // note urattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[j % 6], 2)))) => 0; } @@ -6434,8 +6434,8 @@ code = ''' // remove each tag in permutation order for (unsigned j = 0; j < N*M; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(perm[j]%M+1), 0, LFSR_DATA_NULL()))) => 0; } @@ -6525,17 +6525,19 @@ code = ''' : (uint16_t)TEST_PRNG(&prng); x = x % (rbyd.weight+1); - // build a single attribute list with all attributes, if this fails + // build a single attribute list with all rattributes, if this fails // it should fail atomically - struct lfsr_attr attrs[1+M]; - attrs[0] = LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[x % 6], 4)); + struct lfsr_rattr rattrs[1+M]; + rattrs[0] = LFSR_RATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[x % 6], 4)); for (unsigned u = 0; u < M; u++) { - attrs[1+u] = LFSR_ATTR( + rattrs[1+u] = LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[x % 6], 2)); } - int err = lfsr_rbyd_commit(&lfs, &rbyd, x, attrs, 1+M); + int err = lfsr_rbyd_commit(&lfs, &rbyd, x, rattrs, 1+M); if (err == LFS_ERR_RANGE) { break; } @@ -6636,13 +6638,13 @@ code = ''' } // note the data size differences here - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(perm[j]+1), 0, LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -6782,18 +6784,18 @@ code = ''' } // note the data size differences here - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(perm[j]+1), 0, LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -6907,15 +6909,15 @@ code = ''' // try to delete one rid rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6935,15 +6937,15 @@ code = ''' // try to delete the other rid rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6963,18 +6965,18 @@ code = ''' // try to delete the largest of three rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6998,18 +7000,18 @@ code = ''' // try to delete the smallest of three rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7033,18 +7035,18 @@ code = ''' // try to delete the middle rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7086,21 +7088,21 @@ code = ''' // try to delete one rid rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7130,21 +7132,21 @@ code = ''' // try to delete the other rid rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7174,27 +7176,27 @@ code = ''' // try to delete the largest of three rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7236,27 +7238,27 @@ code = ''' // try to delete the smallest of three rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7298,27 +7300,27 @@ code = ''' // try to delete the middle rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7388,68 +7390,68 @@ code = ''' // rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7549,8 +7551,8 @@ code = ''' &data) => LFS_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -7686,62 +7688,62 @@ code = ''' // rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), +1, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7829,8 +7831,8 @@ code = ''' &data) => LFS_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -7954,90 +7956,90 @@ code = ''' // rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), +1, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(8), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(8), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -8161,8 +8163,8 @@ code = ''' &data) => LFS_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -8325,78 +8327,78 @@ code = ''' // rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), +1, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(8), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(9), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(9), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(9), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -8514,8 +8516,8 @@ code = ''' &data) => LFS_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -8672,78 +8674,78 @@ code = ''' // rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(9), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), +1, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(8), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(8), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -8861,8 +8863,8 @@ code = ''' &data) => LFS_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -9019,79 +9021,79 @@ code = ''' // rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), +1, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -9197,8 +9199,8 @@ code = ''' &data) => LFS_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -9343,79 +9345,79 @@ code = ''' // rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), +1, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), +1, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -9521,8 +9523,8 @@ code = ''' &data) => LFS_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -9669,120 +9671,120 @@ code = ''' // rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), +1, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(8), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(11), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(12), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(13), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(14), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(9), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(10), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(10), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -9930,8 +9932,8 @@ code = ''' &data) => LFS_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -10120,118 +10122,118 @@ code = ''' // rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(6), +1, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(7), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(8), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(9), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(10), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(10), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(10), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(10), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; // this gets a bit messy as we try to make the rbyd take the right shape - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(11), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(12), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(13), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(14), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(14), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(14), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, 0, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -10379,8 +10381,8 @@ code = ''' &data) => LFS_ERR_NOENT; // try to recreate - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -10605,8 +10607,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -10631,8 +10633,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10651,8 +10653,8 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N); @@ -10767,14 +10769,14 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; - // note uattrs have a smaller size to help debugging + // note urattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -10800,8 +10802,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10833,13 +10835,13 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[j % 6], 6)))) => 0; for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[j % 6], 3)))) => 0; } @@ -10967,8 +10969,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -10993,8 +10995,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -11097,14 +11099,14 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; - // note uattrs have a smaller size to help debugging + // note urattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -11130,8 +11132,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -11202,12 +11204,12 @@ code = ''' // create and delete one rid rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11221,16 +11223,16 @@ code = ''' // create and delete two ids rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11244,17 +11246,17 @@ code = ''' // create and delete two ids in the other order rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11268,20 +11270,20 @@ code = ''' // create and delete three ids rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11295,22 +11297,22 @@ code = ''' // create and delete three ids in the other order rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11342,15 +11344,15 @@ code = ''' // create and delete one rid rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11364,22 +11366,22 @@ code = ''' // create and delete two ids rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11393,23 +11395,23 @@ code = ''' // create and delete two ids in the other order rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11423,29 +11425,29 @@ code = ''' // create and delete three ids rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11459,31 +11461,31 @@ code = ''' // create and delete three ids in the other order rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11537,8 +11539,8 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[j % 6], 4)))) => 0; } @@ -11589,8 +11591,8 @@ code = ''' } lfs_size_t rbyd_weight_before = rbyd.weight; - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -11602,8 +11604,8 @@ code = ''' &data) => LFS_ERR_NOENT; // try resuming from all tags being removed - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; assert(rbyd.weight == 1); @@ -11686,14 +11688,14 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[j % 6], 4)))) => 0; - // note uattrs have a smaller size to help debugging + // note urattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF(names[j % 6], 2)))) => 0; } @@ -11745,8 +11747,8 @@ code = ''' } lfs_size_t rbyd_weight_before = rbyd.weight; - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -11758,13 +11760,13 @@ code = ''' &data) => LFS_ERR_NOENT; // try resuming from all tags being removed - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u+1), 0, LFSR_DATA_BUF("\xaa\xaa\xaa", 3)))) => 0; } @@ -11879,8 +11881,8 @@ code = ''' sim[rid] = 'a'+(i % 26); count += 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else { @@ -11888,8 +11890,8 @@ code = ''' memmove(sim+rid, sim+rid+1, count-rid-1); count -= 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } } @@ -11953,8 +11955,8 @@ code = ''' // make id0 with weight w1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -11974,8 +11976,8 @@ code = ''' assert(lfsr_data_size(data_) == 4); // make id2 with weight w2 - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +2, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -12007,8 +12009,8 @@ code = ''' assert(lfsr_data_size(data_) == 4); // make id5 with weight w3 - lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +3, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; @@ -12052,8 +12054,8 @@ code = ''' assert(lfsr_data_size(data_) == 4); // make id9 with weight w4 - lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +4, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; @@ -12109,8 +12111,8 @@ code = ''' assert(lfsr_data_size(data_) == 4); // make id14 with weight w5 - lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +5, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; @@ -12199,25 +12201,25 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( // make id0 with weight w1 - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), // make id2 with weight w2 - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +2, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), // make id5 with weight w3 - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +3, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), // make id9 with weight w4 - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +4, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), // make id14 with weight w5 - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +5, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; @@ -12357,8 +12359,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +W, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -12447,8 +12449,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +W, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -12498,17 +12500,17 @@ code = ''' // make id0 with weight w1 rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("unrelated", 9)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; @@ -12564,17 +12566,17 @@ code = ''' assert(lfsr_data_size(data_) == 2); // make id2 with weight w2 - lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +1, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; @@ -12666,17 +12668,17 @@ code = ''' assert(lfsr_data_size(data_) == 2); // make id5 with weight w3 - lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +2, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; @@ -12804,17 +12806,17 @@ code = ''' assert(lfsr_data_size(data_) == 2); // make id9 with weight w4 - lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xdd\xdd", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +3, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xdd\xdd", 2)))) => 0; @@ -12978,17 +12980,17 @@ code = ''' assert(lfsr_data_size(data_) == 2); // make id14 with weight w5 - lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +4, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; @@ -13209,70 +13211,70 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("unrelated", 9)), // make id0 with weight w1 - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xaa\xaa", 2)), // make id2 with weight w2 - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +1, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xbb\xbb", 2)), // make id5 with weight w3 - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +2, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xcc\xcc", 2)), // make id9 with weight w4 - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xdd\xdd", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +3, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xdd\xdd", 2)), // make id14 with weight w5 - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +4, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xee\xee", 2)))) => 0; @@ -13535,8 +13537,8 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("unrelated", 9)))) => 0; @@ -13549,17 +13551,17 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +W-1, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -13657,8 +13659,8 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("unrelated", 9)))) => 0; @@ -13671,17 +13673,17 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_GROW, +W-1, LFSR_DATA_NULL()), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -13798,8 +13800,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +W, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -13824,8 +13826,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_GROW, +D, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_GROW, +D, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -13930,8 +13932,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +W, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -13956,8 +13958,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_GROW | LFSR_TAG_REG, +D, LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W+D); @@ -14074,8 +14076,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), +W, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -14100,8 +14102,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_GROW | LFSR_TAG_ATTR(1), +D, LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W+D); @@ -14231,8 +14233,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +W, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -14257,8 +14259,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_GROW, -D, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_GROW, -D, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N*W-D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14363,8 +14365,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +W, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -14389,8 +14391,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_GROW | LFSR_TAG_REG, -D, LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W-D); @@ -14507,8 +14509,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(2), +W, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -14533,8 +14535,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_GROW | LFSR_TAG_ATTR(1), -D, LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W-D); @@ -14663,8 +14665,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +W, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -14689,8 +14691,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == (N-1)*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14723,8 +14725,8 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, j*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +W, LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W); @@ -14760,7 +14762,7 @@ code = ''' } ''' -[cases.test_rbyd_sparse_attr_permutations] +[cases.test_rbyd_sparse_rattr_permutations] defines.N = 'range(1, 7)' defines.W = 5 # PERMUTATION=-1 => exhaust all permutations @@ -14827,8 +14829,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +W, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -14840,7 +14842,7 @@ code = ''' CFG->read(CFG, rbyd.blocks[0], 0, backup_block, lfsr_rbyd_eoff(&rbyd)) => 0; - // try appending an attr to each rid, this should not affect + // try appending an rattr 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 @@ -14854,8 +14856,8 @@ code = ''' lfsr_bd_flush(&lfs, NULL, false) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(names[j % 6], 2)))) => 0; assert(rbyd.weight == N*W); @@ -14885,10 +14887,10 @@ code = ''' } } - // now try removing the attr + // now try removing the rattr printf("--- removing: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N*W); @@ -14913,10 +14915,10 @@ code = ''' } } - // and try putting the attr back just for good measure + // and try putting the rattr back just for good measure printf("--- appending: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(names[j % 6], 2)))) => 0; assert(rbyd.weight == N*W); @@ -14979,11 +14981,11 @@ code = ''' uint32_t prng = SEED; lfs_size_t count = 0; for (unsigned i = 0; i < N; i++) { - // choose create/delete or attr append/remove + // choose create/delete or rattr append/remove uint8_t op = TEST_PRNG(&prng) % 4; // choose an rid lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); - // choose an attr + // choose an rattr uint8_t u = TEST_PRNG(&prng) % M; if (rid == (lfs_ssize_t)count || op == 0) { @@ -15015,11 +15017,11 @@ code = ''' prng = SEED; count = 0; for (unsigned i = 0; i < N; i++) { - // choose create/delete or attr append/remove + // choose create/delete or rattr append/remove uint8_t op = TEST_PRNG(&prng) % 4; // choose an rid lfs_ssize_t rid = TEST_PRNG(&prng) % (count+1); - // choose an attr + // choose an rattr uint8_t u = TEST_PRNG(&prng) % M; if (rid == (lfs_ssize_t)count || op == 0) { @@ -15029,8 +15031,8 @@ code = ''' sim[rid*(M+1)] = 'a'+(i % 26); count += 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else if (op == 1) { @@ -15038,14 +15040,14 @@ code = ''' 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, rid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } else if (op == 2) { // update our sim sim[rid*(M+1) + u+1] = 'a'+(i % 26); // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(u), 0, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; @@ -15053,8 +15055,8 @@ code = ''' // update our sim sim[rid*(M+1) + u+1] = '\0'; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(u), 0, LFSR_DATA_NULL()))) => 0; } @@ -15204,8 +15206,8 @@ code = ''' sim_weights[rid] = weight; count += 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +weight, LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else if (op == 1) { @@ -15217,16 +15219,16 @@ code = ''' (count-rid-1)*sizeof(lfs_size_t)); count -= 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()))) => 0; } else if (op == 2) { // get the correct weight from the sim weight_ = sim_weights[rid]; // update our sim sim_weights[rid] += weight; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_GROW, +weight, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_GROW, +weight, LFSR_DATA_NULL()))) => 0; } else if (op == 3) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -15236,8 +15238,8 @@ code = ''' // update our sim sim_weights[rid] -= weight; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_GROW, -weight, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_GROW, -weight, LFSR_DATA_NULL()))) => 0; } } @@ -15367,18 +15369,18 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); - // test that we can lookup each attr with a wide lookup + // test that we can lookup each rattr with a wide lookup lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); @@ -15457,12 +15459,12 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -15488,8 +15490,8 @@ code = ''' NULL, false) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0, LFSR_DATA_NULL()))) => 0; @@ -15601,12 +15603,12 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -15632,8 +15634,8 @@ code = ''' NULL, false) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, LFSR_DATA_BUF(names[j % 6], 3)))) => 0; @@ -15747,21 +15749,21 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(0x80), 0, LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; } assert(rbyd.weight == N); - // test that we can lookup each attr with a wide lookup + // test that we can lookup each rattr with a wide lookup lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); @@ -15840,15 +15842,15 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(0x80), 0, LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; } @@ -15874,8 +15876,8 @@ code = ''' NULL, false) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0, LFSR_DATA_NULL()))) => 0; @@ -15994,15 +15996,15 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(0x80), 0, LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; } @@ -16028,8 +16030,8 @@ code = ''' NULL, false) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, LFSR_DATA_BUF(names[j % 6], 3)))) => 0; @@ -16150,15 +16152,15 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); - // test that we can lookup each attr with a wide lookup + // test that we can lookup each rattr with a wide lookup lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); @@ -16237,9 +16239,9 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -16265,8 +16267,8 @@ code = ''' NULL, false) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0, LFSR_DATA_NULL()))) => 0; @@ -16381,9 +16383,9 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } @@ -16409,8 +16411,8 @@ code = ''' NULL, false) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, LFSR_DATA_BUF(names[j % 6], 6)))) => 0; @@ -16518,18 +16520,18 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); - // a supwide attr lookup only gets the file type + // a supwide rattr lookup only gets the file type lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); @@ -16608,12 +16610,12 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -16639,8 +16641,8 @@ code = ''' NULL, false) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_SUP | LFSR_TAG_ATTR, 0, LFSR_DATA_NULL()))) => 0; @@ -16752,12 +16754,12 @@ code = ''' } } - // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR( + // give each rattr a subtype based on its rid + SHIFT + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } @@ -16783,8 +16785,8 @@ code = ''' NULL, false) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUP | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, LFSR_DATA_BUF(names[j % 6], 3)))) => 0; @@ -16866,14 +16868,14 @@ code = ''' // create a null tag hole rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(0), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); @@ -16915,24 +16917,24 @@ code = ''' // create a null tag hole rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(0), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); // remove a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); @@ -16974,25 +16976,25 @@ code = ''' // create a null tag hole rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(0), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); // delete a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( + LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); // can we still access things? @@ -17032,24 +17034,24 @@ code = ''' // create a null tag hole rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(0x00), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(0x01), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(0x80), 0, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); // subwide replace a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUB | LFSR_TAG_ATTR(0x02), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 0); @@ -17100,25 +17102,25 @@ code = ''' // create a null tag hole rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_ATTR(0), 0, LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR( + LFSR_RATTR( LFSR_TAG_REG, +1, LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); // supwide replace a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( + LFSR_RATTR( LFSR_TAG_SUP | LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 1);