From cd22c0d68b9ebadf273df856f61db368a2af8462 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Fri, 10 May 2024 15:43:08 -0500 Subject: [PATCH] Aggressively cleaned up/reworked lfsr_attr_t, consumed lfsr_cat_t This turned into a sort of system-wide refactor based on learned knowledge of what we can do with lfsr_attr_t. The big changes: - Reverted LFSR_ATTR to mainly take lfsr_data_t again, keeping lfsr_data_t as the default data representation in the codebase. Now that we know LFSR_ATTR_CAT_ still provides concatenation mechanics, and LFSR_ATTR_ provides a way to edit in-flight lfsr_attr_ts. - Dropped lfsr_cat_t, replaced with explicit const void* + uint16_t, tried to limit to low-level operations and prefer passing aroud lfsr_attr_t and lfsr_data_t at a high-level. Note this cat + cat_count pair is quite similar to the common attrs + attr_count and buffer + size arguments. - Adopted lfsr_attr_t more in mid-level functions, lfsr_rbyd_appendattr, lfsr_rbyd_appendcompactattr, lfsr_file_carve, etc. This is a bit more ergonomical, allows for use of LFSR_ATTR* macros, and in theory might even save a bit of stack. Unfortunately this seems to have resulted in a net hit to code cost, though I still think it's worth it for the internal ergonomics: code stack before: 33652 2624 after: 33780 (+0.4%) 2640 (+0.4%) Investigating further suggests this may just be the result of compiler noise and changes to argument placement. lfsr_attr_t does touch a lot of code... It's interesting to note the adoption of lfsr_attr_t in lfsr_rbyd_appendattr* and friends prevents their transformation into .isra functions, though this doesn't seem to impact code cost too much: function (5 added, 5 removed) osize nsize dsize lfsr_cat_size - 48 +48 (+100.0%) lfsr_file_carve - 1600 +1600 (+100.0%) lfsr_rbyd_appendattr - 2120 +2120 (+100.0%) lfsr_rbyd_appendattr_ - 244 +244 (+100.0%) lfsr_rbyd_appendcompactattr - 68 +68 (+100.0%) lfsr_rbyd_appendcompactrbyd 144 152 +8 (+5.6%) lfsr_file_truncate 298 314 +16 (+5.4%) lfsr_mdir_commit__ 1056 1112 +56 (+5.3%) lfsr_mdir_compact__ 502 526 +24 (+4.8%) lfsr_rbyd_appendattrs 132 138 +6 (+4.5%) lfsr_file_fruncate 386 402 +16 (+4.1%) lfsr_data_frombtree 84 86 +2 (+2.4%) lfsr_rbyd_appendcksum 512 520 +8 (+1.6%) lfsr_file_opencfg 572 580 +8 (+1.4%) lfsr_rename 608 616 +8 (+1.3%) lfsr_mkdir 500 504 +4 (+0.8%) lfsr_bd_prog 278 280 +2 (+0.7%) lfsr_mdir_commit 2364 2360 -4 (-0.2%) lfsr_bshrub_commit 716 712 -4 (-0.6%) lfsr_file_sync 526 514 -12 (-2.3%) lfsr_file_flush_ 1868 1820 -48 (-2.6%) lfsr_remove 456 436 -20 (-4.4%) lfsr_fs_fixgrm 168 160 -8 (-4.8%) lfsr_cat_size.isra.0 42 - -42 (-100.0%) lfsr_file_carve.isra.0 1596 - -1596 (-100.0%) lfsr_rbyd_appendattr.isra.0 2088 - -2088 (-100.0%) lfsr_rbyd_appendattr_.isra.0 232 - -232 (-100.0%) lfsr_rbyd_appendcompactattr.isra.0 56 - -56 (-100.0%) TOTAL 33652 33780 +128 (+0.4%) --- lfs.c | 828 ++++++++++---------- tests/test_btree.toml | 394 +++++----- tests/test_mtree.toml | 248 +++--- tests/test_rbyd.toml | 1660 ++++++++++++++++++++--------------------- 4 files changed, 1544 insertions(+), 1586 deletions(-) diff --git a/lfs.c b/lfs.c index 71f7c48a..087881c3 100644 --- a/lfs.c +++ b/lfs.c @@ -1409,98 +1409,16 @@ static int lfsr_bd_progdata(lfs_t *lfs, return 0; } +// we can also treat leb128/lleb128 encoding has a high-level operation, +// which is useful for building attrs -// concatenated data - -typedef struct lfsr_cat { - // sign(size)=0 => single in-RAM buffer - // sign(size)=1 => multiple concatenated datas - uint16_t size; - union { - const uint8_t *buffer; - const lfsr_data_t *datas; - } u; -} lfsr_cat_t; - -#define LFSR_CAT_ISCAT 0x8000 - -#define LFSR_CAT_NULL() \ - ((lfsr_cat_t){ \ - .size=0, \ - .u.buffer=NULL}) - -#define LFSR_CAT_BUF(_buffer, _size) \ - ((lfsr_cat_t){ \ - .size=_size, \ - .u.buffer=(const void*)(_buffer)}) - -#define LFSR_CAT_DATA_(_data) \ - ((lfsr_cat_t){ \ - .size=LFSR_CAT_ISCAT | 1, \ - .u.datas=_data}) - -#define LFSR_CAT_DATA(_data) \ - LFSR_CAT_DATA_((const lfsr_data_t[1]){_data}) - -#define LFSR_CAT_DATAS_(_datas, _count) \ - ((lfsr_cat_t){ \ - .size=LFSR_CAT_ISCAT | (_count), \ - .u.datas=_datas}) - -#define LFSR_CAT_DATAS(...) \ - LFSR_CAT_DATAS_( \ - (const lfsr_data_t[]){__VA_ARGS__}, \ - sizeof((const lfsr_data_t[]){__VA_ARGS__}) / sizeof(lfsr_data_t)) - -// data can be converted straight to a cat sometimes -static inline lfsr_cat_t lfsr_data_cat(lfsr_data_t data) { - // only simple data can be converted directly to cats - LFS_ASSERT(lfsr_data_isbuf(data)); - LFS_ASSERT(lfsr_data_size(data) <= 0x7fff); - return (lfsr_cat_t){ - .size=data.size, - .u.buffer=data.u.buffer}; -} - -// cat helpers -static inline bool lfsr_cat_isbuf(lfsr_cat_t cat) { - return !(cat.size & LFSR_CAT_ISCAT); -} - -static inline bool lfsr_cat_iscat(lfsr_cat_t cat) { - return cat.size & LFSR_CAT_ISCAT; -} - -static inline lfs_size_t lfsr_cat_count(lfsr_cat_t cat) { - LFS_ASSERT(lfsr_cat_iscat(cat)); - return cat.size & ~LFSR_CAT_ISCAT; -} - -static inline lfs_size_t lfsr_cat_size(lfsr_cat_t cat) { - // this gets a bit complicated for concatenated data - if (lfsr_cat_isbuf(cat)) { - return cat.size; - } else { - lfs_size_t count = lfsr_cat_count(cat); - lfs_size_t size = 0; - for (lfs_size_t i = 0; i < count; i++) { - size += lfsr_data_size(cat.u.datas[i]); - } - return size; - } -} - -// some more cats #define LFSR_LEB128_DSIZE 5 -#define LFSR_LLEB128_DSIZE 4 -#define LFSR_CAT_LEB128(_word) \ - lfsr_data_cat(*(lfsr_data_t[1]){ \ - lfsr_data_fromleb128(_word, (uint8_t[LFSR_LEB128_DSIZE]){0})}) +#define LFSR_DATA_LEB128_(_word, _buffer) \ + lfsr_data_fromleb128(_word, _buffer) -#define LFSR_CAT_LLEB128(_word) \ - lfsr_data_cat(*(lfsr_data_t[1]){ \ - lfsr_data_fromlleb128(_word, (uint8_t[LFSR_LLEB128_DSIZE]){0})}) +#define LFSR_DATA_LEB128(_word) \ + LFSR_DATA_LEB128_(_word, (uint8_t[LFSR_LEB128_DSIZE]){0}) static inline lfsr_data_t lfsr_data_fromleb128(uint32_t word, uint8_t buffer[static LFSR_LEB128_DSIZE]) { @@ -1512,6 +1430,14 @@ static inline lfsr_data_t lfsr_data_fromleb128(uint32_t word, return LFSR_DATA_BUF(buffer, d); } +#define LFSR_LLEB128_DSIZE 4 + +#define LFSR_DATA_LLEB128_(_word, _buffer) \ + lfsr_data_fromlleb128(_word, _buffer) + +#define LFSR_DATA_LLEB128(_word) \ + LFSR_DATA_LLEB128_(_word, (uint8_t[LFSR_LLEB128_DSIZE]){0}) + static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, uint8_t buffer[static LFSR_LLEB128_DSIZE]) { // little-leb128s should not exceed 28-bits @@ -1522,124 +1448,131 @@ static inline lfsr_data_t lfsr_data_fromlleb128(uint32_t word, return LFSR_DATA_BUF(buffer, d); } -// a bit hacky, but we really don't need the last word in our name's -// lfsr_data_t -typedef struct lfsr_data_name { - lfsr_data_t did_data; - lfs_size_t name_size; - const uint8_t *name; -} lfsr_data_name_t; - -#define LFSR_CAT_NAME(_did, _name, _name_size) \ - LFSR_CAT_DATAS_( \ - ((lfsr_data_t*)&(lfsr_data_name_t){ \ - .did_data=lfsr_data_fromleb128( \ - _did, (uint8_t[LFSR_LEB128_DSIZE]){0}), \ - .name_size=_name_size, \ - .name=(const void*)(_name)}), \ - 2) - -// cat <-> bd interactions -// -// these are simpler than data interactions because we only ever prog -// concatenated data - -static int lfsr_bd_progcat(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfsr_cat_t cat, - uint32_t *cksum_) { - // direct buffer? - if (lfsr_cat_isbuf(cat)) { - return lfsr_bd_prog(lfs, block, off, cat.u.buffer, cat.size, - cksum_); - - // indirect concatenated data? - } else { - lfs_size_t count = lfsr_cat_count(cat); - for (lfs_size_t i = 0; i < count; i++) { - int err = lfsr_bd_progdata(lfs, block, off, cat.u.datas[i], - cksum_); - if (err) { - return err; - } - - off += lfsr_data_size(cat.u.datas[i]); - } - return 0; - } -} - // operations on attribute lists typedef struct lfsr_attr { lfsr_tag_t tag; - uint16_t size; + uint16_t cat_count; lfsr_srid_t delta; // sign(size)=0 => single in-RAM buffer // sign(size)=1 => multiple concatenated datas - union { - const uint8_t *buffer; - const lfsr_data_t *datas; - } u; + // special tags => other things + const void *cat; } lfsr_attr_t; -#define LFSR_ATTR(_tag, _delta, _cat) \ - lfsr_attr(_tag, _delta, _cat) +// cat can either be a simple in-RAM buffer or concatenated datas +#define LFSR_CAT_ISCAT 0x8000 + +#define LFSR_ATTR_(_tag, _delta, _cat, _cat_count) \ + ((lfsr_attr_t){ \ + .tag=_tag, \ + .cat_count=_cat_count, \ + .delta=_delta, \ + .cat=_cat}) + +#define LFSR_ATTR(_tag, _delta, _data) \ + lfsr_attr(_tag, _delta, *(lfsr_data_t[1]){_data}) static inline lfsr_attr_t lfsr_attr( - lfsr_tag_t tag, lfsr_srid_t delta, lfsr_cat_t cat) { + lfsr_tag_t tag, lfsr_srid_t delta, 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){ .tag=tag, - .size=cat.size, + .cat_count=lfsr_data_size(data), .delta=delta, - .u.datas=cat.u.datas}; + .cat=data.u.buffer}; } +#define LFSR_ATTR_CAT_(_tag, _delta, _datas, _data_count) \ + ((lfsr_attr_t){ \ + .tag=_tag, \ + .cat_count=LFSR_CAT_ISCAT | (_data_count), \ + .delta=_delta, \ + .cat=_datas}) + +#define LFSR_ATTR_CAT(_tag, _delta, ...) \ + LFSR_ATTR_CAT_( \ + _tag, \ + _delta, \ + (const lfsr_data_t[]){__VA_ARGS__}, \ + sizeof((const lfsr_data_t[]){__VA_ARGS__}) / sizeof(lfsr_data_t)) + #define LFSR_ATTR_NOOP() \ - ((const lfsr_attr_t){LFSR_TAG_NULL, 0, LFSR_CAT_NULL()}) + LFSR_ATTR_(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) -// attr hacks - sometimes we want to marshal something that isn't really data +// cat helpers +static inline bool lfsr_cat_isbuf(const void *cat, uint16_t cat_count) { + (void)cat; + return !(cat_count & LFSR_CAT_ISCAT); +} -// a move of all attrs from an mdir entry -#define LFSR_ATTR_MOVE(_tag, _delta, _mdir) \ - ((const lfsr_attr_t){ \ - .tag=_tag, \ - .delta=_delta, \ - .u.buffer=(const void*)(const lfsr_mdir_t*){_mdir}}) +static inline bool lfsr_cat_iscat(const void *cat, uint16_t cat_count) { + (void)cat; + return cat_count & LFSR_CAT_ISCAT; +} -// a grm update, note this is mutable! we may update the grm during -// mdir commits -#define LFSR_ATTR_GRM(_tag, _delta, _grm) \ - ((const lfsr_attr_t){ \ - .tag=_tag, \ - .delta=_delta, \ - .u.buffer=(const void*)(const lfsr_grm_t*){_grm}}) +static inline lfs_size_t lfsr_cat_size_(const void *cat, uint16_t cat_count) { + LFS_ASSERT(lfsr_cat_isbuf(cat, cat_count)); + return cat_count; +} -// writing to an unrelated trunk in the rbyd -typedef struct lfsr_shrubcommit lfsr_shrubcommit_t; -#define LFSR_ATTR_SHRUBCOMMIT(_tag, _delta, \ - _shrub, _rid, _attrs, _attr_count) \ - ((const lfsr_attr_t){ \ - .tag=_tag, \ - .delta=_delta, \ - .u.buffer=(const void*)&(const lfsr_shrubcommit_t){ \ - .shrub=_shrub, \ - .rid=_rid, \ - .attrs=_attrs, \ - .attr_count=_attr_count}}) +static inline lfs_size_t lfsr_cat_count(const void *cat, uint16_t cat_count) { + LFS_ASSERT(lfsr_cat_iscat(cat, cat_count)); + return cat_count & ~LFSR_CAT_ISCAT; +} -#define LFSR_ATTR_SHRUBTRUNK(_tag, _delta, _shrub) \ - ((const lfsr_attr_t){ \ - .tag=_tag, \ - .delta=_delta, \ - .u.buffer=(const void*)(const lfsr_shrub_t*){_shrub}}) +static inline lfs_size_t lfsr_cat_size(const void *cat, uint16_t cat_count) { + // this gets a bit complicated for concatenated data + if (lfsr_cat_isbuf(cat, cat_count)) { + return cat_count; -// some helpers + } else { + const lfsr_data_t *datas = cat; + lfs_size_t data_count = lfsr_cat_count(cat, cat_count); + lfs_size_t size = 0; + for (lfs_size_t i = 0; i < data_count; i++) { + size += lfsr_data_size(datas[i]); + } + return size; + } +} + +// cat <-> bd interactions +static int lfsr_bd_progcat(lfs_t *lfs, + lfs_block_t block, lfs_size_t off, + const void *cat, uint16_t cat_count, + uint32_t *cksum_) { + // direct buffer? + if (lfsr_cat_isbuf(cat, cat_count)) { + return lfsr_bd_prog(lfs, block, off, cat, cat_count, + cksum_); + + // indirect concatenated data? + } else { + const lfsr_data_t *datas = cat; + lfs_size_t data_count = lfsr_cat_count(cat, cat_count); + for (lfs_size_t i = 0; i < data_count; i++) { + int err = lfsr_bd_progdata(lfs, block, off, datas[i], + cksum_); + if (err) { + return err; + } + + off += lfsr_data_size(datas[i]); + } + return 0; + } +} + +// other attr helpers static inline bool lfsr_attr_isnoop(lfsr_attr_t attr) { return !attr.tag && attr.delta == 0; } @@ -1648,32 +1581,56 @@ static inline bool lfsr_attr_isinsert(lfsr_attr_t attr) { return !lfsr_tag_isgrow(attr.tag) && attr.delta > 0; } -static inline lfsr_cat_t lfsr_attr_cat(lfsr_attr_t attr) { - return (lfsr_cat_t){ - .size=attr.size, - .u.datas=attr.u.datas}; -} - static inline lfs_size_t lfsr_attr_size(lfsr_attr_t attr) { - return lfsr_cat_size(lfsr_attr_cat(attr)); + return lfsr_cat_size(attr.cat, attr.cat_count); } -static inline lfsr_grm_t *lfsr_attr_grm(lfsr_attr_t attr) { - return (lfsr_grm_t*)attr.u.buffer; -} +// special attrs - here be hacks -static inline const lfsr_mdir_t *lfsr_attr_mdir(lfsr_attr_t attr) { - return (lfsr_mdir_t*)attr.u.buffer; -} +// special case for passing names, we need to cat but we don't need the +// full lfsr_data_t +typedef struct lfsr_data_name { + lfsr_data_t did_data; + lfs_size_t name_size; + const uint8_t *name; +} lfsr_data_name_t; -static inline const lfsr_shrubcommit_t *lfsr_attr_shrubcommit( - lfsr_attr_t attr) { - return (const lfsr_shrubcommit_t*)attr.u.buffer; -} +#define LFSR_ATTR_NAME(_tag, _delta, _did, _name, _name_size) \ + LFSR_ATTR_CAT_( \ + _tag, \ + _delta, \ + ((lfsr_data_t*)&(lfsr_data_name_t){ \ + .did_data=LFSR_DATA_LEB128(_did), \ + .name_size=_name_size, \ + .name=(const void*)(_name)}), \ + 2) -static inline const lfsr_shrub_t *lfsr_attr_shrubtrunk(lfsr_attr_t attr) { - return (const lfsr_shrub_t*)attr.u.buffer; -} +// hacky attrs - these end up handled as special cases in high-level +// commit layers + +// a move of all attrs from an mdir entry +#define LFSR_ATTR_MOVE(_tag, _delta, _mdir) \ + LFSR_ATTR_(_tag, _delta, (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, _delta, _grm) \ + LFSR_ATTR_(_tag, _delta, (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, _delta, \ + _shrub, _rid, _attrs, _attr_count) \ + LFSR_ATTR_(_tag, _delta, \ + (&(const lfsr_shrubcommit_t){ \ + .shrub=_shrub, \ + .rid=_rid, \ + .attrs=_attrs, \ + .attr_count=_attr_count}), \ + 0) + +#define LFSR_ATTR_SHRUBTRUNK(_tag, _delta, _shrub) \ + LFSR_ATTR_(_tag, _delta, (const lfsr_shrub_t*){_shrub}, 0) @@ -1818,11 +1775,11 @@ typedef struct lfsr_ecksum { // #define LFSR_ECKSUM_DSIZE (4+4) -#define LFSR_CAT_ECKSUM_(_ecksum, _buffer) \ - lfsr_data_cat(*(lfsr_data_t[1]){lfsr_data_fromecksum(_ecksum, _buffer)}) +#define LFSR_DATA_ECKSUM_(_ecksum, _buffer) \ + lfsr_data_fromecksum(_ecksum, _buffer) -#define LFSR_CAT_ECKSUM(_ecksum) \ - LFSR_CAT_ECKSUM_(_ecksum, (uint8_t[LFSR_ECKSUM_DSIZE]){0}) +#define LFSR_DATA_ECKSUM(_ecksum) \ + LFSR_DATA_ECKSUM_(_ecksum, (uint8_t[LFSR_ECKSUM_DSIZE]){0}) static lfsr_data_t lfsr_data_fromecksum(const lfsr_ecksum_t *ecksum, uint8_t buffer[static LFSR_ECKSUM_DSIZE]) { @@ -1875,11 +1832,11 @@ static int lfsr_data_readecksum(lfs_t *lfs, lfsr_data_t *data, // #define LFSR_BPTR_DSIZE (4+5+4+4+4) -#define LFSR_CAT_BPTR_(_bptr, _buffer) \ - lfsr_data_cat(*(lfsr_data_t[1]){lfsr_data_frombptr(_bptr, _buffer)}) +#define LFSR_DATA_BPTR_(_bptr, _buffer) \ + lfsr_data_frombptr(_bptr, _buffer) -#define LFSR_CAT_BPTR(_bptr) \ - LFSR_CAT_BPTR_(_bptr, (uint8_t[LFSR_BPTR_DSIZE]){0}) +#define LFSR_DATA_BPTR(_bptr) \ + LFSR_DATA_BPTR_(_bptr, (uint8_t[LFSR_BPTR_DSIZE]){0}) static lfsr_data_t lfsr_data_frombptr(const lfsr_bptr_t *bptr, uint8_t buffer[static LFSR_BPTR_DSIZE]) { @@ -2087,11 +2044,11 @@ static inline bool lfsr_grm_isrm(const lfsr_grm_t *grm, lfsr_smid_t mid) { return grm->rms[0] == mid || grm->rms[1] == mid; } -#define LFSR_CAT_GRM_(_grm, _buffer) \ - lfsr_data_cat(*(lfsr_data_t[1]){lfsr_data_fromgrm(_grm, _buffer)}) +#define LFSR_DATA_GRM_(_grm, _buffer) \ + lfsr_data_fromgrm(_grm, _buffer) -#define LFSR_CAT_GRM(_grm) \ - LFSR_CAT_GRM_(_grm, (uint8_t[LFSR_GRM_DSIZE]){0}) +#define LFSR_DATA_GRM(_grm) \ + LFSR_DATA_GRM_(_grm, (uint8_t[LFSR_GRM_DSIZE]){0}) static lfsr_data_t lfsr_data_fromgrm(const lfsr_grm_t *grm, uint8_t buffer[static LFSR_GRM_DSIZE]) { @@ -2731,10 +2688,10 @@ static int lfsr_rbyd_appendtag(lfs_t *lfs, lfsr_rbyd_t *rbyd, } static int lfsr_rbyd_appendcat(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_cat_t cat) { + const void *cat, uint16_t cat_count) { uint32_t cksum_ = rbyd->cksum; int err = lfsr_bd_progcat(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), - cat, + cat, cat_count, &cksum_); if (err) { return err; @@ -2744,20 +2701,20 @@ static int lfsr_rbyd_appendcat(lfs_t *lfs, lfsr_rbyd_t *rbyd, rbyd->eoff += ((lfs_size_t)lfs_parity(rbyd->cksum ^ cksum_) << (8*sizeof(lfs_size_t)-1)) - + lfsr_cat_size(cat); + + lfsr_cat_size(cat, cat_count); rbyd->cksum = cksum_; return 0; } static int lfsr_rbyd_appendattr_(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_tag_t tag, lfsr_rid_t weight, lfsr_cat_t cat) { + lfsr_attr_t attr) { int err = lfsr_rbyd_appendtag(lfs, rbyd, - tag, weight, lfsr_cat_size(cat)); + attr.tag, attr.delta, lfsr_attr_size(attr)); if (err) { return err; } - err = lfsr_rbyd_appendcat(lfs, rbyd, cat); + err = lfsr_rbyd_appendcat(lfs, rbyd, attr.cat, attr.cat_count); if (err) { return err; } @@ -2887,19 +2844,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_tag_t tag, lfsr_srid_t delta, lfsr_cat_t cat) { + lfsr_srid_t rid, lfsr_attr_t attr) { // must fetch before mutating! LFS_ASSERT(lfsr_rbyd_isfetched(rbyd)); // tag must not be internal at this point - LFS_ASSERT(!lfsr_tag_isinternal(tag)); + LFS_ASSERT(!lfsr_tag_isinternal(attr.tag)); // bit 7 is reserved for future subtype extensions - LFS_ASSERT(!(tag & 0x80)); + LFS_ASSERT(!(attr.tag & 0x80)); // you can't delete more than what's in the rbyd - LFS_ASSERT(delta >= -(lfsr_srid_t)rbyd->weight); + LFS_ASSERT(attr.delta >= -(lfsr_srid_t)rbyd->weight); // ignore noops - if (!tag) { - LFS_ASSERT(delta == 0); + if (!attr.tag) { + LFS_ASSERT(attr.delta == 0); return 0; } @@ -2914,8 +2871,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(tag) && delta != 0) { - if (delta > 0) { + if (!lfsr_tag_isgrow(attr.tag) && attr.delta != 0) { + if (attr.delta > 0) { LFS_ASSERT(rid <= (lfsr_srid_t)rbyd->weight); // it's a bit ugly, but adjusting the rid here makes the following @@ -2929,7 +2886,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_smax32(-delta, 0); + a_rid = rid - lfs_smax32(-attr.delta, 0); b_rid = rid; } @@ -2939,23 +2896,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_smax32(-delta, 0); + a_rid = rid - lfs_smax32(-attr.delta, 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(tag)) { + if (lfsr_tag_issup(attr.tag)) { a_tag = 0x000; b_tag = 0xf00; - } else if (lfsr_tag_issub(tag)) { - a_tag = lfsr_tag_supkey(tag); - b_tag = lfsr_tag_supkey(tag) + 0x100; - } else if (lfsr_tag_isrm(tag)) { - a_tag = lfsr_tag_key(tag); - b_tag = lfsr_tag_key(tag) + 1; + } 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 { - a_tag = lfsr_tag_key(tag); - b_tag = lfsr_tag_key(tag); + a_tag = lfsr_tag_key(attr.tag); + b_tag = lfsr_tag_key(attr.tag); } } a_tag = lfs_max16(a_tag, 0x1); @@ -3344,11 +3301,11 @@ trunk:; } // terminate diverged trunk with an unreachable tag - err = lfsr_rbyd_appendattr_(lfs, rbyd, + err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR( (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | LFSR_TAG_NULL, 0, - LFSR_CAT_NULL()); + LFSR_DATA_NULL())); if (err) { return err; } @@ -3391,18 +3348,20 @@ stem:; lfsr_tag_t alt = 0; lfsr_rid_t weight = 0; if (tag_ - && (upper_rid-1 < rid-lfs_smax32(-delta, 0) - || (upper_rid-1 == rid-lfs_smax32(-delta, 0) - && ((!lfsr_tag_isgrow(tag) && delta > 0) - || (!lfsr_tag_issup(tag) - && lfsr_tag_supkey(tag_) < lfsr_tag_supkey(tag)) - || (!lfsr_tag_issup(tag) - && !lfsr_tag_issub(tag) - && lfsr_tag_key(tag_) < lfsr_tag_key(tag)))))) { - if (lfsr_tag_isrm(tag) || !lfsr_tag_key(tag)) { + && (upper_rid-1 < rid-lfs_smax32(-attr.delta, 0) + || (upper_rid-1 == rid-lfs_smax32(-attr.delta, 0) + && ((!lfsr_tag_isgrow(attr.tag) && attr.delta > 0) + || (!lfsr_tag_issup(attr.tag) + && lfsr_tag_supkey(tag_) + < lfsr_tag_supkey(attr.tag)) + || (!lfsr_tag_issup(attr.tag) + && !lfsr_tag_issub(attr.tag) + && lfsr_tag_key(tag_) + < lfsr_tag_key(attr.tag)))))) { + if (lfsr_tag_isrm(attr.tag) || !lfsr_tag_key(attr.tag)) { // if removed, make our tag unreachable alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, lower_tag); - weight = upper_rid - lower_rid + delta; + weight = upper_rid - lower_rid + attr.delta; upper_rid -= weight; } else { // split less than @@ -3414,20 +3373,22 @@ stem:; } else if (tag_ && (upper_rid-1 > rid || (upper_rid-1 == rid - && ((!lfsr_tag_isgrow(tag) && delta > 0) - || (!lfsr_tag_issup(tag) - && lfsr_tag_supkey(tag_) > lfsr_tag_supkey(tag)) - || (!lfsr_tag_issup(tag) - && !lfsr_tag_issub(tag) - && lfsr_tag_key(tag_) > lfsr_tag_key(tag)))))) { - if (lfsr_tag_isrm(tag) || !lfsr_tag_key(tag)) { + && ((!lfsr_tag_isgrow(attr.tag) && attr.delta > 0) + || (!lfsr_tag_issup(attr.tag) + && lfsr_tag_supkey(tag_) + > lfsr_tag_supkey(attr.tag)) + || (!lfsr_tag_issup(attr.tag) + && !lfsr_tag_issub(attr.tag) + && lfsr_tag_key(tag_) + > lfsr_tag_key(attr.tag)))))) { + if (lfsr_tag_isrm(attr.tag) || !lfsr_tag_key(attr.tag)) { // if removed, make our tag unreachable alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, lower_tag); - weight = upper_rid - lower_rid + delta; + weight = upper_rid - lower_rid + attr.delta; upper_rid -= weight; } else { // split greater than - alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, tag); + alt = LFSR_TAG_ALT(LFSR_TAG_B, LFSR_TAG_GT, attr.tag); weight = upper_rid - (rid+1); upper_rid -= weight; } @@ -3455,22 +3416,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, + err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR_( // 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(tag)) + | ((lfsr_tag_isrm(attr.tag)) ? LFSR_TAG_NULL - : lfsr_tag_key(tag)), - upper_rid - lower_rid + delta, - cat); + : lfsr_tag_key(attr.tag)), + upper_rid - lower_rid + attr.delta, + attr.cat, attr.cat_count)); if (err) { return err; } // update the trunk and weight rbyd->trunk = (rbyd->trunk & LFSR_RBYD_ISSHRUB) | trunk_; - rbyd->weight += delta; + rbyd->weight += attr.delta; return 0; } @@ -3538,8 +3499,8 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) { return err; } - err = lfsr_rbyd_appendattr_(lfs, rbyd, - LFSR_TAG_ECKSUM, 0, LFSR_CAT_ECKSUM(&ecksum)); + err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR( + LFSR_TAG_ECKSUM, 0, LFSR_DATA_ECKSUM(&ecksum))); if (err) { return err; } @@ -3627,7 +3588,7 @@ static int lfsr_rbyd_appendattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd, && (lfs_size_t)(rid + 1) <= (lfs_size_t)end_rid) { int err = lfsr_rbyd_appendattr(lfs, rbyd, rid - lfs_smax32(start_rid, 0), - attrs[i].tag, attrs[i].delta, lfsr_attr_cat(attrs[i])); + attrs[i]); if (err) { return err; } @@ -3757,7 +3718,7 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // // also note the direct use of weight instead of delta here static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, - lfsr_tag_t tag, lfsr_rid_t weight, lfsr_cat_t cat) { + lfsr_attr_t attr) { // begin appending int err = lfsr_rbyd_prepareappend(lfs, rbyd); if (err) { @@ -3765,10 +3726,10 @@ static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // write the tag - err = lfsr_rbyd_appendattr_(lfs, rbyd, - (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | tag, - weight, - cat); + err = lfsr_rbyd_appendattr_(lfs, rbyd, LFSR_ATTR_( + (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | attr.tag, + attr.delta, + attr.cat, attr.cat_count)); if (err) { return err; } @@ -3801,8 +3762,8 @@ static int lfsr_rbyd_appendcompactrbyd(lfs_t *lfs, lfsr_rbyd_t *rbyd_, } // write the tag - err = lfsr_rbyd_appendcompactattr(lfs, rbyd_, - tag, weight, LFSR_CAT_DATA_(&data)); + err = lfsr_rbyd_appendcompactattr(lfs, rbyd_, LFSR_ATTR_CAT_( + tag, weight, &data, 1)); if (err) { return err; } @@ -3985,12 +3946,12 @@ 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_, LFSR_GRM_DSIZE); - err = lfsr_rbyd_appendattr(lfs, rbyd, -1, + err = lfsr_rbyd_appendattr(lfs, rbyd, -1, LFSR_ATTR( // opportunistically remove this tag if delta is all zero (size == 0) ? LFSR_TAG_RM | LFSR_TAG_GRMDELTA : LFSR_TAG_GRMDELTA, 0, - LFSR_CAT_BUF(grm_, size)); + LFSR_DATA_BUF(grm_, size))); if (err) { return err; } @@ -4158,11 +4119,11 @@ static inline int lfsr_btree_cmp( // #define LFSR_BRANCH_DSIZE (5+4+4) -#define LFSR_CAT_BRANCH_(_branch, _buffer) \ - lfsr_data_cat(*(lfsr_data_t[1]){lfsr_data_frombranch(_branch, _buffer)}) +#define LFSR_DATA_BRANCH_(_branch, _buffer) \ + lfsr_data_frombranch(_branch, _buffer) -#define LFSR_CAT_BRANCH(_branch) \ - LFSR_CAT_BRANCH_(_branch, (uint8_t[LFSR_BRANCH_DSIZE]){0}) +#define LFSR_DATA_BRANCH(_branch) \ + LFSR_DATA_BRANCH_(_branch, (uint8_t[LFSR_BRANCH_DSIZE]){0}) static lfsr_data_t lfsr_data_frombranch(const lfsr_rbyd_t *branch, uint8_t buffer[static LFSR_BRANCH_DSIZE]) { @@ -4231,11 +4192,11 @@ static int lfsr_data_readbranch(lfs_t *lfs, lfsr_data_t *data, // #define LFSR_BTREE_DSIZE (5+LFSR_BRANCH_DSIZE) -#define LFSR_CAT_BTREE_(_btree, _buffer) \ - lfsr_data_cat(*(lfsr_data_t[1]){lfsr_data_frombtree(_btree, _buffer)}) +#define LFSR_DATA_BTREE_(_btree, _buffer) \ + lfsr_data_frombtree(_btree, _buffer) -#define LFSR_CAT_BTREE(_btree) \ - LFSR_CAT_BTREE_(_btree, (uint8_t[LFSR_BTREE_DSIZE]){0}) +#define LFSR_DATA_BTREE(_btree) \ + LFSR_DATA_BTREE_(_btree, (uint8_t[LFSR_BTREE_DSIZE]){0}) static lfsr_data_t lfsr_data_frombtree(const lfsr_btree_t *btree, uint8_t buffer[static LFSR_BTREE_DSIZE]) { @@ -4573,15 +4534,15 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, bid -= pid - (rbyd.weight-1); if (rbyd_.weight == 0) { scratch->attrs[attr_count++] = LFSR_ATTR( - LFSR_TAG_RM, -rbyd.weight, LFSR_CAT_NULL()); + LFSR_TAG_RM, -rbyd.weight, LFSR_DATA_NULL()); } else { scratch->attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_BRANCH, 0, - LFSR_CAT_BRANCH_(&rbyd_, scratch->buf)); + LFSR_DATA_BRANCH_(&rbyd_, scratch->buf)); if (rbyd_.weight != rbyd.weight) { scratch->attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_GROW, -rbyd.weight + rbyd_.weight, - LFSR_CAT_NULL()); + LFSR_DATA_NULL()); } } attrs = scratch->attrs; @@ -4844,41 +4805,41 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, if (!lfsr_rbyd_trunk(&parent)) { scratch->attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_BRANCH, +rbyd_.weight, - LFSR_CAT_BRANCH_( + LFSR_DATA_BRANCH_( &rbyd_, &scratch->buf[0*LFSR_BRANCH_DSIZE])); scratch->attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_BRANCH, +sibling.weight, - LFSR_CAT_BRANCH_( + LFSR_DATA_BRANCH_( &sibling, &scratch->buf[1*LFSR_BRANCH_DSIZE])); if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { - scratch->attrs[attr_count++] = LFSR_ATTR( + scratch->attrs[attr_count++] = LFSR_ATTR_CAT_( LFSR_TAG_NAME, 0, - LFSR_CAT_DATA_(&scratch->split_data)); + &scratch->split_data, 1); } // split root? } else { bid -= pid - (rbyd.weight-1); scratch->attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_BRANCH, 0, - LFSR_CAT_BRANCH_( + LFSR_DATA_BRANCH_( &rbyd_, &scratch->buf[0*LFSR_BRANCH_DSIZE])); if (rbyd_.weight != rbyd.weight) { scratch->attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_GROW, -rbyd.weight + rbyd_.weight, - LFSR_CAT_NULL()); + LFSR_DATA_NULL()); } scratch->attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_BRANCH, +sibling.weight, - LFSR_CAT_BRANCH_( + LFSR_DATA_BRANCH_( &sibling, &scratch->buf[1*LFSR_BRANCH_DSIZE])); if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { - scratch->attrs[attr_count++] = LFSR_ATTR( + scratch->attrs[attr_count++] = LFSR_ATTR_CAT_( LFSR_TAG_NAME, 0, - LFSR_CAT_DATA_(&scratch->split_data)); + &scratch->split_data, 1); } } attrs = scratch->attrs; @@ -4943,14 +4904,14 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, attr_count = 0; bid -= pid - (rbyd.weight-1); scratch->attrs[attr_count++] = LFSR_ATTR( - LFSR_TAG_RM, -sibling.weight, LFSR_CAT_NULL()); + LFSR_TAG_RM, -sibling.weight, LFSR_DATA_NULL()); scratch->attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_BRANCH, 0, - LFSR_CAT_BRANCH_(&rbyd_, scratch->buf)); + LFSR_DATA_BRANCH_(&rbyd_, scratch->buf)); if (rbyd_.weight != rbyd.weight) { scratch->attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_GROW, -rbyd.weight + rbyd_.weight, - LFSR_CAT_NULL()); + LFSR_DATA_NULL()); } attrs = scratch->attrs; @@ -5302,11 +5263,11 @@ static inline int lfsr_shrub_cmp( // #define LFSR_SHRUB_DSIZE (5+4) -#define LFSR_CAT_SHRUB_(_rbyd, _buffer) \ - lfsr_data_cat(*(lfsr_data_t[1]){lfsr_data_fromshrub(_rbyd, _buffer)}) +#define LFSR_DATA_SHRUB_(_rbyd, _buffer) \ + lfsr_data_fromshrub(_rbyd, _buffer) -#define LFSR_CAT_SHRUB(_rbyd) \ - LFSR_CAT_SHRUB_(_rbyd, (uint8_t[LFSR_SHRUB_DSIZE]){0}) +#define LFSR_DATA_SHRUB(_rbyd) \ + LFSR_DATA_SHRUB_(_rbyd, (uint8_t[LFSR_SHRUB_DSIZE]){0}) static lfsr_data_t lfsr_data_fromshrub(const lfsr_shrub_t *shrub, uint8_t buffer[static LFSR_SHRUB_DSIZE]) { @@ -5507,11 +5468,11 @@ static inline bool lfsr_mptr_ismrootanchor(const lfsr_mptr_t *mptr) { // #define LFSR_MPTR_DSIZE (5+5) -#define LFSR_CAT_MPTR_(_mptr, _buffer) \ - lfsr_data_cat(*(lfsr_data_t[1]){lfsr_data_frommptr(_mptr, _buffer)}) +#define LFSR_DATA_MPTR_(_mptr, _buffer) \ + lfsr_data_frommptr(_mptr, _buffer) -#define LFSR_CAT_MPTR(_mptr) \ - LFSR_CAT_MPTR_(_mptr, (uint8_t[LFSR_MPTR_DSIZE]){0}) +#define LFSR_DATA_MPTR(_mptr) \ + LFSR_DATA_MPTR_(_mptr, (uint8_t[LFSR_MPTR_DSIZE]){0}) static lfsr_data_t lfsr_data_frommptr(const lfsr_mptr_t *mptr, uint8_t buffer[static LFSR_MPTR_DSIZE]) { @@ -6031,7 +5992,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } else if (attrs[i].tag == LFSR_TAG_MOVE) { // weighted moves are not supported LFS_ASSERT(attrs[i].delta == 0); - const lfsr_mdir_t *mdir__ = lfsr_attr_mdir(attrs[i]); + const lfsr_mdir_t *mdir__ = attrs[i].cat; // skip the name tag, this is always replaced by upper layers lfsr_tag_t tag = LFSR_TAG_STRUCT-1; @@ -6051,7 +6012,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, if (tag == LFSR_TAG_DATA) { err = lfsr_rbyd_appendattr(lfs, &rbyd_, rid - lfs_smax32(start_rid, 0), - tag, 0, LFSR_CAT_DATA_(&data)); + LFSR_ATTR_CAT_(tag, 0, &data, 1)); if (err) { return err; } @@ -6082,8 +6043,9 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // write our new shrub tag err = lfsr_rbyd_appendattr(lfs, &rbyd_, rid - lfs_smax32(start_rid, 0), - LFSR_TAG_BSHRUB, 0, - LFSR_CAT_SHRUB(&shrub)); + LFSR_ATTR( + LFSR_TAG_BSHRUB, 0, + LFSR_DATA_SHRUB(&shrub))); if (err) { return err; } @@ -6092,7 +6054,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } else { err = lfsr_rbyd_appendattr(lfs, &rbyd_, rid - lfs_smax32(start_rid, 0), - tag, 0, LFSR_CAT_DATA_(&data)); + LFSR_ATTR_CAT_(tag, 0, &data, 1)); if (err) { return err; } @@ -6116,8 +6078,9 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, && file->bshrub_.u.bsprout.u.disk.block != rbyd_.blocks[0]) { int err = lfsr_rbyd_appendcompactattr(lfs, &rbyd_, - LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0, - LFSR_CAT_DATA_(&file->bshrub.u.bsprout)); + LFSR_ATTR_CAT_( + LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0, + &file->bshrub.u.bsprout, 1)); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -6152,8 +6115,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // in our rbyd } else if (attrs[i].tag == LFSR_TAG_SHRUBALLOC || attrs[i].tag == LFSR_TAG_SHRUBCOMMIT) { - const lfsr_shrubcommit_t *bshrubcommit - = lfsr_attr_shrubcommit(attrs[i]); + const lfsr_shrubcommit_t *bshrubcommit = attrs[i].cat; // SHRUBALLOC is roughly the same as SHRUBCOMMIT but also // resets the shrub, we need to do this here so bshrub root @@ -6179,14 +6141,15 @@ 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) { - const lfsr_shrub_t *shrub = lfsr_attr_shrubtrunk(attrs[i]); + const lfsr_shrub_t *shrub = attrs[i].cat; int err = lfsr_rbyd_appendattr(lfs, &rbyd_, rid - lfs_smax32(start_rid, 0), - lfsr_tag_mode(attrs[i].tag) | LFSR_TAG_BSHRUB, - attrs[i].delta, - // note we use the staged trunk here - LFSR_CAT_SHRUB(shrub)); + LFSR_ATTR( + lfsr_tag_mode(attrs[i].tag) | LFSR_TAG_BSHRUB, + attrs[i].delta, + // note we use the staged trunk here + LFSR_DATA_SHRUB(shrub))); if (err) { return err; } @@ -6197,9 +6160,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, int err = lfsr_rbyd_appendattr(lfs, &rbyd_, rid - lfs_smax32(start_rid, 0), - attrs[i].tag, - attrs[i].delta, - lfsr_attr_cat(attrs[i])); + attrs[i]); if (err) { return err; } @@ -6427,7 +6388,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // we need to update any opened inlined files if (tag == LFSR_TAG_DATA) { err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, - tag, weight, LFSR_CAT_DATA_(&data)); + LFSR_ATTR_CAT_(tag, weight, &data, 1)); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -6460,7 +6421,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // write the new shrub tag err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, - tag, weight, LFSR_CAT_SHRUB(&shrub)); + LFSR_ATTR(tag, weight, LFSR_DATA_SHRUB(&shrub))); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -6469,7 +6430,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, } else { // write the tag err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, - tag, weight, LFSR_CAT_DATA_(&data)); + LFSR_ATTR_CAT_(tag, weight, &data, 1)); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -6501,8 +6462,9 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, && file->bshrub_.u.bsprout.u.disk.block != mdir_->rbyd.blocks[0]) { err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, - LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0, - LFSR_CAT_DATA_(&file->bshrub.u.bsprout)); + LFSR_ATTR_CAT_( + LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0, + &file->bshrub.u.bsprout, 1)); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -6655,7 +6617,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, for (lfs_size_t i = 0; i < attr_count; i++) { if (attrs[i].tag == LFSR_TAG_GRM) { // encode to disk - lfsr_grm_t *grm = lfsr_attr_grm(attrs[i]); + lfsr_grm_t *grm = (lfsr_grm_t*)attrs[i].cat; lfsr_gdelta_xorgrm(lfs, lfs->grm_d, LFSR_GRM_DSIZE, grm); // xor with our current gstate to find our initial gdelta @@ -6831,13 +6793,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_MDIR, +lfsr_mleafweight(lfs), - LFSR_CAT_MPTR(lfsr_mdir_mptr(&mdir_))), - LFSR_ATTR( + LFSR_DATA_MPTR(lfsr_mdir_mptr(&mdir_))), + LFSR_ATTR_CAT_( LFSR_TAG_NAME, +lfsr_mleafweight(lfs), - LFSR_CAT_DATA_(&split_data)), + &split_data, 1), LFSR_ATTR( LFSR_TAG_MDIR, 0, - LFSR_CAT_MPTR(lfsr_mdir_mptr(&msibling_))))); + LFSR_DATA_MPTR(lfsr_mdir_mptr(&msibling_))))); if (err) { return err; } @@ -6851,13 +6813,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_MDIR, 0, - LFSR_CAT_MPTR(lfsr_mdir_mptr(&mdir_))), - LFSR_ATTR( + LFSR_DATA_MPTR(lfsr_mdir_mptr(&mdir_))), + LFSR_ATTR_CAT_( LFSR_TAG_NAME, +lfsr_mleafweight(lfs), - LFSR_CAT_DATA_(&split_data)), + &split_data, 1), LFSR_ATTR( LFSR_TAG_MDIR, 0, - LFSR_CAT_MPTR(lfsr_mdir_mptr(&msibling_))))); + LFSR_DATA_MPTR(lfsr_mdir_mptr(&msibling_))))); if (err) { return err; } @@ -6891,7 +6853,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM, -lfsr_mleafweight(lfs), - LFSR_CAT_NULL()))); + LFSR_DATA_NULL()))); if (err) { return err; } @@ -6921,7 +6883,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_MDIR, 0, - LFSR_CAT_MPTR(lfsr_mdir_mptr(&mdir_))))); + LFSR_DATA_MPTR(lfsr_mdir_mptr(&mdir_))))); if (err) { return err; } @@ -6938,7 +6900,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // // gd' = gd xor (grm' xor grm) // - lfsr_grm_t *grm = lfsr_attr_grm(attrs[i]); + lfsr_grm_t *grm = (lfsr_grm_t*)attrs[i].cat; lfsr_gdelta_xorgrm(lfs, lfs->grm_d, LFSR_GRM_DSIZE, grm); // patch our grm @@ -6981,10 +6943,10 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, (lfsr_mtree_ismptr(&mtree_)) ? LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_MDIR, 0, - LFSR_CAT_MPTR(&mtree_.u.mptr.mptr)) + LFSR_DATA_MPTR(&mtree_.u.mptr.mptr)) : LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_MTREE, 0, - LFSR_CAT_BTREE(&mtree_.u.btree)))); + LFSR_DATA_BTREE(&mtree_.u.btree)))); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -7019,7 +6981,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_MROOT, 0, - LFSR_CAT_MPTR(lfsr_mdir_mptr(&mrootchild_))))); + LFSR_DATA_MPTR(lfsr_mdir_mptr(&mrootchild_))))); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_NOENT); @@ -7051,10 +7013,10 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_MAGIC, 0, - LFSR_CAT_BUF("littlefs", 8)), + LFSR_DATA_BUF("littlefs", 8)), LFSR_ATTR( LFSR_TAG_MROOT, 0, - LFSR_CAT_MPTR(lfsr_mdir_mptr(&mrootchild_))))); + LFSR_DATA_MPTR(lfsr_mdir_mptr(&mrootchild_))))); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_NOENT); @@ -7073,7 +7035,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, for (lfs_size_t i = 0; i < attr_count; i++) { // update any gstate changes if (attrs[i].tag == LFSR_TAG_GRM) { - lfs->grm = *lfsr_attr_grm(attrs[i]); + lfs->grm = *(lfsr_grm_t*)attrs[i].cat; // keep track of the exact encoding on-disk lfsr_data_fromgrm(&lfs->grm, lfs->grm_g); @@ -8041,8 +8003,8 @@ static inline bool lfsr_ocompat_isincompat(lfsr_ocompat_t ocompat) { // // little-endian, truncated bits must be assumed zero -#define LFSR_CAT_RCOMPAT(_rcompat) \ - LFSR_CAT_BUF(((uint8_t[]){ \ +#define LFSR_DATA_RCOMPAT(_rcompat) \ + LFSR_DATA_BUF(((uint8_t[]){ \ (((_rcompat) >> 0) & 0xff), \ (((_rcompat) >> 8) & 0xff)}), 2) @@ -8077,7 +8039,7 @@ static int lfsr_data_readrcompat(lfs_t *lfs, lfsr_data_t *data, } // all the compat parsing is basically the same, so try to reuse code -#define LFSR_CAT_WCOMPAT(_wcompat) LFSR_CAT_RCOMPAT(_wcompat) +#define LFSR_DATA_WCOMPAT(_wcompat) LFSR_DATA_RCOMPAT(_wcompat) static int lfsr_data_readwcompat(lfs_t *lfs, lfsr_data_t *data, lfsr_wcompat_t *wcompat) { @@ -8101,12 +8063,11 @@ typedef struct lfsr_geometry { // '---+- -+- -+- -+- -' #define LFSR_GEOMETRY_DSIZE (4+5) -#define LFSR_CAT_GEOMETRY_(_geometry, _buffer) \ - lfsr_data_cat(*(lfsr_data_t[1]){ \ - lfsr_data_fromgeometry(_geometry, _buffer)}) +#define LFSR_DATA_GEOMETRY_(_geometry, _buffer) \ + lfsr_data_fromgeometry(_geometry, _buffer) -#define LFSR_CAT_GEOMETRY(_geometry) \ - LFSR_CAT_GEOMETRY_(_geometry, (uint8_t[LFSR_GEOMETRY_DSIZE]){0}) +#define LFSR_DATA_GEOMETRY(_geometry) \ + LFSR_DATA_GEOMETRY_(_geometry, (uint8_t[LFSR_GEOMETRY_DSIZE]){0}) static lfsr_data_t lfsr_data_fromgeometry(const lfsr_geometry_t *geometry, uint8_t buffer[static LFSR_GEOMETRY_DSIZE]) { @@ -8503,29 +8464,29 @@ static int lfsr_formatinited(lfs_t *lfs) { err = lfsr_rbyd_commit(lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_MAGIC, 0, - LFSR_CAT_BUF("littlefs", 8)), + LFSR_DATA_BUF("littlefs", 8)), LFSR_ATTR( LFSR_TAG_VERSION, 0, - LFSR_CAT_BUF(((const uint8_t[2]){ + LFSR_DATA_BUF(((const uint8_t[2]){ LFS_DISK_VERSION_MAJOR, LFS_DISK_VERSION_MINOR}), 2)), LFSR_ATTR( LFSR_TAG_RCOMPAT, 0, - LFSR_CAT_RCOMPAT(LFSR_RCOMPAT_COMPAT)), + LFSR_DATA_RCOMPAT(LFSR_RCOMPAT_COMPAT)), LFSR_ATTR( LFSR_TAG_GEOMETRY, 0, - LFSR_CAT_GEOMETRY((&(lfsr_geometry_t){ + LFSR_DATA_GEOMETRY((&(lfsr_geometry_t){ lfs->cfg->block_size, lfs->cfg->block_count}))), LFSR_ATTR( LFSR_TAG_NAMELIMIT, 0, - LFSR_CAT_LLEB128(lfs->name_limit)), + LFSR_DATA_LLEB128(lfs->name_limit)), LFSR_ATTR( LFSR_TAG_SIZELIMIT, 0, - LFSR_CAT_LEB128(lfs->size_limit)), + LFSR_DATA_LEB128(lfs->size_limit)), LFSR_ATTR( LFSR_TAG_BOOKMARK, +1, - LFSR_CAT_LEB128(0)))); + LFSR_DATA_LEB128(0)))); if (err) { return err; } @@ -8782,7 +8743,7 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) { LFS_ASSERT(lfsr_mid_rid(lfs, lfs->grm.rms[0]) < (lfsr_srid_t)mdir.rbyd.weight); err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()), + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), LFSR_ATTR_GRM(LFSR_TAG_GRM, 0, &grm))); } @@ -8814,7 +8775,7 @@ static int lfsr_fs_fixorphans(lfs_t *lfs) { if (err != LFS_ERR_NOENT) { // remove orphaned file err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); if (err) { return err; } @@ -9017,7 +8978,7 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { // commit our bookmark and a grm to self-remove in case of powerloss err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_BOOKMARK, +1, LFSR_CAT_LEB128(did_)), + LFSR_ATTR(LFSR_TAG_BOOKMARK, +1, LFSR_DATA_LEB128(did_)), LFSR_ATTR_GRM(LFSR_TAG_GRM, 0, &((lfsr_grm_t){{mdir.mid, -1}})))); if (err) { return err; @@ -9036,10 +8997,10 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { // commit our new directory into our parent, zeroing the grm in the // process err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_SUP | LFSR_TAG_DIR, (!exists) ? +1 : 0, - LFSR_CAT_NAME(did, name, name_size)), - LFSR_ATTR(LFSR_TAG_DID, 0, LFSR_CAT_LEB128(did_)), + did, name, name_size), + LFSR_ATTR(LFSR_TAG_DID, 0, LFSR_DATA_LEB128(did_)), LFSR_ATTR_GRM(LFSR_TAG_GRM, 0, &((lfsr_grm_t){{-1, -1}})))); if (err) { return err; @@ -9139,11 +9100,11 @@ int lfsr_remove(lfs_t *lfs, const char *path) { // we use a create+delete here to also clear any attrs // and trim the entry size (zombie) - ? LFSR_ATTR( + ? LFSR_ATTR_NAME( LFSR_TAG_SUP | LFSR_TAG_ORPHAN, 0, - LFSR_CAT_NAME(did, name, name_size)) + did, name, name_size) : LFSR_ATTR( - LFSR_TAG_RM, -1, LFSR_CAT_NULL()), + LFSR_TAG_RM, -1, LFSR_DATA_NULL()), LFSR_ATTR_GRM(LFSR_TAG_GRM, 0, &grm))); if (err) { return err; @@ -9287,9 +9248,9 @@ 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 err = lfsr_mdir_commit(lfs, &new_mdir, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_SUP | old_tag, (!exists) ? +1 : 0, - LFSR_CAT_NAME(new_did, new_name, new_name_size)), + new_did, new_name, new_name_size), LFSR_ATTR_MOVE(LFSR_TAG_MOVE, 0, &old_mdir), LFSR_ATTR_GRM(LFSR_TAG_GRM, 0, &grm))); if (err) { @@ -9766,9 +9727,9 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file, // mid until first sync if (!err) { err = lfsr_mdir_commit(lfs, &file->m.mdir, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_ORPHAN, +1, - LFSR_CAT_NAME(did, name, name_size)))); + did, name, name_size))); if (err) { return err; } @@ -10347,8 +10308,7 @@ evict:; } static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, - lfs_off_t pos, lfs_off_t weight, lfs_soff_t delta, - lfsr_tag_t tag, lfsr_cat_t cat) { + lfs_off_t pos, lfs_off_t weight, lfsr_attr_t attr) { // Note! This function has some rather special constraints: // // 1. We must never allow our btree size to overflow, even temporarily. @@ -10383,13 +10343,13 @@ 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->m.mdir, &file->bshrub)) { - attrs[attr_count++] = LFSR_ATTR( + attrs[attr_count++] = LFSR_ATTR_CAT_( LFSR_TAG_DATA, +lfsr_bshrub_size(&file->bshrub), - LFSR_CAT_DATA_(&file->bshrub.u.bsprout)); + &file->bshrub.u.bsprout, 1); } else if (lfsr_bshrub_isbptr(&file->m.mdir, &file->bshrub)) { attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_BLOCK, +lfsr_bshrub_size(&file->bshrub), - LFSR_CAT_BPTR_(&file->bshrub.u.bptr, left.buf)); + LFSR_DATA_BPTR_(&file->bshrub.u.bptr, left.buf)); } file->bshrub.u.bshrub.blocks[0] = file->m.mdir.rbyd.blocks[0]; @@ -10417,21 +10377,19 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub)-1); attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_GROW, +(pos - lfsr_bshrub_size(&file->bshrub)), - LFSR_CAT_NULL()); + LFSR_DATA_NULL()); // new hole } else { bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub)); attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_DATA, +(pos - lfsr_bshrub_size(&file->bshrub)), - LFSR_CAT_NULL()); + LFSR_DATA_NULL()); } } // try to carve any existing data - lfsr_tag_t right_tag_ = 0; - lfsr_bid_t right_weight_; - lfsr_cat_t right_cat_; + lfsr_attr_t right_attr_ = {.tag=0}; while (pos < lfsr_bshrub_size(&file->bshrub)) { lfsr_tag_t tag_; lfsr_bid_t weight_; @@ -10461,15 +10419,14 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, -1); err = lfsr_bshrub_commit(lfs, file, bid, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_CAT( LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA, -(weight_ - lfs->cfg->fragment_size), - LFSR_CAT_DATA( - lfsr_data_truncate(left_slice_, - lfs->cfg->fragment_size))), + lfsr_data_truncate(left_slice_, + lfs->cfg->fragment_size)), LFSR_ATTR( LFSR_TAG_BLOCK, +(weight_ - lfs->cfg->fragment_size), - LFSR_CAT_BPTR(&bptr_)))); + LFSR_DATA_BPTR(&bptr_)))); if (err) { return err; } @@ -10493,13 +10450,12 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, LFSR_ATTR( LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK, -(weight_ - lfsr_data_size(bptr_.data)), - LFSR_CAT_BPTR(&bptr_)), - LFSR_ATTR( + LFSR_DATA_BPTR(&bptr_)), + LFSR_ATTR_CAT( LFSR_TAG_DATA, +(weight_ - lfsr_data_size(bptr_.data)), - LFSR_CAT_DATA( - lfsr_data_fruncate(right_slice_, - lfs->cfg->fragment_size))))); + lfsr_data_fruncate(right_slice_, + lfs->cfg->fragment_size)))); if (err) { return err; } @@ -10516,22 +10472,22 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // can we get away with a grow attribute? if (lfsr_data_size(bptr_.data) == lfsr_data_size(left_slice_)) { attrs[attr_count++] = LFSR_ATTR( - LFSR_TAG_GROW, -(bid+1 - pos), LFSR_CAT_NULL()); + 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( + attrs[attr_count++] = LFSR_ATTR_CAT_( LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA, -(bid+1 - pos), - LFSR_CAT_DATA_(&left.data)); + &left.data, 1); // carve bptr? } else if (tag_ == LFSR_TAG_BLOCK) { attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK, -(bid+1 - pos), - LFSR_CAT_BPTR_( + LFSR_DATA_BPTR_( (&(lfsr_bptr_t){ .data = left_slice_, .cksize = bptr_.cksize, @@ -10545,7 +10501,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // completely overwriting this entry? } else { attrs[attr_count++] = LFSR_ATTR( - LFSR_TAG_RM, -weight_, LFSR_CAT_NULL()); + LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()); } // spans more than one entry? we can't do everything in one commit, @@ -10560,7 +10516,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, return err; } - delta += lfs_min32(weight, bid+1 - pos); + attr.delta += lfs_min32(weight, bid+1 - pos); weight -= lfs_min32(weight, bid+1 - pos); attr_count = 0; continue; @@ -10570,62 +10526,66 @@ 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) { - delta += bid+1 - (pos+weight); + attr.delta += bid+1 - (pos+weight); // carve fragment? } else if (tag_ == LFSR_TAG_DATA) { right.data = right_slice_; - right_tag_ = tag_; - right_weight_ = bid+1 - (pos+weight); - right_cat_ = LFSR_CAT_DATA_(&right.data); + right_attr_ = LFSR_ATTR_CAT_( + tag_, + bid+1 - (pos+weight), + &right.data, 1); // carve bptr? } else if (tag_ == LFSR_TAG_BLOCK) { - right_tag_ = tag_; - right_weight_ = bid+1 - (pos+weight); - right_cat_ = LFSR_CAT_BPTR_( - (&(lfsr_bptr_t){ - .data = right_slice_, - .cksize = bptr_.cksize, - .cksum = bptr_.cksum}), - right.buf); + right_attr_ = LFSR_ATTR( + tag_, + bid+1 - (pos+weight), + LFSR_DATA_BPTR_( + (&(lfsr_bptr_t){ + .data = right_slice_, + .cksize = bptr_.cksize, + .cksum = bptr_.cksum}), + right.buf)); } else { LFS_UNREACHABLE(); } } - delta += lfs_min32(weight, bid+1 - pos); + attr.delta += lfs_min32(weight, bid+1 - pos); weight -= lfs_min32(weight, bid+1 - pos); break; } // append our data - if (weight + delta > 0) { + if (weight + attr.delta > 0) { // can we coalesce a hole? - if (lfsr_cat_size(cat) == 0 && pos > 0) { + if (lfsr_attr_size(attr) == 0 && pos > 0) { bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub)-1); attrs[attr_count++] = LFSR_ATTR( - LFSR_TAG_GROW, +(weight + delta), LFSR_CAT_NULL()); + LFSR_TAG_GROW, +(weight + attr.delta), + LFSR_DATA_NULL()); // need a new hole? - } else if (lfsr_cat_size(cat) == 0) { + } else if (lfsr_attr_size(attr) == 0) { bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub)); attrs[attr_count++] = LFSR_ATTR( - LFSR_TAG_DATA, +(weight + delta), LFSR_CAT_NULL()); + LFSR_TAG_DATA, +(weight + attr.delta), + LFSR_DATA_NULL()); // append new fragment/bptr? } else { bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub)); - attrs[attr_count++] = LFSR_ATTR( - tag, +(weight + delta), cat); + attrs[attr_count++] = LFSR_ATTR_( + attr.tag, +(weight + attr.delta), + attr.cat, attr.cat_count); } } // and don't forget the right sibling - if (right_tag_) { - attrs[attr_count++] = LFSR_ATTR( - right_tag_, +right_weight_, right_cat_); + if (right_attr_.tag) { + attrs[attr_count++] = right_attr_; } // commit pending attrs @@ -10965,8 +10925,8 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, // and write it into our tree err = lfsr_file_carve(lfs, file, - block_start, block_end - block_start, 0, - LFSR_TAG_BLOCK, LFSR_CAT_BPTR(&bptr)); + block_start, block_end - block_start, + LFSR_ATTR(LFSR_TAG_BLOCK, 0, LFSR_DATA_BPTR(&bptr))); if (err) { return err; } @@ -11074,8 +11034,8 @@ fragment:; // once we've figured out what fragment to write, carve it into // our tree int err = lfsr_file_carve(lfs, file, - fragment_start, fragment_end - fragment_start, 0, - LFSR_TAG_DATA, LFSR_CAT_DATAS_(datas, data_count)); + fragment_start, fragment_end - fragment_start, + LFSR_ATTR_CAT_(LFSR_TAG_DATA, 0, datas, data_count)); if (err && err != LFS_ERR_RANGE) { return err; } @@ -11464,9 +11424,9 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { goto failed; } - attrs[attr_count++] = LFSR_ATTR( + attrs[attr_count++] = LFSR_ATTR_CAT_( LFSR_TAG_SUB | LFSR_TAG_REG, 0, - LFSR_CAT_DATA_(&name_data)); + &name_data, 1); } // commit the file state @@ -11475,13 +11435,13 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { if (lfsr_f_isunflush(file->m.flags) && file->buffer_size == 0) { attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_STRUCT, 0, - LFSR_CAT_NULL()); + LFSR_DATA_NULL()); // small file inlined in mdir? } else if (lfsr_f_isunflush(file->m.flags)) { data.data = LFSR_DATA_BUF(file->buffer, file->buffer_size); - attrs[attr_count++] = LFSR_ATTR( + attrs[attr_count++] = LFSR_ATTR_CAT_( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_DATA_(&data.data)); + &data.data, 1); // bshrub? } else if (lfsr_bshrub_isbshrub(&file->m.mdir, &file->bshrub)) { attrs[attr_count++] = LFSR_ATTR_SHRUBTRUNK( @@ -11491,7 +11451,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { } else if (lfsr_bshrub_isbtree(&file->m.mdir, &file->bshrub)) { attrs[attr_count++] = LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_BTREE, 0, - LFSR_CAT_BTREE_(&file->bshrub.u.btree, data.buf)); + LFSR_DATA_BTREE_(&file->bshrub.u.btree, data.buf)); } else { LFS_UNREACHABLE(); } @@ -11655,8 +11615,7 @@ int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { err = lfsr_file_carve(lfs, file, lfs_min32(size, size_), size - lfs_min32(size, size_), - +size_ - size, - LFSR_TAG_DATA, LFSR_CAT_NULL()); + LFSR_ATTR(LFSR_TAG_DATA, +size_ - size, LFSR_DATA_NULL())); if (err) { goto failed; } @@ -11773,8 +11732,7 @@ int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { err = lfsr_file_carve(lfs, file, 0, lfs_smax32(size - size_, 0), - +size_ - size, - LFSR_TAG_DATA, LFSR_CAT_NULL()); + LFSR_ATTR(LFSR_TAG_DATA, +size_ - size, LFSR_DATA_NULL())); if (err) { goto failed; } diff --git a/tests/test_btree.toml b/tests/test_btree.toml index 0b3dbd7d..79e72b6d 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -55,7 +55,7 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -97,9 +97,9 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0; + 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_CAT_BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -147,9 +147,9 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("b", 1)))) => 0; + 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_CAT_BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -198,11 +198,11 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0; + 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_CAT_BUF("b", 1)))) => 0; + 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_CAT_BUF("c", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -257,11 +257,11 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("c", 1)))) => 0; + 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_CAT_BUF("b", 1)))) => 0; + 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_CAT_BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -323,7 +323,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -379,7 +379,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -449,7 +449,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -524,7 +524,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +W, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -620,7 +620,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +weight, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -734,12 +734,12 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; // update the tree lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF("A", 1)))) => 0; + LFSR_DATA_BUF("A", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -780,18 +780,18 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0; + 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_CAT_BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; // update the tree lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF("A", 1)))) => 0; + LFSR_DATA_BUF("A", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF("B", 1)))) => 0; + LFSR_DATA_BUF("B", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -839,24 +839,24 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0; + 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_CAT_BUF("b", 1)))) => 0; + 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_CAT_BUF("c", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; // update the tree lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF("A", 1)))) => 0; + LFSR_DATA_BUF("A", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF("B", 1)))) => 0; + LFSR_DATA_BUF("B", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF("C", 1)))) => 0; + LFSR_DATA_BUF("C", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -915,7 +915,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -931,7 +931,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -991,7 +991,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1021,7 +1021,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -1092,7 +1092,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +W, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1108,7 +1108,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1183,7 +1183,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +W, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1224,10 +1224,10 @@ code = ''' weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1)), + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)), LFSR_ATTR( LFSR_TAG_GROW, +weight-sim_weights[bid], - LFSR_CAT_NULL()))); + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -1338,10 +1338,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0; + LFSR_ATTR(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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1359,7 +1359,7 @@ code = ''' // 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_CAT_BUF("A", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1395,12 +1395,12 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0; + 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_CAT_BUF("b", 1)))) => 0; + LFSR_ATTR(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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1425,7 +1425,7 @@ code = ''' // 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_CAT_BUF("B", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("B", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1468,12 +1468,12 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0; + 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_CAT_BUF("b", 1)))) => 0; + LFSR_ATTR(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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1498,7 +1498,7 @@ code = ''' // 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_CAT_BUF("A", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1541,14 +1541,14 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("a", 1)))) => 0; + 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_CAT_BUF("b", 1)))) => 0; + 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_CAT_BUF("c", 1)))) => 0; + LFSR_ATTR(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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1580,7 +1580,7 @@ code = ''' // 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_CAT_BUF("C", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("C", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1636,7 +1636,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1650,7 +1650,7 @@ code = ''' // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { int err = lfsr_btree_commit(&lfs, &btree, N-1-i, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1689,7 +1689,7 @@ code = ''' // try recovering lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("R", 1)))) => 0; + LFSR_ATTR(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, @@ -1734,7 +1734,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1748,7 +1748,7 @@ code = ''' // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { int err = lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1787,7 +1787,7 @@ code = ''' // try recovering lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("R", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0; lfsr_btree_lookup(&lfs, &btree, 0, &tag_, &weight_, &data_) => 0; @@ -1834,7 +1834,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1863,7 +1863,7 @@ code = ''' // remove from btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -1937,7 +1937,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +W, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1951,7 +1951,7 @@ code = ''' // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { int err = lfsr_btree_commit(&lfs, &btree, (N-1-i)*W+W-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_CAT_NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1989,7 +1989,7 @@ code = ''' // try recovering lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_CAT_BUF("R", 1)))) => 0; + LFSR_ATTR(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, @@ -2081,7 +2081,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +weight, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -2112,7 +2112,7 @@ code = ''' weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM, -sim_weights[bid], - LFSR_CAT_NULL()))); + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2225,16 +2225,16 @@ code = ''' lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), + LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2287,7 +2287,7 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF("_", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -2307,10 +2307,10 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)), + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2384,16 +2384,16 @@ code = ''' lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +W, - LFSR_CAT_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), + LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), LFSR_ATTR( LFSR_TAG_DATA, +W, - LFSR_CAT_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2447,7 +2447,7 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_CAT_BUF("_", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -2480,13 +2480,13 @@ code = ''' weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_GROW, +weight1-sim_weights[bid], - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)), + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), LFSR_ATTR( LFSR_TAG_DATA, +weight2, - LFSR_CAT_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2633,27 +2633,27 @@ code = ''' // 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_CAT_BUF("_", 1)))) => 0; + LFSR_ATTR(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_CAT_BUF(buf1, SIZE)), - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF(buf2, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_ATTR(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_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(buf2, SIZE)))) => 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2701,21 +2701,21 @@ code = ''' // 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_CAT_BUF("_", 1)))) => 0; + LFSR_ATTR(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_CAT_BUF(buf1, SIZE)), - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF(buf2, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_ATTR(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_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(buf2, SIZE)))) => 0; + LFSR_DATA_BUF(buf2, SIZE)))) => 0; assert(btree.weight == 2); // now remove one entry, since this brings the rbyd down this zero, @@ -2724,7 +2724,7 @@ 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2772,14 +2772,14 @@ code = ''' // 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_CAT_BUF("_", 1)))) => 0; + LFSR_ATTR(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_CAT_BUF(buf1, SIZE)), - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF(buf2, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_ATTR(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 @@ -2788,7 +2788,7 @@ code = ''' // btree.eoff = -1; lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2836,38 +2836,38 @@ code = ''' // 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_CAT_BUF("_", 1)))) => 0; + LFSR_ATTR(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_CAT_BUF(buf1, SIZE)), - LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_CAT_BUF(buf2, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_ATTR(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_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(buf2, SIZE)))) => 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_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF("a", 1)))) => 0; + LFSR_DATA_BUF("a", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF("b", 1)))) => 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2932,7 +2932,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2949,7 +2949,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2962,7 +2962,7 @@ code = ''' } else { // pop from btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3063,7 +3063,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +weight, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3084,10 +3084,10 @@ code = ''' weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)), + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), LFSR_ATTR( LFSR_TAG_GROW, +weight-sim_weights[bid], - LFSR_CAT_NULL()))); + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3104,7 +3104,7 @@ code = ''' weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM, -sim_weights[bid], - LFSR_CAT_NULL()))); + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3249,10 +3249,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, "aaa", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("0", 1)))) => 0; + 0, "aaa", 3), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3302,16 +3302,16 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, "aaa", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("0", 1)))) => 0; + 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_CAT_BUF("0", 1)), - LFSR_ATTR( + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, "aab", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("1", 1)))) => 0; + 0, "aab", 3), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3369,22 +3369,22 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, "aaa", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("0", 1)))) => 0; + 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_CAT_BUF("0", 1)), - LFSR_ATTR( + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(1*DID, "aab", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("1", 1)))) => 0; + 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_CAT_BUF("1", 1)), - LFSR_ATTR( + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(2*DID, "aac", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("2", 1)))) => 0; + 2*DID, "aac", 3), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3450,22 +3450,22 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, "aaa", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("0", 1)))) => 0; + 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_CAT_BUF("1", 1)), - LFSR_ATTR( + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(2*DID, "aac", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("2", 1)))) => 0; + 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_CAT_BUF("0", 1)), - LFSR_ATTR( + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(1*DID, "aab", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("1", 1)))) => 0; + 1*DID, "aab", 3), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3535,12 +3535,12 @@ code = ''' 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, name, 3)), + 0, name, 3), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { char name[3] = { @@ -3549,13 +3549,13 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), - LFSR_ATTR( + LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(i*DID, name, 3)), + i*DID, name, 3), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3610,10 +3610,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, "___", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("_", 1)))) => 0; + 0, "___", 3), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3649,13 +3649,13 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)), - LFSR_ATTR( + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, name, 3)), + 0, name, 3), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3733,12 +3733,12 @@ code = ''' 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +W, - LFSR_CAT_NAME(0, name, 3)), + 0, name, 3), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { char name[3] = { @@ -3747,13 +3747,13 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), - LFSR_ATTR( + LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +W, - LFSR_CAT_NAME(i*DID, name, 3)), + i*DID, name, 3), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3809,10 +3809,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +W, - LFSR_CAT_NAME(0, "___", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("_", 1)))) => 0; + 0, "___", 3), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3861,16 +3861,16 @@ code = ''' weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_GROW, +weight1-sim_weights[bid], - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)), - LFSR_ATTR( + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +weight2, - LFSR_CAT_NAME(0, name, 3)), + 0, name, 3), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3970,10 +3970,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, "___", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("_", 1)))) => 0; + 0, "___", 3), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -4021,12 +4021,12 @@ code = ''' if (cmp > LFS_CMP_EQ) { int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, name, 3)), + 0, name, 3), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4034,15 +4034,15 @@ code = ''' assert(err == 0); } else { int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_CAT_( LFSR_TAG_DATA, 0, - LFSR_CAT_DATA_(&split_data)), - LFSR_ATTR( + &split_data, 1), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +1, - LFSR_CAT_NAME(0, name, 3)), + 0, name, 3), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4062,7 +4062,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4075,7 +4075,7 @@ code = ''' } else { // pop from btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4146,10 +4146,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +W, - LFSR_CAT_NAME(0, "___", 3)), - LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_CAT_BUF("_", 1)))) => 0; + 0, "___", 3), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -4209,12 +4209,12 @@ code = ''' if (cmp > LFS_CMP_EQ) { int err = lfsr_btree_commit(&lfs, &btree, split_bid-(split_weight-1), LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_NAME( LFSR_TAG_NAME, +weight, - LFSR_CAT_NAME(0, name, 3)), + 0, name, 3), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4222,15 +4222,15 @@ code = ''' assert(err == 0); } else { int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS( - LFSR_ATTR( + LFSR_ATTR_CAT_( LFSR_TAG_DATA, 0, - LFSR_CAT_DATA_(&split_data)), - LFSR_ATTR( + &split_data, 1), + LFSR_ATTR_NAME( LFSR_TAG_NAME, +weight, - LFSR_CAT_NAME(0, name, 3)), + 0, name, 3), LFSR_ATTR( LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4254,10 +4254,10 @@ code = ''' weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_CAT_BUF(&(uint8_t){'0'+(i % 10)}, 1)), + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), LFSR_ATTR( LFSR_TAG_GROW, +weight-sim_weights[bid], - LFSR_CAT_NULL()))); + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4274,7 +4274,7 @@ code = ''' weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM, -sim_weights[bid], - LFSR_CAT_NULL()))); + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4375,7 +4375,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4515,7 +4515,7 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_DATA, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index dbb49f34..e2e5e318 100644 --- a/tests/test_mtree.toml +++ b/tests/test_mtree.toml @@ -28,7 +28,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(i), 0, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } for (lfs_size_t i = 0; i < N; i++) { @@ -73,7 +73,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(i), 0, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } for (lfs_size_t i = 0; i < N; i++) { @@ -115,7 +115,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; lfsr_data_t data; uint8_t buffer[4]; @@ -162,13 +162,13 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -232,14 +232,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -308,14 +308,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -332,7 +332,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mdir to compact @@ -420,7 +420,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; uint8_t buffer[256]; @@ -510,7 +510,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -593,14 +593,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -617,7 +617,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped @@ -670,14 +670,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -696,7 +696,7 @@ code = ''' // 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped @@ -749,14 +749,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // remove an entry, forcing the mdir to be dropped @@ -767,7 +767,7 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 2); // assert split/drop worked out @@ -820,14 +820,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -844,7 +844,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // remove an entry, forcing the mdir to be dropped @@ -854,7 +854,7 @@ code = ''' // 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 1); // assert split/drop worked out @@ -919,14 +919,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -943,7 +943,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // remove an entry, forcing the mdir to be dropped @@ -953,7 +953,7 @@ code = ''' // 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 1); // assert split/drop worked out @@ -1045,7 +1045,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -1074,7 +1074,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } } @@ -1149,13 +1149,13 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -1171,10 +1171,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1238,14 +1238,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -1264,10 +1264,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1335,14 +1335,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -1361,10 +1361,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1432,7 +1432,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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 @@ -1489,7 +1489,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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 @@ -1557,7 +1557,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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 @@ -1620,14 +1620,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -1649,10 +1649,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated @@ -1722,14 +1722,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -1746,7 +1746,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // setup mroot to compact and relocate on next commit @@ -1756,10 +1756,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated @@ -1841,14 +1841,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -1870,11 +1870,11 @@ code = ''' // force mdir to compact twice, this should relocate mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 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_CAT_NULL()))) => 0; + LFSR_ATTR(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); @@ -1932,13 +1932,13 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact, this should both uninline and relocate lfsr_mdir_t old_mroot = lfs.mroot; @@ -2012,14 +2012,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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 @@ -2120,7 +2120,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -2150,7 +2150,7 @@ 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_CAT_BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -2179,7 +2179,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } } @@ -2249,7 +2249,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_opened_add(&lfs, &left); @@ -2257,7 +2257,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0c", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0c", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_opened_add(&lfs, &right); @@ -2266,7 +2266,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "b", 1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0b", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; assert(mdir.rbyd.weight == 4); lfsr_data_t data; @@ -2308,7 +2308,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_opened_add(&lfs, &left); @@ -2316,7 +2316,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0b", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_opened_add(&lfs, &right); @@ -2325,7 +2325,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &mdir, NULL, NULL) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 2); // assert neighbor was removed @@ -2358,7 +2358,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_opened_add(&lfs, &left); @@ -2366,7 +2366,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0b", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_opened_add(&lfs, &right); @@ -2375,7 +2375,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "b", 1, &mdir, NULL, NULL) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 2); // assert neighbor was removed @@ -2410,7 +2410,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_opened_add(&lfs, &left); @@ -2418,7 +2418,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0d", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_opened_add(&lfs, &right); @@ -2430,14 +2430,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -2483,7 +2483,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_opened_add(&lfs, &left); @@ -2491,7 +2491,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0e", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_opened_add(&lfs, &right); @@ -2503,14 +2503,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -2522,7 +2522,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); // force mdir to compact @@ -2568,7 +2568,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_opened_add(&lfs, &left); @@ -2576,7 +2576,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0b", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_opened_add(&lfs, &right); @@ -2626,7 +2626,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_opened_add(&lfs, &left); @@ -2634,7 +2634,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0d", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_opened_add(&lfs, &right); @@ -2646,14 +2646,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -2672,10 +2672,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -2715,7 +2715,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_opened_add(&lfs, &left); @@ -2723,7 +2723,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0d", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_opened_add(&lfs, &right); @@ -2735,14 +2735,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -2761,10 +2761,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -2802,7 +2802,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_opened_add(&lfs, &left); @@ -2810,7 +2810,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0f", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0f", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_opened_add(&lfs, &right); @@ -2822,14 +2822,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -2841,7 +2841,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); // force mdir to compact @@ -2858,7 +2858,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mdir to compact @@ -2904,7 +2904,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; assert(left.mdir.rbyd.weight == 2); lfsr_opened_add(&lfs, &left); @@ -2912,7 +2912,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF("\0e", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0; assert(right.mdir.rbyd.weight == 3); lfsr_opened_add(&lfs, &right); @@ -2924,14 +2924,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 5); // force mroot to compact @@ -2943,7 +2943,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 4); // force mdir to compact @@ -2957,7 +2957,7 @@ code = ''' // now remove the middle entry, forcing a drop lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped correctly @@ -3002,7 +3002,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(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 @@ -3102,13 +3102,13 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -3236,14 +3236,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -3376,14 +3376,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 3); // force mroot to compact @@ -3400,7 +3400,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; assert(mdir.rbyd.weight == 2); // force mdir to compact @@ -3541,7 +3541,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF("\0a", 2)))) => 0; + LFSR_ATTR(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 @@ -3660,7 +3660,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; uint8_t buffer[256]; @@ -3808,7 +3808,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -3942,7 +3942,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_MROOT, 0, - LFSR_CAT_MPTR(&LFSR_MPTR_MROOTANCHOR())))) => 0; + LFSR_DATA_MPTR(&LFSR_MPTR_MROOTANCHOR())))) => 0; // technically, cycle detection only needs to work when we're validating lfsr_traversal_t traversal = LFSR_TRAVERSAL(LFSR_TRAVERSAL_VALIDATE); @@ -4020,7 +4020,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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 @@ -4077,7 +4077,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 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_CAT_BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(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 diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index ad843a1c..3af13ddc 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -34,7 +34,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes @@ -43,10 +43,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -71,7 +71,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes @@ -80,11 +80,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -109,7 +109,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; // fetch lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -118,7 +118,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -151,7 +151,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -176,10 +176,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -214,10 +214,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -271,7 +271,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -296,11 +296,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -335,11 +335,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -392,7 +392,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -413,10 +413,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -439,10 +439,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0; @@ -482,7 +482,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -503,11 +503,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -530,11 +530,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0; @@ -578,10 +578,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -604,10 +604,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -649,13 +649,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -678,13 +678,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -728,13 +728,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -764,13 +764,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -819,16 +819,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -858,16 +858,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -897,16 +897,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -936,16 +936,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -996,16 +996,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1042,16 +1042,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1088,16 +1088,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1134,16 +1134,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1199,16 +1199,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1245,16 +1245,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1291,16 +1291,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1337,16 +1337,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1404,19 +1404,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1455,19 +1455,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1504,19 +1504,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1553,19 +1553,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1625,19 +1625,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1683,19 +1683,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1739,19 +1739,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1795,19 +1795,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1872,22 +1872,22 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1933,22 +1933,22 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1994,22 +1994,22 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -2076,22 +2076,22 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xff\xff\xff\xff", 4)))) => 0; + LFSR_DATA_BUF("\xff\xff\xff\xff", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -2142,22 +2142,22 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xff\xff\xff\xff", 4)), + LFSR_DATA_BUF("\xff\xff\xff\xff", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -2208,22 +2208,22 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xff\xff\xff\xff", 4)), + LFSR_DATA_BUF("\xff\xff\xff\xff", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -2308,7 +2308,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { attrs[j] = LFSR_ATTR( LFSR_TAG_UATTR(perm[j]+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)); + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)); } // test the given permutation @@ -2401,7 +2401,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(perm[j]+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -2461,10 +2461,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2499,10 +2499,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2558,11 +2558,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2597,11 +2597,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2677,7 +2677,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { attrs[j] = LFSR_ATTR( LFSR_TAG_UATTR(perm[j]+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)); + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)); } // test the given permutation @@ -2752,7 +2752,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(perm[j]+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -2809,7 +2809,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(j+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } // copy block so we can reset after each remove @@ -2851,7 +2851,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(perm[j]+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; } // check that all tags have been updated @@ -2930,7 +2930,7 @@ code = ''' int err = lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(x & 0x7f), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))); + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))); if (err == LFS_ERR_RANGE) { break; } @@ -2982,11 +2982,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3005,14 +3005,14 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -3047,14 +3047,14 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(2), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -3134,7 +3134,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(perm[j]+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } // copy block so we can reset after each remove @@ -3159,7 +3159,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(j+1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -3188,7 +3188,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(j+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -3284,7 +3284,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(perm[j]+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } // copy block so we can reset after each remove @@ -3309,7 +3309,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(j+1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -3363,10 +3363,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3394,7 +3394,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3421,7 +3421,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3448,7 +3448,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3522,30 +3522,30 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; // remove several attributes lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -3574,7 +3574,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3601,7 +3601,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3628,7 +3628,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3657,7 +3657,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3684,7 +3684,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3711,7 +3711,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3785,11 +3785,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3808,17 +3808,17 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(2), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3837,17 +3837,17 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(2), 0, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3899,7 +3899,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(j+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } // copy block so we can reset after each remove @@ -3941,7 +3941,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(perm[j]+1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; } // check that all tags are now removed @@ -3955,7 +3955,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -4053,7 +4053,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(attr), 0, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else { // update our sim sim[attr] = '\0'; @@ -4061,7 +4061,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(attr), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; } } @@ -4137,7 +4137,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4156,10 +4156,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4184,13 +4184,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4239,7 +4239,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4258,11 +4258,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4287,11 +4287,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4316,15 +4316,15 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4355,15 +4355,15 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4394,15 +4394,15 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4497,7 +4497,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -4559,10 +4559,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 00000000, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4632,11 +4632,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4683,11 +4683,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4797,7 +4797,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -4868,7 +4868,7 @@ code = ''' x = x % (rbyd.weight+1); int err = lfsr_rbyd_commit(&lfs, &rbyd, x, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(names[x % 6], 4)))); + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[x % 6], 4)))); if (err == LFS_ERR_RANGE) { break; } @@ -4917,10 +4917,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4945,16 +4945,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4991,22 +4991,22 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)), + LFSR_DATA_BUF("\xbb\xbb", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -5096,11 +5096,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -5125,19 +5125,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -5174,19 +5174,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -5223,27 +5223,27 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -5315,27 +5315,27 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -5384,27 +5384,27 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -5518,13 +5518,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -5593,16 +5593,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5704,19 +5704,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5795,19 +5795,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5950,13 +5950,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -6040,13 +6040,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[j % 6], 4)))) => 0; + LFSR_DATA_BUF(names[j % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[j % 6], 2)))) => 0; + LFSR_DATA_BUF(names[j % 6], 2)))) => 0; } } @@ -6089,7 +6089,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(perm[j]%M+1), 0, - LFSR_CAT_BUF(names[(perm[j]/M) % 6], 3)))) => 0; + LFSR_DATA_BUF(names[(perm[j]/M) % 6], 3)))) => 0; } // check that all tags have been updated @@ -6207,13 +6207,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -6239,7 +6239,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR((j%M)+1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -6283,7 +6283,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR((j%M)+1), 0, - LFSR_CAT_BUF(names[(j/M)%6], 3)))) => 0; + LFSR_DATA_BUF(names[(j/M)%6], 3)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -6387,13 +6387,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[j % 6], 4)))) => 0; + LFSR_DATA_BUF(names[j % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[j % 6], 2)))) => 0; + LFSR_DATA_BUF(names[j % 6], 2)))) => 0; } } @@ -6436,7 +6436,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(perm[j]%M+1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; } // check that all tags have been removed @@ -6527,11 +6527,11 @@ code = ''' // build a single attribute list with all attributes, if this fails // it should fail atomically struct lfsr_attr attrs[1+M]; - attrs[0] = LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_CAT_BUF(names[x % 6], 4)); + attrs[0] = LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[x % 6], 4)); for (unsigned u = 0; u < M; u++) { attrs[1+u] = LFSR_ATTR( LFSR_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[x % 6], 2)); + LFSR_DATA_BUF(names[x % 6], 2)); } int err = lfsr_rbyd_commit(&lfs, &rbyd, x, attrs, 1+M); @@ -6638,12 +6638,12 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(perm[j]+1), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 1)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } // try looking up each tag @@ -6784,17 +6784,17 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(perm[j]+1), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 1)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + 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_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -6909,12 +6909,12 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6937,12 +6937,12 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6965,15 +6965,15 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7000,15 +7000,15 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7035,15 +7035,15 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7088,18 +7088,18 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7132,18 +7132,18 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7176,24 +7176,24 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)), + LFSR_DATA_BUF("\xbb\xbb", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7238,24 +7238,24 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)), + LFSR_DATA_BUF("\xbb\xbb", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7300,24 +7300,24 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)), + LFSR_DATA_BUF("\xbb\xbb", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7390,65 +7390,65 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 0; + LFSR_DATA_BUF("\xee\xee", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7551,7 +7551,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7688,59 +7688,59 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), +1, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 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_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7831,7 +7831,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -7956,87 +7956,87 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), +1, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 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_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(8), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), // propagate yellow LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(8), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow LFSR_ATTR( LFSR_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 0; + LFSR_DATA_BUF("\xee\xee", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -8163,7 +8163,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -8327,75 +8327,75 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(4), +1, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(8), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(9), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root LFSR_ATTR( LFSR_TAG_UATTR(9), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(9), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 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_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), // propagate yellow LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -8516,7 +8516,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -8674,75 +8674,75 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(9), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), +1, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 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_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(8), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), // propagate yellow LFSR_ATTR( LFSR_TAG_UATTR(8), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -8863,7 +8863,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -9021,76 +9021,76 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), +1, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root LFSR_ATTR( LFSR_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 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_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), // propagate yellow LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -9199,7 +9199,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -9345,76 +9345,76 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(1), +1, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), +1, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 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_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), // propagate yellow LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -9523,7 +9523,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -9671,117 +9671,117 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), +1, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 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_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(8), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(11), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), // propagate yellow LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(12), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), // propagate yellow LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(13), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(14), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(9), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(10), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), // propagate yellow LFSR_ATTR( LFSR_TAG_UATTR(10), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -9932,7 +9932,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -10122,115 +10122,115 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_UATTR(6), +1, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(7), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(8), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(9), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(10), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow to the root LFSR_ATTR( LFSR_TAG_UATTR(10), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(10), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(10), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 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_TAG_UATTR(11), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(12), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(13), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(14), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow LFSR_ATTR( LFSR_TAG_UATTR(14), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(14), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 0; + LFSR_DATA_BUF("\xee\xee", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 0; + LFSR_DATA_BUF("\xee\xee", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_REG, 0, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(5), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), // propagate yellow LFSR_ATTR( LFSR_TAG_UATTR(4), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 0; + LFSR_DATA_BUF("\xee\xee", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -10381,7 +10381,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -10607,7 +10607,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -10631,7 +10631,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(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; @@ -10653,7 +10653,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[j % 6], 6)))) => 0; + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10769,13 +10769,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } assert(rbyd.weight == N); @@ -10800,7 +10800,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(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; @@ -10835,12 +10835,12 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[j % 6], 6)))) => 0; + 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_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[j % 6], 3)))) => 0; + LFSR_DATA_BUF(names[j % 6], 3)))) => 0; } assert(rbyd.weight == N); @@ -10969,7 +10969,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -10993,7 +10993,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -11099,13 +11099,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } assert(rbyd.weight == N); @@ -11130,7 +11130,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -11204,9 +11204,9 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11223,13 +11223,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11246,14 +11246,14 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11270,17 +11270,17 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + 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; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11297,19 +11297,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + 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_CAT_NULL()))) => 0; + 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11344,12 +11344,12 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11366,19 +11366,19 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11395,20 +11395,20 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11425,26 +11425,26 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)), + LFSR_DATA_BUF("\xbb\xbb", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()), - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + 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; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11461,28 +11461,28 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)), + LFSR_DATA_BUF("\xbb\xbb", 2)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + 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_CAT_NULL()))) => 0; + 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -11539,7 +11539,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[j % 6], 4)))) => 0; + LFSR_DATA_BUF(names[j % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -11589,7 +11589,7 @@ code = ''' lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -11604,7 +11604,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -11688,13 +11688,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[j % 6], 4)))) => 0; + LFSR_DATA_BUF(names[j % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF(names[j % 6], 2)))) => 0; + LFSR_DATA_BUF(names[j % 6], 2)))) => 0; } } assert(rbyd.weight == N); @@ -11745,7 +11745,7 @@ code = ''' lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -11760,12 +11760,12 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + 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_TAG_UATTR(u+1), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa", 3)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa", 3)))) => 0; } assert(rbyd.weight == 1); @@ -11880,14 +11880,14 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else { // update our sim 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } } @@ -11954,7 +11954,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -11975,7 +11975,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +2, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -12008,7 +12008,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +3, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -12053,7 +12053,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +4, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -12110,7 +12110,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +5, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -12201,23 +12201,23 @@ code = ''' // make id0 with weight w1 LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), // make id2 with weight w2 LFSR_ATTR( LFSR_TAG_REG, +2, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), // make id5 with weight w3 LFSR_ATTR( LFSR_TAG_REG, +3, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), // make id9 with weight w4 LFSR_ATTR( LFSR_TAG_REG, +4, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), // make id14 with weight w5 LFSR_ATTR( LFSR_TAG_REG, +5, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; // traverse, finding tags and weights lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, @@ -12358,7 +12358,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +W, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -12448,7 +12448,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +W, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -12499,16 +12499,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("unrelated", 9)), + LFSR_DATA_BUF("unrelated", 9)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)))) => 0; + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -12565,16 +12565,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)), + LFSR_DATA_BUF("\xbb\xbb", 2)), LFSR_ATTR( LFSR_TAG_GROW, +1, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)))) => 0; + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -12667,16 +12667,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_GROW, +2, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)))) => 0; + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -12805,16 +12805,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xdd\xdd", 2)), + LFSR_DATA_BUF("\xdd\xdd", 2)), LFSR_ATTR( LFSR_TAG_GROW, +3, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xdd\xdd", 2)))) => 0; + LFSR_DATA_BUF("\xdd\xdd", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -12979,16 +12979,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_GROW, +4, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 0; + LFSR_DATA_BUF("\xee\xee", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -13210,69 +13210,69 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("unrelated", 9)), + LFSR_DATA_BUF("unrelated", 9)), // make id0 with weight w1 LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xaa\xaa", 2)), + LFSR_DATA_BUF("\xaa\xaa", 2)), // make id2 with weight w2 LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)), + LFSR_DATA_BUF("\xbb\xbb", 2)), LFSR_ATTR( LFSR_TAG_GROW, +1, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xbb\xbb", 2)), + LFSR_DATA_BUF("\xbb\xbb", 2)), // make id5 with weight w3 LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), LFSR_ATTR( LFSR_TAG_GROW, +2, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xcc\xcc", 2)), + LFSR_DATA_BUF("\xcc\xcc", 2)), // make id9 with weight w4 LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xdd\xdd", 2)), + LFSR_DATA_BUF("\xdd\xdd", 2)), LFSR_ATTR( LFSR_TAG_GROW, +3, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xdd\xdd", 2)), + LFSR_DATA_BUF("\xdd\xdd", 2)), // make id14 with weight w5 LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xee\xee\xee\xee", 4)), + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xee\xee", 2)), + LFSR_DATA_BUF("\xee\xee", 2)), LFSR_ATTR( LFSR_TAG_GROW, +4, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xee\xee", 2)))) => 0; + LFSR_DATA_BUF("\xee\xee", 2)))) => 0; // traverse, finding tags and weights lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, @@ -13536,7 +13536,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("unrelated", 9)))) => 0; + LFSR_DATA_BUF("unrelated", 9)))) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -13550,16 +13550,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)), + LFSR_DATA_BUF(names[perm[j] % 6], 2)), LFSR_ATTR( LFSR_TAG_GROW, +W-1, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -13658,7 +13658,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(3), 0, - LFSR_CAT_BUF("unrelated", 9)))) => 0; + LFSR_DATA_BUF("unrelated", 9)))) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -13672,16 +13672,16 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)), + LFSR_DATA_BUF(names[perm[j] % 6], 2)), LFSR_ATTR( LFSR_TAG_GROW, +W-1, - LFSR_CAT_NULL()), + LFSR_DATA_NULL()), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -13799,7 +13799,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +W, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -13823,7 +13823,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_GROW, +D, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(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; @@ -13931,7 +13931,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +W, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -13957,7 +13957,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_GROW | LFSR_TAG_REG, +D, - LFSR_CAT_BUF(names[j % 6], 6)))) => 0; + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14075,7 +14075,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), +W, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -14101,7 +14101,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_GROW | LFSR_TAG_UATTR(1), +D, - LFSR_CAT_BUF(names[j % 6], 6)))) => 0; + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14232,7 +14232,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +W, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -14256,7 +14256,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_GROW, -D, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(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; @@ -14364,7 +14364,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +W, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -14390,7 +14390,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_GROW | LFSR_TAG_REG, -D, - LFSR_CAT_BUF(names[j % 6], 6)))) => 0; + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W-D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14508,7 +14508,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(2), +W, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -14534,7 +14534,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_GROW | LFSR_TAG_UATTR(1), -D, - LFSR_CAT_BUF(names[j % 6], 6)))) => 0; + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W-D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14664,7 +14664,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +W, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -14688,7 +14688,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(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; @@ -14724,7 +14724,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +W, - LFSR_CAT_BUF(names[j % 6], 6)))) => 0; + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14828,7 +14828,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +W, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -14855,7 +14855,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF(names[j % 6], 2)))) => 0; + LFSR_DATA_BUF(names[j % 6], 2)))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14888,7 +14888,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14916,7 +14916,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF(names[j % 6], 2)))) => 0; + LFSR_DATA_BUF(names[j % 6], 2)))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15029,14 +15029,14 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else if (op == 1) { // update our sim 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } else if (op == 2) { // update our sim sim[rid*(M+1) + u+1] = 'a'+(i % 26); @@ -15044,7 +15044,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(u), 0, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else if (op == 3) { // update our sim @@ -15053,7 +15053,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(u), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; } } @@ -15203,7 +15203,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +weight, - LFSR_CAT_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else if (op == 1) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -15214,7 +15214,7 @@ code = ''' count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS( - LFSR_ATTR(LFSR_TAG_RM, -weight_, LFSR_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()))) => 0; } else if (op == 2) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -15222,7 +15222,7 @@ code = ''' 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_GROW, +weight, LFSR_DATA_NULL()))) => 0; } else if (op == 3) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -15233,7 +15233,7 @@ code = ''' 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_GROW, -weight, LFSR_DATA_NULL()))) => 0; } } @@ -15367,10 +15367,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -15457,10 +15457,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -15487,7 +15487,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_UATTR, 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15601,10 +15601,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -15632,7 +15632,7 @@ code = ''' LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[j % 6], 3)))) => 0; + LFSR_DATA_BUF(names[j % 6], 3)))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15747,13 +15747,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)), + LFSR_DATA_BUF(names[perm[j] % 6], 2)), LFSR_ATTR( LFSR_TAG_SATTR(0), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 1)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; } assert(rbyd.weight == N); @@ -15840,13 +15840,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)), + LFSR_DATA_BUF(names[perm[j] % 6], 2)), LFSR_ATTR( LFSR_TAG_SATTR(0), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 1)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; } assert(rbyd.weight == N); @@ -15873,7 +15873,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_UATTR, 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15994,13 +15994,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)), + LFSR_DATA_BUF(names[perm[j] % 6], 2)), LFSR_ATTR( LFSR_TAG_SATTR(0), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 1)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; } assert(rbyd.weight == N); @@ -16028,7 +16028,7 @@ code = ''' LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[j % 6], 3)))) => 0; + LFSR_DATA_BUF(names[j % 6], 3)))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16150,7 +16150,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -16237,7 +16237,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -16264,7 +16264,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_UATTR, 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16381,7 +16381,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -16409,7 +16409,7 @@ code = ''' LFSR_ATTR( LFSR_TAG_SUB | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[j % 6], 6)))) => 0; + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16518,10 +16518,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -16608,10 +16608,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -16638,7 +16638,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_SUP | LFSR_TAG_UATTR, 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16752,10 +16752,10 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF(names[perm[j] % 6], 4)), + LFSR_DATA_BUF(names[perm[j] % 6], 4)), LFSR_ATTR( LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -16783,7 +16783,7 @@ code = ''' LFSR_ATTR( LFSR_TAG_SUP | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f), 0, - LFSR_CAT_BUF(names[j % 6], 3)))) => 0; + LFSR_DATA_BUF(names[j % 6], 3)))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16864,13 +16864,13 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(0), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -16912,23 +16912,23 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(0), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0, - LFSR_CAT_NULL()))) => 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_TAG_RM | LFSR_TAG_UATTR(1), 0, - LFSR_CAT_NULL()))) => 0; + LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -16970,22 +16970,22 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(0), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0, - LFSR_CAT_NULL()))) => 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_CAT_NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); // can we still access things? @@ -17027,23 +17027,23 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(0), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_SATTR(0), 0, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0, - LFSR_CAT_NULL()))) => 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_TAG_SUB | LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -17094,24 +17094,24 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_UATTR(0), 0, - LFSR_CAT_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR( LFSR_TAG_UATTR(1), 0, - LFSR_CAT_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR( LFSR_TAG_REG, +1, - LFSR_CAT_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0, - LFSR_CAT_NULL()))) => 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_TAG_SUP | LFSR_TAG_UATTR(2), 0, - LFSR_CAT_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 1); // can we still access things?