From 919113f6c4e122f3e0ef57e9605db73339793263 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Mon, 10 Feb 2025 04:53:35 -0600 Subject: [PATCH] Fully adopted lazy attr encoding This fully adopts LFSR_RATTR__ and friends: - LFSR_RATTR -> LFSR_RATTR__ or LFSR_RATTR_DATA__ - LFSR_RATTR_BUF -> LFSR_RATTR__ - LFSR_RATTR_CAT -> LFSR_RATTR_CAT__ - LFSR_RATTR_NOOP -> LFSR_RATTR_NOOP__ - LFSR_RATTR_NAME -> LFSR_RATTR_NAME__ Note the new LFSR_RATTR__ macro also lets us a drop the special rattr macros, at the cost of a bit less type safety: - LFSR_RATTR_RATTRS -> LFSR_RATTR__ - LFSR_RATTR_MOVE -> LFSR_RATTR__ - LFSR_RATTR_GRM -> LFSR_RATTR__ (we weren't using this?) - LFSR_RATTR_SHRUBCOMMIT -> LFSR_RATTR__ Curiously, this ended up adding ~88 bytes to lfsr_file_carve: function (0 added, 0 removed) osize nsize dsize lfsr_file_carve 1228 1316 +88 (+7.2%) lfsr_mdir_commit 2144 2152 +8 (+0.4%) lfsr_mdir_commit__ 1192 1188 -4 (-0.3%) lfsr_file_truncate 184 182 -2 (-1.1%) lfsr_mount 98 96 -2 (-2.0%) TOTAL 35508 35596 +88 (+0.2%) I'm really not sure why, all I can think of is maybe the change from a forced-inline function to a macro added a bunch of compiler noise? Still, 80 bytes is not worth two competing LFSR_RATTR APIs. Though it may be worth looking into this in the future. Total code changes: code stack ctx before: 35508 2472 636 after: 35596 (+0.2%) 2472 (+0.0%) 636 (+0.0%) --- lfs.c | 278 ++-- tests/test_badblocks.toml | 12 +- tests/test_btree.toml | 488 +++--- tests/test_files.toml | 30 +- tests/test_mount.toml | 88 +- tests/test_mtree.toml | 128 +- tests/test_paths.toml | 150 +- tests/test_rbyd.toml | 3206 ++++++++++++++++++------------------- 8 files changed, 2156 insertions(+), 2224 deletions(-) diff --git a/lfs.c b/lfs.c index b5bda9e0..a64d9e39 100644 --- a/lfs.c +++ b/lfs.c @@ -2140,18 +2140,11 @@ typedef struct lfsr_rattr { #define LFSR_RATTR__(_tag, _weight, _etc, _data_count) \ ((lfsr_rattr_t){ \ .tag=_tag, \ - .data_count=_data_count, \ + .data_count=(uint16_t){_data_count}, \ .weight=_weight, \ /* TODO why does assigning to .u.etc add ~100 bytes of code? */ \ .u.cat=_etc}) -#define LFSR_RATTR_BUF__(_tag, _weight, _buffer, _size) \ - ((lfsr_rattr_t){ \ - .tag=_tag, \ - .data_count=_size, \ - .weight=_weight, \ - .u.buffer=(const void*)(_buffer)}) - #define LFSR_RATTR_DATA__(_tag, _weight, _data) \ ((lfsr_rattr_t){ \ .tag=_tag, \ @@ -2162,7 +2155,7 @@ typedef struct lfsr_rattr { #define LFSR_RATTR_CAT___(_tag, _weight, _datas, _data_count) \ ((lfsr_rattr_t){ \ .tag=_tag, \ - .data_count=-(_data_count), \ + .data_count=-(uint16_t){_data_count}, \ .weight=_weight, \ .u.datas=_datas}) @@ -2216,47 +2209,6 @@ typedef struct lfsr_name { .name=_name, \ .name_len=_name_len})) -// TODO rm me -#define LFSR_RATTR_(_tag, _weight, _cat, _count) \ - ((lfsr_rattr_t){ \ - .tag=_tag, \ - .data_count=(uint16_t){_count}, \ - .weight=_weight, \ - .u.cat=_cat}) - -#define LFSR_RATTR(_tag, _weight, _data) \ - ((struct {lfsr_rattr_t a;}){lfsr_rattr(_tag, _weight, _data)}.a) - -LFS_FORCEINLINE -static inline lfsr_rattr_t lfsr_rattr( - lfsr_tag_t tag, lfsr_srid_t weight, lfsr_data_t data) { - // only simple data works here - LFS_ASSERT(lfsr_data_isbuf(data)); - LFS_ASSERT(lfsr_data_size(data) <= 0x7fff); - return (lfsr_rattr_t){ - .tag=tag, - .data_count=lfsr_data_size(data), - .weight=weight, - .u.cat=data.u.buffer}; -} - -#define LFSR_RATTR_CAT_(_tag, _weight, _datas, _data_count) \ - ((lfsr_rattr_t){ \ - .tag=_tag, \ - .data_count=-(uint16_t){_data_count}, \ - .weight=_weight, \ - .u.cat=_datas}) - -#define LFSR_RATTR_CAT(_tag, _weight, ...) \ - LFSR_RATTR_CAT_( \ - _tag, \ - _weight, \ - ((const lfsr_data_t[]){__VA_ARGS__}), \ - sizeof((const lfsr_data_t[]){__VA_ARGS__}) / sizeof(lfsr_data_t)) - -#define LFSR_RATTR_NOOP() \ - LFSR_RATTR_(LFSR_TAG_NULL, 0, NULL, 0) - // create an attribute list #define LFSR_RATTRS(...) \ (const lfsr_rattr_t[]){__VA_ARGS__}, \ @@ -2309,49 +2261,6 @@ static inline lfs_size_t lfsr_rattr_dsize(lfsr_rattr_t rattr) { } } -// TODO still need all these? -// special rattrs - here be hacks - -// helper macro for did+name pairs -#define LFSR_RATTR_NAME(_tag, _weight, _did, _name, _name_len) \ - LFSR_RATTR_CAT( \ - _tag, \ - _weight, \ - LFSR_DATA_LEB128(_did, (uint8_t[LFSR_LEB128_DSIZE]){0}), \ - LFSR_DATA_BUF(_name, _name_len)) - -// hacky rattrs - these end up handled as special cases in high-level -// commit layers - -// chain another rattr-list, only allowed as last rattr -#define LFSR_RATTR_RATTRS(_tag, _weight, _rattrs, _rattr_count) \ - LFSR_RATTR_(_tag, _weight, (const lfsr_rattr_t*){_rattrs}, _rattr_count) - -// chain a list of user attributes, these require a bit of last-minute -// reencoding during commits -#define LFSR_RATTR_ATTRS(_tag, _weight, _attrs, _attr_count) \ - LFSR_RATTR_(_tag, _weight, (const struct lfs_attr*){_attrs}, _attr_count) - -// a move of all rattrs from an mdir entry -#define LFSR_RATTR_MOVE(_tag, _weight, _mdir) \ - LFSR_RATTR_(_tag, _weight, (const lfsr_mdir_t*){_mdir}, 0) - -// a grm update, note this is mutable! we may update the grm during -// mdir commits -#define LFSR_RATTR_GRM(_tag, _weight, _grm) \ - LFSR_RATTR_(_tag, _weight, (const lfsr_grm_t*){_grm}, 0) - -// writing to an unrelated trunk in the rbyd -typedef struct lfsr_shrubcommit lfsr_shrubcommit_t; -#define LFSR_RATTR_SHRUBCOMMIT(_tag, _weight, \ - _bshrub, _rid, _rattrs, _rattr_count) \ - LFSR_RATTR_(_tag, _weight, \ - (&(const lfsr_shrubcommit_t){ \ - .bshrub=_bshrub, \ - .rid=_rid, \ - .rattrs=_rattrs, \ - .rattr_count=_rattr_count}), \ - 0) // operations on custom attribute lists @@ -4313,11 +4222,11 @@ trunk:; } // terminate diverged trunk with an unreachable tag - err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR( + err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR__( (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | LFSR_TAG_NULL, 0, - LFSR_DATA_NULL())); + NULL, 0)); if (err) { return err; } @@ -4428,7 +4337,7 @@ leaf:; // // note we always need a non-alt to terminate the trunk, otherwise we // can't find trunks during fetch - err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR_( + err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR__( // mark as shrub if we are a shrub (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) // rm => null, otherwise strip off control bits @@ -4756,7 +4665,7 @@ static int lfsr_rbyd_appendcompactrattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // write the tag - err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR_( + err = lfsr_rbyd_appendrattr_(lfs, rbyd, LFSR_RATTR__( (lfsr_rbyd_isshrub(rbyd) ? LFSR_TAG_SHRUB : 0) | rattr.tag, rattr.weight, rattr.u.cat, rattr.data_count)); @@ -4792,8 +4701,8 @@ static int lfsr_rbyd_appendcompactrbyd(lfs_t *lfs, lfsr_rbyd_t *rbyd_, } // write the tag - err = lfsr_rbyd_appendcompactrattr(lfs, rbyd_, LFSR_RATTR_CAT_( - tag, weight, &data, 1)); + err = lfsr_rbyd_appendcompactrattr(lfs, rbyd_, LFSR_RATTR_DATA__( + tag, weight, &data)); if (err) { return err; } @@ -5856,9 +5765,9 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, LFSR_TAG_BRANCH, +sibling.weight, &bscratch->branches[1], LFSR_BRANCH_DSIZE); if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { - bscratch->rattrs[rattr_count_++] = LFSR_RATTR_CAT_( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR_DATA__( LFSR_TAG_NAME, 0, - &bscratch->split_data, 1); + &bscratch->split_data); } // split root? } else { @@ -5868,18 +5777,18 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, LFSR_TAG_BRANCH, 0, &bscratch->branches[0], LFSR_BRANCH_DSIZE); if (rbyd__.weight != rbyd_.weight) { - bscratch->rattrs[rattr_count_++] = LFSR_RATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR__( LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight, - LFSR_DATA_NULL()); + NULL, 0); } bscratch->branches[1] = sibling; bscratch->rattrs[rattr_count_++] = LFSR_RATTR__( LFSR_TAG_BRANCH, +sibling.weight, &bscratch->branches[1], LFSR_BRANCH_DSIZE); if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { - bscratch->rattrs[rattr_count_++] = LFSR_RATTR_CAT_( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR_DATA__( LFSR_TAG_NAME, 0, - &bscratch->split_data, 1); + &bscratch->split_data); } } rattrs_ = bscratch->rattrs; @@ -5954,16 +5863,16 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, LFS_ASSERT(rbyd__.weight > 0); rattr_count_ = 0; bid_ -= pid - (rbyd_.weight-1); - bscratch->rattrs[rattr_count_++] = LFSR_RATTR( - LFSR_TAG_RM, -sibling.weight, LFSR_DATA_NULL()); + bscratch->rattrs[rattr_count_++] = LFSR_RATTR__( + LFSR_TAG_RM, -sibling.weight, NULL, 0); bscratch->branches[0] = rbyd__; bscratch->rattrs[rattr_count_++] = LFSR_RATTR__( LFSR_TAG_BRANCH, 0, &bscratch->branches[0], LFSR_BRANCH_DSIZE); if (rbyd__.weight != rbyd_.weight) { - bscratch->rattrs[rattr_count_++] = LFSR_RATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR__( LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight, - LFSR_DATA_NULL()); + NULL, 0); } rattrs_ = bscratch->rattrs; @@ -5994,17 +5903,17 @@ static int lfsr_btree_commit__(lfs_t *lfs, lfsr_btree_t *btree, rattr_count_ = 0; bid_ -= pid - (rbyd_.weight-1); if (rbyd__.weight == 0) { - bscratch->rattrs[rattr_count_++] = LFSR_RATTR( - LFSR_TAG_RM, -rbyd_.weight, LFSR_DATA_NULL()); + bscratch->rattrs[rattr_count_++] = LFSR_RATTR__( + LFSR_TAG_RM, -rbyd_.weight, NULL, 0); } else { bscratch->branches[0] = rbyd__; bscratch->rattrs[rattr_count_++] = LFSR_RATTR__( LFSR_TAG_BRANCH, 0, &bscratch->branches[0], LFSR_BRANCH_DSIZE); if (rbyd__.weight != rbyd_.weight) { - bscratch->rattrs[rattr_count_++] = LFSR_RATTR( + bscratch->rattrs[rattr_count_++] = LFSR_RATTR__( LFSR_TAG_GROW, -rbyd_.weight + rbyd__.weight, - LFSR_DATA_NULL()); + NULL, 0); } } rattrs_ = bscratch->rattrs; @@ -6388,12 +6297,12 @@ static int lfsr_shrub_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd_, } // this is needed to sneak shrub commits into mdir commits -struct lfsr_shrubcommit { +typedef struct lfsr_shrubcommit { lfsr_bshrub_t *bshrub; lfsr_srid_t rid; const lfsr_rattr_t *rattrs; lfs_size_t rattr_count; -}; +} lfsr_shrubcommit_t; static int lfsr_shrub_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd_, lfsr_shrub_t *shrub, lfsr_srid_t rid, @@ -6610,9 +6519,13 @@ static int lfsr_bshrub_commit_(lfs_t *lfs, lfsr_bshrub_t *bshrub, // commit to shrub int err = lfsr_mdir_commit(lfs, &bshrub->o.mdir, LFSR_RATTRS( - LFSR_RATTR_SHRUBCOMMIT( - LFSR_TAG_SHRUBCOMMIT, 0, - bshrub, bid, rattrs, rattr_count))); + LFSR_RATTR__( + LFSR_TAG_SHRUBCOMMIT, 0, + (&(lfsr_shrubcommit_t){ + .bshrub=bshrub, + .rid=bid, + .rattrs=rattrs, + .rattr_count=rattr_count}), 0))); if (err) { return err; } @@ -7173,12 +7086,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 = lfs_memlen(grmdelta_, LFSR_GRM_DSIZE); - err = lfsr_rbyd_appendrattr(lfs, rbyd, -1, LFSR_RATTR( + err = lfsr_rbyd_appendrattr(lfs, rbyd, -1, LFSR_RATTR__( // opportunistically remove this tag if delta is all zero (size == 0) ? LFSR_TAG_RM | LFSR_TAG_GRMDELTA : LFSR_TAG_GRMDELTA, 0, - LFSR_DATA_BUF(grmdelta_, size))); + grmdelta_, size)); if (err) { return err; } @@ -7717,7 +7630,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } else { err = lfsr_rbyd_appendrattr(lfs, &mdir->rbyd, rid - lfs_smax(start_rid, 0), - LFSR_RATTR_CAT_(tag, 0, &data, 1)); + LFSR_RATTR_DATA__(tag, 0, &data)); if (err) { return err; } @@ -7782,15 +7695,14 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, rid - lfs_smax(start_rid, 0), // removing or updating? (lfsr_attr_isnoattr(&attrs_[j])) - ? LFSR_RATTR( + ? LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(attrs_[j].type), 0, - LFSR_DATA_NULL()) - : LFSR_RATTR( + NULL, 0) + : LFSR_RATTR__( LFSR_TAG_ATTR(attrs_[j].type), 0, - LFSR_DATA_BUF( - attrs_[j].buffer, - lfsr_attr_size(&attrs_[j])))); + attrs_[j].buffer, + lfsr_attr_size(&attrs_[j]))); if (err) { return err; } @@ -8053,7 +7965,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, } else { // write the tag err = lfsr_rbyd_appendcompactrattr(lfs, &mdir_->rbyd, - LFSR_RATTR_CAT_(tag, weight, &data, 1)); + LFSR_RATTR_DATA__(tag, weight, &data)); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -8491,9 +8403,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, LFSR_RATTR__( LFSR_TAG_MDIR, +(1 << lfs->mdir_bits), mdir_[0].rbyd.blocks, LFSR_MPTR_DSIZE), - LFSR_RATTR_CAT_( + LFSR_RATTR_DATA__( LFSR_TAG_NAME, +(1 << lfs->mdir_bits), - &split_data, 1), + &split_data), LFSR_RATTR__( LFSR_TAG_MDIR, 0, mdir_[1].rbyd.blocks, LFSR_MPTR_DSIZE))); @@ -8511,9 +8423,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, LFSR_RATTR__( LFSR_TAG_MDIR, 0, mdir_[0].rbyd.blocks, LFSR_MPTR_DSIZE), - LFSR_RATTR_CAT_( + LFSR_RATTR_DATA__( LFSR_TAG_NAME, +(1 << lfs->mdir_bits), - &split_data, 1), + &split_data), LFSR_RATTR__( LFSR_TAG_MDIR, 0, mdir_[1].rbyd.blocks, LFSR_MPTR_DSIZE))); @@ -8548,9 +8460,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree err = lfsr_btree_commit(lfs, &mtree_, lfsr_mid_bid(lfs, mdir->mid), LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM, -(1 << lfs->mdir_bits), - LFSR_DATA_NULL()))); + NULL, 0))); if (err) { goto failed; } @@ -8645,10 +8557,10 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, &mtree_, LFSR_BTREE_DSIZE), // were we committing to the mroot? include any -1 rattrs (mdir->mid == -1) - ? LFSR_RATTR_RATTRS( + ? LFSR_RATTR__( LFSR_TAG_RATTRS, 0, rattrs, rattr_count) - : LFSR_RATTR_NOOP())); + : LFSR_RATTR_NOOP__())); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); goto failed; @@ -8736,9 +8648,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, err = lfsr_mdir_commit__(lfs, &mrootanchor_, -2, -1, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_MAGIC, 0, - LFSR_DATA_BUF("littlefs", 8)), + "littlefs", 8), LFSR_RATTR__( LFSR_TAG_MROOT, 0, mrootchild_.rbyd.blocks, LFSR_MPTR_DSIZE))); @@ -10250,8 +10162,8 @@ int lfsr_remove(lfs_t *lfs, const char *path) { ? LFSR_RATTR_NAME__( LFSR_TAG_SUP | LFSR_TAG_STICKYNOTE, 0, did, path, lfsr_path_namelen(path)) - : LFSR_RATTR( - LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); + : LFSR_RATTR__( + LFSR_TAG_RM, -1, NULL, 0))); if (err) { return err; } @@ -10417,7 +10329,7 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) { LFSR_RATTR_NAME__( LFSR_TAG_SUP | old_tag, (!exists) ? +1 : 0, new_did, new_path, new_name_len), - LFSR_RATTR_MOVE(LFSR_TAG_MOVE, 0, &old_mdir))); + LFSR_RATTR__(LFSR_TAG_MOVE, 0, &old_mdir, 0))); if (err) { return err; } @@ -10858,9 +10770,9 @@ int lfsr_setattr(lfs_t *lfs, const char *path, uint8_t type, // commit our attr lfs_alloc_ckpoint(lfs); err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(type), 0, - LFSR_DATA_BUF(buffer, size)))); + buffer, size))); if (err) { return err; } @@ -10910,9 +10822,9 @@ int lfsr_removeattr(lfs_t *lfs, const char *path, uint8_t type) { // commit our removal lfs_alloc_ckpoint(lfs); err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(type), 0, - LFSR_DATA_NULL()))); + NULL, 0))); if (err) { return err; } @@ -11521,16 +11433,16 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // can we coalesce? if (file->b.shrub.weight > 0) { bid = lfs_min(bid, file->b.shrub.weight-1); - rattrs[rattr_count++] = LFSR_RATTR( + rattrs[rattr_count++] = LFSR_RATTR__( LFSR_TAG_GROW, +(pos - file->b.shrub.weight), - LFSR_DATA_NULL()); + NULL, 0); // new hole } else { bid = lfs_min(bid, file->b.shrub.weight); - rattrs[rattr_count++] = LFSR_RATTR( + rattrs[rattr_count++] = LFSR_RATTR__( LFSR_TAG_DATA, +(pos - file->b.shrub.weight), - LFSR_DATA_NULL()); + NULL, 0); } } @@ -11577,10 +11489,10 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, -1); err = lfsr_file_commit(lfs, file, bid, LFSR_RATTRS( - LFSR_RATTR_CAT( + LFSR_RATTR_DATA__( LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA, -(weight_ - lfs->cfg->fragment_size), - LFSR_DATA_TRUNCATE(left.data, + &LFSR_DATA_TRUNCATE(left.data, lfs->cfg->fragment_size)), LFSR_RATTR__( LFSR_TAG_BLOCK, @@ -11610,10 +11522,10 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_BLOCK, -(weight_ - lfsr_data_size(bptr_.data)), &bptr_, LFSR_BPTR_DSIZE), - LFSR_RATTR_CAT( + LFSR_RATTR_DATA__( LFSR_TAG_DATA, +(weight_ - lfsr_data_size(bptr_.data)), - LFSR_DATA_FRUNCATE(right.data, + &LFSR_DATA_FRUNCATE(right.data, lfs->cfg->fragment_size)))); if (err) { return err; @@ -11630,15 +11542,15 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, if (bid-(weight_-1) < pos) { // can we get away with a grow attribute? if (lfsr_data_size(bptr_.data) == lfsr_data_size(left.data)) { - rattrs[rattr_count++] = LFSR_RATTR( - LFSR_TAG_GROW, -(bid+1 - pos), LFSR_DATA_NULL()); + rattrs[rattr_count++] = LFSR_RATTR__( + LFSR_TAG_GROW, -(bid+1 - pos), NULL, 0); // carve fragment? } else if (!lfsr_bptr_isbptr(&bptr_)) { - rattrs[rattr_count++] = LFSR_RATTR_CAT_( + rattrs[rattr_count++] = LFSR_RATTR_DATA__( LFSR_TAG_GROW | LFSR_TAG_SUB | LFSR_TAG_DATA, -(bid+1 - pos), - &left.data, 1); + &left.data); // carve bptr? } else { @@ -11650,8 +11562,8 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // completely overwriting this entry? } else { - rattrs[rattr_count++] = LFSR_RATTR( - LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()); + rattrs[rattr_count++] = LFSR_RATTR__( + LFSR_TAG_RM, -weight_, NULL, 0); } // spans more than one entry? we can't do everything in one commit, @@ -11680,9 +11592,9 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // carve fragment? } else if (!lfsr_bptr_isbptr(&bptr_)) { - right_rattr_ = LFSR_RATTR_CAT_( + right_rattr_ = LFSR_RATTR_DATA__( LFSR_TAG_DATA, bid+1 - (pos+weight), - &right.data, 1); + &right.data); // carve bptr? } else { @@ -11702,21 +11614,21 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // can we coalesce a hole? if (lfsr_rattr_dsize(rattr) == 0 && pos > 0) { bid = lfs_min(bid, file->b.shrub.weight-1); - rattrs[rattr_count++] = LFSR_RATTR( + rattrs[rattr_count++] = LFSR_RATTR__( LFSR_TAG_GROW, +(weight + rattr.weight), - LFSR_DATA_NULL()); + NULL, 0); // need a new hole? } else if (lfsr_rattr_dsize(rattr) == 0) { bid = lfs_min(bid, file->b.shrub.weight); - rattrs[rattr_count++] = LFSR_RATTR( + rattrs[rattr_count++] = LFSR_RATTR__( LFSR_TAG_DATA, +(weight + rattr.weight), - LFSR_DATA_NULL()); + NULL, 0); // append new fragment/bptr? } else { bid = lfs_min(bid, file->b.shrub.weight); - rattrs[rattr_count++] = LFSR_RATTR_( + rattrs[rattr_count++] = LFSR_RATTR__( rattr.tag, +(weight + rattr.weight), rattr.u.cat, rattr.data_count); } @@ -12239,7 +12151,7 @@ fragment:; // our tree int err = lfsr_file_carve(lfs, file, fragment_start, fragment_end - fragment_start, - LFSR_RATTR_CAT_( + LFSR_RATTR_CAT___( LFSR_TAG_DATA, 0, datas, data_count)); if (err && err != LFS_ERR_RANGE) { @@ -12482,9 +12394,9 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { goto failed; } - rattrs[rattr_count++] = LFSR_RATTR_CAT_( + rattrs[rattr_count++] = LFSR_RATTR_DATA__( LFSR_TAG_SUB | LFSR_TAG_REG, 0, - &name_data, 1); + &name_data); } // pending file changes? @@ -12501,9 +12413,9 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { // no bshrub/btree? if (lfsr_bshrub_isbnull(&file->b)) { - rattrs[rattr_count++] = LFSR_RATTR( + rattrs[rattr_count++] = LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_STRUCT, 0, - LFSR_DATA_NULL()); + NULL, 0); // bshrub? } else if (lfsr_bshrub_isbshrub(&file->b)) { rattrs[rattr_count++] = LFSR_RATTR__( @@ -12559,7 +12471,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { } if (attrs) { // need to append custom attributes - rattrs[rattr_count++] = LFSR_RATTR_ATTRS( + rattrs[rattr_count++] = LFSR_RATTR__( LFSR_TAG_ATTRS, 0, file->cfg->attrs, file->cfg->attr_count); } @@ -12770,9 +12682,9 @@ int lfsr_file_truncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { // truncate our btree err = lfsr_file_carve(lfs, file, lfs_min(size, size_), size - lfs_min(size, size_), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +size_ - size, - LFSR_DATA_NULL())); + NULL, 0)); if (err) { goto failed; } @@ -12827,9 +12739,9 @@ int lfsr_file_fruncate(lfs_t *lfs, lfsr_file_t *file, lfs_off_t size_) { // fruncate our btree err = lfsr_file_carve(lfs, file, 0, lfs_smax(size - size_, 0), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +size_ - size, - LFSR_DATA_NULL())); + NULL, 0)); if (err) { goto failed; } @@ -13919,14 +13831,14 @@ static int lfsr_formatinited(lfs_t *lfs) { // - any format-time configuration // - the root's bookmark tag, which reserves did = 0 for the root err = lfsr_rbyd_appendrattrs(lfs, &rbyd, -1, -1, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_MAGIC, 0, - LFSR_DATA_BUF("littlefs", 8)), - LFSR_RATTR( + "littlefs", 8), + LFSR_RATTR__( LFSR_TAG_VERSION, 0, - LFSR_DATA_BUF(((const uint8_t[2]){ + ((const uint8_t[2]){ LFS_DISK_VERSION_MAJOR, - LFS_DISK_VERSION_MINOR}), 2)), + LFS_DISK_VERSION_MINOR}), 2), LFSR_RATTR_LE32__( LFSR_TAG_RCOMPAT, 0, LFSR_RCOMPAT_COMPAT), @@ -14142,7 +14054,7 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) { lfs_alloc_ckpoint(lfs); // remove the rid while atomically updating our grm err = lfsr_mdir_commit(lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))); if (err) { // revert grm manually lfs->grm = grm_p; @@ -14185,7 +14097,7 @@ static int lfsr_mdir_mkconsistent(lfs_t *lfs, lfsr_mdir_t *mdir) { lfs_alloc_ckpoint(lfs); err = lfsr_mdir_commit(lfs, mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))); if (err) { goto failed; } diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml index 62ed7555..2f9ca165 100644 --- a/tests/test_badblocks.toml +++ b/tests/test_badblocks.toml @@ -76,9 +76,9 @@ code = ''' // add to btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -1851,9 +1851,9 @@ code = ''' // add to btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -3626,9 +3626,9 @@ code = ''' // add to btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); diff --git a/tests/test_btree.toml b/tests/test_btree.toml index 841c0720..ac3ca9dc 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -55,7 +55,7 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "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_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "a", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "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_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "b", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "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_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "a", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "b", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "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_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "c", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "b", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "a", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -321,9 +321,9 @@ code = ''' lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -372,9 +372,9 @@ code = ''' lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1)))) => 0; + &(uint8_t){'a'+((N-1-i) % 26)}, 1))) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -438,9 +438,9 @@ code = ''' // add to btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -508,9 +508,9 @@ code = ''' lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -600,9 +600,9 @@ code = ''' // add to btree lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +weight, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -711,12 +711,12 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "a", 1))) => 0; // update the tree lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("A", 1)))) => 0; + "A", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -757,18 +757,18 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "a", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "b", 1))) => 0; // update the tree lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("A", 1)))) => 0; + "A", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("B", 1)))) => 0; + "B", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -816,24 +816,24 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "a", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "b", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "c", 1))) => 0; // update the tree lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("A", 1)))) => 0; + "A", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("B", 1)))) => 0; + "B", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("C", 1)))) => 0; + "C", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -890,16 +890,16 @@ code = ''' lfsr_btree_init(&btree); for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // update the tree for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0; + &(uint8_t){'A'+(i % 26)}, 1))) => 0; } printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -948,9 +948,9 @@ code = ''' lfsr_btree_init(&btree); for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // set up a simulation to compare against @@ -969,9 +969,9 @@ code = ''' // update btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0; + &(uint8_t){'A'+(i % 26)}, 1))) => 0; // update sim sim[bid] = 'A'+(i % 26); @@ -1035,16 +1035,16 @@ code = ''' lfsr_btree_init(&btree); for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // update the tree for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0; + &(uint8_t){'A'+(i % 26)}, 1))) => 0; } printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -1109,9 +1109,9 @@ code = ''' lfsr_btree_init(&btree); for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // set up a simulation to compare against @@ -1141,12 +1141,12 @@ code = ''' // update btree lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)), - LFSR_RATTR( + &(uint8_t){'A'+(i % 26)}, 1), + LFSR_RATTR__( LFSR_TAG_GROW, +weight-sim_weights[bid], - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // update sim sim[bid] = 'A'+(i % 26); @@ -1252,10 +1252,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "a", 1))) => 0; // pop! lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1273,7 +1273,7 @@ code = ''' // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "A", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1309,12 +1309,12 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "a", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "b", 1))) => 0; // pop! lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1339,7 +1339,7 @@ code = ''' // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("B", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "B", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1382,12 +1382,12 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "a", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "b", 1))) => 0; // pop! lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1412,7 +1412,7 @@ code = ''' // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "A", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1455,14 +1455,14 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "a", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "b", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "c", 1))) => 0; // pop! lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1494,7 +1494,7 @@ code = ''' // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("C", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "C", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1548,14 +1548,14 @@ code = ''' lfsr_btree_init(&btree); for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { lfsr_btree_commit(&lfs, &btree, N-1-i, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; } printf("btree: w%d 0x%x.%x\n", @@ -1585,7 +1585,7 @@ code = ''' // try recovering lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "R", 1))) => 0; for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_lookup(&lfs, &btree, i, @@ -1628,14 +1628,14 @@ code = ''' lfsr_btree_init(&btree); for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; } printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -1665,7 +1665,7 @@ code = ''' // try recovering lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "R", 1))) => 0; lfsr_btree_lookup(&lfs, &btree, 0, &tag_, &weight_, &data_) => 0; @@ -1711,9 +1711,9 @@ code = ''' lfsr_btree_init(&btree); for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // set up a simulation to compare against @@ -1733,7 +1733,7 @@ code = ''' // remove from btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; // remove from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -1800,14 +1800,14 @@ code = ''' lfsr_btree_init(&btree); for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { lfsr_btree_commit(&lfs, &btree, (N-1-i)*W+W-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -W, NULL, 0))) => 0; } printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -1836,7 +1836,7 @@ code = ''' // try recovering lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("R", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +W, "R", 1))) => 0; for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_lookup(&lfs, &btree, i*W+W-1, @@ -1927,9 +1927,9 @@ code = ''' } lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +weight, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; sim[i] = 'a'+(i % 26); sim_weights[i] = weight; @@ -1949,9 +1949,9 @@ code = ''' // remove from btree lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM, -sim_weights[bid], - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // remove from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -2057,18 +2057,18 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; + &(uint8_t){'a'+(0 % 26)}, 1))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), - LFSR_RATTR( + &(uint8_t){'a'+((i-1) % 26)}, 1), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))) => 0; + &(uint8_t){'a'+((i-0) % 26)}, 1))) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -2117,7 +2117,7 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "_", 1))) => 0; // set up a simulation to compare against // @@ -2135,12 +2135,12 @@ code = ''' // split btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), - LFSR_RATTR( + &(uint8_t){'a'+(i % 26)}, 1), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0; + &(uint8_t){'A'+(i % 26)}, 1))) => 0; // split sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -2207,18 +2207,18 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; + &(uint8_t){'a'+(0 % 26)}, 1))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), - LFSR_RATTR( + &(uint8_t){'a'+((i-1) % 26)}, 1), + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))) => 0; + &(uint8_t){'a'+((i-0) % 26)}, 1))) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -2268,7 +2268,7 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +W, "_", 1))) => 0; // set up a simulation to compare against // @@ -2299,15 +2299,15 @@ code = ''' // split btree lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_GROW, +weight1-sim_weights[bid], - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), - LFSR_RATTR( + &(uint8_t){'a'+(i % 26)}, 1), + LFSR_RATTR__( LFSR_TAG_DATA, +weight2, - LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))) => 0; + &(uint8_t){'A'+(i % 26)}, 1))) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -2449,27 +2449,27 @@ code = ''' // the extra push here avoids trying to inline the big entry lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "_", 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_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, buf1, SIZE), + LFSR_RATTR__(LFSR_TAG_DATA, +1, buf2, SIZE))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(buf2, SIZE)))) => 0; + 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_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2517,21 +2517,21 @@ code = ''' // the extra push here avoids trying to inline the big entry lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "_", 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_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, buf1, SIZE), + LFSR_RATTR__(LFSR_TAG_DATA, +1, buf2, SIZE))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(buf2, SIZE)))) => 0; + buf2, SIZE))) => 0; assert(btree.weight == 2); // now remove one entry, since this brings the rbyd down this zero, @@ -2540,7 +2540,7 @@ code = ''' // do this while forcing a compaction btree.eoff = -1; lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2588,14 +2588,14 @@ code = ''' // the extra push here avoids trying to inline the big entry lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "_", 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_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, buf1, SIZE), + LFSR_RATTR__(LFSR_TAG_DATA, +1, 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 @@ -2604,7 +2604,7 @@ code = ''' // btree.eoff = -1; lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2652,38 +2652,38 @@ code = ''' // the extra push here avoids trying to inline the big entry lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "_", 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_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, buf1, SIZE), + LFSR_RATTR__(LFSR_TAG_DATA, +1, buf2, SIZE))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(buf2, SIZE)))) => 0; + 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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("a", 1)))) => 0; + "a", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("b", 1)))) => 0; + "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_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2747,9 +2747,9 @@ code = ''' if (op == 0 || bid == sim_size) { // push to btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; // push to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -2759,9 +2759,9 @@ code = ''' } else if (op == 1) { // update btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; // update sim sim[bid] = 'a'+(i % 26); @@ -2769,7 +2769,7 @@ code = ''' } else { // pop from btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -2864,9 +2864,9 @@ code = ''' if (op == 0 || bid == sim_size) { // push to btree lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +weight, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; // push to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -2880,12 +2880,12 @@ code = ''' // update btree lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), - LFSR_RATTR( + &(uint8_t){'a'+(i % 26)}, 1), + LFSR_RATTR__( LFSR_TAG_GROW, +weight-sim_weights[bid], - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // update sim sim[bid] = 'a'+(i % 26); @@ -2895,9 +2895,9 @@ code = ''' // remove from btree lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM, -sim_weights[bid], - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // remove from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -3037,10 +3037,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, "aaa", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "0", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3090,16 +3090,16 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, "aaa", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "0", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), - LFSR_RATTR_NAME( + LFSR_RATTR__(LFSR_TAG_DATA, 0, "0", 1), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, "aab", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "1", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3157,22 +3157,22 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, "aaa", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "0", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), - LFSR_RATTR_NAME( + LFSR_RATTR__(LFSR_TAG_DATA, 0, "0", 1), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 1*DID, "aab", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "1", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), - LFSR_RATTR_NAME( + LFSR_RATTR__(LFSR_TAG_DATA, 0, "1", 1), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 2*DID, "aac", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "2", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3238,22 +3238,22 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, "aaa", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "0", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), - LFSR_RATTR_NAME( + LFSR_RATTR__(LFSR_TAG_DATA, 0, "1", 1), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 2*DID, "aac", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "2", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), - LFSR_RATTR_NAME( + LFSR_RATTR__(LFSR_TAG_DATA, 0, "0", 1), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 1*DID, "aab", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "1", 1))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3323,27 +3323,27 @@ code = ''' 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, name, 3), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; + &(uint8_t){'0'+(0 % 10)}, 1))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; lfsr_btree_commit(&lfs, &btree, i-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), - LFSR_RATTR_NAME( + &(uint8_t){'0'+((i-1) % 10)}, 1), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, i*DID, name, 3), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))) => 0; + &(uint8_t){'0'+((i-0) % 10)}, 1))) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -3394,10 +3394,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, "___", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "_", 1))) => 0; // set up a simulation to compare against // @@ -3431,15 +3431,15 @@ code = ''' // split btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), - LFSR_RATTR_NAME( + &(uint8_t){'0'+(i % 10)}, 1), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, name, 3), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0; + &(uint8_t){'0'+(i % 10)}, 1))) => 0; // split sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -3512,27 +3512,27 @@ code = ''' 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +W, 0, name, 3), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; + &(uint8_t){'0'+(0 % 10)}, 1))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), - LFSR_RATTR_NAME( + &(uint8_t){'0'+((i-1) % 10)}, 1), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +W, i*DID, name, 3), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))) => 0; + &(uint8_t){'0'+((i-0) % 10)}, 1))) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -3584,10 +3584,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +W, 0, "___", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "_", 1))) => 0; // set up a simulation to compare against // @@ -3634,18 +3634,18 @@ code = ''' // split btree lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_GROW, +weight1-sim_weights[bid], - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), - LFSR_RATTR_NAME( + &(uint8_t){'0'+(i % 10)}, 1), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +weight2, 0, name, 3), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0; + &(uint8_t){'0'+(i % 10)}, 1))) => 0; // split sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -3741,10 +3741,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, "___", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "_", 1))) => 0; // set up a simulation to compare against // @@ -3792,24 +3792,23 @@ code = ''' if (cmp > LFS_CMP_EQ) { lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, name, 3), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF( - &(uint8_t){'0'+(i % 10)}, 1)))) => 0; + &(uint8_t){'0'+(i % 10)}, 1))) => 0; } else { lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( - LFSR_RATTR_CAT_( + LFSR_RATTR_DATA__( LFSR_TAG_DATA, 0, - &split_data, 1), - LFSR_RATTR_NAME( + &split_data), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +1, 0, name, 3), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0; + &(uint8_t){'0'+(i % 10)}, 1))) => 0; } // split sim @@ -3822,9 +3821,9 @@ code = ''' } else if (op == 1) { // update btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0; + &(uint8_t){'0'+(i % 10)}, 1))) => 0; // update sim sim[bid] = '0'+(i % 10); @@ -3832,7 +3831,7 @@ code = ''' } else { // pop from btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -3899,10 +3898,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +W, 0, "___", 3), - LFSR_RATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, 0, "_", 1))) => 0; // set up a simulation to compare against // @@ -3962,24 +3961,23 @@ code = ''' if (cmp > LFS_CMP_EQ) { lfsr_btree_commit(&lfs, &btree, split_bid-(split_weight-1), LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +weight, 0, name, 3), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF( - &(uint8_t){'0'+(i % 10)}, 1)))) => 0; + &(uint8_t){'0'+(i % 10)}, 1))) => 0; } else { lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( - LFSR_RATTR_CAT_( + LFSR_RATTR_DATA__( LFSR_TAG_DATA, 0, - &split_data, 1), - LFSR_RATTR_NAME( + &split_data), + LFSR_RATTR_NAME__( LFSR_TAG_NAME, +weight, 0, name, 3), - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))) => 0; + &(uint8_t){'0'+(i % 10)}, 1))) => 0; } // split sim @@ -3996,12 +3994,12 @@ code = ''' // update btree lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_DATA, 0, - LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), - LFSR_RATTR( + &(uint8_t){'0'+(i % 10)}, 1), + LFSR_RATTR__( LFSR_TAG_GROW, +weight-sim_weights[bid], - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // update sim sim[bid] = '0'+(i % 10); @@ -4011,9 +4009,9 @@ code = ''' // pop from btree lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM, -sim_weights[bid], - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -4107,9 +4105,9 @@ code = ''' lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_commit(&lfs, &btree, i, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -4245,9 +4243,9 @@ code = ''' // add to btree lfsr_btree_commit(&lfs, &btree, bid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); diff --git a/tests/test_files.toml b/tests/test_files.toml index 6ccb41f0..6d226345 100644 --- a/tests/test_files.toml +++ b/tests/test_files.toml @@ -978,9 +978,9 @@ code = ''' // delete any bshrub/btree lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_STRUCT, 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_file_close(&lfs, &file) => 0; @@ -1095,17 +1095,23 @@ code = ''' // create an empty bshrub lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS( - LFSR_RATTR_SHRUBCOMMIT( + LFSR_RATTR__( LFSR_TAG_SHRUBCOMMIT, 0, - &file.b, 0, ((lfsr_rattr_t[]){ - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("?", 1))}), - 1))) => 0; + (&(lfsr_shrubcommit_t){ + .bshrub=&file.b, + .rid=0, + .rattrs=((lfsr_rattr_t[]){ + LFSR_RATTR__(LFSR_TAG_DATA, +1, "?", 1)}), + .rattr_count=1}), 0))) => 0; lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS( - LFSR_RATTR_SHRUBCOMMIT( + LFSR_RATTR__( LFSR_TAG_SHRUBCOMMIT, 0, - &file.b, 0, ((lfsr_rattr_t[]){ - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL())}), - 1))) => 0; + (&(lfsr_shrubcommit_t){ + .bshrub=&file.b, + .rid=0, + .rattrs=((lfsr_rattr_t[]){ + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0)}), + .rattr_count=1}), 0))) => 0; lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS( LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_BSHRUB, 0, @@ -1226,9 +1232,9 @@ code = ''' lfs_alloc_ckpoint(&lfs); lfsr_rbyd_alloc(&lfs, &file.b.shrub) => 0; lfsr_rbyd_commit(&lfs, &file.b.shrub, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("?", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_DATA, +1, "?", 1))) => 0; lfsr_rbyd_commit(&lfs, &file.b.shrub, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; lfsr_mdir_commit(&lfs, &file.b.o.mdir, LFSR_RATTRS( LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_BTREE, 0, diff --git a/tests/test_mount.toml b/tests/test_mount.toml index a44f75e1..0d6b7e2c 100644 --- a/tests/test_mount.toml +++ b/tests/test_mount.toml @@ -545,9 +545,9 @@ code = ''' // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_MAGIC, 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_unmount(&lfs) => 0; // mount should now fail @@ -569,9 +569,9 @@ code = ''' // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_MAGIC, 0, - LFSR_DATA_BUF("lottlefs", 8)))) => 0; + "lottlefs", 8))) => 0; lfsr_unmount(&lfs) => 0; // mount should now fail @@ -593,11 +593,11 @@ code = ''' // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_VERSION, 0, - LFSR_DATA_BUF(((const uint8_t[2]){ + ((const uint8_t[2]){ LFS_DISK_VERSION_MAJOR+1, - 0}), 2)))) => 0; + 0}), 2))) => 0; lfsr_unmount(&lfs) => 0; // mount should now fail @@ -619,11 +619,11 @@ code = ''' // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_VERSION, 0, - LFSR_DATA_BUF(((const uint8_t[2]){ + ((const uint8_t[2]){ LFS_DISK_VERSION_MAJOR, - LFS_DISK_VERSION_MINOR+1}), 2)))) => 0; + LFS_DISK_VERSION_MINOR+1}), 2))) => 0; lfsr_unmount(&lfs) => 0; // mount should now fail @@ -645,14 +645,11 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t rcompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR_LE32__( LFSR_TAG_RCOMPAT, 0, - LFSR_DATA_LE32( - LFSR_RCOMPAT_COMPAT - | LFSR_RCOMPAT_NONSTANDARD, - rcompat_buf)))) => 0; + LFSR_RCOMPAT_COMPAT + | LFSR_RCOMPAT_NONSTANDARD))) => 0; lfsr_unmount(&lfs) => 0; // mount should now fail @@ -674,14 +671,11 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t wcompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR_LE32__( LFSR_TAG_WCOMPAT, 0, - LFSR_DATA_LE32( - LFSR_WCOMPAT_COMPAT - | LFSR_WCOMPAT_NONSTANDARD, - wcompat_buf)))) => 0; + LFSR_WCOMPAT_COMPAT + | LFSR_WCOMPAT_NONSTANDARD))) => 0; lfsr_unmount(&lfs) => 0; // mount should now fail @@ -706,14 +700,11 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t ocompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR_LE32__( LFSR_TAG_OCOMPAT, 0, - LFSR_DATA_LE32( - LFSR_OCOMPAT_COMPAT - | LFSR_OCOMPAT_NONSTANDARD, - ocompat_buf)))) => 0; + LFSR_OCOMPAT_COMPAT + | LFSR_OCOMPAT_NONSTANDARD))) => 0; lfsr_unmount(&lfs) => 0; // mount should _not_ fail, ocompat should always be ignored @@ -736,14 +727,11 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t wcompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR_LE32__( LFSR_TAG_WCOMPAT, 0, - LFSR_DATA_LE32( - LFSR_WCOMPAT_COMPAT - | LFSR_WCOMPAT_RDONLY, - wcompat_buf)))) => 0; + LFSR_WCOMPAT_COMPAT + | LFSR_WCOMPAT_RDONLY))) => 0; lfsr_unmount(&lfs) => 0; // mount should now fail @@ -767,14 +755,11 @@ code = ''' // note we're messing around with internals to do this! this // is not a user API lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; - uint8_t rcompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR_LE32__( LFSR_TAG_RCOMPAT, 0, - LFSR_DATA_LE32( - LFSR_RCOMPAT_COMPAT - | LFSR_RCOMPAT_WRONLY, - rcompat_buf)))) => 0; + LFSR_RCOMPAT_COMPAT + | LFSR_RCOMPAT_WRONLY))) => 0; lfsr_unmount(&lfs) => 0; // mount should now fail @@ -803,7 +788,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; uint8_t rcompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( + LFSR_RATTR_CAT__( LFSR_TAG_RCOMPAT, 0, LFSR_DATA_LE32(LFSR_RCOMPAT_COMPAT, rcompat_buf), LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; @@ -837,7 +822,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; uint8_t wcompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( + LFSR_RATTR_CAT__( LFSR_TAG_WCOMPAT, 0, LFSR_DATA_LE32(LFSR_WCOMPAT_COMPAT, wcompat_buf), LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; @@ -871,7 +856,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; uint8_t ocompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( + LFSR_RATTR_CAT__( LFSR_TAG_OCOMPAT, 0, LFSR_DATA_LE32(LFSR_OCOMPAT_COMPAT, ocompat_buf), LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; @@ -903,7 +888,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; uint8_t rcompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( + LFSR_RATTR_CAT__( LFSR_TAG_RCOMPAT, 0, LFSR_DATA_LE32(LFSR_RCOMPAT_COMPAT, rcompat_buf), LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; @@ -937,7 +922,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; uint8_t wcompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( + LFSR_RATTR_CAT__( LFSR_TAG_WCOMPAT, 0, LFSR_DATA_LE32(LFSR_WCOMPAT_COMPAT, wcompat_buf), LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; @@ -968,7 +953,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; uint8_t ocompat_buf[LFSR_LE32_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( + LFSR_RATTR_CAT__( LFSR_TAG_OCOMPAT, 0, LFSR_DATA_LE32(LFSR_OCOMPAT_COMPAT, ocompat_buf), LFSR_DATA_BUF(overflow, sizeof(overflow))))) => 0; @@ -1075,7 +1060,7 @@ code = ''' lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; uint8_t file_limit_buf[LFSR_LEB128_DSIZE]; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR_CAT( + LFSR_RATTR_CAT__( LFSR_TAG_FILELIMIT, 0, // it's a bit difficult to test this since file limit // is usually our integer limit, but we can force a @@ -1101,9 +1086,9 @@ code = ''' // create an unknown config lfsr_mount(&lfs, LFS_M_RDWR, CFG) => 0; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_CONFIG + 0x13, 0, - LFSR_DATA_BUF("oh no!", strlen("oh no!"))))) => 0; + "oh no!", strlen("oh no!")))) => 0; lfsr_unmount(&lfs) => 0; // mount should now fail @@ -1147,9 +1132,10 @@ code = ''' lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_SUB | (LFSR_TAG_NAME + 0x13), 0, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; lfsr_unmount(&lfs) => 0; // mount diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index 6a07a1c6..10ad1dc1 100644 --- a/tests/test_mtree.toml +++ b/tests/test_mtree.toml @@ -37,9 +37,9 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(i), 0, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } for (lfs_size_t i = 0; i < N; i++) { @@ -82,9 +82,9 @@ code = ''' lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(i), 0, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } for (lfs_size_t i = 0; i < N; i++) { @@ -124,9 +124,9 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; lfsr_data_t data; uint8_t buffer[4]; @@ -173,18 +173,18 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, buffer, SIZE))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(3), 0, "c", 1))) => 0; // assert mdirs were unininlined assert(lfs.mtree.weight == (1 << lfs.mdir_bits)); @@ -269,7 +269,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -358,7 +358,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -378,7 +378,7 @@ code = ''' // force mdir to compact mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("e", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, "e", 1))) => 0; // assert mdir was split correctly assert(lfs.mtree.weight == (3 << lfs.mdir_bits)); @@ -675,7 +675,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -687,7 +687,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped @@ -765,7 +765,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -779,7 +779,7 @@ code = ''' // force mdir to compact while we're removing mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped @@ -862,7 +862,7 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(mdir.rbyd.weight == 2); // assert split/drop worked out @@ -932,7 +932,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -956,7 +956,7 @@ code = ''' // force mdir to compact while we're removing mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(mdir.rbyd.weight == 1); // assert split/drop worked out @@ -1046,7 +1046,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -1070,7 +1070,7 @@ code = ''' // force mdir to compact while we're removing mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(mdir.rbyd.weight == 1); // assert split/drop worked out @@ -1198,7 +1198,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; } } @@ -1273,18 +1273,18 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, buffer, SIZE))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(3), 0, "c", 1))) => 0; // assert mdirs were unininlined assert(lfs.mtree.weight == (1 << lfs.mdir_bits)); @@ -1296,10 +1296,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("d", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(4), 0, "d", 1))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("e", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(5), 0, "e", 1))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1408,7 +1408,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -1422,10 +1422,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, "d", 1))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(3), 0, "e", 1))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1538,7 +1538,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -1552,10 +1552,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, "d", 1))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(3), 0, "e", 1))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1660,10 +1660,10 @@ code = ''' lfsr_mdir_t old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "b", 1))) => 0; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, "c", 1))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -1737,10 +1737,10 @@ code = ''' lfsr_mdir_t old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "b", 1))) => 0; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, "c", 1))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -1749,16 +1749,16 @@ code = ''' old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("d", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(3), 0, "d", 1))) => 0; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("e", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(4), 0, "e", 1))) => 0; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(5), 0, LFSR_DATA_BUF("f", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(5), 0, "f", 1))) => 0; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(6), 0, LFSR_DATA_BUF("g", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(6), 0, "g", 1))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -1861,10 +1861,10 @@ code = ''' lfsr_mdir_t old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("b", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "b", 1))) => 0; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, "c", 1))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -1872,10 +1872,10 @@ code = ''' old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("d", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(3), 0, "d", 1))) => 0; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(4), 0, LFSR_DATA_BUF("e", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(4), 0, "e", 1))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -1970,7 +1970,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -1987,10 +1987,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, "d", 1))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("e", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(3), 0, "e", 1))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated @@ -2105,7 +2105,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -2129,10 +2129,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("e", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, "e", 1))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("f", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(3), 0, "f", 1))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated @@ -2255,7 +2255,7 @@ code = ''' // force mroot to compact lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mdirs were unininlined and split assert(lfs.mtree.weight == (2 << lfs.mdir_bits)); @@ -2272,11 +2272,11 @@ code = ''' // force mdir to compact twice, this should relocate mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF("d", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, "d", 1))) => 0; // force mdir to compact while we're removing mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(mdir.rbyd.weight == 0); // assert mroot relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2342,19 +2342,19 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(2), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(2), 0, buffer, SIZE))) => 0; // force mroot to compact, this should both uninline and relocate lfsr_mdir_t old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(3), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(3), 0, "c", 1))) => 0; // assert mroot relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2449,7 +2449,7 @@ code = ''' lfsr_mdir_t old_mroot = lfs.mroot; lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF("c", 1)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, "c", 1))) => 0; // assert mroot relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2609,7 +2609,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; } } @@ -2755,7 +2755,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, 0, "a", 1, &mdir, NULL, NULL) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(mdir.rbyd.weight == 2); // assert neighbor was removed @@ -2805,7 +2805,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, 0, "b", 1, &mdir, NULL, NULL) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(mdir.rbyd.weight == 2); // assert neighbor was removed @@ -3427,7 +3427,7 @@ code = ''' // now remove the middle entry, forcing a drop lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(mdir.rbyd.weight == 0); // assert mdir was dropped correctly @@ -3575,13 +3575,13 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_ATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; + LFSR_RATTR__(LFSR_TAG_ATTR(1), 0, buffer, SIZE))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; diff --git a/tests/test_paths.toml b/tests/test_paths.toml index bb54a8e1..1b09c59a 100644 --- a/tests/test_paths.toml +++ b/tests/test_paths.toml @@ -4566,44 +4566,50 @@ code = ''' lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/coldbrew"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/turkish"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/tubruk"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/vietnamese"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/thai"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; // stat paths struct lfs_info info; @@ -4746,44 +4752,50 @@ code = ''' lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coldbrew"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "turkish"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "tubruk"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "vietnamese"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "thai"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; if (DIR) { lfsr_mkdir(&lfs, "drip/coffee") => LFS_ERR_NOTSUP; @@ -5036,44 +5048,50 @@ code = ''' lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/coldbrew"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/turkish"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/tubruk"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/vietnamese"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/thai"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; // stat paths struct lfs_info info; @@ -5272,44 +5290,50 @@ code = ''' lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/coldbrew"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/turkish"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/tubruk"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/vietnamese"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/thai"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; // stat paths struct lfs_info info; @@ -5508,44 +5532,50 @@ code = ''' lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/coldbrew"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/turkish"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/tubruk"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/vietnamese"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; path = "coffee/thai"; lfsr_mtree_pathlookup(&lfs, &path, &mdir, NULL, &did) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_RATTRS( - LFSR_RATTR_NAME( + LFSR_RATTR_CAT__( LFSR_TAG_NAME + 0x13, +1, - did, path, lfsr_path_namelen(path)))) => 0; + LFSR_DATA_LEB128(did, (uint8_t[LFSR_LEB128_DSIZE]){0}), + LFSR_DATA_BUF(path, lfsr_path_namelen(path))))) => 0; // stat paths struct lfs_info info; diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index e7b3c7aa..32594b94 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -32,21 +32,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -69,22 +69,22 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -107,18 +107,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; // fetch lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with the second attribute lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -149,9 +149,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -174,12 +174,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -212,12 +212,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -269,9 +269,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -294,13 +294,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -333,13 +333,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -390,9 +390,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -411,12 +411,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -437,12 +437,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), &data) => 0; @@ -480,9 +480,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -501,13 +501,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -528,13 +528,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(2), &data) => 0; @@ -576,12 +576,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -602,12 +602,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -647,15 +647,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -676,15 +676,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -726,15 +726,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -762,15 +762,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -817,18 +817,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -856,18 +856,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -895,18 +895,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -934,18 +934,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -994,18 +994,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + "\xdd\xdd\xdd\xdd", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1040,18 +1040,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1086,18 +1086,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1132,18 +1132,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1197,18 +1197,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + "\xdd\xdd\xdd\xdd", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1243,18 +1243,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1289,18 +1289,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1335,18 +1335,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1402,21 +1402,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + "\xdd\xdd\xdd\xdd", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1453,21 +1453,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1502,21 +1502,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1551,21 +1551,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1623,21 +1623,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1681,21 +1681,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1737,21 +1737,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1793,21 +1793,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1870,24 +1870,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1931,24 +1931,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -1992,24 +1992,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -2074,24 +2074,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xff\xff\xff\xff", 4)))) => 0; + "\xff\xff\xff\xff", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -2140,24 +2140,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xff\xff\xff\xff", 4)), - LFSR_RATTR( + "\xff\xff\xff\xff", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -2206,24 +2206,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xff\xff\xff\xff", 4)), - LFSR_RATTR( + "\xff\xff\xff\xff", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), @@ -2306,9 +2306,9 @@ code = ''' // build the attribute list for the current permutation struct lfsr_rattr rattrs[N]; for (unsigned j = 0; j < N; j++) { - rattrs[j] = LFSR_RATTR( + rattrs[j] = LFSR_RATTR__( LFSR_TAG_ATTR(perm[j]+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)); + "\xaa\xaa\xaa\xaa", 4); } // test the given permutation @@ -2399,9 +2399,9 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(perm[j]+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -2459,12 +2459,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2497,12 +2497,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2556,13 +2556,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2595,13 +2595,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2675,9 +2675,9 @@ code = ''' // build the attribute list for the current permutation struct lfsr_rattr rattrs[N]; for (unsigned j = 0; j < N; j++) { - rattrs[j] = LFSR_RATTR( + rattrs[j] = LFSR_RATTR__( LFSR_TAG_ATTR(perm[j]+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)); + "\xaa\xaa\xaa\xaa", 4); } // test the given permutation @@ -2750,9 +2750,9 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(perm[j]+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -2807,9 +2807,9 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(j+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; } // copy block so we can reset after each remove @@ -2849,9 +2849,9 @@ code = ''' // update each tag in permutation order for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(perm[j]+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; } // check that all tags have been updated @@ -2928,9 +2928,9 @@ code = ''' : (ORDER == 1) ? (((lfs_size_t)-1) - i) : TEST_PRNG(&prng); int err = lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(x & 0x7f), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))); + "\xaa\xaa\xaa\xaa", 4))); if (err == LFS_ERR_RANGE) { break; } @@ -2980,13 +2980,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3003,16 +3003,16 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -3045,16 +3045,16 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -3132,9 +3132,9 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(perm[j]+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; } // copy block so we can reset after each remove @@ -3157,9 +3157,9 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(j+1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -3186,9 +3186,9 @@ code = ''' // try appending the tag back to make sure things still work printf("--- append: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(j+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + "\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++) { @@ -3282,9 +3282,9 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(perm[j]+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; } // copy block so we can reset after each remove @@ -3307,9 +3307,9 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(j+1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -3361,12 +3361,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + "\xdd\xdd\xdd\xdd", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR(2)); @@ -3392,9 +3392,9 @@ code = ''' // try to remove tags that aren't there, this should do nothing lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR(2)); @@ -3419,9 +3419,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR(2)); @@ -3446,9 +3446,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR(2)); @@ -3520,32 +3520,32 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; // remove several attributes lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -3572,9 +3572,9 @@ code = ''' // try to remove tags that aren't there, this should do nothing lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR(2)); @@ -3599,9 +3599,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR(2)); @@ -3626,9 +3626,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR(2)); @@ -3655,9 +3655,9 @@ code = ''' // try to remove the tags again, just to make sure (keep in mind // these removes still commit to the rbyd) lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR(2)); @@ -3682,9 +3682,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(3), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR(2)); @@ -3709,9 +3709,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(5), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR(2)); @@ -3783,13 +3783,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3806,19 +3806,19 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3835,19 +3835,19 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(2), 0, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3897,9 +3897,9 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(j+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; } // copy block so we can reset after each remove @@ -3939,9 +3939,9 @@ code = ''' // remove each tag in permutation order for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(perm[j]+1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; } // check that all tags are now removed @@ -3953,9 +3953,9 @@ code = ''' // try resuming from all tags being removed lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + "\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_ATTR(1), @@ -4052,17 +4052,17 @@ code = ''' sim[rattr] = 'a'+(i % 26); // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(rattr), 0, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } else { // update our sim sim[rattr] = '\0'; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(rattr), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; } } @@ -4136,9 +4136,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4155,12 +4155,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4183,15 +4183,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4238,9 +4238,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4257,13 +4257,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4286,13 +4286,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4315,17 +4315,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4354,17 +4354,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4393,17 +4393,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4496,9 +4496,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -4558,12 +4558,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 00000000, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4631,13 +4631,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4682,13 +4682,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4796,9 +4796,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -4869,7 +4869,7 @@ code = ''' x = x % (rbyd.weight+1); int err = lfsr_rbyd_commit(&lfs, &rbyd, x, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(names[x % 6], 4)))); + LFSR_RATTR__(LFSR_TAG_DATA, +1, names[x % 6], 4))); if (err == LFS_ERR_RANGE) { break; } @@ -4916,12 +4916,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4944,18 +4944,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -4990,24 +4990,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_RATTR( + "\xbb\xbb", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -5095,13 +5095,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -5124,21 +5124,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -5173,21 +5173,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -5222,29 +5222,29 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -5314,29 +5314,29 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -5383,29 +5383,29 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -5517,15 +5517,15 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + 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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } } @@ -5592,18 +5592,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5703,21 +5703,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5794,21 +5794,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5949,15 +5949,15 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + 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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } } @@ -6039,15 +6039,15 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[j % 6], 4)))) => 0; + 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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[j % 6], 2)))) => 0; + names[j % 6], 2))) => 0; } } @@ -6088,9 +6088,9 @@ code = ''' // update each tag in permutation order for (unsigned j = 0; j < N*M; j++) { lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(perm[j]%M+1), 0, - LFSR_DATA_BUF(names[(perm[j]/M) % 6], 3)))) => 0; + names[(perm[j]/M) % 6], 3))) => 0; } // check that all tags have been updated @@ -6206,15 +6206,15 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + 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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } } @@ -6238,9 +6238,9 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR((j%M)+1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -6282,9 +6282,9 @@ code = ''' // try append the tag back to make sure things still work printf("--- append: rid%jd, %jd ---\n", j/M, (j%M)+1); lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR((j%M)+1), 0, - LFSR_DATA_BUF(names[(j/M)%6], 3)))) => 0; + 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++) { @@ -6386,15 +6386,15 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[j % 6], 4)))) => 0; + 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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[j % 6], 2)))) => 0; + names[j % 6], 2))) => 0; } } @@ -6435,9 +6435,9 @@ code = ''' // remove each tag in permutation order for (unsigned j = 0; j < N*M; j++) { lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(perm[j]%M+1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; } // check that all tags have been removed @@ -6528,13 +6528,13 @@ code = ''' // build a single attribute list with all ratibutes, if this fails // it should fail atomically struct lfsr_rattr rattrs[1+M]; - rattrs[0] = LFSR_RATTR( + rattrs[0] = LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[x % 6], 4)); + names[x % 6], 4); for (unsigned u = 0; u < M; u++) { - rattrs[1+u] = LFSR_RATTR( + rattrs[1+u] = LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[x % 6], 2)); + names[x % 6], 2); } int err = lfsr_rbyd_commit(&lfs, &rbyd, x, rattrs, 1+M); @@ -6639,14 +6639,14 @@ code = ''' // note the data size differences here lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(perm[j]+1), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; + names[perm[j] % 6], 1))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } // try looking up each tag @@ -6785,19 +6785,19 @@ code = ''' // note the data size differences here lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(perm[j]+1), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; + names[perm[j] % 6], 1))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } } @@ -6910,14 +6910,14 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -6938,14 +6938,14 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -6966,17 +6966,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7001,17 +7001,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7036,17 +7036,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7089,20 +7089,20 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7133,20 +7133,20 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7177,26 +7177,26 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_RATTR( + "\xbb\xbb", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7239,26 +7239,26 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_RATTR( + "\xbb\xbb", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7301,26 +7301,26 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_RATTR( + "\xbb\xbb", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7391,67 +7391,67 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\xee\xee", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7552,9 +7552,9 @@ code = ''' // try to recreate lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7689,61 +7689,61 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), +1, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7832,9 +7832,9 @@ code = ''' // try to recreate lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -7957,89 +7957,89 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), +1, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(8), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), + "\xaa\xaa", 2), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(8), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\xee\xee", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -8164,9 +8164,9 @@ code = ''' // try to recreate lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -8328,77 +8328,77 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(4), +1, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(8), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(9), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(9), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(9), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + "\xee\xee\xee\xee", 4), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -8517,9 +8517,9 @@ code = ''' // try to recreate lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -8675,77 +8675,77 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(9), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), +1, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(8), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), + "\xaa\xaa", 2), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(8), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -8864,9 +8864,9 @@ code = ''' // try to recreate lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -9022,78 +9022,78 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), +1, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), + "\xcc\xcc", 2), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -9200,9 +9200,9 @@ code = ''' // try to recreate lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -9346,78 +9346,78 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(1), +1, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), +1, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + "\xcc\xcc\xcc\xcc", 4), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -9524,9 +9524,9 @@ code = ''' // try to recreate lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -9672,119 +9672,119 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), +1, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(8), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(11), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), + "\xcc\xcc", 2), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(12), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + "\xcc\xcc\xcc\xcc", 4), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(13), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(14), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(9), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(10), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), + "\xaa\xaa", 2), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(10), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -9933,9 +9933,9 @@ code = ''' // try to recreate lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -10123,117 +10123,117 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(6), +1, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(7), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(8), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(9), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(10), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow to the root - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(10), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(10), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(10), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(11), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(12), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(13), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(14), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(14), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(14), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\xee\xee", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\xee\xee", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_DATA, 0, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(5), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xee\xee", 2)), + "\xee\xee", 2), // propagate yellow - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(4), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\xee\xee", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -10382,9 +10382,9 @@ code = ''' // try to recreate lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, &data) => 0; @@ -10608,9 +10608,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -10634,7 +10634,7 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10654,9 +10654,9 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[j % 6], 6)))) => 0; + names[j % 6], 6))) => 0; assert(rbyd.weight == N); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10770,15 +10770,15 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + 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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } } assert(rbyd.weight == N); @@ -10803,7 +10803,7 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10836,14 +10836,14 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[j % 6], 6)))) => 0; + names[j % 6], 6))) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[j % 6], 3)))) => 0; + names[j % 6], 3))) => 0; } assert(rbyd.weight == N); @@ -10970,9 +10970,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -10996,7 +10996,7 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -11100,15 +11100,15 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + 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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } } assert(rbyd.weight == N); @@ -11133,7 +11133,7 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -11205,11 +11205,11 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, @@ -11224,15 +11224,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0), + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, @@ -11247,16 +11247,16 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, @@ -11271,19 +11271,19 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0), + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0), + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, @@ -11298,21 +11298,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, @@ -11345,14 +11345,14 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, @@ -11367,21 +11367,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0), + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, @@ -11396,22 +11396,22 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, @@ -11426,28 +11426,28 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_RATTR( + "\xbb\xbb", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0), + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0), + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, @@ -11462,30 +11462,30 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_RATTR( + "\xbb\xbb", 2), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, @@ -11540,9 +11540,9 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[j % 6], 4)))) => 0; + names[j % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -11592,7 +11592,7 @@ code = ''' lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -11605,9 +11605,9 @@ code = ''' // try resuming from all tags being removed lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -11689,15 +11689,15 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[j % 6], 4)))) => 0; + 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_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF(names[j % 6], 2)))) => 0; + names[j % 6], 2))) => 0; } } assert(rbyd.weight == N); @@ -11748,7 +11748,7 @@ code = ''' lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -11761,14 +11761,14 @@ code = ''' // try resuming from all tags being removed lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u+1), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa", 3)))) => 0; + "\xaa\xaa\xaa", 3))) => 0; } assert(rbyd.weight == 1); @@ -11882,16 +11882,16 @@ code = ''' count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(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_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; } } @@ -11956,9 +11956,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + "\xaa\xaa\xaa\xaa", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; @@ -11977,9 +11977,9 @@ code = ''' // make id2 with weight w2 lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +2, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + "\xbb\xbb\xbb\xbb", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; @@ -12010,9 +12010,9 @@ code = ''' // make id5 with weight w3 lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +3, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; @@ -12055,9 +12055,9 @@ code = ''' // make id9 with weight w4 lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +4, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + "\xdd\xdd\xdd\xdd", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; @@ -12112,9 +12112,9 @@ code = ''' // make id14 with weight w5 lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +5, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_DATA, &rid_, &tag_, &weight_, &data_) => 0; @@ -12203,25 +12203,25 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( // make id0 with weight w1 - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + "\xaa\xaa\xaa\xaa", 4), // make id2 with weight w2 - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +2, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + "\xbb\xbb\xbb\xbb", 4), // make id5 with weight w3 - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +3, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + "\xcc\xcc\xcc\xcc", 4), // make id9 with weight w4 - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +4, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + "\xdd\xdd\xdd\xdd", 4), // make id14 with weight w5 - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +5, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; + "\xee\xee\xee\xee", 4))) => 0; // traverse, finding tags and weights lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, @@ -12360,9 +12360,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -12450,9 +12450,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -12501,18 +12501,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("unrelated", 9)), - LFSR_RATTR( + "unrelated", 9), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; + "\xaa\xaa", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -12567,18 +12567,18 @@ code = ''' // make id2 with weight w2 lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_RATTR( + "\xbb\xbb", 2), + LFSR_RATTR__( LFSR_TAG_GROW, +1, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; + "\xbb\xbb", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -12669,18 +12669,18 @@ code = ''' // make id5 with weight w3 lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_GROW, +2, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; + "\xcc\xcc", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -12807,18 +12807,18 @@ code = ''' // make id9 with weight w4 lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xdd\xdd", 2)), - LFSR_RATTR( + "\xdd\xdd", 2), + LFSR_RATTR__( LFSR_TAG_GROW, +3, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xdd\xdd", 2)))) => 0; + "\xdd\xdd", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -12981,18 +12981,18 @@ code = ''' // make id14 with weight w5 lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_GROW, +4, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\xee\xee", 2))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_ATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -13212,71 +13212,71 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("unrelated", 9)), + "unrelated", 9), // make id0 with weight w1 - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), - LFSR_RATTR( + "\xaa\xaa", 2), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xaa\xaa", 2)), + "\xaa\xaa", 2), // make id2 with weight w2 - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)), - LFSR_RATTR( + "\xbb\xbb", 2), + LFSR_RATTR__( LFSR_TAG_GROW, +1, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xbb\xbb", 2)), + "\xbb\xbb", 2), // make id5 with weight w3 - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), - LFSR_RATTR( + "\xcc\xcc", 2), + LFSR_RATTR__( LFSR_TAG_GROW, +2, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xcc\xcc", 2)), + "\xcc\xcc", 2), // make id9 with weight w4 - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xdd\xdd", 2)), - LFSR_RATTR( + "\xdd\xdd", 2), + LFSR_RATTR__( LFSR_TAG_GROW, +3, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xdd\xdd", 2)), + "\xdd\xdd", 2), // make id14 with weight w5 - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), - LFSR_RATTR( + "\xee\xee\xee\xee", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xee\xee", 2)), - LFSR_RATTR( + "\xee\xee", 2), + LFSR_RATTR__( LFSR_TAG_GROW, +4, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xee\xee", 2)))) => 0; + "\xee\xee", 2))) => 0; // traverse, finding tags and weights lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, @@ -13538,9 +13538,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("unrelated", 9)))) => 0; + "unrelated", 9))) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -13552,18 +13552,18 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)), - LFSR_RATTR( + names[perm[j] % 6], 2), + LFSR_RATTR__( LFSR_TAG_GROW, +W-1, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -13660,9 +13660,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(3), 0, - LFSR_DATA_BUF("unrelated", 9)))) => 0; + "unrelated", 9))) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -13674,18 +13674,18 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)), - LFSR_RATTR( + names[perm[j] % 6], 2), + LFSR_RATTR__( LFSR_TAG_GROW, +W-1, - LFSR_DATA_NULL()), - LFSR_RATTR( + NULL, 0), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -13801,9 +13801,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -13827,7 +13827,7 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_GROW, +D, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_GROW, +D, NULL, 0))) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -13933,9 +13933,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -13959,9 +13959,9 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_GROW | LFSR_TAG_DATA, +D, - LFSR_DATA_BUF(names[j % 6], 6)))) => 0; + names[j % 6], 6))) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14077,9 +14077,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), +W, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -14103,9 +14103,9 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_GROW | LFSR_TAG_ATTR(1), +D, - LFSR_DATA_BUF(names[j % 6], 6)))) => 0; + names[j % 6], 6))) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14234,9 +14234,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -14260,7 +14260,7 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_GROW, -D, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_GROW, -D, NULL, 0))) => 0; assert(rbyd.weight == N*W-D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14366,9 +14366,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -14392,9 +14392,9 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_GROW | LFSR_TAG_DATA, -D, - LFSR_DATA_BUF(names[j % 6], 6)))) => 0; + names[j % 6], 6))) => 0; assert(rbyd.weight == N*W-D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14510,9 +14510,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(2), +W, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -14536,9 +14536,9 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_GROW | LFSR_TAG_ATTR(1), -D, - LFSR_DATA_BUF(names[j % 6], 6)))) => 0; + names[j % 6], 6))) => 0; assert(rbyd.weight == N*W-D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14666,9 +14666,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -14692,7 +14692,7 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -W, NULL, 0))) => 0; assert(rbyd.weight == (N-1)*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14726,9 +14726,9 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, j*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(names[j % 6], 6)))) => 0; + names[j % 6], 6))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14830,9 +14830,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +W, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N*W); @@ -14857,9 +14857,9 @@ code = ''' NULL, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF(names[j % 6], 2)))) => 0; + names[j % 6], 2))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14890,9 +14890,9 @@ code = ''' // now try removing the rattr printf("--- removing: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14918,9 +14918,9 @@ code = ''' // and try putting the rattr back just for good measure printf("--- appending: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF(names[j % 6], 2)))) => 0; + names[j % 6], 2))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15032,33 +15032,33 @@ code = ''' count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(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_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; } else if (op == 2) { // update our sim sim[rid*(M+1) + u+1] = 'a'+(i % 26); // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(u), 0, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } else if (op == 3) { // update our sim sim[rid*(M+1) + u+1] = '\0'; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(u), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; } } @@ -15207,9 +15207,9 @@ code = ''' count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +weight, - LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + &(uint8_t){'a'+(i % 26)}, 1))) => 0; } else if (op == 1) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -15220,7 +15220,7 @@ code = ''' count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -weight_, NULL, 0))) => 0; } else if (op == 2) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -15228,7 +15228,7 @@ code = ''' sim_weights[rid] += weight; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_GROW, +weight, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_GROW, +weight, NULL, 0))) => 0; } else if (op == 3) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -15239,7 +15239,7 @@ code = ''' sim_weights[rid] -= weight; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_GROW, -weight, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_GROW, -weight, NULL, 0))) => 0; } } @@ -15371,12 +15371,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); @@ -15461,12 +15461,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); @@ -15491,9 +15491,9 @@ code = ''' // remove with a wide tag lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15605,12 +15605,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); @@ -15635,10 +15635,10 @@ code = ''' // replace with bitwise inverse lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, - LFSR_DATA_BUF(names[j % 6], 3)))) => 0; + names[j % 6], 3))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15751,15 +15751,15 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)), - LFSR_RATTR( + names[perm[j] % 6], 2), + LFSR_RATTR__( LFSR_TAG_ATTR(0x80), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; + names[perm[j] % 6], 1))) => 0; } assert(rbyd.weight == N); @@ -15844,15 +15844,15 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)), - LFSR_RATTR( + names[perm[j] % 6], 2), + LFSR_RATTR__( LFSR_TAG_ATTR(0x80), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; + names[perm[j] % 6], 1))) => 0; } assert(rbyd.weight == N); @@ -15877,9 +15877,9 @@ code = ''' // remove with a wide tag lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15998,15 +15998,15 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)), - LFSR_RATTR( + names[perm[j] % 6], 2), + LFSR_RATTR__( LFSR_TAG_ATTR(0x80), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; + names[perm[j] % 6], 1))) => 0; } assert(rbyd.weight == N); @@ -16031,10 +16031,10 @@ code = ''' // replace with bitwise inverse lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, - LFSR_DATA_BUF(names[j % 6], 3)))) => 0; + names[j % 6], 3))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16154,9 +16154,9 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -16241,9 +16241,9 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -16268,9 +16268,9 @@ code = ''' // remove with a wide tag lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_SUB | LFSR_TAG_ATTR, 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16385,9 +16385,9 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; + names[perm[j] % 6], 4))) => 0; } assert(rbyd.weight == N); @@ -16412,10 +16412,10 @@ code = ''' // replace with bitwise inverse lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, - LFSR_DATA_BUF(names[j % 6], 6)))) => 0; + names[j % 6], 6))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16522,12 +16522,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); @@ -16612,12 +16612,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); @@ -16642,9 +16642,9 @@ code = ''' // remove with a wide tag lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_SUP | LFSR_TAG_ATTR, 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16756,12 +16756,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF(names[perm[j] % 6], 4)), - LFSR_RATTR( + names[perm[j] % 6], 4), + LFSR_RATTR__( LFSR_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; + names[perm[j] % 6], 2))) => 0; } assert(rbyd.weight == N); @@ -16786,10 +16786,10 @@ code = ''' // replace with bitwise inverse lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUP | LFSR_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, - LFSR_DATA_BUF(names[j % 6], 3)))) => 0; + names[j % 6], 3))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16869,15 +16869,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(0), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -16918,25 +16918,25 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(0), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_RATTR( + "\xcc\xcc\xcc\xcc", 4), + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; assert(rbyd.weight == 0); // remove a neighbor to the hole lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(1), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -16977,24 +16977,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(0), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; assert(rbyd.weight == 2); // delete a neighbor to the hole lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_RATTRS( - LFSR_RATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; + LFSR_RATTR__(LFSR_TAG_RM, -1, NULL, 0))) => 0; assert(rbyd.weight == 1); // can we still access things? @@ -17035,25 +17035,25 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(0x00), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(0x01), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(0x80), 0, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_RATTR( + "\xdd\xdd\xdd\xdd", 4), + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; assert(rbyd.weight == 0); // subwide replace a neighbor to the hole lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUB | LFSR_TAG_ATTR(0x02), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -17103,26 +17103,26 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_ATTR(0), 0, - LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_RATTR( + "\xaa\xaa\xaa\xaa", 4), + LFSR_RATTR__( LFSR_TAG_ATTR(1), 0, - LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_RATTR( + "\xbb\xbb\xbb\xbb", 4), + LFSR_RATTR__( LFSR_TAG_DATA, +1, - LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + "\xdd\xdd\xdd\xdd", 4))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_RM | LFSR_TAG_ATTR(0), 0, - LFSR_DATA_NULL()))) => 0; + NULL, 0))) => 0; assert(rbyd.weight == 1); // supwide replace a neighbor to the hole lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_RATTRS( - LFSR_RATTR( + LFSR_RATTR__( LFSR_TAG_SUP | LFSR_TAG_ATTR(2), 0, - LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + "\xcc\xcc\xcc\xcc", 4))) => 0; assert(rbyd.weight == 1); // can we still access things?