From 4aabb8f631ac922bb1b83ecf5b03dd235a9f0ee3 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Sun, 15 Jan 2023 14:01:09 -0600 Subject: [PATCH] Reworked tag representation so that sup/sub types have expected order Previously the subtype was encoded above the suptype. This was an issue if you wanted to, say, traverse all tags in a given suptype. I'm not sure yet if this sort of functionality is needed, it may be useful for cleaning up/replacing classes of tags, such as file struct tags, but not sure yet. At the very least is avoids unintuitive tag ordering in the tree, which could potential cause problems for create/deletes. New encoding: tags: iiiiiii iiiiitt ttTTTTT TTT0trv ^----^--------^-^^^- 16-bit id '--------|-'||- 5-bit suptype (split) '--||- 8-bit subtype '|- perturb/remove bit '- valid bit lllllll lllllll lllllll lllllll ^- n-bit length alts: wwwwwww wwwwwww wwwwwww www1dcv ^^^-^- 28-bit weight '|-|- color bit '-|- direction bit '- valid bit jjjjjjj jjjjjjj jjjjjjj jjjjjjj ^- n-bit jump Also a large amount of name changes and other cleanup. --- lfs.c | 643 ++++----- lfs.h | 4 +- scripts/dbgrbyd.py | 85 +- tests/test_rbyd.toml | 2932 +++++++++++++++++++++--------------------- 4 files changed, 1845 insertions(+), 1819 deletions(-) diff --git a/lfs.c b/lfs.c index 3564957a..e8d77582 100644 --- a/lfs.c +++ b/lfs.c @@ -415,193 +415,220 @@ static inline lfs_size_t lfs_tag_dsize(lfs_tag_t tag) { // // in-device, these are effectively 31-bit unsigned integers // on-disk, these are encoded as leb128, so smaller constants are prefered -typedef uint32_t lfs_rtag_t; -typedef int32_t lfs_srtag_t; +typedef uint32_t lfsr_tag_t; +typedef int32_t lfsr_stag_t; -enum lfs_rtag_type1 { - LFS_TYPE1_CREATE = 0x0040, - LFS_TYPE1_CREATEREG = 0x00c0, - LFS_TYPE1_CREATEDIR = 0x0140, - LFS_TYPE1_DELETE = 0x0041, - LFS_TYPE1_STRUCT = 0x0050, - LFS_TYPE1_UATTR = 0x0060, +enum lfsr_tag_type { + LFSR_TAG_MK = 0x0800, + LFSR_TAG_RM = 0x0801, + LFSR_TAG_MKREG = 0x0800, + LFSR_TAG_MKDIR = 0x0808, - LFS_TYPE1_TAIL = 0x0008, - LFS_TYPE1_GSTATE = 0x0010, + LFSR_TAG_UATTR = 0x1000, + LFSR_TAG_RMUATTR = 0x1001, - LFS_TYPE1_CRC = 0x0002, - LFS_TYPE1_FCRC = 0x000a, + LFSR_TAG_CRC = 0x0002, + LFSR_TAG_FCRC = 0x0802, - LFS_TYPE1_RM = 0x0001, - LFS_TYPE1_ALT = 0x0004, + LFSR_TAG_ALT = 0x0004, + LFSR_TAG_ALTBLT = 0x0004, + LFSR_TAG_ALTRLT = 0x0005, + LFSR_TAG_ALTBGT = 0x0006, + LFSR_TAG_ALTRGT = 0x0007, }; -enum lfs_rtag_pat { +#define LFSR_TAG_(type, id) \ + LFSR_TAG2_(type, 0, id) + +#define LFSR_TAG(type, id) \ + LFSR_TAG_(LFSR_TAG_##type, id) + +#define LFSR_TAG2_(suptype, subtype, id) \ + (((0x7fff & (lfsr_tag_t)(suptype)) << 0) \ + | ((0xff & (lfsr_tag_t)(subtype)) << 3) \ + | ((0xffff & (lfsr_tag_t)((id)+1)) << 15)) + +#define LFSR_TAG2(suptype, subtype, id) \ + LFSR_TAG2_(LFSR_TAG_##suptype, subtype, id) + +#define LFSR_ALT_(color, dir, weight) \ + (LFSR_TAG_ALT \ + | ((0x1 & (lfsr_tag_t)(color)) << 0) \ + | ((0x1 & (lfsr_tag_t)(dir)) << 1) \ + | ((0x1ffffff8 & (lfsr_tag_t)(weight)))) + +#define LFSR_ALT(color, dir, weight) \ + (LFSR_TAG_ALT##color##dir \ + | ((0x1ffffff8 & (lfsr_tag_t)(weight)))) + +//enum lfsr_tag_type1 { +// LFS_TYPE1_CREATE = 0x0040, +// LFS_TYPE1_CREATEREG = 0x00c0, +// LFS_TYPE1_CREATEDIR = 0x0140, +// LFS_TYPE1_DELETE = 0x0041, +// LFS_TYPE1_STRUCT = 0x0050, +// LFS_TYPE1_UATTR = 0x0060, +// +// LFS_TYPE1_TAIL = 0x0008, +// LFS_TYPE1_GSTATE = 0x0010, +// +// LFS_TYPE1_CRC = 0x0002, +// LFS_TYPE1_FCRC = 0x000a, +// +// LFS_TYPE1_RM = 0x0001, +// LFS_TYPE1_ALT = 0x0004, +//}; + +enum lfsr_tag_pat { LFS_PAT_GET = 0x0000, LFS_PAT_FIND = 0x0001, }; -#define LFS_ALT_B false -#define LFS_ALT_R true - -#define LFS_ALT_LT false -#define LFS_ALT_GT true - -#define LFS_MKRTAG_(type1, type2, id) \ - (((0x7fff & (lfs_rtag_t)(type1)) << 0) \ - | ((0xff & (lfs_rtag_t)(type2)) << 7) \ - | ((0xffff & (lfs_rtag_t)(id)) << 15)) - -#define LFS_MKRTAG(type1, type2, id) \ - LFS_MKRTAG_(LFS_TYPE1_##type1, type2, id) - -#define LFS_MKRRMTAG_(type1, type2, id) \ - LFS_MKRTAG_(LFS_TYPE1_RM | (type1), type2, id) - -#define LFS_MKRRMTAG(type1, type2, id) \ - LFS_MKRRMTAG_(LFS_TYPE1_##type1, type2, id) - -#define LFS_MKRPATTAG_(pat, type1, type2, id) \ - LFS_MKRTAG_((pat) | (type1), type2, id) - -#define LFS_MKRPATTAG(pat, type1, type2, id) \ - LFS_MKRPATTAG_(LFS_PAT_##pat, type1, type2, id) - -#define LFS_MKRALT_(color, dir, weight) \ - (LFS_TYPE1_ALT \ - | ((0x1 & (lfs_rtag_t)(color)) << 0) \ - | ((0x1 & (lfs_rtag_t)(dir)) << 1) \ - | ((0x1ffffff8 & (lfs_rtag_t)(weight)))) - -#define LFS_MKRALT(color, dir, weight) \ - LFS_MKRALT_(LFS_ALT_##color, LFS_ALT_##dir, weight) +//#define LFS_ALT_B false +//#define LFS_ALT_R true +// +//#define LFS_ALT_LT false +//#define LFS_ALT_GT true +// +//#define LFS_MKRTAG_(type1, type2, id) +// (((0x7fff & (lfsr_tag_t)(type1)) << 0) +// | ((0xff & (lfsr_tag_t)(type2)) << 3) +// | ((0xffff & (lfsr_tag_t)(id)) << 15)) +// +//#define LFS_MKRTAG(type1, type2, id) +// LFS_MKRTAG_(LFSR_TAG_##type1, type2, id) +// +//#define LFS_MKRRMTAG_(type1, type2, id) +// LFS_MKRTAG_((type1) | 0x1, type2, id) +// +//#define LFS_MKRRMTAG(type1, type2, id) +// LFS_MKRRMTAG_(LFSR_TAG_##type1, type2, id) +// +//#define LFS_MKRPATTAG_(pat, type1, type2, id) +// LFS_MKRTAG_((pat) | (type1), type2, id) +// +//#define LFS_MKRPATTAG(pat, type1, type2, id) +// LFS_MKRPATTAG_(LFS_PAT_##pat, type1, type2, id) +// +//#define LFS_MKRALT_(color, dir, weight) +// (LFSR_TAG_ALT +// | ((0x1 & (lfsr_tag_t)(color)) << 0) +// | ((0x1 & (lfsr_tag_t)(dir)) << 1) +// | ((0x1ffffff8 & (lfsr_tag_t)(weight)))) +// +//#define LFS_MKRALT(color, dir, weight) +// LFS_MKRALT_(LFS_ALT_##color, LFS_ALT_##dir, weight) // tag operations -static inline bool lfs_rtag_isvalid(lfs_rtag_t tag) { +static inline bool lfsr_tag_isvalid(lfsr_tag_t tag) { return !(tag & 0x80000000); } -static inline lfs_rtag_t lfs_rtag_valid(lfs_rtag_t tag) { +static inline lfsr_tag_t lfsr_tag_mkvalid(lfsr_tag_t tag) { return tag & ~0x80000000; } -static inline lfs_rtag_t lfs_rtag_invalid(lfs_rtag_t tag) { +static inline lfsr_tag_t lfsr_tag_mkinvalid(lfsr_tag_t tag) { return tag | 0x80000000; } -static inline bool lfs_rtag_isalt(lfs_rtag_t tag) { +static inline bool lfsr_tag_isalt(lfsr_tag_t tag) { return tag & 0x4; } -static inline bool lfs_rtag_intree(lfs_rtag_t tag) { +static inline bool lfsr_tag_intree(lfsr_tag_t tag) { return !(tag & 0x2); } -static inline bool lfs_rtag_isrm(lfs_rtag_t tag) { +static inline bool lfsr_tag_isrm(lfsr_tag_t tag) { return tag & 0x1; } -static inline uint8_t lfs_rtag_type1(lfs_rtag_t tag) { - return tag & 0x7f; +static inline uint16_t lfsr_tag_suptype(lfsr_tag_t tag) { + return tag & 0x7807; } -static inline uint8_t lfs_rtag_type2(lfs_rtag_t tag) { - return (tag >> 7) & 0xff; +static inline uint16_t lfsr_tag_subtype(lfsr_tag_t tag) { + return (tag >> 3) & 0xff; } -static inline uint16_t lfs_rtag_type3(lfs_rtag_t tag) { +static inline uint16_t lfsr_tag_type(lfsr_tag_t tag) { return tag & 0x7fff; } -static inline uint16_t lfs_rtag_id(lfs_rtag_t tag) { - return tag >> 15; +static inline int16_t lfsr_tag_id(lfsr_tag_t tag) { + return (tag >> 15)-1; } -static inline lfs_rtag_t lfs_rtag_setid(lfs_rtag_t tag, uint16_t id) { - return (tag & 0x7fff) | ((lfs_rtag_t)id << 15); -} - -static inline lfs_rtag_t lfs_rtag_incid(lfs_rtag_t tag) { - return tag + (1 << 15); -} - -static inline lfs_rtag_t lfs_rtag_decid(lfs_rtag_t tag) { - return tag - (1 << 15); -} - -static inline lfs_rtag_t lfs_rtag_inc(lfs_rtag_t tag) { +static inline lfsr_tag_t lfsr_tag_next(lfsr_tag_t tag) { return tag + 0x8; } -static inline uint8_t lfs_rtag_pat(lfs_rtag_t tag) { - return tag & 0x7; -} - // alt operations -static inline bool lfs_rtag_isblack(lfs_rtag_t tag) { +static inline bool lfsr_tag_isblack(lfsr_tag_t tag) { return !(tag & 0x1); } -static inline bool lfs_rtag_isred(lfs_rtag_t tag) { +static inline bool lfsr_tag_isred(lfsr_tag_t tag) { return tag & 0x1; } -static inline lfs_rtag_t lfs_rtag_red(lfs_rtag_t tag) { - return tag | 0x1; -} - -static inline lfs_rtag_t lfs_rtag_black(lfs_rtag_t tag) { +static inline lfsr_tag_t lfsr_tag_mkblack(lfsr_tag_t tag) { return tag & ~0x1; } -static inline bool lfs_rtag_islt(lfs_rtag_t tag) { +static inline lfsr_tag_t lfsr_tag_mkred(lfsr_tag_t tag) { + return tag | 0x1; +} + +static inline bool lfsr_tag_islt(lfsr_tag_t tag) { return !(tag & 0x2); } -static inline bool lfs_rtag_isgt(lfs_rtag_t tag) { +static inline bool lfsr_tag_isgt(lfsr_tag_t tag) { return tag & 0x2; } -static inline lfs_rtag_t lfs_rtag_isparallel(lfs_rtag_t a, lfs_rtag_t b) { +static inline lfsr_tag_t lfsr_tag_isparallel(lfsr_tag_t a, lfsr_tag_t b) { return (a & 0x2) == (b & 0x2); } -static inline lfs_rtag_t lfs_rtag_weight(lfs_rtag_t tag) { +static inline lfsr_tag_t lfsr_tag_weight(lfsr_tag_t tag) { return tag & ~0x7; } -static inline bool lfs_rtag_follow(lfs_rtag_t alt, - lfs_rtag_t lower, lfs_rtag_t upper, lfs_rtag_t tag) { - if (lfs_rtag_isgt(alt)) { - return tag >= upper - lfs_rtag_weight(alt); +static inline bool lfsr_tag_follow(lfsr_tag_t alt, + lfsr_tag_t lower, lfsr_tag_t upper, lfsr_tag_t tag) { + if (lfsr_tag_isgt(alt)) { + return tag >= upper - lfsr_tag_weight(alt); } else { - return tag < lower + lfs_rtag_weight(alt); + return tag < lower + lfsr_tag_weight(alt); } } -static inline lfs_rtag_t lfs_rtag_flip(lfs_rtag_t alt, - lfs_rtag_t lower, lfs_rtag_t upper) { - return LFS_MKRALT_( - lfs_rtag_isred(alt), - !lfs_rtag_isgt(alt), - (upper-lower) - lfs_rtag_weight(alt)); +static inline lfsr_tag_t lfsr_tag_flip(lfsr_tag_t alt, + lfsr_tag_t lower, lfsr_tag_t upper) { + return LFSR_ALT_( + lfsr_tag_isred(alt), + !lfsr_tag_isgt(alt), + (upper-lower) - lfsr_tag_weight(alt)); } -static inline void lfs_rtag_trim(lfs_rtag_t alt, - lfs_rtag_t *lower, lfs_rtag_t *upper) { - if (lfs_rtag_isgt(alt)) { - *upper -= lfs_rtag_weight(alt); +static inline void lfsr_tag_trim(lfsr_tag_t alt, + lfsr_tag_t *lower, lfsr_tag_t *upper) { + if (lfsr_tag_isgt(alt)) { + *upper -= lfsr_tag_weight(alt); } else { - *lower += lfs_rtag_weight(alt); + *lower += lfsr_tag_weight(alt); } } -static inline void lfs_rtag_untrim(lfs_rtag_t alt, - lfs_rtag_t *lower, lfs_rtag_t *upper) { - if (lfs_rtag_isgt(alt)) { - *upper += lfs_rtag_weight(alt); +static inline void lfsr_tag_untrim(lfsr_tag_t alt, + lfsr_tag_t *lower, lfsr_tag_t *upper) { + if (lfsr_tag_isgt(alt)) { + *upper += lfsr_tag_weight(alt); } else { - *lower -= lfs_rtag_weight(alt); + *lower -= lfsr_tag_weight(alt); } } @@ -621,29 +648,38 @@ struct lfs_diskoff { sizeof((struct lfs_mattr[]){__VA_ARGS__}) / sizeof(struct lfs_mattr) struct lfs_rattr { - lfs_rtag_t tag; + lfsr_tag_t tag; const void *buffer; lfs_size_t size; const struct lfs_rattr *next; }; -#define LFS_MKRATTR_(...) \ - (&(const struct lfs_rattr){__VA_ARGS__}) +#define LFSR_ATTR_(tag, buffer, size, next) \ + (&(const struct lfs_rattr){tag, buffer, size, next}) -#define LFS_MKRATTR(type1, type2, id, buffer, size, next) \ - (&(const struct lfs_rattr){ \ - LFS_MKRTAG(type1, type2, id), \ - buffer, size, next}) +#define LFSR_ATTR(type, id, buffer, size, next) \ + LFSR_ATTR_(LFSR_TAG(type, id), buffer, size, next) -#define LFS_MKRRMATTR(type1, type2, id, next) \ - (&(const struct lfs_rattr){ \ - LFS_MKRRMTAG(type1, type2, id), \ - NULL, 0, next}) +#define LFSR_ATTR2(suptype, subtype, id, buffer, size, next) \ + LFSR_ATTR_(LFSR_TAG2(suptype, subtype, id), buffer, size, next) + +//#define LFS_MKRATTR_(...) +// (&(const struct lfs_rattr){__VA_ARGS__}) +// +//#define LFS_MKRATTR(type1, type2, id, buffer, size, next) +// (&(const struct lfs_rattr){ +// LFS_MKRTAG(type1, type2, id), +// buffer, size, next}) +// +//#define LFS_MKRRMATTR(type1, type2, id, next) +// (&(const struct lfs_rattr){ +// LFS_MKRRMTAG(type1, type2, id), +// NULL, 0, next}) // operations on pattern lists struct lfs_rpat { - lfs_rtag_t tag; + lfsr_tag_t tag; union { struct { void *buffer; @@ -745,12 +781,12 @@ static void lfs_fcrc_tole32(struct lfs_fcrc *fcrc) { } #endif -struct lfs_rfcrc { +struct lfsr_fcrc { uint32_t crc; lfs_size_t size; }; -static lfs_ssize_t lfs_rfcrc_todisk(struct lfs_rfcrc *fcrc) { +static lfs_ssize_t lfsr_fcrc_todisk(struct lfsr_fcrc *fcrc) { lfs_tole32_(fcrc->crc, &fcrc->crc); lfs_ssize_t delta = lfs_toleb128(fcrc->size, (uint8_t*)&fcrc->size, 4); @@ -761,7 +797,7 @@ static lfs_ssize_t lfs_rfcrc_todisk(struct lfs_rfcrc *fcrc) { return sizeof(uint32_t) + delta; } -static lfs_ssize_t lfs_rfcrc_fromdisk(struct lfs_rfcrc *fcrc) { +static lfs_ssize_t lfsr_fcrc_fromdisk(struct lfsr_fcrc *fcrc) { fcrc->crc = lfs_fromle32_(&fcrc->crc); lfs_ssize_t delta = lfs_fromleb128(&fcrc->size, (uint8_t*)&fcrc->size, 4); @@ -964,10 +1000,10 @@ static int lfs_alloc(lfs_t *lfs, lfs_block_t *block) { /// Red-black-yellow Dhara tree operations /// // TODO actually should this be an lfs_bd_ operation? -static lfs_ssize_t lfs_rbyd_readtag(lfs_t *lfs, +static lfs_ssize_t lfsr_rbyd_readtag(lfs_t *lfs, const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint, lfs_block_t block, lfs_off_t off, - lfs_rtag_t *tag, lfs_size_t *size, uint32_t *crc) { + lfsr_tag_t *tag, lfs_size_t *size, uint32_t *crc) { // needed to quiet an uninitialized warning, zeroing tag on error is // probably a good idea anyways *tag = 0; @@ -1000,7 +1036,7 @@ static lfs_ssize_t lfs_rbyd_readtag(lfs_t *lfs, } } - lfs_rtag_t tag_; + lfsr_tag_t tag_; ssize_t delta = lfs_fromleb128(&tag_, &buffer[i], 4); if (delta < 0) { return delta; @@ -1027,15 +1063,15 @@ static lfs_ssize_t lfs_rbyd_readtag(lfs_t *lfs, return i; } -static int lfs_rbyd_fetch(lfs_t *lfs, - lfs_rbyd_t *rbyd, lfs_block_t block, +static int lfsr_rbyd_fetch(lfs_t *lfs, + lfsr_rbyd_t *rbyd, lfs_block_t block, struct lfs_rpat *patterns) { // TODO this // first mark patterns as invalid until we find matches for (struct lfs_rpat *pattern = patterns; pattern; pattern = pattern->next) { - pattern->tag = lfs_rtag_invalid(pattern->tag); + pattern->tag = lfsr_tag_mkinvalid(pattern->tag); } // read the revision count and get the crc started @@ -1064,13 +1100,13 @@ static int lfs_rbyd_fetch(lfs_t *lfs, // assume unerased until proven otherwise bool maybeerased = false; bool hasfcrc = false; - struct lfs_rfcrc fcrc; + struct lfsr_fcrc fcrc; // scan tags, checking valid bits, crcs, etc while (true) { - lfs_rtag_t tag; + lfsr_tag_t tag; lfs_size_t size; - lfs_ssize_t delta = lfs_rbyd_readtag(lfs, + lfs_ssize_t delta = lfsr_rbyd_readtag(lfs, NULL, &lfs->rcache, lfs->cfg->block_size, block, off, &tag, &size, &crc); if (delta < 0) { @@ -1084,7 +1120,7 @@ static int lfs_rbyd_fetch(lfs_t *lfs, } // found trunk of tree? - if (!wastrunk && (lfs_rtag_isalt(tag) || lfs_rtag_intree(tag))) { + if (!wastrunk && (lfsr_tag_isalt(tag) || lfsr_tag_intree(tag))) { trunk = off; wastrunk = true; } @@ -1092,7 +1128,7 @@ static int lfs_rbyd_fetch(lfs_t *lfs, off += delta; // we mostly just skip alt pointers here - if (lfs_rtag_isalt(tag)) { + if (lfsr_tag_isalt(tag)) { continue; } @@ -1105,7 +1141,7 @@ static int lfs_rbyd_fetch(lfs_t *lfs, } // not an end-of-commit crc - if ((lfs_rtag_type1(tag) & ~0x1) != LFS_TYPE1_CRC) { + if ((lfsr_tag_suptype(tag) & ~0x1) != LFSR_TAG_CRC) { // fcrc is only valid if the last tag was a crc hasfcrc = false; @@ -1121,23 +1157,23 @@ static int lfs_rbyd_fetch(lfs_t *lfs, } // found a create? increase count of ids - if (lfs_rtag_type1(tag) == LFS_TYPE1_CREATE) { + if (lfsr_tag_suptype(tag) == LFSR_TAG_MK) { // TODO put this somewhere? we can't check this here because // we may be reading invalid tags //LFS_ASSERT(count < 0xffff); count += 1; // found a delete? decrease count of ids - } else if (lfs_rtag_type1(tag) == LFS_TYPE1_DELETE) { + } else if (lfsr_tag_suptype(tag) == LFSR_TAG_RM) { // TODO put this somewhere? we can't check this here because // we may be reading invalid tags //LFS_ASSERT(count > 0); count -= 1; // found an fcrc? save for later - } else if (lfs_rtag_type1(tag) == LFS_TYPE1_FCRC) { + } else if (lfsr_tag_suptype(tag) == LFSR_TAG_FCRC) { err = lfs_bd_read(lfs, NULL, &lfs->rcache, lfs->cfg->block_size, block, off, &fcrc, - lfs_min(size, sizeof(struct lfs_rfcrc))); + lfs_min(size, sizeof(struct lfsr_fcrc))); if (err) { if (err == LFS_ERR_CORRUPT) { break; @@ -1145,7 +1181,7 @@ static int lfs_rbyd_fetch(lfs_t *lfs, return err; } - lfs_ssize_t delta = lfs_rfcrc_fromdisk(&fcrc); + lfs_ssize_t delta = lfsr_fcrc_fromdisk(&fcrc); if (delta < 0) { return delta; } @@ -1212,8 +1248,8 @@ static int lfs_rbyd_fetch(lfs_t *lfs, return 0; } -static lfs_srtag_t lfs_rbyd_lookup(lfs_t *lfs, const lfs_rbyd_t *rbyd, - lfs_rtag_t tag, lfs_off_t *off, lfs_size_t *size) { +static lfsr_stag_t lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, + lfsr_tag_t tag, lfs_off_t *off, lfs_size_t *size) { // no trunk yet? lfs_off_t branch = rbyd->trunk; if (!branch) { @@ -1221,14 +1257,14 @@ static lfs_srtag_t lfs_rbyd_lookup(lfs_t *lfs, const lfs_rbyd_t *rbyd, } // keep track of bounds as we descend down the tree - lfs_rtag_t lower = 0; - lfs_rtag_t upper = (rbyd->count+1) << 15; + lfsr_tag_t lower = 0; + lfsr_tag_t upper = (rbyd->count+1) << 15; // descend down tree while (true) { - lfs_rtag_t alt; + lfsr_tag_t alt; lfs_off_t jump; - lfs_ssize_t delta = lfs_rbyd_readtag(lfs, + lfs_ssize_t delta = lfsr_rbyd_readtag(lfs, &lfs->pcache, &lfs->rcache, lfs->cfg->block_size, rbyd->block, branch, &alt, &jump, NULL); if (delta < 0) { @@ -1236,24 +1272,26 @@ static lfs_srtag_t lfs_rbyd_lookup(lfs_t *lfs, const lfs_rbyd_t *rbyd, } // found an alt? - if (lfs_rtag_isalt(alt)) { - if (lfs_rtag_follow(alt, lower, upper, tag)) { - lfs_rtag_trim( - lfs_rtag_flip(alt, lower, upper), + if (lfsr_tag_isalt(alt)) { + if (lfsr_tag_follow(alt, lower, upper, tag)) { + lfsr_tag_trim( + lfsr_tag_flip(alt, lower, upper), &lower, &upper); branch = branch - jump; } else { - lfs_rtag_trim(alt, &lower, &upper); + lfsr_tag_trim(alt, &lower, &upper); branch = branch + delta; } // found end of tree? } else { // update the tag id - lfs_rtag_t tag_ = lfs_rtag_setid(alt, lfs_rtag_id(upper-1)); + lfsr_tag_t tag_ = LFSR_TAG_( + lfsr_tag_type(alt), + lfsr_tag_id(upper-0x8)); // not what we're looking for? - if (tag_ < tag || lfs_rtag_isrm(tag_)) { + if (tag_ < tag || lfsr_tag_isrm(tag_)) { return LFS_ERR_NOENT; } @@ -1266,11 +1304,11 @@ static lfs_srtag_t lfs_rbyd_lookup(lfs_t *lfs, const lfs_rbyd_t *rbyd, } } -static lfs_ssize_t lfs_rbyd_get(lfs_t *lfs, const lfs_rbyd_t *rbyd, - lfs_rtag_t tag, void *buffer, lfs_size_t size) { +static lfs_ssize_t lfsr_rbyd_get(lfs_t *lfs, const lfsr_rbyd_t *rbyd, + lfsr_tag_t tag, void *buffer, lfs_size_t size) { lfs_off_t off_; lfs_size_t size_; - lfs_srtag_t tag_ = lfs_rbyd_lookup(lfs, rbyd, tag, &off_, &size_); + lfsr_stag_t tag_ = lfsr_rbyd_lookup(lfs, rbyd, tag, &off_, &size_); if (tag_ < 0) { return tag_; } @@ -1293,7 +1331,7 @@ static lfs_ssize_t lfs_rbyd_get(lfs_t *lfs, const lfs_rbyd_t *rbyd, return size_; } -static int lfs_rbyd_prog(lfs_t *lfs, lfs_rbyd_t *rbyd_, +static int lfsr_rbyd_prog(lfs_t *lfs, lfsr_rbyd_t *rbyd_, const void *buffer, lfs_size_t size, uint32_t *crc) { // check for out-of-bounds here // TODO should we just move this to lfs_bd_prog? @@ -1313,7 +1351,7 @@ static int lfs_rbyd_prog(lfs_t *lfs, lfs_rbyd_t *rbyd_, rbyd_->off += size; // TODO should this not be optional? should we move the range check // into bd_prog? so we can get rid of the one use of this in - // lfs_rbyd_commit? + // lfsr_rbyd_commit? // optionally crc if (crc) { *crc = lfs_crc32c(*crc, buffer, size); @@ -1322,10 +1360,10 @@ static int lfs_rbyd_prog(lfs_t *lfs, lfs_rbyd_t *rbyd_, return 0; } -static int lfs_rbyd_progtag(lfs_t *lfs, lfs_rbyd_t *rbyd_, - lfs_rtag_t tag, lfs_size_t size, uint32_t *crc) { +static int lfsr_rbyd_progtag(lfs_t *lfs, lfsr_rbyd_t *rbyd_, + lfsr_tag_t tag, lfs_size_t size, uint32_t *crc) { // convert to on-disk repr - LFS_ASSERT(lfs_rtag_isvalid(tag)); + LFS_ASSERT(lfsr_tag_isvalid(tag)); tag <<= 1; // make sure to include the parity of the current crc @@ -1347,7 +1385,7 @@ static int lfs_rbyd_progtag(lfs_t *lfs, lfs_rbyd_t *rbyd_, } delta += delta_; - int err = lfs_rbyd_prog(lfs, rbyd_, &buffer, delta, crc); + int err = lfsr_rbyd_prog(lfs, rbyd_, &buffer, delta, crc); if (err) { return err; } @@ -1355,18 +1393,18 @@ static int lfs_rbyd_progtag(lfs_t *lfs, lfs_rbyd_t *rbyd_, return 0; } -static int lfs_rbyd_p_flush(lfs_t *lfs, lfs_rbyd_t *rbyd_, - lfs_rtag_t p_alts[static 3], - lfs_rtag_t p_jumps[static 3], +static int lfsr_rbyd_p_flush(lfs_t *lfs, lfsr_rbyd_t *rbyd_, + lfsr_tag_t p_alts[static 3], + lfsr_tag_t p_jumps[static 3], unsigned count) { // write out some number of alt pointers in our queue for (unsigned i = 0; i < count; i++) { if (p_alts[3-1-i]) { // change to a relative jump at the last minute - lfs_rtag_t alt = p_alts[3-1-i]; + lfsr_tag_t alt = p_alts[3-1-i]; lfs_off_t jump = rbyd_->off - p_jumps[3-1-i]; - int err = lfs_rbyd_progtag(lfs, rbyd_, alt, jump, &rbyd_->crc); + int err = lfsr_rbyd_progtag(lfs, rbyd_, alt, jump, &rbyd_->crc); if (err) { return err; } @@ -1376,16 +1414,16 @@ static int lfs_rbyd_p_flush(lfs_t *lfs, lfs_rbyd_t *rbyd_, return 0; } -static inline int lfs_rbyd_p_push(lfs_t *lfs, lfs_rbyd_t *rbyd_, - lfs_rtag_t p_alts[static 3], +static inline int lfsr_rbyd_p_push(lfs_t *lfs, lfsr_rbyd_t *rbyd_, + lfsr_tag_t p_alts[static 3], lfs_off_t p_jumps[static 3], - lfs_rtag_t alt, lfs_off_t jump) { - int err = lfs_rbyd_p_flush(lfs, rbyd_, p_alts, p_jumps, 1); + lfsr_tag_t alt, lfs_off_t jump) { + int err = lfsr_rbyd_p_flush(lfs, rbyd_, p_alts, p_jumps, 1); if (err) { return err; } - memmove(p_alts+1, p_alts, 2*sizeof(lfs_rtag_t)); + memmove(p_alts+1, p_alts, 2*sizeof(lfsr_tag_t)); memmove(p_jumps+1, p_jumps, 2*sizeof(lfs_off_t)); p_alts[0] = alt; p_jumps[0] = jump; @@ -1393,43 +1431,43 @@ static inline int lfs_rbyd_p_push(lfs_t *lfs, lfs_rbyd_t *rbyd_, return 0; } -static inline void lfs_rbyd_p_pop( - lfs_rtag_t p_alts[static 3], +static inline void lfsr_rbyd_p_pop( + lfsr_tag_t p_alts[static 3], lfs_off_t p_jumps[static 3]) { - memmove(p_alts, p_alts+1, 2*sizeof(lfs_rtag_t)); + memmove(p_alts, p_alts+1, 2*sizeof(lfsr_tag_t)); memmove(p_jumps, p_jumps+1, 2*sizeof(lfs_off_t)); p_alts[2] = 0; p_jumps[2] = 0; } -static void lfs_rbyd_p_red( - lfs_rtag_t p_alts[static 3], +static void lfsr_rbyd_p_red( + lfsr_tag_t p_alts[static 3], lfs_off_t p_jumps[static 3]) { - LFS_ASSERT(lfs_rtag_isblack(p_alts[0])); + LFS_ASSERT(lfsr_tag_isblack(p_alts[0])); // recolor with red edge if (p_alts[1]) { - p_alts[1] = lfs_rtag_red(p_alts[1]); + p_alts[1] = lfsr_tag_mkred(p_alts[1]); // reorder so that top two edges always go in the same direction - if (p_alts[2] && lfs_rtag_isred(p_alts[2])) { - if (lfs_rtag_isparallel(p_alts[1], p_alts[2])) { + if (p_alts[2] && lfsr_tag_isred(p_alts[2])) { + if (lfsr_tag_isparallel(p_alts[1], p_alts[2])) { // no reorder needed - } else if (lfs_rtag_isparallel(p_alts[0], p_alts[2])) { - lfs_rtag_t alt_ = p_alts[1]; + } else if (lfsr_tag_isparallel(p_alts[0], p_alts[2])) { + lfsr_tag_t alt_ = p_alts[1]; lfs_off_t jump_ = p_jumps[1]; - p_alts[1] = lfs_rtag_red(p_alts[0]); + p_alts[1] = lfsr_tag_mkred(p_alts[0]); p_jumps[1] = p_jumps[0]; - p_alts[0] = lfs_rtag_black(alt_); + p_alts[0] = lfsr_tag_mkblack(alt_); p_jumps[0] = jump_; - } else if (lfs_rtag_isparallel(p_alts[0], p_alts[1])) { - lfs_rtag_t alt_ = p_alts[2]; + } else if (lfsr_tag_isparallel(p_alts[0], p_alts[1])) { + lfsr_tag_t alt_ = p_alts[2]; lfs_off_t jump_ = p_jumps[2]; - p_alts[2] = lfs_rtag_red(p_alts[1]); + p_alts[2] = lfsr_tag_mkred(p_alts[1]); p_jumps[2] = p_jumps[1]; - p_alts[1] = lfs_rtag_red(p_alts[0]); + p_alts[1] = lfsr_tag_mkred(p_alts[0]); p_jumps[1] = p_jumps[0]; - p_alts[0] = lfs_rtag_black(alt_); + p_alts[0] = lfsr_tag_mkblack(alt_); p_jumps[0] = jump_; } else { LFS_ASSERT(false); @@ -1438,11 +1476,14 @@ static void lfs_rbyd_p_red( } } -static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, - lfs_rtag_t tag, const void *buffer, lfs_size_t size) { +static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_, + lfsr_tag_t tag, const void *buffer, lfs_size_t size) { // tags must be in a valid id range at this point - LFS_ASSERT(lfs_rtag_id(tag) < rbyd_->count+1 - + (lfs_rtag_type1(tag) == LFS_TYPE1_CREATE ? 1 : 0)); + if (lfsr_tag_suptype(tag) == LFSR_TAG_MK) { + LFS_ASSERT(lfsr_tag_id(tag) <= rbyd_->count); + } else { + LFS_ASSERT(lfsr_tag_id(tag) < rbyd_->count); + } // assume we'll update our trunk lfs_off_t lower_branch = rbyd_->trunk; @@ -1455,17 +1496,17 @@ static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, } // figure out the range of tags to replace - lfs_rtag_t lower_tag_; - lfs_rtag_t upper_tag_; - if (lfs_rtag_type1(tag) == LFS_TYPE1_CREATE) { + lfsr_tag_t lower_tag_; + lfsr_tag_t upper_tag_; + if (lfsr_tag_suptype(tag) == LFSR_TAG_MK) { LFS_ASSERT(rbyd_->count < 0xffff); lower_tag_ = tag & ~0x7fff; upper_tag_ = lower_tag_; - } else if (lfs_rtag_type1(tag) == LFS_TYPE1_DELETE) { + } else if (lfsr_tag_suptype(tag) == LFSR_TAG_RM) { LFS_ASSERT(rbyd_->count > 0); lower_tag_ = tag & ~0x7fff; upper_tag_ = lower_tag_ + 0x8000; - } else if (lfs_rtag_isrm(tag)) { + } else if (lfsr_tag_isrm(tag)) { lower_tag_ = tag & ~0x1; upper_tag_ = lower_tag_ + 0x8; } else { @@ -1479,13 +1520,13 @@ static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, // track of both the lower and upper bounds of diverging paths // in the case of range deletions bool diverged = false; - lfs_rtag_t lower_lower = 0; - lfs_rtag_t lower_upper = (rbyd_->count+1) << 15; - lfs_rtag_t upper_lower = lower_lower; - lfs_rtag_t upper_upper = lower_upper; + lfsr_tag_t lower_lower = 0; + lfsr_tag_t lower_upper = (rbyd_->count+1) << 15; + lfsr_tag_t upper_lower = lower_lower; + lfsr_tag_t upper_upper = lower_upper; // queue of pending alts we can emulate rotations with - lfs_rtag_t p_alts[3] = {0, 0, 0}; + lfsr_tag_t p_alts[3] = {0, 0, 0}; lfs_off_t p_jumps[3] = {0, 0, 0}; lfs_off_t graft = 0; @@ -1494,7 +1535,7 @@ static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, // do we need to flip bounds? if (diverged && !(upper_tag_ & 0x2) - && (!p_alts[0] || lfs_rtag_isblack(p_alts[0]))) { + && (!p_alts[0] || lfsr_tag_isblack(p_alts[0]))) { lfs_swap(&lower_tag_, &upper_tag_); lfs_swap(&lower_branch, &upper_branch); lfs_swap(&lower_lower, &upper_lower); @@ -1502,9 +1543,9 @@ static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, } // read the alt pointer - lfs_rtag_t alt; + lfsr_tag_t alt; lfs_off_t jump; - lfs_ssize_t delta = lfs_rbyd_readtag(lfs, + lfs_ssize_t delta = lfsr_rbyd_readtag(lfs, &lfs->pcache, &lfs->rcache, lfs->cfg->block_size, rbyd_->block, lower_branch, &alt, &jump, NULL); if (delta < 0) { @@ -1512,16 +1553,16 @@ static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, } // found an alt? - if (lfs_rtag_isalt(alt)) { + if (lfsr_tag_isalt(alt)) { // make jump absolute jump = lower_branch - jump; - lfs_rtag_t branch_ = lower_branch + delta; + lfsr_tag_t branch_ = lower_branch + delta; // do bounds want to take different paths? begin cutting if (!diverged - && lfs_rtag_follow(alt, + && lfsr_tag_follow(alt, lower_lower, lower_upper, lower_tag_) - != lfs_rtag_follow(alt, + != lfsr_tag_follow(alt, lower_lower, lower_upper, upper_tag_)) { diverged = true; upper_branch = lower_branch; @@ -1540,33 +1581,33 @@ static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, // | | .----'| | .----'| | // 1 2 3 4 4 1 2 3 4 4 2 bool prune = false; - if (lfs_rtag_weight(alt) >= (lower_upper-lower_lower)) { + if (lfsr_tag_weight(alt) >= (lower_upper-lower_lower)) { prune = true; // cut while following } else if (diverged - && lfs_rtag_follow(alt, lower_lower, lower_upper, lower_tag_) - && (lower_tag_ < upper_tag_) == lfs_rtag_islt(alt)) { - lfs_rtag_trim( - lfs_rtag_flip(alt, lower_lower, lower_upper), + && lfsr_tag_follow(alt, lower_lower, lower_upper, lower_tag_) + && (lower_tag_ < upper_tag_) == lfsr_tag_islt(alt)) { + lfsr_tag_trim( + lfsr_tag_flip(alt, lower_lower, lower_upper), &lower_lower, &lower_upper); prune = true; // cut while not following } else if (diverged - && !lfs_rtag_follow(alt, lower_lower, lower_upper, lower_tag_) - && (lower_tag_ < upper_tag_) != lfs_rtag_islt(alt)) { - lfs_rtag_trim(alt, &lower_lower, &lower_upper); + && !lfsr_tag_follow(alt, lower_lower, lower_upper, lower_tag_) + && (lower_tag_ < upper_tag_) != lfsr_tag_islt(alt)) { + lfsr_tag_trim(alt, &lower_lower, &lower_upper); lfs_swap(&jump, &branch_); prune = true; } if (prune) { - if (p_alts[0] && lfs_rtag_isred(p_alts[0])) { - alt = lfs_rtag_black(p_alts[0]); + if (p_alts[0] && lfsr_tag_isred(p_alts[0])) { + alt = lfsr_tag_mkblack(p_alts[0]); branch_ = jump; jump = p_jumps[0]; - lfs_rbyd_p_pop(p_alts, p_jumps); + lfsr_rbyd_p_pop(p_alts, p_jumps); - lfs_rtag_untrim(alt, &lower_lower, &lower_upper); + lfsr_tag_untrim(alt, &lower_lower, &lower_upper); } else { lower_branch = jump; continue; @@ -1574,10 +1615,10 @@ static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, } // two reds makes a yellow, split? - if (lfs_rtag_isred(alt) + if (lfsr_tag_isred(alt) && p_alts[0] - && lfs_rtag_isred(p_alts[0])) { - LFS_ASSERT(lfs_rtag_isparallel(alt, p_alts[0])); + && lfsr_tag_isred(p_alts[0])) { + LFS_ASSERT(lfsr_tag_isparallel(alt, p_alts[0])); // if we take the red or yellow alt we can just point // to the black alt @@ -1588,19 +1629,19 @@ static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, // | | b // .-'| => .-'| // 1 2 1 2 1 - if (lfs_rtag_isblack(alt) - && lfs_rtag_follow(alt, + if (lfsr_tag_isblack(alt) + && lfsr_tag_follow(alt, lower_lower, lower_upper, lower_tag_)) { - alt = lfs_rtag_flip(alt, lower_lower, lower_upper); + alt = lfsr_tag_flip(alt, lower_lower, lower_upper); lfs_swap(&jump, &branch_); } @@ -1645,26 +1686,26 @@ static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, // | .-'| .--|-'| // 1 2 3 1 2 3 1 if (p_alts[0] - && lfs_rtag_follow( - p_alts[0] - lfs_rtag_weight(p_alts[0]), + && lfsr_tag_follow( + p_alts[0] - lfsr_tag_weight(p_alts[0]), lower_lower, lower_upper, lower_tag_)) { - LFS_ASSERT(lfs_rtag_isred(p_alts[0])); - LFS_ASSERT(lfs_rtag_isblack(alt)); + LFS_ASSERT(lfsr_tag_isred(p_alts[0])); + LFS_ASSERT(lfsr_tag_isblack(alt)); lfs_swap(&alt, &p_alts[0]); lfs_swap(&jump, &p_jumps[0]); - p_alts[0] = lfs_rtag_red(p_alts[0]); - alt = lfs_rtag_black(alt); + p_alts[0] = lfsr_tag_mkred(p_alts[0]); + alt = lfsr_tag_mkblack(alt); - lfs_rtag_untrim(alt, &lower_lower, &lower_upper); - lfs_rtag_trim(p_alts[0], &lower_lower, &lower_upper); + lfsr_tag_untrim(alt, &lower_lower, &lower_upper); + lfsr_tag_trim(p_alts[0], &lower_lower, &lower_upper); - alt = lfs_rtag_flip(alt, lower_lower, lower_upper); + alt = lfsr_tag_flip(alt, lower_lower, lower_upper); lfs_swap(&jump, &branch_); } // push alt onto queue - int err = lfs_rbyd_p_push(lfs, rbyd_, + int err = lfsr_rbyd_p_push(lfs, rbyd_, p_alts, p_jumps, alt, jump); if (err) { @@ -1672,16 +1713,16 @@ static int lfs_rbyd_append(lfs_t *lfs, lfs_rbyd_t *rbyd_, } // continue to next alt - lfs_rtag_trim(alt, &lower_lower, &lower_upper); + lfsr_tag_trim(alt, &lower_lower, &lower_upper); graft = lower_branch; lower_branch = branch_; // found end of tree? } else { - // update the tag id - lower_tag_ = lfs_rtag_setid(alt, lfs_rtag_id(lower_upper-1)); - // mark as found - lower_tag_ |= 0x2; + // update the tag id, marking as found + lower_tag_ = LFSR_TAG_( + lfsr_tag_type(alt) | 0x2, + lfsr_tag_id(lower_upper-1)); // if we diverged, we also need to find the other bound if (diverged && !(upper_tag_ & 0x2)) { @@ -1710,72 +1751,72 @@ stem:; // split leaf nodes? // - // note we bias the weights here so that lfs_rbyd_lookup + // note we bias the weights here so that lfsr_rbyd_lookup // always finds the next biggest tag - lfs_rtag_t alt = 0; + lfsr_tag_t alt = 0; lfs_off_t jump = 0; - if (lfs_rtag_isrm(lower_tag_)) { + if (lfsr_tag_isrm(lower_tag_)) { // no split needed, prune the removed tag - } else if (lfs_rtag_weight(lower_tag_) < lfs_rtag_weight(tag)) { + } else if (lfsr_tag_weight(lower_tag_) < lfsr_tag_weight(tag)) { // split less than, this is consistent for all appends and only happens // when appending to the end of the tree - alt = LFS_MKRALT(B, LT, - (lfs_rtag_weight(lower_tag_)+0x8) - lower_lower); + alt = LFSR_ALT(B, LT, + (lfsr_tag_weight(lower_tag_)+0x8) - lower_lower); jump = lower_branch; - } else if (lfs_rtag_type1(tag) == LFS_TYPE1_CREATE) { - if (lfs_rtag_weight(upper_tag_) - >= lfs_rtag_weight(tag & ~0x7fff)) { + } else if (lfsr_tag_suptype(tag) == LFSR_TAG_MK) { + if (lfsr_tag_weight(upper_tag_) + >= lfsr_tag_weight(tag & ~0x7fff)) { // increase biased weight when creating - alt = LFS_MKRALT(B, GT, - (upper_upper+0x8000) - (lfs_rtag_weight(tag)+0x8)); + alt = LFSR_ALT(B, GT, + (upper_upper+0x8000) - (lfsr_tag_weight(tag)+0x8)); jump = upper_branch; } - } else if (lfs_rtag_type1(tag) == LFS_TYPE1_DELETE) { - if (lfs_rtag_weight(upper_tag_) - >= lfs_rtag_weight(tag & ~0x7fff)+0x8000) { + } else if (lfsr_tag_suptype(tag) == LFSR_TAG_RM) { + if (lfsr_tag_weight(upper_tag_) + >= lfsr_tag_weight(tag & ~0x7fff)+0x8000) { // decrease biased weight when deleting - alt = LFS_MKRALT(B, GT, + alt = LFSR_ALT(B, GT, upper_upper-0x8000 - lower_lower); jump = upper_branch; } - } else if (lfs_rtag_isrm(tag)) { - if (lfs_rtag_weight(upper_tag_) > lfs_rtag_weight(tag)) { + } else if (lfsr_tag_isrm(tag)) { + if (lfsr_tag_weight(upper_tag_) > lfsr_tag_weight(tag)) { // hide our tag during removes - alt = LFS_MKRALT(B, GT, + alt = LFSR_ALT(B, GT, upper_upper - lower_lower); jump = upper_branch; } } else { - if (lfs_rtag_weight(upper_tag_) > lfs_rtag_weight(tag)) { + if (lfsr_tag_weight(upper_tag_) > lfsr_tag_weight(tag)) { // split greater than - alt = LFS_MKRALT(B, GT, - upper_upper - (lfs_rtag_weight(tag)+0x8)); + alt = LFSR_ALT(B, GT, + upper_upper - (lfsr_tag_weight(tag)+0x8)); jump = upper_branch; } } if (alt) { - int err = lfs_rbyd_p_push(lfs, rbyd_, + int err = lfsr_rbyd_p_push(lfs, rbyd_, p_alts, p_jumps, alt, jump); if (err) { return err; } - if (!lfs_rtag_isrm(tag)) { + if (!lfsr_tag_isrm(tag)) { // introduce a red edge - lfs_rbyd_p_red(p_alts, p_jumps); + lfsr_rbyd_p_red(p_alts, p_jumps); } } // flush any pending alts - int err = lfs_rbyd_p_flush(lfs, rbyd_, + int err = lfsr_rbyd_p_flush(lfs, rbyd_, p_alts, p_jumps, 3); if (err) { return err; @@ -1783,13 +1824,13 @@ stem:; leaf:; // write the tag - err = lfs_rbyd_progtag(lfs, rbyd_, tag, size, &rbyd_->crc); + err = lfsr_rbyd_progtag(lfs, rbyd_, tag, size, &rbyd_->crc); if (err) { return err; } // don't forget the actual data! - err = lfs_rbyd_prog(lfs, rbyd_, buffer, size, &rbyd_->crc); + err = lfsr_rbyd_prog(lfs, rbyd_, buffer, size, &rbyd_->crc); if (err) { return err; } @@ -1800,16 +1841,16 @@ leaf:; // note we do this here since it is possible to insert into an // empty tree // - if (lfs_rtag_type1(tag) == LFS_TYPE1_CREATE) { + if (lfsr_tag_suptype(tag) == LFSR_TAG_MK) { rbyd_->count += 1; - } else if (lfs_rtag_type1(tag) == LFS_TYPE1_DELETE) { + } else if (lfsr_tag_suptype(tag) == LFSR_TAG_RM) { rbyd_->count -= 1; } return 0; } -int lfs_rbyd_commit(lfs_t *lfs, lfs_rbyd_t *rbyd, +int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd, const struct lfs_rattr *attrs) { LFS_ASSERT(rbyd->erased); @@ -1817,13 +1858,13 @@ int lfs_rbyd_commit(lfs_t *lfs, lfs_rbyd_t *rbyd, rbyd->erased = false; // setup commit state - lfs_rbyd_t rbyd_ = *rbyd; + lfsr_rbyd_t rbyd_ = *rbyd; // include revision count? if (!rbyd_.off) { uint32_t rev; lfs_tole32_(rbyd_.rev, &rev); - int err = lfs_rbyd_prog(lfs, &rbyd_, + int err = lfsr_rbyd_prog(lfs, &rbyd_, &rev, sizeof(uint32_t), &rbyd_.crc); if (err) { return err; @@ -1832,7 +1873,7 @@ int lfs_rbyd_commit(lfs_t *lfs, lfs_rbyd_t *rbyd, // append each tag to the tree for (const struct lfs_rattr *attr = attrs; attr; attr = attr->next) { - int err = lfs_rbyd_append(lfs, &rbyd_, + int err = lfsr_rbyd_append(lfs, &rbyd_, attr->tag, attr->buffer, attr->size); if (err) { return err; @@ -1843,7 +1884,7 @@ int lfs_rbyd_commit(lfs_t *lfs, lfs_rbyd_t *rbyd, // // this gets a bit complicated as we have two types of crcs: // - 7-word crc with fcrc to check following prog (middle of block) - // 1-byte fcrc tag + // 2-byte fcrc tag // + 1-byte fcrc len (worst case) // + 4-byte fcrc crc // + 4-byte fcrc crc-len (worst case) @@ -1858,7 +1899,7 @@ int lfs_rbyd_commit(lfs_t *lfs, lfs_rbyd_t *rbyd, // = 9 bytes // const lfs_off_t aligned = lfs_alignup( - rbyd_.off + 1+1+4+4 + 1+4+4, + rbyd_.off + 2+1+4+4 + 1+4+4, lfs->cfg->prog_size); // space for fcrc? @@ -1875,7 +1916,7 @@ int lfs_rbyd_commit(lfs_t *lfs, lfs_rbyd_t *rbyd, // find the expected fcrc, don't bother avoiding a reread of the // perturb byte, as it should still be in our cache - struct lfs_rfcrc fcrc = {.crc=0, .size=lfs->cfg->prog_size}; + struct lfsr_fcrc fcrc = {.crc=0, .size=lfs->cfg->prog_size}; err = lfs_bd_crc32c(lfs, &lfs->pcache, &lfs->rcache, lfs->cfg->prog_size, rbyd_.block, aligned, fcrc.size, &fcrc.crc); @@ -1883,14 +1924,14 @@ int lfs_rbyd_commit(lfs_t *lfs, lfs_rbyd_t *rbyd, return err; } - lfs_size_t fcrc_delta = lfs_rfcrc_todisk(&fcrc); - err = lfs_rbyd_progtag(lfs, &rbyd_, - LFS_MKRTAG(FCRC, 0, 0), fcrc_delta, &rbyd_.crc); + lfs_size_t fcrc_delta = lfsr_fcrc_todisk(&fcrc); + err = lfsr_rbyd_progtag(lfs, &rbyd_, + LFSR_TAG(FCRC, -1), fcrc_delta, &rbyd_.crc); if (err) { return err; } - err = lfs_rbyd_prog(lfs, &rbyd_, + err = lfsr_rbyd_prog(lfs, &rbyd_, &fcrc, fcrc_delta, &rbyd_.crc); if (err) { return err; @@ -1905,7 +1946,7 @@ int lfs_rbyd_commit(lfs_t *lfs, lfs_rbyd_t *rbyd, // get around this catch-22 we just always write a fully-expanded leb128 // encoding uint8_t buffer[1+4+4]; - buffer[0] = (LFS_MKRTAG(CRC, 0, 0) << 1) | (lfs_popc(rbyd_.crc) & 1); + buffer[0] = (LFSR_TAG(CRC, -1) << 1) | (lfs_popc(rbyd_.crc) & 1); lfs_off_t padding = aligned - (rbyd_.off + 1+4); buffer[1] = 0x80 | (0x7f & (padding >> 0)); @@ -1924,7 +1965,7 @@ int lfs_rbyd_commit(lfs_t *lfs, lfs_rbyd_t *rbyd, } lfs_tole32_(rbyd_.crc, &buffer[1+4]); - int err = lfs_rbyd_prog(lfs, &rbyd_, buffer, 1+4+4, NULL); + int err = lfsr_rbyd_prog(lfs, &rbyd_, buffer, 1+4+4, NULL); if (err) { return err; } diff --git a/lfs.h b/lfs.h index e4159f51..991dc68b 100644 --- a/lfs.h +++ b/lfs.h @@ -329,7 +329,7 @@ typedef struct lfs_cache { uint8_t *buffer; } lfs_cache_t; -typedef struct lfs_rbyd { +typedef struct lfsr_rbyd { lfs_block_t block; lfs_off_t trunk; lfs_off_t off; @@ -337,7 +337,7 @@ typedef struct lfs_rbyd { uint32_t crc; uint16_t count; bool erased; -} lfs_rbyd_t; +} lfsr_rbyd_t; typedef struct lfs_mdir { lfs_block_t pair[2]; diff --git a/scripts/dbgrbyd.py b/scripts/dbgrbyd.py index 13120f7a..56c183e1 100755 --- a/scripts/dbgrbyd.py +++ b/scripts/dbgrbyd.py @@ -50,62 +50,47 @@ def xxd(data, width=16, crc=False): for b in map(chr, data[i:i+width]))) def tagrepr(tag, size, off=None): - type1 = tag & 0x7f - type2 = (tag >> 7) & 0xff + type = tag & 0x7fff + suptype = tag & 0x7807 + subtype = (tag >> 3) & 0xff id = (tag >> 15) & 0xffff - if (type1 & 0x7f) == 0x40: - return 'create%s id%d%s' % ( - 'reg' if type2 == 1 - else ' x%02x' % type2, + if suptype == 0x0800: + return 'mk%s id%d%s' % ( + 'reg' if subtype == 0 + else ' x%02x' % subtype, id, - ' %d' % size if not type1 & 0x1 else '') - elif (type1 & 0x7f) == 0x41: - return 'delete%s id%d%s' % ( - ' x%02x' % type2 if type2 else '', + ' %d' % size if not tag & 0x1 else '') + elif suptype == 0x0801: + return 'rm%s id%d%s' % ( + ' x%02x' % subtype if subtype else '', id, - ' %d' % size if not type1 & 0x1 else '') - elif (type1 & 0x7e) == 0x50: - return '%sstruct x%02x id%d%s' % ( - '~' if type1 & 0x1 else '', - type2, - id, - ' %d' % size if not type1 & 0x1 else '') - elif (type1 & 0x7e) == 0x60: + ' %d' % size if not tag & 0x1 else '') + elif (suptype & ~0x1) == 0x1000: return '%suattr x%02x id%d%s' % ( - '~' if type1 & 0x1 else '', - type2, + 'rm' if suptype & 0x1 else '', + subtype, id, - ' %d' % size if not type1 & 0x1 else '') - elif (type1 & 0x7e) == 0x08: - return '%stail%s%s' % ( - '~' if type1 & 0x1 else '', - ' x%02x' % type2 if type2 else '', - ' %d' % size if not type1 & 0x1 else '') - elif (type1 & 0x7e) == 0x10: - return '%sgstate x%02x%s' % ( - '~' if type1 & 0x1 else '', - type2, - ' %d' % size if not type1 & 0x1 else '') - elif (type1 & 0x7e) == 0x02: + ' %d' % size if not tag & 0x1 else '') + elif (suptype & ~0x1) == 0x0002: return 'crc%x%s %d' % ( - type1 >> 3, - ' x%02x' % type2 if type2 else '', + suptype & 0x1, + ' x%02x' % subtype if subtype else '', size) - elif type1 == 0x0a: + elif suptype == 0x0802: return 'fcrc%s %d' % ( - ' x%02x' % type2 if type2 else '', + ' x%02x' % subtype if subtype else '', size) - elif type1 & 0x4: + elif suptype & 0x4: return 'alt%s%s x%x %s' % ( - 'r' if type1 & 1 else 'b', - 'gt' if type1 & 2 else 'lt', + 'r' if suptype & 0x1 else 'b', + 'gt' if suptype & 0x2 else 'lt', tag & ~0x7, 'x%x' % (0xffffffff & (off-size)) if off is not None else '-%d' % off) else: - return 'x%02x x%02x id%d %d' % (type1, type2, id, size) + return 'x%02x id%d %d' % (type, id, size) def main(disk, block_size, block1, block2=None, *, @@ -141,7 +126,7 @@ def main(disk, block_size, block1, block2=None, *, j += delta if not tag & 0x4: - if (tag & 0x7e) != 0x2: + if (tag & 0x7806) != 0x0002: crc = crc32c(data[j:j+size], crc) # found a crc? else: @@ -167,11 +152,7 @@ def main(disk, block_size, block1, block2=None, *, # print contents of the winning metadata block block, data, rev, off = blocks[i], datas[i], revs[i], offs[i] - - # print revision count crc = crc32c(data[0:4]) - if args.get('raw'): - print('%08x: %s' % (0, next(xxd(data[0:4])))) # preprocess jumps if args.get('jumps'): @@ -248,7 +229,7 @@ def main(disk, block_size, block1, block2=None, *, if not tag & 0x4: j += size - if (tag & 0x7f) == 0x40: + if (tag & 0x7807) == 0x0800: count += 1 max_count = max(max_count, count) ids.insert(((tag >> 15) & 0xffff)-1, @@ -265,7 +246,7 @@ def main(disk, block_size, block1, block2=None, *, for id in range(count)) + ' ', count) - elif ((tag & 0x7f) == 0x41 + elif ((tag & 0x7807) == 0x0801 and ((tag >> 15) & 0xffff)-1 < len(ids)): lifetimes[j_] = ( ''.join( @@ -312,6 +293,10 @@ def main(disk, block_size, block1, block2=None, *, 'data (truncated)' if not args.get('no_truncate') else '')) + # print revision count + if args.get('raw'): + print('%8s: %s' % ('%04x' % 0, next(xxd(data[0:4])))) + # print tags j = 4 while j < (block_size if args.get('all') else off): @@ -325,7 +310,7 @@ def main(disk, block_size, block1, block2=None, *, j += delta if not tag & 0x4: - if (tag & 0x7e) != 0x2: + if (tag & 0x7806) != 0x0002: crc = crc32c(data[j:j+size], crc) # found a crc? else: @@ -336,9 +321,9 @@ def main(disk, block_size, block1, block2=None, *, # adjust count? if args.get('lifetimes'): - if (tag & 0x7f) == 0x40: + if (tag & 0x7807) == 0x0800: count += 1 - elif ((tag & 0x7f) == 0x41 + elif ((tag & 0x7807) == 0x0801 and ((tag >> 15) & 0xffff)-1 < len(ids)): count -= 1 diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 3ee189fd..0d482d4f 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -10,7 +10,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -19,28 +19,28 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; // try an empty commit rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, NULL) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; // commit with two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; ''' [cases.test_rbyd_multi_commit] @@ -49,7 +49,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -58,30 +58,30 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; // try an empty commit rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, NULL) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, NULL) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; // commit with two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; ''' [cases.test_rbyd_commit_fetch_commit] @@ -90,7 +90,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -99,19 +99,19 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; // commit with the second attribute - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; ''' # [cases.test_rbyd_fetchmatch] @@ -125,7 +125,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -134,59 +134,59 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; // try an empty commit rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) => LFS_ERR_NOENT; ''' @@ -196,7 +196,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -205,60 +205,60 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; // try an empty commit rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) => LFS_ERR_NOENT; ''' @@ -268,7 +268,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -277,60 +277,60 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; uint8_t buffer[4]; // try an empty commit rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, NULL) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => LFS_ERR_NOENT; // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), buffer, 4) => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => 4; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), buffer, 4) => 4; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => 4; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), buffer, 4) => 4; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), buffer, 4) => LFS_ERR_NOENT; ''' @@ -340,7 +340,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -349,61 +349,61 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; uint8_t buffer[4]; // try an empty commit rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, NULL) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, NULL) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => LFS_ERR_NOENT; // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), buffer, 4) => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => 4; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), buffer, 4) => 4; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), buffer, 4) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), buffer, 4) => 4; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), buffer, 4) => 4; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), buffer, 4) => LFS_ERR_NOENT; ''' @@ -413,7 +413,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -422,10 +422,10 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; - lfs_srtag_t tag; + lfsr_stag_t tag; // traverse requires correct biasing of the weights in the rbyd tree // so that lookups return strictly the tag greater than or equal to @@ -433,23 +433,23 @@ code = ''' rbyd = init_rbyd; rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - tag = lfs_rbyd_lookup(&lfs, &rbyd, 0, &off, &size); - assert(tag == LFS_MKRTAG(UATTR, 1, 0)); - tag = lfs_rbyd_lookup(&lfs, &rbyd, lfs_rtag_inc(tag), &off, &size); - assert(tag == LFS_MKRTAG(UATTR, 2, 0)); - tag = lfs_rbyd_lookup(&lfs, &rbyd, lfs_rtag_inc(tag), &off, &size); + tag = lfsr_rbyd_lookup(&lfs, &rbyd, 0, &off, &size); + assert(tag == LFSR_TAG2(UATTR, 1, -1)); + tag = lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag), &off, &size); + assert(tag == LFSR_TAG2(UATTR, 2, -1)); + tag = lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag), &off, &size); assert(tag == LFS_ERR_NOENT); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - tag = lfs_rbyd_lookup(&lfs, &rbyd, 0, &off, &size); - assert(tag == LFS_MKRTAG(UATTR, 1, 0)); - tag = lfs_rbyd_lookup(&lfs, &rbyd, lfs_rtag_inc(tag), &off, &size); - assert(tag == LFS_MKRTAG(UATTR, 2, 0)); - tag = lfs_rbyd_lookup(&lfs, &rbyd, lfs_rtag_inc(tag), &off, &size); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + tag = lfsr_rbyd_lookup(&lfs, &rbyd, 0, &off, &size); + assert(tag == LFSR_TAG2(UATTR, 1, -1)); + tag = lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag), &off, &size); + assert(tag == LFSR_TAG2(UATTR, 2, -1)); + tag = lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag), &off, &size); assert(tag == LFS_ERR_NOENT); ''' @@ -459,7 +459,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -468,10 +468,10 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; - lfs_srtag_t tag; + lfsr_stag_t tag; // traverse requires correct biasing of the weights in the rbyd tree // so that lookups return strictly the tag greater than or equal to @@ -479,24 +479,24 @@ code = ''' rbyd = init_rbyd; rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; - tag = lfs_rbyd_lookup(&lfs, &rbyd, 0, &off, &size); - assert(tag == LFS_MKRTAG(UATTR, 1, 0)); - tag = lfs_rbyd_lookup(&lfs, &rbyd, lfs_rtag_inc(tag), &off, &size); - assert(tag == LFS_MKRTAG(UATTR, 2, 0)); - tag = lfs_rbyd_lookup(&lfs, &rbyd, lfs_rtag_inc(tag), &off, &size); + tag = lfsr_rbyd_lookup(&lfs, &rbyd, 0, &off, &size); + assert(tag == LFSR_TAG2(UATTR, 1, -1)); + tag = lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag), &off, &size); + assert(tag == LFSR_TAG2(UATTR, 2, -1)); + tag = lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag), &off, &size); assert(tag == LFS_ERR_NOENT); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - tag = lfs_rbyd_lookup(&lfs, &rbyd, 0, &off, &size); - assert(tag == LFS_MKRTAG(UATTR, 1, 0)); - tag = lfs_rbyd_lookup(&lfs, &rbyd, lfs_rtag_inc(tag), &off, &size); - assert(tag == LFS_MKRTAG(UATTR, 2, 0)); - tag = lfs_rbyd_lookup(&lfs, &rbyd, lfs_rtag_inc(tag), &off, &size); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + tag = lfsr_rbyd_lookup(&lfs, &rbyd, 0, &off, &size); + assert(tag == LFSR_TAG2(UATTR, 1, -1)); + tag = lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag), &off, &size); + assert(tag == LFSR_TAG2(UATTR, 2, -1)); + tag = lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag), &off, &size); assert(tag == LFS_ERR_NOENT); ''' @@ -506,7 +506,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -515,7 +515,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -525,15 +525,15 @@ code = ''' // 1 1 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); // split the other direction // >b @@ -541,15 +541,15 @@ code = ''' // 2 2 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); ''' [cases.test_rbyd_bflips] @@ -558,7 +558,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -567,7 +567,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -577,16 +577,16 @@ code = ''' // 1 2 1 2 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL)))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); // flip a black edge // b @@ -594,16 +594,16 @@ code = ''' // 1 2 1 2 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); ''' [cases.test_rbyd_trifoliate] @@ -612,7 +612,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -621,7 +621,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -633,18 +633,18 @@ code = ''' // 1 2 1 2 3 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); // flip a black edge // >r @@ -654,18 +654,18 @@ code = ''' // 2 3 2 3 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); ''' @@ -675,7 +675,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -684,7 +684,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -696,19 +696,19 @@ code = ''' // 1 2 3 1 2 3 3 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); // ignore a red edge, flip a black edge // 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); // flip a red edge and black edge // r @@ -740,19 +740,19 @@ code = ''' // 1 2 3 1 2 3 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); // flip a red edge, ignore a black edge // r @@ -762,19 +762,19 @@ code = ''' // 3 1 2 3 1 2 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); ''' [cases.test_rbyd_quadrifoliate] @@ -783,7 +783,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -792,7 +792,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -806,21 +806,21 @@ code = ''' // 1 2 3 1 2 3 4 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); // ignore a red edge, flip a black edge // y @@ -832,21 +832,21 @@ code = ''' // 1 3 4 1 3 4 2 1 3 4 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); // flip a red edge and black edge // >y @@ -858,21 +858,21 @@ code = ''' // 2 3 4 2 3 4 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); // flip a red edge, ignore a black edge // >y @@ -884,21 +884,21 @@ code = ''' // 4 2 3 4 2 3 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); ''' [cases.test_rbyd_rotations] @@ -907,7 +907,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -916,7 +916,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -930,21 +930,21 @@ code = ''' // 1 2 3 1 2 3 4 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); // yellow and red alt the same // 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); // yellow and black alt the same // 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); // red and black alt the same // >y 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, NULL))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); ''' [cases.test_rbyd_ysplits] @@ -1031,7 +1031,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -1040,7 +1040,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -1056,22 +1056,22 @@ code = ''' // 1 2 3 4 1 2 3 4 4 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, NULL)))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, NULL)))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); // split a yellow triple, taking the black alt // 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, NULL)))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, NULL)))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); // split a yellow triple, taking the red alt // b @@ -1112,22 +1112,22 @@ code = ''' // 1 2 3 4 1 2 3 4 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL)))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL)))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); // split a yellow triple, taking the yellow alt // b @@ -1139,22 +1139,22 @@ code = ''' // 1 2 3 4 1 2 3 4 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); ''' [cases.test_rbyd_quintifoliate] @@ -1163,7 +1163,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -1172,7 +1172,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -1190,24 +1190,24 @@ code = ''' // 1 2 3 4 1 2 3 4 5 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, NULL)))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, NULL)))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) - => LFS_MKRTAG(UATTR, 5, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) + => LFSR_TAG2(UATTR, 5, -1); // split a yellow triple, taking the black alt // 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, NULL)))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, NULL)))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) - => LFS_MKRTAG(UATTR, 5, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) + => LFSR_TAG2(UATTR, 5, -1); // split a yellow triple, taking the red alt // >b @@ -1254,24 +1254,24 @@ code = ''' // 1 3 4 5 1 3 4 5 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL)))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL)))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) - => LFS_MKRTAG(UATTR, 5, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) + => LFSR_TAG2(UATTR, 5, -1); // split a yellow triple, taking the yellow alt // >b @@ -1285,24 +1285,24 @@ code = ''' // 2 3 4 5 2 3 4 5 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) - => LFS_MKRTAG(UATTR, 5, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) + => LFSR_TAG2(UATTR, 5, -1); ''' [cases.test_rbyd_prunes] @@ -1311,7 +1311,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -1320,7 +1320,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -1338,25 +1338,25 @@ code = ''' // 1 2 3 4 5 1 2 3 4 5 5 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, NULL))))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) - => LFS_MKRTAG(UATTR, 5, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) + => LFSR_TAG2(UATTR, 5, -1); // prune by taking a red alt // 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) - => LFS_MKRTAG(UATTR, 5, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) + => LFSR_TAG2(UATTR, 5, -1); // prune by taking a yellow alt (this needs to prune during the rflip) // 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL))))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) - => LFS_MKRTAG(UATTR, 5, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) + => LFSR_TAG2(UATTR, 5, -1); ''' [cases.test_rbyd_sextifoliate] @@ -1433,7 +1433,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -1442,7 +1442,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -1462,27 +1462,27 @@ code = ''' // 1 2 3 4 5 1 2 3 4 5 6 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, - LFS_MKRATTR(UATTR, 6, 0, "\xff\xff\xff\xff", 4, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, + LFSR_ATTR2(UATTR, 6, -1, "\xff\xff\xff\xff", 4, NULL))))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) - => LFS_MKRTAG(UATTR, 5, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 6, 0), &off, &size) - => LFS_MKRTAG(UATTR, 6, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) + => LFSR_TAG2(UATTR, 5, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 6, -1), &off, &size) + => LFSR_TAG2(UATTR, 6, -1); // prune by taking a red alt // b @@ -1498,27 +1498,27 @@ code = ''' // 1 3 4 5 6 1 3 4 5 6 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, - LFS_MKRATTR(UATTR, 6, 0, "\xff\xff\xff\xff", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, + LFSR_ATTR2(UATTR, 6, -1, "\xff\xff\xff\xff", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) - => LFS_MKRTAG(UATTR, 5, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 6, 0), &off, &size) - => LFS_MKRTAG(UATTR, 6, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) + => LFSR_TAG2(UATTR, 5, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 6, -1), &off, &size) + => LFSR_TAG2(UATTR, 6, -1); // prune by taking a yellow alt (this needs to prune during the rflip) // b @@ -1534,27 +1534,27 @@ code = ''' // 2 3 4 5 6 2 3 4 5 6 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, - LFS_MKRATTR(UATTR, 6, 0, "\xff\xff\xff\xff", 4, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, + LFSR_ATTR2(UATTR, 6, -1, "\xff\xff\xff\xff", 4, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL))))))) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 3, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) - => LFS_MKRTAG(UATTR, 5, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 6, 0), &off, &size) - => LFS_MKRTAG(UATTR, 6, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 3, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) + => LFSR_TAG2(UATTR, 5, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 6, -1), &off, &size) + => LFSR_TAG2(UATTR, 6, -1); ''' [cases.test_rbyd_permutations] @@ -1564,7 +1564,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -1573,7 +1573,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -1603,8 +1603,8 @@ code = ''' // build the attribute list for the current permutation struct lfs_rattr attrs[N]; for (unsigned j = 0; j < N; j++) { - attrs[j] = *LFS_MKRATTR( - UATTR, perm[j]+1, 0, + attrs[j] = *LFSR_ATTR2( + UATTR, perm[j]+1, -1, "\xaa\xaa\xaa\xaa", 4, (j+1 < N) ? &attrs[j+1] : NULL); } @@ -1612,13 +1612,13 @@ code = ''' // test the given permutation rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, attrs) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, attrs) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (unsigned j = 0; j < N; j++) { - lfs_rbyd_lookup(&lfs, &rbyd, - LFS_MKRTAG(UATTR, j+1, 0), &off, &size) - => LFS_MKRTAG(UATTR, j+1, 0); + lfsr_rbyd_lookup(&lfs, &rbyd, + LFSR_TAG2(UATTR, j+1, -1), &off, &size) + => LFSR_TAG2(UATTR, j+1, -1); } // keep track of the worst size @@ -1660,7 +1660,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -1669,7 +1669,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -1701,16 +1701,16 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, perm[j]+1, 0, "\xaa\xaa\xaa\xaa", 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, perm[j]+1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; } - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (unsigned j = 0; j < N; j++) { - lfs_rbyd_lookup(&lfs, &rbyd, - LFS_MKRTAG(UATTR, j+1, 0), &off, &size) - => LFS_MKRTAG(UATTR, j+1, 0); + lfsr_rbyd_lookup(&lfs, &rbyd, + LFSR_TAG2(UATTR, j+1, -1), &off, &size) + => LFSR_TAG2(UATTR, j+1, -1); } // keep track of the worst size @@ -1756,7 +1756,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -1765,7 +1765,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -1784,11 +1784,11 @@ code = ''' = (ORDER == 0) ? (uint8_t)i : (ORDER == 1) ? (uint8_t)(((lfs_size_t)-1) - i) : (uint8_t)TEST_PRNG(&prng); - int err = lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, x, 0, "\xaa\xaa\xaa\xaa", 4, + int err = lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, x, -1, "\xaa\xaa\xaa\xaa", 4, NULL)); // if we can't fit an fcrc, erased is set to false, but if we can, - // lfs_rbyd_commit may error later with LFS_ERR_RANGE + // lfsr_rbyd_commit may error later with LFS_ERR_RANGE if (!rbyd.erased || err == LFS_ERR_RANGE) { break; } @@ -1799,15 +1799,15 @@ code = ''' // check that we can still lookup all the tags prng = 42; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (lfs_size_t i = 0; i < count; i++) { uint8_t x = (ORDER == 0) ? (uint8_t)i : (ORDER == 1) ? (uint8_t)(((lfs_size_t)-1) - i) : (uint8_t)TEST_PRNG(&prng); - lfs_rbyd_lookup(&lfs, &rbyd, - LFS_MKRTAG(UATTR, x, 0), &off, &size) - => LFS_MKRTAG(UATTR, x, 0); + lfsr_rbyd_lookup(&lfs, &rbyd, + LFSR_TAG2(UATTR, x, -1), &off, &size) + => LFSR_TAG2(UATTR, x, -1); } ''' @@ -1820,7 +1820,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -1829,75 +1829,75 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; // add and remove one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 1, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 1, -1, NULL, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; // commit with two attributes, remove the first one rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 1, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 1, -1, NULL, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) => LFS_ERR_NOENT; // commit with two attributes, remove the second one rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 2, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 2, -1, NULL, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) => LFS_ERR_NOENT; ''' @@ -1908,7 +1908,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -1917,7 +1917,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -1949,13 +1949,13 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, perm[j]+1, 0, "\xaa\xaa\xaa\xaa", 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, perm[j]+1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; } // copy block so we can reset after each remove - lfs_rbyd_t backup_rbyd = rbyd; + lfsr_rbyd_t backup_rbyd = rbyd; uint8_t backup_block[BLOCK_SIZE]; lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; @@ -1971,21 +1971,21 @@ code = ''' rbyd.block, 0, backup_block, rbyd.off) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, j+1, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, j+1, -1, NULL, 0, NULL)) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (unsigned k = 0; k < N; k++) { - lfs_srtag_t tag = lfs_rbyd_lookup(&lfs, &rbyd, - LFS_MKRTAG(UATTR, k+1, 0), &off, &size); + lfsr_stag_t tag = lfsr_rbyd_lookup(&lfs, &rbyd, + LFSR_TAG2(UATTR, k+1, -1), &off, &size); if (k == j) { if (j == N-1) { assert(tag == LFS_ERR_NOENT); } else { - assert(tag == LFS_MKRTAG(UATTR, j+1+1, 0)); + assert(tag == LFSR_TAG2(UATTR, j+1+1, -1)); } } else { - assert(tag == LFS_MKRTAG(UATTR, k+1, 0)); + assert(tag == LFSR_TAG2(UATTR, k+1, -1)); } } @@ -2028,7 +2028,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -2037,79 +2037,79 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; // create a tree two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, NULL))) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; // try to remove tags that aren't there, this should do nothing - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 1, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 1, -1, NULL, 0, NULL)) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 3, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 3, -1, NULL, 0, NULL)) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 5, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 5, -1, NULL, 0, NULL)) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; // one last fetch to make sure nothing was broken - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; ''' @@ -2119,7 +2119,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -2128,129 +2128,129 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; // create a tree rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 3, 0, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 4, 0, "\xdd\xdd\xdd\xdd", 4, - LFS_MKRATTR(UATTR, 5, 0, "\xee\xee\xee\xee", 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 3, -1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 4, -1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR2(UATTR, 5, -1, "\xee\xee\xee\xee", 4, NULL)))))) => 0; // remove several attributes - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 1, 0, - LFS_MKRRMATTR(UATTR, 3, 0, - LFS_MKRRMATTR(UATTR, 5, 0, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 1, -1, NULL, 0, + LFSR_ATTR2(RMUATTR, 3, -1, NULL, 0, + LFSR_ATTR2(RMUATTR, 5, -1, NULL, 0, NULL)))) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; // try to remove tags that aren't there, this should do nothing - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 1, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 1, -1, NULL, 0, NULL)) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 3, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 3, -1, NULL, 0, NULL)) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 5, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 5, -1, NULL, 0, NULL)) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; // try to remove the tags again, just to make sure (keep in mind // these removes still commit to the rbyd) - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 1, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 1, -1, NULL, 0, NULL)) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 3, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 3, -1, NULL, 0, NULL)) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 5, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 5, -1, NULL, 0, NULL)) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; // one last fetch to make sure nothing was broken - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) - => LFS_MKRTAG(UATTR, 2, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 3, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 4, 0), &off, &size) - => LFS_MKRTAG(UATTR, 4, 0); - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 5, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) + => LFSR_TAG2(UATTR, 2, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 3, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 4, -1), &off, &size) + => LFSR_TAG2(UATTR, 4, -1); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 5, -1), &off, &size) => LFS_ERR_NOENT; ''' @@ -2260,7 +2260,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -2269,69 +2269,69 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; // commit with one attribute, remove it rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 1, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 1, -1, NULL, 0, NULL)) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; // commit with two attributes, remove both rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 1, 0, - LFS_MKRRMATTR(UATTR, 2, 0, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 1, -1, NULL, 0, + LFSR_ATTR2(RMUATTR, 2, -1, NULL, 0, NULL))) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; // commit with two attributes, remove both in the other order rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 2, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, 2, 0, - LFS_MKRRMATTR(UATTR, 1, 0, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 2, -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, 2, -1, NULL, 0, + LFSR_ATTR2(RMUATTR, 1, -1, NULL, 0, NULL))) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 0), &off, &size) + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, -1), &off, &size) => LFS_ERR_NOENT; - lfs_rbyd_lookup(&lfs, &rbyd, LFS_MKRTAG(UATTR, 2, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG2(UATTR, 2, -1), &off, &size) => LFS_ERR_NOENT; ''' @@ -2342,7 +2342,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -2351,7 +2351,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -2363,13 +2363,13 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, j+1, 0, "\xaa\xaa\xaa\xaa", 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, j+1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; } // copy block so we can reset after each remove - lfs_rbyd_t backup_rbyd = rbyd; + lfsr_rbyd_t backup_rbyd = rbyd; uint8_t backup_block[BLOCK_SIZE]; lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; @@ -2403,30 +2403,30 @@ code = ''' // remove each tag in permutation order for (unsigned j = 0; j < N; j++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, perm[j]+1, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, perm[j]+1, -1, NULL, 0, NULL)) => 0; } // check that all tags are now removed - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (unsigned j = 0; j < N; j++) { - lfs_rbyd_lookup(&lfs, &rbyd, - LFS_MKRTAG(UATTR, j+1, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, + LFSR_TAG2(UATTR, j+1, -1), &off, &size) => LFS_ERR_NOENT; } // try resuming from all tags being removed - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, 1, 0, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, 1, -1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, NULL)) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; - lfs_rbyd_lookup(&lfs, &rbyd, - LFS_MKRTAG(UATTR, 1, 0), &off, &size) - => LFS_MKRTAG(UATTR, 1, 0); + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, + LFSR_TAG2(UATTR, 1, -1), &off, &size) + => LFSR_TAG2(UATTR, 1, -1); for (unsigned j = 1; j < N; j++) { - lfs_rbyd_lookup(&lfs, &rbyd, - LFS_MKRTAG(UATTR, j+1, 0), &off, &size) + lfsr_rbyd_lookup(&lfs, &rbyd, + LFSR_TAG2(UATTR, j+1, -1), &off, &size) => LFS_ERR_NOENT; } @@ -2469,7 +2469,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -2478,7 +2478,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; lfs_off_t off; lfs_size_t size; @@ -2510,13 +2510,13 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, perm[j]+1, 0, "\xaa\xaa\xaa\xaa", 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, perm[j]+1, -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; } // copy block so we can reset after each remove - lfs_rbyd_t backup_rbyd = rbyd; + lfsr_rbyd_t backup_rbyd = rbyd; uint8_t backup_block[BLOCK_SIZE]; lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; @@ -2534,31 +2534,31 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // remove - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRRMATTR(UATTR, j+1, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(RMUATTR, j+1, -1, NULL, 0, NULL)) => 0; // try appending each tag to make sure the rbyd tree // is still usable - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, l+1, 0, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, l+1, -1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, NULL)) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (unsigned k = 0; k < N; k++) { - lfs_srtag_t tag = lfs_rbyd_lookup(&lfs, &rbyd, - LFS_MKRTAG(UATTR, k+1, 0), &off, &size); + lfsr_stag_t tag = lfsr_rbyd_lookup(&lfs, &rbyd, + LFSR_TAG2(UATTR, k+1, -1), &off, &size); if (k == l) { - assert(tag == LFS_MKRTAG(UATTR, l+1, 0)); + assert(tag == LFSR_TAG2(UATTR, l+1, -1)); assert(size == 6); } else if (k == j) { if (j == N-1) { assert(tag == LFS_ERR_NOENT); } else { - assert(tag == LFS_MKRTAG(UATTR, j+1+1, 0)); + assert(tag == LFSR_TAG2(UATTR, j+1+1, -1)); } } else { - assert(tag == LFS_MKRTAG(UATTR, k+1, 0)); + assert(tag == LFSR_TAG2(UATTR, k+1, -1)); assert(size == 4); } } @@ -2606,7 +2606,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -2615,139 +2615,139 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; uint8_t buffer[4]; // try to create one id rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); // try to create two ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // try to create two in the other direction rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // create a third to the right rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); // create a third to the left rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)))) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); // create a third in the middle rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL)))) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); ''' @@ -2757,7 +2757,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -2766,147 +2766,147 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; uint8_t buffer[4]; // try to create one id rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); // try to create two ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // try to create two in the other direction rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // create a third to the right rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); // create a third to the left rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 2, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); // create a third in the middle rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 2, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 3); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); ''' @@ -2917,7 +2917,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -2926,7 +2926,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -2971,8 +2971,8 @@ code = ''' } } - attrs[j] = *LFS_MKRATTR( - CREATEREG, 0, id+1, + attrs[j] = *LFSR_ATTR( + MKREG, id, names[perm[j] % 6], 4, (j+1 < N) ? &attrs[j+1] : NULL); } @@ -2980,13 +2980,13 @@ code = ''' // test the given permutation rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, attrs) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, attrs) => 0; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == N); for (unsigned j = 0; j < N; j++) { - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, j+1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, j), buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } @@ -3029,7 +3029,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -3038,7 +3038,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -3085,16 +3085,16 @@ code = ''' } } - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, id+1, names[perm[j] % 6], 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, NULL)) => 0; } - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == N); for (unsigned j = 0; j < N; j++) { - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, j+1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, j), buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } @@ -3141,7 +3141,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -3150,7 +3150,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -3178,10 +3178,10 @@ code = ''' : (uint16_t)TEST_PRNG(&prng); x = x % (rbyd.count+1); - int err = lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, x+1, names[x % 6], 4, NULL)); + int err = lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, x, names[x % 6], 4, NULL)); // if we can't fit an fcrc, erased is set to false, but if we can, - // lfs_rbyd_commit may error later with LFS_ERR_RANGE + // lfsr_rbyd_commit may error later with LFS_ERR_RANGE if (!rbyd.erased || err == LFS_ERR_RANGE) { break; } @@ -3191,11 +3191,11 @@ code = ''' // check that we can at least lookup all the tags lfs_off_t off; lfs_size_t size; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (uint16_t x = 0; x < rbyd.count; x++) { - lfs_rbyd_lookup(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, x+1), &off, &size) - => LFS_MKRTAG(CREATEREG, 0, x+1); + lfsr_rbyd_lookup(&lfs, &rbyd, + LFSR_TAG(MKREG, x), &off, &size) + => LFSR_TAG(MKREG, x); } ''' @@ -3208,7 +3208,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -3217,148 +3217,148 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; uint8_t buffer[4]; // try to delete one id rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 2, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 1, NULL, 0, NULL)) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => LFS_ERR_NOENT; // try to delete the other id rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => LFS_ERR_NOENT; // try to delete the largest of three rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 3, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 2, NULL, 0, NULL)) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; // try to delete the smallest of three rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; // try to delete the middle rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 2, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 1, NULL, 0, NULL)) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; ''' @@ -3368,7 +3368,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -3377,229 +3377,229 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; uint8_t buffer[4]; // try to delete one id rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xaa\xaa", 2, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 2, "\xbb\xbb", 2, NULL))))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 2, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(MKREG, 0, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 1, 0, "\xaa\xaa", 2, + LFSR_ATTR2(MKREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, 1, "\xbb\xbb", 2, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 1, NULL, 0, NULL)) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 0), buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 0), buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 1), buffer, 4) => LFS_ERR_NOENT; // try to delete the other id rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xaa\xaa", 2, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 2, "\xbb\xbb", 2, NULL))))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(MKREG, 0, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 1, 0, "\xaa\xaa", 2, + LFSR_ATTR2(MKREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, 1, "\xbb\xbb", 2, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 0), buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 0), buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 1), buffer, 4) => LFS_ERR_NOENT; // try to delete the largest of three rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xaa\xaa", 2, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 2, "\xbb\xbb", 2, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 1, 3, "\xcc\xcc", 2, NULL))))))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 3, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(MKREG, 0, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 1, 0, "\xaa\xaa", 2, + LFSR_ATTR2(MKREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, 1, "\xbb\xbb", 2, + LFSR_ATTR2(MKREG, 0, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 1, 2, "\xcc\xcc", 2, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 2, NULL, 0, NULL)) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 0), buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 1), buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 0), buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 1), buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 2), buffer, 4) => LFS_ERR_NOENT; // try to delete the smallest of three rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xaa\xaa", 2, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 2, "\xbb\xbb", 2, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 1, 3, "\xcc\xcc", 2, NULL))))))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(MKREG, 0, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 1, 0, "\xaa\xaa", 2, + LFSR_ATTR2(MKREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, 1, "\xbb\xbb", 2, + LFSR_ATTR2(MKREG, 0, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 1, 2, "\xcc\xcc", 2, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 0), buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 0), buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 2), buffer, 4) => LFS_ERR_NOENT; // try to delete the middle rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xaa\xaa", 2, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 2, "\xbb\xbb", 2, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 1, 3, "\xcc\xcc", 2, NULL))))))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 2, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(MKREG, 0, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 1, 0, "\xaa\xaa", 2, + LFSR_ATTR2(MKREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, 1, "\xbb\xbb", 2, + LFSR_ATTR2(MKREG, 0, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 1, 2, "\xcc\xcc", 2, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 1, NULL, 0, NULL)) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 0), buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 2); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 0), buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 1), buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 2), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 2), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(UATTR, 1, 3), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG2(UATTR, 1, 2), buffer, 4) => LFS_ERR_NOENT; ''' @@ -3610,7 +3610,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -3619,7 +3619,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -3666,14 +3666,14 @@ code = ''' } } - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, id+1, names[perm[j] % 6], 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.count == N); // copy block so we can reset after each delete - lfs_rbyd_t backup_rbyd = rbyd; + lfsr_rbyd_t backup_rbyd = rbyd; uint8_t backup_block[BLOCK_SIZE]; lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; @@ -3689,22 +3689,22 @@ code = ''' rbyd.block, 0, backup_block, rbyd.off) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, j+1, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, j, NULL, 0, NULL)) => 0; assert(rbyd.count == N-1); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (unsigned k = 0; k < N-1; k++) { - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, k+1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, k), buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { assert(memcmp(buffer, names[k % 6], 4) == 0); } } - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, N-1+1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, N-1), buffer, 4) => LFS_ERR_NOENT; // keep track of the worst size @@ -3748,7 +3748,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -3757,7 +3757,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -3804,20 +3804,20 @@ code = ''' } } - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, id+1, names[perm[j] % 6], 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, u+1, id+1, names[perm[j] % 6], 2, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, u+1, id, names[perm[j] % 6], 2, NULL)) => 0; } } assert(rbyd.count == N); // copy block so we can reset after each delete - lfs_rbyd_t backup_rbyd = rbyd; + lfsr_rbyd_t backup_rbyd = rbyd; uint8_t backup_block[BLOCK_SIZE]; lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; @@ -3833,14 +3833,14 @@ code = ''' rbyd.block, 0, backup_block, rbyd.off) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, j+1, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, j, NULL, 0, NULL)) => 0; assert(rbyd.count == N-1); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (unsigned k = 0; k < N-1; k++) { - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, k+1), buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, k), buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { @@ -3848,8 +3848,8 @@ code = ''' } for (unsigned u = 0; u < M; u++) { - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(UATTR, u+1, k+1), buffer, 4) => 2; + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG2(UATTR, u+1, k), buffer, 4) => 2; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 2) == 0); } else { @@ -3857,11 +3857,11 @@ code = ''' } } } - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, N-1+1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, N-1), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(UATTR, 1, N-1+1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG2(UATTR, 1, N-1), buffer, 4) => LFS_ERR_NOENT; // keep track of the worst size @@ -3903,7 +3903,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -3912,104 +3912,104 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; uint8_t buffer[4]; // create and delete one id rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; // create and delete two ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 0, NULL, 0, + LFSR_ATTR(RM, 0, NULL, 0, NULL))) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; // create and delete two ids in the other order rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 2, NULL, 0, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 1, NULL, 0, + LFSR_ATTR(RM, 0, NULL, 0, NULL))) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; // create and delete three ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 0, NULL, 0, + LFSR_ATTR(RM, 0, NULL, 0, + LFSR_ATTR(RM, 0, NULL, 0, NULL)))) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; // create and delete three ids in the other order rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 3, NULL, 0, - LFS_MKRATTR(DELETE, 0, 2, NULL, 0, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 2, NULL, 0, + LFSR_ATTR(RM, 1, NULL, 0, + LFSR_ATTR(RM, 0, NULL, 0, NULL)))) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; ''' @@ -4019,7 +4019,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -4028,115 +4028,115 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; uint8_t buffer[4]; // create and delete one id rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xaa\xaa", 2, NULL))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(MKREG, 0, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 1, 0, "\xaa\xaa", 2, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; // create and delete two ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xaa\xaa", 2, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xbb\xbb", 2, NULL))))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(MKREG, 0, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 1, 0, "\xaa\xaa", 2, + LFSR_ATTR2(MKREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, 1, "\xbb\xbb", 2, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 0, NULL, 0, + LFSR_ATTR(RM, 0, NULL, 0, NULL))) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; // create and delete two ids in the other order rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xaa\xaa", 2, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xbb\xbb", 2, NULL))))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 2, NULL, 0, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(MKREG, 0, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 1, 0, "\xaa\xaa", 2, + LFSR_ATTR2(MKREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, 1, "\xbb\xbb", 2, NULL))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 1, NULL, 0, + LFSR_ATTR(RM, 0, NULL, 0, NULL))) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; // create and delete three ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xaa\xaa", 2, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xbb\xbb", 2, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xcc\xcc", 2, NULL))))))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(MKREG, 0, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 1, 0, "\xaa\xaa", 2, + LFSR_ATTR2(MKREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, 1, "\xbb\xbb", 2, + LFSR_ATTR2(MKREG, 0, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 1, 2, "\xcc\xcc", 2, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 0, NULL, 0, + LFSR_ATTR(RM, 0, NULL, 0, + LFSR_ATTR(RM, 0, NULL, 0, NULL)))) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; // create and delete three ids in the other order rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xaa\xaa", 2, - LFS_MKRATTR(CREATEREG, 0, 2, "\xbb\xbb\xbb\xbb", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xbb\xbb", 2, - LFS_MKRATTR(CREATEREG, 0, 3, "\xcc\xcc\xcc\xcc", 4, - LFS_MKRATTR(UATTR, 1, 1, "\xcc\xcc", 2, NULL))))))) => 0; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, 3, NULL, 0, - LFS_MKRATTR(DELETE, 0, 2, NULL, 0, - LFS_MKRATTR(DELETE, 0, 1, NULL, 0, NULL)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(MKREG, 0, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR2(UATTR, 1, 0, "\xaa\xaa", 2, + LFSR_ATTR2(MKREG, 0, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR2(UATTR, 1, 1, "\xbb\xbb", 2, + LFSR_ATTR2(MKREG, 0, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR2(UATTR, 1, 2, "\xcc\xcc", 2, NULL))))))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, 2, NULL, 0, + LFSR_ATTR(RM, 1, NULL, 0, + LFSR_ATTR(RM, 0, NULL, 0, NULL)))) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; ''' @@ -4147,7 +4147,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -4156,7 +4156,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -4175,14 +4175,14 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, j+1, names[j % 6], 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, j, names[j % 6], 4, NULL)) => 0; } assert(rbyd.count == N); // copy block so we can reset after each delete - lfs_rbyd_t backup_rbyd = rbyd; + lfsr_rbyd_t backup_rbyd = rbyd; uint8_t backup_block[BLOCK_SIZE]; lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; @@ -4225,32 +4225,32 @@ code = ''' } uint16_t rbyd_count_before = rbyd.count; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, id+1, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, id, NULL, 0, NULL)) => 0; assert(rbyd.count == rbyd_count_before-1); } // check that all tags are now removed - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; // try resuming from all tags being removed - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, NULL)) => 0; assert(rbyd.count == 1); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, 1), buffer, 6) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, 0), buffer, 6) => 6; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0); - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, 2), buffer, 6) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, 1), buffer, 6) => LFS_ERR_NOENT; // keep track of the worst size @@ -4293,7 +4293,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -4302,7 +4302,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; const uint8_t names[6][4] = { "\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb", @@ -4321,20 +4321,20 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; for (unsigned j = 0; j < N; j++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, j+1, names[j % 6], 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, j, names[j % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, u+1, j+1, names[j % 6], 2, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, u+1, j, names[j % 6], 2, NULL)) => 0; } } assert(rbyd.count == N); // copy block so we can reset after each delete - lfs_rbyd_t backup_rbyd = rbyd; + lfsr_rbyd_t backup_rbyd = rbyd; uint8_t backup_block[BLOCK_SIZE]; lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; @@ -4377,46 +4377,46 @@ code = ''' } uint16_t rbyd_count_before = rbyd.count; - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, id+1, NULL, 0, NULL)) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, id, NULL, 0, NULL)) => 0; assert(rbyd.count == rbyd_count_before-1); } // check that all tags are now removed - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 0); - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, 1), buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, 0), buffer, 4) => LFS_ERR_NOENT; // try resuming from all tags being removed - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, 1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, NULL)) => 0; for (unsigned u = 0; u < M; u++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, u+1, 1, "\xaa\xaa\xaa", 3, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, u+1, 0, "\xaa\xaa\xaa", 3, NULL)) => 0; } assert(rbyd.count == 1); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; assert(rbyd.count == 1); - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, 1), buffer, 6) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, 0), buffer, 6) => 6; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0); for (unsigned u = 0; u < M; u++) { - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(UATTR, u+1, 1), buffer, 6) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG2(UATTR, u+1, 0), buffer, 6) => 3; assert(memcmp(buffer, "\xaa\xaa\xaa", 3) == 0); } - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, 2), buffer, 6) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, 1), buffer, 6) => LFS_ERR_NOENT; - lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(UATTR, 1, 2), buffer, 6) + lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG2(UATTR, 1, 1), buffer, 6) => LFS_ERR_NOENT; // keep track of the worst size @@ -4458,7 +4458,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -4467,7 +4467,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -4514,14 +4514,14 @@ code = ''' } } - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, id+1, names[perm[j] % 6], 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.count == N); // copy block so we can reset after each delete - lfs_rbyd_t backup_rbyd = rbyd; + lfsr_rbyd_t backup_rbyd = rbyd; uint8_t backup_block[BLOCK_SIZE]; lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; @@ -4539,22 +4539,22 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // delete - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, j+1, NULL, 0, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, j, NULL, 0, NULL)) => 0; assert(rbyd.count == N-1); // try creating each tag to make sure the rbyd tree // is still usable - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, l+1, names[l % 6], 6, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, l, names[l % 6], 6, NULL)) => 0; assert(rbyd.count == N); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (unsigned k = 0; k < N; k++) { - lfs_ssize_t size = lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, k+1), buffer, 6); + lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, k), buffer, 6); if (k == l) { assert(size == 6); assert(memcmp(buffer, names[l % 6], 6) == 0); @@ -4613,7 +4613,7 @@ code = ''' lfs_t lfs; lfs_init(&lfs, cfg) => 0; - lfs_rbyd_t init_rbyd = { + lfsr_rbyd_t init_rbyd = { .block = 0, .trunk = 0, .off = 0, @@ -4622,7 +4622,7 @@ code = ''' .count = 0, .erased = true, }; - lfs_rbyd_t rbyd; + lfsr_rbyd_t rbyd; const uint8_t names[6][6] = { "\xaa\xaa\xaa\xaa\xaa\xaa", "\xbb\xbb\xbb\xbb\xbb\xbb", @@ -4669,20 +4669,20 @@ code = ''' } } - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, id+1, names[perm[j] % 6], 4, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, u+1, id+1, names[perm[j] % 6], 2, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, u+1, id, names[perm[j] % 6], 2, NULL)) => 0; } } assert(rbyd.count == N); // copy block so we can reset after each delete - lfs_rbyd_t backup_rbyd = rbyd; + lfsr_rbyd_t backup_rbyd = rbyd; uint8_t backup_block[BLOCK_SIZE]; lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, rbyd.block, 0, backup_block, rbyd.off) => 0; @@ -4700,27 +4700,27 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // delete - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(DELETE, 0, j+1, NULL, 0, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, j, NULL, 0, NULL)) => 0; assert(rbyd.count == N-1); // try creating each tag to make sure the rbyd tree // is still usable - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(CREATEREG, 0, l+1, names[l % 6], 6, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, l, names[l % 6], 6, NULL)) => 0; for (unsigned u = 0; u < M; u++) { - lfs_rbyd_commit(&lfs, &rbyd, - LFS_MKRATTR(UATTR, u+1, l+1, names[l % 6], 3, + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR2(UATTR, u+1, l, names[l % 6], 3, NULL)) => 0; } assert(rbyd.count == N); - lfs_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, NULL) => 0; for (unsigned k = 0; k < N; k++) { - lfs_ssize_t size = lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(CREATEREG, 0, k+1), buffer, 6); + lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG(MKREG, k), buffer, 6); if (k == l) { assert(size == 6); assert(memcmp(buffer, names[l % 6], 6) == 0); @@ -4737,8 +4737,8 @@ code = ''' } for (unsigned u = 0; u < M; u++) { - size = lfs_rbyd_get(&lfs, &rbyd, - LFS_MKRTAG(UATTR, u+1, k+1), buffer, 6); + size = lfsr_rbyd_get(&lfs, &rbyd, + LFSR_TAG2(UATTR, u+1, k), buffer, 6); if (k == l) { assert(size == 3); assert(memcmp(buffer, names[l % 6], 3) == 0);