From 546fff77fb7edca025b0df73a81c760dc5ac26ee Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Sat, 25 Mar 2023 14:36:29 -0500 Subject: [PATCH] Adopted full le16 tags instead of 14-bit leb128 tags The main motivation for this was issues fitting a good tag encoding into 14-bits. The extra 2-bits (though really only 1 bit was needed) from making this not a leb encoding opens up the space from 3 suptypes to 15 suptypes, which is nothing to shake a stick at. The main downsides: 1. We can't rely on leb encoding for effectively-infinite extensions. 2. We can't shorten small tags (crcs, grows, shrinks) to one byte. For 1., extending the leb encoding beyond 14-bits is already unpalatable, because it would increase RAM costs in the tag encoder/decoder,` which must assume a worst-case tag size, and would likely add storage cost to every alt pointer, more on this in the next section. The current encoding is quite generous, so I think it is unlikely we will exceed the 16-bit encoding space. But even if we do, it's possible to use a spare bit for an "extended" set of tags in the future. As for 2., the lack of compression is a downside, but I've realized the only tags that really matter storage-wise are the alt pointers. In any rbyds there will be roughly O(m log m) alt pointers, but at most O(m) of any other tags. What this means is that the encoding of any other tag is in the noise of the encoding of our alt pointers. Our alt pointers are already pretty densely packed. But because the sparse key part of alt-pointers are stored as-is, the worst-case encoding of in-tree tags likely ends up as the encoding of our alt-pointers. So going up to 3-byte tags adds a surprisingly large storage cost. As a minor plus, le16s should be slightly cheaper to encode/decode. It should also be slightly easier to debug tags on-disk. tag encoding: TTTTtttt ttttTTTv ^--------^--^^- 4+3-bit suptype '---|- 8-bit subtype '- valid bit iiii iiiiiii iiiiiii iiiiiii iiiiiii ^- m-bit id/weight llll lllllll lllllll lllllll lllllll ^- m-bit length/jump Also renamed the "mk" tags, since they no longer have special behavior outside of providing names for entries: - LFSR_TAG_MK => LFSR_TAG_NAME - LFSR_TAG_MKBRANCH => LFSR_TAG_BNAME - LFSR_TAG_MKREG => LFSR_TAG_REG - LFSR_TAG_MKDIR => LFSR_TAG_DIR --- lfs.c | 170 +++--- lfs_util.h | 12 + scripts/dbgbtree.py | 111 ++-- scripts/dbgrbyd.py | 85 +-- tests/test_rbyd.toml | 1258 +++++++++++++++++++++--------------------- 5 files changed, 842 insertions(+), 794 deletions(-) diff --git a/lfs.c b/lfs.c index 57ff12ea..4ed4f6f7 100644 --- a/lfs.c +++ b/lfs.c @@ -447,25 +447,21 @@ static inline lfs_size_t lfs_tag_dsize(lfs_tag_t tag) { return sizeof(tag) + lfs_tag_size(tag + lfs_tag_isdelete(tag)); } -// 14-bit metadata tags -// -// in-device, these are effectively 14-bit unsigned integers, -// on-disk, these are encoded in leb128, so smaller constants are prefered -// +// 16-bit metadata tags enum lfsr_tag_type { - LFSR_TAG_MK = 0x0400, - LFSR_TAG_MKBRANCH = 0x0400, - LFSR_TAG_MKREG = 0x0410, - LFSR_TAG_MKDIR = 0x0420, + LFSR_TAG_NAME = 0x1000, + LFSR_TAG_BNAME = 0x1000, + LFSR_TAG_REG = 0x1010, + LFSR_TAG_DIR = 0x1020, - LFSR_TAG_STRUCT = 0x0800, - LFSR_TAG_INLINED = 0x0800, - LFSR_TAG_BLOCK = 0x0810, - LFSR_TAG_BTREE = 0x0820, - LFSR_TAG_BRANCH = 0x0830, + LFSR_TAG_STRUCT = 0x3000, + LFSR_TAG_INLINED = 0x3000, + LFSR_TAG_BLOCK = 0x3100, + LFSR_TAG_BRANCH = 0x3200, + LFSR_TAG_BTREE = 0x3300, - LFSR_TAG_UATTR = 0x2000, - LFSR_TAG_RMUATTR = 0x2002, + LFSR_TAG_UATTR = 0x4000, + LFSR_TAG_RMUATTR = 0x4002, LFSR_TAG_GROW = 0x0006, LFSR_TAG_SHRINK = 0x0016, @@ -478,20 +474,18 @@ enum lfsr_tag_type { LFSR_TAG_ALTRGT = 0x000e, LFSR_TAG_CRC = 0x0004, - LFSR_TAG_CRC0 = 0x0004, - LFSR_TAG_CRC1 = 0x0014, - LFSR_TAG_FCRC = 0x0024, + LFSR_TAG_FCRC = 0x1004, }; #define LFSR_TAG_ALT_(color, dir, key) \ (LFSR_TAG_ALT \ | ((0x1 & (lfsr_tag_t)(color)) << 1) \ | ((0x1 & (lfsr_tag_t)(dir)) << 2) \ - | ((0x3ff0 & (lfsr_tag_t)(key)))) + | ((0xfff0 & (lfsr_tag_t)(key)))) #define LFSR_TAG_ALT(color, dir, key) \ (LFSR_TAG_ALT##color##dir \ - | ((0x3ff0 & (lfsr_tag_t)(key)))) + | ((0xfff0 & (lfsr_tag_t)(key)))) #define LFSR_TAG_UATTR(attr) \ (LFSR_TAG_UATTR \ @@ -502,6 +496,14 @@ enum lfsr_tag_type { | ((0xff & (lfsr_tag_t)(attr)) << 4)) // tag type operations +static inline lfsr_tag_t lfsr_tag_suptype(lfsr_tag_t tag) { + return tag & 0xf00f; +} + +static inline uint8_t lfsr_tag_subtype(lfsr_tag_t tag) { + return (tag & 0x0ff0) >> 4; +} + static inline bool lfsr_tag_isrm(lfsr_tag_t tag) { return tag & 0x2; } @@ -522,18 +524,6 @@ static inline bool lfsr_tag_isalt(lfsr_tag_t tag) { return tag & 0x8; } -static inline bool lfsr_tag_iscrc(lfsr_tag_t tag) { - return (tag & ~0x0010) == LFSR_TAG_CRC; -} - -static inline bool lfsr_tag_ismk(lfsr_tag_t tag) { - return (tag & ~0x03f0) == LFSR_TAG_MK; -} - -static inline bool lfsr_tag_isstruct(lfsr_tag_t tag) { - return (tag & ~0x03f0) == LFSR_TAG_STRUCT; -} - //static inline bool lfsr_tag_isfound(lfsr_tag_t tag) { // // note that this is only for driver bookkeeping and never // // exists on disk @@ -1174,9 +1164,9 @@ static int lfsr_rbyd_alloc(lfs_t *lfs, lfsr_rbyd_t *rbyd, uint32_t rev) { // TODO is id actually 31-bits? do we rely on sign anywhere? we should really // nail this down for all the types -// each piece of metadata in an rbyd tree is prefixed with a 3-leb128 piece tag: +// each piece of metadata in an rbyd tree is prefixed with a 3-piece tag: // -// - 14-bit type => 2 byte leb128 (worst case) +// - 16-bit type => 2 byte le16 // - 32-bit id/weight => 5 byte leb128 (worst case) // - 32-bit size/jump => 5 byte leb128 (worst case) // => 12 bytes total @@ -1224,16 +1214,11 @@ static lfs_ssize_t lfsr_rbyd_readtag(lfs_t *lfs, } } - lfs_size_t delta = 0; - uint32_t tag_; - ssize_t delta_ = lfs_fromleb128(&tag_, &buffer[delta], 2); - if (delta_ < 0) { - return delta_; - } - delta += delta_; + uint16_t tag_ = lfs_fromle16_(&buffer[0]); lfs_size_t id_; - delta_ = lfs_fromleb128(&id_, &buffer[delta], 5); + ssize_t delta = 2; + lfs_ssize_t delta_ = lfs_fromleb128(&id_, &buffer[delta], 5); if (delta_ < 0) { return delta_; } @@ -1367,7 +1352,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // not an end-of-commit crc - if (!lfsr_tag_iscrc(tag)) { + if (lfsr_tag_suptype(tag) != LFSR_TAG_CRC) { // crc the entry first, hopefully leaving it in the cache err = lfs_bd_crc32c(lfs, NULL, &lfs->rcache, limit-off, @@ -1400,7 +1385,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // found our find? - if (find && lfsr_tag_ismk(tag)) { + if (find && lfsr_tag_suptype(tag) == LFSR_TAG_NAME) { // compare with disk lfs_size_t diff = lfs_min(size, find->name_len); int cmp = lfs_bd_cmp(lfs, @@ -1761,8 +1746,6 @@ static int lfsr_rbyd_progdata(lfs_t *lfs, lfsr_rbyd_t *rbyd_, static int lfsr_rbyd_progtag(lfs_t *lfs, lfsr_rbyd_t *rbyd_, lfsr_tag_t tag, lfs_ssize_t id, lfs_size_t size, uint32_t *crc) { - LFS_ASSERT(tag <= 0x3fff); - // make sure to include the parity of the current crc tag |= lfs_popc(rbyd_->crc) & 1; @@ -1771,16 +1754,12 @@ static int lfsr_rbyd_progtag(lfs_t *lfs, lfsr_rbyd_t *rbyd_, id += 1; } - // compress into a trio of leb128s + // compress into an le16 and pair of leb128s uint8_t buf[LFSR_TAG_DSIZE]; - lfs_size_t delta = 0; - ssize_t delta_ = lfs_toleb128(tag, &buf[delta], 2); - if (delta_ < 0) { - return delta_; - } - delta += delta_; + lfs_tole16_(tag, &buf[0]); - delta_ = lfs_toleb128(id, &buf[delta], 5); + lfs_size_t delta = 2; + ssize_t delta_ = lfs_toleb128(id, &buf[delta], 5); if (delta_ < 0) { return delta_; } @@ -2399,26 +2378,26 @@ static int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd, // this gets a bit complicated as we have two types of crcs: // // - 9-word crc with fcrc to check following prog (middle of block) - // - fcrc tag type => 1 byte leb128 + // - fcrc tag type => 2 byte le16 // - fcrc tag id => 1 byte leb128 // - fcrc tag size => 1 byte leb128 (worst case) // - fcrc crc => 4 byte le32 // - fcrc size => 5 byte leb128 (worst case) - // - crc tag type => 1 byte leb128 + // - crc tag type => 2 byte le16 // - crc tag id => 1 byte leb128 // - crc tag size => 5 byte leb128 (worst case) // - crc crc => 4 byte le32 - // => 23 bytes total + // => 25 bytes total // // - 4-word crc with no following prog (end of block) - // - crc tag type => 1 byte leb128 + // - crc tag type => 2 byte le16 // - crc tag id => 1 byte leb128 // - crc tag size => 5 byte leb128 (worst case) // - crc crc => 4 byte le32 - // => 11 bytes total + // => 12 bytes total // lfs_off_t aligned = lfs_alignup( - rbyd_.off + 1+1+1+4+5 + 1+1+5+4, + rbyd_.off + 2+1+1+4+5 + 2+1+5+4, lfs->cfg->prog_size); // space for fcrc? @@ -2480,29 +2459,29 @@ static int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd, // note padding-size depends on leb-encoding depends on padding-size, to // get around this catch-22 we just always write a fully-expanded leb128 // encoding - uint8_t buffer[1+1+5+4]; - buffer[0] = LFSR_TAG_CRC | (lfs_popc(rbyd_.crc) & 1); - buffer[1] = 0; + uint8_t buffer[2+1+5+4]; + lfs_tole16_(LFSR_TAG_CRC | (lfs_popc(rbyd_.crc) & 1), &buffer[0]); + buffer[2] = 0; - lfs_off_t padding = aligned - (rbyd_.off + 1+1+5); - buffer[2] = 0x80 | (0x7f & (padding >> 0)); - buffer[3] = 0x80 | (0x7f & (padding >> 7)); - buffer[4] = 0x80 | (0x7f & (padding >> 14)); - buffer[5] = 0x80 | (0x7f & (padding >> 21)); - buffer[6] = 0x00 | (0x7f & (padding >> 28)); + lfs_off_t padding = aligned - (rbyd_.off + 2+1+5); + buffer[3] = 0x80 | (0x7f & (padding >> 0)); + buffer[4] = 0x80 | (0x7f & (padding >> 7)); + buffer[5] = 0x80 | (0x7f & (padding >> 14)); + buffer[6] = 0x80 | (0x7f & (padding >> 21)); + buffer[7] = 0x00 | (0x7f & (padding >> 28)); - rbyd_.crc = lfs_crc32c(rbyd_.crc, buffer, 1+1+5); + rbyd_.crc = lfs_crc32c(rbyd_.crc, buffer, 2+1+5); // we can't let the next tag appear as valid, so intentionally perturb the // commit if this happens, note parity(crc(m)) == parity(m) with crc32c, // so we can really change any bit to make this happen, we've reserved a bit // in crc tags just for this purpose if ((lfs_popc(rbyd_.crc) & 1) == (perturb & 1)) { buffer[0] ^= 0x10; - rbyd_.crc ^= 0x9c5bfaa6; // note crc(a ^ b) == crc(a) ^ crc(b) + rbyd_.crc ^= 0x847609b4; // note crc(a ^ b) == crc(a) ^ crc(b) } - lfs_tole32_(rbyd_.crc, &buffer[1+1+5]); + lfs_tole32_(rbyd_.crc, &buffer[2+1+5]); - int err = lfsr_rbyd_prog(lfs, &rbyd_, buffer, 1+1+5+4, NULL); + int err = lfsr_rbyd_prog(lfs, &rbyd_, buffer, 2+1+5+4, NULL); if (err) { rbyd_.erased = false; return err; @@ -2643,13 +2622,13 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs, lfs_size_t weight__; lfs_off_t off_; lfs_size_t size_; - err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_MK, rid, + err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_NAME, rid, &tag__, &rid__, &weight__, &off_, &size_); if (err) { return err; } - if (lfsr_tag_ismk(tag__)) { + if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { // TODO what if we don't find a struct? ENOENT? err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_STRUCT, rid__, &tag__, NULL, NULL, &off_, &size_); @@ -2741,14 +2720,14 @@ static int lfsr_btree_parent(lfs_t *lfs, lfs_size_t weight__; lfs_off_t off_; lfs_size_t size_; - err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_MK, rid, + err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_NAME, rid, &tag__, &rid__, &weight__, &off_, &size_); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); return err; } - if (lfsr_tag_ismk(tag__)) { + if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { // TODO what if we don't find a struct? ENOENT? err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_STRUCT, rid__, &tag__, NULL, NULL, &off_, &size_); @@ -2865,13 +2844,13 @@ static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs, lfs_size_t weight__; lfs_off_t off_; lfs_size_t size_; - err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_MK, find.found_id, + err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_NAME, find.found_id, &tag__, &rid__, &weight__, &off_, &size_); if (err) { return err; } - if (lfsr_tag_ismk(tag__)) { + if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { // TODO what if we don't find a struct? ENOENT? err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_STRUCT, rid__, &tag__, NULL, NULL, &off_, &size_); @@ -3063,7 +3042,7 @@ static int lfsr_btree_commit(lfs_t *lfs, // // Discarding these during compaction is easy and prevents any // real storage cost. - if (lfsr_tag_ismk(tag) && id-(weight-1) == 0) { + if (lfsr_tag_suptype(tag) == LFSR_TAG_NAME && id-(weight-1) == 0) { continue; } @@ -3277,7 +3256,7 @@ static int lfsr_btree_commit(lfs_t *lfs, lfs_ssize_t sid; lfs_off_t soff; lfs_size_t ssize; - err = lfsr_rbyd_lookup(lfs, &sibling, LFSR_TAG_MK, 0, + err = lfsr_rbyd_lookup(lfs, &sibling, LFSR_TAG_NAME, 0, &stag, &sid, NULL, &soff, &ssize); if (err && err != LFS_ERR_NOENT) { return err; @@ -3321,8 +3300,8 @@ static int lfsr_btree_commit(lfs_t *lfs, NULL, sibling.weight, &scratch_attrs[3]); scratch_attrs[3] = *LFSR_ATTR_DISK_IF( - lfsr_tag_ismk(stag), - MKBRANCH, 0+rbyd_.weight+sibling.weight-1, + lfsr_tag_suptype(stag) == LFSR_TAG_NAME, + BNAME, 0+rbyd_.weight+sibling.weight-1, sibling.block, soff, ssize, &scratch_attrs[4]); scratch_attrs[4] = *LFSR_ATTR( @@ -3366,8 +3345,8 @@ static int lfsr_btree_commit(lfs_t *lfs, NULL, sibling.weight, &scratch_attrs[3]); scratch_attrs[3] = *LFSR_ATTR_DISK_IF( - lfsr_tag_ismk(stag), - MKBRANCH, rid-(rweight-1)+rbyd_.weight + lfsr_tag_suptype(stag) == LFSR_TAG_NAME, + BNAME, rid-(rweight-1)+rbyd_.weight +sibling.weight-1, sibling.block, soff, ssize, &scratch_attrs[4]); @@ -3397,7 +3376,7 @@ static int lfsr_btree_commit(lfs_t *lfs, // try looking up the sibling lfs_size_t sweight; - err = lfsr_rbyd_lookup(lfs, &parent, LFSR_TAG_MK, sid, + err = lfsr_rbyd_lookup(lfs, &parent, LFSR_TAG_NAME, sid, NULL, &sid, &sweight, NULL, NULL); if (err && err != LFS_ERR_NOENT) { return err; @@ -3498,25 +3477,25 @@ static int lfsr_btree_commit(lfs_t *lfs, lfs_off_t split_off; lfs_size_t split_size; err = lfsr_rbyd_lookup(lfs, &parent, - LFSR_TAG_MK, (sdelta == 0 ? rid : sid), + LFSR_TAG_NAME, (sdelta == 0 ? rid : sid), &split_tag, NULL, NULL, &split_off, &split_size); if (err) { return err; } - if (lfsr_tag_ismk(split_tag)) { + if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { // TODO can we avoid this? // lookup the id of the previously-split entry lfs_ssize_t split_id; err = lfsr_rbyd_lookup(lfs, &rbyd_, - LFSR_TAG_MK, (sdelta == 0 ? sweight : rweight_), + LFSR_TAG_NAME, (sdelta == 0 ? sweight : rweight_), NULL, &split_id, NULL, NULL, NULL); if (err) { return err; } err = lfsr_rbyd_append(lfs, &rbyd_, - LFSR_TAG_MKBRANCH, split_id, + LFSR_TAG_BNAME, split_id, LFSR_DATA_DISK(parent.block, split_off, split_size)); if (err) { return err; @@ -3740,7 +3719,7 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t id) { // try looking up the sibling lfs_size_t sweight; - int err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_MK, sid, + int err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_NAME, sid, NULL, &sid, &sweight, NULL, NULL); if (err && err != LFS_ERR_NOENT) { return err; @@ -3762,7 +3741,8 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t id) { } // no sibling? null btree - if (err == LFS_ERR_NOENT || !lfsr_tag_isstruct(stag)) { + if (err == LFS_ERR_NOENT + || lfsr_tag_suptype(stag) != LFSR_TAG_STRUCT) { btree->weight = 0; return 0; } @@ -3820,7 +3800,7 @@ static int lfsr_btree_split(lfs_t *lfs, lfsr_btree_t *btree, LFSR_ATTR_(tag1, 0+weight1-1, buffer1, size1, LFSR_ATTR(GROW, weight1, NULL, weight2, - LFSR_ATTR(MKBRANCH, weight1+weight2-1, + LFSR_ATTR(BNAME, weight1+weight2-1, name, name_len, LFSR_ATTR_(tag2, weight1+weight2-1, buffer2, size2, @@ -3869,7 +3849,7 @@ static int lfsr_btree_split(lfs_t *lfs, lfsr_btree_t *btree, LFSR_ATTR_(tag1, rid-(rweight-1)+weight1-1, buffer1, size1, LFSR_ATTR(GROW, rid-(rweight-1)+weight1, NULL, weight2, - LFSR_ATTR(MKBRANCH, rid-(rweight-1)+weight1+weight2-1, + LFSR_ATTR(BNAME, rid-(rweight-1)+weight1+weight2-1, name, name_len, LFSR_ATTR_(tag2, rid-(rweight-1)+weight1+weight2-1, buffer2, size2, diff --git a/lfs_util.h b/lfs_util.h index 8c75edfe..c463cf9f 100644 --- a/lfs_util.h +++ b/lfs_util.h @@ -261,6 +261,17 @@ static inline uint32_t lfs_tobe32(uint32_t a) { return lfs_frombe32(a); } +// Convert to/from 16-bit little-endian +static inline void lfs_tole16_(uint16_t word, void *buffer) { + ((uint8_t*)buffer)[0] = word >> 0; + ((uint8_t*)buffer)[1] = word >> 8; +} + +static inline uint16_t lfs_fromle16_(const void *buffer) { + return (((uint8_t*)buffer)[0] << 0) + | (((uint8_t*)buffer)[1] << 8); +} + // Convert to/from 32-bit little-endian static inline void lfs_tole32_(uint32_t word, void *buffer) { ((uint8_t*)buffer)[0] = word >> 0; @@ -277,6 +288,7 @@ static inline uint32_t lfs_fromle32_(const void *buffer) { } // Convert to/from leb128 encoding +// TODO should we really be using ssize_t here and not lfs_ssize_t? ssize_t lfs_toleb128(uint32_t word, void *buffer, size_t size); ssize_t lfs_fromleb128(uint32_t *word, const void *buffer, size_t size); diff --git a/scripts/dbgbtree.py b/scripts/dbgbtree.py index 8ea1409c..d85951ba 100755 --- a/scripts/dbgbtree.py +++ b/scripts/dbgbtree.py @@ -7,6 +7,22 @@ import os import struct +TAG_NAME = 0x1000 +TAG_BNAME = 0x1000 +TAG_REG = 0x1010 +TAG_DIR = 0x1020 +TAG_STRUCT = 0x3000 +TAG_INLINED = 0x3000 +TAG_BLOCK = 0x3100 +TAG_BRANCH = 0x3200 +TAG_BTREE = 0x3300 +TAG_UATTR = 0x4000 +TAG_GROW = 0x0006 +TAG_SHRINK = 0x0016 +TAG_ALT = 0x0008 +TAG_CRC = 0x0004 +TAG_FCRC = 0x1004 + def blocklim(s): if '.' in s: s = s.strip() @@ -34,6 +50,11 @@ def crc32c(data, crc=0): crc = (crc >> 1) ^ ((crc & 1) * 0x82f63b78) return 0xffffffff ^ crc +def fromle16(data): + if len(data) < 2: + return 0 + return struct.unpack('> 4) == 0x00 - else 'reg' if ((tag & 0x3f0) >> 4) == 0x01 - else 'dir' if ((tag & 0x3f0) >> 4) == 0x02 - else ' 0x%02x' % ((tag & 0x3f0) >> 4), + if (tag & 0xf00c) == TAG_NAME: + return '%s%s id%d %d' % ( + 'rm' if tag & 0x2 else '', + 'bname' if (tag & 0xfffe) == TAG_BNAME + else 'reg' if (tag & 0xfffe) == TAG_REG + else 'dir' if (tag & 0xfffe) == TAG_DIR + else 'name 0x%02x' % ((tag & 0x0ff0) >> 4), id, size) - elif tag == 0x0800: - return 'inlined id%d %d' % (id, size) - elif tag == 0x0810: - return 'block id%d %d' % (id, size) - elif tag == 0x0820: - return 'btree id%d %d' % (id, size) - elif tag == 0x0830: - return 'branch id%d %d' % (id, size) - elif (tag & ~0xff2) == 0x2000: + elif (tag & 0xf00c) == TAG_STRUCT: + return '%s%s id%d %d' % ( + 'rm' if tag & 0x2 else '', + 'inlined' if (tag & 0xfffe) == TAG_INLINED + else 'block' if (tag & 0xfffe) == TAG_BLOCK + else 'branch' if (tag & 0xfffe) == TAG_BRANCH + else 'btree' if (tag & 0xfffe) == TAG_BTREE + else 'struct 0x%02x' % ((tag & 0x0ff0) >> 4), + id, + size) + elif (tag & 0xf00c) == TAG_UATTR: return '%suattr 0x%02x%s%s' % ( 'rm' if tag & 0x2 else '', - (tag & 0xff0) >> 4, + (tag & 0x0ff0) >> 4, ' id%d' % id if id != -1 else '', ' %d' % size if not tag & 0x2 or size else '') - elif tag == 0x0006: + elif (tag & 0xfffe) == TAG_GROW: return 'grow id%d w%d' % ( id, size) - elif tag == 0x0016: + elif (tag & 0xfffe) == TAG_SHRINK: return 'shrink id%d w%d' % ( id, size) - elif (tag & ~0x10) == 0x0004: + elif (tag & 0xf00e) == TAG_CRC: return 'crc%x%s %d' % ( 1 if tag & 0x10 else 0, ' 0x%02x' % id if id != -1 else '', size) - elif tag == 0x0024: + elif (tag & 0xfffe) == TAG_FCRC: return 'fcrc%s %d' % ( ' 0x%02x' % id if id != -1 else '', size) @@ -106,7 +130,7 @@ def tagrepr(tag, id, size, off=None): return 'alt%s%s 0x%x w%d %s' % ( 'r' if tag & 0x2 else 'b', 'gt' if tag & 0x4 else 'le', - tag & 0x3ff0, + tag & 0xfff0, id, '0x%x' % (0xffffffff & (off-size)) if off is not None @@ -114,7 +138,6 @@ def tagrepr(tag, id, size, off=None): else: return '0x%04x id%d %d' % (tag, id, size) - class Rbyd: def __init__(self, block, limit, data, rev, off, trunk, weight): self.block = block @@ -154,14 +177,14 @@ class Rbyd: wastrunk = not not tag & 0x8 # keep track of weight - if tag == 0x0006: + if tag == TAG_GROW: weight_ += size - elif tag == 0x0016: + elif tag == TAG_SHRINK: weight_ = max(weight_ - size, 0) # take care of crcs if (tag & 0xe) <= 0x4: - if (tag & ~0x10) != 0x04: + if (tag & 0xf00f) != TAG_CRC: crc = crc32c(data[j_:j_+size], crc) # found a crc? else: @@ -284,24 +307,34 @@ def main(disk, block_size=None, trunk=0, limit=None, *, while True: # first lookup id/name (done, name_tag, rid_, w, - name_j, name_d, name) = rbyd.lookup(0x400, rid) + name_j, name_d, name) = rbyd.lookup(TAG_NAME, rid) if done: - return True, id, 0, rbyd, -1, 0, 0, 0, b'', 0, 0, b'', path - if name_tag & 0xf00 != 0x400: - name_j, name_d, name = name_j, 0, b'' + return (True, id, 0, rbyd, -1, 0, + 0, 0, b'', + 0, 0, b'', + path) - # then lookup struct - (done, tag, _, _, - struct_j, struct_d, struct_) = rbyd.lookup(0x800, rid_) - if done: - return True, id, 0, rbyd, -1, 0, 0, 0, b'', 0, 0, b'', path + if name_tag & 0xf00f == TAG_NAME: + # then lookup struct + (done, tag, _, _, + struct_j, struct_d, struct_) = rbyd.lookup( + TAG_STRUCT, rid_) + if done: + return (True, id, 0, rbyd, -1, 0, + 0, 0, b'', + 0, 0, b'', + path) + else: + tag = name_tag + struct_j, struct_d, struct_ = name_j, name_d, name + name_j, name_d, name = name_j, 0, b'' path.append((id + (rid_-rid), w, rbyd, rid_, tag, name_j, name_d, name, struct_j, struct_d, struct_)) # is it another branch? continue down tree - if tag == 0x830 and (depth is None or depth_ < depth): + if tag == TAG_BRANCH and (depth is None or depth_ < depth): block, delta = fromleb128(struct_) limit, _ = fromleb128(struct_[delta:]) rbyd = Rbyd.fetch(f, block_size, block, limit) diff --git a/scripts/dbgrbyd.py b/scripts/dbgrbyd.py index 4e75be6e..d855e2ff 100755 --- a/scripts/dbgrbyd.py +++ b/scripts/dbgrbyd.py @@ -16,6 +16,22 @@ COLORS = [ ] +TAG_NAME = 0x1000 +TAG_BNAME = 0x1000 +TAG_REG = 0x1010 +TAG_DIR = 0x1020 +TAG_STRUCT = 0x3000 +TAG_INLINED = 0x3000 +TAG_BLOCK = 0x3100 +TAG_BRANCH = 0x3200 +TAG_BTREE = 0x3300 +TAG_UATTR = 0x4000 +TAG_GROW = 0x0006 +TAG_SHRINK = 0x0016 +TAG_ALT = 0x0008 +TAG_CRC = 0x0004 +TAG_FCRC = 0x1004 + def blocklim(s): if '.' in s: s = s.strip() @@ -43,6 +59,11 @@ def crc32c(data, crc=0): crc = (crc >> 1) ^ ((crc & 1) * 0x82f63b78) return 0xffffffff ^ crc +def fromle16(data): + if len(data) < 2: + return 0 + return struct.unpack('> 4) == 0x00 - else 'reg' if ((tag & 0x3f0) >> 4) == 0x01 - else 'dir' if ((tag & 0x3f0) >> 4) == 0x02 - else ' 0x%02x' % ((tag & 0x3f0) >> 4), + 'bname' if (tag & 0xfffe) == TAG_BNAME + else 'reg' if (tag & 0xfffe) == TAG_REG + else 'dir' if (tag & 0xfffe) == TAG_DIR + else 'name 0x%02x' % ((tag & 0x0ff0) >> 4), id, size) - elif tag == 0x0800: - return 'inlined id%d %d' % (id, size) - elif tag == 0x0810: - return 'block id%d %d' % (id, size) - elif tag == 0x0820: - return 'btree id%d %d' % (id, size) - elif tag == 0x0830: - return 'branch id%d %d' % (id, size) - elif (tag & ~0xff2) == 0x2000: + elif (tag & 0xf00c) == TAG_STRUCT: + return '%s%s id%d %d' % ( + 'rm' if tag & 0x2 else '', + 'inlined' if (tag & 0xfffe) == TAG_INLINED + else 'block' if (tag & 0xfffe) == TAG_BLOCK + else 'branch' if (tag & 0xfffe) == TAG_BRANCH + else 'btree' if (tag & 0xfffe) == TAG_BTREE + else 'struct 0x%02x' % ((tag & 0x0ff0) >> 4), + id, + size) + elif (tag & 0xf00c) == TAG_UATTR: return '%suattr 0x%02x%s%s' % ( 'rm' if tag & 0x2 else '', - (tag & 0xff0) >> 4, + (tag & 0x0ff0) >> 4, ' id%d' % id if id != -1 else '', ' %d' % size if not tag & 0x2 or size else '') - elif tag == 0x0006: + elif (tag & 0xfffe) == TAG_GROW: return 'grow id%d w%d' % ( id, size) - elif tag == 0x0016: + elif (tag & 0xfffe) == TAG_SHRINK: return 'shrink id%d w%d' % ( id, size) - elif (tag & ~0x10) == 0x0004: + elif (tag & 0xf00e) == TAG_CRC: return 'crc%x%s %d' % ( 1 if tag & 0x10 else 0, ' 0x%02x' % id if id != -1 else '', size) - elif tag == 0x0024: + elif (tag & 0xfffe) == TAG_FCRC: return 'fcrc%s %d' % ( ' 0x%02x' % id if id != -1 else '', size) @@ -116,7 +139,7 @@ def tagrepr(tag, id, size, off=None): return 'alt%s%s 0x%x w%d %s' % ( 'r' if tag & 0x2 else 'b', 'gt' if tag & 0x4 else 'le', - tag & 0x3ff0, + tag & 0xfff0, id, '0x%x' % (0xffffffff & (off-size)) if off is not None @@ -235,7 +258,7 @@ def show_log(block_size, data, rev, off, *, j_ += size # note we ignore out-of-bounds here for debugging - if tag == 0x0006: + if tag == TAG_GROW: # grow lifetimes i, id_ = index(weights, id) if id_ > 0: @@ -247,7 +270,7 @@ def show_log(block_size, data, rev, off, *, checkpoint(j, weights, lifetimes, {i}, set(), {i}) - elif tag == 0x0016: + elif tag == TAG_SHRINK: # shrink lifetimes i, id_ = index(weights, id) size_ = size @@ -354,7 +377,7 @@ def show_log(block_size, data, rev, off, *, j_ += delta if (tag & 0xe) <= 0x4: - if (tag & ~0x10) != 0x04: + if (tag & 0xf00f) != TAG_CRC: crc = crc32c(data[j_:j_+size], crc) # found a crc? else: @@ -707,14 +730,14 @@ def main(disk, block_size=None, block1=0, block2=None, *, wastrunk = not not tag & 0x8 # keep track of weight - if tag == 0x0006: + if tag == TAG_GROW: weight_ += size - elif tag == 0x0016: + elif tag == TAG_SHRINK: weight_ = max(weight_ - size, 0) # take care of crcs if (tag & 0xe) <= 0x4: - if (tag & ~0x10) != 0x04: + if (tag & 0xf00f) != TAG_CRC: crc = crc32c(data[j_:j_+size], crc) # found a crc? else: diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 95405760..d6a9e25e 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -3869,15 +3869,15 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); // try to create two ids @@ -3885,21 +3885,21 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // try to create two in the other direction @@ -3907,21 +3907,21 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // create a third to the right @@ -3929,27 +3929,27 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); // create a third to the left @@ -3957,27 +3957,27 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 1, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); // create a third in the middle @@ -3985,27 +3985,27 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 1, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); ''' @@ -4032,16 +4032,16 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4050,22 +4050,22 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // try to create two in the other direction @@ -4073,22 +4073,22 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); // create a third to the right @@ -4096,29 +4096,29 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); // create a third to the left @@ -4126,29 +4126,29 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); // create a third in the middle @@ -4156,29 +4156,29 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); ''' @@ -4250,7 +4250,7 @@ code = ''' GROW, id, NULL, 1, (2*j+1 < 2*N) ? &attrs[2*j+1] : NULL); attrs[2*j+1] = *LFSR_ATTR( - MKREG, id, names[perm[j] % 6], 4, + REG, id, names[perm[j] % 6], 4, (2*j+2 < 2*N) ? &attrs[2*j+2] : NULL); } @@ -4262,7 +4262,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, j, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } @@ -4357,7 +4357,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id, names[perm[j] % 6], 4, NULL))) => 0; } @@ -4365,7 +4365,7 @@ code = ''' assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_get(&lfs, &rbyd, - LFSR_TAG_MKREG, j, buffer, 4) => 4; + LFSR_TAG_REG, j, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } @@ -4420,20 +4420,20 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -4444,14 +4444,14 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -4464,20 +4464,20 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -4488,14 +4488,14 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -4533,21 +4533,21 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -4558,14 +4558,14 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -4578,21 +4578,21 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -4603,14 +4603,14 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -4687,7 +4687,7 @@ code = ''' GROW, id, NULL, 1, (2*j+1 < 2*N) ? &attrs[2*j+1] : NULL); attrs[2*j+1] = *LFSR_ATTR( - MKREG, id, names[perm[j] % 6], 4, + REG, id, names[perm[j] % 6], 4, (2*j+2 < 2*N) ? &attrs[2*j+2] : NULL); } @@ -4704,7 +4704,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == j); assert(size_ == 4); @@ -4785,7 +4785,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id, names[perm[j] % 6], 4, NULL))) => 0; } @@ -4797,7 +4797,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == j); assert(size_ == 4); @@ -4859,7 +4859,7 @@ code = ''' int err = lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, x, NULL, 1, - LFSR_ATTR(MKREG, x, names[x % 6], 4, NULL))); + LFSR_ATTR(REG, x, names[x % 6], 4, NULL))); if (err == LFS_ERR_RANGE) { break; } @@ -4875,9 +4875,9 @@ code = ''' lfs_size_t size_; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, x, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, x, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == x); assert(size_ == 4); } @@ -4909,18 +4909,18 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); @@ -4930,29 +4930,29 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); @@ -4962,29 +4962,29 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 0, "\xbb\xbb", 2, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL))))))) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); @@ -4994,57 +4994,57 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL)))))))))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); @@ -5054,40 +5054,40 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 0, "\xbb\xbb", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 1, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 1, "\xcc\xcc", 2, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)))))))))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); @@ -5097,40 +5097,40 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 1, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 1, "\xcc\xcc", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL)))))))))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); @@ -5159,19 +5159,19 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); @@ -5181,32 +5181,32 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL)) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); @@ -5216,32 +5216,32 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xbb\xbb", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); @@ -5251,62 +5251,62 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL)) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); @@ -5316,45 +5316,45 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xbb\xbb", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 1, "\xcc\xcc", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); @@ -5364,45 +5364,45 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 1, "\xcc\xcc", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL)) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); @@ -5477,7 +5477,7 @@ code = ''' GROW, id, NULL, 1, ((2+M)*j+1 < (2+M)*N) ? &attrs[(2+M)*j+1] : NULL); attrs[(2+M)*j+1] = *LFSR_ATTR( - MKREG, id, names[perm[j] % 6], 4, + REG, id, names[perm[j] % 6], 4, ((2+M)*j+2 < (2+M)*N) ? &attrs[(2+M)*j+2] : NULL); // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -5497,7 +5497,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, j, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { @@ -5599,7 +5599,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id, names[perm[j] % 6], 4, NULL))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -5612,7 +5612,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, j, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { @@ -5673,15 +5673,15 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5695,7 +5695,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5713,7 +5713,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5727,7 +5727,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5747,15 +5747,15 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 0, "\xbb\xbb", 2, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL))))))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5769,7 +5769,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5787,7 +5787,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5801,7 +5801,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5846,18 +5846,18 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5871,7 +5871,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5889,7 +5889,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5903,7 +5903,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5923,18 +5923,18 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xbb\xbb", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5948,7 +5948,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5966,7 +5966,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -5980,7 +5980,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; @@ -6065,7 +6065,7 @@ code = ''' GROW, id, NULL, 1, ((2+M)*j+1 < N*(2+M)) ? &attrs[(2+M)*j+1] : NULL); attrs[(2+M)*j+1] = *LFSR_ATTR( - MKREG, id, names[perm[j] % 6], 4, + REG, id, names[perm[j] % 6], 4, ((2+M)*j+2 < N*(2+M)) ? &attrs[(2+M)*j+2] : NULL); // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -6091,7 +6091,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == j); assert(size_ == 4); @@ -6184,7 +6184,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id, names[perm[j] % 6], 4, NULL))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -6203,7 +6203,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == j); assert(size_ == 4); @@ -6272,7 +6272,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, j, NULL, 1, - LFSR_ATTR(MKREG, j, names[j % 6], 4, + LFSR_ATTR(REG, j, names[j % 6], 4, NULL))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -6325,7 +6325,7 @@ code = ''' // check that all tags have been updated lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, j, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { @@ -6436,7 +6436,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id, names[perm[j] % 6], 4, NULL))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -6469,7 +6469,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, k, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, k, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { @@ -6482,7 +6482,7 @@ code = ''' assert(err == LFS_ERR_NOENT); } else if (u == M-1) { assert(!err); - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k+1); assert(size_ == 4); } else { @@ -6511,7 +6511,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, k, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, k, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { @@ -6608,7 +6608,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, j, NULL, 1, - LFSR_ATTR(MKREG, j, names[j % 6], 4, + LFSR_ATTR(REG, j, names[j % 6], 4, NULL))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -6660,7 +6660,7 @@ code = ''' // check that all tags have been removed lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, j, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { @@ -6750,7 +6750,7 @@ code = ''' GROW, x, NULL, 1, &attrs[1]); attrs[1] = *LFSR_ATTR( - MKREG, x, names[x % 6], 4, + REG, x, names[x % 6], 4, M > 0 ? &attrs[2] : NULL); for (unsigned u = 0; u < M; u++) { attrs[2+u] = *LFSR_ATTR( @@ -6774,9 +6774,9 @@ code = ''' lfs_size_t size_; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, x, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, x, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == x); assert(size_ == 4); @@ -6816,122 +6816,122 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 1, NULL, 1, NULL)) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => LFS_ERR_NOENT; // try to delete the other id rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => LFS_ERR_NOENT; // try to delete the largest of three rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 2, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; // try to delete the smallest of three rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; // try to delete the middle rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 1, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; ''' [cases.test_rbyd_delete_range] @@ -6957,35 +6957,35 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 1, NULL, 1, NULL)) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => LFS_ERR_NOENT; @@ -6995,35 +6995,35 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => LFS_ERR_NOENT; @@ -7033,49 +7033,49 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL)))))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 2, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => LFS_ERR_NOENT; @@ -7085,50 +7085,50 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL)))))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => LFS_ERR_NOENT; @@ -7138,50 +7138,50 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL)))))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 1, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => LFS_ERR_NOENT; @@ -7259,7 +7259,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id, names[perm[j] % 6], 4, NULL))) => 0; } assert(rbyd.weight == N); @@ -7289,21 +7289,21 @@ code = ''' cfg->block_size, NULL) => 0; assert(rbyd.weight == N-1); for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, k, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 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); } } - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, N-1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, N-1, buffer, 4) => LFS_ERR_NOENT; // try recreating the id to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, j, NULL, 1, - LFSR_ATTR(MKREG, j, names[j % 6], 6, NULL))) => 0; + LFSR_ATTR(REG, j, names[j % 6], 6, NULL))) => 0; assert(rbyd.weight == N); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, @@ -7311,11 +7311,11 @@ code = ''' assert(rbyd.weight == N); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, k, buffer, 6) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, k, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, k, buffer, 6) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, k, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } @@ -7420,7 +7420,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id, names[perm[j] % 6], 4, NULL))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -7456,7 +7456,7 @@ code = ''' cfg->block_size, NULL) => 0; assert(rbyd.weight == N-1); for (unsigned k = 0; k < N-1; k++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, k, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, k, buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { @@ -7473,7 +7473,7 @@ code = ''' } } } - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, N-1, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, N-1, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), N-1, buffer, 4) => LFS_ERR_NOENT; @@ -7482,7 +7482,7 @@ code = ''' printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, j, NULL, 1, - LFSR_ATTR(MKREG, j, names[j % 6], 6, NULL))) => 0; + LFSR_ATTR(REG, j, names[j % 6], 6, NULL))) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(u+1), j, names[j % 6], 3, NULL)) => 0; @@ -7494,7 +7494,7 @@ code = ''' assert(rbyd.weight == N); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, k, buffer, 6) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, k, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); @@ -7505,7 +7505,7 @@ code = ''' assert(memcmp(buffer, names[k % 6], 3) == 0); } } else { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, k, buffer, 6) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, k, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -7616,7 +7616,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id, names[perm[j] % 6], 4, NULL))) => 0; } assert(rbyd.weight == N); @@ -7652,7 +7652,7 @@ code = ''' for (unsigned k = 0; k < N-1; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k); assert(size_ == 4); @@ -7746,7 +7746,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id, names[perm[j] % 6], 4, NULL))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -7788,7 +7788,7 @@ code = ''' for (unsigned k = 0; k < N-1; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, NULL, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k); assert(size_ == 4); @@ -7849,17 +7849,17 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; // create and delete two ids @@ -7867,20 +7867,20 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 0, NULL, 1, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; // create and delete two ids in the other order @@ -7888,20 +7888,20 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 1, NULL, 1, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; // create and delete three ids @@ -7909,23 +7909,23 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 0, NULL, 1, LFSR_ATTR(SHRINK, 0, NULL, 1, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL)))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; // create and delete three ids in the other order @@ -7933,23 +7933,23 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 2, NULL, 1, LFSR_ATTR(SHRINK, 1, NULL, 1, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL)))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; ''' @@ -7976,18 +7976,18 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; // create and delete two ids @@ -7995,22 +7995,22 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 0, NULL, 1, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; // create and delete two ids in the other order @@ -8018,22 +8018,22 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 1, NULL, 1, LFSR_ATTR(SHRINK, 0, NULL, 1, NULL))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; // create and delete three ids @@ -8041,13 +8041,13 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL)))))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 0, NULL, 1, @@ -8055,12 +8055,12 @@ code = ''' LFSR_ATTR(SHRINK, 0, NULL, 1, NULL)))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; // create and delete three ids in the other order @@ -8068,13 +8068,13 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL)))))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(SHRINK, 2, NULL, 1, @@ -8082,12 +8082,12 @@ code = ''' LFSR_ATTR(SHRINK, 0, NULL, 1, NULL)))) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; ''' @@ -8136,7 +8136,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, j, NULL, 1, - LFSR_ATTR(MKREG, j, names[j % 6], 4, + LFSR_ATTR(REG, j, names[j % 6], 4, NULL))) => 0; } assert(rbyd.weight == N); @@ -8193,24 +8193,24 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, - LFSR_TAG_MKREG, 0, buffer, 4) + LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; // try resuming from all tags being removed lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, NULL))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, - LFSR_TAG_MKREG, 0, buffer, 6) + LFSR_TAG_REG, 0, buffer, 6) => 6; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0); lfsr_rbyd_get(&lfs, &rbyd, - LFSR_TAG_MKREG, 1, buffer, 6) + LFSR_TAG_REG, 1, buffer, 6) => LFS_ERR_NOENT; // keep track of the worst size @@ -8284,7 +8284,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, j, NULL, 1, - LFSR_ATTR(MKREG, j, names[j % 6], 4, + LFSR_ATTR(REG, j, names[j % 6], 4, NULL))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -8347,13 +8347,13 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, - LFSR_TAG_MKREG, 0, buffer, 4) + LFSR_TAG_REG, 0, buffer, 4) => LFS_ERR_NOENT; // try resuming from all tags being removed lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, NULL))) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, @@ -8365,7 +8365,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, - LFSR_TAG_MKREG, 0, buffer, 6) + LFSR_TAG_REG, 0, buffer, 6) => 6; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0); for (unsigned u = 0; u < M; u++) { @@ -8375,7 +8375,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa\xaa", 3) == 0); } lfsr_rbyd_get(&lfs, &rbyd, - LFSR_TAG_MKREG, 1, buffer, 6) + LFSR_TAG_REG, 1, buffer, 6) => LFS_ERR_NOENT; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 6) @@ -8486,7 +8486,7 @@ code = ''' // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, &alpha[i % 26], 1, + LFSR_ATTR(REG, id, &alpha[i % 26], 1, NULL))) => 0; } else { // update our sim @@ -8511,7 +8511,7 @@ code = ''' printf("rbyd: ["); for (lfs_ssize_t id = 0; id < (lfs_ssize_t)rbyd.weight; id++) { lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd, - LFSR_TAG_MKREG, id, buffer, 4); + LFSR_TAG_REG, id, buffer, 4); if (size >= 0) { printf("%.*s", size, buffer); } else { @@ -8525,7 +8525,7 @@ code = ''' assert(count == rbyd.weight); for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, id, buffer, 4) => 1; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, id, buffer, 4) => 1; assert(memcmp(&sim[id], buffer, 1) == 0); } @@ -8577,13 +8577,13 @@ code = ''' // create three ids lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 2, "\xcc\xcc\xcc\xcc", 4, NULL))))))))) => 0; // delete the last two @@ -8594,44 +8594,44 @@ code = ''' // will end up losing tags lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR(REG, 1, "\xdd\xdd\xdd\xdd", 4, LFSR_ATTR(UATTR(1), 1, "\xdd\xdd", 2, LFSR_ATTR(GROW, 2, NULL, 1, - LFSR_ATTR(MKREG, 2, "\xee\xee\xee\xee", 4, + LFSR_ATTR(REG, 2, "\xee\xee\xee\xee", 4, LFSR_ATTR(UATTR(1), 2, "\xee\xee", 2, NULL))))))) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xdd\xdd\xdd\xdd", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xdd\xdd", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 3, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 3, buffer, 4) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 1, buffer, 4) => 4; assert(memcmp(buffer, "\xdd\xdd\xdd\xdd", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 1, buffer, 4) => 2; assert(memcmp(buffer, "\xdd\xdd", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 2, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 2, buffer, 4) => 4; assert(memcmp(buffer, "\xee\xee\xee\xee", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, buffer, 4) => 2; assert(memcmp(buffer, "\xee\xee", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 3, buffer, 4) + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 3, buffer, 4) => LFS_ERR_NOENT; ''' @@ -8664,19 +8664,19 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -8684,32 +8684,32 @@ code = ''' // make id2 with weight w2 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 2, - LFSR_ATTR(MKREG, 2, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 2, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -8717,44 +8717,44 @@ code = ''' // make id5 with weight w3 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 3, NULL, 3, - LFSR_ATTR(MKREG, 5, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 5, "\xcc\xcc\xcc\xcc", 4, NULL))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); @@ -8762,56 +8762,56 @@ code = ''' // make id9 with weight w4 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 6, NULL, 4, - LFSR_ATTR(MKREG, 9, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR(REG, 9, "\xdd\xdd\xdd\xdd", 4, NULL))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 9, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 9, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); @@ -8819,68 +8819,68 @@ code = ''' // make id14 with weight w5 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 10, NULL, 5, - LFSR_ATTR(MKREG, 14, "\xee\xee\xee\xee", 4, + LFSR_ATTR(REG, 14, "\xee\xee\xee\xee", 4, NULL))) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 9, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 14, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 14, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); assert(size_ == 4); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 9, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 14, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 14, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); assert(size_ == 4); @@ -8913,49 +8913,49 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, // make id0 with weight w1 LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, // make id2 with weight w2 LFSR_ATTR(GROW, 1, NULL, 2, - LFSR_ATTR(MKREG, 2, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 2, "\xbb\xbb\xbb\xbb", 4, // make id5 with weight w3 LFSR_ATTR(GROW, 3, NULL, 3, - LFSR_ATTR(MKREG, 5, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 5, "\xcc\xcc\xcc\xcc", 4, // make id9 with weight w4 LFSR_ATTR(GROW, 6, NULL, 4, - LFSR_ATTR(MKREG, 9, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR(REG, 9, "\xdd\xdd\xdd\xdd", 4, // make id14 with weight w5 LFSR_ATTR(GROW, 10, NULL, 5, - LFSR_ATTR(MKREG, 14, "\xee\xee\xee\xee", 4, + LFSR_ATTR(REG, 14, "\xee\xee\xee\xee", 4, NULL))))))))))) => 0; // traverse, finding tags and weights lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); assert(size_ == 4); @@ -8965,31 +8965,31 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); assert(size_ == 4); @@ -9068,21 +9068,21 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id*W, NULL, W, - LFSR_ATTR(MKREG, id*W+W-1, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id*W+W-1, names[perm[j] % 6], 4, NULL))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; assert(rbyd.weight == N*W); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, j*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, j*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == j*W+W-1); assert(weight_ == W); assert(size_ == 4); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j*W+W-1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, j*W+W-1, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } } @@ -9159,7 +9159,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id*W, NULL, W, - LFSR_ATTR(MKREG, id*W+W-1, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id*W+W-1, names[perm[j] % 6], 4, NULL))) => 0; } @@ -9171,7 +9171,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == j*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -9213,7 +9213,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(3), -1, "unrelated", 9, LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(UATTR(2), 0, "\xaa\xaa", 2, NULL)))))) => 0; @@ -9223,9 +9223,9 @@ code = ''' assert(id_ == -1); assert(weight_ == 0); assert(size_ == 9); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9249,9 +9249,9 @@ code = ''' assert(id_ == -1); assert(weight_ == 0); assert(size_ == 9); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9271,7 +9271,7 @@ code = ''' // make id2 with weight w2 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, LFSR_ATTR(GROW, 1, NULL, 1, LFSR_ATTR(UATTR(2), 2, "\xbb\xbb", 2, @@ -9283,9 +9283,9 @@ code = ''' assert(id_ == -1); assert(weight_ == 0); assert(size_ == 9); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9301,9 +9301,9 @@ code = ''' assert(id_ == 0); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -9327,9 +9327,9 @@ code = ''' assert(id_ == -1); assert(weight_ == 0); assert(size_ == 9); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9345,9 +9345,9 @@ code = ''' assert(id_ == 0); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -9367,7 +9367,7 @@ code = ''' // make id5 with weight w3 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 3, NULL, 1, - LFSR_ATTR(MKREG, 3, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 3, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 3, "\xcc\xcc", 2, LFSR_ATTR(GROW, 3, NULL, 2, LFSR_ATTR(UATTR(2), 5, "\xcc\xcc", 2, @@ -9379,9 +9379,9 @@ code = ''' assert(id_ == -1); assert(weight_ == 0); assert(size_ == 9); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9397,9 +9397,9 @@ code = ''' assert(id_ == 0); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -9415,9 +9415,9 @@ code = ''' assert(id_ == 2); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); @@ -9441,9 +9441,9 @@ code = ''' assert(id_ == -1); assert(weight_ == 0); assert(size_ == 9); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9459,9 +9459,9 @@ code = ''' assert(id_ == 0); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -9477,9 +9477,9 @@ code = ''' assert(id_ == 2); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); @@ -9499,7 +9499,7 @@ code = ''' // make id9 with weight w4 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 6, NULL, 1, - LFSR_ATTR(MKREG, 6, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR(REG, 6, "\xdd\xdd\xdd\xdd", 4, LFSR_ATTR(UATTR(1), 6, "\xdd\xdd", 2, LFSR_ATTR(GROW, 6, NULL, 3, LFSR_ATTR(UATTR(2), 9, "\xdd\xdd", 2, @@ -9511,9 +9511,9 @@ code = ''' assert(id_ == -1); assert(weight_ == 0); assert(size_ == 9); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9529,9 +9529,9 @@ code = ''' assert(id_ == 0); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -9547,9 +9547,9 @@ code = ''' assert(id_ == 2); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); @@ -9565,9 +9565,9 @@ code = ''' assert(id_ == 5); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 9, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); @@ -9591,9 +9591,9 @@ code = ''' assert(id_ == -1); assert(weight_ == 0); assert(size_ == 9); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9609,9 +9609,9 @@ code = ''' assert(id_ == 0); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -9627,9 +9627,9 @@ code = ''' assert(id_ == 2); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); @@ -9645,9 +9645,9 @@ code = ''' assert(id_ == 5); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 9, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); @@ -9667,7 +9667,7 @@ code = ''' // make id14 with weight w5 lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, 10, NULL, 1, - LFSR_ATTR(MKREG, 10, "\xee\xee\xee\xee", 4, + LFSR_ATTR(REG, 10, "\xee\xee\xee\xee", 4, LFSR_ATTR(UATTR(1), 10, "\xee\xee", 2, LFSR_ATTR(GROW, 10, NULL, 4, LFSR_ATTR(UATTR(2), 14, "\xee\xee", 2, @@ -9679,9 +9679,9 @@ code = ''' assert(id_ == -1); assert(weight_ == 0); assert(size_ == 9); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9697,9 +9697,9 @@ code = ''' assert(id_ == 0); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -9715,9 +9715,9 @@ code = ''' assert(id_ == 2); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); @@ -9733,9 +9733,9 @@ code = ''' assert(id_ == 5); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 9, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); @@ -9751,9 +9751,9 @@ code = ''' assert(id_ == 9); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 14, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 14, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); assert(size_ == 4); @@ -9777,9 +9777,9 @@ code = ''' assert(id_ == -1); assert(weight_ == 0); assert(size_ == 9); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9795,9 +9795,9 @@ code = ''' assert(id_ == 0); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 2, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -9813,9 +9813,9 @@ code = ''' assert(id_ == 2); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 5, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); @@ -9831,9 +9831,9 @@ code = ''' assert(id_ == 5); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 9, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); @@ -9849,9 +9849,9 @@ code = ''' assert(id_ == 9); assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 14, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 14, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); assert(size_ == 4); @@ -9897,30 +9897,30 @@ code = ''' LFSR_ATTR(UATTR(3), -1, "unrelated", 9, // make id0 with weight w1 LFSR_ATTR(GROW, 0, NULL, 1, - LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(REG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, LFSR_ATTR(UATTR(2), 0, "\xaa\xaa", 2, // make id2 with weight w2 LFSR_ATTR(GROW, 1, NULL, 1, - LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(REG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, LFSR_ATTR(GROW, 1, NULL, 1, LFSR_ATTR(UATTR(2), 2, "\xbb\xbb", 2, // make id5 with weight w3 LFSR_ATTR(GROW, 3, NULL, 1, - LFSR_ATTR(MKREG, 3, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(REG, 3, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 3, "\xcc\xcc", 2, LFSR_ATTR(GROW, 3, NULL, 2, LFSR_ATTR(UATTR(2), 5, "\xcc\xcc", 2, // make id9 with weight w4 LFSR_ATTR(GROW, 6, NULL, 1, - LFSR_ATTR(MKREG, 6, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR(REG, 6, "\xdd\xdd\xdd\xdd", 4, LFSR_ATTR(UATTR(1), 6, "\xdd\xdd", 2, LFSR_ATTR(GROW, 6, NULL, 3, LFSR_ATTR(UATTR(2), 9, "\xdd\xdd", 2, // make id14 with weight w5 LFSR_ATTR(GROW, 10, NULL, 1, - LFSR_ATTR(MKREG, 10, "\xee\xee\xee\xee", 4, + LFSR_ATTR(REG, 10, "\xee\xee\xee\xee", 4, LFSR_ATTR(UATTR(1), 10, "\xee\xee", 2, LFSR_ATTR(GROW, 10, NULL, 4, LFSR_ATTR(UATTR(2), 14, "\xee\xee", 2, @@ -9935,7 +9935,7 @@ code = ''' assert(size_ == 9); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -9953,7 +9953,7 @@ code = ''' assert(size_ == 2); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -9971,7 +9971,7 @@ code = ''' assert(size_ == 2); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); @@ -9989,7 +9989,7 @@ code = ''' assert(size_ == 2); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); @@ -10007,7 +10007,7 @@ code = ''' assert(size_ == 2); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); assert(size_ == 4); @@ -10035,7 +10035,7 @@ code = ''' assert(size_ == 9); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 0); assert(weight_ == 1); assert(size_ == 4); @@ -10053,7 +10053,7 @@ code = ''' assert(size_ == 2); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 2); assert(weight_ == 2); assert(size_ == 4); @@ -10071,7 +10071,7 @@ code = ''' assert(size_ == 2); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 5); assert(weight_ == 3); assert(size_ == 4); @@ -10089,7 +10089,7 @@ code = ''' assert(size_ == 2); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 9); assert(weight_ == 4); assert(size_ == 4); @@ -10107,7 +10107,7 @@ code = ''' assert(size_ == 2); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == 14); assert(weight_ == 5); assert(size_ == 4); @@ -10201,7 +10201,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id*W, NULL, 1, - LFSR_ATTR(MKREG, id*W, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id*W, names[perm[j] % 6], 4, LFSR_ATTR(UATTR(1), id*W, names[perm[j] % 6], 2, LFSR_ATTR(GROW, id*W, NULL, W-1, LFSR_ATTR(UATTR(2), id*W+W-1, names[perm[j] % 6], 2, @@ -10217,9 +10217,9 @@ code = ''' assert(weight_ == 0); assert(size_ == 9); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, j*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, j*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == j*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -10236,7 +10236,7 @@ code = ''' assert(weight_ == 0); assert(size_ == 2); - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j*W+W-1, buffer, 4) => 4; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, j*W+W-1, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } } @@ -10316,7 +10316,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id*W, NULL, 1, - LFSR_ATTR(MKREG, id*W, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id*W, names[perm[j] % 6], 4, LFSR_ATTR(UATTR(1), id*W, names[perm[j] % 6], 2, LFSR_ATTR(GROW, id*W, NULL, W-1, LFSR_ATTR(UATTR(2), id*W+W-1, names[perm[j] % 6], 2, @@ -10337,7 +10337,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == j*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -10434,7 +10434,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id*W, NULL, W, - LFSR_ATTR(MKREG, id*W+W-1, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id*W+W-1, names[perm[j] % 6], 4, NULL))) => 0; } assert(rbyd.weight == N*W); @@ -10465,23 +10465,23 @@ code = ''' assert(rbyd.weight == N*W+1); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1+1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1+1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1+1); assert(weight_ == W+1); assert(size_ == 4); } else if (k > j) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1+1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1+1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1+1); assert(weight_ == W); assert(size_ == 4); } else { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -10565,7 +10565,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id*W, NULL, W, - LFSR_ATTR(MKREG, id*W+W-1, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id*W+W-1, names[perm[j] % 6], 4, NULL))) => 0; } assert(rbyd.weight == N*W); @@ -10596,23 +10596,23 @@ code = ''' assert(rbyd.weight == N*W-1); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1-1); assert(weight_ == W-1); assert(size_ == 4); } else if (k > j) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1-1); assert(weight_ == W); assert(size_ == 4); } else { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -10696,7 +10696,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id*W, NULL, W, - LFSR_ATTR(MKREG, id*W+W-1, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id*W+W-1, names[perm[j] % 6], 4, NULL))) => 0; } assert(rbyd.weight == N*W); @@ -10727,9 +10727,9 @@ code = ''' assert(rbyd.weight == (N-1)*W); for (unsigned k = 0; k < N-1; k++) { if (k >= j) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -10737,9 +10737,9 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); } else { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -10753,7 +10753,7 @@ code = ''' printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, j*W, NULL, W, - LFSR_ATTR(MKREG, j*W+W-1, names[j % 6], 6, + LFSR_ATTR(REG, j*W+W-1, names[j % 6], 6, NULL))) => 0; assert(rbyd.weight == N*W); @@ -10762,9 +10762,9 @@ code = ''' assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); assert(size_ == 6); @@ -10772,9 +10772,9 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -10858,7 +10858,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id*W, NULL, W, - LFSR_ATTR(MKREG, id*W+W-1, names[perm[j] % 6], 4, + LFSR_ATTR(REG, id*W+W-1, names[perm[j] % 6], 4, NULL))) => 0; } assert(rbyd.weight == N*W); @@ -10889,9 +10889,9 @@ code = ''' cfg->block_size, NULL) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -10919,9 +10919,9 @@ code = ''' cfg->block_size, NULL) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -10945,9 +10945,9 @@ code = ''' cfg->block_size, NULL) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, k*W+W-1, &tag_, &id_, &weight_, &off_, &size_) => 0; - assert(tag_ == LFSR_TAG_MKREG); + assert(tag_ == LFSR_TAG_REG); assert(id_ == k*W+W-1); assert(weight_ == W); assert(size_ == 4); @@ -11063,7 +11063,7 @@ code = ''' // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, id, NULL, 1, - LFSR_ATTR(MKREG, id, &alpha[i % 26], 1, + LFSR_ATTR(REG, id, &alpha[i % 26], 1, NULL))) => 0; } else if (op == 1) { // update our sim @@ -11110,7 +11110,7 @@ code = ''' printf("rbyd: ["); for (lfs_ssize_t id = 0; id < (lfs_ssize_t)rbyd.weight; id++) { lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd, - LFSR_TAG_MKREG, id, buffer, 4); + LFSR_TAG_REG, id, buffer, 4); if (size >= 0) { printf("%.*s", size, buffer); } else { @@ -11133,7 +11133,7 @@ code = ''' assert(count == rbyd.weight); for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) { - lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, id, buffer, 4) => 1; + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, id, buffer, 4) => 1; assert(memcmp(&sim[id*(M+1)], buffer, 1) == 0); } @@ -11267,7 +11267,7 @@ code = ''' // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(GROW, weighted_id, NULL, weight, - LFSR_ATTR(MKREG, weighted_id+weight-1, + LFSR_ATTR(REG, weighted_id+weight-1, &alpha[i % 26], 1, NULL))) => 0; } else if (op == 1) { @@ -11320,7 +11320,7 @@ code = ''' } int err = lfsr_rbyd_lookup(&lfs, &rbyd, - LFSR_TAG_MKREG, weighted_id, + LFSR_TAG_REG, weighted_id, &tag_, &id_, &weight_, &off_, &size_); if (!err) { lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd, @@ -11354,7 +11354,7 @@ code = ''' } lfsr_rbyd_lookup(&lfs, &rbyd, - LFSR_TAG_MKREG, weighted_id, + LFSR_TAG_REG, weighted_id, &tag_, &id_, &weight_, &off_, &size_) => 0; lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 1; assert(memcmp(&sim[id], buffer, 1) == 0);