From 748bca0b6132bbc74fa43305903bf6c4eb51ce10 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Thu, 22 Feb 2024 17:46:20 -0600 Subject: [PATCH] Dropped LFSR_ATTR() prefix magic Before: LFSR_ATTR(RM(SUBMASK(REG)), 0, BUF("hi", 2)) Now: LFSR_ATTR( LFSR_TAG_RM | LFSR_TAG_SUBMASK | LFSR_TAG_REG, 0, LFSR_DATA_BUF("hi", 2)) Yes, it's more verbose now. But there were a couple reasons for dropping the idea: - The implicit prefixing is a bit magical, and not really all that common in C code. It would likely confuse new users on first read. - The implicitly prefixing macros did not play will with macro expansion rules. In particular, because the nested not-yet-prefixed macros aren't really macros, they aren't expanded as a part of argument prescan. This led to surprising compile-time errors, and prevented recursive attr-lists (which may be useful for shrubs). - Implicit prefixes is not very C-like, and in particular it gets in the way of sed/grep operations on source files. - RM(SUBMASK(REG)) for combining tags is (IMO) ugly, compared to LFSR_TAG_RM | LFSR_TAG_SUBMASK | LFSR_TAG_REG, even if the latter requires more typing. - Sometimes you need runtime-dependent TAG/DATA values, which implicit prefixing gets in the way of. The LFSR_TAG_TAG(tag)/ LFSR_DATA_DATA(tag) backdoors worked around this, but they are even more magical, and added noise to a not-actually-all-that-uncommon use case. And it's really not _that_ much extra effort to write out the prefixes everywhere. lfs.c: lines bytes before: 16894 537171 after: 16907 (+0.1%) 538340 (+0.2%) tests/*.toml: lines bytes before: 53306 1811035 after: 54517 (+2.3%) 1851006 (+2.2%) qadte came in quite handy again for refactoring the tests without completely losing my sanity. --- lfs.c | 331 +++--- tests/test_btree.toml | 593 ++++++---- tests/test_mtree.toml | 254 ++--- tests/test_rbyd.toml | 2382 +++++++++++++++++++++++++++++------------ 4 files changed, 2392 insertions(+), 1168 deletions(-) diff --git a/lfs.c b/lfs.c index 8a8a6a7b..f110f65a 100644 --- a/lfs.c +++ b/lfs.c @@ -764,22 +764,11 @@ enum lfsr_tag { LFSR_TAG_DIVERGEDLOWER = 0x0000, }; -// LFSR_TAG_TAG just provides and escape hatch to pass raw tags -// through the LFSR_ATTR macro -#define LFSR_TAG_TAG(tag) (tag) - -// some tag modifiers -#define LFSR_TAG_SHRUB(tag) (LFSR_TAG_SHRUB | LFSR_TAG_##tag) -#define LFSR_TAG_RM(tag) (LFSR_TAG_RM | LFSR_TAG_##tag) -#define LFSR_TAG_GROW(tag) (LFSR_TAG_GROW | LFSR_TAG_##tag) -#define LFSR_TAG_SUPMASK(tag) (LFSR_TAG_SUPMASK | LFSR_TAG_##tag) -#define LFSR_TAG_SUBMASK(tag) (LFSR_TAG_SUBMASK | LFSR_TAG_##tag) - // some other tag encodings with their own subfields #define LFSR_TAG_ALT(d, c, key) \ (LFSR_TAG_ALT \ - | LFSR_TAG_##d \ - | LFSR_TAG_##c \ + | (0x2000 & (d)) \ + | (0x1000 & (c)) \ | (0x0fff & (lfsr_tag_t)(key))) #define LFSR_TAG_UATTR(attr) \ @@ -1109,10 +1098,6 @@ static lfs_ssize_t lfsr_bd_progtag(lfs_t *lfs, #define LFSR_DATA_ISIMM 0x40000000 #define LFSR_DATA_ISCAT 0xc0000000 -// LFSR_DATA_DATA just provides and escape hatch to pass raw datas -// through the LFSR_ATTR macro -#define LFSR_DATA_DATA(_data) (_data) - #define LFSR_DATA_NULL() \ ((lfsr_data_t){ \ .u.buf.size=0, \ @@ -1530,13 +1515,10 @@ typedef struct lfsr_attr { lfsr_data_t data; } lfsr_attr_t; -#define LFSR_ATTR(_type, _delta, _data) \ - ((const lfsr_attr_t){ \ - LFSR_TAG_##_type, \ - _delta, \ - LFSR_DATA_##_data}) +#define LFSR_ATTR(_tag, _delta, _data) \ + ((const lfsr_attr_t){_tag, _delta, _data}) -#define LFSR_ATTR_NOOP() LFSR_ATTR(NULL, 0, NULL()) +#define LFSR_ATTR_NOOP() LFSR_ATTR(LFSR_TAG_NULL, 0, LFSR_DATA_NULL()) #define LFSR_ATTRS(...) \ (const lfsr_attr_t[]){__VA_ARGS__}, \ @@ -3063,17 +3045,17 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, && lfsr_tag_key(tag_) < lfsr_tag_key(tag)))))) { if (lfsr_tag_isrm(tag) || !lfsr_tag_key(tag)) { // if removed, make our tag unreachable - alt = LFSR_TAG_ALT(GT, B, 0); + alt = LFSR_TAG_ALT(LFSR_TAG_GT, LFSR_TAG_B, 0); weight = upper_rid - lower_rid + delta; upper_rid -= weight; } else { // split less than alt = LFSR_TAG_ALT( - LE, - TAG((!lfsr_tag_hasdiverged(tag_)) + LFSR_TAG_LE, + (!lfsr_tag_hasdiverged(tag_)) ? LFSR_TAG_R - : LFSR_TAG_B), - lfsr_tag_key(tag_)); + : LFSR_TAG_B, + tag_); weight = upper_rid - lower_rid; lower_rid += weight; } @@ -3089,17 +3071,17 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, && lfsr_tag_key(tag_) > lfsr_tag_key(tag)))))) { if (lfsr_tag_isrm(tag) || !lfsr_tag_key(tag)) { // if removed, make our tag unreachable - alt = LFSR_TAG_ALT(GT, B, 0); + alt = LFSR_TAG_ALT(LFSR_TAG_GT, LFSR_TAG_B, 0); weight = upper_rid - lower_rid + delta; upper_rid -= weight; } else { // split greater than alt = LFSR_TAG_ALT( - GT, - TAG((!lfsr_tag_hasdiverged(tag_)) + LFSR_TAG_GT, + (!lfsr_tag_hasdiverged(tag_)) ? LFSR_TAG_R - : LFSR_TAG_B), - lfsr_tag_key(tag)); + : LFSR_TAG_B, + tag); weight = upper_rid - (rid+1); upper_rid -= weight; } @@ -3634,7 +3616,7 @@ static int lfsr_rbyd_appendcompaction(lfs_t *lfs, lfsr_rbyd_t *rbyd, // connect with an altle lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff, - LFSR_TAG_ALT(LE, B, lfsr_tag_key(tag)), + LFSR_TAG_ALT(LFSR_TAG_LE, LFSR_TAG_B, tag), weight, rbyd->eoff - trunk, &rbyd->cksum); @@ -3713,7 +3695,9 @@ static int lfsr_rbyd_appendgdelta(lfs_t *lfs, lfsr_rbyd_t *rbyd) { lfs_size_t size = lfsr_gdelta_size(grm_, LFSR_GRM_DSIZE); err = lfsr_rbyd_appendattr(lfs, rbyd, -1, // opportunistically remove this tag if delta is all zero - (size == 0) ? LFSR_TAG_RM(GRMDELTA) : LFSR_TAG_GRMDELTA, 0, + (size == 0) + ? LFSR_TAG_RM | LFSR_TAG_GRMDELTA + : LFSR_TAG_GRMDELTA, 0, LFSR_DATA_BUF(grm_, size)); if (err) { return err; @@ -4284,15 +4268,16 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, bid -= pid - (rbyd.weight-1); if (rbyd_.weight == 0) { attrs__[attr_count++] = LFSR_ATTR( - RM, -rbyd.weight, NULL()); + LFSR_TAG_RM, -rbyd.weight, LFSR_DATA_NULL()); } else { attrs__[attr_count++] = LFSR_ATTR( - BRANCH, 0, - DATA(lfsr_data_frombranch(&rbyd_, &buf__[buf_size]))); + LFSR_TAG_BRANCH, 0, + lfsr_data_frombranch(&rbyd_, &buf__[buf_size])); buf_size += LFSR_BRANCH_DSIZE; if (rbyd_.weight != rbyd.weight) { attrs__[attr_count++] = LFSR_ATTR( - GROW, -rbyd.weight + rbyd_.weight, NULL()); + LFSR_TAG_GROW, -rbyd.weight + rbyd_.weight, + LFSR_DATA_NULL()); } } attrs = attrs__; @@ -4559,35 +4544,36 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // new root? if (!lfsr_rbyd_hastrunk(&parent)) { attrs__[attr_count++] = LFSR_ATTR( - BRANCH, +rbyd_.weight, - DATA(lfsr_data_frombranch(&rbyd_, &buf__[buf_size]))); + LFSR_TAG_BRANCH, +rbyd_.weight, + lfsr_data_frombranch(&rbyd_, &buf__[buf_size])); buf_size += LFSR_BRANCH_DSIZE; attrs__[attr_count++] = LFSR_ATTR( - BRANCH, +sibling.weight, - DATA(lfsr_data_frombranch(&sibling, &buf__[buf_size]))); + LFSR_TAG_BRANCH, +sibling.weight, + lfsr_data_frombranch(&sibling, &buf__[buf_size])); buf_size += LFSR_BRANCH_DSIZE; if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { attrs__[attr_count++] = LFSR_ATTR( - NAME, 0, DATA(split_data)); + LFSR_TAG_NAME, 0, split_data); } // split root? } else { bid -= pid - (rbyd.weight-1); attrs__[attr_count++] = LFSR_ATTR( - BRANCH, 0, - DATA(lfsr_data_frombranch(&rbyd_, &buf__[buf_size]))); + LFSR_TAG_BRANCH, 0, + lfsr_data_frombranch(&rbyd_, &buf__[buf_size])); buf_size += LFSR_BRANCH_DSIZE; if (rbyd_.weight != rbyd.weight) { attrs__[attr_count++] = LFSR_ATTR( - GROW, -rbyd.weight + rbyd_.weight, NULL()); + LFSR_TAG_GROW, -rbyd.weight + rbyd_.weight, + LFSR_DATA_NULL()); } attrs__[attr_count++] = LFSR_ATTR( - BRANCH, +sibling.weight, - DATA(lfsr_data_frombranch(&sibling, &buf__[buf_size]))); + LFSR_TAG_BRANCH, +sibling.weight, + lfsr_data_frombranch(&sibling, &buf__[buf_size])); buf_size += LFSR_BRANCH_DSIZE; if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { attrs__[attr_count++] = LFSR_ATTR( - NAME, 0, DATA(split_data)); + LFSR_TAG_NAME, 0, split_data); } } attrs = attrs__; @@ -4653,14 +4639,15 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, buf_size = 0; bid -= pid - (rbyd.weight-1); attrs__[attr_count++] = LFSR_ATTR( - RM, -sibling.weight, NULL()); + LFSR_TAG_RM, -sibling.weight, LFSR_DATA_NULL()); attrs__[attr_count++] = LFSR_ATTR( - BRANCH, 0, - DATA(lfsr_data_frombranch(&rbyd_, &buf__[buf_size]))); + LFSR_TAG_BRANCH, 0, + lfsr_data_frombranch(&rbyd_, &buf__[buf_size])); buf_size += LFSR_BRANCH_DSIZE; if (rbyd_.weight != rbyd.weight) { attrs__[attr_count++] = LFSR_ATTR( - GROW, -rbyd.weight + rbyd_.weight, NULL()); + LFSR_TAG_GROW, -rbyd.weight + rbyd_.weight, + LFSR_DATA_NULL()); } attrs = attrs__; @@ -5822,7 +5809,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, && file->bshrub_.u.bsprout.u.disk.block != rbyd_.blocks[0]) { int err = lfsr_rbyd_appendcompactattr(lfs, &rbyd_, - LFSR_TAG_SHRUB(DATA), 0, + LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0, file->bshrub.u.bsprout); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -6210,7 +6197,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, && file->bshrub_.u.bsprout.u.disk.block != mdir_->rbyd.blocks[0]) { err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, - LFSR_TAG_SHRUB(DATA), 0, file->bshrub.u.bsprout); + LFSR_TAG_SHRUB | LFSR_TAG_DATA, 0, file->bshrub.u.bsprout); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -6539,13 +6526,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, err = lfsr_btree_commit(lfs, &mtree_.u.btree, 0, LFSR_ATTRS( LFSR_ATTR( - MDIR, +lfsr_mleafweight(lfs), - FROMMPTR(lfsr_mdir_mptr(&mdir_))), + LFSR_TAG_MDIR, +lfsr_mleafweight(lfs), + LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&mdir_))), LFSR_ATTR( - NAME, +lfsr_mleafweight(lfs), DATA(split_data)), + LFSR_TAG_NAME, +lfsr_mleafweight(lfs), split_data), LFSR_ATTR( - MDIR, 0, - FROMMPTR(lfsr_mdir_mptr(&msibling_))))); + LFSR_TAG_MDIR, 0, + LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&msibling_))))); if (err) { return err; } @@ -6558,13 +6545,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, err = lfsr_btree_commit(lfs, &mtree_.u.btree, lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS( LFSR_ATTR( - MDIR, 0, - FROMMPTR(lfsr_mdir_mptr(&mdir_))), + LFSR_TAG_MDIR, 0, + LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&mdir_))), LFSR_ATTR( - NAME, +lfsr_mleafweight(lfs), DATA(split_data)), + LFSR_TAG_NAME, +lfsr_mleafweight(lfs), split_data), LFSR_ATTR( - MDIR, 0, - FROMMPTR(lfsr_mdir_mptr(&msibling_))))); + LFSR_TAG_MDIR, 0, + LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&msibling_))))); if (err) { return err; } @@ -6596,7 +6583,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree err = lfsr_btree_commit(lfs, &mtree_.u.btree, lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS( - LFSR_ATTR(RM, -lfsr_mleafweight(lfs), NULL()))); + LFSR_ATTR( + LFSR_TAG_RM, -lfsr_mleafweight(lfs), + LFSR_DATA_NULL()))); if (err) { return err; } @@ -6625,8 +6614,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, err = lfsr_btree_commit(lfs, &mtree_.u.btree, lfsr_mid_bid(lfs, mdir->mid), LFSR_ATTRS( LFSR_ATTR( - MDIR, 0, - FROMMPTR(lfsr_mdir_mptr(&mdir_))))); + LFSR_TAG_MDIR, 0, + LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&mdir_))))); if (err) { return err; } @@ -6685,11 +6674,11 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, err = lfsr_mdir_commit_(lfs, &mroot_, -1, 0, NULL, -1, LFSR_ATTRS( (lfsr_mtree_ismptr(&mtree_)) ? LFSR_ATTR( - SUBMASK(MDIR), 0, - FROMMPTR(&mtree_.u.mptr.mptr)) + LFSR_TAG_SUBMASK | LFSR_TAG_MDIR, 0, + LFSR_DATA_FROMMPTR(&mtree_.u.mptr.mptr)) : LFSR_ATTR( - SUBMASK(MTREE), 0, - FROMBTREE(&mtree_.u.btree)))); + LFSR_TAG_SUBMASK | LFSR_TAG_MTREE, 0, + LFSR_DATA_FROMBTREE(&mtree_.u.btree)))); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -6723,8 +6712,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, err = lfsr_mdir_commit_(lfs, &mrootparent_, -1, -1, NULL, -1, LFSR_ATTRS( LFSR_ATTR( - MROOT, 0, - FROMMPTR(lfsr_mdir_mptr(&mrootchild_))))); + LFSR_TAG_MROOT, 0, + LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&mrootchild_))))); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_NOENT); @@ -6790,8 +6779,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, err = lfsr_mdir_commit__(lfs, &mrootanchor_, -1, -1, -1, LFSR_ATTRS( LFSR_ATTR( - SUBMASK(MROOT), 0, - FROMMPTR(lfsr_mdir_mptr(&mrootchild_))))); + LFSR_TAG_SUBMASK | LFSR_TAG_MROOT, 0, + LFSR_DATA_FROMMPTR(lfsr_mdir_mptr(&mrootchild_))))); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_NOENT); @@ -8132,17 +8121,32 @@ 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_commit(lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(MAGIC, 0, BUF("littlefs", 8)), - LFSR_ATTR(VERSION, 0, IMM(((const uint8_t[2]){ - LFS_DISK_VERSION_MAJOR, - LFS_DISK_VERSION_MINOR}), 2)), - LFSR_ATTR(RCOMPATFLAGS, 0, IMM((&(uint8_t){ - LFSR_RCOMPAT_GRM}), 1)), - LFSR_ATTR(BLOCKSIZE, 0, LEB128(lfs->cfg->block_size-1)), - LFSR_ATTR(BLOCKCOUNT, 0, LEB128(lfs->cfg->block_count-1)), - LFSR_ATTR(NAMELIMIT, 0, LEB128(lfs->name_limit)), - LFSR_ATTR(SIZELIMIT, 0, LEB128(lfs->size_limit)), - LFSR_ATTR(BOOKMARK, +1, LEB128(0)))); + LFSR_ATTR( + LFSR_TAG_MAGIC, 0, + LFSR_DATA_BUF("littlefs", 8)), + LFSR_ATTR( + LFSR_TAG_VERSION, 0, + LFSR_DATA_IMM(((const uint8_t[2]){ + LFS_DISK_VERSION_MAJOR, + LFS_DISK_VERSION_MINOR}), 2)), + LFSR_ATTR( + LFSR_TAG_RCOMPATFLAGS, 0, + LFSR_DATA_IMM(((uint8_t[1]){LFSR_RCOMPAT_GRM}), 1)), + LFSR_ATTR( + LFSR_TAG_BLOCKSIZE, 0, + LFSR_DATA_LEB128(lfs->cfg->block_size-1)), + LFSR_ATTR( + LFSR_TAG_BLOCKCOUNT, 0, + LFSR_DATA_LEB128(lfs->cfg->block_count-1)), + LFSR_ATTR( + LFSR_TAG_NAMELIMIT, 0, + LFSR_DATA_LEB128(lfs->name_limit)), + LFSR_ATTR( + LFSR_TAG_SIZELIMIT, 0, + LFSR_DATA_LEB128(lfs->size_limit)), + LFSR_ATTR( + LFSR_TAG_BOOKMARK, +1, + LFSR_DATA_LEB128(0)))); if (err) { return err; } @@ -8392,8 +8396,8 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) { LFS_ASSERT(lfsr_mid_rid(lfs, lfs->grm.rms[0]) < (lfsr_srid_t)mdir.rbyd.weight); err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()), - LFSR_ATTR(GRM, 0, GRM(&grm)))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_ATTR(LFSR_TAG_GRM, 0, LFSR_DATA_GRM(&grm)))); } return 0; @@ -8424,7 +8428,7 @@ static int lfsr_fs_fixorphans(lfs_t *lfs) { if (err != LFS_ERR_NOENT) { // remove orphaned file err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); if (err) { return err; } @@ -8609,8 +8613,10 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { // commit our bookmark and a grm to self-remove in case of powerloss err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(BOOKMARK, +1, LEB128(did_)), - LFSR_ATTR(GRM, 0, GRM(&((lfsr_grm_t){{mdir.mid, -1}}))))); + LFSR_ATTR(LFSR_TAG_BOOKMARK, +1, LFSR_DATA_LEB128(did_)), + LFSR_ATTR( + LFSR_TAG_GRM, 0, + LFSR_DATA_GRM(&((lfsr_grm_t){{mdir.mid, -1}}))))); if (err) { return err; } @@ -8629,11 +8635,14 @@ int lfsr_mkdir(lfs_t *lfs, const char *path) { // process err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( LFSR_ATTR( - SUPMASK(DIR), (!exists) ? +1 : 0, CAT( + LFSR_TAG_SUPMASK | LFSR_TAG_DIR, (!exists) ? +1 : 0, + LFSR_DATA_CAT( LFSR_DATA_LEB128(did), LFSR_DATA_BUF(name, name_size))), - LFSR_ATTR(DID, 0, LEB128(did_)), - LFSR_ATTR(GRM, 0, GRM(&((lfsr_grm_t){{-1, -1}}))))); + LFSR_ATTR(LFSR_TAG_DID, 0, LFSR_DATA_LEB128(did_)), + LFSR_ATTR( + LFSR_TAG_GRM, 0, + LFSR_DATA_GRM(&((lfsr_grm_t){{-1, -1}}))))); if (err) { return err; } @@ -8732,11 +8741,14 @@ int lfsr_remove(lfs_t *lfs, const char *path) { // we use a create+delete here to also clear any attrs // and trim the entry size (zombie) - ? LFSR_ATTR(SUPMASK(ORPHAN), 0, CAT( - LFSR_DATA_LEB128(did), - LFSR_DATA_BUF(name, name_size))) - : LFSR_ATTR(RM, -1, NULL()), - LFSR_ATTR(GRM, 0, GRM(&grm)))); + ? LFSR_ATTR( + LFSR_TAG_SUPMASK | LFSR_TAG_ORPHAN, 0, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(did), + LFSR_DATA_BUF(name, name_size))) + : LFSR_ATTR( + LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_ATTR(LFSR_TAG_GRM, 0, LFSR_DATA_GRM(&grm)))); if (err) { return err; } @@ -8880,11 +8892,12 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) { // new rid, while also marking the old rid for removal err = lfsr_mdir_commit(lfs, &new_mdir, LFSR_ATTRS( LFSR_ATTR( - SUPMASK(TAG(old_tag)), (!exists) ? +1 : 0, CAT( + LFSR_TAG_SUPMASK | old_tag, (!exists) ? +1 : 0, + LFSR_DATA_CAT( LFSR_DATA_LEB128(new_did), LFSR_DATA_BUF(new_name, new_name_size))), - LFSR_ATTR(MOVE, 0, MOVE(&old_mdir)), - LFSR_ATTR(GRM, 0, GRM(&grm)))); + LFSR_ATTR(LFSR_TAG_MOVE, 0, LFSR_DATA_MOVE(&old_mdir)), + LFSR_ATTR(LFSR_TAG_GRM, 0, LFSR_DATA_GRM(&grm)))); if (err) { return err; } @@ -9358,7 +9371,8 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file, if (!err) { err = lfsr_mdir_commit(lfs, &file->m.mdir, LFSR_ATTRS( LFSR_ATTR( - ORPHAN, +1, CAT( + LFSR_TAG_ORPHAN, +1, + LFSR_DATA_CAT( LFSR_DATA_LEB128(did), LFSR_DATA_BUF(name, name_size))))); if (err) { @@ -9906,10 +9920,10 @@ static int lfsr_bshrub_commit(lfs_t *lfs, lfsr_file_t *file, lfsr_bid_t bid, // commit to shrub int err = lfsr_mdir_commit(lfs, &file->m.mdir, LFSR_ATTRS( LFSR_ATTR( - TAG((alloc) + (alloc) ? LFSR_TAG_SHRUBALLOC - : LFSR_TAG_SHRUBCOMMIT), 0, - SHRUBCOMMIT(&file->bshrub_.u.bshrub, bid, + : LFSR_TAG_SHRUBCOMMIT, 0, + LFSR_DATA_SHRUBCOMMIT(&file->bshrub_.u.bshrub, bid, attrs, attr_count)))); if (err) { return err; @@ -9997,14 +10011,12 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // data before insertion if (lfsr_bshrub_isbsprout(&file->m.mdir, &file->bshrub)) { attrs[attr_count++] = LFSR_ATTR( - DATA, +lfsr_bshrub_size(&file->bshrub), - DATA(file->bshrub.u.bsprout)); + LFSR_TAG_DATA, +lfsr_bshrub_size(&file->bshrub), + file->bshrub.u.bsprout); } else if (lfsr_bshrub_isbptr(&file->m.mdir, &file->bshrub)) { attrs[attr_count++] = LFSR_ATTR( - BLOCK, +lfsr_bshrub_size(&file->bshrub), - DATA(lfsr_data_frombptr( - &file->bshrub.u.bptr, - &buf[buf_size]))); + LFSR_TAG_BLOCK, +lfsr_bshrub_size(&file->bshrub), + lfsr_data_frombptr(&file->bshrub.u.bptr, &buf[buf_size])); buf_size += LFSR_BPTR_DSIZE; } @@ -10034,13 +10046,15 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, if (lfsr_bshrub_size(&file->bshrub) > 0) { bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub)-1); attrs[attr_count++] = LFSR_ATTR( - GROW, +(pos - lfsr_bshrub_size(&file->bshrub)), NULL()); + LFSR_TAG_GROW, +(pos - lfsr_bshrub_size(&file->bshrub)), + LFSR_DATA_NULL()); // new hole } else { bid = lfs_min32(bid, lfsr_bshrub_size(&file->bshrub)); attrs[attr_count++] = LFSR_ATTR( - DATA, +(pos - lfsr_bshrub_size(&file->bshrub)), NULL()); + LFSR_TAG_DATA, +(pos - lfsr_bshrub_size(&file->bshrub)), + LFSR_DATA_NULL()); } } @@ -10076,13 +10090,13 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, err = lfsr_bshrub_commit(lfs, file, bid, LFSR_ATTRS( LFSR_ATTR( - GROW(SUBMASK(DATA)), + LFSR_TAG_GROW | LFSR_TAG_SUBMASK | LFSR_TAG_DATA, -(weight_ - lfs->cfg->fragment_size), - DATA(lfsr_data_truncate(left_slice_, - lfs->cfg->fragment_size))), + lfsr_data_truncate(left_slice_, + lfs->cfg->fragment_size)), LFSR_ATTR( - BLOCK, +(weight_ - lfs->cfg->fragment_size), - FROMBPTR(&bptr_)))); + LFSR_TAG_BLOCK, +(weight_ - lfs->cfg->fragment_size), + LFSR_DATA_FROMBPTR(&bptr_)))); if (err) { return err; } @@ -10103,13 +10117,14 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, err = lfsr_bshrub_commit(lfs, file, bid, LFSR_ATTRS( LFSR_ATTR( - GROW(SUBMASK(BLOCK)), + LFSR_TAG_GROW | LFSR_TAG_SUBMASK | LFSR_TAG_BLOCK, -(weight_ - lfsr_data_size(&bptr_.data)), - FROMBPTR(&bptr_)), + LFSR_DATA_FROMBPTR(&bptr_)), LFSR_ATTR( - DATA, +(weight_ - lfsr_data_size(&bptr_.data)), - DATA(lfsr_data_fruncate(right_slice_, - lfs->cfg->fragment_size))))); + LFSR_TAG_DATA, + +(weight_ - lfsr_data_size(&bptr_.data)), + lfsr_data_fruncate(right_slice_, + lfs->cfg->fragment_size)))); if (err) { return err; } @@ -10126,7 +10141,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, // can we get away with a grow attribute? if (lfsr_data_size(&bptr_.data) == lfsr_data_size(&left_slice_)) { attrs[attr_count++] = LFSR_ATTR( - GROW, -(bid+1 - pos), NULL()); + LFSR_TAG_GROW, -(bid+1 - pos), LFSR_DATA_NULL()); // carve bptr? } else if (tag_ == LFSR_TAG_BLOCK) { @@ -10136,21 +10151,23 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, .cksum = bptr_.cksum, }; attrs[attr_count++] = LFSR_ATTR( - GROW(SUBMASK(BLOCK)), -(bid+1 - pos), - DATA(lfsr_data_frombptr(&bptr__, &buf[buf_size]))); + LFSR_TAG_GROW | LFSR_TAG_SUBMASK | LFSR_TAG_BLOCK, + -(bid+1 - pos), + lfsr_data_frombptr(&bptr__, &buf[buf_size])); buf_size += LFSR_BPTR_DSIZE; // carve fragment? } else { attrs[attr_count++] = LFSR_ATTR( - GROW(SUBMASK(DATA)), -(bid+1 - pos), - DATA(left_slice_)); + LFSR_TAG_GROW | LFSR_TAG_SUBMASK | LFSR_TAG_DATA, + -(bid+1 - pos), + left_slice_); } // completely overwriting this entry? } else { attrs[attr_count++] = LFSR_ATTR( - RM, -weight_, NULL()); + LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()); } // spans more than one entry? we can't do everything in one commit, @@ -10187,25 +10204,23 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, .cksum = bptr_.cksum, }; attrs[attr_count+attr_tnuoc++] = LFSR_ATTR( - BLOCK, +(bid+1 - (pos+weight)), - DATA(lfsr_data_frombptr(&bptr__, &buf[buf_size]))); + LFSR_TAG_BLOCK, +(bid+1 - (pos+weight)), + lfsr_data_frombptr(&bptr__, &buf[buf_size])); buf_size += LFSR_BPTR_DSIZE; // copy over becksum since erase-state is still valid if (becksum_.cksize != -1) { attrs[attr_count+attr_tnuoc++] = LFSR_ATTR( - BECKSUM, 0, - DATA(lfsr_data_fromecksum( - &becksum_, - &buf[buf_size]))); + LFSR_TAG_BECKSUM, 0, + lfsr_data_fromecksum(&becksum_, &buf[buf_size])); buf_size += LFSR_ECKSUM_DSIZE; } // carve fragment? } else { attrs[attr_count+attr_tnuoc++] = LFSR_ATTR( - DATA, +(bid+1 - (pos+weight)), - DATA(right_slice_)); + LFSR_TAG_DATA, +(bid+1 - (pos+weight)), + right_slice_); } } @@ -10222,7 +10237,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, memmove(&attrs[attr_count+1], &attrs[attr_count], attr_tnuoc*sizeof(lfsr_attr_t)); attrs[attr_count++] = LFSR_ATTR( - GROW, +(weight + delta), NULL()); + LFSR_TAG_GROW, +(weight + delta), LFSR_DATA_NULL()); // need a new hole? } else if (!bptr || lfsr_data_size(&bptr->data) == 0) { @@ -10230,7 +10245,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, memmove(&attrs[attr_count+1], &attrs[attr_count], attr_tnuoc*sizeof(lfsr_attr_t)); attrs[attr_count++] = LFSR_ATTR( - DATA, +(weight + delta), NULL()); + LFSR_TAG_DATA, +(weight + delta), LFSR_DATA_NULL()); // append new fragment? } else if (tag == LFSR_TAG_DATA) { @@ -10238,7 +10253,7 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, memmove(&attrs[attr_count+1], &attrs[attr_count], attr_tnuoc*sizeof(lfsr_attr_t)); attrs[attr_count++] = LFSR_ATTR( - DATA, +(weight + delta), DATA(bptr->data)); + LFSR_TAG_DATA, +(weight + delta), bptr->data); // append a new block? } else if (tag == LFSR_TAG_BLOCK) { @@ -10246,8 +10261,8 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, memmove(&attrs[attr_count+1], &attrs[attr_count], attr_tnuoc*sizeof(lfsr_attr_t)); attrs[attr_count++] = LFSR_ATTR( - BLOCK, +(weight + delta), - DATA(lfsr_data_frombptr(bptr, &buf[buf_size]))); + LFSR_TAG_BLOCK, +(weight + delta), + lfsr_data_frombptr(bptr, &buf[buf_size])); buf_size += LFSR_BPTR_DSIZE; // append becksum? @@ -10255,10 +10270,8 @@ static int lfsr_file_carve(lfs_t *lfs, lfsr_file_t *file, memmove(&attrs[attr_count+1], &attrs[attr_count], attr_tnuoc*sizeof(lfsr_attr_t)); attrs[attr_count++] = LFSR_ATTR( - BECKSUM, 0, - DATA(lfsr_data_fromecksum( - becksum, - &buf[buf_size]))); + LFSR_TAG_BECKSUM, 0, + lfsr_data_fromecksum(becksum, &buf[buf_size])); buf_size += LFSR_ECKSUM_DSIZE; } @@ -11140,7 +11153,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { } attrs[attr_count++] = LFSR_ATTR( - SUBMASK(REG), 0, DATA(data)); + LFSR_TAG_SUBMASK | LFSR_TAG_REG, 0, data); } // commit the file state @@ -11148,25 +11161,25 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) { // null? no attr? if (lfsr_f_isunflush(file->m.flags) && file->buffer_size == 0) { attrs[attr_count++] = LFSR_ATTR( - SUBMASK(RM(STRUCT)), 0, - NULL()); + LFSR_TAG_RM | LFSR_TAG_SUBMASK | LFSR_TAG_STRUCT, 0, + LFSR_DATA_NULL()); // small file inlined in mdir? } else if (lfsr_f_isunflush(file->m.flags)) { attrs[attr_count++] = LFSR_ATTR( - SUBMASK(DATA), 0, - BUF(file->buffer, file->buffer_size)); + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(file->buffer, file->buffer_size)); // bshrub? } else if (lfsr_bshrub_isbshrub(&file->m.mdir, &file->bshrub)) { attrs[attr_count++] = LFSR_ATTR( - SUBMASK(SHRUBTRUNK), 0, - SHRUBTRUNK(&file->bshrub_.u.bshrub)); + LFSR_TAG_SUBMASK | LFSR_TAG_SHRUBTRUNK, 0, + LFSR_DATA_SHRUBTRUNK(&file->bshrub_.u.bshrub)); // btree? } else if (lfsr_bshrub_isbtree(&file->m.mdir, &file->bshrub)) { attrs[attr_count++] = LFSR_ATTR( - SUBMASK(BTREE), 0, - DATA(lfsr_data_frombtree( + LFSR_TAG_SUBMASK | LFSR_TAG_BTREE, 0, + lfsr_data_frombtree( &file->bshrub.u.btree, - &buf[buf_size]))); + &buf[buf_size])); buf_size += LFSR_BTREE_DSIZE; } else { LFS_UNREACHABLE(); diff --git a/tests/test_btree.toml b/tests/test_btree.toml index 50450795..a3cf8c21 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -55,7 +55,7 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -97,9 +97,9 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -147,9 +147,9 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -198,11 +198,11 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("c", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -257,11 +257,11 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("c", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -321,7 +321,9 @@ code = ''' lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -375,7 +377,9 @@ code = ''' lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+((N-1-i) % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -443,7 +447,9 @@ code = ''' // add to btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -516,7 +522,9 @@ code = ''' lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( - LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +W, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -610,7 +618,9 @@ code = ''' // add to btree int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS( - LFSR_ATTR(DATA, +weight, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +weight, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -724,10 +734,12 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; // update the tree lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF("A", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF("A", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -768,14 +780,18 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; // update the tree lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF("A", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF("A", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF("B", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF("B", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -823,18 +839,24 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("c", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; // update the tree lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF("A", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF("A", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF("B", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF("B", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF("C", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF("C", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -891,7 +913,9 @@ code = ''' lfsr_btree_alloc(&lfs, &btree) => 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -905,7 +929,9 @@ code = ''' // update the tree for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF(&(uint8_t){'A'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -963,7 +989,9 @@ code = ''' lfsr_btree_alloc(&lfs, &btree) => 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -991,7 +1019,9 @@ code = ''' // update btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF(&(uint8_t){'A'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -1060,7 +1090,9 @@ code = ''' lfsr_btree_alloc(&lfs, &btree) => 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( - LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +W, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1074,7 +1106,9 @@ code = ''' // update the tree for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i*W+W-1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF(&(uint8_t){'A'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1147,7 +1181,9 @@ code = ''' lfsr_btree_alloc(&lfs, &btree) => 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( - LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +W, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1186,9 +1222,12 @@ code = ''' // update btree int err = lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF( - &(uint8_t){'A'+(i % 26)}, 1)), - LFSR_ATTR(GROW, +weight-sim_weights[bid], NULL()))); + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)), + LFSR_ATTR( + LFSR_TAG_GROW, +weight-sim_weights[bid], + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -1299,10 +1338,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; // pop! lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1320,7 +1359,7 @@ code = ''' // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("A", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1356,12 +1395,12 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; // pop! lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1386,7 +1425,7 @@ code = ''' // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("B", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("B", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1429,12 +1468,12 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; // pop! lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1459,7 +1498,7 @@ code = ''' // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("A", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("A", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1502,14 +1541,14 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("a", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("a", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("b", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("b", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("c", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("c", 1)))) => 0; // pop! lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1541,7 +1580,7 @@ code = ''' // try to putting it back to see if things still work lfsr_btree_commit(&lfs, &btree, 2, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("C", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("C", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -1595,7 +1634,9 @@ code = ''' lfsr_btree_alloc(&lfs, &btree) => 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1609,7 +1650,7 @@ code = ''' // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { int err = lfsr_btree_commit(&lfs, &btree, N-1-i, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1648,7 +1689,7 @@ code = ''' // try recovering lfsr_btree_commit(&lfs, &btree, REMAINING, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("R", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0; for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_lookup(&lfs, &btree, i, @@ -1691,7 +1732,9 @@ code = ''' lfsr_btree_alloc(&lfs, &btree) => 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1705,7 +1748,7 @@ code = ''' // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { int err = lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1744,7 +1787,7 @@ code = ''' // try recovering lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("R", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("R", 1)))) => 0; lfsr_btree_lookup(&lfs, &btree, 0, &tag_, &weight_, &data_) => 0; @@ -1789,7 +1832,9 @@ code = ''' lfsr_btree_alloc(&lfs, &btree) => 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1818,7 +1863,7 @@ code = ''' // remove from btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -1890,7 +1935,9 @@ code = ''' lfsr_btree_alloc(&lfs, &btree) => 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i*W, LFSR_ATTRS( - LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +W, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1904,7 +1951,7 @@ code = ''' // drain the tree for (lfs_size_t i = 0; i < N-REMAINING; i++) { int err = lfsr_btree_commit(&lfs, &btree, (N-1-i)*W+W-1, LFSR_ATTRS( - LFSR_ATTR(RM, -W, NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -1942,7 +1989,7 @@ code = ''' // try recovering lfsr_btree_commit(&lfs, &btree, REMAINING*W, LFSR_ATTRS( - LFSR_ATTR(DATA, +W, BUF("R", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("R", 1)))) => 0; for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_lookup(&lfs, &btree, i*W+W-1, @@ -2032,7 +2079,9 @@ code = ''' } int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS( - LFSR_ATTR(DATA, +weight, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +weight, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", @@ -2061,7 +2110,9 @@ code = ''' // remove from btree int err = lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR(RM, -sim_weights[bid], NULL()))); + LFSR_ATTR( + LFSR_TAG_RM, -sim_weights[bid], + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2172,12 +2223,18 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2230,7 +2287,7 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("_", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -2248,8 +2305,12 @@ code = ''' // split btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'a'+(i % 26)}, 1)), - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'A'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2321,12 +2382,18 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_DATA, +W, + LFSR_DATA_BUF(&(uint8_t){'a'+(0 % 26)}, 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), - LFSR_ATTR(DATA, +W, BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'a'+((i-1) % 26)}, 1)), + LFSR_ATTR( + LFSR_TAG_DATA, +W, + LFSR_DATA_BUF(&(uint8_t){'a'+((i-0) % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2380,7 +2447,7 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +W, BUF("_", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +W, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -2411,11 +2478,15 @@ code = ''' // split btree int err = lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR(GROW, +weight1-sim_weights[bid], NULL()), - LFSR_ATTR(DATA, 0, BUF( - &(uint8_t){'a'+(i % 26)}, 1)), - LFSR_ATTR(DATA, +weight2, BUF( - &(uint8_t){'A'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_GROW, +weight1-sim_weights[bid], + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), + LFSR_ATTR( + LFSR_TAG_DATA, +weight2, + LFSR_DATA_BUF(&(uint8_t){'A'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2562,25 +2633,27 @@ code = ''' // the extra push here avoids trying to inline the big entry lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("_", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF(buf1, SIZE)), - LFSR_ATTR(DATA, +1, BUF(buf2, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF(buf2, SIZE)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(buf2, SIZE)))) => 0; assert(btree.weight == 2); // now remove one entry, since this brings the rbyd down to zero, // this should force one of the blocks to drop lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2628,19 +2701,21 @@ code = ''' // the extra push here avoids trying to inline the big entry lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("_", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF(buf1, SIZE)), - LFSR_ATTR(DATA, +1, BUF(buf2, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF(buf2, SIZE)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(buf2, SIZE)))) => 0; assert(btree.weight == 2); // now remove one entry, since this brings the rbyd down this zero, @@ -2649,7 +2724,7 @@ code = ''' // do this while forcing a compaction btree.eoff = -1; lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2697,14 +2772,14 @@ code = ''' // the extra push here avoids trying to inline the big entry lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("_", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF(buf1, SIZE)), - LFSR_ATTR(DATA, +1, BUF(buf2, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; // force compaction, causing a split, but while we're splitting, // also remove an entry, bringing the split rbyd down to zero mid split @@ -2713,7 +2788,7 @@ code = ''' // btree.eoff = -1; lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2761,32 +2836,38 @@ code = ''' // the extra push here avoids trying to inline the big entry lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF("_", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF("_", 1)))) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF(buf1, SIZE)), - LFSR_ATTR(DATA, +1, BUF(buf2, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF(buf1, SIZE)), + LFSR_ATTR(LFSR_TAG_DATA, +1, LFSR_DATA_BUF(buf2, SIZE)))) => 0; // force compaction btree.eoff = -1; memset(buf2, 'b', SIZE); lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF(buf2, SIZE)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(buf2, SIZE)))) => 0; assert(btree.weight == 2); // now make both entries small so they should be merged if either compacts lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF("a", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF("a", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF("b", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF("b", 1)))) => 0; // force compaction, while removing one entry, this drops the rbyd // down to zero while also triggering a merge btree.eoff = -1; lfsr_btree_commit(&lfs, &btree, SIBLING, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -2849,7 +2930,9 @@ code = ''' if (op == 0 || bid == sim_size) { // push to btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2864,8 +2947,9 @@ code = ''' } else if (op == 1) { // update btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF( - &(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2878,7 +2962,7 @@ code = ''' } else { // pop from btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2977,8 +3061,9 @@ code = ''' if (op == 0 || bid == sim_size) { // push to btree int err = lfsr_btree_commit(&lfs, &btree, weighted_bid, LFSR_ATTRS( - LFSR_ATTR(DATA, +weight, BUF( - &(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +weight, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2997,9 +3082,12 @@ code = ''' // update btree int err = lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF( - &(uint8_t){'a'+(i % 26)}, 1)), - LFSR_ATTR(GROW, +weight-sim_weights[bid], NULL()))); + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)), + LFSR_ATTR( + LFSR_TAG_GROW, +weight-sim_weights[bid], + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3014,7 +3102,9 @@ code = ''' // remove from btree int err = lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR(RM, -sim_weights[bid], NULL()))); + LFSR_ATTR( + LFSR_TAG_RM, -sim_weights[bid], + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3159,9 +3249,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(NAME, +1, - CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), - LFSR_ATTR(DATA, 0, BUF("0", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3211,15 +3302,16 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(NAME, +1, - CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), - LFSR_ATTR(DATA, 0, BUF("0", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF("0", 1)), - LFSR_ATTR(NAME, +1, CAT( - LFSR_DATA_LEB128(0), - LFSR_DATA_BUF("aab", 3))), - LFSR_ATTR(DATA, 0, BUF("1", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aab", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3277,21 +3369,28 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(NAME, +1, - CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), - LFSR_ATTR(DATA, 0, BUF("0", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF("aaa", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF("0", 1)), - LFSR_ATTR(NAME, +1, CAT( - LFSR_DATA_LEB128(1*DID), - LFSR_DATA_BUF("aab", 3))), - LFSR_ATTR(DATA, 0, BUF("1", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(1*DID), + LFSR_DATA_BUF("aab", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF("1", 1)), - LFSR_ATTR(NAME, +1, CAT( - LFSR_DATA_LEB128(2*DID), - LFSR_DATA_BUF("aac", 3))), - LFSR_ATTR(DATA, 0, BUF("2", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(2*DID), + LFSR_DATA_BUF("aac", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3357,21 +3456,28 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(NAME, +1, - CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), - LFSR_ATTR( DATA, 0, BUF("0", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF("aaa", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF("1", 1)), - LFSR_ATTR(NAME, +1, CAT( - LFSR_DATA_LEB128(2*DID), - LFSR_DATA_BUF("aac", 3))), - LFSR_ATTR(DATA, 0, BUF("2", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(2*DID), + LFSR_DATA_BUF("aac", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF("0", 1)), - LFSR_ATTR(NAME, +1, CAT( - LFSR_DATA_LEB128(1*DID), - LFSR_DATA_BUF("aab", 3))), - LFSR_ATTR(DATA, 0, BUF("1", 1)))) => 0; + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(1*DID), + LFSR_DATA_BUF("aab", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3441,20 +3547,28 @@ code = ''' 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(NAME, +1, - CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; int err = lfsr_btree_commit(&lfs, &btree, i-1, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), - LFSR_ATTR(NAME, +1, CAT( - LFSR_DATA_LEB128(i*DID), - LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), + LFSR_ATTR( + LFSR_TAG_NAME, +1, LFSR_DATA_CAT( + LFSR_DATA_LEB128(i*DID), + LFSR_DATA_BUF(name, 3))), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3509,9 +3623,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(NAME, +1, - CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), - LFSR_ATTR(DATA, 0, BUF("_", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3545,11 +3660,17 @@ code = ''' // split btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1)), - LFSR_ATTR(NAME, +1, CAT( - LFSR_DATA_LEB128(0), - LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3627,20 +3748,29 @@ code = ''' 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(NAME, +W, - CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_NAME, +W, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; int err = lfsr_btree_commit(&lfs, &btree, (i-1)*W+W-1, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), - LFSR_ATTR(NAME, +W, CAT( - LFSR_DATA_LEB128(i*DID), - LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), + LFSR_ATTR( + LFSR_TAG_NAME, +W, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(i*DID), + LFSR_DATA_BUF(name, 3))), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3696,9 +3826,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(NAME, +W, - CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), - LFSR_ATTR(DATA, 0, BUF("_", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_NAME, +W, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3745,12 +3876,20 @@ code = ''' // split btree int err = lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR(GROW, +weight1-sim_weights[bid], NULL()), - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1)), - LFSR_ATTR(NAME, +weight2, CAT( - LFSR_DATA_LEB128(0), - LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_ATTR( + LFSR_TAG_GROW, +weight1-sim_weights[bid], + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), + LFSR_ATTR( + LFSR_TAG_NAME, +weight2, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3850,9 +3989,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(NAME, +1, - CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), - LFSR_ATTR(DATA, 0, BUF("_", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3900,11 +4040,14 @@ code = ''' if (cmp > LFS_CMP_EQ) { int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS( - LFSR_ATTR(NAME, +1, CAT( - LFSR_DATA_LEB128(0), - LFSR_DATA_BUF(name, 3))), LFSR_ATTR( - DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3912,11 +4055,15 @@ code = ''' assert(err == 0); } else { int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, DATA( split_data)), - LFSR_ATTR(NAME, +1, CAT( - LFSR_DATA_LEB128(0), - LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_ATTR(LFSR_TAG_DATA, 0, split_data), + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3934,8 +4081,9 @@ code = ''' } else if (op == 1) { // update btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF( - &(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3948,7 +4096,7 @@ code = ''' } else { // pop from btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))); + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4019,9 +4167,10 @@ code = ''' lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( - LFSR_ATTR(NAME, +W, - CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), - LFSR_ATTR(DATA, 0, BUF("_", 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_NAME, +W, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), + LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -4082,11 +4231,13 @@ code = ''' int err = lfsr_btree_commit(&lfs, &btree, split_bid-(split_weight-1), LFSR_ATTRS( LFSR_ATTR( - NAME, +weight, CAT( + LFSR_TAG_NAME, +weight, + LFSR_DATA_CAT( LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), LFSR_ATTR( - DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4094,12 +4245,15 @@ code = ''' assert(err == 0); } else { int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS( - LFSR_ATTR(DATA, 0, DATA( - split_data)), - LFSR_ATTR(NAME, +weight, CAT( - LFSR_DATA_LEB128(0), - LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(DATA, 0, BUF(&(uint8_t){'0'+(i % 10)}, 1)))); + LFSR_ATTR(LFSR_TAG_DATA, 0, split_data), + LFSR_ATTR( + LFSR_TAG_NAME, +weight, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), + LFSR_ATTR( + LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4121,9 +4275,12 @@ code = ''' // update btree int err = lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(DATA), 0, BUF( - &(uint8_t){'0'+(i % 10)}, 1)), - LFSR_ATTR(GROW, +weight-sim_weights[bid], NULL()))); + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_DATA, 0, + LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), + LFSR_ATTR( + LFSR_TAG_GROW, +weight-sim_weights[bid], + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4138,7 +4295,9 @@ code = ''' // pop from btree int err = lfsr_btree_commit(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_ATTRS( - LFSR_ATTR(RM, -sim_weights[bid], NULL()))); + LFSR_ATTR( + LFSR_TAG_RM, -sim_weights[bid], + LFSR_DATA_NULL()))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4237,7 +4396,9 @@ code = ''' lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { int err = lfsr_btree_commit(&lfs, &btree, i, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4375,7 +4536,9 @@ code = ''' // add to btree int err = lfsr_btree_commit(&lfs, &btree, bid, LFSR_ATTRS( - LFSR_ATTR(DATA, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))); + LFSR_ATTR( + LFSR_TAG_DATA, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index 058c942e..455dfcc4 100644 --- a/tests/test_mtree.toml +++ b/tests/test_mtree.toml @@ -26,7 +26,9 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(UATTR(i), 0, BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(i), 0, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } for (lfs_size_t i = 0; i < N; i++) { @@ -70,7 +72,8 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR( - UATTR(i), 0, BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_TAG_UATTR(i), 0, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } for (lfs_size_t i = 0; i < N; i++) { @@ -111,7 +114,8 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR( - UATTR(1), 0, BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; lfsr_data_t data; uint8_t buffer[4]; @@ -158,13 +162,13 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -228,13 +232,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -302,13 +306,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -324,7 +328,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mdir to compact mdir.rbyd.eoff = -1; @@ -411,7 +415,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; uint8_t buffer[256]; @@ -501,7 +505,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -584,13 +588,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -606,7 +610,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // assert mdir was dropped assert(lfsr_mtree_weight(&lfs.mtree) == 1*lfsr_mleafweight(&lfs)); @@ -658,13 +662,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -682,7 +686,7 @@ code = ''' // force mdir to compact while we're removing mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // assert mdir was dropped assert(lfsr_mtree_weight(&lfs.mtree) == 1*lfsr_mleafweight(&lfs)); @@ -734,13 +738,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // remove an entry, forcing the mdir to be dropped memset(buffer+1, 'b', SIZE-1); @@ -750,7 +754,7 @@ code = ''' lfs.mroot.rbyd.eoff = -1; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // assert split/drop worked out assert(lfsr_mtree_weight(&lfs.mtree) == 1*lfsr_mleafweight(&lfs)); @@ -802,13 +806,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -824,7 +828,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // remove an entry, forcing the mdir to be dropped memset(buffer+1, 'b', SIZE-1); @@ -833,7 +837,7 @@ code = ''' // force mdir to compact while we're removing mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // assert split/drop worked out assert(lfsr_mtree_weight(&lfs.mtree) == 2*lfsr_mleafweight(&lfs)); @@ -897,13 +901,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -919,7 +923,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // remove an entry, forcing the mdir to be dropped memset(buffer+1, 'c', SIZE-1); @@ -928,7 +932,7 @@ code = ''' // force mdir to compact while we're removing mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // assert split/drop worked out assert(lfsr_mtree_weight(&lfs.mtree) == 2*lfsr_mleafweight(&lfs)); @@ -1019,7 +1023,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -1048,7 +1052,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } } @@ -1123,13 +1127,13 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -1145,10 +1149,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1212,13 +1216,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -1236,10 +1240,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1307,13 +1311,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -1331,10 +1335,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1402,7 +1406,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; @@ -1458,7 +1462,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; @@ -1525,7 +1529,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; @@ -1587,13 +1591,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -1614,10 +1618,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated @@ -1687,13 +1691,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -1709,7 +1713,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // setup mroot to compact and relocate on next commit lfs.mroot.rbyd.eoff = -1; @@ -1718,10 +1722,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated @@ -1803,13 +1807,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -1830,11 +1834,11 @@ code = ''' // force mdir to compact twice, this should relocate mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mdir to compact while we're removing mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // assert mroot relocated assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -1891,13 +1895,13 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact, this should both uninline and relocate lfsr_mdir_t old_mroot = lfs.mroot; @@ -1971,13 +1975,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact, this should both split and relocate lfsr_mdir_t old_mroot = lfs.mroot; @@ -2077,7 +2081,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -2107,7 +2111,7 @@ code = ''' // we can't really change metadata names, but commits still // trigger writes to the mdir lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -2136,7 +2140,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } } @@ -2206,14 +2210,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; lfsr_opened_add(&lfs, &left); lfsr_opened_t right = {.type=0}; lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "c", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0c", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0c", 2)))) => 0; lfsr_opened_add(&lfs, &right); // insert a new entry, this should update our neighbors @@ -2221,7 +2225,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "b", 1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0b", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; lfsr_data_t data; // assert our entry was created @@ -2262,14 +2266,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; lfsr_opened_add(&lfs, &left); lfsr_opened_t right = {.type=0}; lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "b", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0b", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; lfsr_opened_add(&lfs, &right); // try removing left neighbor @@ -2277,7 +2281,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &mdir, NULL, NULL) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // assert neighbor was removed lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, @@ -2309,14 +2313,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; lfsr_opened_add(&lfs, &left); lfsr_opened_t right = {.type=0}; lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "b", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0b", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; lfsr_opened_add(&lfs, &right); // try removing right neighbor @@ -2324,7 +2328,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "b", 1, &mdir, NULL, NULL) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // assert neighbor was removed lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "b", 1, @@ -2358,14 +2362,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; lfsr_opened_add(&lfs, &left); lfsr_opened_t right = {.type=0}; lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "d", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0d", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; lfsr_opened_add(&lfs, &right); // create 2 large entries that needs to be uninlined and split @@ -2376,13 +2380,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'c', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -2427,14 +2431,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; lfsr_opened_add(&lfs, &left); lfsr_opened_t right = {.type=0}; lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "e", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0e", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0; lfsr_opened_add(&lfs, &right); // create 2 large entries that needs to be uninlined and split @@ -2445,13 +2449,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'd', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -2462,7 +2466,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mdir to compact mdir.rbyd.eoff = -1; @@ -2507,14 +2511,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; lfsr_opened_add(&lfs, &left); lfsr_opened_t right = {.type=0}; lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "b", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0b", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0b", 2)))) => 0; lfsr_opened_add(&lfs, &right); // force mroot to compact twice, this should extend the mroot @@ -2563,14 +2567,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; lfsr_opened_add(&lfs, &left); lfsr_opened_t right = {.type=0}; lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "d", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0d", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; lfsr_opened_add(&lfs, &right); // create 2 large entries that needs to be uninlined and split @@ -2581,13 +2585,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'c', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -2605,10 +2609,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -2648,14 +2652,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; lfsr_opened_add(&lfs, &left); lfsr_opened_t right = {.type=0}; lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "d", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0d", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0d", 2)))) => 0; lfsr_opened_add(&lfs, &right); // create 2 large entries that needs to be uninlined and split @@ -2666,13 +2670,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'c', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -2690,10 +2694,10 @@ code = ''' lfsr_mdir_t old_mdir = mdir; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -2731,14 +2735,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; lfsr_opened_add(&lfs, &left); lfsr_opened_t right = {.type=0}; lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "f", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0f", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0f", 2)))) => 0; lfsr_opened_add(&lfs, &right); // create 2 large entries that needs to be uninlined and split @@ -2749,13 +2753,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'e', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -2766,7 +2770,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mdir to compact mdir.rbyd.eoff = -1; @@ -2782,7 +2786,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mdir to compact mdir.rbyd.eoff = -1; @@ -2827,14 +2831,14 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &left.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &left.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; lfsr_opened_add(&lfs, &left); lfsr_opened_t right = {.type=0}; lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "e", 1, &right.mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &right.mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0e", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0e", 2)))) => 0; lfsr_opened_add(&lfs, &right); // create 2 large entries that needs to be uninlined and split @@ -2845,13 +2849,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'd', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -2862,7 +2866,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mdir to compact mdir.rbyd.eoff = -1; @@ -2875,7 +2879,7 @@ code = ''' // now remove the middle entry, forcing a drop lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; // assert mdir was dropped correctly assert(lfsr_mtree_weight(&lfs.mtree) == 2*lfsr_mleafweight(&lfs)); @@ -2919,7 +2923,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; // test that we can traverse the tree, keeping track of all blocks we see uint8_t *seen = malloc((BLOCK_COUNT+7)/8); @@ -3018,13 +3022,13 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer, 'b', SIZE); lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, &lfs.mtree, 0, &mdir) => 0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_UATTR(1), 0, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -3152,13 +3156,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -3290,13 +3294,13 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; memset(buffer+1, 'b', SIZE-1); lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact lfs.mroot.rbyd.eoff = -1; @@ -3312,7 +3316,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mdir to compact mdir.rbyd.eoff = -1; @@ -3452,7 +3456,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, "a", 1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\0a", 2)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF("\0a", 2)))) => 0; // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; @@ -3570,7 +3574,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; uint8_t buffer[256]; @@ -3718,7 +3722,7 @@ code = ''' mdir.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(name, 4)))) => 0; lfsr_data_t data; // double check @@ -3851,8 +3855,8 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR( - MROOT, 0, - FROMMPTR(&LFSR_MPTR_MROOTANCHOR())))) => 0; + LFSR_TAG_MROOT, 0, + LFSR_DATA_FROMMPTR(&LFSR_MPTR_MROOTANCHOR())))) => 0; // technically, cycle detection only needs to work when we're validating lfsr_traversal_t traversal = LFSR_TRAVERSAL(LFSR_TRAVERSAL_VALIDATE); @@ -3930,7 +3934,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; @@ -3986,7 +3990,7 @@ code = ''' lfsr_mtree_namelookup(&lfs, &lfs.mtree, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL, NULL) => LFS_ERR_NOENT; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(buffer, SIZE)))) => 0; + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(buffer, SIZE)))) => 0; // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index c03f4a78..1ff53093 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -32,15 +32,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\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_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -63,16 +69,22 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\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_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -95,14 +107,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\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_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -133,7 +149,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -156,8 +174,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -190,8 +212,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -243,7 +269,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -266,9 +294,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -301,9 +333,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -354,7 +390,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -373,8 +411,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -395,8 +437,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0; @@ -434,7 +480,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -453,9 +501,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; @@ -476,9 +528,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &data) => 0; @@ -520,8 +576,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -542,8 +602,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -583,9 +647,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -606,9 +676,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -650,9 +726,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -680,9 +762,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -729,10 +817,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -760,10 +856,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -791,10 +895,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -822,10 +934,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -874,10 +994,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -912,10 +1040,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -950,10 +1086,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -988,10 +1132,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1045,10 +1197,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1083,10 +1243,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1121,10 +1289,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1159,10 +1335,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1218,11 +1402,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1259,11 +1453,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1298,11 +1502,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1337,11 +1551,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1399,11 +1623,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1447,11 +1681,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1493,11 +1737,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1539,11 +1793,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1606,12 +1870,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1655,12 +1931,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1704,12 +1992,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1774,12 +2074,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(6), 0, + LFSR_DATA_BUF("\xff\xff\xff\xff", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1828,12 +2140,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(6), 0, + LFSR_DATA_BUF("\xff\xff\xff\xff", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1882,12 +2206,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(6), 0, + LFSR_DATA_BUF("\xff\xff\xff\xff", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1970,8 +2306,9 @@ code = ''' // build the attribute list for the current permutation struct lfsr_attr attrs[N]; for (unsigned j = 0; j < N; j++) { - attrs[j] = LFSR_ATTR(UATTR(perm[j]+1), 0, - BUF("\xaa\xaa\xaa\xaa", 4)); + attrs[j] = LFSR_ATTR( + LFSR_TAG_UATTR(perm[j]+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)); } // test the given permutation @@ -2062,8 +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_ATTRS( - LFSR_ATTR(UATTR(perm[j]+1), 0, - BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(perm[j]+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -2121,8 +2459,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2155,8 +2497,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2210,9 +2556,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2245,9 +2595,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2321,8 +2675,9 @@ code = ''' // build the attribute list for the current permutation struct lfsr_attr attrs[N]; for (unsigned j = 0; j < N; j++) { - attrs[j] = LFSR_ATTR(UATTR(perm[j]+1), 0, - BUF("\xaa\xaa\xaa\xaa", 4)); + attrs[j] = LFSR_ATTR( + LFSR_TAG_UATTR(perm[j]+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)); } // test the given permutation @@ -2395,8 +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_ATTRS( - LFSR_ATTR(UATTR(perm[j]+1), 0, - BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(perm[j]+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -2451,7 +2807,9 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(j+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(j+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } // copy block so we can reset after each remove @@ -2490,8 +2848,9 @@ code = ''' // update each tag in permutation order for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(perm[j]+1), 0, - BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(perm[j]+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; } // check that all tags have been updated @@ -2568,7 +2927,9 @@ code = ''' : (ORDER == 1) ? (((lfs_size_t)-1) - i) : TEST_PRNG(&prng); int err = lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(x & 0x7f), 0, BUF("\xaa\xaa\xaa\xaa", 4)))); + LFSR_ATTR( + LFSR_TAG_UATTR(x & 0x7f), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))); if (err == LFS_ERR_RANGE) { break; } @@ -2618,9 +2979,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -2637,10 +3002,16 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -2673,10 +3044,16 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(2)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(2), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -2754,8 +3131,9 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(perm[j]+1), 0, - BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(perm[j]+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } // copy block so we can reset after each remove @@ -2777,8 +3155,9 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(j+1)), 0, NULL()))) - => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(j+1), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -2805,8 +3184,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_ATTRS( - LFSR_ATTR(UATTR(j+1), 0, - BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(j+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -2900,8 +3280,9 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(perm[j]+1), 0, - BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(perm[j]+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } // copy block so we can reset after each remove @@ -2923,7 +3304,9 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(j+1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(j+1), 0, + LFSR_DATA_NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -2975,8 +3358,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3002,7 +3389,9 @@ code = ''' // try to remove tags that aren't there, this should do nothing lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3027,7 +3416,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(3)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3052,7 +3443,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(5)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3124,16 +3517,32 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(4), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(5), 0, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; // remove several attributes lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(1)), 0, NULL()), - LFSR_ATTR(RM(UATTR(3)), 0, NULL()), - LFSR_ATTR(RM(UATTR(5)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -3160,7 +3569,9 @@ code = ''' // try to remove tags that aren't there, this should do nothing lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3185,7 +3596,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(3)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3210,7 +3623,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(5)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3237,7 +3652,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_ATTRS( - LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3262,7 +3679,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(3)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(3), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3287,7 +3706,9 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(5)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(5), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3359,9 +3780,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3378,11 +3803,19 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(1)), 0, NULL()), - LFSR_ATTR(RM(UATTR(2)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(2), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3399,11 +3832,19 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(2)), 0, NULL()), - LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(2), 0, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3453,7 +3894,9 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(j+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(j+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } // copy block so we can reset after each remove @@ -3492,7 +3935,9 @@ code = ''' // remove each tag in permutation order for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(perm[j]+1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(perm[j]+1), 0, + LFSR_DATA_NULL()))) => 0; } // check that all tags are now removed @@ -3504,8 +3949,9 @@ code = ''' // try resuming from all tags being removed lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, - BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -3601,14 +4047,17 @@ code = ''' sim[attr] = 'a'+(i % 26); // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(attr), 0, - BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(attr), 0, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else { // update our sim sim[attr] = '\0'; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(attr)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(attr), 0, + LFSR_DATA_NULL()))) => 0; } } @@ -3682,7 +4131,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -3699,8 +4150,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -3723,9 +4178,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -3772,7 +4233,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -3789,9 +4252,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -3814,9 +4281,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -3839,11 +4310,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -3872,11 +4349,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -3905,11 +4388,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4002,7 +4491,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -4062,8 +4553,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 00000000, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4131,9 +4626,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4178,9 +4677,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4288,7 +4791,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -4359,7 +4864,7 @@ code = ''' x = x % (rbyd.weight+1); int err = lfsr_rbyd_commit(&lfs, &rbyd, x, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[x % 6], 4)))); + LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[x % 6], 4)))); if (err == LFS_ERR_RANGE) { break; } @@ -4406,8 +4911,12 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4430,10 +4939,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4468,12 +4985,24 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4561,9 +5090,13 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4586,13 +5119,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4627,13 +5168,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4668,17 +5217,29 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4748,17 +5309,29 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4805,17 +5378,29 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -4927,12 +5512,15 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -4999,10 +5587,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5102,13 +5698,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5185,13 +5789,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5332,12 +5944,15 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -5419,11 +6034,15 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[j % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[j % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, BUF(names[j % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[j % 6], 2)))) => 0; } } @@ -5463,8 +6082,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_ATTRS( - LFSR_ATTR(UATTR(perm[j]%M+1), 0, - BUF(names[(perm[j]/M) % 6], 3)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(perm[j]%M+1), 0, + LFSR_DATA_BUF(names[(perm[j]/M) % 6], 3)))) => 0; } // check that all tags have been updated @@ -5580,12 +6200,15 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -5608,7 +6231,9 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR((j%M)+1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR((j%M)+1), 0, + LFSR_DATA_NULL()))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -5650,8 +6275,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_ATTRS( - LFSR_ATTR(UATTR((j%M)+1), 0, - BUF(names[(j/M)%6], 3)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR((j%M)+1), 0, + LFSR_DATA_BUF(names[(j/M)%6], 3)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -5753,11 +6379,15 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[j % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[j % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, BUF(names[j % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[j % 6], 2)))) => 0; } } @@ -5797,8 +6427,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_ATTRS( - LFSR_ATTR(RM(UATTR(perm[j]%M+1)), - 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(perm[j]%M+1), 0, + LFSR_DATA_NULL()))) => 0; } // check that all tags have been removed @@ -5889,9 +6520,11 @@ code = ''' // build a single attribute list with all attributes, if this fails // it should fail atomically struct lfsr_attr attrs[1+M]; - attrs[0] = LFSR_ATTR(REG, +1, BUF(names[x % 6], 4)); + attrs[0] = LFSR_ATTR(LFSR_TAG_REG, +1, LFSR_DATA_BUF(names[x % 6], 4)); for (unsigned u = 0; u < M; u++) { - attrs[1+u] = LFSR_ATTR(UATTR(u+1), 0, BUF(names[x % 6], 2)); + attrs[1+u] = LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[x % 6], 2)); } int err = lfsr_rbyd_commit(&lfs, &rbyd, x, attrs, 1+M); @@ -5996,12 +6629,14 @@ code = ''' // note the data size differences here lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(perm[j]+1), 0, - BUF(names[perm[j] % 6], 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(perm[j]+1), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } // try looking up each tag @@ -6140,16 +6775,19 @@ code = ''' // note the data size differences here lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(perm[j]+1), 0, - BUF(names[perm[j] % 6], 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(perm[j]+1), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -6262,10 +6900,14 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6286,10 +6928,14 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6310,11 +6956,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6339,11 +6991,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6368,11 +7026,17 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6415,12 +7079,20 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6451,12 +7123,20 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6487,14 +7167,26 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6537,14 +7229,26 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6587,14 +7291,26 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, &data) => 0; @@ -6704,7 +7420,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -6727,7 +7445,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -6747,7 +7465,9 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[j % 6], 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -6861,12 +7581,15 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } assert(rbyd.weight == N); @@ -6890,7 +7613,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -6923,11 +7646,14 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[j % 6], 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, - BUF(names[j % 6], 3)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[j % 6], 3)))) => 0; } assert(rbyd.weight == N); @@ -7054,7 +7780,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -7077,7 +7805,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -7181,12 +7909,15 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } } assert(rbyd.weight == N); @@ -7210,7 +7941,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -7282,9 +8013,11 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -7299,11 +8032,15 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()), - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -7318,12 +8055,16 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -7338,13 +8079,19 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()), - LFSR_ATTR(RM, -1, NULL()), - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -7359,15 +8106,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -7400,10 +8153,14 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -7418,13 +8175,21 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()), - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -7439,14 +8204,22 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -7461,16 +8234,28 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()), - LFSR_ATTR(RM, -1, NULL()), - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()), + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -7485,18 +8270,30 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_REG, @@ -7551,7 +8348,9 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[j % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[j % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -7600,7 +8399,7 @@ code = ''' lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -7613,8 +8412,9 @@ code = ''' // try resuming from all tags being removed lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, - BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -7696,11 +8496,15 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[j % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[j % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, BUF(names[j % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF(names[j % 6], 2)))) => 0; } } assert(rbyd.weight == N); @@ -7750,7 +8554,7 @@ code = ''' lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -7763,11 +8567,14 @@ code = ''' // try resuming from all tags being removed lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, - BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(UATTR(u+1), 0, BUF("\xaa\xaa\xaa", 3)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(u+1), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa", 3)))) => 0; } assert(rbyd.weight == 1); @@ -7880,14 +8687,16 @@ code = ''' count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else { // update our sim memmove(sim+rid, sim+rid+1, count-rid-1); count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } } @@ -7952,7 +8761,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -7971,7 +8782,9 @@ code = ''' // make id2 with weight w2 lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +2, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +2, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -8002,7 +8815,9 @@ code = ''' // make id5 with weight w3 lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_ATTRS( - LFSR_ATTR(REG, +3, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +3, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -8045,7 +8860,9 @@ code = ''' // make id9 with weight w4 lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_ATTRS( - LFSR_ATTR(REG, +4, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +4, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -8100,7 +8917,9 @@ code = ''' // make id14 with weight w5 lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_ATTRS( - LFSR_ATTR(REG, +5, BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +5, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -8189,15 +9008,25 @@ code = ''' lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( // make id0 with weight w1 - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), // make id2 with weight w2 - LFSR_ATTR(REG, +2, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +2, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), // make id5 with weight w3 - LFSR_ATTR(REG, +3, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +3, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), // make id9 with weight w4 - LFSR_ATTR(REG, +4, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +4, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), // make id14 with weight w5 - LFSR_ATTR(REG, +5, BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +5, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)))) => 0; // traverse, finding tags and weights lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, @@ -8336,8 +9165,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(REG, +W, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +W, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -8425,8 +9255,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(REG, +W, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +W, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -8475,10 +9306,18 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)), - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(UATTR(2), 0, BUF("\xaa\xaa", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("unrelated", 9)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -8533,10 +9372,18 @@ code = ''' // make id2 with weight w2 lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), - LFSR_ATTR(GROW, +1, NULL()), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)), + LFSR_ATTR( + LFSR_TAG_GROW, +1, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -8627,10 +9474,18 @@ code = ''' // make id5 with weight w3 lfsr_rbyd_commit(&lfs, &rbyd, 3, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)), - LFSR_ATTR(GROW, +2, NULL()), - LFSR_ATTR(UATTR(2), 0, BUF("\xcc\xcc", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)), + LFSR_ATTR( + LFSR_TAG_GROW, +2, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -8757,10 +9612,18 @@ code = ''' // make id9 with weight w4 lfsr_rbyd_commit(&lfs, &rbyd, 6, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xdd\xdd", 2)), - LFSR_ATTR(GROW, +3, NULL()), - LFSR_ATTR(UATTR(2), 0, BUF("\xdd\xdd", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xdd\xdd", 2)), + LFSR_ATTR( + LFSR_TAG_GROW, +3, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xdd\xdd", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -8923,10 +9786,18 @@ code = ''' // make id14 with weight w5 lfsr_rbyd_commit(&lfs, &rbyd, 10, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xee\xee", 2)), - LFSR_ATTR(GROW, +4, NULL()), - LFSR_ATTR(UATTR(2), 0, BUF("\xee\xee", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xee\xee", 2)), + LFSR_ATTR( + LFSR_TAG_GROW, +4, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xee\xee", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -9146,31 +10017,71 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)), + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("unrelated", 9)), // make id0 with weight w1 - LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(UATTR(2), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xaa\xaa", 2)), // make id2 with weight w2 - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), - LFSR_ATTR(GROW, +1, NULL()), - LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)), + LFSR_ATTR( + LFSR_TAG_GROW, +1, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xbb\xbb", 2)), // make id5 with weight w3 - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)), - LFSR_ATTR(GROW, +2, NULL()), - LFSR_ATTR(UATTR(2), 0, BUF("\xcc\xcc", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)), + LFSR_ATTR( + LFSR_TAG_GROW, +2, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xcc\xcc", 2)), // make id9 with weight w4 - LFSR_ATTR(REG, +1, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xdd\xdd", 2)), - LFSR_ATTR(GROW, +3, NULL()), - LFSR_ATTR(UATTR(2), 0, BUF("\xdd\xdd", 2)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xdd\xdd", 2)), + LFSR_ATTR( + LFSR_TAG_GROW, +3, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xdd\xdd", 2)), // make id14 with weight w5 - LFSR_ATTR(REG, +1, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xee\xee", 2)), - LFSR_ATTR(GROW, +4, NULL()), - LFSR_ATTR(UATTR(2), 0, BUF("\xee\xee", 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xee\xee", 2)), + LFSR_ATTR( + LFSR_TAG_GROW, +4, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xee\xee", 2)))) => 0; // traverse, finding tags and weights lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, @@ -9432,7 +10343,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("unrelated", 9)))) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -9444,11 +10357,18 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR(1), 0, BUF(names[perm[j] % 6], 2)), - LFSR_ATTR(GROW, +W-1, NULL()), - LFSR_ATTR(UATTR(2), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)), + LFSR_ATTR( + LFSR_TAG_GROW, +W-1, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -9545,7 +10465,9 @@ code = ''' rbyd = init_rbyd; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(3), 0, + LFSR_DATA_BUF("unrelated", 9)))) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -9557,11 +10479,18 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR(1), 0, BUF(names[perm[j] % 6], 2)), - LFSR_ATTR(GROW, +W-1, NULL()), - LFSR_ATTR(UATTR(2), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)), + LFSR_ATTR( + LFSR_TAG_GROW, +W-1, + LFSR_DATA_NULL()), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -9677,8 +10606,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(REG, +W, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +W, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -9701,7 +10631,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(GROW, +D, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_GROW, +D, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -9807,8 +10737,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(REG, +W, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +W, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -9831,8 +10762,9 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(GROW(REG), +D, - BUF(names[j % 6], 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_GROW | LFSR_TAG_REG, +D, + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -9948,8 +10880,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), +W, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), +W, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -9972,8 +10905,9 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(GROW(UATTR(1)), +D, - BUF(names[j % 6], 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_GROW | LFSR_TAG_UATTR(1), +D, + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10102,8 +11036,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(REG, +W, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +W, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10126,7 +11061,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(GROW, -D, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_GROW, -D, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N*W-D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10232,8 +11167,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(REG, +W, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +W, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10256,8 +11192,9 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(GROW(REG), -D, - BUF(names[j % 6], 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_GROW | LFSR_TAG_REG, -D, + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W-D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10373,8 +11310,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(UATTR(2), +W, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(2), +W, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10397,8 +11335,9 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(GROW(UATTR(1)), -D, - BUF(names[j % 6], 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_GROW | LFSR_TAG_UATTR(1), -D, + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W-D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10526,8 +11465,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(REG, +W, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +W, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10550,7 +11490,7 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(RM, -W, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == (N-1)*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10584,7 +11524,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_ATTRS( - LFSR_ATTR(REG, +W, BUF(names[j % 6], 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +W, + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10686,8 +11628,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, rid*W, LFSR_ATTRS( - LFSR_ATTR(REG, +W, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +W, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10711,8 +11654,9 @@ code = ''' NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, - BUF(names[j % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF(names[j % 6], 2)))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10743,7 +11687,9 @@ code = ''' // now try removing the attr printf("--- removing: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10769,8 +11715,9 @@ code = ''' // and try putting the attr back just for good measure printf("--- appending: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( - LFSR_ATTR(UATTR(1), 0, - BUF(names[j % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF(names[j % 6], 2)))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10881,28 +11828,33 @@ code = ''' count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else if (op == 1) { // update our sim memmove(sim+rid*(M+1), sim+(rid+1)*(M+1), (count-rid-1)*(M+1)); count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; } else if (op == 2) { // update our sim sim[rid*(M+1) + u+1] = 'a'+(i % 26); // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( LFSR_ATTR( - UATTR(u), 0, BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_TAG_UATTR(u), 0, + LFSR_DATA_BUF(&(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_ATTRS( - LFSR_ATTR(RM(UATTR(u)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(u), 0, + LFSR_DATA_NULL()))) => 0; } } @@ -11051,7 +12003,8 @@ code = ''' // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid, LFSR_ATTRS( LFSR_ATTR( - REG, +weight, BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; + LFSR_TAG_REG, +weight, + LFSR_DATA_BUF(&(uint8_t){'a'+(i % 26)}, 1)))) => 0; } else if (op == 1) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -11062,7 +12015,7 @@ code = ''' count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS( - LFSR_ATTR(RM, -weight_, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -weight_, LFSR_DATA_NULL()))) => 0; } else if (op == 2) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -11070,7 +12023,7 @@ code = ''' sim_weights[rid] += weight; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS( - LFSR_ATTR(GROW, +weight, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_GROW, +weight, LFSR_DATA_NULL()))) => 0; } else if (op == 3) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -11081,7 +12034,7 @@ code = ''' sim_weights[rid] -= weight; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS( - LFSR_ATTR(GROW, -weight, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_GROW, -weight, LFSR_DATA_NULL()))) => 0; } } @@ -11213,9 +12166,12 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -11300,9 +12256,12 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -11326,7 +12285,9 @@ code = ''' // remove with a wide tag lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(RM(SUBMASK(UATTR)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_SUBMASK | LFSR_TAG_UATTR, 0, + LFSR_DATA_NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11438,9 +12399,12 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -11464,8 +12428,10 @@ code = ''' // replace with bitwise inverse lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, - BUF(names[j % 6], 3)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f), + 0, + LFSR_DATA_BUF(names[j % 6], 3)))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11578,11 +12544,15 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, - BUF(names[perm[j] % 6], 2)), - LFSR_ATTR(SATTR(0), 0, - BUF(names[perm[j] % 6], 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)), + LFSR_ATTR( + LFSR_TAG_SATTR(0), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; } assert(rbyd.weight == N); @@ -11667,11 +12637,15 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, - BUF(names[perm[j] % 6], 2)), - LFSR_ATTR(SATTR(0), 0, - BUF(names[perm[j] % 6], 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)), + LFSR_ATTR( + LFSR_TAG_SATTR(0), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; } assert(rbyd.weight == N); @@ -11695,7 +12669,9 @@ code = ''' // remove with a wide tag lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(RM(SUBMASK(UATTR)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_SUBMASK | LFSR_TAG_UATTR, 0, + LFSR_DATA_NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11814,11 +12790,15 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, - BUF(names[perm[j] % 6], 2)), - LFSR_ATTR(SATTR(0), 0, - BUF(names[perm[j] % 6], 1)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)), + LFSR_ATTR( + LFSR_TAG_SATTR(0), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 1)))) => 0; } assert(rbyd.weight == N); @@ -11842,8 +12822,10 @@ code = ''' // replace with bitwise inverse lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, - BUF(names[j % 6], 3)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f), + 0, + LFSR_DATA_BUF(names[j % 6], 3)))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11963,8 +12945,9 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), +1, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -12049,8 +13032,9 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), +1, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -12074,7 +13058,9 @@ code = ''' // remove with a wide tag lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(RM(SUBMASK(UATTR)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_SUBMASK | LFSR_TAG_UATTR, 0, + LFSR_DATA_NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -12189,8 +13175,9 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), +1, - BUF(names[perm[j] % 6], 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -12214,8 +13201,10 @@ code = ''' // replace with bitwise inverse lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, - BUF(names[j % 6], 6)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f), + 0, + LFSR_DATA_BUF(names[j % 6], 6)))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -12322,9 +13311,12 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -12409,9 +13401,12 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -12435,7 +13430,9 @@ code = ''' // remove with a wide tag lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(RM(SUPMASK(UATTR)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_SUPMASK | LFSR_TAG_UATTR, 0, + LFSR_DATA_NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -12547,9 +13544,12 @@ code = ''' // give each attr a subtype based on its rid + SHIFT lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( - LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, - BUF(names[perm[j] % 6], 2)))) => 0; + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF(names[perm[j] % 6], 4)), + LFSR_ATTR( + LFSR_TAG_UATTR((perm[j] + SHIFT) & 0x7f), 0, + LFSR_DATA_BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -12573,8 +13573,10 @@ code = ''' // replace with bitwise inverse lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( - LFSR_ATTR(SUPMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, - BUF(names[j % 6], 3)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUPMASK | LFSR_TAG_UATTR(~(j + SHIFT) & 0x7f), + 0, + LFSR_DATA_BUF(names[j % 6], 3)))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -12653,9 +13655,15 @@ code = ''' // create a null tag hole rbyd = init_rbyd; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(RM(UATTR(0)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(0), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0, + LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -12695,15 +13703,25 @@ code = ''' // create a null tag hole rbyd = init_rbyd; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(UATTR(2), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(RM(UATTR(0)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(0), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0, + LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); // remove a neighbor to the hole lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(1), 0, + LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -12743,16 +13761,24 @@ code = ''' // create a null tag hole rbyd = init_rbyd; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(0), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(0)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0, + LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 2); // delete a neighbor to the hole lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( - LFSR_ATTR(RM, -1, NULL()))) => 0; + LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); // can we still access things? @@ -12792,16 +13818,25 @@ code = ''' // create a null tag hole rbyd = init_rbyd; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(SATTR(0), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(RM(UATTR(0)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(0), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_SATTR(0), 0, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0, + LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 0); // subwide replace a neighbor to the hole lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(SUBMASK(UATTR(2)), 0, - BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUBMASK | LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -12850,17 +13885,26 @@ code = ''' // create a null tag hole rbyd = init_rbyd; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(REG, +1, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_UATTR(0), 0, + LFSR_DATA_BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR( + LFSR_TAG_UATTR(1), 0, + LFSR_DATA_BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR( + LFSR_TAG_REG, +1, + LFSR_DATA_BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(RM(UATTR(0)), 0, NULL()))) => 0; + LFSR_ATTR( + LFSR_TAG_RM | LFSR_TAG_UATTR(0), 0, + LFSR_DATA_NULL()))) => 0; assert(rbyd.weight == 1); // supwide replace a neighbor to the hole lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( - LFSR_ATTR(SUPMASK(UATTR(2)), 0, - BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + LFSR_ATTR( + LFSR_TAG_SUPMASK | LFSR_TAG_UATTR(2), 0, + LFSR_DATA_BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 1); // can we still access things?