From dca915dd958d22122812c10b9fe6088e00d8c98c Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Sat, 29 Nov 2025 19:15:54 -0600 Subject: [PATCH] rattrs: Converted rattrs to full variable-length isa It's funny to see what originally started as a simple list of rbyd attrs slowly morph into a full isa. But it makes sense. What we really want is an abstract description of operations that can be played and replayed as necessary to atomically update the mtree. Using a fixed lfs3_rattr_t struct to represent this in C is easy, and avoids strict-aliasing issues, but ultimately limited when it comes to the wide-range of data we want to attach to attributes. Unlike a computer's isa, we want to be able to include full 12-24 byte branch pointers directly in the instruction! --- So here's a full variable-length isa organized by words (max(uintptr_t, uint32_t)). The first 32-bit word extends the 16-bit tag with an extra 16-bits of control information: wwll llff ffcc cccc tttt tttt tttt tttt ^'-.-''-.-''--.--' : : '--|----|-----|----:-----------------:-- compressed weight :: '----|-----|----:-----------------:-- total len :: '-----|----:-----------------:-- from encoder :: '----:-----------------:-- optional count :: rgmm kkkk -kkk kkkk 11 => w=-1 ^^ ^ '-.' '---.---' 00 => w=0 '|-|---|------|------ rm bit 01 => w=+1 '-|---|------|------ grow bit 10 => w=attached '---|------|------ mask bits '------|------ tag suptype '------ tag subtype The 4-bit length field always encodes the full length of the instruction, including the instruction itself and optional weight. The 4-bit from + 6-bit count fields operate independently and tell lfs3_rbyd_appendrattr_ how to actually encode the data related to the instruction. To work around strict-aliasing issues, complex structs are expected to be broken down into words and reconstructed in lfs3_rbyd_appendrattr_. Most of our structs are organized into words anyways. For example: // new child *r++ = LFS3_RATTR(5, LFS3_TAG_BRANCH, -2, LFS3_FROM_BRANCH); *r++ = LFS3_RATTR_WEIGHT(+child_->weight); *r++ = LFS3_RATTR_ARG(child_->blocks[0]); *r++ = LFS3_RATTR_ARG(child_->trunk); *r++ = LFS3_RATTR_ARG(child_->cksum); This also changes rattr-lists to be null-terminated, which makes a bit more sense in a variable-length isa: *r++ = LFS3_RATTR_NULL; // all zeros, including length One concern with null-terminated rattr-lists is how easy it is to forget the null-terminator, but an assert that all non-null rattrs have non-zero length seemed to catch the many many mistakes during adoption. Alternatively, separate LFS3_FROM_NULL/LFS3_FROM_NIL from fields could be used if encoding space gets tight. I'm also quite happy with the 2-bit weight feild, which allows omitting the optional weight word for -1,0,+1 weights. These should cover at least all mdir operations. Note the exact encoding of the rattr fields is less of a concern than the tag fields, as it doesn't reside on-disk can be changed on whim. --- Saves a nice chunk of code and stack: code stack ctx before: 35920 2280 660 after: 35324 (-1.7%) 2176 (-4.6%) 660 (+0.0%) code stack ctx gbmap before: 38812 2296 772 gbmap after: 38156 (-1.7%) 2192 (-4.5%) 772 (+0.0%) The stack savings are obvious, but the code savings a bit less so. A variable length isa _is_ more complicated, but by limiting most encoding decisions to compile-time (2-bit weights vs 32-bit weights for example), the savings from fewer word manipulations on the stack wins. --- lfs3.c | 1767 ++++++++------- lfs3.h | 4 +- tests/test_badblocks.toml | 18 +- tests/test_btree.toml | 902 +++++--- tests/test_files.toml | 53 +- tests/test_fwrite.toml | 14 +- tests/test_gbmap.toml | 24 +- tests/test_mount.toml | 301 +-- tests/test_mtree.toml | 977 ++++++--- tests/test_paths.toml | 270 ++- tests/test_rbyd.toml | 4369 +++++++++++++++++-------------------- 11 files changed, 4546 insertions(+), 4153 deletions(-) diff --git a/lfs3.c b/lfs3.c index 2234e0a6..c708f970 100644 --- a/lfs3.c +++ b/lfs3.c @@ -9,6 +9,10 @@ #include "lfs3_util.h" +// TODO should lfs3_scmp_t/lfs3_sbool_t be moved to lfs3.h? +// TODO should all typedefs be moved to lfs3.h? +// TODO wait, should they actually go in lfs3_util.h? + // internally used disk-comparison enum // // note LT < EQ < GT @@ -1074,6 +1078,10 @@ static inline bool lfs3_tag_perturb(lfs3_tag_t tag) { return tag & LFS3_TAG_PERTURB; } +static inline bool lfs3_tag_isinternal(lfs3_tag_t tag) { + return tag && lfs3_tag_suptype(tag) == LFS3_tag_INTERNAL; +} + static inline bool lfs3_tag_isrm(lfs3_tag_t tag) { return tag & LFS3_tag_RM; } @@ -1856,268 +1864,248 @@ static inline lfs3_data_t lfs3_data_fromlleb128(uint32_t word, /// Rattrs - lfs3_rattr_t stuff /// -// rattr layouts/lazy encoders +// operations on rbyd attribute lists, rattrs have basically evolved +// into a full isa + +// our core rbyd attribute type +// +// wwll llff ffcc cccc tttt tttt tttt tttt +// ^'-.-''-.-''--.--' : : +// '--|----|-----|----:-----------------:-- compressed weight +// :: '----|-----|----:-----------------:-- total len +// :: '-----|----:-----------------:-- from encoder +// :: '----:-----------------:-- optional count +// :: rgmm kkkk -kkk kkkk +// 11 => w=-1 ^^ ^ '-.' '---.---' +// 00 => w=0 '|-|---|------|------ rm bit +// 01 => w=+1 '-|---|------|------ grow bit +// 10 => w=attached '---|------|------ mask bits +// '------|------ tag suptype +// '------ tag subtype +// +typedef uintptr_t lfs3_rattr_t; + +// rattr from encoders enum lfs3_from { - LFS3_FROM_BUF = 0, - LFS3_FROM_DATA = 1, + LFS3_FROM_NIL = 0, + LFS3_FROM_BUF = 1, + LFS3_FROM_DATA = 2, + LFS3_FROM_CAT = 3, - LFS3_FROM_LE32 = 2, - LFS3_FROM_LEB128 = 3, - LFS3_FROM_NAME = 4, + LFS3_FROM_LE32 = 4, + LFS3_FROM_LEB128 = 5, + LFS3_FROM_NAME = 6, - LFS3_FROM_ECKSUM = 5, - LFS3_FROM_BPTR = 6, - LFS3_FROM_BTREE = 7, - LFS3_FROM_SHRUB = 8, - LFS3_FROM_MPTR = 9, - LFS3_FROM_GEOMETRY = 10, + LFS3_FROM_ECKSUM = 7, + LFS3_FROM_BRANCH = 8, + + LFS3_FROM_BPTR = 9, + LFS3_FROM_BTREE = 10, + LFS3_FROM_SHRUB = 11, + LFS3_FROM_MPTR = 12, + LFS3_FROM_GEOMETRY = 13, }; -// operations on attribute lists +typedef uint8_t lfs3_from_t; +typedef uint8_t lfs3_count_t; -// our core attribute type -#ifndef LFS3_RDONLY -typedef struct lfs3_rattr { - lfs3_tag_t tag; - uint8_t from; - uint8_t count; - lfs3_srid_t weight; - union { - const uint8_t *buffer; - const lfs3_data_t *datas; - uint32_t le32; - uint32_t leb128; - uint32_t lleb128; - const void *etc; - } u; -} lfs3_rattr_t; -#endif +// initial rattr macros +#define LFS3_RATTR_5(_len, _tag, _weight, _from, _count) \ + (((lfs3_rattr_t)(_len) << 26) \ + | ((lfs3_rattr_t)(_tag) << 0) \ + | ((lfs3_rattr_t)(_weight) << 30) \ + | ((lfs3_rattr_t)(_from) << 22) \ + | ((lfs3_rattr_t)(_count) << 16)) -// low-level attr macro -#define LFS3_RATTR_(_tag, _weight, _rattr) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=(_rattr).from, \ - .count=(_rattr).count, \ - .weight=_weight, \ - .u=(_rattr).u}) +#define LFS3_RATTR_4(_len, _tag, _weight, _from) \ + LFS3_RATTR_5(_len, _tag, _weight, _from, 0) -// high-level attr macros -#define LFS3_RATTR(_tag, _weight) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_BUF, \ - .count=0, \ - .weight=_weight, \ - .u.datas=NULL}) +#define LFS3_RATTR_3(_len, _tag, _weight) \ + LFS3_RATTR_5(_len, _tag, _weight, LFS3_FROM_NIL, 0) -#define LFS3_RATTR_BUF(_tag, _weight, _buffer, _size) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_BUF, \ - .count=_size, \ - .weight=_weight, \ - .u.buffer=(const void*)(_buffer)}) +#define LFS3_RATTR_N_(_0, _1, _2, _3, _4, _n, ...) _n +#define LFS3_RATTR_N(...) LFS3_RATTR_N_(__VA_ARGS__, 5, 4, 3, 2, 1) -#define LFS3_RATTR_DATA(_tag, _weight, _data) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_DATA, \ - .count=1, \ - .weight=_weight, \ - .u.datas=_data}) +#define LFS3_RATTR__(n) \ + LFS3_RATTR_##n -#define LFS3_RATTR_CAT_(_tag, _weight, _datas, _data_count) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_DATA, \ - .count=_data_count, \ - .weight=_weight, \ - .u.datas=_datas}) +#define LFS3_RATTR_(n, ...) \ + LFS3_RATTR__(n)(__VA_ARGS__) -#define LFS3_RATTR_CAT(_tag, _weight, ...) \ - LFS3_RATTR_CAT_( \ - _tag, \ - _weight, \ - ((const lfs3_data_t[]){__VA_ARGS__}), \ - sizeof((const lfs3_data_t[]){__VA_ARGS__}) / sizeof(lfs3_data_t)) +#define LFS3_RATTR(...) \ + LFS3_RATTR_(LFS3_RATTR_N(__VA_ARGS__), __VA_ARGS__) -#define LFS3_RATTR_NOOP() \ - ((lfs3_rattr_t){ \ - .tag=LFS3_TAG_NULL, \ - .from=LFS3_FROM_BUF, \ - .count=0, \ - .weight=0, \ - .u.buffer=NULL}) +// extended rattr macros +#define LFS3_RATTR_WEIGHT(_weight) \ + ((lfs3_rattr_t)(lfs3_srid_t){_weight}) -// as convenience we lazily encode single le32/leb128/lleb128 attrs -// -// this also avoids needing a stack allocation for these attrs -#define LFS3_RATTR_LE32(_tag, _weight, _le32) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_LE32, \ - .count=0, \ - .weight=_weight, \ - .u.le32=_le32}) +#define LFS3_RATTR_ARG(_arg) \ + ((lfs3_rattr_t)(_arg)) -#define LFS3_RATTR_LEB128(_tag, _weight, _leb128) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_LEB128, \ - .count=0, \ - .weight=_weight, \ - .u.leb128=_leb128}) - -#define LFS3_RATTR_LLEB128(_tag, _weight, _lleb128) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_LEB128, \ - .count=0, \ - .weight=_weight, \ - .u.lleb128=_lleb128}) - -// helper macro for did + name pairs -#ifndef LFS3_RDONLY -typedef struct lfs3_name { - uint32_t did; - const char *name; - lfs3_size_t name_len; -} lfs3_name_t; -#endif - -#define LFS3_RATTR_NAME_(_tag, _weight, _name) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_NAME, \ - .count=0, \ - .weight=_weight, \ - .u.etc=(const lfs3_name_t*){_name}}) - -#define LFS3_RATTR_NAME(_tag, _weight, _did, _name, _name_len) \ - LFS3_RATTR_NAME_( \ - _tag, \ - _weight, \ - (&(const lfs3_name_t){ \ - .did=_did, \ - .name=_name, \ - .name_len=_name_len})) - -// macros for other lazily encoded attrs -#define LFS3_RATTR_ECKSUM(_tag, _weight, _ecksum) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_ECKSUM, \ - .count=0, \ - .weight=_weight, \ - .u.etc=(const lfs3_ecksum_t*){_ecksum}}) - -// note the LFS3_BPTR_DSIZE hint so shrub estimates work -#define LFS3_RATTR_BPTR(_tag, _weight, _bptr) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_BPTR, \ - .count=LFS3_BPTR_DSIZE, \ - .weight=_weight, \ - .u.etc=(const lfs3_bptr_t*){_bptr}}) - -#define LFS3_RATTR_BTREE(_tag, _weight, _btree) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_BTREE, \ - .count=0, \ - .weight=_weight, \ - .u.etc=(const lfs3_btree_t*){_btree}}) - -#define LFS3_RATTR_SHRUB(_tag, _weight, _shrub) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_SHRUB, \ - .count=0, \ - .weight=_weight, \ - .u.etc=(const lfs3_shrub_t*){_shrub}}) - -#define LFS3_RATTR_MPTR(_tag, _weight, _mptr) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_MPTR, \ - .count=0, \ - .weight=_weight, \ - .u.etc=(const lfs3_block_t*){_mptr}}) - -#define LFS3_RATTR_GEOMETRY(_tag, _weight, _geometry) \ - ((lfs3_rattr_t){ \ - .tag=_tag, \ - .from=LFS3_FROM_GEOMETRY, \ - .count=0, \ - .weight=_weight, \ - .u.etc=(const lfs3_geometry_t*){_geometry}}) - -// these are special attrs that trigger unique behavior in -// lfs3_mdir_commit___ -#define LFS3_RATTR_RATTRS(_rattrs, _rattr_count) \ - ((lfs3_rattr_t){ \ - .tag=LFS3_tag_RATTRS, \ - .from=LFS3_FROM_BUF, \ - .count=_rattr_count, \ - .weight=0, \ - .u.etc=(const lfs3_rattr_t*){_rattrs}}) - -#define LFS3_RATTR_SHRUBCOMMIT(_shrubcommit) \ - ((lfs3_rattr_t){ \ - .tag=LFS3_tag_SHRUBCOMMIT, \ - .from=LFS3_FROM_BUF, \ - .count=0, \ - .weight=0, \ - .u.etc=(const lfs3_shrubcommit_t*){_shrubcommit}}) - -#define LFS3_RATTR_MOVE(_move) \ - ((lfs3_rattr_t){ \ - .tag=LFS3_tag_MOVE, \ - .from=LFS3_FROM_BUF, \ - .count=0, \ - .weight=0, \ - .u.etc=(const lfs3_mdir_t*){_move}}) - -#define LFS3_RATTR_ATTRS(_attrs, _attr_count) \ - ((lfs3_rattr_t){ \ - .tag=LFS3_tag_ATTRS, \ - .from=LFS3_FROM_BUF, \ - .count=_attr_count, \ - .weight=0, \ - .u.etc=(const struct lfs3_attr*){_attrs}}) +// null rattr terminates rattr lists +#define LFS3_RATTR_NULL ((lfs3_rattr_t)0) // create an attribute list -#define LFS3_RATTRS(...) \ - (const lfs3_rattr_t[]){__VA_ARGS__}, \ - sizeof((const lfs3_rattr_t[]){__VA_ARGS__}) / sizeof(lfs3_rattr_t) +#define LFS3_RATTRS(...) ((const lfs3_rattr_t[]){__VA_ARGS__}) // rattr helpers #ifndef LFS3_RDONLY -static inline bool lfs3_rattr_isnoop(lfs3_rattr_t rattr) { - // noop rattrs must have zero weight - LFS3_ASSERT(rattr.tag || rattr.weight == 0); - return !rattr.tag; +static inline lfs3_srid_t lfs3_rattr_weight_(lfs3_rattr_t rattr) { + return (lfs3_srid_t)rattr >> 30; } #endif #ifndef LFS3_RDONLY -static inline bool lfs3_rattr_isinsert(lfs3_rattr_t rattr) { - return !lfs3_tag_isgrow(rattr.tag) && rattr.weight > 0; +static inline lfs3_size_t lfs3_rattr_len_(lfs3_rattr_t rattr) { + return 0xf & (rattr >> 26); } #endif #ifndef LFS3_RDONLY -static inline lfs3_srid_t lfs3_rattr_nextrid(lfs3_rattr_t rattr, - lfs3_srid_t rid) { - if (lfs3_rattr_isinsert(rattr)) { - return rid + rattr.weight-1; +static inline lfs3_from_t lfs3_rattr_from_(lfs3_rattr_t rattr) { + return 0xf & (rattr >> 22); +} +#endif + +#ifndef LFS3_RDONLY +static inline lfs3_count_t lfs3_rattr_count_(lfs3_rattr_t rattr) { + return 0x3f & (rattr >> 16); +} +#endif + +#ifndef LFS3_RDONLY +static inline lfs3_tag_t lfs3_rattr_tag_(lfs3_rattr_t rattr) { + return 0xffff & rattr; +} +#endif + +#ifndef LFS3_RDONLY +static inline bool lfs3_rattr_isinternal_(lfs3_rattr_t rattr) { + return lfs3_tag_isinternal(lfs3_rattr_tag_(rattr)); +} +#endif + +#ifndef LFS3_RDONLY +static inline bool lfs3_rattr_isrm_(lfs3_rattr_t rattr) { + return lfs3_tag_isrm(lfs3_rattr_tag_(rattr)); +} +#endif + +#ifndef LFS3_RDONLY +static inline bool lfs3_rattr_isgrow_(lfs3_rattr_t rattr) { + return lfs3_tag_isgrow(lfs3_rattr_tag_(rattr)); +} +#endif + +#ifndef LFS3_RDONLY +static inline lfs3_srid_t lfs3_rattr_weight(const lfs3_rattr_t *rattr) { + lfs3_srid_t weight = lfs3_rattr_weight_(rattr[0]); + if (weight == -2) { + return rattr[1]; } else { - return rid + rattr.weight; + return weight; } } #endif +#ifndef LFS3_RDONLY +static inline const lfs3_rattr_t *lfs3_rattr_args(const lfs3_rattr_t *rattr) { + lfs3_srid_t weight = lfs3_rattr_weight_(rattr[0]); + if (weight == -2) { + return &rattr[2]; + } else { + return &rattr[1]; + } +} +#endif + +#ifndef LFS3_RDONLY +static inline lfs3_rattr_t lfs3_rattr_arg(const lfs3_rattr_t *rattr, + lfs3_size_t i) { + return lfs3_rattr_args(rattr)[i]; +} +#endif + +#ifndef LFS3_RDONLY +static inline lfs3_size_t lfs3_rattr_len(const lfs3_rattr_t *rattr) { + return lfs3_rattr_len_(rattr[0]); +} +#endif + +#ifndef LFS3_RDONLY +static inline lfs3_from_t lfs3_rattr_from(const lfs3_rattr_t *rattr) { + return lfs3_rattr_from_(rattr[0]); +} +#endif + +#ifndef LFS3_RDONLY +static inline lfs3_count_t lfs3_rattr_count(const lfs3_rattr_t *rattr) { + return lfs3_rattr_count_(rattr[0]); +} +#endif + +#ifndef LFS3_RDONLY +static inline lfs3_tag_t lfs3_rattr_tag(const lfs3_rattr_t *rattr) { + return lfs3_rattr_tag_(rattr[0]); +} +#endif + +#ifndef LFS3_RDONLY +static inline bool lfs3_rattr_isinternal(const lfs3_rattr_t *rattr) { + return lfs3_rattr_isinternal_(rattr[0]); +} +#endif + +#ifndef LFS3_RDONLY +static inline bool lfs3_rattr_isrm(const lfs3_rattr_t *rattr) { + return lfs3_rattr_isrm_(rattr[0]); +} +#endif + +#ifndef LFS3_RDONLY +static inline bool lfs3_rattr_isgrow(const lfs3_rattr_t *rattr) { + return lfs3_rattr_isgrow_(rattr[0]); +} +#endif + +#ifndef LFS3_RDONLY +static inline bool lfs3_rattr_isnoop(const lfs3_rattr_t *rattr) { + // noop rattrs must have zero weight and nil encoder + LFS3_ASSERT(lfs3_rattr_tag(rattr) + || lfs3_rattr_weight(rattr) == 0); + LFS3_ASSERT(lfs3_rattr_tag(rattr) + || lfs3_rattr_from(rattr) == LFS3_FROM_NIL); + return !lfs3_rattr_tag(rattr); +} +#endif + +#ifndef LFS3_RDONLY +static inline bool lfs3_rattr_isinsert(const lfs3_rattr_t *rattr) { + return !lfs3_rattr_isgrow(rattr) && lfs3_rattr_weight(rattr) > 0; +} +#endif + +#ifndef LFS3_RDONLY +static inline const lfs3_rattr_t *lfs3_rattr_next(const lfs3_rattr_t *rattr, + lfs3_srid_t *rid) { + // a len of zero here is probably a bug + LFS3_ASSERT(lfs3_rattr_len(rattr) > 0); + + // adjust rid? + if (rid) { + lfs3_srid_t weight = lfs3_rattr_weight(rattr); + if (!lfs3_rattr_isgrow(rattr) && weight > 0) { + *rid = *rid + weight-1; + } else { + *rid = *rid + weight; + } + } + + // return next rattr + return rattr + lfs3_rattr_len(rattr); +} +#endif + // operations on custom attribute lists // @@ -3231,8 +3219,7 @@ static int lfs3_rbyd_appendrev(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, uint32_t rev) { static int lfs3_rbyd_appendtag(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, lfs3_tag_t tag, lfs3_rid_t weight, lfs3_size_t size) { // tag must not be internal at this point - LFS3_ASSERT(lfs3_tag_suptype(tag) != LFS3_tag_INTERNAL - || !tag); + LFS3_ASSERT(!lfs3_tag_isinternal(tag)); // bit 7 is reserved for future subtype extensions LFS3_ASSERT(!(tag & 0x80)); @@ -3267,6 +3254,8 @@ static int lfs3_rbyd_appendtag(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, #endif // needed in lfs3_rbyd_appendrattr_ +static lfs3_data_t lfs3_data_frombranch(const lfs3_rbyd_t *branch, + uint8_t buffer[static LFS3_BRANCH_DSIZE]); static lfs3_data_t lfs3_data_frombtree(const lfs3_btree_t *btree, uint8_t buffer[static LFS3_BTREE_DSIZE]); static lfs3_data_t lfs3_data_fromshrub(const lfs3_shrub_t *shrub, @@ -3280,12 +3269,12 @@ static lfs3_data_t lfs3_data_fromgeometry(const lfs3_geometry_t *geometry, // encode rattrs #ifndef LFS3_RDONLY static int lfs3_rbyd_appendrattr_(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, - lfs3_rattr_t rattr) { + lfs3_tag_t tag, lfs3_srid_t weight, + lfs3_from_t from, lfs3_count_t count, const lfs3_rattr_t *args) { // tag must not be internal at this point - LFS3_ASSERT(lfs3_tag_suptype(rattr.tag) != LFS3_tag_INTERNAL - || !rattr.tag); + LFS3_ASSERT(!lfs3_tag_isinternal(tag)); // bit 7 is reserved for future subtype extensions - LFS3_ASSERT(!(rattr.tag & 0x80)); + LFS3_ASSERT(!(tag & 0x80)); // encode lazy tags? // @@ -3311,14 +3300,19 @@ static int lfs3_rbyd_appendrattr_(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, uint8_t buf[LFS3_LEB128_DSIZE]; } name; - struct { - lfs3_data_t data; - uint8_t buf[LFS3_BPTR_DSIZE]; - } bptr; struct { lfs3_data_t data; uint8_t buf[LFS3_ECKSUM_DSIZE]; } ecksum; + struct { + lfs3_data_t data; + uint8_t buf[LFS3_BRANCH_DSIZE]; + } branch; + + struct { + lfs3_data_t data; + uint8_t buf[LFS3_BPTR_DSIZE]; + } bptr; struct { lfs3_data_t data; uint8_t buf[LFS3_BTREE_DSIZE]; @@ -3338,85 +3332,123 @@ static int lfs3_rbyd_appendrattr_(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, } u; } ctx; - // direct buffer? - if (rattr.from == LFS3_FROM_BUF) { - ctx.u.data = LFS3_DATA_BUF(rattr.u.buffer, rattr.count); + // nil data? + if (from == LFS3_FROM_NIL) { + datas = NULL; + data_count = 0; + + // small buffer? + } else if (from == LFS3_FROM_BUF) { + ctx.u.data = LFS3_DATA_BUF((const uint8_t*)args[0], count); + datas = &ctx.u.data; + data_count = 1; + + // immediate data? + } else if (from == LFS3_FROM_DATA) { + ctx.u.data.size = args[0]; + if (!lfs3_data_ondisk(ctx.u.data)) { + ctx.u.data.u.buffer = (const uint8_t*)args[1]; + } else { + ctx.u.data.u.disk.block = args[1]; + ctx.u.data.u.disk.off = args[2]; + #ifdef LFS3_CKDATACKSUMS + if (lfs3_data_isbptr(ctx.u.data)) { + ctx.u.data.u.disk.cksize = args[3]; + ctx.u.data.u.disk.cksum = args[4]; + } + #endif + } datas = &ctx.u.data; data_count = 1; // indirect concatenated data? - } else if (rattr.from == LFS3_FROM_DATA) { - datas = rattr.u.datas; - data_count = rattr.count; + } else if (from == LFS3_FROM_CAT) { + datas = (const lfs3_data_t*)args[0]; + data_count = count; // le32? - } else if (rattr.from == LFS3_FROM_LE32) { - ctx.u.le32.data = lfs3_data_fromle32(rattr.u.le32, + } else if (from == LFS3_FROM_LE32) { + ctx.u.le32.data = lfs3_data_fromle32(args[0], ctx.u.le32.buf); datas = &ctx.u.le32.data; data_count = 1; // leb128? - } else if (rattr.from == LFS3_FROM_LEB128) { + } else if (from == LFS3_FROM_LEB128) { // leb128s should not exceed 31-bits - LFS3_ASSERT(rattr.u.leb128 <= 0x7fffffff); - // little-leb128s should not exceed 28-bits - LFS3_ASSERT(rattr.tag != LFS3_TAG_NAMELIMIT - || rattr.u.leb128 <= 0x0fffffff); - ctx.u.leb128.data = lfs3_data_fromleb128(rattr.u.leb128, + LFS3_ASSERT(args[0] <= 0x7fffffff); + ctx.u.leb128.data = lfs3_data_fromleb128(args[0], ctx.u.leb128.buf); datas = &ctx.u.leb128.data; data_count = 1; // name? - } else if (rattr.from == LFS3_FROM_NAME) { - const lfs3_name_t *name = rattr.u.etc; - ctx.u.name.datas[0] = lfs3_data_fromleb128(name->did, ctx.u.name.buf); - ctx.u.name.datas[1] = LFS3_DATA_BUF(name->name, name->name_len); + } else if (from == LFS3_FROM_NAME) { + ctx.u.name.datas[0] = lfs3_data_fromleb128(args[0], ctx.u.name.buf); + ctx.u.name.datas[1] = LFS3_DATA_BUF((const uint8_t*)args[1], args[2]); datas = ctx.u.name.datas; data_count = 2; - // bptr? - } else if (rattr.from == LFS3_FROM_BPTR) { - ctx.u.bptr.data = lfs3_data_frombptr(rattr.u.etc, - ctx.u.bptr.buf); - datas = &ctx.u.bptr.data; - data_count = 1; - // ecksum? - } else if (rattr.from == LFS3_FROM_ECKSUM) { - ctx.u.ecksum.data = lfs3_data_fromecksum(rattr.u.etc, + } else if (from == LFS3_FROM_ECKSUM) { + ctx.u.ecksum.data = lfs3_data_fromecksum( + &(const lfs3_ecksum_t){ + .cksize = args[0], + .cksum = args[1]}, ctx.u.ecksum.buf); datas = &ctx.u.ecksum.data; data_count = 1; + // branch? + } else if (from == LFS3_FROM_BRANCH) { + ctx.u.branch.data = lfs3_data_frombranch( + &(const lfs3_rbyd_t){ + .blocks[0] = args[0], + .trunk = args[1], + .cksum = args[2]}, + ctx.u.ecksum.buf); + datas = &ctx.u.branch.data; + data_count = 1; + + // bptr? + } else if (from == LFS3_FROM_BPTR) { + ctx.u.bptr.data = lfs3_data_frombptr( + (const lfs3_bptr_t*)args[0], + ctx.u.bptr.buf); + datas = &ctx.u.bptr.data; + data_count = 1; + // btree? - } else if (rattr.from == LFS3_FROM_BTREE) { - ctx.u.btree.data = lfs3_data_frombtree(rattr.u.etc, + } else if (from == LFS3_FROM_BTREE) { + ctx.u.btree.data = lfs3_data_frombtree( + (const lfs3_btree_t*)args[0], ctx.u.btree.buf); datas = &ctx.u.btree.data; data_count = 1; // shrub trunk? - } else if (rattr.from == LFS3_FROM_SHRUB) { + } else if (from == LFS3_FROM_SHRUB) { // note unlike the other lazy tags, we _need_ to lazily encode // shrub trunks, since they change underneath us during mdir // compactions, relocations, etc - ctx.u.shrub.data = lfs3_data_fromshrub(rattr.u.etc, + ctx.u.shrub.data = lfs3_data_fromshrub( + (const lfs3_shrub_t*)args[0], ctx.u.shrub.buf); datas = &ctx.u.shrub.data; data_count = 1; // mptr? - } else if (rattr.from == LFS3_FROM_MPTR) { - ctx.u.mptr.data = lfs3_data_frommptr(rattr.u.etc, + } else if (from == LFS3_FROM_MPTR) { + ctx.u.mptr.data = lfs3_data_frommptr( + (const lfs3_block_t*)args[0], ctx.u.mptr.buf); datas = &ctx.u.mptr.data; data_count = 1; // geometry? - } else if (rattr.from == LFS3_FROM_GEOMETRY) { - ctx.u.geometry.data = lfs3_data_fromgeometry(rattr.u.etc, + } else if (from == LFS3_FROM_GEOMETRY) { + ctx.u.geometry.data = lfs3_data_fromgeometry( + (const lfs3_geometry_t*)args[0], ctx.u.geometry.buf); datas = &ctx.u.geometry.data; data_count = 1; @@ -3441,7 +3473,7 @@ static int lfs3_rbyd_appendrattr_(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, // append tag int err = lfs3_rbyd_appendtag(lfs3, rbyd, - rattr.tag, rattr.weight, size); + tag, weight, size); if (err) { return err; } @@ -3614,16 +3646,15 @@ static void lfs3_rbyd_p_recolor( // our core rbyd append algorithm #ifndef LFS3_RDONLY static int lfs3_rbyd_appendrattr(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, - lfs3_srid_t rid, lfs3_rattr_t rattr) { + lfs3_srid_t rid, const lfs3_rattr_t *rattr) { // must fetch before mutating! LFS3_ASSERT(lfs3_rbyd_isfetched(rbyd)); // tag must not be internal at this point - LFS3_ASSERT(lfs3_tag_suptype(rattr.tag) != LFS3_tag_INTERNAL - || lfs3_rattr_isnoop(rattr)); + LFS3_ASSERT(!lfs3_rattr_isinternal(rattr)); // bit 7 is reserved for future subtype extensions - LFS3_ASSERT(!(rattr.tag & 0x80)); + LFS3_ASSERT(!(lfs3_rattr_tag(rattr) & 0x80)); // you can't delete more than what's in the rbyd - LFS3_ASSERT(rattr.weight >= -(lfs3_srid_t)rbyd->weight); + LFS3_ASSERT(lfs3_rattr_weight(rattr) >= -(lfs3_srid_t)rbyd->weight); // ignore noops if (lfs3_rattr_isnoop(rattr)) { @@ -3637,12 +3668,14 @@ static int lfs3_rbyd_appendrattr(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, } // figure out what range of tags we're operating on + lfs3_tag_t tag = lfs3_rattr_tag(rattr); + lfs3_srid_t weight = lfs3_rattr_weight(rattr); lfs3_srid_t a_rid; lfs3_srid_t b_rid; lfs3_tag_t a_tag; lfs3_tag_t b_tag; - if (!lfs3_tag_isgrow(rattr.tag) && rattr.weight != 0) { - if (rattr.weight > 0) { + if (!lfs3_tag_isgrow(tag) && weight != 0) { + if (weight > 0) { LFS3_ASSERT(rid <= (lfs3_srid_t)rbyd->weight); // it's a bit ugly, but adjusting the rid here makes the following @@ -3656,7 +3689,7 @@ static int lfs3_rbyd_appendrattr(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, // it's a bit ugly, but adjusting the rid here makes the following // logic work out more consistently rid += 1; - a_rid = rid - lfs3_smax(-rattr.weight, 0); + a_rid = rid - lfs3_smax(-weight, 0); b_rid = rid; } @@ -3666,26 +3699,26 @@ static int lfs3_rbyd_appendrattr(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, } else { LFS3_ASSERT(rid < (lfs3_srid_t)rbyd->weight); - a_rid = rid - lfs3_smax(-rattr.weight, 0); + a_rid = rid - lfs3_smax(-weight, 0); b_rid = rid; // note both normal and rm wide-tags have the same bounds, really it's // the normal non-wide-tags that are an outlier here - if (lfs3_tag_ismask12(rattr.tag)) { + if (lfs3_tag_ismask12(tag)) { a_tag = 0x000; b_tag = 0xfff; - } else if (lfs3_tag_ismask8(rattr.tag)) { - a_tag = (rattr.tag & 0xf00); - b_tag = (rattr.tag & 0xf00) + 0x100; - } else if (lfs3_tag_ismask2(rattr.tag)) { - a_tag = (rattr.tag & 0xffc); - b_tag = (rattr.tag & 0xffc) + 0x004; - } else if (lfs3_tag_isrm(rattr.tag)) { - a_tag = lfs3_tag_key(rattr.tag); - b_tag = lfs3_tag_key(rattr.tag) + 1; + } else if (lfs3_tag_ismask8(tag)) { + a_tag = (tag & 0xf00); + b_tag = (tag & 0xf00) + 0x100; + } else if (lfs3_tag_ismask2(tag)) { + a_tag = (tag & 0xffc); + b_tag = (tag & 0xffc) + 0x004; + } else if (lfs3_tag_isrm(tag)) { + a_tag = lfs3_tag_key(tag); + b_tag = lfs3_tag_key(tag) + 1; } else { - a_tag = lfs3_tag_key(rattr.tag); - b_tag = lfs3_tag_key(rattr.tag); + a_tag = lfs3_tag_key(tag); + b_tag = lfs3_tag_key(tag); } } a_tag = lfs3_max(a_tag, 0x1); @@ -3742,41 +3775,41 @@ trunk:; } // read the alt pointer - lfs3_tag_t alt; - lfs3_rid_t weight; - lfs3_size_t jump; + lfs3_tag_t alt_; + lfs3_rid_t weight_; + lfs3_size_t jump_; lfs3_ssize_t d = lfs3_bd_readtag(lfs3, rbyd->blocks[0], branch, 0, - &alt, &weight, &jump, + &alt_, &weight_, &jump_, NULL); if (d < 0) { return d; } // found an alt? - if (lfs3_tag_isalt(alt)) { + if (lfs3_tag_isalt(alt_)) { // make jump absolute - jump = branch - jump; + jump_ = branch - jump_; lfs3_size_t branch_ = branch + d; // yellow alts should be parallel - LFS3_ASSERT(!(lfs3_tag_isred(alt) && lfs3_tag_isred(p[0].alt)) - || lfs3_tag_isparallel(alt, p[0].alt)); + LFS3_ASSERT(!(lfs3_tag_isred(alt_) && lfs3_tag_isred(p[0].alt)) + || lfs3_tag_isparallel(alt_, p[0].alt)); // take black alt? needs a flip // b // .-'| => .-'| // 1 2 1 2 1 if (lfs3_tag_follow2( - alt, weight, + alt_, weight_, p[0].alt, p[0].weight, lower_rid, upper_rid, a_rid, a_tag)) { lfs3_tag_flip2( - &alt, &weight, + &alt_, &weight_, p[0].alt, p[0].weight, lower_rid, upper_rid); - LFS3_SWAP(lfs3_size_t, &jump, &branch_); + LFS3_SWAP(lfs3_size_t, &jump_, &branch_); } // should've taken red alt? needs a flip @@ -3790,17 +3823,17 @@ trunk:; p[0].alt, p[0].weight, lower_rid, upper_rid, a_rid, a_tag)) { - LFS3_SWAP(lfs3_tag_t, &p[0].alt, &alt); - LFS3_SWAP(lfs3_rid_t, &p[0].weight, &weight); - LFS3_SWAP(lfs3_size_t, &p[0].jump, &jump); - alt = (alt & ~LFS3_TAG_R) | (p[0].alt & LFS3_TAG_R); + LFS3_SWAP(lfs3_tag_t, &p[0].alt, &alt_); + LFS3_SWAP(lfs3_rid_t, &p[0].weight, &weight_); + LFS3_SWAP(lfs3_size_t, &p[0].jump, &jump_); + alt_ = (alt_ & ~LFS3_TAG_R) | (p[0].alt & LFS3_TAG_R); p[0].alt |= LFS3_TAG_R; lfs3_tag_flip2( - &alt, &weight, + &alt_, &weight_, p[0].alt, p[0].weight, lower_rid, upper_rid); - LFS3_SWAP(lfs3_size_t, &jump, &branch_); + LFS3_SWAP(lfs3_size_t, &jump_, &branch_); } // do bounds want to take different paths? begin diverging @@ -3812,7 +3845,7 @@ trunk:; // .-'| .-'| | .-'| | .-----' // 1 2 3 4 1 2 3 4 x 1 2 3 4 x x bool diverging_b = lfs3_tag_diverging2( - alt, weight, + alt_, weight_, p[0].alt, p[0].weight, lower_rid, upper_rid, a_rid, a_tag, @@ -3832,10 +3865,10 @@ trunk:; // 1 2 3 1 2 3 x if (diverging_b && diverging_r) { LFS3_ASSERT(a_rid < b_rid || a_tag < b_tag); - LFS3_ASSERT(lfs3_tag_isparallel(alt, p[0].alt)); + LFS3_ASSERT(lfs3_tag_isparallel(alt_, p[0].alt)); - weight += p[0].weight; - jump = p[0].jump; + weight_ += p[0].weight; + jump_ = p[0].jump; lfs3_rbyd_p_pop(p); diverging_r = false; @@ -3851,7 +3884,7 @@ trunk:; // 1 2 3 4 1 2 3 4 x if ((diverging_b || diverging_r) // diverging black? - && (lfs3_tag_isblack(alt) + && (lfs3_tag_isblack(alt_) // give up if we find a yellow alt || (lfs3_tag_isred(p[0].alt)))) { diverged = true; @@ -3867,11 +3900,11 @@ trunk:; if (a_rid > b_rid || a_tag > b_tag) { LFS3_ASSERT(!diverging_r); - alt = LFS3_TAG_ALT( - alt & LFS3_TAG_R, + alt_ = LFS3_TAG_ALT( + alt_ & LFS3_TAG_R, LFS3_TAG_LE, d_tag); - weight -= d_weight; + weight_ -= d_weight; lower_rid += d_weight; } } @@ -3883,10 +3916,10 @@ trunk:; // 3 4 3 4 x if (diverging_b) { lfs3_tag_trim( - alt, weight, + alt_, weight_, &lower_rid, &upper_rid, &lower_tag, &upper_tag); - weight = 0; + weight_ = 0; } } @@ -3909,7 +3942,7 @@ trunk:; lower_rid, upper_rid, lower_tag, upper_tag) && p[0].jump > branch) { - alt &= ~LFS3_TAG_R; + alt_ &= ~LFS3_TAG_R; lfs3_rbyd_p_pop(p); // prune unreachable yellow-split red alts @@ -3924,14 +3957,14 @@ trunk:; // 1 2 3 4 4 1 2 3 4 4 2 } else if (lfs3_tag_isred(p[0].alt) && lfs3_tag_unreachable2( - alt, weight, + alt_, weight_, p[0].alt, p[0].weight, lower_rid, upper_rid, lower_tag, upper_tag) - && jump > branch) { - alt = p[0].alt & ~LFS3_TAG_R; - weight = p[0].weight; - jump = p[0].jump; + && jump_ > branch) { + alt_ = p[0].alt & ~LFS3_TAG_R; + weight_ = p[0].weight; + jump_ = p[0].jump; lfs3_rbyd_p_pop(p); } @@ -3953,7 +3986,7 @@ trunk:; // prune black alts if (lfs3_tag_unreachable2( - alt, weight, + alt_, weight_, p[0].alt, p[0].weight, lower_rid, upper_rid, lower_tag, upper_tag)) { @@ -3975,10 +4008,10 @@ trunk:; // | .-'| | .-----' // 1 2 3 1 2 3 x } else if (lfs3_tag_isred(p[0].alt)) { - LFS3_ASSERT(jump < branch); - alt = (p[0].alt & ~LFS3_TAG_R) | (alt & LFS3_TAG_R); - weight = p[0].weight; - jump = p[0].jump; + LFS3_ASSERT(jump_ < branch); + alt_ = (p[0].alt & ~LFS3_TAG_R) | (alt_ & LFS3_TAG_R); + weight_ = p[0].weight; + jump_ = p[0].jump; lfs3_rbyd_p_pop(p); // we can't prune non-root black alts or we risk @@ -3988,18 +4021,18 @@ trunk:; // nb // .-'| .--' // 3 4 3 4 x - } else if (lfs3_tag_isblack(alt)) { - alt = LFS3_TAG_ALT( + } else if (lfs3_tag_isblack(alt_)) { + alt_ = LFS3_TAG_ALT( LFS3_TAG_B, LFS3_TAG_LE, (diverged && (a_rid > b_rid || a_tag > b_tag)) ? d_tag : lower_tag); - LFS3_ASSERT(weight == 0); - // jump=0 also asserts the alt is unreachable (or + LFS3_ASSERT(weight_ == 0); + // jump_=0 also asserts the alt is unreachable (or // else we loop indefinitely), and uses the minimum // alt encoding - jump = 0; + jump_ = 0; } } @@ -4007,7 +4040,7 @@ trunk:; // // note we've lost the original yellow edge because of flips, but // we know the red edge is the only branch_ > branch - if (lfs3_tag_isred(alt) && lfs3_tag_isred(p[0].alt)) { + if (lfs3_tag_isred(alt_) && lfs3_tag_isred(p[0].alt)) { // if we take the red or yellow alt we can just point // to the black alt // b @@ -4018,12 +4051,12 @@ trunk:; // | | .-'| | .-'| | // 1 2 3 4 1 2 3 4 1 if (branch_ < branch) { - if (jump > branch) { - LFS3_SWAP(lfs3_tag_t, &p[0].alt, &alt); - LFS3_SWAP(lfs3_rid_t, &p[0].weight, &weight); - LFS3_SWAP(lfs3_size_t, &p[0].jump, &jump); + if (jump_ > branch) { + LFS3_SWAP(lfs3_tag_t, &p[0].alt, &alt_); + LFS3_SWAP(lfs3_rid_t, &p[0].weight, &weight_); + LFS3_SWAP(lfs3_size_t, &p[0].jump, &jump_); } - alt &= ~LFS3_TAG_R; + alt_ &= ~LFS3_TAG_R; lfs3_tag_trim( p[0].alt, p[0].weight, @@ -4044,8 +4077,8 @@ trunk:; // 1 2 3 4 1 2 3 4 4 } else { LFS3_ASSERT(y_branch != 0); - p[0].alt = alt; - p[0].weight += weight; + p[0].alt = alt_; + p[0].weight += weight_; p[0].jump = y_branch; lfs3_tag_trim( @@ -4060,21 +4093,21 @@ trunk:; } // red alt? we need to read the rest of the 2-3-4 node - if (lfs3_tag_isred(alt)) { + if (lfs3_tag_isred(alt_)) { // undo flip temporarily if (branch_ < branch) { lfs3_tag_flip2( - &alt, &weight, + &alt_, &weight_, p[0].alt, p[0].weight, lower_rid, upper_rid); - LFS3_SWAP(lfs3_size_t, &jump, &branch_); + LFS3_SWAP(lfs3_size_t, &jump_, &branch_); } // black alt? terminate 2-3-4 nodes } else { // trim alts from our current bounds lfs3_tag_trim2( - alt, weight, + alt_, weight_, p[0].alt, p[0].weight, &lower_rid, &upper_rid, &lower_tag, &upper_tag); @@ -4082,7 +4115,7 @@ trunk:; // push alt onto our queue err = lfs3_rbyd_p_push(lfs3, rbyd, p, - alt, weight, jump); + alt_, weight_, jump_); if (err) { return err; } @@ -4095,7 +4128,7 @@ trunk:; // found end of tree? } else { // update the found tag - tag_ = lfs3_tag_key(alt); + tag_ = lfs3_tag_key(alt_); // the last alt should always end up black LFS3_ASSERT(lfs3_tag_isblack(p[0].alt)); @@ -4114,10 +4147,10 @@ trunk:; } // terminate diverged trunk with an unreachable tag - err = lfs3_rbyd_appendrattr_(lfs3, rbyd, LFS3_RATTR( + err = lfs3_rbyd_appendtag(lfs3, rbyd, (lfs3_rbyd_isshrub(rbyd) ? LFS3_TAG_SHRUB : 0) | LFS3_TAG_NULL, - 0)); + 0, 0); if (err) { return err; } @@ -4156,48 +4189,48 @@ stem:; // - rm-bit set => never split, but emit alt-always tags, making our // tag effectively unreachable // - lfs3_tag_t alt = 0; - lfs3_rid_t weight = 0; + lfs3_tag_t alt_ = 0; + lfs3_rid_t weight_ = 0; if (tag_ - && (upper_rid-1 < rid-lfs3_smax(-rattr.weight, 0) - || (upper_rid-1 == rid-lfs3_smax(-rattr.weight, 0) - && ((!lfs3_tag_isgrow(rattr.tag) && rattr.weight > 0) - || ((tag_ & lfs3_tag_mask(rattr.tag)) - < (rattr.tag & lfs3_tag_mask(rattr.tag))))))) { - if (lfs3_tag_isrm(rattr.tag) || !lfs3_tag_key(rattr.tag)) { + && (upper_rid-1 < rid-lfs3_smax(-weight, 0) + || (upper_rid-1 == rid-lfs3_smax(-weight, 0) + && ((!lfs3_tag_isgrow(tag) && weight > 0) + || ((tag_ & lfs3_tag_mask(tag)) + < (tag & lfs3_tag_mask(tag))))))) { + if (lfs3_tag_isrm(tag) || !lfs3_tag_key(tag)) { // if removed, make our tag unreachable - alt = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_GT, lower_tag); - weight = upper_rid - lower_rid + rattr.weight; - upper_rid -= weight; + alt_ = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_GT, lower_tag); + weight_ = upper_rid - lower_rid + weight; + upper_rid -= weight_; } else { // split less than - alt = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_LE, tag_); - weight = upper_rid - lower_rid; - lower_rid += weight; + alt_ = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_LE, tag_); + weight_ = upper_rid - lower_rid; + lower_rid += weight_; } } else if (tag_ && (upper_rid-1 > rid || (upper_rid-1 == rid - && ((!lfs3_tag_isgrow(rattr.tag) && rattr.weight > 0) - || ((tag_ & lfs3_tag_mask(rattr.tag)) - > (rattr.tag & lfs3_tag_mask(rattr.tag))))))) { - if (lfs3_tag_isrm(rattr.tag) || !lfs3_tag_key(rattr.tag)) { + && ((!lfs3_tag_isgrow(tag) && weight > 0) + || ((tag_ & lfs3_tag_mask(tag)) + > (tag & lfs3_tag_mask(tag))))))) { + if (lfs3_tag_isrm(tag) || !lfs3_tag_key(tag)) { // if removed, make our tag unreachable - alt = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_GT, lower_tag); - weight = upper_rid - lower_rid + rattr.weight; - upper_rid -= weight; + alt_ = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_GT, lower_tag); + weight_ = upper_rid - lower_rid + weight; + upper_rid -= weight_; } else { // split greater than - alt = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_GT, rattr.tag); - weight = upper_rid - (rid+1); - upper_rid -= weight; + alt_ = LFS3_TAG_ALT(LFS3_TAG_B, LFS3_TAG_GT, tag); + weight_ = upper_rid - (rid+1); + upper_rid -= weight_; } } - if (alt) { + if (alt_) { err = lfs3_rbyd_p_push(lfs3, rbyd, p, - alt, weight, branch); + alt_, weight_, branch); if (err) { return err; } @@ -4217,22 +4250,24 @@ leaf:; // // note we always need a non-alt to terminate the trunk, otherwise we // can't find trunks during fetch - err = lfs3_rbyd_appendrattr_(lfs3, rbyd, LFS3_RATTR_( + err = lfs3_rbyd_appendrattr_(lfs3, rbyd, // mark as shrub if we are a shrub (lfs3_rbyd_isshrub(rbyd) ? LFS3_TAG_SHRUB : 0) // rm => null, otherwise strip off control bits - | ((lfs3_tag_isrm(rattr.tag)) + | ((lfs3_tag_isrm(tag)) ? LFS3_TAG_NULL - : lfs3_tag_key(rattr.tag)), - upper_rid - lower_rid + rattr.weight, - rattr)); + : lfs3_tag_key(tag)), + upper_rid - lower_rid + weight, + lfs3_rattr_from(rattr), + lfs3_rattr_count(rattr), + lfs3_rattr_args(rattr)); if (err) { return err; } // update the trunk and weight rbyd->trunk = (rbyd->trunk & LFS3_RBYD_ISSHRUB) | trunk_; - rbyd->weight += rattr.weight; + rbyd->weight += weight; return 0; } #endif @@ -4296,11 +4331,11 @@ static int lfs3_rbyd_appendcksum_(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, return err; } - err = lfs3_rbyd_appendrattr_(lfs3, rbyd, LFS3_RATTR_ECKSUM( + err = lfs3_rbyd_appendrattr_(lfs3, rbyd, LFS3_TAG_ECKSUM, 0, - (&(lfs3_ecksum_t){ - .cksize=lfs3->cfg->prog_size, - .cksum=ecksum}))); + LFS3_FROM_ECKSUM, 0, LFS3_RATTRS( + LFS3_RATTR_ARG(lfs3->cfg->prog_size), + LFS3_RATTR_ARG(ecksum))); if (err) { return err; } @@ -4403,12 +4438,12 @@ static int lfs3_rbyd_appendcksum(lfs3_t *lfs3, lfs3_rbyd_t *rbyd) { #ifndef LFS3_RDONLY static int lfs3_rbyd_appendrattrs(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, lfs3_srid_t rid, lfs3_srid_t start_rid, lfs3_srid_t end_rid, - const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + const lfs3_rattr_t *rattrs) { // append each tag to the tree - for (lfs3_size_t i = 0; i < rattr_count; i++) { + for (const lfs3_rattr_t *r = rattrs; *r; r = lfs3_rattr_next(r, &rid)) { // treat inserts after the first tag as though they are splits, // sequential inserts don't really make sense otherwise - if (i > 0 && lfs3_rattr_isinsert(rattrs[i])) { + if (r > rattrs && lfs3_rattr_isinsert(r)) { rid += 1; } @@ -4420,7 +4455,7 @@ static int lfs3_rbyd_appendrattrs(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, && (lfs3_size_t)(rid + 1) <= (lfs3_size_t)end_rid) { int err = lfs3_rbyd_appendrattr(lfs3, rbyd, rid - lfs3_smax(start_rid, 0), - rattrs[i]); + r); if (err) { return err; } @@ -4429,24 +4464,20 @@ static int lfs3_rbyd_appendrattrs(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, // we need to make sure we keep start_rid/end_rid updated with // weight changes if (rid < start_rid) { - start_rid += rattrs[i].weight; + start_rid += lfs3_rattr_weight(r); } if (rid < end_rid) { - end_rid += rattrs[i].weight; + end_rid += lfs3_rattr_weight(r); } - - // adjust rid - rid = lfs3_rattr_nextrid(rattrs[i], rid); } return 0; } static int lfs3_rbyd_commit(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, - lfs3_srid_t rid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + lfs3_srid_t rid, const lfs3_rattr_t *rattrs) { // append each tag to the tree - int err = lfs3_rbyd_appendrattrs(lfs3, rbyd, rid, -1, -1, - rattrs, rattr_count); + int err = lfs3_rbyd_appendrattrs(lfs3, rbyd, rid, -1, -1, rattrs); if (err) { return err; } @@ -4550,7 +4581,7 @@ static lfs3_ssize_t lfs3_rbyd_estimate(lfs3_t *lfs3, const lfs3_rbyd_t *rbyd, // also note rattr.weight here is total weight not delta weight #ifndef LFS3_RDONLY static int lfs3_rbyd_appendcompactrattr(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, - lfs3_rattr_t rattr) { + const lfs3_rattr_t *rattr) { // begin appending int err = lfs3_rbyd_appendinit(lfs3, rbyd); if (err) { @@ -4558,10 +4589,13 @@ static int lfs3_rbyd_appendcompactrattr(lfs3_t *lfs3, lfs3_rbyd_t *rbyd, } // write the tag - err = lfs3_rbyd_appendrattr_(lfs3, rbyd, LFS3_RATTR_( - (lfs3_rbyd_isshrub(rbyd) ? LFS3_TAG_SHRUB : 0) | rattr.tag, - rattr.weight, - rattr)); + err = lfs3_rbyd_appendrattr_(lfs3, rbyd, + (lfs3_rbyd_isshrub(rbyd) ? LFS3_TAG_SHRUB : 0) + | lfs3_rattr_tag(rattr), + lfs3_rattr_weight(rattr), + lfs3_rattr_from(rattr), + lfs3_rattr_count(rattr), + lfs3_rattr_args(rattr)); if (err) { return err; } @@ -4596,8 +4630,10 @@ static int lfs3_rbyd_appendcompactrbyd(lfs3_t *lfs3, lfs3_rbyd_t *rbyd_, } // write the tag - int err = lfs3_rbyd_appendcompactrattr(lfs3, rbyd_, LFS3_RATTR_DATA( - tag, weight, &data)); + int err = lfs3_rbyd_appendcompactrattr(lfs3, rbyd_, LFS3_RATTRS( + LFS3_RATTR(3, tag, -2, LFS3_FROM_CAT, 1), + LFS3_RATTR_WEIGHT(weight), + LFS3_RATTR_ARG(&data))); if (err) { return err; } @@ -5384,19 +5420,13 @@ static int lfs3_btree_parent(lfs3_t *lfs3, // extra state needed for non-terminating lfs3_btree_commit_ calls #ifndef LFS3_RDONLY typedef struct lfs3_bcommit { - // pending commit, this is updates as lfs3_btree_commit_ recurses + // pending commit, this is updated as lfs3_btree_commit_ recurses lfs3_bid_t bid; const lfs3_rattr_t *rattrs; - lfs3_size_t rattr_count; - // internal lfs3_btree_commit_ state that needs to persist until - // the root is committed - struct { - lfs3_rattr_t rattrs[4]; - lfs3_data_t split_name; - uint8_t l_buf[LFS3_BRANCH_DSIZE]; - uint8_t r_buf[LFS3_BRANCH_DSIZE]; - } ctx; + // scratch space for lfs3_btree_commit_ state that needs to persist + // until the root is committed + lfs3_rattr_t rscratch[16]; } lfs3_bcommit_t; #endif @@ -5537,7 +5567,7 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, // interacting with other references to the rbyd *child_ = child; int err = lfs3_rbyd_commit(lfs3, child_, rid, - bcommit->rattrs, bcommit->rattr_count); + bcommit->rattrs); if (err) { if (err == LFS3_ERR_RANGE || err == LFS3_ERR_CORRUPT) { goto compact; @@ -5567,29 +5597,27 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, // note that since we defer merges to compaction time, we can // end up removing an rbyd here bcommit->bid -= pid - (child.weight-1); - lfs3_size_t rattr_count = 0; - lfs3_data_t branch; + bcommit->rattrs = bcommit->rscratch; + lfs3_rattr_t *r = bcommit->rscratch; // drop child? if (child_->weight == 0) { // drop child - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR( - LFS3_tag_RM, -child.weight); + *r++ = LFS3_RATTR(2, LFS3_tag_RM, -2); + *r++ = LFS3_RATTR_WEIGHT(-child.weight); } else { // update child - branch = lfs3_data_frombranch(child_, bcommit->ctx.l_buf); - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR_BUF( - LFS3_TAG_BRANCH, 0, - branch.u.buffer, lfs3_data_size(branch)); + *r++ = LFS3_RATTR(4, LFS3_TAG_BRANCH, 0, LFS3_FROM_BRANCH); + *r++ = LFS3_RATTR_ARG(child_->blocks[0]); + *r++ = LFS3_RATTR_ARG(child_->trunk); + *r++ = LFS3_RATTR_ARG(child_->cksum); if (child_->weight != child.weight) { - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR( - LFS3_tag_GROW, -child.weight + child_->weight); + *r++ = LFS3_RATTR(2, LFS3_tag_GROW, -2); + *r++ = LFS3_RATTR_ARG(-child.weight + child_->weight); } } - LFS3_ASSERT(rattr_count - <= sizeof(bcommit->ctx.rattrs) - / sizeof(lfs3_rattr_t)); - bcommit->rattrs = bcommit->ctx.rattrs; - bcommit->rattr_count = rattr_count; + *r++ = LFS3_RATTR_NULL; + LFS3_ASSERT((lfs3_size_t)(r-bcommit->rscratch) + <= sizeof(bcommit->rscratch)/sizeof(lfs3_rattr_t)); // recurse! child = parent; @@ -5754,7 +5782,7 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, // append any pending rattrs, it's up to upper // layers to make sure these always fit err = lfs3_rbyd_commit(lfs3, child_, rid, - bcommit->rattrs, bcommit->rattr_count); + bcommit->rattrs); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block @@ -5806,7 +5834,7 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, // upper layers should make sure this can't fail by limiting the // maximum commit size err = lfs3_rbyd_appendrattrs(lfs3, child_, rid, -1, split_rid, - bcommit->rattrs, bcommit->rattr_count); + bcommit->rattrs); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block @@ -5862,7 +5890,7 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, // upper layers should make sure this can't fail by limiting the // maximum commit size err = lfs3_rbyd_appendrattrs(lfs3, &sibling, rid, split_rid, -1, - bcommit->rattrs, bcommit->rattr_count); + bcommit->rattrs); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block @@ -5897,8 +5925,9 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, // // note we need to do this after playing out pending rattrs in case // they introduce a new name! + lfs3_data_t split_name; lfs3_stag_t split_tag = lfs3_rbyd_lookupnext(lfs3, &sibling, 0, 0, - NULL, NULL, &bcommit->ctx.split_name); + NULL, NULL, &split_name); if (split_tag < 0) { LFS3_ASSERT(split_tag != LFS3_ERR_NOENT); return split_tag; @@ -5909,40 +5938,44 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, LFS3_ASSERT(sibling.weight > 0); // don't worry about bid if new root, we discard it anyways bcommit->bid -= pid - (child.weight-1); - rattr_count = 0; - branch = lfs3_data_frombranch(child_, bcommit->ctx.l_buf); + bcommit->rattrs = bcommit->rscratch; + r = bcommit->rscratch; + // new root? if (!lfs3_rbyd_trunk(&parent)) { // new child - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR_BUF( - LFS3_TAG_BRANCH, +child_->weight, - branch.u.buffer, lfs3_data_size(branch)); + *r++ = LFS3_RATTR(5, LFS3_TAG_BRANCH, -2, LFS3_FROM_BRANCH); + *r++ = LFS3_RATTR_WEIGHT(+child_->weight); + *r++ = LFS3_RATTR_ARG(child_->blocks[0]); + *r++ = LFS3_RATTR_ARG(child_->trunk); + *r++ = LFS3_RATTR_ARG(child_->cksum); // split root? } else { // update child - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR_BUF( - LFS3_TAG_BRANCH, 0, - branch.u.buffer, lfs3_data_size(branch)); + *r++ = LFS3_RATTR(4, LFS3_TAG_BRANCH, 0, LFS3_FROM_BRANCH); + *r++ = LFS3_RATTR_ARG(child_->blocks[0]); + *r++ = LFS3_RATTR_ARG(child_->trunk); + *r++ = LFS3_RATTR_ARG(child_->cksum); if (child_->weight != child.weight) { - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR( - LFS3_tag_GROW, -child.weight + child_->weight); + *r++ = LFS3_RATTR(2, LFS3_tag_GROW, -2); + *r++ = LFS3_RATTR_WEIGHT(-child.weight + child_->weight); } } // new sibling - branch = lfs3_data_frombranch(&sibling, bcommit->ctx.r_buf); - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR_BUF( - LFS3_TAG_BRANCH, +sibling.weight, - branch.u.buffer, lfs3_data_size(branch)); + *r++ = LFS3_RATTR(5, LFS3_TAG_BRANCH, -2, LFS3_FROM_BRANCH); + *r++ = LFS3_RATTR_WEIGHT(+sibling.weight); + *r++ = LFS3_RATTR_ARG(sibling.blocks[0]); + *r++ = LFS3_RATTR_ARG(sibling.trunk); + *r++ = LFS3_RATTR_ARG(sibling.cksum); if (lfs3_tag_suptype(split_tag) == LFS3_TAG_NAME) { - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR_DATA( - LFS3_TAG_BNAME, 0, - &bcommit->ctx.split_name); + *r++ = LFS3_RATTR(4, LFS3_TAG_BNAME, 0, LFS3_FROM_DATA); + *r++ = LFS3_RATTR_ARG(split_name.size); + *r++ = LFS3_RATTR_ARG(split_name.u.disk.block); + *r++ = LFS3_RATTR_ARG(split_name.u.disk.off); } - LFS3_ASSERT(rattr_count - <= sizeof(bcommit->ctx.rattrs) - / sizeof(lfs3_rattr_t)); - bcommit->rattrs = bcommit->ctx.rattrs; - bcommit->rattr_count = rattr_count; + *r++ = LFS3_RATTR_NULL; + LFS3_ASSERT((lfs3_size_t)(r-bcommit->rscratch) + <= sizeof(bcommit->rscratch)/sizeof(lfs3_rattr_t)); // recurse! child = parent; @@ -6003,7 +6036,7 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, // append any pending rattrs, it's up to upper // layers to make sure these always fit err = lfs3_rbyd_commit(lfs3, child_, rid, - bcommit->rattrs, bcommit->rattr_count); + bcommit->rattrs); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block @@ -6026,24 +6059,23 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, // prepare commit to parent, tail recursing upwards LFS3_ASSERT(child_->weight > 0); bcommit->bid -= pid - (child.weight-1); - rattr_count = 0; + bcommit->rattrs = bcommit->rscratch; + r = bcommit->rscratch; // merge sibling - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR( - LFS3_tag_RM, -sibling.weight); + *r++ = LFS3_RATTR(2, LFS3_tag_RM, -2); + *r++ = LFS3_RATTR_WEIGHT(-sibling.weight); // update child - branch = lfs3_data_frombranch(child_, bcommit->ctx.l_buf); - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR_BUF( - LFS3_TAG_BRANCH, 0, - branch.u.buffer, lfs3_data_size(branch)); + *r++ = LFS3_RATTR(4, LFS3_TAG_BRANCH, 0, LFS3_FROM_BRANCH); + *r++ = LFS3_RATTR_ARG(child_->blocks[0]); + *r++ = LFS3_RATTR_ARG(child_->trunk); + *r++ = LFS3_RATTR_ARG(child_->cksum); if (child_->weight != child.weight) { - bcommit->ctx.rattrs[rattr_count++] = LFS3_RATTR( - LFS3_tag_GROW, -child.weight + child_->weight); + *r++ = LFS3_RATTR(2, LFS3_tag_GROW, -2); + *r++ = LFS3_RATTR_ARG(-child.weight + child_->weight); } - LFS3_ASSERT(rattr_count - <= sizeof(bcommit->ctx.rattrs) - / sizeof(lfs3_rattr_t)); - bcommit->rattrs = bcommit->ctx.rattrs; - bcommit->rattr_count = rattr_count; + *r++ = LFS3_RATTR_NULL; + LFS3_ASSERT((lfs3_size_t)(r-bcommit->rscratch) + <= sizeof(bcommit->rscratch)/sizeof(lfs3_rattr_t)); // recurse! child = parent; @@ -6057,7 +6089,7 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, #ifndef LFS3_RDONLY static int lfs3_btree_commitroot_(lfs3_t *lfs3, lfs3_rbyd_t *btree_, lfs3_btree_t *btree, - lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + const lfs3_bcommit_t *bcommit) { relocate:; int err = lfs3_rbyd_alloc(lfs3, btree_); if (err) { @@ -6089,7 +6121,8 @@ relocate:; } } - err = lfs3_rbyd_commit(lfs3, btree_, bid, rattrs, rattr_count); + err = lfs3_rbyd_commit(lfs3, btree_, + bcommit->bid, bcommit->rattrs); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block @@ -6106,13 +6139,12 @@ relocate:; // commit to a btree, this is atomic #ifndef LFS3_RDONLY static int lfs3_btree_commit(lfs3_t *lfs3, lfs3_btree_t *btree, - lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + lfs3_bid_t bid, const lfs3_rattr_t *rattrs) { // try to commit to the btree lfs3_rbyd_t btree_; lfs3_bcommit_t bcommit; // do _not_ fully init this bcommit.bid = bid; bcommit.rattrs = rattrs; - bcommit.rattr_count = rattr_count; int err = lfs3_btree_commit_(lfs3, &btree_, btree, &bcommit); if (err && err != LFS3_ERR_RANGE) { @@ -6123,7 +6155,7 @@ static int lfs3_btree_commit(lfs3_t *lfs3, lfs3_btree_t *btree, // needs a new root? if (err == LFS3_ERR_RANGE) { err = lfs3_btree_commitroot_(lfs3, &btree_, btree, - bcommit.bid, bcommit.rattrs, bcommit.rattr_count); + &bcommit); if (err) { return err; } @@ -6516,7 +6548,7 @@ typedef struct lfs3_shrubcommit { #ifndef LFS3_RDONLY static int lfs3_shrub_commit(lfs3_t *lfs3, lfs3_rbyd_t *rbyd_, lfs3_shrub_t *shrub, lfs3_srid_t rid, - const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + const lfs3_rattr_t *rattrs) { // swap out our trunk/weight temporarily, note we're // operating on a copy so if this fails we shouldn't mess // things up too much @@ -6528,8 +6560,7 @@ static int lfs3_shrub_commit(lfs3_t *lfs3, lfs3_rbyd_t *rbyd_, rbyd_->weight = shrub->weight; // append any bshrub attributes - int err = lfs3_rbyd_appendrattrs(lfs3, rbyd_, rid, -1, -1, - rattrs, rattr_count); + int err = lfs3_rbyd_appendrattrs(lfs3, rbyd_, rid, -1, -1, rattrs); if (err) { return err; } @@ -6731,13 +6762,13 @@ static lfs3_stag_t lfs3_bshrub_traverse(lfs3_t *lfs3, // needed in lfs3_bshrub_commitroot_ #ifndef LFS3_RDONLY static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, - const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count); + const lfs3_rattr_t *rattrs); #endif // commit to the bshrub root, i.e. the bshrub's shrub #ifndef LFS3_RDONLY static int lfs3_bshrub_commitroot_(lfs3_t *lfs3, lfs3_bshrub_t *bshrub, - lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + const lfs3_bcommit_t *bcommit) { // we need to prevent our shrub from overflowing our mdir somehow // // maintaining an accurate estimate is tricky and error-prone, @@ -6750,17 +6781,21 @@ static int lfs3_bshrub_commitroot_(lfs3_t *lfs3, lfs3_bshrub_t *bshrub, // figure out how much data this commit progs lfs3_size_t commit_estimate = 0; - for (lfs3_size_t i = 0; i < rattr_count; i++) { + for (const lfs3_rattr_t *r = bcommit->rattrs; + *r; + r = lfs3_rattr_next(r, NULL)) { commit_estimate += lfs3->rattr_estimate; // fortunately the tags we commit to shrubs are actually quite // limited, if lazily encoded the rattr should set rattr.count // to the expected dsize - if (rattrs[i].from == LFS3_FROM_DATA) { - for (lfs3_size_t j = 0; j < rattrs[i].count; j++) { - commit_estimate += lfs3_data_size(rattrs[i].u.datas[j]); + if (lfs3_rattr_from(r) == LFS3_FROM_CAT) { + const lfs3_data_t *datas + = (const lfs3_data_t*)lfs3_rattr_arg(r, 0); + for (lfs3_size_t j = 0; j < lfs3_rattr_count(r); j++) { + commit_estimate += lfs3_data_size(datas[j]); } } else { - commit_estimate += rattrs[i].count; + commit_estimate += lfs3_rattr_count(r); } } @@ -6799,12 +6834,11 @@ static int lfs3_bshrub_commitroot_(lfs3_t *lfs3, lfs3_bshrub_t *bshrub, // note we do _not_ checkpoint the allocator here, blocks may be // in-flight! int err = lfs3_mdir_commit_(lfs3, &bshrub->h.mdir, LFS3_RATTRS( - LFS3_RATTR_SHRUBCOMMIT( - (&(lfs3_shrubcommit_t){ - .bshrub=bshrub, - .rid=bid, - .rattrs=rattrs, - .rattr_count=rattr_count})))); + LFS3_RATTR(4, LFS3_tag_SHRUBCOMMIT, 0), + LFS3_RATTR_ARG(bshrub), + LFS3_RATTR_ARG(bcommit->bid), + LFS3_RATTR_ARG(bcommit->rattrs), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -6834,12 +6868,11 @@ static int lfs3_bshrub_commitroot_(lfs3_t *lfs3, lfs3_bshrub_t *bshrub, // commit to bshrub, this is atomic #ifndef LFS3_RDONLY static int lfs3_bshrub_commit(lfs3_t *lfs3, lfs3_bshrub_t *bshrub, - lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + lfs3_bid_t bid, const lfs3_rattr_t *rattrs) { // try to commit to the btree lfs3_bcommit_t bcommit; // do _not_ fully init this bcommit.bid = bid; bcommit.rattrs = rattrs; - bcommit.rattr_count = rattr_count; int err = lfs3_btree_commit_(lfs3, &bshrub->b_, &bshrub->b, &bcommit); if (err && err != LFS3_ERR_RANGE @@ -6861,16 +6894,15 @@ static int lfs3_bshrub_commit(lfs3_t *lfs3, lfs3_bshrub_t *bshrub, // try to commit to shrub root err = lfs3_bshrub_commitroot_(lfs3, bshrub, - bcommit.bid, bcommit.rattrs, bcommit.rattr_count); + &bcommit); if (err && err != LFS3_ERR_RANGE) { return err; } // if we don't fit, convert to btree if (err == LFS3_ERR_RANGE) { - err = lfs3_btree_commitroot_(lfs3, - &bshrub->b_, &bshrub->b, - bcommit.bid, bcommit.rattrs, bcommit.rattr_count); + err = lfs3_btree_commitroot_(lfs3, &bshrub->b_, &bshrub->b, + &bcommit); if (err) { return err; } @@ -7599,12 +7631,12 @@ static int lfs3_rbyd_appendgdelta(lfs3_t *lfs3, lfs3_rbyd_t *rbyd) { // append to our rbyd, replacing any existing delta lfs3_size_t size = lfs3_memlen(grmdelta_, LFS3_GRM_DSIZE); - int err = lfs3_rbyd_appendrattr(lfs3, rbyd, -1, LFS3_RATTR_BUF( + int err = lfs3_rbyd_appendrattr(lfs3, rbyd, -1, LFS3_RATTRS( // opportunistically remove this tag if delta is all zero (size == 0) - ? LFS3_tag_RM | LFS3_TAG_GRMDELTA - : LFS3_TAG_GRMDELTA, 0, - grmdelta_, size)); + ? LFS3_RATTR(2, LFS3_tag_RM | LFS3_TAG_GRMDELTA, 0) + : LFS3_RATTR(2, LFS3_TAG_GRMDELTA, 0, LFS3_FROM_BUF, size), + LFS3_RATTR_ARG(grmdelta_))); if (err) { return err; } @@ -7650,12 +7682,13 @@ static int lfs3_rbyd_appendgdelta(lfs3_t *lfs3, lfs3_rbyd_t *rbyd) { // append to our rbyd, replacing any existing delta lfs3_size_t size = lfs3_memlen(gbmapdelta_, LFS3_GBMAP_DSIZE); - int err = lfs3_rbyd_appendrattr(lfs3, rbyd, -1, LFS3_RATTR_BUF( + int err = lfs3_rbyd_appendrattr(lfs3, rbyd, -1, LFS3_RATTRS( // opportunistically remove this tag if delta is all zero (size == 0) - ? LFS3_tag_RM | LFS3_TAG_GBMAPDELTA - : LFS3_TAG_GBMAPDELTA, 0, - gbmapdelta_, size)); + ? LFS3_RATTR(2, LFS3_tag_RM | LFS3_TAG_GBMAPDELTA, 0) + : LFS3_RATTR(2, LFS3_TAG_GBMAPDELTA, 0, + LFS3_FROM_BUF, size), + LFS3_RATTR_ARG(gbmapdelta_))); if (err) { return err; } @@ -8086,8 +8119,8 @@ static int lfs3_mtree_lookup(lfs3_t *lfs3, lfs3_smid_t mid, #ifndef LFS3_RDONLY static int lfs3_mtree_commit(lfs3_t *lfs3, lfs3_btree_t *mtree, - lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { - return lfs3_btree_commit(lfs3, mtree, bid, rattrs, rattr_count); + lfs3_bid_t bid, const lfs3_rattr_t *rattrs) { + return lfs3_btree_commit(lfs3, mtree, bid, rattrs); } #endif @@ -8215,7 +8248,7 @@ static int lfs3_mdir_swap___(lfs3_t *lfs3, lfs3_mdir_t *mdir_, #ifndef LFS3_RDONLY static int lfs3_mdir_commit___(lfs3_t *lfs3, lfs3_mdir_t *mdir_, lfs3_srid_t start_rid, lfs3_srid_t end_rid, - lfs3_smid_t mid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + lfs3_smid_t mid, const lfs3_rattr_t *rattrs) { // since we only ever commit to one mid or split, we can ignore the // entire rattr-list if our mid is out of range lfs3_srid_t rid = lfs3_mrid(lfs3, mid); @@ -8225,31 +8258,30 @@ static int lfs3_mdir_commit___(lfs3_t *lfs3, lfs3_mdir_t *mdir_, // is still included && (lfs3_size_t)(rid + 1) <= (lfs3_size_t)end_rid) { - for (lfs3_size_t i = 0; i < rattr_count; i++) { + const lfs3_rattr_t *r = rattrs; + recurse:; + for (; *r; r = lfs3_rattr_next(r, &rid)) { // we just happen to never split in an mdir commit - LFS3_ASSERT(!(i > 0 && lfs3_rattr_isinsert(rattrs[i]))); + LFS3_ASSERT(!(r > rattrs && lfs3_rattr_isinsert(r))); // rattr lists can be chained, but only tail-recursively - if (rattrs[i].tag == LFS3_tag_RATTRS) { + if (lfs3_rattr_tag(r) == LFS3_tag_RATTRS) { // must be the last tag - LFS3_ASSERT(i == rattr_count-1); - const lfs3_rattr_t *rattrs_ = rattrs[i].u.etc; - lfs3_size_t rattr_count_ = rattrs[i].count; + LFS3_ASSERT(!*lfs3_rattr_next(r, NULL)); + const lfs3_rattr_t *rattrs_ + = (const lfs3_rattr_t*)lfs3_rattr_arg(r, 0); // switch to chained rattr-list - rattrs = rattrs_; - rattr_count = rattr_count_; - i = -1; - continue; + r = rattrs_; + goto recurse; // shrub tags append a set of attributes to an unrelated trunk // in our rbyd - } else if (rattrs[i].tag == LFS3_tag_SHRUBCOMMIT) { - const lfs3_shrubcommit_t *shrubcommit = rattrs[i].u.etc; - lfs3_bshrub_t *bshrub_ = shrubcommit->bshrub; - lfs3_srid_t rid_ = shrubcommit->rid; - const lfs3_rattr_t *rattrs_ = shrubcommit->rattrs; - lfs3_size_t rattr_count_ = shrubcommit->rattr_count; + } else if (lfs3_rattr_tag(r) == LFS3_tag_SHRUBCOMMIT) { + lfs3_bshrub_t *bshrub_ = (lfs3_bshrub_t*)lfs3_rattr_arg(r, 0); + lfs3_srid_t rid_ = lfs3_rattr_arg(r, 1); + const lfs3_rattr_t *rattrs_ + = (const lfs3_rattr_t*)lfs3_rattr_arg(r, 2); // reset shrub if it doesn't live in our block, this happens // when converting from a btree @@ -8260,23 +8292,23 @@ static int lfs3_mdir_commit___(lfs3_t *lfs3, lfs3_mdir_t *mdir_, } // commit to shrub - int err = lfs3_shrub_commit(lfs3, - &mdir_->r, &bshrub_->b_, - rid_, rattrs_, rattr_count_); + int err = lfs3_shrub_commit(lfs3, &mdir_->r, &bshrub_->b_, + rid_, rattrs_); if (err) { return err; } // push a new grm, this tag lets us push grms atomically when // creating new mids - } else if (rattrs[i].tag == LFS3_tag_GRMPUSH) { + } else if (lfs3_rattr_tag(r) == LFS3_tag_GRMPUSH) { // do nothing here, this is handled up in lfs3_mdir_commit // move tags copy over any tags associated with the source's rid // TODO can this be deduplicated with lfs3_mdir_compact___ more? // it _really_ wants to be deduplicated - } else if (rattrs[i].tag == LFS3_tag_MOVE) { - const lfs3_mdir_t *mdir__ = rattrs[i].u.etc; + } else if (lfs3_rattr_tag(r) == LFS3_tag_MOVE) { + const lfs3_mdir_t *mdir__ + = (const lfs3_mdir_t*)lfs3_rattr_arg(r, 0); // skip the name tag, this is always replaced by upper layers lfs3_stag_t tag = LFS3_TAG_STRUCT-1; @@ -8310,8 +8342,10 @@ static int lfs3_mdir_commit___(lfs3_t *lfs3, lfs3_mdir_t *mdir_, // write our new shrub tag err = lfs3_rbyd_appendrattr(lfs3, &mdir_->r, - rid - lfs3_smax(start_rid, 0), - LFS3_RATTR_SHRUB(LFS3_TAG_BSHRUB, 0, &shrub)); + rid - lfs3_smax(start_rid, 0), LFS3_RATTRS( + LFS3_RATTR(2, LFS3_TAG_BSHRUB, 0, + LFS3_FROM_SHRUB), + LFS3_RATTR_ARG(&shrub))); if (err) { return err; } @@ -8319,8 +8353,9 @@ static int lfs3_mdir_commit___(lfs3_t *lfs3, lfs3_mdir_t *mdir_, // append the rattr } else { int err = lfs3_rbyd_appendrattr(lfs3, &mdir_->r, - rid - lfs3_smax(start_rid, 0), - LFS3_RATTR_DATA(tag, 0, &data)); + rid - lfs3_smax(start_rid, 0), LFS3_RATTRS( + LFS3_RATTR(2, tag, 0, LFS3_FROM_CAT, 1), + LFS3_RATTR_ARG(&data))); if (err) { return err; } @@ -8349,9 +8384,10 @@ static int lfs3_mdir_commit___(lfs3_t *lfs3, lfs3_mdir_t *mdir_, } // custom attributes need to be reencoded into our tag format - } else if (rattrs[i].tag == LFS3_tag_ATTRS) { - const struct lfs3_attr *attrs_ = rattrs[i].u.etc; - lfs3_size_t attr_count_ = rattrs[i].count; + } else if (lfs3_rattr_tag(r) == LFS3_tag_ATTRS) { + const struct lfs3_attr *attrs_ + = (const struct lfs3_attr*)lfs3_rattr_arg(r, 0); + lfs3_size_t attr_count_ = lfs3_rattr_arg(r, 1); for (lfs3_size_t j = 0; j < attr_count_; j++) { // skip readonly attrs and lazy attrs @@ -8382,17 +8418,17 @@ static int lfs3_mdir_commit___(lfs3_t *lfs3, lfs3_mdir_t *mdir_, // append the custom attr int err = lfs3_rbyd_appendrattr(lfs3, &mdir_->r, - rid - lfs3_smax(start_rid, 0), - // removing or updating? - (lfs3_attr_isnoattr(&attrs_[j])) - ? LFS3_RATTR( - LFS3_tag_RM - | LFS3_TAG_ATTR(attrs_[j].type), 0) - : LFS3_RATTR_DATA( - LFS3_TAG_ATTR(attrs_[j].type), 0, - &LFS3_DATA_BUF( - attrs_[j].buffer, - lfs3_attr_size(&attrs_[j])))); + rid - lfs3_smax(start_rid, 0), LFS3_RATTRS( + // removing or updating? + (lfs3_attr_isnoattr(&attrs_[j])) + ? LFS3_RATTR(3, + LFS3_tag_RM + | LFS3_TAG_ATTR(attrs_[j].type), 0) + : LFS3_RATTR(3, + LFS3_TAG_ATTR(attrs_[j].type), 0, + LFS3_FROM_DATA), + LFS3_RATTR_ARG(lfs3_attr_size(&attrs_[j])), + LFS3_RATTR_ARG(attrs_[j].buffer))); if (err) { return err; } @@ -8400,20 +8436,15 @@ static int lfs3_mdir_commit___(lfs3_t *lfs3, lfs3_mdir_t *mdir_, // write out normal tags normally } else { - LFS3_ASSERT(lfs3_tag_suptype(rattrs[i].tag) - != LFS3_tag_INTERNAL - || lfs3_rattr_isnoop(rattrs[i])); + LFS3_ASSERT(!lfs3_rattr_isinternal(r)); int err = lfs3_rbyd_appendrattr(lfs3, &mdir_->r, rid - lfs3_smax(start_rid, 0), - rattrs[i]); + r); if (err) { return err; } } - - // adjust rid - rid = lfs3_rattr_nextrid(rattrs[i], rid); } } @@ -8452,8 +8483,10 @@ static int lfs3_mdir_commit___(lfs3_t *lfs3, lfs3_mdir_t *mdir_, ^ lfs3_crc32c_cube(lfs3->gcksum ^ cksum) ^ lfs3->gcksum_d; - int err = lfs3_rbyd_appendrattr_(lfs3, &mdir_->r, LFS3_RATTR_LE32( - LFS3_TAG_GCKSUMDELTA, 0, mdir_->gcksumdelta)); + int err = lfs3_rbyd_appendrattr_(lfs3, &mdir_->r, + LFS3_TAG_GCKSUMDELTA, 0, + LFS3_FROM_LE32, 0, LFS3_RATTRS( + LFS3_RATTR_ARG(mdir_->gcksumdelta))); if (err) { return err; } @@ -8654,8 +8687,11 @@ static int lfs3_mdir_compact___(lfs3_t *lfs3, } // write the new shrub tag + LFS3_ASSERT(weight == 0); err = lfs3_rbyd_appendcompactrattr(lfs3, &mdir_->r, - LFS3_RATTR_SHRUB(tag, weight, &shrub)); + LFS3_RATTRS( + LFS3_RATTR(2, tag, 0, LFS3_FROM_SHRUB), + LFS3_RATTR_ARG(&shrub))); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); return err; @@ -8664,7 +8700,10 @@ static int lfs3_mdir_compact___(lfs3_t *lfs3, } else { // write the tag int err = lfs3_rbyd_appendcompactrattr(lfs3, &mdir_->r, - LFS3_RATTR_DATA(tag, weight, &data)); + LFS3_RATTRS( + LFS3_RATTR(3, tag, -2, LFS3_FROM_CAT, 1), + LFS3_RATTR_WEIGHT(weight), + LFS3_RATTR_ARG(&data))); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); return err; @@ -8712,7 +8751,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, lfs3_mdir_t *mdir_, lfs3_mdir_t *mdir, lfs3_srid_t start_rid, lfs3_srid_t end_rid, lfs3_srid_t *split_rid_, - lfs3_smid_t mid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + lfs3_smid_t mid, const lfs3_rattr_t *rattrs) { // make a copy *mdir_ = *mdir; // mark our mdir as unerased in case we fail @@ -8729,7 +8768,7 @@ static int lfs3_mdir_commit__(lfs3_t *lfs3, // try to commit int err = lfs3_mdir_commit___(lfs3, mdir_, start_rid, end_rid, - mid, rattrs, rattr_count); + mid, rattrs); if (err) { if (err == LFS3_ERR_RANGE || err == LFS3_ERR_CORRUPT) { goto compact; @@ -8799,7 +8838,7 @@ compact:; // upper layers should make sure this can't fail by limiting the // maximum commit size err = lfs3_mdir_commit___(lfs3, mdir_, start_rid_, end_rid, - mid, rattrs, rattr_count); + mid, rattrs); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block @@ -8903,7 +8942,7 @@ static inline void lfs3_file_discardleaf(lfs3_file_t *file); // #ifndef LFS3_RDONLY static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, - const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + const lfs3_rattr_t *rattrs) { // non-mroot mdirs must have weight LFS3_ASSERT(mdir->mid <= -1 // note inlined mdirs are mroots with mid != -1 @@ -8918,10 +8957,10 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, // play out any rattrs that affect our grm _before_ committing to disk, // keep in mind we revert to on-disk gstate if we run into an error lfs3_smid_t mid_ = lfs3_smax(mdir->mid, -1); - for (lfs3_size_t i = 0; i < rattr_count; i++) { + for (const lfs3_rattr_t *r = rattrs; *r; r = lfs3_rattr_next(r, &mid_)) { // push a new grm, this tag lets us push grms atomically when // creating new mids - if (rattrs[i].tag == LFS3_tag_GRMPUSH) { + if (lfs3_rattr_tag(r) == LFS3_tag_GRMPUSH) { lfs3_grm_push(lfs3, mid_); // adjust pending grms? @@ -8930,16 +8969,14 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, if (lfs3_mbid(lfs3, lfs3->grm.queue[j]) == lfs3_mbid(lfs3, mid_) && lfs3->grm.queue[j] >= mid_) { // deleting a pending grm doesn't really make sense - LFS3_ASSERT(lfs3->grm.queue[j] >= mid_ - rattrs[i].weight); + LFS3_ASSERT(lfs3->grm.queue[j] + >= mid_ - lfs3_rattr_weight(r)); // adjust the grm - lfs3->grm.queue[j] += rattrs[i].weight; + lfs3->grm.queue[j] += lfs3_rattr_weight(r); } } } - - // adjust mid - mid_ = lfs3_rattr_nextrid(rattrs[i], mid_); } // flush gdeltas @@ -8965,7 +9002,7 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, lfs3_srid_t split_rid; int err = lfs3_mdir_commit__(lfs3, &mdir_[0], mdir, -2, -1, &split_rid, - mdir->mid, rattrs, rattr_count); + mdir->mid, rattrs); if (err && err != LFS3_ERR_RANGE && err != LFS3_ERR_NOENT) { goto failed; @@ -9030,7 +9067,7 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, err = lfs3_mdir_commit___(lfs3, &mdir_[i^l], ((i^l) == 0) ? 0 : split_rid, ((i^l) == 0) ? split_rid : -1, - mdir->mid, rattrs, rattr_count); + mdir->mid, rattrs); if (err && err != LFS3_ERR_NOENT) { LFS3_ASSERT(err != LFS3_ERR_RANGE); // bad prog? try another block @@ -9107,15 +9144,15 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, err = lfs3_mtree_commit(lfs3, &mtree_, 0, LFS3_RATTRS( - LFS3_RATTR_MPTR( - LFS3_TAG_MDIR, +(1 << lfs3->mbits), - mdir_[0].r.blocks), - LFS3_RATTR_DATA( - LFS3_TAG_MNAME, +(1 << lfs3->mbits), - &split_name), - LFS3_RATTR_MPTR( - LFS3_TAG_MDIR, 0, - mdir_[1].r.blocks))); + LFS3_RATTR(3, LFS3_TAG_MDIR, -2, LFS3_FROM_MPTR), + LFS3_RATTR_WEIGHT(+(1 << lfs3->mbits)), + LFS3_RATTR_ARG(mdir_[0].r.blocks), + LFS3_RATTR(3, LFS3_TAG_MNAME, -2, LFS3_FROM_CAT, 1), + LFS3_RATTR_WEIGHT(+(1 << lfs3->mbits)), + LFS3_RATTR_ARG(&split_name), + LFS3_RATTR(2, LFS3_TAG_MDIR, 0, LFS3_FROM_MPTR), + LFS3_RATTR_ARG(mdir_[1].r.blocks), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -9124,15 +9161,14 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, } else { err = lfs3_mtree_commit(lfs3, &mtree_, lfs3_mbid(lfs3, mdir->mid), LFS3_RATTRS( - LFS3_RATTR_MPTR( - LFS3_TAG_MDIR, 0, - mdir_[0].r.blocks), - LFS3_RATTR_DATA( - LFS3_TAG_MNAME, +(1 << lfs3->mbits), - &split_name), - LFS3_RATTR_MPTR( - LFS3_TAG_MDIR, 0, - mdir_[1].r.blocks))); + LFS3_RATTR(2, LFS3_TAG_MDIR, 0, LFS3_FROM_MPTR), + LFS3_RATTR_ARG(mdir_[0].r.blocks), + LFS3_RATTR(3, LFS3_TAG_MNAME, -2, LFS3_FROM_CAT, 1), + LFS3_RATTR_WEIGHT(+(1 << lfs3->mbits)), + LFS3_RATTR_ARG(&split_name), + LFS3_RATTR(2, LFS3_TAG_MDIR, 0, LFS3_FROM_MPTR), + LFS3_RATTR_ARG(mdir_[1].r.blocks), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -9161,8 +9197,9 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, // update our mtree err = lfs3_mtree_commit(lfs3, &mtree_, lfs3_mbid(lfs3, mdir->mid), LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM, -(1 << lfs3->mbits)))); + LFS3_RATTR(2, LFS3_tag_RM, -2), + LFS3_RATTR_WEIGHT(-(1 << lfs3->mbits)), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -9183,9 +9220,10 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, err = lfs3_mtree_commit(lfs3, &mtree_, 0, LFS3_RATTRS( - LFS3_RATTR_MPTR( - LFS3_TAG_MDIR, +(1 << lfs3->mbits), - mdir_[0].r.blocks))); + LFS3_RATTR(3, LFS3_TAG_MDIR, -2, LFS3_FROM_MPTR), + LFS3_RATTR_WEIGHT(+(1 << lfs3->mbits)), + LFS3_RATTR_ARG(mdir_[0].r.blocks), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -9194,9 +9232,9 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, } else { err = lfs3_mtree_commit(lfs3, &mtree_, lfs3_mbid(lfs3, mdir->mid), LFS3_RATTRS( - LFS3_RATTR_MPTR( - LFS3_TAG_MDIR, 0, - mdir_[0].r.blocks))); + LFS3_RATTR(2, LFS3_TAG_MDIR, 0, LFS3_FROM_MPTR), + LFS3_RATTR_ARG(mdir_[0].r.blocks), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -9242,13 +9280,15 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, err = lfs3_mdir_commit__(lfs3, &mroot_, &lfs3->mroot, -2, 0, NULL, -1, LFS3_RATTRS( - LFS3_RATTR_BTREE( - LFS3_tag_MASK8 | LFS3_TAG_MTREE, 0, - &mtree_), + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_MTREE, 0, + LFS3_FROM_BTREE), + LFS3_RATTR_ARG(&mtree_), // were we committing to the mroot? include any -1 rattrs (mdir->mid <= -1) - ? LFS3_RATTR_RATTRS(rattrs, rattr_count) - : LFS3_RATTR_NOOP())); + ? LFS3_RATTR(2, LFS3_tag_RATTRS, 0) + : LFS3_RATTR(2, LFS3_TAG_NULL, 0), + LFS3_RATTR_ARG(rattrs), + LFS3_RATTR_NULL)); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); goto failed; @@ -9291,9 +9331,9 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, err = lfs3_mdir_commit__(lfs3, &mrootparent_, &mrootparent, -2, -1, NULL, -1, LFS3_RATTRS( - LFS3_RATTR_MPTR( - LFS3_TAG_MROOT, 0, - mrootchild_.r.blocks))); + LFS3_RATTR(2, LFS3_TAG_MROOT, 0, LFS3_FROM_MPTR), + LFS3_RATTR_ARG(mrootchild_.r.blocks), + LFS3_RATTR_NULL)); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); LFS3_ASSERT(err != LFS3_ERR_NOENT); @@ -9337,12 +9377,11 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, err = lfs3_mdir_commit___(lfs3, &mrootanchor_, -2, -1, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_MAGIC, 0, - "littlefs", 8), - LFS3_RATTR_MPTR( - LFS3_TAG_MROOT, 0, - mrootchild_.r.blocks))); + LFS3_RATTR(2, LFS3_TAG_MAGIC, 0, LFS3_FROM_BUF, 8), + LFS3_RATTR_ARG("littlefs"), + LFS3_RATTR(2, LFS3_TAG_MROOT, 0, LFS3_FROM_MPTR), + LFS3_RATTR_ARG(mrootchild_.r.blocks), + LFS3_RATTR_NULL)); if (err) { LFS3_ASSERT(err != LFS3_ERR_RANGE); LFS3_ASSERT(err != LFS3_ERR_NOENT); @@ -9370,27 +9409,24 @@ static int lfs3_mdir_commit_(lfs3_t *lfs3, lfs3_mdir_t *mdir, // play out any rattrs that affect internal state mid_ = lfs3_smax(mdir->mid, -1); - for (lfs3_size_t i = 0; i < rattr_count; i++) { + for (const lfs3_rattr_t *r = rattrs; *r; r = lfs3_rattr_next(r, &mid_)) { // adjust any opened mdirs for (lfs3_handle_t *h = lfs3->handles; h; h = h->next) { // adjust opened mdirs? if (lfs3_mdir_cmp(&h->mdir, mdir) == 0 && h->mdir.mid >= mid_) { // removed? - if (h->mdir.mid < mid_ - rattrs[i].weight) { + if (h->mdir.mid < mid_ - lfs3_rattr_weight(r)) { // opened files should turn into stickynote, not // have their mid removed LFS3_ASSERT(lfs3_o_type(h->flags) != LFS3_TYPE_REG); h->flags |= LFS3_o_ZOMBIE; h->mdir.mid = mid_; } else { - h->mdir.mid += rattrs[i].weight; + h->mdir.mid += lfs3_rattr_weight(r); } } } - - // adjust mid - mid_ = lfs3_rattr_nextrid(rattrs[i], mid_); } // update internal mdir state @@ -9496,7 +9532,7 @@ failed:; // #ifndef LFS3_RDONLY static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir, - const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { + const lfs3_rattr_t *rattrs) { // checkpoint the allocator int err = lfs3_alloc_ckpoint(lfs3); if (err) { @@ -9506,7 +9542,7 @@ static int lfs3_mdir_commit(lfs3_t *lfs3, lfs3_mdir_t *mdir, } // commit to mdir - return lfs3_mdir_commit_(lfs3, mdir, rattrs, rattr_count); + return lfs3_mdir_commit_(lfs3, mdir, rattrs); } #endif @@ -9515,7 +9551,7 @@ static int lfs3_mdir_compact_(lfs3_t *lfs3, lfs3_mdir_t *mdir) { // the easiest way to do this is to just mark mdir as unerased // and call lfs3_mdir_commit lfs3_mdir_claim(mdir); - return lfs3_mdir_commit_(lfs3, mdir, NULL, 0); + return lfs3_mdir_commit_(lfs3, mdir, LFS3_RATTRS(LFS3_RATTR_NULL)); } #endif @@ -9524,7 +9560,7 @@ static int lfs3_mdir_compact(lfs3_t *lfs3, lfs3_mdir_t *mdir) { // the easiest way to do this is to just mark mdir as unerased // and call lfs3_mdir_commit lfs3_mdir_claim(mdir); - return lfs3_mdir_commit(lfs3, mdir, NULL, 0); + return lfs3_mdir_commit(lfs3, mdir, LFS3_RATTRS(LFS3_RATTR_NULL)); } #endif @@ -10488,8 +10524,8 @@ static lfs3_stag_t lfs3_gbmap_lookupnext(lfs3_t *lfs3, lfs3_btree_t *gbmap, #if !defined(LFS3_RDONLY) && defined(LFS3_GBMAP) static int lfs3_gbmap_commit(lfs3_t *lfs3, lfs3_btree_t *gbmap, - lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { - return lfs3_btree_commit(lfs3, gbmap, bid, rattrs, rattr_count); + lfs3_bid_t bid, const lfs3_rattr_t *rattrs) { + return lfs3_btree_commit(lfs3, gbmap, bid, rattrs); } #endif @@ -10544,7 +10580,9 @@ static int lfs3_gbmap_mark_(lfs3_t *lfs3, lfs3_btree_t *gbmap, if (r_tag == tag) { // delete to prepare merge int err = lfs3_gbmap_commit(lfs3, &gbmap_, r_bid, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -r_weight))); + LFS3_RATTR(2, LFS3_tag_RM, -2), + LFS3_RATTR_WEIGHT(-r_weight), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -10573,7 +10611,9 @@ static int lfs3_gbmap_mark_(lfs3_t *lfs3, lfs3_btree_t *gbmap, if (l_tag == tag) { // delete to prepare merge int err = lfs3_gbmap_commit(lfs3, &gbmap_, l_bid, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -l_weight))); + LFS3_RATTR(2, LFS3_tag_RM, -2), + LFS3_RATTR_WEIGHT(-l_weight), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -10595,12 +10635,16 @@ static int lfs3_gbmap_mark_(lfs3_t *lfs3, lfs3_btree_t *gbmap, // works int err = lfs3_gbmap_commit(lfs3, &gbmap_, bid__, LFS3_RATTRS( (bid__-(weight__-1) < block-(weight-1)) - ? LFS3_RATTR(LFS3_tag_GROW, -((bid__+1) - (block-(weight-1)))) - : LFS3_RATTR(LFS3_tag_RM, -((bid__+1) - (block-(weight-1)))), - LFS3_RATTR(tag, +weight_), + ? LFS3_RATTR(2, LFS3_tag_GROW, -2) + : LFS3_RATTR(2, LFS3_tag_RM, -2), + LFS3_RATTR_WEIGHT(-((bid__+1) - (block-(weight-1)))), + LFS3_RATTR(2, tag, -2), + LFS3_RATTR_WEIGHT(+weight_), (bid__ > block) - ? LFS3_RATTR(tag__, +(bid__ - block)) - : LFS3_RATTR_NOOP())); + ? LFS3_RATTR(2, tag__, -2) + : LFS3_RATTR(2, LFS3_TAG_NULL, 0), + LFS3_RATTR_WEIGHT(+(bid__ - block)), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -11251,10 +11295,10 @@ int lfs3_mkdir(lfs3_t *lfs3, const char *path) { // commit our bookmark and a grm to self-remove in case of powerloss err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_BOOKMARK, +1, did_, NULL, 0), - LFS3_RATTR( - LFS3_tag_GRMPUSH, 0))); + LFS3_RATTR(2, LFS3_TAG_BOOKMARK, +1, LFS3_FROM_LEB128), + LFS3_RATTR_ARG(did_), + LFS3_RATTR(1, LFS3_tag_GRMPUSH, 0), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -11275,12 +11319,15 @@ int lfs3_mkdir(lfs3_t *lfs3, const char *path) { // process lfs3_grm_pop(lfs3); err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_tag_MASK12 | LFS3_TAG_DIR, - (tag == LFS3_ERR_NOENT) ? +1 : 0, - did, name, name_len), - LFS3_RATTR_LEB128( - LFS3_TAG_DID, 0, did_))); + LFS3_RATTR(4, LFS3_tag_MASK12 | LFS3_TAG_DIR, + (tag == LFS3_ERR_NOENT) ? +1 : 0, + LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(name_len), + LFS3_RATTR(2, LFS3_TAG_DID, 0, LFS3_FROM_LEB128), + LFS3_RATTR_ARG(did_), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -11425,11 +11472,13 @@ int lfs3_remove(lfs3_t *lfs3, const char *path) { // we use a create+delete here to also clear any rattrs // and trim the entry size (zombie) - ? LFS3_RATTR_NAME( - LFS3_tag_MASK12 | LFS3_TAG_STICKYNOTE, 0, - did, path, lfs3_path_namelen(path)) - : LFS3_RATTR( - LFS3_tag_RM, -1))); + ? LFS3_RATTR(4, LFS3_tag_MASK12 | LFS3_TAG_STICKYNOTE, 0, + LFS3_FROM_NAME) + : LFS3_RATTR(4, LFS3_tag_RM, -1), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -11599,11 +11648,15 @@ int lfs3_rename(lfs3_t *lfs3, const char *old_path, const char *new_path) { // rename our entry, copying all tags associated with the old rid to the // new rid, while also marking the old rid for removal err = lfs3_mdir_commit(lfs3, &new_mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_tag_MASK12 | old_tag, + LFS3_RATTR(4, LFS3_tag_MASK12 | old_tag, (new_tag == LFS3_ERR_NOENT) ? +1 : 0, - new_did, new_path, lfs3_path_namelen(new_path)), - LFS3_RATTR_MOVE(&old_mdir))); + LFS3_FROM_NAME), + LFS3_RATTR_ARG(new_did), + LFS3_RATTR_ARG(new_path), + LFS3_RATTR_ARG(lfs3_path_namelen(new_path)), + LFS3_RATTR(2, LFS3_tag_MOVE, 0), + LFS3_RATTR_ARG(&old_mdir), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -12032,10 +12085,10 @@ int lfs3_setattr(lfs3_t *lfs3, const char *path, uint8_t type, // commit our attr err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_DATA( - LFS3_TAG_ATTR(type), 0, - &LFS3_DATA_BUF( - buffer, size)))); + LFS3_RATTR(3, LFS3_TAG_ATTR(type), 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(size), + LFS3_RATTR_ARG(buffer), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -12085,8 +12138,8 @@ int lfs3_removeattr(lfs3_t *lfs3, const char *path, uint8_t type) { // commit our removal err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(type), 0))); + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(type), 0), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -12234,7 +12287,7 @@ static int lfs3_file_fetch(lfs3_t *lfs3, lfs3_file_t *file, uint32_t flags) { static void lfs3_file_close_(lfs3_t *lfs3, lfs3_file_t *file); #ifndef LFS3_RDONLY static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file, - const lfs3_name_t *name); + const lfs3_rattr_t *rname); #endif int lfs3_file_opencfg_(lfs3_t *lfs3, lfs3_file_t *file, @@ -12354,10 +12407,11 @@ int lfs3_file_opencfg_(lfs3_t *lfs3, lfs3_file_t *file, // we need to mark as unsync for sync to do anything file->b.h.flags |= LFS3_o_UNSYNC; - err = lfs3_file_sync_(lfs3, file, &(lfs3_name_t){ - .did=did, - .name=path, - .name_len=lfs3_path_namelen(path)}); + err = lfs3_file_sync_(lfs3, file, LFS3_RATTRS( + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)))); if (err) { goto failed; } @@ -12366,9 +12420,11 @@ int lfs3_file_opencfg_(lfs3_t *lfs3, lfs3_file_t *file, // create a stickynote entry if we don't have one, this // reserves the mid until first sync err = lfs3_mdir_commit(lfs3, &file->b.h.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_STICKYNOTE, +1, - did, path, lfs3_path_namelen(path)))); + LFS3_RATTR(4, LFS3_TAG_STICKYNOTE, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -12713,9 +12769,8 @@ lfs3_ssize_t lfs3_file_read(lfs3_t *lfs3, lfs3_file_t *file, #ifndef LFS3_RDONLY static int lfs3_file_commit(lfs3_t *lfs3, lfs3_file_t *file, - lfs3_bid_t bid, const lfs3_rattr_t *rattrs, lfs3_size_t rattr_count) { - return lfs3_bshrub_commit(lfs3, &file->b, - bid, rattrs, rattr_count); + lfs3_bid_t bid, const lfs3_rattr_t *rattrs) { + return lfs3_bshrub_commit(lfs3, &file->b, bid, rattrs); } #endif @@ -12770,10 +12825,10 @@ static int lfs3_file_graft_(lfs3_t *lfs3, lfs3_file_t *file, // try to merge commits where possible lfs3_bid_t bid = file->b.b.r.weight; - lfs3_rattr_t rattrs[3]; - lfs3_size_t rattr_count = 0; - lfs3_bptr_t l; - lfs3_bptr_t r; + lfs3_rattr_t rattrs[10]; + lfs3_rattr_t *r = rattrs; + lfs3_bptr_t l_bptr; + lfs3_bptr_t r_bptr; int err; // need a hole? @@ -12781,19 +12836,19 @@ static int lfs3_file_graft_(lfs3_t *lfs3, lfs3_file_t *file, // can we coalesce? if (file->b.b.r.weight > 0) { bid = lfs3_min(bid, file->b.b.r.weight-1); - rattrs[rattr_count++] = LFS3_RATTR( - LFS3_tag_GROW, +(pos - file->b.b.r.weight)); + *r++ = LFS3_RATTR(2, LFS3_tag_GROW, -2); + *r++ = LFS3_RATTR_WEIGHT(+(pos - file->b.b.r.weight)); // new hole } else { bid = lfs3_min(bid, file->b.b.r.weight); - rattrs[rattr_count++] = LFS3_RATTR( - LFS3_TAG_DATA, +(pos - file->b.b.r.weight)); + *r++ = LFS3_RATTR(2, LFS3_TAG_DATA, -2); + *r++ = LFS3_RATTR_WEIGHT(+(pos - file->b.b.r.weight)); } } // try to carve any existing data - lfs3_rattr_t r_rattr_ = {.tag=0}; + lfs3_off_t r_weight = 0; while (pos < file->b.b.r.weight) { lfs3_bid_t weight_; lfs3_bptr_t bptr_; @@ -12805,87 +12860,89 @@ static int lfs3_file_graft_(lfs3_t *lfs3, lfs3_file_t *file, } // note, an entry can be both a left and right sibling - l = bptr_; - lfs3_bptr_slice(&l, + l_bptr = bptr_; + lfs3_bptr_slice(&l_bptr, -1, pos - (bid-(weight_-1))); - r = bptr_; - lfs3_bptr_slice(&r, + r_bptr = bptr_; + lfs3_bptr_slice(&r_bptr, pos+weight - (bid-(weight_-1)), -1); // found left sibling? if (bid-(weight_-1) < pos) { // can we get away with a grow attribute? - if (lfs3_bptr_size(&bptr_) == lfs3_bptr_size(&l)) { - rattrs[rattr_count++] = LFS3_RATTR( - LFS3_tag_GROW, -(bid+1 - pos)); + if (lfs3_bptr_size(&bptr_) == lfs3_bptr_size(&l_bptr)) { + *r++ = LFS3_RATTR(2, LFS3_tag_GROW, -2); + *r++ = LFS3_RATTR_WEIGHT(-(bid+1 - pos)); // carve fragment? } else if (!lfs3_bptr_isbptr(&bptr_) // carve bptr into fragment? - || (lfs3_bptr_size(&l) <= lfs3->cfg->fragment_size - && lfs3_bptr_size(&l) + || (lfs3_bptr_size(&l_bptr) <= lfs3->cfg->fragment_size + && lfs3_bptr_size(&l_bptr) < lfs3_max(lfs3->cfg->crystal_thresh, 1))) { - rattrs[rattr_count++] = LFS3_RATTR_DATA( - LFS3_tag_GROW | LFS3_tag_MASK8 | LFS3_TAG_DATA, - -(bid+1 - pos), - &l.d); + *r++ = LFS3_RATTR(3, + LFS3_tag_GROW | LFS3_tag_MASK8 | LFS3_TAG_DATA, -2, + LFS3_FROM_CAT, 1); + *r++ = LFS3_RATTR_WEIGHT(-(bid+1 - pos)); + *r++ = LFS3_RATTR_ARG(&l_bptr); // carve bptr? } else { - rattrs[rattr_count++] = LFS3_RATTR_BPTR( - LFS3_tag_GROW | LFS3_tag_MASK8 | LFS3_TAG_BLOCK, - -(bid+1 - pos), - &l); + *r++ = LFS3_RATTR(3, + LFS3_tag_GROW | LFS3_tag_MASK8 | LFS3_TAG_BLOCK, -2, + LFS3_FROM_BPTR, LFS3_BPTR_DSIZE); + *r++ = LFS3_RATTR_WEIGHT(-(bid+1 - pos)); + *r++ = LFS3_RATTR_ARG(&l_bptr); } // completely overwriting this entry? } else { - rattrs[rattr_count++] = LFS3_RATTR( - LFS3_tag_RM, -weight_); + *r++ = LFS3_RATTR(2, LFS3_tag_RM, -2); + *r++ = LFS3_RATTR_WEIGHT(-weight_); } // spans more than one entry? we can't do everything in one // commit because it might span more than one btree leaf, so // commit what we have and move on to next entry if (pos+weight > bid+1) { - LFS3_ASSERT(lfs3_bptr_size(&r) == 0); - LFS3_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfs3_rattr_t)); + LFS3_ASSERT(lfs3_bptr_size(&r_bptr) == 0); - err = lfs3_file_commit(lfs3, file, bid, - rattrs, rattr_count); + *r++ = LFS3_RATTR_NULL; + LFS3_ASSERT((lfs3_size_t)(r-rattrs) + <= sizeof(rattrs)/sizeof(lfs3_rattr_t)); + + err = lfs3_file_commit(lfs3, file, bid, rattrs); if (err) { goto failed; } delta += lfs3_min(weight, bid+1 - pos); weight -= lfs3_min(weight, bid+1 - pos); - rattr_count = 0; + r = rattrs; continue; } // found right sibling? if (pos+weight < bid+1) { // can we coalesce a hole? - if (lfs3_bptr_size(&r) == 0) { + if (lfs3_bptr_size(&r_bptr) == 0) { delta += bid+1 - (pos+weight); // carve fragment? } else if (!lfs3_bptr_isbptr(&bptr_) // carve bptr into fragment? - || (lfs3_bptr_size(&r) <= lfs3->cfg->fragment_size - && lfs3_bptr_size(&r) + || (lfs3_bptr_size(&r_bptr) <= lfs3->cfg->fragment_size + && lfs3_bptr_size(&r_bptr) < lfs3_max(lfs3->cfg->crystal_thresh, 1))) { - r_rattr_ = LFS3_RATTR_DATA( - LFS3_TAG_DATA, bid+1 - (pos+weight), - &r.d); + r_weight = bid+1 - (pos+weight); + r_bptr.d.size &= ~LFS3_DATA_ISBPTR; // carve bptr? } else { - r_rattr_ = LFS3_RATTR_BPTR( - LFS3_TAG_BLOCK, bid+1 - (pos+weight), - &r); + r_weight = bid+1 - (pos+weight); + LFS3_ASSERT(lfs3_bptr_isbptr(&r_bptr)); } } @@ -12904,42 +12961,57 @@ static int lfs3_file_graft_(lfs3_t *lfs3, lfs3_file_t *file, // can we coalesce a hole? if (dsize == 0 && pos > 0) { bid = lfs3_min(bid, file->b.b.r.weight-1); - rattrs[rattr_count++] = LFS3_RATTR( - LFS3_tag_GROW, +(weight + delta)); + *r++ = LFS3_RATTR(2, LFS3_tag_GROW, -2); + *r++ = LFS3_RATTR_WEIGHT(+(weight + delta)); // need a new hole? } else if (dsize == 0) { bid = lfs3_min(bid, file->b.b.r.weight); - rattrs[rattr_count++] = LFS3_RATTR( - LFS3_TAG_DATA, +(weight + delta)); + *r++ = LFS3_RATTR(2, LFS3_TAG_DATA, -2); + *r++ = LFS3_RATTR_WEIGHT(+(weight + delta)); // append a new fragment? } else if (!lfs3_graft_isbptr(graft_count)) { bid = lfs3_min(bid, file->b.b.r.weight); - rattrs[rattr_count++] = LFS3_RATTR_CAT_( - LFS3_TAG_DATA, +(weight + delta), - graft, graft_count); + *r++ = LFS3_RATTR(3, LFS3_TAG_DATA, -2, + LFS3_FROM_CAT, graft_count); + *r++ = LFS3_RATTR_WEIGHT(+(weight + delta)); + *r++ = LFS3_RATTR_ARG(graft); // append a new bptr? } else { bid = lfs3_min(bid, file->b.b.r.weight); - rattrs[rattr_count++] = LFS3_RATTR_BPTR( - LFS3_TAG_BLOCK, +(weight + delta), - (const lfs3_bptr_t*)graft); + *r++ = LFS3_RATTR(3, LFS3_TAG_BLOCK, -2, + LFS3_FROM_BPTR, LFS3_BPTR_DSIZE); + *r++ = LFS3_RATTR_WEIGHT(+(weight + delta)); + *r++ = LFS3_RATTR_ARG(graft); } } // and don't forget the right sibling - if (r_rattr_.tag) { - rattrs[rattr_count++] = r_rattr_; + if (r_weight > 0) { + if (!lfs3_bptr_isbptr(&r_bptr)) { + *r++ = LFS3_RATTR(3, + LFS3_TAG_DATA, -2, + LFS3_FROM_CAT, 1); + *r++ = LFS3_RATTR_WEIGHT(+r_weight); + *r++ = LFS3_RATTR_ARG(&r_bptr); + } else { + *r++ = LFS3_RATTR(3, + LFS3_TAG_BLOCK, -2, + LFS3_FROM_BPTR, LFS3_BPTR_DSIZE); + *r++ = LFS3_RATTR_WEIGHT(+r_weight); + *r++ = LFS3_RATTR_ARG(&r_bptr); + } } // commit pending rattrs - if (rattr_count > 0) { - LFS3_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfs3_rattr_t)); + if (r > rattrs) { + *r++ = LFS3_RATTR_NULL; + LFS3_ASSERT((lfs3_size_t)(r-rattrs) + <= sizeof(rattrs)/sizeof(lfs3_rattr_t)); - err = lfs3_file_commit(lfs3, file, bid, - rattrs, rattr_count); + err = lfs3_file_commit(lfs3, file, bid, rattrs); if (err) { goto failed; } @@ -13923,15 +13995,10 @@ failed:; // this LFS3_NOINLINE is to force lfs3_file_sync_ off the stack hot-path LFS3_NOINLINE static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file, - const lfs3_name_t *name) { + const lfs3_rattr_t *rname) { // build a commit of any pending file metadata - lfs3_rattr_t rattrs[4]; - lfs3_size_t rattr_count = 0; - lfs3_data_t name_data; - lfs3_rattr_t shrub_rattrs[1]; - lfs3_size_t shrub_rattr_count = 0; - lfs3_data_t file_data; - lfs3_shrubcommit_t shrub_commit; + lfs3_rattr_t rattrs[14]; + lfs3_rattr_t shrub_rattrs[5]; // uncreated files must be unsync LFS3_ASSERT(!lfs3_o_isuncreat(file->b.h.flags) @@ -13944,16 +14011,19 @@ static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file, LFS3_ASSERT(!lfs3_o_isungraft(file->b.h.flags)); // pending metadata changes? + lfs3_rattr_t *r = rattrs; if (lfs3_o_isunsync(file->b.h.flags)) { // explicit name? - if (name) { - rattrs[rattr_count++] = LFS3_RATTR_NAME_( - LFS3_TAG_REG, +1, - name); + if (rname) { + LFS3_ASSERT(lfs3_rattr_len(rname) <= 4); + for (lfs3_size_t i = 0; i < lfs3_rattr_len(rname); i++) { + *r++ = rname[i]; + } // not created yet? need to convert to normal file } else if (lfs3_o_isuncreat(file->b.h.flags)) { // convert stickynote -> reg file + lfs3_data_t name_data; lfs3_stag_t name_tag = lfs3_rbyd_lookup(lfs3, &file->b.h.mdir.r, lfs3_mrid(lfs3, file->b.h.mdir.mid), LFS3_TAG_STICKYNOTE, &name_data); @@ -13963,9 +14033,11 @@ static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file, return name_tag; } - rattrs[rattr_count++] = LFS3_RATTR_DATA( - LFS3_tag_MASK8 | LFS3_TAG_REG, 0, - &name_data); + *r++ = LFS3_RATTR(4, LFS3_tag_MASK8 | LFS3_TAG_REG, 0, + LFS3_FROM_DATA); + *r++ = LFS3_RATTR_ARG(name_data.size); + *r++ = LFS3_RATTR_ARG(name_data.u.disk.block); + *r++ = LFS3_RATTR_ARG(name_data.u.disk.off); } // pending small file flush? @@ -13979,20 +14051,19 @@ static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file, // build a small shrub commit if (file->cache.size > 0) { - file_data = LFS3_DATA_BUF( - file->cache.buffer, - file->cache.size); - shrub_rattrs[shrub_rattr_count++] = LFS3_RATTR_DATA( - LFS3_TAG_DATA, +file->cache.size, - &file_data); - - LFS3_ASSERT(shrub_rattr_count + lfs3_rattr_t *shrub_r = shrub_rattrs; + *shrub_r++ = LFS3_RATTR(4, LFS3_TAG_DATA, -2, LFS3_FROM_DATA); + *shrub_r++ = LFS3_RATTR_WEIGHT(+file->cache.size); + *shrub_r++ = LFS3_RATTR_ARG(file->cache.size); + *shrub_r++ = LFS3_RATTR_ARG(file->cache.buffer); + *shrub_r++ = LFS3_RATTR_NULL; + LFS3_ASSERT((lfs3_size_t)(shrub_r-shrub_rattrs) <= sizeof(shrub_rattrs)/sizeof(lfs3_rattr_t)); - shrub_commit.bshrub = &file->b; - shrub_commit.rid = 0; - shrub_commit.rattrs = shrub_rattrs; - shrub_commit.rattr_count = shrub_rattr_count; - rattrs[rattr_count++] = LFS3_RATTR_SHRUBCOMMIT(&shrub_commit); + + *r++ = LFS3_RATTR(4, LFS3_tag_SHRUBCOMMIT, 0); + *r++ = LFS3_RATTR_ARG(&file->b); + *r++ = LFS3_RATTR_ARG(0); + *r++ = LFS3_RATTR_ARG(shrub_rattrs); } } @@ -14011,20 +14082,22 @@ static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file, // no bshrub/btree? if (lfs3_file_size_(file) == 0) { - rattrs[rattr_count++] = LFS3_RATTR( + *r++ = LFS3_RATTR(1, LFS3_tag_RM | LFS3_tag_MASK8 | LFS3_TAG_STRUCT, 0); // bshrub? } else if (lfs3_bshrub_isbshrub(&file->b) || lfs3_o_isunflush(file->b.h.flags)) { - rattrs[rattr_count++] = LFS3_RATTR_SHRUB( + *r++ = LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_BSHRUB, 0, - // note we use the staged trunk here - &file->b.b_); + LFS3_FROM_SHRUB); + // note we use the staged trunk here + *r++ = LFS3_RATTR_ARG(&file->b.b_); // btree? } else if (lfs3_bshrub_isbtree(&file->b)) { - rattrs[rattr_count++] = LFS3_RATTR_BTREE( + *r++ = LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_BTREE, 0, - &file->b.b); + LFS3_FROM_BTREE); + *r++ = LFS3_RATTR_ARG(&file->b.b); } else { LFS3_UNREACHABLE(); } @@ -14068,18 +14141,20 @@ static int lfs3_file_sync_(lfs3_t *lfs3, lfs3_file_t *file, } if (attrs) { // need to append custom attributes - rattrs[rattr_count++] = LFS3_RATTR_ATTRS( - file->cfg->attrs, file->cfg->attr_count); + *r++ = LFS3_RATTR(3, LFS3_tag_ATTRS, 0); + *r++ = LFS3_RATTR_ARG(file->cfg->attrs); + *r++ = LFS3_RATTR_ARG(file->cfg->attr_count); } // pending metadata? looks like we need to write to disk - if (rattr_count > 0) { + if (r > rattrs) { // make sure we don't overflow our rattr buffer - LFS3_ASSERT(rattr_count <= sizeof(rattrs)/sizeof(lfs3_rattr_t)); + *r++ = LFS3_RATTR_NULL; + LFS3_ASSERT((lfs3_size_t)(r-rattrs) + <= sizeof(rattrs)/sizeof(lfs3_rattr_t)); // and commit! - int err = lfs3_mdir_commit(lfs3, &file->b.h.mdir, - rattrs, rattr_count); + int err = lfs3_mdir_commit(lfs3, &file->b.h.mdir, rattrs); if (err) { return err; } @@ -15738,11 +15813,14 @@ static int lfs3_formatgbmap(lfs3_t *lfs3) { err = lfs3_rbyd_commit(lfs3, &lfs3->gbmap.b.r, 0, LFS3_RATTRS( // blocks 0..3 - in-use - LFS3_RATTR(LFS3_TAG_BMINUSE, +3), + LFS3_RATTR(2, LFS3_TAG_BMINUSE, -2), + LFS3_RATTR_WEIGHT(+3), // blocks 3..block_count - free (lfs3->block_count > 3) - ? LFS3_RATTR(LFS3_TAG_BMFREE, +(lfs3->block_count - 3)) - : LFS3_RATTR_NOOP())); + ? LFS3_RATTR(2, LFS3_TAG_BMFREE, -2) + : LFS3_RATTR(2, LFS3_TAG_NULL, 0), + LFS3_RATTR_WEIGHT(+(lfs3->block_count - 3)), + LFS3_RATTR_NULL)); if (err) { return err; } @@ -15791,64 +15869,65 @@ static int lfs3_formatinited(lfs3_t *lfs3) { return err; } - // include on-disk gbmap? - // - // TODO this is not the greatest solution, but at least it's - // warning free... alternatives? switch to builder pattern? - #ifdef LFS3_GBMAP - #define LFS3_RATTR_IFDEF_GBMAP \ - (lfs3_f_isgbmap(lfs3->flags)) \ - ? LFS3_RATTR_DATA(LFS3_TAG_GBMAPDELTA, 0, \ - (&((struct {lfs3_data_t d;}){ \ - lfs3_data_fromgbmap(&lfs3->gbmap, \ - lfs3->gbmap_d)}).d)) \ - : LFS3_RATTR_NOOP(), - #else - #define LFS3_RATTR_IFDEF_GBMAP - #endif - // our initial superblock contains a couple things: // - our magic string, "littlefs" // - any format-time configuration - // - the root's bookmark tag, which reserves did = 0 for the root - err = lfs3_rbyd_appendrattrs(lfs3, &rbyd, -1, -1, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_MAGIC, 0, - "littlefs", 8), - LFS3_RATTR_BUF( - LFS3_TAG_VERSION, 0, - ((const uint8_t[2]){ - LFS3_DISK_VERSION_MAJOR, - LFS3_DISK_VERSION_MINOR}), 2), - LFS3_RATTR_LE32( - LFS3_TAG_RCOMPAT, 0, - lfs3_rcompat(lfs3)), - LFS3_RATTR_LE32( - LFS3_TAG_WCOMPAT, 0, - lfs3_wcompat(lfs3)), - LFS3_RATTR_GEOMETRY( - LFS3_TAG_GEOMETRY, 0, - (&(lfs3_geometry_t){ - lfs3->cfg->block_size, - lfs3->cfg->block_count})), - LFS3_RATTR_LLEB128( - LFS3_TAG_NAMELIMIT, 0, - lfs3->name_limit), - LFS3_RATTR_LEB128( - LFS3_TAG_FILELIMIT, 0, - lfs3->file_limit), - LFS3_RATTR_IFDEF_GBMAP - LFS3_RATTR_NAME( - LFS3_TAG_BOOKMARK, +1, - 0, NULL, 0))); + // - the root's bookmark tag, which reserves did=0 for the root + // + lfs3_rattr_t rattrs[LFS3_IFDEF_GBMAP(19, 17)]; + const uint8_t version[2] = { + LFS3_DISK_VERSION_MAJOR, + LFS3_DISK_VERSION_MINOR, + }; + const lfs3_geometry_t geometry = { + .block_size=lfs3->cfg->block_size, + .block_count=lfs3->cfg->block_count, + }; + + // magic + various config + lfs3_rattr_t *r = rattrs; + *r++ = LFS3_RATTR(2, LFS3_TAG_MAGIC, 0, LFS3_FROM_BUF, 8); + *r++ = LFS3_RATTR_ARG("littlefs"); + *r++ = LFS3_RATTR(2, LFS3_TAG_VERSION, 0, LFS3_FROM_BUF, 2); + *r++ = LFS3_RATTR_ARG(version); + *r++ = LFS3_RATTR(2, LFS3_TAG_RCOMPAT, 0, LFS3_FROM_LE32); + *r++ = LFS3_RATTR_ARG(lfs3_rcompat(lfs3)); + *r++ = LFS3_RATTR(2, LFS3_TAG_WCOMPAT, 0, LFS3_FROM_LE32); + *r++ = LFS3_RATTR_ARG(lfs3_wcompat(lfs3)); + *r++ = LFS3_RATTR(2, LFS3_TAG_GEOMETRY, 0, LFS3_FROM_GEOMETRY); + *r++ = LFS3_RATTR_ARG(&geometry); + *r++ = LFS3_RATTR(2, LFS3_TAG_NAMELIMIT, 0, LFS3_FROM_LEB128); + *r++ = LFS3_RATTR_ARG(lfs3->name_limit); + *r++ = LFS3_RATTR(2, LFS3_TAG_FILELIMIT, 0, LFS3_FROM_LEB128); + *r++ = LFS3_RATTR_ARG(lfs3->file_limit); + // include on-disk gbmap? + #ifdef LFS3_GBMAP + if (lfs3_f_isgbmap(lfs3->flags)) { + lfs3_data_fromgbmap(&lfs3->gbmap, lfs3->gbmap_d); + *r++ = LFS3_RATTR(2, LFS3_TAG_GBMAPDELTA, 0, + LFS3_FROM_BUF, + lfs3_memlen(lfs3->gbmap_d, LFS3_GBMAP_DSIZE)); + *r++ = LFS3_RATTR_ARG(&lfs3->gbmap_d); + } + #endif + // root did=0 + *r++ = LFS3_RATTR(2, LFS3_TAG_BOOKMARK, +1, LFS3_FROM_LEB128); + *r++ = LFS3_RATTR_ARG(0); + *r++ = LFS3_RATTR_NULL; + LFS3_ASSERT((lfs3_size_t)(r-rattrs) + <= sizeof(rattrs)/sizeof(lfs3_rattr_t)); + + err = lfs3_rbyd_appendrattrs(lfs3, &rbyd, -1, -1, -1, rattrs); if (err) { return err; } // append initial gcksum uint32_t cksum = rbyd.cksum; - err = lfs3_rbyd_appendrattr_(lfs3, &rbyd, LFS3_RATTR_LE32( - LFS3_TAG_GCKSUMDELTA, 0, lfs3_crc32c_cube(cksum))); + err = lfs3_rbyd_appendrattr_(lfs3, &rbyd, + LFS3_TAG_GCKSUMDELTA, 0, + LFS3_FROM_LE32, 0, LFS3_RATTRS( + LFS3_RATTR_ARG(lfs3_crc32c_cube(cksum)))); if (err) { return err; } @@ -16094,7 +16173,8 @@ static int lfs3_fs_fixgrm(lfs3_t *lfs3) { // remove the rid while atomically updating our grm err = lfs3_mdir_commit(lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))); + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)); if (err) { // revert grm manually lfs3->grm = grm_p; @@ -16145,7 +16225,8 @@ static int lfs3_mdir_mkconsistent(lfs3_t *lfs3, lfs3_mdir_t *mdir) { // remove the orphaned stickynote err = lfs3_mdir_commit(lfs3, mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))); + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -16434,11 +16515,11 @@ int lfs3_fs_grow(lfs3_t *lfs3, lfs3_size_t block_count_) { err = lfs3_gbmap_commit(lfs3, &lfs3->gbmap.b, (tag == LFS3_TAG_BMFREE) ? block_count-1 : block_count, LFS3_RATTRS( - LFS3_RATTR( - (tag == LFS3_TAG_BMFREE) - ? LFS3_tag_GROW - : LFS3_TAG_BMFREE, - +(block_count_ - block_count)))); + (tag == LFS3_TAG_BMFREE) + ? LFS3_RATTR(2, LFS3_tag_GROW, -2) + : LFS3_RATTR(2, LFS3_TAG_BMFREE, -2), + LFS3_RATTR_WEIGHT(+(block_count_ - block_count)), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -16446,12 +16527,14 @@ int lfs3_fs_grow(lfs3_t *lfs3, lfs3_size_t block_count_) { #endif // update our on-disk config + const lfs3_geometry_t geometry = { + .block_size=lfs3->cfg->block_size, + .block_count=block_count_, + }; err = lfs3_mdir_commit(lfs3, &lfs3->mroot, LFS3_RATTRS( - LFS3_RATTR_GEOMETRY( - LFS3_TAG_GEOMETRY, 0, - (&(lfs3_geometry_t){ - lfs3->cfg->block_size, - block_count_})))); + LFS3_RATTR(2, LFS3_TAG_GEOMETRY, 0, LFS3_FROM_GEOMETRY), + LFS3_RATTR_ARG(&geometry), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -16492,7 +16575,9 @@ int lfs3_fs_mkgbmap(lfs3_t *lfs3) { lfs3_gbmap_init(&lfs3->gbmap); err = lfs3_gbmap_commit(lfs3, &lfs3->gbmap.b, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_TAG_BMFREE, +lfs3->block_count))); + LFS3_RATTR(2, LFS3_TAG_BMFREE, -2), + LFS3_RATTR_WEIGHT(+lfs3->block_count), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -16518,7 +16603,9 @@ int lfs3_fs_mkgbmap(lfs3_t *lfs3) { wcompat_ |= LFS3_WCOMPAT_GBMAP; err = lfs3_mdir_commit(lfs3, &lfs3->mroot, LFS3_RATTRS( - LFS3_RATTR_LE32(LFS3_TAG_WCOMPAT, 0, wcompat_))); + LFS3_RATTR(2, LFS3_TAG_WCOMPAT, 0, LFS3_FROM_LE32), + LFS3_RATTR_ARG(wcompat_), + LFS3_RATTR_NULL)); if (err) { goto failed; } @@ -16556,7 +16643,9 @@ int lfs3_fs_rmgbmap(lfs3_t *lfs3) { wcompat_ &= ~LFS3_WCOMPAT_GBMAP; err = lfs3_mdir_commit(lfs3, &lfs3->mroot, LFS3_RATTRS( - LFS3_RATTR_LE32(LFS3_TAG_WCOMPAT, 0, wcompat_))); + LFS3_RATTR(2, LFS3_TAG_WCOMPAT, 0, LFS3_FROM_LE32), + LFS3_RATTR_ARG(wcompat_), + LFS3_RATTR_NULL)); if (err) { return err; } diff --git a/lfs3.h b/lfs3.h index fa02e55f..ab77b7de 100644 --- a/lfs3.h +++ b/lfs3.h @@ -38,7 +38,7 @@ typedef uint32_t lfs3_off_t; typedef int32_t lfs3_soff_t; typedef uint32_t lfs3_block_t; -typedef int32_t lfs3_sblock_t; +typedef int32_t lfs3_sblock_t; typedef uint32_t lfs3_rid_t; typedef int32_t lfs3_srid_t; @@ -1142,8 +1142,6 @@ typedef struct lfs3_file { lfs3_off_t pos; // in-RAM cache - // - // note this lines up with lfs3_data_t's buffer representation struct { lfs3_off_t pos; lfs3_off_t size; diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml index 1da1f51e..38e19653 100644 --- a/tests/test_badblocks.toml +++ b/tests/test_badblocks.toml @@ -78,9 +78,9 @@ code = ''' // add to btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -2041,9 +2041,9 @@ code = ''' // add to btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -4006,9 +4006,9 @@ code = ''' // add to btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); diff --git a/tests/test_btree.toml b/tests/test_btree.toml index 7d13c7c6..4e1ade02 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -58,7 +58,9 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -102,9 +104,13 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -153,9 +159,13 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -205,11 +215,17 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -265,11 +281,17 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -330,9 +352,9 @@ code = ''' lfs3_size_t n = 0; for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -382,9 +404,9 @@ code = ''' lfs3_size_t n = 0; for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+((N-1-i) % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+((N-1-i) % 26)}), + LFS3_RATTR_NULL)) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -449,9 +471,9 @@ code = ''' // add to btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -520,9 +542,10 @@ code = ''' lfs3_size_t n = 0; for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -613,9 +636,10 @@ code = ''' // add to btree lfs3_btree_commit(&lfs3, &btree, weighted_bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +weight, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+weight), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -726,12 +750,15 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; // update the tree lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - "A", 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("A"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -773,18 +800,24 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; // update the tree lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - "A", 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("A"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - "B", 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("B"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -833,24 +866,33 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // update the tree lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - "A", 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("A"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - "B", 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("B"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - "C", 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("C"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -908,16 +950,17 @@ code = ''' lfs3_btree_init(&btree); for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } // update the tree for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &(uint8_t){'A'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'A'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } printf("btree: w%d 0x%x.%x\n", btree.r.weight, @@ -967,9 +1010,9 @@ code = ''' lfs3_btree_init(&btree); for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } // set up a simulation to compare against @@ -988,9 +1031,10 @@ code = ''' // update btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &(uint8_t){'A'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'A'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // update sim sim[bid] = 'A'+(i % 26); @@ -1055,16 +1099,18 @@ code = ''' lfs3_btree_init(&btree); for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } // update the tree for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i*W+W-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &(uint8_t){'A'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'A'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } printf("btree: w%d 0x%x.%x\n", btree.r.weight, @@ -1130,9 +1176,10 @@ code = ''' lfs3_btree_init(&btree); for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } // set up a simulation to compare against @@ -1162,11 +1209,12 @@ code = ''' // update btree lfs3_btree_commit(&lfs3, &btree, weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &(uint8_t){'A'+(i % 26)}, 1), - LFS3_RATTR( - LFS3_tag_GROW, +weight-sim_weights[bid]))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'A'+(i % 26)}), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+weight-sim_weights[bid]), + LFS3_RATTR_NULL)) => 0; // update sim sim[bid] = 'A'+(i % 26); @@ -1274,10 +1322,13 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; // pop! lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -1296,7 +1347,9 @@ code = ''' // try to putting it back to see if things still work lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "A", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("A"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -1332,12 +1385,17 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; // pop! lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -1363,7 +1421,9 @@ code = ''' // try to putting it back to see if things still work lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "B", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("B"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -1406,12 +1466,17 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; // pop! lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -1437,7 +1502,9 @@ code = ''' // try to putting it back to see if things still work lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "A", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("A"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -1480,14 +1547,21 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "a", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // pop! lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -1520,7 +1594,9 @@ code = ''' // try to putting it back to see if things still work lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "C", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("C"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -1574,14 +1650,15 @@ code = ''' lfs3_btree_init(&btree); for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } // drain the tree for (lfs3_size_t i = 0; i < N-REMAINING; i++) { lfs3_btree_commit(&lfs3, &btree, N-1-i, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; } printf("btree: w%d 0x%x.%x\n", @@ -1612,7 +1689,9 @@ code = ''' // try recovering lfs3_btree_commit(&lfs3, &btree, REMAINING, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "R", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("R"), + LFS3_RATTR_NULL)) => 0; for (lfs3_size_t i = 0; i < REMAINING; i++) { tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, @@ -1655,14 +1734,15 @@ code = ''' lfs3_btree_init(&btree); for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } // drain the tree for (lfs3_size_t i = 0; i < N-REMAINING; i++) { lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; } printf("btree: w%d 0x%x.%x\n", btree.r.weight, @@ -1693,7 +1773,9 @@ code = ''' // try recovering lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "R", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("R"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, &bid_, &weight_, &data_); @@ -1739,9 +1821,9 @@ code = ''' lfs3_btree_init(&btree); for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } // set up a simulation to compare against @@ -1761,7 +1843,8 @@ code = ''' // remove from btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; // remove from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -1829,14 +1912,17 @@ code = ''' lfs3_btree_init(&btree); for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } // drain the tree for (lfs3_size_t i = 0; i < N-REMAINING; i++) { lfs3_btree_commit(&lfs3, &btree, (N-1-i)*W+W-1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -W))) => 0; + LFS3_RATTR(2, LFS3_tag_RM, -2), + LFS3_RATTR_WEIGHT(-W), + LFS3_RATTR_NULL)) => 0; } printf("btree: w%d 0x%x.%x\n", btree.r.weight, @@ -1866,7 +1952,10 @@ code = ''' // try recovering lfs3_btree_commit(&lfs3, &btree, REMAINING*W, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +W, "R", 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG("R"), + LFS3_RATTR_NULL)) => 0; for (lfs3_size_t i = 0; i < REMAINING; i++) { tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, @@ -1957,9 +2046,10 @@ code = ''' } lfs3_btree_commit(&lfs3, &btree, weighted_bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +weight, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+weight), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; sim[i] = 'a'+(i % 26); sim_weights[i] = weight; @@ -1979,8 +2069,9 @@ code = ''' // remove from btree lfs3_btree_commit(&lfs3, &btree, weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM, -sim_weights[bid]))) => 0; + LFS3_RATTR(2, LFS3_tag_RM, -2), + LFS3_RATTR_WEIGHT(-sim_weights[bid]), + LFS3_RATTR_NULL)) => 0; // remove from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -2088,18 +2179,17 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(0 % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(0 % 26)}), + LFS3_RATTR_NULL)) => 0; lfs3_size_t n = 1; for (lfs3_size_t i = 1; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'a'+((i-1) % 26)}, 1), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+((i-0) % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+((i-1) % 26)}), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+((i-0) % 26)}), + LFS3_RATTR_NULL)) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -2149,7 +2239,9 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "_", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("_"), + LFS3_RATTR_NULL)) => 0; // set up a simulation to compare against // @@ -2167,12 +2259,11 @@ code = ''' // split btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'a'+(i % 26)}, 1), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'A'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'A'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // split sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -2240,18 +2331,19 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - &(uint8_t){'a'+(0 % 26)}, 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(&(uint8_t){'a'+(0 % 26)}), + LFS3_RATTR_NULL)) => 0; lfs3_size_t n = 1; for (lfs3_size_t i = 1; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, (i-1)*W+W-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'a'+((i-1) % 26)}, 1), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - &(uint8_t){'a'+((i-0) % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+((i-1) % 26)}), + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(&(uint8_t){'a'+((i-0) % 26)}), + LFS3_RATTR_NULL)) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -2302,7 +2394,10 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +W, "_", 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG("_"), + LFS3_RATTR_NULL)) => 0; // set up a simulation to compare against // @@ -2333,14 +2428,14 @@ code = ''' // split btree lfs3_btree_commit(&lfs3, &btree, weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_GROW, +weight1-sim_weights[bid]), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'a'+(i % 26)}, 1), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +weight2, - &(uint8_t){'A'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+weight1-sim_weights[bid]), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+weight2), + LFS3_RATTR_ARG(&(uint8_t){'A'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -2486,29 +2581,36 @@ code = ''' // the extra push here avoids trying to inline the big entry lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "_", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("_"), + LFS3_RATTR_NULL)) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_DATA, 0, - &LFS3_DATA_BUF(buf1, SIZE)), - LFS3_RATTR_DATA(LFS3_TAG_DATA, +1, - &LFS3_DATA_BUF(buf2, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf1), + LFS3_RATTR(3, LFS3_TAG_DATA, +1, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf2), + LFS3_RATTR_NULL)) => 0; // force compaction lfs3_btree_claim(&btree); memset(buf2, 'b', SIZE); lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_DATA( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &LFS3_DATA_BUF(buf2, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf2), + LFS3_RATTR_NULL)) => 0; assert(btree.r.weight == 2); // now remove one entry, since this brings the rbyd down to zero, // this should force one of the blocks to drop lfs3_btree_commit(&lfs3, &btree, SIBLING, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, @@ -2557,23 +2659,29 @@ code = ''' // the extra push here avoids trying to inline the big entry lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "_", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("_"), + LFS3_RATTR_NULL)) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_DATA, 0, - &LFS3_DATA_BUF(buf1, SIZE)), - LFS3_RATTR_DATA(LFS3_TAG_DATA, +1, - &LFS3_DATA_BUF(buf2, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf1), + LFS3_RATTR(3, LFS3_TAG_DATA, +1, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf2), + LFS3_RATTR_NULL)) => 0; // force compaction lfs3_btree_claim(&btree); memset(buf2, 'b', SIZE); lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_DATA( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &LFS3_DATA_BUF(buf2, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf2), + LFS3_RATTR_NULL)) => 0; assert(btree.r.weight == 2); // now remove one entry, since this brings the rbyd down this zero, @@ -2582,7 +2690,8 @@ code = ''' // do this while forcing a compaction lfs3_btree_claim(&btree); lfs3_btree_commit(&lfs3, &btree, SIBLING, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, @@ -2631,16 +2740,21 @@ code = ''' // the extra push here avoids trying to inline the big entry lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "_", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("_"), + LFS3_RATTR_NULL)) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_DATA, 0, - &LFS3_DATA_BUF(buf1, SIZE)), - LFS3_RATTR_DATA(LFS3_TAG_DATA, +1, - &LFS3_DATA_BUF(buf2, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf1), + LFS3_RATTR(3, LFS3_TAG_DATA, +1, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf2), + LFS3_RATTR_NULL)) => 0; // force compaction, causing a split, but while we're splitting, // also remove an entry, bringing the split rbyd down to zero mid split @@ -2649,7 +2763,8 @@ code = ''' // lfs3_btree_claim(&btree); lfs3_btree_commit(&lfs3, &btree, SIBLING, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, @@ -2698,40 +2813,49 @@ code = ''' // the extra push here avoids trying to inline the big entry lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "_", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("_"), + LFS3_RATTR_NULL)) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_DATA, 0, - &LFS3_DATA_BUF(buf1, SIZE)), - LFS3_RATTR_DATA(LFS3_TAG_DATA, +1, - &LFS3_DATA_BUF(buf2, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf1), + LFS3_RATTR(3, LFS3_TAG_DATA, +1, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf2), + LFS3_RATTR_NULL)) => 0; // force compaction lfs3_btree_claim(&btree); memset(buf2, 'b', SIZE); lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_DATA( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &LFS3_DATA_BUF(buf2, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buf2), + LFS3_RATTR_NULL)) => 0; assert(btree.r.weight == 2); // now make both entries small so they should be merged if either compacts lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - "a", 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - "b", 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; // force compaction, while removing one entry, this drops the rbyd // down to zero while also triggering a merge lfs3_btree_claim(&btree); lfs3_btree_commit(&lfs3, &btree, SIBLING, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, @@ -2796,9 +2920,9 @@ code = ''' if (op == 0 || bid == sim_size) { // push to btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // push to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -2808,9 +2932,10 @@ code = ''' } else if (op == 1) { // update btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // update sim sim[bid] = 'a'+(i % 26); @@ -2818,7 +2943,8 @@ code = ''' } else { // pop from btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -2914,9 +3040,10 @@ code = ''' if (op == 0 || bid == sim_size) { // push to btree lfs3_btree_commit(&lfs3, &btree, weighted_bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +weight, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+weight), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // push to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -2930,11 +3057,12 @@ code = ''' // update btree lfs3_btree_commit(&lfs3, &btree, weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &(uint8_t){'a'+(i % 26)}, 1), - LFS3_RATTR( - LFS3_tag_GROW, +weight-sim_weights[bid]))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+weight-sim_weights[bid]), + LFS3_RATTR_NULL)) => 0; // update sim sim[bid] = 'a'+(i % 26); @@ -2944,8 +3072,9 @@ code = ''' // remove from btree lfs3_btree_commit(&lfs3, &btree, weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM, -sim_weights[bid]))) => 0; + LFS3_RATTR(2, LFS3_tag_RM, -2), + LFS3_RATTR_WEIGHT(-sim_weights[bid]), + LFS3_RATTR_NULL)) => 0; // remove from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -3085,10 +3214,13 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, "aaa", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("aaa"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("0"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -3144,16 +3276,23 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, "aaa", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("aaa"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("0"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, "aab", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "1", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("0"), + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("aab"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("1"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -3220,22 +3359,33 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, "aaa", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("aaa"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("0"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 1*DID, "aab", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "1", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("0"), + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(1*DID), + LFS3_RATTR_ARG("aab"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("1"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "1", 1), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 2*DID, "aac", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "2", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("1"), + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(2*DID), + LFS3_RATTR_ARG("aac"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("2"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -3313,22 +3463,33 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, "aaa", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("aaa"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("0"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "1", 1), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 2*DID, "aac", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "2", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("1"), + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(2*DID), + LFS3_RATTR_ARG("aac"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("2"), + LFS3_RATTR_NULL)) => 0; lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "0", 1), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 1*DID, "aab", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "1", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("0"), + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(1*DID), + LFS3_RATTR_ARG("aab"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("1"), + LFS3_RATTR_NULL)) => 0; printf("btree: w%d 0x%x.%x\n", btree.r.weight, btree.r.blocks[0], @@ -3410,27 +3571,28 @@ code = ''' 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, name, 3), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(0 % 10)}, 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(0 % 10)}), + LFS3_RATTR_NULL)) => 0; lfs3_size_t n = 1; for (lfs3_size_t i = 1; i < N; i++) { char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; lfs3_btree_commit(&lfs3, &btree, i-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+((i-1) % 10)}, 1), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - i*DID, name, 3), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+((i-0) % 10)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+((i-1) % 10)}), + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(i*DID), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+((i-0) % 10)}), + LFS3_RATTR_NULL)) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -3484,10 +3646,13 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, "___", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "_", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("___"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("_"), + LFS3_RATTR_NULL)) => 0; // set up a simulation to compare against // @@ -3521,15 +3686,15 @@ code = ''' // split btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, name, 3), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(i % 10)}), + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(i % 10)}), + LFS3_RATTR_NULL)) => 0; // split sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -3605,27 +3770,30 @@ code = ''' 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) }; lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +W, - 0, name, 3), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(0 % 10)}, 1))) => 0; + LFS3_RATTR(5, LFS3_TAG_REG, -2, LFS3_FROM_NAME), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(0 % 10)}), + LFS3_RATTR_NULL)) => 0; lfs3_size_t n = 1; for (lfs3_size_t i = 1; i < N; i++) { char name[3] = { 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; lfs3_btree_commit(&lfs3, &btree, (i-1)*W+W-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+((i-1) % 10)}, 1), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +W, - i*DID, name, 3), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+((i-0) % 10)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+((i-1) % 10)}), + LFS3_RATTR(5, LFS3_TAG_REG, -2, LFS3_FROM_NAME), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(i*DID), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+((i-0) % 10)}), + LFS3_RATTR_NULL)) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -3680,10 +3848,14 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +W, - 0, "___", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "_", 1))) => 0; + LFS3_RATTR(5, LFS3_TAG_REG, -2, LFS3_FROM_NAME), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("___"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("_"), + LFS3_RATTR_NULL)) => 0; // set up a simulation to compare against // @@ -3730,17 +3902,18 @@ code = ''' // split btree lfs3_btree_commit(&lfs3, &btree, weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_GROW, +weight1-sim_weights[bid]), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +weight2, - 0, name, 3), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1))) => 0; + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+weight1-sim_weights[bid]), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(i % 10)}), + LFS3_RATTR(5, LFS3_TAG_REG, -2, LFS3_FROM_NAME), + LFS3_RATTR_WEIGHT(+weight2), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(i % 10)}), + LFS3_RATTR_NULL)) => 0; // split sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); @@ -3839,10 +4012,13 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, "___", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "_", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("___"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("_"), + LFS3_RATTR_NULL)) => 0; // set up a simulation to compare against // @@ -3911,22 +4087,24 @@ code = ''' assert(cmp != LFS3_CMP_EQ); if (cmp > LFS3_CMP_EQ) { lfs3_btree_commit(&lfs3, &btree, split_bid, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, name, 3), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(i % 10)}), + LFS3_RATTR_NULL)) => 0; } else { lfs3_btree_commit(&lfs3, &btree, split_bid, LFS3_RATTRS( // yes, we need this noop, see above - LFS3_RATTR_NOOP(), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, name, 3), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1))) => 0; + LFS3_RATTR(1, LFS3_RATTR_NULL, 0), + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(i % 10)}), + LFS3_RATTR_NULL)) => 0; } // split sim @@ -3939,9 +4117,10 @@ code = ''' } else if (op == 1) { // update btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(i % 10)}), + LFS3_RATTR_NULL)) => 0; // update sim sim[bid] = '0'+(i % 10); @@ -3949,7 +4128,8 @@ code = ''' } else { // pop from btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -4019,10 +4199,14 @@ code = ''' lfs3_btree_t btree; lfs3_btree_init(&btree); lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +W, - 0, "___", 3), - LFS3_RATTR_BUF(LFS3_TAG_DATA, 0, "_", 1))) => 0; + LFS3_RATTR(5, LFS3_TAG_REG, -2, LFS3_FROM_NAME), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("___"), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("_"), + LFS3_RATTR_NULL)) => 0; // set up a simulation to compare against // @@ -4105,22 +4289,26 @@ code = ''' if (cmp > LFS3_CMP_EQ) { lfs3_btree_commit(&lfs3, &btree, split_bid-(split_weight-1), LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +weight, - 0, name, 3), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1))) => 0; + LFS3_RATTR(5, LFS3_TAG_REG, -2, LFS3_FROM_NAME), + LFS3_RATTR_WEIGHT(+weight), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(i % 10)}), + LFS3_RATTR_NULL)) => 0; } else { lfs3_btree_commit(&lfs3, &btree, split_bid, LFS3_RATTRS( // yes, we need this noop, see above - LFS3_RATTR_NOOP(), - LFS3_RATTR_NAME( - LFS3_TAG_REG, +weight, - 0, name, 3), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1))) => 0; + LFS3_RATTR(1, LFS3_RATTR_NULL, 0), + LFS3_RATTR(5, LFS3_TAG_REG, -2, LFS3_FROM_NAME), + LFS3_RATTR_WEIGHT(+weight), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name), + LFS3_RATTR_ARG(3), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(i % 10)}), + LFS3_RATTR_NULL)) => 0; } // split sim @@ -4137,11 +4325,12 @@ code = ''' // update btree lfs3_btree_commit(&lfs3, &btree, weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1), - LFS3_RATTR( - LFS3_tag_GROW, +weight-sim_weights[bid]))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_DATA, 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'0'+(i % 10)}), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+weight-sim_weights[bid]), + LFS3_RATTR_NULL)) => 0; // update sim sim[bid] = '0'+(i % 10); @@ -4151,8 +4340,9 @@ code = ''' // pop from btree lfs3_btree_commit(&lfs3, &btree, weighted_bid+sim_weights[bid]-1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM, -sim_weights[bid]))) => 0; + LFS3_RATTR(2, LFS3_tag_RM, -2), + LFS3_RATTR_WEIGHT(-sim_weights[bid]), + LFS3_RATTR_NULL)) => 0; // pop from sim memmove(&sim[bid], &sim[bid+1], sim_size-(bid+1)); @@ -4249,9 +4439,9 @@ code = ''' lfs3_size_t n = 0; for (lfs3_size_t i = 0; i < N; i++) { lfs3_btree_commit(&lfs3, &btree, i, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; n += 1; } printf("btree: w%d 0x%x.%x\n", @@ -4392,9 +4582,9 @@ code = ''' // add to btree lfs3_btree_commit(&lfs3, &btree, bid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; // add to sim memmove(&sim[bid+1], &sim[bid], sim_size-bid); diff --git a/tests/test_files.toml b/tests/test_files.toml index edb1d592..fc97d7d0 100644 --- a/tests/test_files.toml +++ b/tests/test_files.toml @@ -978,8 +978,8 @@ code = ''' // delete any bshrub/btree lfs3_mdir_commit(&lfs3, &file.b.h.mdir, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_tag_MASK8 | LFS3_TAG_STRUCT, 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_tag_MASK8 | LFS3_TAG_STRUCT, 0), + LFS3_RATTR_NULL)) => 0; lfs3_file_close(&lfs3, &file) => 0; @@ -1094,25 +1094,27 @@ code = ''' // create an empty bshrub lfs3_mdir_commit(&lfs3, &file.b.h.mdir, LFS3_RATTRS( - LFS3_RATTR_SHRUBCOMMIT( - (&(lfs3_shrubcommit_t){ - .bshrub=&file.b, - .rid=0, - .rattrs=((lfs3_rattr_t[]){ - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "?", 1)}), - .rattr_count=1})))) => 0; + LFS3_RATTR(4, LFS3_tag_SHRUBCOMMIT, 0), + LFS3_RATTR_ARG(&file.b), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(LFS3_RATTRS( + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("?"), + LFS3_RATTR_NULL)), + LFS3_RATTR_NULL)) => 0; lfs3_mdir_commit(&lfs3, &file.b.h.mdir, LFS3_RATTRS( - LFS3_RATTR_SHRUBCOMMIT( - (&(lfs3_shrubcommit_t){ - .bshrub=&file.b, - .rid=0, - .rattrs=((lfs3_rattr_t[]){ - LFS3_RATTR(LFS3_tag_RM, -1)}), - .rattr_count=1})))) => 0; + LFS3_RATTR(4, LFS3_tag_SHRUBCOMMIT, 0), + LFS3_RATTR_ARG(&file.b), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(LFS3_RATTRS( + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)), + LFS3_RATTR_NULL)) => 0; lfs3_mdir_commit(&lfs3, &file.b.h.mdir, LFS3_RATTRS( - LFS3_RATTR_SHRUB( - LFS3_tag_MASK8 | LFS3_TAG_BSHRUB, 0, - &file.b.b_))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_BSHRUB, 0, + LFS3_FROM_SHRUB), + LFS3_RATTR_ARG(&file.b.b_), + LFS3_RATTR_NULL)) => 0; lfs3_file_close(&lfs3, &file) => 0; @@ -1229,13 +1231,16 @@ code = ''' lfs3_alloc_ckpoint(&lfs3); lfs3_rbyd_alloc(&lfs3, &file.b.b.r) => 0; lfs3_rbyd_commit(&lfs3, &file.b.b.r, 0, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "?", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("?"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &file.b.b.r, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; lfs3_mdir_commit(&lfs3, &file.b.h.mdir, LFS3_RATTRS( - LFS3_RATTR_BTREE( - LFS3_tag_MASK8 | LFS3_TAG_BTREE, 0, - &file.b.b))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_BTREE, 0, + LFS3_FROM_BTREE), + LFS3_RATTR_ARG(&file.b.b))) => 0; lfs3_file_close(&lfs3, &file) => 0; diff --git a/tests/test_fwrite.toml b/tests/test_fwrite.toml index 448624ac..37c912d2 100644 --- a/tests/test_fwrite.toml +++ b/tests/test_fwrite.toml @@ -5000,9 +5000,10 @@ code = ''' printf("pos = %d, %d\n", pos, weight); lfs3_bshrub_commit(&lfs3, &file.b, pos, LFS3_RATTRS( - LFS3_RATTR_DATA( - LFS3_tag_GROW | tag, -(weight/2), - &data))) => 0; + LFS3_RATTR(3, LFS3_tag_GROW | tag, -2, LFS3_FROM_CAT, 1), + LFS3_RATTR_WEIGHT(-(weight/2)), + LFS3_RATTR_ARG(&data), + LFS3_RATTR_NULL)) => 0; pos = pos - (weight/2) + 1; } @@ -5110,9 +5111,10 @@ code = ''' printf("pos = %d, %d\n", pos, weight); lfs3_bshrub_commit(&lfs3, &file.b, pos, LFS3_RATTRS( - LFS3_RATTR_DATA( - LFS3_tag_GROW | tag, -(weight/2), - &data))) => 0; + LFS3_RATTR(3, LFS3_tag_GROW | tag, -2, LFS3_FROM_CAT, 1), + LFS3_RATTR_WEIGHT(-(weight/2)), + LFS3_RATTR_ARG(&data), + LFS3_RATTR_NULL)) => 0; pos = pos - (weight/2) + 1; } diff --git a/tests/test_gbmap.toml b/tests/test_gbmap.toml index a13c64b7..1c42b13f 100644 --- a/tests/test_gbmap.toml +++ b/tests/test_gbmap.toml @@ -24,7 +24,9 @@ code = ''' lfs3_btree_t gbmap; lfs3_btree_init(&gbmap); lfs3_gbmap_commit(&lfs3, &gbmap, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_TAG_BMFREE, +BLOCK_COUNT))) => 0; + LFS3_RATTR(2, LFS3_TAG_BMFREE, -2), + LFS3_RATTR_WEIGHT(+BLOCK_COUNT), + LFS3_RATTR_NULL)) => 0; // set some blocks as in-use, avoid any weird merges for now lfs3_gbmap_mark(&lfs3, &gbmap, 6, LFS3_TAG_BMINUSE) => 0; @@ -85,7 +87,9 @@ code = ''' lfs3_btree_t gbmap; lfs3_btree_init(&gbmap); lfs3_gbmap_commit(&lfs3, &gbmap, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_TAG_BMFREE, +BLOCK_COUNT))) => 0; + LFS3_RATTR(2, LFS3_TAG_BMFREE, -2), + LFS3_RATTR_WEIGHT(+BLOCK_COUNT), + LFS3_RATTR_NULL)) => 0; // set some blocks as in-use, avoid any weird merges for now lfs3_gbmap_mark(&lfs3, &gbmap, 6, LFS3_TAG_BMINUSE) => 0; @@ -150,7 +154,9 @@ code = ''' lfs3_btree_t gbmap; lfs3_btree_init(&gbmap); lfs3_gbmap_commit(&lfs3, &gbmap, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_TAG_BMFREE, +BLOCK_COUNT))) => 0; + LFS3_RATTR(2, LFS3_TAG_BMFREE, -2), + LFS3_RATTR_WEIGHT(+BLOCK_COUNT), + LFS3_RATTR_NULL)) => 0; // set some blocks as in-use, avoid any weird merges for now lfs3_gbmap_mark(&lfs3, &gbmap, 6, LFS3_TAG_BMINUSE) => 0; @@ -216,7 +222,9 @@ code = ''' lfs3_btree_t gbmap; lfs3_btree_init(&gbmap); lfs3_gbmap_commit(&lfs3, &gbmap, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_TAG_BMFREE, +BLOCK_COUNT))) => 0; + LFS3_RATTR(2, LFS3_TAG_BMFREE, -2), + LFS3_RATTR_WEIGHT(+BLOCK_COUNT), + LFS3_RATTR_NULL)) => 0; // set some blocks as in-use, avoid any weird merges for now lfs3_gbmap_mark(&lfs3, &gbmap, 6, LFS3_TAG_BMINUSE) => 0; @@ -283,7 +291,9 @@ code = ''' lfs3_btree_t gbmap; lfs3_btree_init(&gbmap); lfs3_gbmap_commit(&lfs3, &gbmap, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_TAG_BMFREE, +BLOCK_COUNT))) => 0; + LFS3_RATTR(2, LFS3_TAG_BMFREE, -2), + LFS3_RATTR_WEIGHT(+BLOCK_COUNT), + LFS3_RATTR_NULL)) => 0; // test that setting the first and last blocks don't break anything // @@ -333,7 +343,9 @@ code = ''' lfs3_btree_t gbmap; lfs3_btree_init(&gbmap); lfs3_gbmap_commit(&lfs3, &gbmap, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_TAG_BMFREE, +BLOCK_COUNT))) => 0; + LFS3_RATTR(2, LFS3_TAG_BMFREE, -2), + LFS3_RATTR_WEIGHT(+BLOCK_COUNT), + LFS3_RATTR_NULL)) => 0; // create a simulation to compare against lfs3_tag_t *sim = malloc(BLOCK_COUNT*sizeof(lfs3_tag_t)); diff --git a/tests/test_mount.toml b/tests/test_mount.toml index 82b14790..b735cdaa 100644 --- a/tests/test_mount.toml +++ b/tests/test_mount.toml @@ -704,8 +704,8 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_MAGIC, 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_MAGIC, 0), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -727,9 +727,9 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_MAGIC, 0, - "lottlefs", 8))) => 0; + LFS3_RATTR(2, LFS3_TAG_MAGIC, 0, LFS3_FROM_BUF, 8), + LFS3_RATTR_ARG("lottlefs"), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -751,11 +751,11 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_VERSION, 0, - ((const uint8_t[2]){ - LFS3_DISK_VERSION_MAJOR+1, - 0}), 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_VERSION, 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(((const uint8_t[2]){ + LFS3_DISK_VERSION_MAJOR+1, + 0})), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -777,11 +777,11 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_VERSION, 0, - ((const uint8_t[2]){ - LFS3_DISK_VERSION_MAJOR, - LFS3_DISK_VERSION_MINOR+1}), 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_VERSION, 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(((const uint8_t[2]){ + LFS3_DISK_VERSION_MAJOR, + LFS3_DISK_VERSION_MINOR+1})), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -804,10 +804,11 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_LE32( - LFS3_TAG_RCOMPAT, 0, + LFS3_RATTR(2, LFS3_TAG_RCOMPAT, 0, LFS3_FROM_LE32), + LFS3_RATTR_ARG( lfs3_rcompat(&lfs3) - | LFS3_RCOMPAT_NONSTANDARD))) => 0; + | LFS3_RCOMPAT_NONSTANDARD), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -830,10 +831,11 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_LE32( - LFS3_TAG_WCOMPAT, 0, + LFS3_RATTR(2, LFS3_TAG_WCOMPAT, 0, LFS3_FROM_LE32), + LFS3_RATTR_ARG( lfs3_wcompat(&lfs3) - | LFS3_WCOMPAT_NONSTANDARD))) => 0; + | LFS3_WCOMPAT_NONSTANDARD), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -859,10 +861,11 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_LE32( - LFS3_TAG_OCOMPAT, 0, + LFS3_RATTR(2, LFS3_TAG_OCOMPAT, 0, LFS3_FROM_LE32), + LFS3_RATTR_ARG( lfs3_ocompat(&lfs3) - | LFS3_OCOMPAT_NONSTANDARD))) => 0; + | LFS3_OCOMPAT_NONSTANDARD), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should _not_ fail, ocompat should always be ignored @@ -886,10 +889,11 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_LE32( - LFS3_TAG_WCOMPAT, 0, + LFS3_RATTR(2, LFS3_TAG_WCOMPAT, 0, LFS3_FROM_LE32), + LFS3_RATTR_ARG( lfs3_wcompat(&lfs3) - | LFS3_WCOMPAT_RDONLY))) => 0; + | LFS3_WCOMPAT_RDONLY), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -914,10 +918,11 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_LE32( - LFS3_TAG_RCOMPAT, 0, + LFS3_RATTR(2, LFS3_TAG_RCOMPAT, 0, LFS3_FROM_LE32), + LFS3_RATTR_ARG( lfs3_rcompat(&lfs3) - | LFS3_RCOMPAT_WRONLY))) => 0; + | LFS3_RCOMPAT_WRONLY), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -939,17 +944,17 @@ code = ''' // // note we're messing around with internals to do this! this // is not a user API - uint8_t overflow[OVERFLOW / 8]; - memset(overflow, 0, sizeof(overflow)); - overflow[FLAG / 8] |= 1 << (FLAG % 8); + uint8_t rcompat_buf[sizeof(uint32_t) + OVERFLOW/8]; + memset(rcompat_buf, 0, sizeof(rcompat_buf)); + lfs3_data_fromle32(lfs3_rcompat(&lfs3), rcompat_buf); + rcompat_buf[sizeof(uint32_t) + FLAG/8] |= 1 << (FLAG%8); lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - uint8_t rcompat_buf[LFS3_LE32_DSIZE]; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_RCOMPAT, 0, - lfs3_data_fromle32(lfs3_rcompat(&lfs3), rcompat_buf), - LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + LFS3_RATTR(3, LFS3_TAG_RCOMPAT, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(sizeof(rcompat_buf)), + LFS3_RATTR_ARG(rcompat_buf), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -973,17 +978,17 @@ code = ''' // // note we're messing around with internals to do this! this // is not a user API - uint8_t overflow[OVERFLOW / 8]; - memset(overflow, 0, sizeof(overflow)); - overflow[FLAG / 8] |= 1 << (FLAG % 8); + uint8_t wcompat_buf[sizeof(uint32_t) + OVERFLOW/8]; + memset(wcompat_buf, 0, sizeof(wcompat_buf)); + lfs3_data_fromle32(lfs3_wcompat(&lfs3), wcompat_buf); + wcompat_buf[sizeof(uint32_t) + FLAG/8] |= 1 << (FLAG%8); lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - uint8_t wcompat_buf[LFS3_LE32_DSIZE]; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_WCOMPAT, 0, - lfs3_data_fromle32(lfs3_wcompat(&lfs3), wcompat_buf), - LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + LFS3_RATTR(3, LFS3_TAG_WCOMPAT, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(sizeof(wcompat_buf)), + LFS3_RATTR_ARG(wcompat_buf), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -1007,17 +1012,16 @@ code = ''' // // note we're messing around with internals to do this! this // is not a user API - uint8_t overflow[OVERFLOW / 8]; - memset(overflow, 0, sizeof(overflow)); - overflow[FLAG / 8] |= 1 << (FLAG % 8); + uint8_t ocompat_buf[sizeof(uint32_t) + OVERFLOW/8]; + memset(ocompat_buf, 0, sizeof(ocompat_buf)); + ocompat_buf[sizeof(uint32_t) + FLAG/8] |= 1 << (FLAG%8); lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - uint8_t ocompat_buf[LFS3_LE32_DSIZE]; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_OCOMPAT, 0, - lfs3_data_fromle32(lfs3_ocompat(&lfs3), ocompat_buf), - LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + LFS3_RATTR(3, LFS3_TAG_OCOMPAT, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(sizeof(ocompat_buf)), + LFS3_RATTR_ARG(ocompat_buf), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should _not_ fail, ocompat should always be ignored @@ -1040,16 +1044,16 @@ code = ''' // // note we're messing around with internals to do this! this // is not a user API - uint8_t overflow[OVERFLOW / 8]; - memset(overflow, 0, sizeof(overflow)); + uint8_t rcompat_buf[sizeof(uint32_t) + OVERFLOW/8]; + memset(rcompat_buf, 0, sizeof(rcompat_buf)); + lfs3_data_fromle32(lfs3_rcompat(&lfs3), rcompat_buf); lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - uint8_t rcompat_buf[LFS3_LE32_DSIZE]; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_RCOMPAT, 0, - lfs3_data_fromle32(lfs3_rcompat(&lfs3), rcompat_buf), - LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + LFS3_RATTR(3, LFS3_TAG_RCOMPAT, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(sizeof(rcompat_buf)), + LFS3_RATTR_ARG(rcompat_buf), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should _not_ fail, extra zeros should be ignored @@ -1074,16 +1078,16 @@ code = ''' // // note we're messing around with internals to do this! this // is not a user API - uint8_t overflow[OVERFLOW / 8]; - memset(overflow, 0, sizeof(overflow)); + uint8_t wcompat_buf[sizeof(uint32_t) + OVERFLOW/8]; + memset(wcompat_buf, 0, sizeof(wcompat_buf)); + lfs3_data_fromle32(lfs3_wcompat(&lfs3), wcompat_buf); lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - uint8_t wcompat_buf[LFS3_LE32_DSIZE]; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_WCOMPAT, 0, - lfs3_data_fromle32(lfs3_wcompat(&lfs3), wcompat_buf), - LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + LFS3_RATTR(3, LFS3_TAG_WCOMPAT, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(sizeof(wcompat_buf)), + LFS3_RATTR_ARG(wcompat_buf), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should _not_ fail, extra zeros should be ignored @@ -1105,16 +1109,15 @@ code = ''' // // note we're messing around with internals to do this! this // is not a user API - uint8_t overflow[OVERFLOW / 8]; - memset(overflow, 0, sizeof(overflow)); + uint8_t ocompat_buf[sizeof(uint32_t) + OVERFLOW/8]; + memset(ocompat_buf, 0, sizeof(ocompat_buf)); lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - uint8_t ocompat_buf[LFS3_LE32_DSIZE]; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_OCOMPAT, 0, - lfs3_data_fromle32(lfs3_ocompat(&lfs3), ocompat_buf), - LFS3_DATA_BUF(overflow, sizeof(overflow))))) => 0; + LFS3_RATTR(3, LFS3_TAG_OCOMPAT, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(sizeof(ocompat_buf)), + LFS3_RATTR_ARG(ocompat_buf), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should _not_ fail, extra zeros should be ignored @@ -1139,11 +1142,11 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_GEOMETRY( - LFS3_TAG_GEOMETRY, 0, - (&(lfs3_geometry_t){ - INC_BLOCK_SIZE, - BLOCK_COUNT})))) => 0; + LFS3_RATTR(2, LFS3_TAG_GEOMETRY, 0, LFS3_FROM_GEOMETRY), + LFS3_RATTR_ARG((&(lfs3_geometry_t){ + INC_BLOCK_SIZE, + BLOCK_COUNT})), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -1166,11 +1169,11 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_GEOMETRY( - LFS3_TAG_GEOMETRY, 0, - (&(lfs3_geometry_t){ - BLOCK_SIZE, - INC_BLOCK_COUNT})))) => 0; + LFS3_RATTR(2, LFS3_TAG_GEOMETRY, 0, LFS3_FROM_GEOMETRY), + LFS3_RATTR_ARG((&(lfs3_geometry_t){ + BLOCK_SIZE, + INC_BLOCK_COUNT})), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -1193,9 +1196,9 @@ code = ''' // is not a user API lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_LEB128( - LFS3_TAG_NAMELIMIT, 0, - INC_NAME_LIMIT))) => 0; + LFS3_RATTR(2, LFS3_TAG_NAMELIMIT, 0, LFS3_FROM_LEB128), + LFS3_RATTR_ARG(INC_NAME_LIMIT), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -1215,17 +1218,24 @@ code = ''' // // note we're messing around with internals to do this! this // is not a user API + + // it's a bit difficult to test this since file limit + // is usually our integer limit, but we can force a + // larger value by inserting an extra byte into our + // leb128 encoding + uint8_t filelimit_buf[1+LFS3_LEB128_DSIZE]; + filelimit_buf[0] = 0xff; + lfs3_ssize_t d_ = lfs3_toleb128(LFS3_FILE_MAX, + filelimit_buf+1, LFS3_LEB128_DSIZE); + assert(d_ >= 0); + lfs3_size_t d = 1 + d_; + lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; - uint8_t file_limit_buf[LFS3_LEB128_DSIZE]; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_FILELIMIT, 0, - // it's a bit difficult to test this since file limit - // is usually our integer limit, but we can force a - // larger value by inserting an extra byte into our - // leb128 encoding - LFS3_DATA_BUF("\xff", 1), - lfs3_data_fromleb128(LFS3_FILE_MAX, file_limit_buf)))) => 0; + LFS3_RATTR(3, LFS3_TAG_FILELIMIT, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(d), + LFS3_RATTR_ARG(filelimit_buf), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -1244,9 +1254,10 @@ code = ''' // create an unknown config lfs3_mount(&lfs3, LFS3_M_RDWR, CFG) => 0; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_CONFIG + 0x42, 0, - "oh no!", strlen("oh no!")))) => 0; + LFS3_RATTR(3, LFS3_TAG_CONFIG + 0x42, 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(strlen("oh no!")), + LFS3_RATTR_ARG("oh no!"), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount should now fail @@ -1290,10 +1301,12 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount @@ -1377,10 +1390,12 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount @@ -1483,10 +1498,12 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount @@ -1592,10 +1609,12 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount @@ -1701,18 +1720,22 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "c"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount @@ -1818,10 +1841,12 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount @@ -1927,10 +1952,12 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount @@ -2036,10 +2063,12 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_tag_MASK8 | (LFS3_TAG_NAME + 0x13), 0, + LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; lfs3_unmount(&lfs3) => 0; // mount diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index 27814f9d..9bda7c6c 100644 --- a/tests/test_mtree.toml +++ b/tests/test_mtree.toml @@ -46,9 +46,9 @@ code = ''' for (lfs3_size_t i = 0; i < N; i++) { lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(i), 0, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(i), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } for (lfs3_size_t i = 0; i < N; i++) { @@ -93,9 +93,9 @@ code = ''' lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(i), 0, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(i), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } for (lfs3_size_t i = 0; i < N; i++) { @@ -137,9 +137,9 @@ code = ''' for (lfs3_size_t i = 0; i < N; i++) { lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; lfs3_data_t data; uint8_t buffer[4]; @@ -189,20 +189,26 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_ATTR(1), 0, - &LFS3_DATA_BUF(buffer, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_ATTR(1), 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buffer), + LFS3_RATTR_NULL)) => 0; memset(buffer, 'b', SIZE); lfs3_mdir_t mdir; lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_ATTR(2), 0, - &LFS3_DATA_BUF(buffer, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_ATTR(2), 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buffer), + LFS3_RATTR_NULL)) => 0; // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined assert(lfs3.mtree.r.weight == (1 << lfs3.mbits)); @@ -276,24 +282,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -371,24 +383,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -400,15 +418,19 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // force mdir to compact mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "e", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("e"), + LFS3_RATTR_NULL)) => 0; // assert mdir was split correctly assert(lfs3.mtree.r.weight == (3 << lfs3.mbits)); @@ -517,7 +539,11 @@ code = ''' mdir.r.eoff = -1; } lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name+1), + LFS3_RATTR_ARG(3), + LFS3_RATTR_NULL)) => 0; lfs3_data_t data; uint8_t buffer[256]; @@ -620,7 +646,11 @@ code = ''' mdir.r.eoff = -1; } lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name+1), + LFS3_RATTR_ARG(3), + LFS3_RATTR_NULL)) => 0; lfs3_data_t data; // double check @@ -708,24 +738,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -737,7 +773,8 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 0); // assert mdir was dropped @@ -802,24 +839,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -833,7 +876,8 @@ code = ''' // force mdir to compact while we're removing mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 0); // assert mdir was dropped @@ -898,18 +942,22 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // remove an entry, forcing the mdir to be dropped @@ -920,7 +968,8 @@ code = ''' lfs3.mroot.r.eoff = -1; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // assert split/drop worked out @@ -975,24 +1024,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -1004,9 +1059,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // remove an entry, forcing the mdir to be dropped @@ -1016,7 +1073,8 @@ code = ''' // force mdir to compact while we're removing mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 1); // assert split/drop worked out @@ -1095,24 +1153,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -1124,9 +1188,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // remove an entry, forcing the mdir to be dropped @@ -1136,7 +1202,8 @@ code = ''' // force mdir to compact while we're removing mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 1); // assert split/drop worked out @@ -1242,7 +1309,11 @@ code = ''' mdir.r.eoff = -1; } lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name+1), + LFS3_RATTR_ARG(3), + LFS3_RATTR_NULL)) => 0; lfs3_data_t data; // double check @@ -1271,7 +1342,8 @@ code = ''' mdir.r.eoff = -1; } lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; } } @@ -1350,20 +1422,26 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_ATTR(1), 0, - &LFS3_DATA_BUF(buffer, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_ATTR(1), 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buffer), + LFS3_RATTR_NULL)) => 0; memset(buffer, 'b', SIZE); lfs3_mdir_t mdir; lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_ATTR(2), 0, - &LFS3_DATA_BUF(buffer, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_ATTR(2), 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buffer), + LFS3_RATTR_NULL)) => 0; // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined assert(lfs3.mtree.r.weight == (1 << lfs3.mbits)); @@ -1375,10 +1453,14 @@ code = ''' lfs3_mdir_t old_mdir = mdir; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(4), 0, "d", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("d"), + LFS3_RATTR_NULL)) => 0; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(5), 0, "e", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("e"), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1480,24 +1562,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -1511,10 +1599,14 @@ code = ''' lfs3_mdir_t old_mdir = mdir; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("d"), + LFS3_RATTR_NULL)) => 0; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "e", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("e"), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1620,24 +1712,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -1651,10 +1749,14 @@ code = ''' lfs3_mdir_t old_mdir = mdir; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("d"), + LFS3_RATTR_NULL)) => 0; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "e", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("e"), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1760,19 +1862,25 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // force mroot to compact twice, this should extend the mroot lfs3_mdir_t old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -1843,19 +1951,25 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // force mroot to compact twice, this should extend the mroot lfs3_mdir_t old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -1864,16 +1978,24 @@ code = ''' old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "d", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("d"), + LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(4), 0, "e", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("e"), + LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(5), 0, "f", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("f"), + LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(6), 0, "g", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("g"), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -1981,19 +2103,25 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // force mroot to compact twice, this should extend the mroot lfs3_mdir_t old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "b", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -2001,10 +2129,14 @@ code = ''' old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "d", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("d"), + LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(4), 0, "e", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("e"), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -2092,24 +2224,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -2126,10 +2264,14 @@ code = ''' lfs3_mdir_t old_mdir = mdir; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("d"), + LFS3_RATTR_NULL)) => 0; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "e", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("e"), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated @@ -2237,24 +2379,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -2266,9 +2414,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // setup mroot to compact and relocate on next commit @@ -2278,10 +2428,14 @@ code = ''' lfs3_mdir_t old_mdir = mdir; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "e", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("e"), + LFS3_RATTR_NULL)) => 0; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "f", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("f"), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); // assert mroot relocated @@ -2399,24 +2553,30 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -2433,11 +2593,14 @@ code = ''' // force mdir to compact twice, this should relocate mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(2), 0, "d", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("d"), + LFS3_RATTR_NULL)) => 0; // force mdir to compact while we're removing mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 0); // assert mroot relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -2500,28 +2663,34 @@ code = ''' // force mroot to compact once, so the second compact below will // trigger a relocation lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; lfs3_data_t data; // create a 2 large rattrs that needs to be uninlined uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_ATTR(1), 0, - &LFS3_DATA_BUF(buffer, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_ATTR(1), 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buffer), + LFS3_RATTR_NULL)) => 0; memset(buffer, 'b', SIZE); lfs3_mdir_t mdir; lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_ATTR(2), 0, - &LFS3_DATA_BUF(buffer, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_ATTR(2), 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buffer), + LFS3_RATTR_NULL)) => 0; // force mroot to compact, this should both uninline and relocate lfs3_mdir_t old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(3), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mroot relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -2593,7 +2762,7 @@ code = ''' // force mroot to compact once, so the second compact below will // trigger a relocation lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; lfs3_data_t data; // create 2 large entries that needs to be uninlined and split @@ -2604,25 +2773,31 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact, this should both split and relocate lfs3_mdir_t old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_ATTR(1), 0, "c", 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_NULL)) => 0; // assert mroot relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -2731,7 +2906,11 @@ code = ''' mdir.r.eoff = -1; } lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name+1), + LFS3_RATTR_ARG(3), + LFS3_RATTR_NULL)) => 0; lfs3_data_t data; // double check @@ -2761,7 +2940,11 @@ code = ''' // we can't really change metadata names, but commits still // trigger writes to the mdir lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, 0, 0, name+1, 3))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, 0, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name+1), + LFS3_RATTR_ARG(3), + LFS3_RATTR_NULL)) => 0; lfs3_data_t data; // double check @@ -2790,7 +2973,8 @@ code = ''' mdir.r.eoff = -1; } lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; } } @@ -2864,7 +3048,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &left.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(left.mdir.r.weight == 2); lfs3_handle_open(&lfs3, &left); @@ -2872,7 +3060,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "c", 1, &right.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "c", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("c"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(right.mdir.r.weight == 3); lfs3_handle_open(&lfs3, &right); @@ -2881,7 +3073,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "b", 1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 4); lfs3_data_t data; @@ -2924,7 +3120,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &left.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(left.mdir.r.weight == 2); lfs3_handle_open(&lfs3, &left); @@ -2932,7 +3132,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "b", 1, &right.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(right.mdir.r.weight == 3); lfs3_handle_open(&lfs3, &right); @@ -2941,7 +3145,8 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // assert neighbor was removed @@ -2974,7 +3179,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &left.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(left.mdir.r.weight == 2); lfs3_handle_open(&lfs3, &left); @@ -2982,7 +3191,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "b", 1, &right.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(right.mdir.r.weight == 3); lfs3_handle_open(&lfs3, &right); @@ -2991,7 +3204,8 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "b", 1, &mdir, NULL) => LFS3_TAG_REG; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // assert neighbor was removed @@ -3026,7 +3240,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &left.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(left.mdir.r.weight == 2); lfs3_handle_open(&lfs3, &left); @@ -3034,7 +3252,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "d", 1, &right.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "d", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("d"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(right.mdir.r.weight == 3); lfs3_handle_open(&lfs3, &right); @@ -3046,23 +3268,27 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 4); memset(buffer+1, 'c', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 5); // force mroot to compact lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -3103,7 +3329,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &left.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(left.mdir.r.weight == 2); lfs3_handle_open(&lfs3, &left); @@ -3111,7 +3341,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "e", 1, &right.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "e", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("e"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(right.mdir.r.weight == 3); lfs3_handle_open(&lfs3, &right); @@ -3123,37 +3357,43 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 4); memset(buffer+1, 'd', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 5); // force mroot to compact lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // now add another large entry to an mdir, forcing a split memset(buffer+1, 'c', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 4); // force mdir to compact mdir.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdir was split correctly assert(lfs3.mtree.r.weight == (3 << lfs3.mbits)); @@ -3194,7 +3434,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &left.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(left.mdir.r.weight == 2); lfs3_handle_open(&lfs3, &left); @@ -3202,16 +3446,20 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "b", 1, &right.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "b", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("b"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(right.mdir.r.weight == 3); lfs3_handle_open(&lfs3, &right); // force mroot to compact twice, this should extend the mroot lfs3_mdir_t old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -3252,7 +3500,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &left.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(left.mdir.r.weight == 2); lfs3_handle_open(&lfs3, &left); @@ -3260,7 +3512,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "d", 1, &right.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "d", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("d"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(right.mdir.r.weight == 3); lfs3_handle_open(&lfs3, &right); @@ -3272,23 +3528,27 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 4); memset(buffer+1, 'c', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 5); // force mroot to compact lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -3302,14 +3562,18 @@ code = ''' lfs3_mdir_t old_mdir = mdir; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, 0, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, 0, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, 0, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, 0, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); @@ -3349,7 +3613,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &left.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(left.mdir.r.weight == 2); lfs3_handle_open(&lfs3, &left); @@ -3357,7 +3625,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "d", 1, &right.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "d", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("d"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(right.mdir.r.weight == 3); lfs3_handle_open(&lfs3, &right); @@ -3369,23 +3641,27 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 4); memset(buffer+1, 'c', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 5); // force mroot to compact lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -3399,14 +3675,18 @@ code = ''' lfs3_mdir_t old_mdir = mdir; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, 0, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, 0, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; mdir.r.eoff = -1; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, 0, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, 0, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mdir, &mdir) != 0); @@ -3444,7 +3724,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &left.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(left.mdir.r.weight == 2); lfs3_handle_open(&lfs3, &left); @@ -3452,7 +3736,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "f", 1, &right.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "f", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("f"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(right.mdir.r.weight == 3); lfs3_handle_open(&lfs3, &right); @@ -3464,37 +3752,43 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 4); memset(buffer+1, 'e', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 5); // force mroot to compact lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // now add another large entry to an mdir, forcing a split memset(buffer+1, 'c', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 4); // force mdir to compact mdir.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdir was split correctly assert(lfs3.mtree.r.weight == (3 << lfs3.mbits)); @@ -3506,14 +3800,16 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // force mdir to compact mdir.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdir was split correctly assert(lfs3.mtree.r.weight == (4 << lfs3.mbits)); @@ -3554,7 +3850,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &left.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &left.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(left.mdir.r.weight == 2); lfs3_handle_open(&lfs3, &left); @@ -3562,7 +3862,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "e", 1, &right.mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &right.mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "e", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("e"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(right.mdir.r.weight == 3); lfs3_handle_open(&lfs3, &right); @@ -3574,37 +3878,43 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 4); memset(buffer+1, 'd', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 5); // force mroot to compact lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // now add another large entry to an mdir, forcing a split memset(buffer+1, 'c', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 4); // force mdir to compact mdir.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdir was split correctly assert(lfs3.mtree.r.weight == (3 << lfs3.mbits)); @@ -3613,7 +3923,8 @@ code = ''' // now remove the middle entry, forcing a drop lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 0); // assert mdir was dropped correctly @@ -3658,7 +3969,11 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // test that we can traverse the tree, keeping track of all blocks we see @@ -3764,19 +4079,23 @@ code = ''' uint8_t buffer[SIZE]; memset(buffer, 'a', SIZE); lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_ATTR(1), 0, - &LFS3_DATA_BUF(buffer, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_ATTR(1), 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buffer), + LFS3_RATTR_NULL)) => 0; memset(buffer, 'b', SIZE); lfs3_mdir_t mdir; lfs3_mtree_lookup(&lfs3, 0, &mdir) => 0; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_DATA(LFS3_TAG_ATTR(1), 0, - &LFS3_DATA_BUF(buffer, SIZE)))) => 0; + LFS3_RATTR(3, LFS3_TAG_ATTR(1), 0, LFS3_FROM_DATA), + LFS3_RATTR_ARG(SIZE), + LFS3_RATTR_ARG(buffer), + LFS3_RATTR_NULL)) => 0; // force mroot to compact lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined assert(lfs3.mtree.r.weight == (1 << lfs3.mbits)); @@ -3908,23 +4227,27 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -4060,23 +4383,27 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); memset(buffer+1, 'b', SIZE-1); lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 3); // force mroot to compact lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdirs were unininlined and split assert(lfs3.mtree.r.weight == (2 << lfs3.mbits)); @@ -4088,14 +4415,16 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // force mdir to compact mdir.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &mdir, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert mdir was split correctly assert(lfs3.mtree.r.weight == (3 << lfs3.mbits)); @@ -4241,15 +4570,19 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, "a", 1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, "a", 1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG("a"), + LFS3_RATTR_ARG(1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // force mroot to compact twice, this should extend the mroot lfs3_mdir_t old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -4369,7 +4702,11 @@ code = ''' mdir.r.eoff = -1; } lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name+1), + LFS3_RATTR_ARG(3), + LFS3_RATTR_NULL)) => 0; lfs3_data_t data; uint8_t buffer[256]; @@ -4537,7 +4874,11 @@ code = ''' mdir.r.eoff = -1; } lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME(LFS3_TAG_REG, +1, 0, name+1, 3))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG(name+1), + LFS3_RATTR_ARG(3), + LFS3_RATTR_NULL)) => 0; lfs3_data_t data; // double check @@ -4681,9 +5022,9 @@ code = ''' lfs3_alloc_ckpoint(&lfs3); lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS( - LFS3_RATTR_MPTR( - LFS3_TAG_MROOT, 0, - LFS3_MPTR_MROOTANCHOR()))) => 0; + LFS3_RATTR(2, LFS3_TAG_MROOT, 0, LFS3_FROM_MPTR), + LFS3_RATTR_ARG(LFS3_MPTR_MROOTANCHOR()), + LFS3_RATTR_NULL)) => 0; // technically, cycle detection only needs to work when we're validating lfs3_mtrv_t mtrv; @@ -5009,17 +5350,19 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // force mroot to compact twice, this should extend the mroot lfs3_mdir_t old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -5069,17 +5412,19 @@ code = ''' lfs3_mtree_namelookup(&lfs3, 0, (const char*)buffer+1, SIZE-1, &mdir, NULL) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_NAME( - LFS3_TAG_REG, +1, - 0, (const char*)buffer+1, SIZE-1))) => 0; + LFS3_RATTR(4, LFS3_TAG_REG, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(0), + LFS3_RATTR_ARG((const char*)buffer+1), + LFS3_RATTR_ARG(SIZE-1), + LFS3_RATTR_NULL)) => 0; assert(mdir.r.weight == 2); // force mroot to compact twice, this should extend the mroot lfs3_mdir_t old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); @@ -5087,13 +5432,13 @@ code = ''' // twice, forcing a second mroot extension old_mroot = lfs3.mroot; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; lfs3.mroot.r.eoff = -1; - lfs3_mdir_commit(&lfs3, &lfs3.mroot, NULL, 0) => 0; + lfs3_mdir_commit(&lfs3, &lfs3.mroot, LFS3_RATTRS(LFS3_RATTR_NULL)) => 0; // assert we relocated assert(lfs3_mdir_cmp(&old_mroot, &lfs3.mroot) != 0); diff --git a/tests/test_paths.toml b/tests/test_paths.toml index 0b47187f..18322c3c 100644 --- a/tests/test_paths.toml +++ b/tests/test_paths.toml @@ -4566,50 +4566,56 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/coldbrew"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/turkish"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/tubruk"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/vietnamese"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/thai"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; // stat paths struct lfs3_info info; @@ -4740,50 +4746,56 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coldbrew"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "turkish"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "tubruk"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "vietnamese"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "thai"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; if (DIR) { lfs3_mkdir(&lfs3, "drip/coffee") => LFS3_ERR_NOTDIR; @@ -5036,50 +5048,56 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/coldbrew"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/turkish"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/tubruk"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/vietnamese"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/thai"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; // stat paths struct lfs3_info info; @@ -5278,50 +5296,56 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/coldbrew"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/turkish"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/tubruk"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/vietnamese"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/thai"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; // stat paths struct lfs3_info info; @@ -5520,50 +5544,56 @@ code = ''' lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/coldbrew"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/turkish"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/tubruk"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/vietnamese"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; path = "coffee/thai"; lfs3_mtree_pathlookup(&lfs3, &path, &mdir, &did) => LFS3_ERR_NOENT; lfs3_mdir_commit(&lfs3, &mdir, LFS3_RATTRS( - LFS3_RATTR_CAT( - LFS3_TAG_NAME + 0x13, +1, - lfs3_data_fromleb128(did, (uint8_t[LFS3_LEB128_DSIZE]){0}), - LFS3_DATA_BUF(path, lfs3_path_namelen(path))))) => 0; + LFS3_RATTR(4, LFS3_TAG_NAME + 0x13, +1, LFS3_FROM_NAME), + LFS3_RATTR_ARG(did), + LFS3_RATTR_ARG(path), + LFS3_RATTR_ARG(lfs3_path_namelen(path)), + LFS3_RATTR_NULL)) => 0; // stat paths struct lfs3_info info; diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 158cd0cb..ec10ea9c 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -32,21 +32,20 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -69,22 +68,22 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -107,18 +106,18 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; // fetch lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; // commit with the second attribute lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -144,9 +143,9 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); @@ -169,12 +168,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); @@ -207,12 +205,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); @@ -264,9 +261,9 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); @@ -289,13 +286,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); @@ -328,13 +325,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); @@ -385,9 +382,9 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &data) => LFS3_TAG_ATTR(1); @@ -408,12 +405,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &data) => LFS3_TAG_ATTR(1); @@ -438,12 +434,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &data) => LFS3_TAG_ATTR(1); lfs3_data_read(&lfs3, &data, buffer, 4) => 4; @@ -485,9 +480,9 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &data) => LFS3_TAG_ATTR(1); @@ -508,13 +503,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &data) => LFS3_TAG_ATTR(1); @@ -539,13 +534,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_lookup(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &data) => LFS3_TAG_ATTR(1); lfs3_data_read(&lfs3, &data, buffer, 4) => 4; @@ -591,12 +586,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -617,12 +611,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -662,15 +655,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -691,15 +682,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -741,15 +730,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -777,15 +764,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -832,18 +817,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -871,18 +853,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -910,18 +889,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -949,18 +925,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1009,18 +982,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1055,18 +1025,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1101,18 +1068,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1147,18 +1111,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1212,18 +1173,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1258,18 +1216,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1304,18 +1259,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1350,18 +1302,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1417,21 +1366,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1468,21 +1413,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1517,21 +1458,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1566,21 +1503,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1638,21 +1571,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1696,21 +1625,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1752,21 +1677,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1808,21 +1729,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1885,24 +1802,19 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -1946,24 +1858,19 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -2007,24 +1914,19 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -2089,24 +1991,19 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xff\xff\xff\xff", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xff\xff\xff\xff"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -2155,24 +2052,19 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xff\xff\xff\xff", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xff\xff\xff\xff"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -2221,24 +2113,19 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xff\xff\xff\xff", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xff\xff\xff\xff"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -2319,17 +2206,19 @@ code = ''' printf("] ---\n"); // build the attribute list for the current permutation - struct lfs3_rattr rattrs[N]; + lfs3_rattr_t rattrs[2*N+1]; + lfs3_rattr_t *r = rattrs; for (unsigned j = 0; j < N; j++) { - rattrs[j] = LFS3_RATTR_BUF( - LFS3_TAG_ATTR(perm[j]+1), 0, - "\xaa\xaa\xaa\xaa", 4); + *r++ = LFS3_RATTR(2, LFS3_TAG_ATTR(perm[j]+1), 0, + LFS3_FROM_BUF, 4); + *r++ = LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"); } + *r++ = LFS3_RATTR_NULL; // test the given permutation rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; - lfs3_rbyd_commit(&lfs3, &rbyd, -1, rattrs, N) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, rattrs) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { @@ -2414,9 +2303,10 @@ code = ''' lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(perm[j]+1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(perm[j]+1), 0, + LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; } lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; @@ -2474,12 +2364,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, NULL, &data_); @@ -2512,12 +2401,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, NULL, &data_); @@ -2571,13 +2459,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, NULL, &data_); @@ -2610,13 +2498,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, NULL, &data_); @@ -2688,17 +2576,19 @@ code = ''' printf("] ---\n"); // build the attribute list for the current permutation - struct lfs3_rattr rattrs[N]; + lfs3_rattr_t rattrs[2*N+1]; + lfs3_rattr_t *r = rattrs; for (unsigned j = 0; j < N; j++) { - rattrs[j] = LFS3_RATTR_BUF( - LFS3_TAG_ATTR(perm[j]+1), 0, - "\xaa\xaa\xaa\xaa", 4); + *r++ = LFS3_RATTR(2, LFS3_TAG_ATTR(perm[j]+1), 0, + LFS3_FROM_BUF, 4); + *r++ = LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"); } + *r++ = LFS3_RATTR_NULL; // test the given permutation rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; - lfs3_rbyd_commit(&lfs3, &rbyd, -1, rattrs, N) => 0; + lfs3_rbyd_commit(&lfs3, &rbyd, -1, rattrs) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; // try traversing all tags @@ -2765,9 +2655,10 @@ code = ''' lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(perm[j]+1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(perm[j]+1), 0, + LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; } lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; @@ -2822,9 +2713,9 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(j+1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(j+1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; } // copy block so we can reset after each remove @@ -2864,9 +2755,10 @@ code = ''' // update each tag in permutation order for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(perm[j]+1), 0, - "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(perm[j]+1), 0, + LFS3_FROM_BUF, 6), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; } // check that all tags have been updated @@ -2943,9 +2835,9 @@ code = ''' : (ORDER == 1) ? (((lfs3_size_t)-1) - i) : TEST_PRNG(&prng); int err = lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(x & 0x7f), 0, - "\xaa\xaa\xaa\xaa", 4))); + LFS3_RATTR(2, LFS3_TAG_ATTR(x & 0x7f), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)); if (err == LFS3_ERR_RANGE) { break; } @@ -2995,12 +2887,12 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_) => LFS3_ERR_NOENT; @@ -3017,15 +2909,14 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); @@ -3058,15 +2949,14 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(2), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(2), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); @@ -3144,9 +3034,10 @@ code = ''' lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(perm[j]+1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(perm[j]+1), 0, + LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; } // copy block so we can reset after each remove @@ -3169,8 +3060,8 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(j+1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(j+1), 0), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -3195,9 +3086,9 @@ code = ''' // try appending the tag back to make sure things still work printf("--- append: %d ---\n", j); lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(j+1), 0, - "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(j+1), 0, LFS3_FROM_BUF, 6), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -3291,9 +3182,10 @@ code = ''' lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(perm[j]+1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(perm[j]+1), 0, + LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; } // copy block so we can reset after each remove @@ -3316,8 +3208,8 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(j+1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(j+1), 0), + LFS3_RATTR_NULL)) => 0; // try traversing over the tags lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -3369,12 +3261,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); assert(tag_ == LFS3_TAG_ATTR(2)); @@ -3400,8 +3291,8 @@ code = ''' // try to remove tags that aren't there, this should do nothing lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); assert(tag_ == LFS3_TAG_ATTR(2)); @@ -3426,8 +3317,8 @@ code = ''' &rid_, NULL, &data_) => LFS3_ERR_NOENT; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(3), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(3), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); assert(tag_ == LFS3_TAG_ATTR(2)); @@ -3452,8 +3343,8 @@ code = ''' &rid_, NULL, &data_) => LFS3_ERR_NOENT; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(5), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(5), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); assert(tag_ == LFS3_TAG_ATTR(2)); @@ -3525,29 +3416,23 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; // remove several attributes lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(3), 0), - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(5), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(3), 0), + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(5), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); @@ -3574,8 +3459,8 @@ code = ''' // try to remove tags that aren't there, this should do nothing lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); assert(tag_ == LFS3_TAG_ATTR(2)); @@ -3600,8 +3485,8 @@ code = ''' &rid_, NULL, &data_) => LFS3_ERR_NOENT; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(3), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(3), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); assert(tag_ == LFS3_TAG_ATTR(2)); @@ -3626,8 +3511,8 @@ code = ''' &rid_, NULL, &data_) => LFS3_ERR_NOENT; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(5), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(5), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); assert(tag_ == LFS3_TAG_ATTR(2)); @@ -3654,8 +3539,8 @@ code = ''' // try to remove the tags again, just to make sure (keep in mind // these removes still commit to the rbyd) lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); assert(tag_ == LFS3_TAG_ATTR(2)); @@ -3680,8 +3565,8 @@ code = ''' &rid_, NULL, &data_) => LFS3_ERR_NOENT; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(3), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(3), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); assert(tag_ == LFS3_TAG_ATTR(2)); @@ -3706,8 +3591,8 @@ code = ''' &rid_, NULL, &data_) => LFS3_ERR_NOENT; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(5), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(5), 0), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_); assert(tag_ == LFS3_TAG_ATTR(2)); @@ -3778,12 +3663,12 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_) => LFS3_ERR_NOENT; @@ -3800,17 +3685,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(2), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(2), 0), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_) => LFS3_ERR_NOENT; @@ -3827,17 +3710,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(2), 0), - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(2), 0), + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), &rid_, NULL, &data_) => LFS3_ERR_NOENT; @@ -3887,9 +3768,9 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(j+1), 0, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(j+1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; } // copy block so we can reset after each remove @@ -3929,8 +3810,9 @@ code = ''' // remove each tag in permutation order for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(perm[j]+1), 0))) => 0; + LFS3_RATTR(1, + LFS3_tag_RM | LFS3_TAG_ATTR(perm[j]+1), 0), + LFS3_RATTR_NULL)) => 0; } // check that all tags are now removed @@ -3942,9 +3824,9 @@ code = ''' // try resuming from all tags being removed lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 6), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(1), @@ -4042,16 +3924,16 @@ code = ''' sim[rattr] = 'a'+(i % 26); // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(rattr), 0, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(rattr), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } else { // update our sim sim[rattr] = '\0'; // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(rattr), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(rattr), 0), + LFS3_RATTR_NULL)) => 0; } } @@ -4125,9 +4007,9 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -4146,12 +4028,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -4178,15 +4059,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -4239,9 +4118,9 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -4260,13 +4139,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -4293,13 +4172,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -4326,17 +4205,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -4371,17 +4250,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -4416,17 +4295,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -4525,9 +4404,9 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; @@ -4587,12 +4466,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 00000000, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, NULL, &data_); @@ -4664,13 +4542,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, NULL, &data_); @@ -4719,13 +4597,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, NULL, &data_); @@ -4837,9 +4715,9 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; @@ -4911,7 +4789,9 @@ code = ''' x = x % (rbyd.weight+1); int err = lfs3_rbyd_commit(&lfs3, &rbyd, x, LFS3_RATTRS( - LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, names[x % 6], 4))); + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[x % 6]), + LFS3_RATTR_NULL)); if (err == LFS3_ERR_RANGE) { break; } @@ -4958,12 +4838,11 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -4990,18 +4869,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -5044,24 +4920,19 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -5167,13 +5038,13 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -5200,21 +5071,21 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -5257,21 +5128,21 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -5314,29 +5185,29 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -5424,29 +5295,29 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -5505,29 +5376,29 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -5651,15 +5522,15 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } } @@ -5727,18 +5598,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, NULL, &data_); @@ -5846,21 +5714,21 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, NULL, &data_); @@ -5945,21 +5813,21 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, &rid_, NULL, &data_); @@ -6108,15 +5976,15 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } } @@ -6200,15 +6068,15 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[j % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[j % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; } } @@ -6249,9 +6117,10 @@ code = ''' // update each tag in permutation order for (unsigned j = 0; j < N*M; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, perm[j]/M, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(perm[j]%M+1), 0, - names[(perm[j]/M) % 6], 3))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(perm[j]%M+1), 0, + LFS3_FROM_BUF, 3), + LFS3_RATTR_ARG(names[(perm[j]/M) % 6]), + LFS3_RATTR_NULL)) => 0; } // check that all tags have been updated @@ -6368,15 +6237,15 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } } @@ -6400,8 +6269,9 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j/M, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR((j%M)+1), 0))) => 0; + LFS3_RATTR(1, + LFS3_tag_RM | LFS3_TAG_ATTR((j%M)+1), 0), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -6442,9 +6312,9 @@ code = ''' // try append the tag back to make sure things still work printf("--- append: rid%jd, %jd ---\n", j/M, (j%M)+1); lfs3_rbyd_commit(&lfs3, &rbyd, j/M, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR((j%M)+1), 0, - names[(j/M)%6], 3))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR((j%M)+1), 0, LFS3_FROM_BUF, 3), + LFS3_RATTR_ARG(names[(j/M)%6]), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -6549,15 +6419,15 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[j % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[j % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; } } @@ -6598,8 +6468,9 @@ code = ''' // remove each tag in permutation order for (unsigned j = 0; j < N*M; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, perm[j]/M, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(perm[j]%M+1), 0))) => 0; + LFS3_RATTR(1, + LFS3_tag_RM | LFS3_TAG_ATTR(perm[j]%M+1), 0), + LFS3_RATTR_NULL)) => 0; } // check that all tags have been removed @@ -6690,17 +6561,17 @@ code = ''' // build a single attribute list with all ratibutes, if this fails // it should fail atomically - struct lfs3_rattr rattrs[1+M]; - rattrs[0] = LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[x % 6], 4); + lfs3_rattr_t rattrs[2+2*M+1]; + lfs3_rattr_t *r = rattrs; + *r++ = LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4); + *r++ = LFS3_RATTR_ARG(names[x % 6]); for (unsigned u = 0; u < M; u++) { - rattrs[1+u] = LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[x % 6], 2); + *r++ = LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 2); + *r++ = LFS3_RATTR_ARG(names[x % 6]); } + *r++ = LFS3_RATTR_NULL; - int err = lfs3_rbyd_commit(&lfs3, &rbyd, x, rattrs, 1+M); + int err = lfs3_rbyd_commit(&lfs3, &rbyd, x, rattrs); if (err == LFS3_ERR_RANGE) { break; } @@ -6802,14 +6673,15 @@ code = ''' // note the data size differences here lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(perm[j]+1), 0, - names[perm[j] % 6], 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(perm[j]+1), 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } // try looking up each tag @@ -6950,19 +6822,20 @@ code = ''' // note the data size differences here lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(perm[j]+1), 0, - names[perm[j] % 6], 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(perm[j]+1), 0, + LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } } @@ -7079,14 +6952,14 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7109,14 +6982,14 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7139,17 +7012,16 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7178,17 +7050,16 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7217,17 +7088,16 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7274,20 +7144,18 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7322,20 +7190,18 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7370,26 +7236,22 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7440,26 +7302,22 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7510,26 +7368,22 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7608,67 +7462,50 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow to the root - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7797,9 +7634,9 @@ code = ''' // try to recreate lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -7964,61 +7801,49 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), +1, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), +1, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow to the root - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; // this gets a bit messy as we try to make the rbyd take the right shape lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -8131,9 +7956,9 @@ code = ''' // try to recreate lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -8282,89 +8107,71 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), +1, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), +1, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow to the root - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; // this gets a bit messy as we try to make the rbyd take the right shape lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(8), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(8), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(8), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_ATTR(8), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -8525,9 +8332,9 @@ code = ''' // try to recreate lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -8727,77 +8534,60 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), +1, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(8), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(9), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), +1, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(8), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(9), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow to the root - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(9), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(9), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(9), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(9), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; // this gets a bit messy as we try to make the rbyd take the right shape lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xee\xee\xee\xee", 4), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -8950,9 +8740,9 @@ code = ''' // try to recreate lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -9144,77 +8934,60 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(9), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), +1, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(9), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), +1, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow to the root - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; // this gets a bit messy as we try to make the rbyd take the right shape lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(8), 0, - "\xaa\xaa", 2), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(8), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(8), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(8), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -9367,9 +9140,9 @@ code = ''' // try to recreate lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -9561,78 +9334,62 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), +1, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), +1, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow to the root - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; // this gets a bit messy as we try to make the rbyd take the right shape lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -9769,9 +9526,9 @@ code = ''' // try to recreate lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -9947,78 +9704,62 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), +1, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), +1, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), +1, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), +1, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow to the root - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; // this gets a bit messy as we try to make the rbyd take the right shape lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xcc\xcc\xcc\xcc", 4), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -10155,9 +9896,9 @@ code = ''' // try to recreate lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -10335,119 +10076,94 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), +1, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), +1, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow to the root - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; // this gets a bit messy as we try to make the rbyd take the right shape lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(8), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(11), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(8), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(11), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(12), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(12), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xcc\xcc\xcc\xcc", 4), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(13), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(14), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(13), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(14), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(9), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(10), 0, - "\xaa\xaa", 2), + LFS3_RATTR(2, LFS3_TAG_ATTR(9), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(10), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(10), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(10), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -10640,9 +10356,9 @@ code = ''' // try to recreate lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -10876,117 +10592,90 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xcc\xcc", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(6), +1, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(7), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(8), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(9), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(10), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(6), +1, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(7), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(8), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(9), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(10), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow to the root - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(10), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(10), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(10), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(10), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(10), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(10), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; // this gets a bit messy as we try to make the rbyd take the right shape lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(11), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(12), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(13), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(14), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_ATTR(11), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(12), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(13), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(14), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(14), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(14), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(14), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(14), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, 0, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_DATA, 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(5), 0, - "\xee\xee", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xee\xee", 2), + LFS3_RATTR(2, LFS3_TAG_ATTR(5), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), // propagate yellow - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(4), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(4), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -11179,9 +10868,9 @@ code = ''' // try to recreate lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 3); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -11451,9 +11140,9 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -11477,7 +11166,8 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N-1); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11498,9 +11188,9 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[j % 6], 6))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 6), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11616,15 +11306,15 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } } assert(rbyd.weight == N); @@ -11649,7 +11339,8 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N-1); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11683,14 +11374,14 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[j % 6], 6))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 6), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[j % 6], 3))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 3), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -11819,9 +11510,9 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -11845,7 +11536,8 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -11950,15 +11642,15 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } } assert(rbyd.weight == N); @@ -11983,7 +11675,8 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -12057,11 +11750,12 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -12076,15 +11770,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1), - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -12099,16 +11793,17 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -12123,19 +11818,18 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1), - LFS3_RATTR(LFS3_tag_RM, -1), - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -12150,21 +11844,22 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -12197,14 +11892,14 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -12219,21 +11914,19 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1), - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -12248,22 +11941,21 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -12278,28 +11970,24 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 2, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1), - LFS3_RATTR(LFS3_tag_RM, -1), - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -12314,30 +12002,28 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); lfs3_rbyd_lookup(&lfs3, &rbyd, 0, LFS3_TAG_DATA, @@ -12392,9 +12078,9 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[j % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -12444,7 +12130,8 @@ code = ''' lfs3_size_t rbyd_weight_before = rbyd.weight; lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -12456,9 +12143,9 @@ code = ''' // try resuming from all tags being removed lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 6), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; @@ -12539,15 +12226,15 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[j % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - names[j % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; } } assert(rbyd.weight == N); @@ -12598,7 +12285,8 @@ code = ''' lfs3_size_t rbyd_weight_before = rbyd.weight; lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -12610,14 +12298,14 @@ code = ''' // try resuming from all tags being removed lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa\xaa\xaa", 6))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 6), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; for (unsigned u = 0; u < M; u++) { lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u+1), 0, - "\xaa\xaa\xaa", 3))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u+1), 0, LFS3_FROM_BUF, 3), + LFS3_RATTR_ARG("\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == 1); @@ -12730,16 +12418,17 @@ code = ''' count += 1; // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } else { // update our sim memmove(sim+rid, sim+rid+1, count-rid-1); count -= 1; // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; } } @@ -12805,9 +12494,9 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &weight_, &data_); @@ -12826,9 +12515,10 @@ code = ''' // make id2 with weight w2 lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +2, - "\xbb\xbb\xbb\xbb", 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+2), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &weight_, &data_); @@ -12859,9 +12549,10 @@ code = ''' // make id5 with weight w3 lfs3_rbyd_commit(&lfs3, &rbyd, 3, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +3, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+3), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &weight_, &data_); @@ -12904,9 +12595,10 @@ code = ''' // make id9 with weight w4 lfs3_rbyd_commit(&lfs3, &rbyd, 6, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +4, - "\xdd\xdd\xdd\xdd", 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &weight_, &data_); @@ -12961,9 +12653,10 @@ code = ''' // make id14 with weight w5 lfs3_rbyd_commit(&lfs3, &rbyd, 10, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +5, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+5), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, 0, LFS3_TAG_DATA, &rid_, &weight_, &data_); @@ -13052,25 +12745,25 @@ code = ''' lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( // make id0 with weight w1 - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), // make id2 with weight w2 - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +2, - "\xbb\xbb\xbb\xbb", 4), + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+2), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), // make id5 with weight w3 - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +3, - "\xcc\xcc\xcc\xcc", 4), + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+3), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), // make id9 with weight w4 - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +4, - "\xdd\xdd\xdd\xdd", 4), + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), // make id14 with weight w5 - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +5, - "\xee\xee\xee\xee", 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+5), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR_NULL)) => 0; // traverse, finding tags and weights tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, @@ -13209,9 +12902,10 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; @@ -13300,9 +12994,10 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; @@ -13352,18 +13047,15 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "unrelated", 9), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 9), + LFS3_RATTR_ARG("unrelated"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &weight_, &data_); @@ -13418,17 +13110,14 @@ code = ''' // make id2 with weight w2 lfs3_rbyd_commit(&lfs3, &rbyd, 1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2), - LFS3_RATTR( - LFS3_tag_GROW, +1), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR(1, LFS3_tag_GROW, +1), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &weight_, &data_); @@ -13519,17 +13208,15 @@ code = ''' // make id5 with weight w3 lfs3_rbyd_commit(&lfs3, &rbyd, 3, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2), - LFS3_RATTR( - LFS3_tag_GROW, +2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xcc\xcc", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+2), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &weight_, &data_); @@ -13656,17 +13343,15 @@ code = ''' // make id9 with weight w4 lfs3_rbyd_commit(&lfs3, &rbyd, 6, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xdd\xdd", 2), - LFS3_RATTR( - LFS3_tag_GROW, +3), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xdd\xdd", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xdd\xdd"), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+3), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xdd\xdd"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &weight_, &data_); @@ -13829,17 +13514,15 @@ code = ''' // make id14 with weight w5 lfs3_rbyd_commit(&lfs3, &rbyd, 10, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR( - LFS3_tag_GROW, +4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+4), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, LFS3_TAG_ATTR(3), &rid_, &weight_, &data_); @@ -14059,67 +13742,51 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "unrelated", 9), + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 9), + LFS3_RATTR_ARG("unrelated"), // make id0 with weight w1 - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xaa\xaa", 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xaa\xaa", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xaa\xaa"), // make id2 with weight w2 - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb", 2), - LFS3_RATTR( - LFS3_tag_GROW, +1), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xbb\xbb", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), + LFS3_RATTR(1, LFS3_tag_GROW, +1), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xbb\xbb"), // make id5 with weight w3 - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xcc\xcc", 2), - LFS3_RATTR( - LFS3_tag_GROW, +2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xcc\xcc", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+2), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xcc\xcc"), // make id9 with weight w4 - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xdd\xdd", 2), - LFS3_RATTR( - LFS3_tag_GROW, +3), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xdd\xdd", 2), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xdd\xdd"), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+3), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xdd\xdd"), // make id14 with weight w5 - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xee\xee\xee\xee", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xee\xee", 2), - LFS3_RATTR( - LFS3_tag_GROW, +4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xee\xee", 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xee\xee\xee\xee"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+4), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG("\xee\xee"), + LFS3_RATTR_NULL)) => 0; // traverse, finding tags and weights tag_ = lfs3_rbyd_lookupnext(&lfs3, &rbyd, -1, 0, @@ -14381,9 +14048,9 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "unrelated", 9))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 9), + LFS3_RATTR_ARG("unrelated"), + LFS3_RATTR_NULL)) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -14395,17 +14062,15 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - names[perm[j] % 6], 2), - LFS3_RATTR( - LFS3_tag_GROW, +W-1), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+W-1), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; @@ -14503,9 +14168,9 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(3), 0, - "unrelated", 9))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(3), 0, LFS3_FROM_BUF, 9), + LFS3_RATTR_ARG("unrelated"), + LFS3_RATTR_NULL)) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -14517,17 +14182,15 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - names[perm[j] % 6], 2), - LFS3_RATTR( - LFS3_tag_GROW, +W-1), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+W-1), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], 0) => 0; @@ -14644,9 +14307,10 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N*W); @@ -14670,7 +14334,9 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_GROW, +D))) => 0; + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+D), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N*W+D); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14780,9 +14446,10 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N*W); @@ -14806,9 +14473,11 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_GROW | LFS3_TAG_DATA, +D, - names[j % 6], 6))) => 0; + LFS3_RATTR(3, LFS3_tag_GROW | LFS3_TAG_DATA, -2, + LFS3_FROM_BUF, 6), + LFS3_RATTR_WEIGHT(+D), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N*W+D); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -14930,9 +14599,10 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), +W, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_ATTR(2), -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N*W); @@ -14956,9 +14626,11 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_GROW | LFS3_TAG_ATTR(1), +D, - names[j % 6], 6))) => 0; + LFS3_RATTR(3, LFS3_tag_GROW | LFS3_TAG_ATTR(1), -2, + LFS3_FROM_BUF, 6), + LFS3_RATTR_WEIGHT(+D), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N*W+D); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15091,9 +14763,10 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N*W); @@ -15117,7 +14790,9 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_GROW, -D))) => 0; + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(-D), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N*W-D); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15227,9 +14902,10 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N*W); @@ -15253,9 +14929,11 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_GROW | LFS3_TAG_DATA, -D, - names[j % 6], 6))) => 0; + LFS3_RATTR(3, LFS3_tag_GROW | LFS3_TAG_DATA, -2, + LFS3_FROM_BUF, 6), + LFS3_RATTR_WEIGHT(-D), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N*W-D); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15377,9 +15055,10 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), +W, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_ATTR(2), -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N*W); @@ -15403,9 +15082,11 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_GROW | LFS3_TAG_ATTR(1), -D, - names[j % 6], 6))) => 0; + LFS3_RATTR(3, LFS3_tag_GROW | LFS3_TAG_ATTR(1), -2, + LFS3_FROM_BUF, 6), + LFS3_RATTR_WEIGHT(-D), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N*W-D); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15537,9 +15218,10 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N*W); @@ -15563,7 +15245,9 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -W))) => 0; + LFS3_RATTR(2, LFS3_tag_RM, -2), + LFS3_RATTR_WEIGHT(-W), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == (N-1)*W); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15601,9 +15285,10 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); lfs3_rbyd_commit(&lfs3, &rbyd, j*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - names[j % 6], 6))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 6), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N*W); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15709,9 +15394,10 @@ code = ''' } lfs3_rbyd_commit(&lfs3, &rbyd, rid*W, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +W, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 4), + LFS3_RATTR_WEIGHT(+W), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N*W); @@ -15736,9 +15422,9 @@ code = ''' NULL) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - names[j % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N*W); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15771,8 +15457,8 @@ code = ''' // now try removing the rattr printf("--- removing: %d ---\n", j); lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N*W); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15800,9 +15486,9 @@ code = ''' // and try putting the rattr back just for good measure printf("--- appending: %d ---\n", j); lfs3_rbyd_commit(&lfs3, &rbyd, j*W+W-1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - names[j % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == N*W); lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -15917,32 +15603,33 @@ code = ''' count += 1; // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 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 lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; } else if (op == 2) { // update our sim sim[rid*(M+1) + u+1] = 'a'+(i % 26); // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(u), 0, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(u), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } else if (op == 3) { // update our sim sim[rid*(M+1) + u+1] = '\0'; // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(u), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(u), 0), + LFS3_RATTR_NULL)) => 0; } } @@ -16092,9 +15779,10 @@ code = ''' count += 1; // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, weighted_rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +weight, - &(uint8_t){'a'+(i % 26)}, 1))) => 0; + LFS3_RATTR(3, LFS3_TAG_DATA, -2, LFS3_FROM_BUF, 1), + LFS3_RATTR_WEIGHT(+weight), + LFS3_RATTR_ARG(&(uint8_t){'a'+(i % 26)}), + LFS3_RATTR_NULL)) => 0; } else if (op == 1) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -16105,7 +15793,9 @@ code = ''' count -= 1; // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, weighted_rid+weight_-1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -weight_))) => 0; + LFS3_RATTR(2, LFS3_tag_RM, -2), + LFS3_RATTR_WEIGHT(-weight_), + LFS3_RATTR_NULL)) => 0; } else if (op == 2) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -16113,7 +15803,9 @@ code = ''' sim_weights[rid] += weight; // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, weighted_rid+weight_-1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_GROW, +weight))) => 0; + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(+weight), + LFS3_RATTR_NULL)) => 0; } else if (op == 3) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -16124,7 +15816,9 @@ code = ''' sim_weights[rid] -= weight; // update our rbyd lfs3_rbyd_commit(&lfs3, &rbyd, weighted_rid+weight_-1, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_GROW, -weight))) => 0; + LFS3_RATTR(2, LFS3_tag_GROW, -2), + LFS3_RATTR_WEIGHT(-weight), + LFS3_RATTR_NULL)) => 0; } } @@ -16259,12 +15953,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -16349,12 +16043,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -16379,8 +16073,9 @@ code = ''' // remove with a wide tag lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_tag_MASK8 | LFS3_TAG_ATTR, 0))) => 0; + LFS3_RATTR(1, + LFS3_tag_RM | LFS3_tag_MASK8 | LFS3_TAG_ATTR, 0), + LFS3_RATTR_NULL)) => 0; // try traversing over the tags lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16494,12 +16189,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -16524,10 +16219,11 @@ code = ''' // replace with bitwise inverse lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), - 0, - names[j % 6], 3))) => 0; + LFS3_RATTR(2, + LFS3_tag_MASK8 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, + LFS3_FROM_BUF, 3), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; // try traversing over the tags lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16641,15 +16337,14 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, - names[perm[j] % 6], 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0x80), 0, - names[perm[j] % 6], 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, + LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR(0x80), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -16734,15 +16429,14 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, - names[perm[j] % 6], 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0x80), 0, - names[perm[j] % 6], 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, + LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR(0x80), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -16767,8 +16461,9 @@ code = ''' // remove with a wide tag lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_tag_MASK8 | LFS3_TAG_ATTR, 0))) => 0; + LFS3_RATTR(1, + LFS3_tag_RM | LFS3_tag_MASK8 | LFS3_TAG_ATTR, 0), + LFS3_RATTR_NULL)) => 0; // try traversing over the tags lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -16889,15 +16584,14 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, - names[perm[j] % 6], 2), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0x80), 0, - names[perm[j] % 6], 1))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR(0x7f & (perm[j] + SHIFT)), 0, + LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR(0x80), 0, LFS3_FROM_BUF, 1), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -16922,10 +16616,11 @@ code = ''' // replace with bitwise inverse lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), - 0, - names[j % 6], 3))) => 0; + LFS3_RATTR(2, + LFS3_tag_MASK8 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, + LFS3_FROM_BUF, 3), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; // try traversing over the tags lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -17046,9 +16741,10 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, + LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -17133,9 +16829,10 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, + LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -17160,8 +16857,9 @@ code = ''' // remove with a wide tag lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_tag_MASK8 | LFS3_TAG_ATTR, 0))) => 0; + LFS3_RATTR(1, + LFS3_tag_RM | LFS3_tag_MASK8 | LFS3_TAG_ATTR, 0), + LFS3_RATTR_NULL)) => 0; // try traversing over the tags lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -17278,9 +16976,10 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, - names[perm[j] % 6], 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), +1, + LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -17305,10 +17004,11 @@ code = ''' // replace with bitwise inverse lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), - 0, - names[j % 6], 6))) => 0; + LFS3_RATTR(2, + LFS3_tag_MASK8 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, + LFS3_FROM_BUF, 6), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; // try traversing over the tags lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -17416,12 +17116,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -17505,12 +17205,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -17535,9 +17235,10 @@ code = ''' // remove with a wide tag lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR( + LFS3_RATTR(1, LFS3_tag_RM | LFS3_tag_MASK12 | LFS3_TAG_ATTR, - 0))) => 0; + 0), + LFS3_RATTR_NULL)) => 0; // try traversing over the tags lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -17651,12 +17352,12 @@ code = ''' // give each rattr a subtype based on its rid + SHIFT lfs3_rbyd_commit(&lfs3, &rbyd, rid, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - names[perm[j] % 6], 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, - names[perm[j] % 6], 2))) => 0; + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR(2, LFS3_TAG_ATTR((perm[j] + SHIFT) & 0x7f), 0, + LFS3_FROM_BUF, 2), + LFS3_RATTR_ARG(names[perm[j] % 6]), + LFS3_RATTR_NULL)) => 0; } assert(rbyd.weight == N); @@ -17681,10 +17382,11 @@ code = ''' // replace with bitwise inverse lfs3_rbyd_commit(&lfs3, &rbyd, j, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK12 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), - 0, - names[j % 6], 3))) => 0; + LFS3_RATTR(2, + LFS3_tag_MASK12 | LFS3_TAG_ATTR(~(j + SHIFT) & 0x7f), 0, + LFS3_FROM_BUF, 3), + LFS3_RATTR_ARG(names[j % 6]), + LFS3_RATTR_NULL)) => 0; // try traversing over the tags lfs3_rbyd_fetch(&lfs3, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -17765,14 +17467,12 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(0), 0))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(0), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(0), 0), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -17813,23 +17513,20 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(2), 0, - "\xcc\xcc\xcc\xcc", 4), - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(0), 0))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(0), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(2), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(0), 0), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); // remove a neighbor to the hole lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(1), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(1), 0), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -17870,23 +17567,22 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(0), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(0), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(0), 0), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 2); // delete a neighbor to the hole lfs3_rbyd_commit(&lfs3, &rbyd, 0, LFS3_RATTRS( - LFS3_RATTR(LFS3_tag_RM, -1))) => 0; + LFS3_RATTR(1, LFS3_tag_RM, -1), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); // can we still access things? @@ -17927,24 +17623,22 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0x00), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0x01), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0x80), 0, - "\xdd\xdd\xdd\xdd", 4), - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(0), 0))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(0x00), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(0x01), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_ATTR(0x80), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(0), 0), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); // subwide replace a neighbor to the hole lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK8 | LFS3_TAG_ATTR(0x02), 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK8 | LFS3_TAG_ATTR(0x02), 0, + LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -17994,25 +17688,24 @@ code = ''' rbyd = init_rbyd; lfs3_bd_erase(&lfs3, rbyd.blocks[0]) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(0), 0, - "\xaa\xaa\xaa\xaa", 4), - LFS3_RATTR_BUF( - LFS3_TAG_ATTR(1), 0, - "\xbb\xbb\xbb\xbb", 4), - LFS3_RATTR_BUF( - LFS3_TAG_DATA, +1, - "\xdd\xdd\xdd\xdd", 4))) => 0; + LFS3_RATTR(2, LFS3_TAG_ATTR(0), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xaa\xaa\xaa\xaa"), + LFS3_RATTR(2, LFS3_TAG_ATTR(1), 0, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xbb\xbb\xbb\xbb"), + LFS3_RATTR(2, LFS3_TAG_DATA, +1, LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xdd\xdd\xdd\xdd"), + LFS3_RATTR_NULL)) => 0; lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR( - LFS3_tag_RM | LFS3_TAG_ATTR(0), 0))) => 0; + LFS3_RATTR(1, LFS3_tag_RM | LFS3_TAG_ATTR(0), 0), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); // supwide replace a neighbor to the hole lfs3_rbyd_commit(&lfs3, &rbyd, -1, LFS3_RATTRS( - LFS3_RATTR_BUF( - LFS3_tag_MASK12 | LFS3_TAG_ATTR(2), 0, - "\xcc\xcc\xcc\xcc", 4))) => 0; + LFS3_RATTR(2, LFS3_tag_MASK12 | LFS3_TAG_ATTR(2), 0, + LFS3_FROM_BUF, 4), + LFS3_RATTR_ARG("\xcc\xcc\xcc\xcc"), + LFS3_RATTR_NULL)) => 0; assert(rbyd.weight == 1); // can we still access things?