Github/littlefs
1
Fork 0
Code Actions Activity

Removed mid argument from lfsr_mdir_lookup*

Browse Source 
With lfsr_mdir_t being a logical cursor pointing to a specific metadata
entry in the on-disk mdir, we don't really need the mid to be provided
on every lookup call (may have jumped the gun a bit in the attr-list
changes).

In the rare case we need to lookup unrelated mids, we call always call
lfsr_rbyd_lookup on the underlying rbyd.

This saves a little bit of code/stack:

            code          stack
  before:  33964           2896
  after:   33852 (-0.3%)   2888 (-0.3%)
This commit is contained in:
Christopher Haster
2024-01-28 00:05:55 -06:00
parent d30ed42c7f
commit 40b926b947
2 changed files with 170 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+36 -45
View File
@@ -5128,12 +5128,12 @@ static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir,
} }
static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir,
lfsr_smid_t mid, lfsr_tag_t tag, lfsr_tag_t tag,
lfsr_tag_t *tag_, lfsr_data_t *data_) { lfsr_tag_t *tag_, lfsr_data_t *data_) {
lfsr_srid_t rid__; lfsr_srid_t rid__;
lfsr_tag_t tag__; lfsr_tag_t tag__;
int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd, int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd,
lfsr_mid_rid(lfs, mid), tag, lfsr_mid_rid(lfs, mdir->mid), tag,
&rid__, &tag__, NULL, data_); &rid__, &tag__, NULL, data_);
if (err) { if (err) {
return err; return err;
@@ -5141,7 +5141,7 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir,
// this is very similar to lfsr_rbyd_lookupnext, but we error if // this is very similar to lfsr_rbyd_lookupnext, but we error if
// lookupnext would change mids // lookupnext would change mids
if (rid__ != lfsr_mid_rid(lfs, mid)) { if (rid__ != lfsr_mid_rid(lfs, mdir->mid)) {
return LFS_ERR_NOENT; return LFS_ERR_NOENT;
} }
@@ -5151,7 +5151,7 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir,
// semantics, and it's easier to manage the implied mid gap in // semantics, and it's easier to manage the implied mid gap in
// higher-levels // higher-levels
if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME
&& lfsr_grm_isrm(&lfs->grm, mid)) { && lfsr_grm_isrm(&lfs->grm, mdir->mid)) {
tag__ = LFSR_TAG_ORPHAN; tag__ = LFSR_TAG_ORPHAN;
} }
@@ -5162,10 +5162,10 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir,
} }
static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir, static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
lfsr_smid_t mid, lfsr_tag_t tag, lfsr_tag_t tag,
lfsr_data_t *data_) { lfsr_data_t *data_) {
lfsr_tag_t tag_; lfsr_tag_t tag_;
int err = lfsr_mdir_lookupnext(lfs, mdir, mid, tag, int err = lfsr_mdir_lookupnext(lfs, mdir, tag,
&tag_, data_); &tag_, data_);
if (err) { if (err) {
return err; return err;
@@ -5181,13 +5181,13 @@ static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
} }
static int lfsr_mdir_sublookup(lfs_t *lfs, const lfsr_mdir_t *mdir, static int lfsr_mdir_sublookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
lfsr_smid_t mid, lfsr_tag_t tag, lfsr_tag_t tag,
lfsr_tag_t *tag_, lfsr_data_t *data_) { lfsr_tag_t *tag_, lfsr_data_t *data_) {
// looking up a wide tag with subtype is probably a mistake // looking up a wide tag with subtype is probably a mistake
LFS_ASSERT(lfsr_tag_subtype(tag) == 0); LFS_ASSERT(lfsr_tag_subtype(tag) == 0);
lfsr_tag_t tag__; lfsr_tag_t tag__;
int err = lfsr_mdir_lookupnext(lfs, mdir, mid, tag, int err = lfsr_mdir_lookupnext(lfs, mdir, tag,
&tag__, data_); &tag__, data_);
if (err) { if (err) {
return err; return err;
@@ -5206,10 +5206,9 @@ static int lfsr_mdir_sublookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
} }
static int lfsr_mdir_suplookup(lfs_t *lfs, const lfsr_mdir_t *mdir, static int lfsr_mdir_suplookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
lfsr_smid_t mid,
lfsr_tag_t *tag_, lfsr_data_t *data_) { lfsr_tag_t *tag_, lfsr_data_t *data_) {
lfsr_tag_t tag__; lfsr_tag_t tag__;
int err = lfsr_mdir_lookupnext(lfs, mdir, mid, 0, int err = lfsr_mdir_lookupnext(lfs, mdir, 0,
&tag__, data_); &tag__, data_);
if (err) { if (err) {
return err; return err;
@@ -5388,7 +5387,7 @@ static void lfsr_fs_flushgdelta(lfs_t *lfs) {
static int lfsr_fs_consumegdelta(lfs_t *lfs, const lfsr_mdir_t *mdir) { static int lfsr_fs_consumegdelta(lfs_t *lfs, const lfsr_mdir_t *mdir) {
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_mdir_lookup(lfs, mdir, -1, LFSR_TAG_GRMDELTA, int err = lfsr_rbyd_lookup(lfs, &mdir->rbyd, -1, LFSR_TAG_GRMDELTA,
&data); &data);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
@@ -5547,8 +5546,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir,
lfsr_tag_t tag = LFSR_TAG_STRUCT-1; lfsr_tag_t tag = LFSR_TAG_STRUCT-1;
while (true) { while (true) {
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_mdir_lookupnext(lfs, mdir__, int err = lfsr_mdir_lookupnext(lfs, mdir__, tag+1,
mdir__->mid, tag+1,
&tag, &data); &tag, &data);
if (err) { if (err) {
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
@@ -6131,7 +6129,7 @@ static int lfsr_mroot_parent(lfs_t *lfs, const lfsr_mptr_t *mptr,
// lookup next mroot // lookup next mroot
lfsr_data_t data; lfsr_data_t data;
err = lfsr_mdir_lookup(lfs, &mdir, -1, LFSR_TAG_MROOT, err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_MROOT,
&data); &data);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_NOENT); LFS_ASSERT(err != LFS_ERR_NOENT);
@@ -7075,7 +7073,7 @@ static int lfsr_mtree_pathlookup(lfs_t *lfs, const char *path,
// read the next did from the mdir if this is not the root // read the next did from the mdir if this is not the root
if (mdir.mid != -1) { if (mdir.mid != -1) {
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_mdir_lookup(lfs, &mdir, mdir.mid, LFSR_TAG_DID, int err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_DID,
&data); &data);
if (err) { if (err) {
return err; return err;
@@ -7225,7 +7223,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal,
lfsr_tag_t tag; lfsr_tag_t tag;
lfsr_data_t data; lfsr_data_t data;
err = lfsr_mdir_sublookup(lfs, &traversal->file.mdir, err = lfsr_mdir_sublookup(lfs, &traversal->file.mdir,
-1, LFSR_TAG_STRUCT, LFSR_TAG_STRUCT,
&tag, &data); &tag, &data);
if (err) { if (err) {
// if we have no mtree/mdir (inlined mdir), we need to traverse // if we have no mtree/mdir (inlined mdir), we need to traverse
@@ -7436,7 +7434,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal,
// do we have a block/btree? // do we have a block/btree?
err = lfsr_mdir_lookupnext(lfs, &traversal->file.mdir, err = lfsr_mdir_lookupnext(lfs, &traversal->file.mdir,
traversal->file.mdir.mid, LFSR_TAG_DATA, LFSR_TAG_DATA,
&tag, &data); &tag, &data);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
@@ -7682,7 +7680,7 @@ static int lfs_deinit(lfs_t *lfs);
static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) { static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
// has magic string? // has magic string?
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_mdir_lookup(lfs, mroot, -1, LFSR_TAG_MAGIC, int err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_MAGIC,
&data); &data);
if (err) { if (err) {
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
@@ -7704,7 +7702,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
} }
// check the disk version // check the disk version
err = lfsr_mdir_lookup(lfs, mroot, -1, LFSR_TAG_VERSION, err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_VERSION,
&data); &data);
if (err) { if (err) {
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
@@ -7745,7 +7743,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
// check for any rcompatflags, we must understand these to read // check for any rcompatflags, we must understand these to read
// the filesystem // the filesystem
err = lfsr_mdir_lookup(lfs, mroot, -1, LFSR_TAG_RCOMPATFLAGS, err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_RCOMPATFLAGS,
&data); &data);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
@@ -7780,7 +7778,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
// check for any wcompatflags, we must understand these to write // check for any wcompatflags, we must understand these to write
// the filesystem // the filesystem
err = lfsr_mdir_lookup(lfs, mroot, -1, LFSR_TAG_WCOMPATFLAGS, err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_WCOMPATFLAGS,
&data); &data);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
@@ -7797,7 +7795,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
} }
// check block size // check block size
err = lfsr_mdir_lookup(lfs, mroot, -1, LFSR_TAG_BLOCKSIZE, err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_BLOCKSIZE,
&data); &data);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
@@ -7822,7 +7820,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
} }
// check block count // check block count
err = lfsr_mdir_lookup(lfs, mroot, -1, LFSR_TAG_BLOCKCOUNT, err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_BLOCKCOUNT,
&data); &data);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
@@ -7848,7 +7846,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
} }
// read the name limit // read the name limit
err = lfsr_mdir_lookup(lfs, mroot, -1, LFSR_TAG_NAMELIMIT, err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_NAMELIMIT,
&data); &data);
if (err) { if (err) {
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
@@ -7877,7 +7875,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
lfs->name_limit = name_limit; lfs->name_limit = name_limit;
// read the size limit // read the size limit
err = lfsr_mdir_lookup(lfs, mroot, -1, LFSR_TAG_SIZELIMIT, err = lfsr_mdir_lookup(lfs, mroot, LFSR_TAG_SIZELIMIT,
&data); &data);
if (err) { if (err) {
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
@@ -7907,7 +7905,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
// check for unknown configs // check for unknown configs
lfsr_tag_t tag; lfsr_tag_t tag;
err = lfsr_mdir_lookupnext(lfs, mroot, -1, LFSR_TAG_SIZELIMIT+1, err = lfsr_mdir_lookupnext(lfs, mroot, LFSR_TAG_SIZELIMIT+1,
&tag, NULL); &tag, NULL);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
@@ -7979,7 +7977,7 @@ static int lfsr_mountinited(lfs_t *lfs) {
for (lfs_size_t rid = 0; for (lfs_size_t rid = 0;
rid < (lfs_size_t)tinfo.u.mdir.rbyd.weight; rid < (lfs_size_t)tinfo.u.mdir.rbyd.weight;
rid++) { rid++) {
err = lfsr_mdir_lookup(lfs, &tinfo.u.mdir, err = lfsr_rbyd_lookup(lfs, &tinfo.u.mdir.rbyd,
rid, LFSR_TAG_ORPHAN, rid, LFSR_TAG_ORPHAN,
NULL); NULL);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
@@ -8353,7 +8351,7 @@ static int lfsr_fs_fixorphans(lfs_t *lfs) {
// is this mid opened? skip // is this mid opened? skip
if (!lfsr_mid_isopened(lfs, mdir.mid)) { if (!lfsr_mid_isopened(lfs, mdir.mid)) {
// are we an orphaned file? // are we an orphaned file?
err = lfsr_mdir_lookup(lfs, &mdir, mdir.mid, LFSR_TAG_ORPHAN, err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_ORPHAN,
NULL); NULL);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
@@ -8607,7 +8605,7 @@ int lfsr_remove(lfs_t *lfs, const char *path) {
if (tag == LFSR_TAG_DIR) { if (tag == LFSR_TAG_DIR) {
// first lets figure out the did // first lets figure out the did
lfsr_data_t data; lfsr_data_t data;
err = lfsr_mdir_lookup(lfs, &mdir, mdir.mid, LFSR_TAG_DID, err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_DID,
&data); &data);
if (err) { if (err) {
return err; return err;
@@ -8639,8 +8637,7 @@ int lfsr_remove(lfs_t *lfs, const char *path) {
if (err != LFS_ERR_NOENT) { if (err != LFS_ERR_NOENT) {
lfsr_tag_t bookmark_tag; lfsr_tag_t bookmark_tag;
err = lfsr_mdir_sublookup(lfs, &bookmark_mdir, err = lfsr_mdir_sublookup(lfs, &bookmark_mdir, LFSR_TAG_NAME,
bookmark_mdir.mid, LFSR_TAG_NAME,
&bookmark_tag, NULL); &bookmark_tag, NULL);
if (err) { if (err) {
return err; return err;
@@ -8769,8 +8766,7 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) {
// TODO deduplicate the isempty check with lfsr_remove? // TODO deduplicate the isempty check with lfsr_remove?
// first lets figure out the did // first lets figure out the did
lfsr_data_t data; lfsr_data_t data;
err = lfsr_mdir_lookup(lfs, &new_mdir, err = lfsr_mdir_lookup(lfs, &new_mdir, LFSR_TAG_DID,
new_mdir.mid, LFSR_TAG_DID,
&data); &data);
if (err) { if (err) {
return err; return err;
@@ -8802,8 +8798,7 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) {
if (err != LFS_ERR_NOENT) { if (err != LFS_ERR_NOENT) {
lfsr_tag_t bookmark_tag; lfsr_tag_t bookmark_tag;
err = lfsr_mdir_sublookup(lfs, &bookmark_mdir, err = lfsr_mdir_sublookup(lfs, &bookmark_mdir, LFSR_TAG_NAME,
bookmark_mdir.mid, LFSR_TAG_NAME,
&bookmark_tag, NULL); &bookmark_tag, NULL);
if (err) { if (err) {
return err; return err;
@@ -8867,7 +8862,7 @@ static int lfsr_stat_(lfs_t *lfs, const lfsr_mdir_t *mdir,
// inlined? // inlined?
lfsr_tag_t tag; lfsr_tag_t tag;
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_mdir_lookupnext(lfs, mdir, mdir->mid, LFSR_TAG_DATA, int err = lfsr_mdir_lookupnext(lfs, mdir, LFSR_TAG_DATA,
&tag, &data); &tag, &data);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
@@ -8955,7 +8950,7 @@ int lfsr_dir_open(lfs_t *lfs, lfsr_dir_t *dir, const char *path) {
} }
lfsr_data_t data; lfsr_data_t data;
err = lfsr_mdir_lookup(lfs, &mdir, mdir.mid, LFSR_TAG_DID, err = lfsr_mdir_lookup(lfs, &mdir, LFSR_TAG_DID,
&data); &data);
if (err) { if (err) {
return err; return err;
@@ -9025,8 +9020,7 @@ int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info) {
// lookup the next name tag // lookup the next name tag
lfsr_tag_t tag; lfsr_tag_t tag;
lfsr_data_t data; lfsr_data_t data;
err = lfsr_mdir_sublookup(lfs, &dir->p.mdir, err = lfsr_mdir_sublookup(lfs, &dir->p.mdir, LFSR_TAG_NAME,
dir->p.mdir.mid, LFSR_TAG_NAME,
&tag, &data); &tag, &data);
if (err) { if (err) {
return err; return err;
@@ -9329,8 +9323,7 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file,
// read any inlined state // read any inlined state
lfsr_tag_t tag; lfsr_tag_t tag;
lfsr_data_t data; lfsr_data_t data;
err = lfsr_mdir_lookupnext(lfs, &file->m.mdir, err = lfsr_mdir_lookupnext(lfs, &file->m.mdir, LFSR_TAG_DATA,
file->m.mdir.mid, LFSR_TAG_DATA,
&tag, &data); &tag, &data);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
@@ -9473,8 +9466,7 @@ static lfs_ssize_t lfsr_bshrub_estimate(lfs_t *lfs, const lfsr_file_t *file) {
// including the on-disk sprout/shrub // including the on-disk sprout/shrub
lfsr_tag_t tag; lfsr_tag_t tag;
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_mdir_lookupnext(lfs, &file->m.mdir, int err = lfsr_mdir_lookupnext(lfs, &file->m.mdir, LFSR_TAG_DATA,
file->m.mdir.mid, LFSR_TAG_DATA,
&tag, &data); &tag, &data);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
LFS_ASSERT(err < 0); LFS_ASSERT(err < 0);
@@ -11080,8 +11072,7 @@ int lfsr_file_sync(lfs_t *lfs, lfsr_file_t *file) {
// not created yet? need to convert orphan to normal file // not created yet? need to convert orphan to normal file
if (lfsr_f_isorphan(file->m.flags)) { if (lfsr_f_isorphan(file->m.flags)) {
lfsr_data_t data; lfsr_data_t data;
err = lfsr_mdir_lookup(lfs, &file->m.mdir, err = lfsr_mdir_lookup(lfs, &file->m.mdir, LFSR_TAG_ORPHAN,
file->m.mdir.mid, LFSR_TAG_ORPHAN,
&data); &data);
if (err) { if (err) {
// we must have an orphan at this point // we must have an orphan at this point
tests/test_mtree.toml
+134 -134
View File
@@ -9,9 +9,9 @@ defines.LOOKAHEAD_SIZE = 'BLOCK_COUNT / 8'
in = 'lfs.c' in = 'lfs.c'
code = ''' code = '''
static lfs_ssize_t lfsr_mdir_get(lfs_t *lfs, const lfsr_mdir_t *mdir, static lfs_ssize_t lfsr_mdir_get(lfs_t *lfs, const lfsr_mdir_t *mdir,
lfs_ssize_t rid, lfsr_tag_t tag, void *buffer, lfs_size_t size) { lfsr_tag_t tag, void *buffer, lfs_size_t size) {
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_mdir_lookup(lfs, mdir, rid, tag, &data); int err = lfsr_mdir_lookup(lfs, mdir, tag, &data);
if (err) { if (err) {
return err; return err;
} }
@@ -47,8 +47,8 @@ code = '''
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
uint8_t buffer[1]; uint8_t buffer[1];
lfsr_mdir_get(&lfs, &lfs.mroot, lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i),
-1, LFSR_TAG_UATTR(i), buffer, 1) => 1; buffer, 1) => 1;
assert(memcmp(buffer, &alphas[i % 26], 1) == 0); assert(memcmp(buffer, &alphas[i % 26], 1) == 0);
} }
@@ -60,8 +60,8 @@ code = '''
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
uint8_t buffer[1]; uint8_t buffer[1];
lfsr_mdir_get(&lfs, &lfs.mroot, lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i),
-1, LFSR_TAG_UATTR(i), buffer, 1) => 1; buffer, 1) => 1;
assert(memcmp(buffer, &alphas[i % 26], 1) == 0); assert(memcmp(buffer, &alphas[i % 26], 1) == 0);
} }
@@ -89,8 +89,8 @@ code = '''
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
uint8_t buffer[1]; uint8_t buffer[1];
lfsr_mdir_get(&lfs, &lfs.mroot, lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i),
-1, LFSR_TAG_UATTR(i), buffer, 1) => 1; buffer, 1) => 1;
assert(memcmp(buffer, &alphas[i % 26], 1) == 0); assert(memcmp(buffer, &alphas[i % 26], 1) == 0);
} }
@@ -102,8 +102,8 @@ code = '''
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
uint8_t buffer[1]; uint8_t buffer[1];
lfsr_mdir_get(&lfs, &lfs.mroot, lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(i),
-1, LFSR_TAG_UATTR(i), buffer, 1) => 1; buffer, 1) => 1;
assert(memcmp(buffer, &alphas[i % 26], 1) == 0); assert(memcmp(buffer, &alphas[i % 26], 1) == 0);
} }
@@ -126,14 +126,14 @@ code = '''
LFSR_ATTR(UATTR(1), 0, BUF(&alphas[i % 26], 1)))) => 0; LFSR_ATTR(UATTR(1), 0, BUF(&alphas[i % 26], 1)))) => 0;
uint8_t buffer[4]; uint8_t buffer[4];
lfsr_mdir_get(&lfs, &lfs.mroot, lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-1, LFSR_TAG_UATTR(1), buffer, 4) => 1; buffer, 4) => 1;
assert(memcmp(buffer, &alphas[i % 26], 1) == 0); assert(memcmp(buffer, &alphas[i % 26], 1) == 0);
} }
uint8_t buffer[4]; uint8_t buffer[4];
lfsr_mdir_get(&lfs, &lfs.mroot, lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-1, LFSR_TAG_UATTR(1), buffer, 4) => 1; buffer, 4) => 1;
assert(memcmp(buffer, &alphas[(N-1) % 26], 1) == 0); assert(memcmp(buffer, &alphas[(N-1) % 26], 1) == 0);
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
@@ -142,8 +142,8 @@ code = '''
// check things stay sane after remount // check things stay sane after remount
lfsr_mount(&lfs, CFG) => 0; lfsr_mount(&lfs, CFG) => 0;
lfsr_mdir_get(&lfs, &lfs.mroot, lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
-1, LFSR_TAG_UATTR(1), buffer, 4) => 1; buffer, 4) => 1;
assert(memcmp(buffer, &alphas[(N-1) % 26], 1) == 0); assert(memcmp(buffer, &alphas[(N-1) % 26], 1) == 0);
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
@@ -185,13 +185,13 @@ code = '''
assert(lfs.mroot.rbyd.weight == 0); assert(lfs.mroot.rbyd.weight == 0);
// assert that our attrs are still in the mroot/mtree // assert that our attrs are still in the mroot/mtree
lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'a'); assert(buffer[0] == 'a');
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'b'); assert(buffer[0] == 'b');
@@ -205,13 +205,13 @@ code = '''
assert(lfs.mroot.rbyd.weight == 0); assert(lfs.mroot.rbyd.weight == 0);
// assert that our attrs are still in the mroot/mtree // assert that our attrs are still in the mroot/mtree
lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'a'); assert(buffer[0] == 'a');
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'b'); assert(buffer[0] == 'b');
@@ -256,13 +256,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -278,13 +278,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -345,19 +345,19 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'c'); assert(buffer[1] == 'c');
@@ -373,19 +373,19 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'c'); assert(buffer[1] == 'c');
@@ -421,7 +421,7 @@ code = '''
LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0; LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0;
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} }
@@ -430,14 +430,14 @@ code = '''
lfsr_mdir_t mdir; lfsr_mdir_t mdir;
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
name[0] = '\0'; name[0] = '\0';
sprintf(name+1, "%03x", i); sprintf(name+1, "%03x", i);
lfsr_mtree_seek(&lfs, &mdir, +1) => 0; lfsr_mtree_seek(&lfs, &mdir, +1) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} }
@@ -448,14 +448,14 @@ code = '''
// try looking up each entry // try looking up each entry
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
name[0] = '\0'; name[0] = '\0';
sprintf(name+1, "%03x", i); sprintf(name+1, "%03x", i);
lfsr_mtree_seek(&lfs, &mdir, +1) => 0; lfsr_mtree_seek(&lfs, &mdir, +1) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} }
@@ -509,7 +509,7 @@ code = '''
// double check // double check
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} }
@@ -518,7 +518,7 @@ code = '''
lfsr_mdir_t mdir; lfsr_mdir_t mdir;
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
@@ -527,7 +527,7 @@ code = '''
if (sim[i]) { if (sim[i]) {
lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3, lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} else { } else {
@@ -542,7 +542,7 @@ code = '''
// try looking up each entry // try looking up each entry
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
@@ -551,7 +551,7 @@ code = '''
if (sim[i]) { if (sim[i]) {
lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3, lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} else { } else {
@@ -617,7 +617,7 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -633,7 +633,7 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -692,7 +692,7 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -708,7 +708,7 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -759,7 +759,7 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -775,7 +775,7 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -841,13 +841,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'c'); assert(buffer[1] == 'c');
@@ -863,13 +863,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'c'); assert(buffer[1] == 'c');
@@ -935,13 +935,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -957,13 +957,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -1019,7 +1019,7 @@ code = '''
// double check // double check
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
@@ -1050,7 +1050,7 @@ code = '''
lfsr_mdir_t mdir; lfsr_mdir_t mdir;
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
@@ -1059,7 +1059,7 @@ code = '''
if (sim[i]) { if (sim[i]) {
lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3, lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} else { } else {
@@ -1074,7 +1074,7 @@ code = '''
// try looking up each entry // try looking up each entry
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
@@ -1083,7 +1083,7 @@ code = '''
if (sim[i]) { if (sim[i]) {
lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3, lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} else { } else {
@@ -1150,13 +1150,13 @@ code = '''
assert(lfs.mroot.rbyd.weight == 0); assert(lfs.mroot.rbyd.weight == 0);
// assert that our attrs are still in the mroot/mtree // assert that our attrs are still in the mroot/mtree
lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'a'); assert(buffer[0] == 'a');
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'b'); assert(buffer[0] == 'b');
@@ -1170,13 +1170,13 @@ code = '''
assert(lfs.mroot.rbyd.weight == 0); assert(lfs.mroot.rbyd.weight == 0);
// assert that our attrs are still in the mroot/mtree // assert that our attrs are still in the mroot/mtree
lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'a'); assert(buffer[0] == 'a');
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'b'); assert(buffer[0] == 'b');
@@ -1242,13 +1242,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -1264,13 +1264,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -1336,13 +1336,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -1358,13 +1358,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -1405,7 +1405,7 @@ code = '''
// assert that our entry is still in the mroot // assert that our entry is still in the mroot
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -1416,7 +1416,7 @@ code = '''
// assert that our attr is still in the mroot // assert that our attr is still in the mroot
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -1474,7 +1474,7 @@ code = '''
// assert that our attr is still in the mroot // assert that our attr is still in the mroot
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -1485,7 +1485,7 @@ code = '''
// assert that our attr is still in the mroot // assert that our attr is still in the mroot
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -1535,7 +1535,7 @@ code = '''
// assert that our entry is still in the mroot // assert that our entry is still in the mroot
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -1546,7 +1546,7 @@ code = '''
// assert that our attr is still in the mroot // assert that our attr is still in the mroot
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -1617,13 +1617,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -1639,13 +1639,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -1720,19 +1720,19 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'c'); assert(buffer[1] == 'c');
@@ -1748,19 +1748,19 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'c'); assert(buffer[1] == 'c');
@@ -1830,7 +1830,7 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -1846,7 +1846,7 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -1895,13 +1895,13 @@ code = '''
assert(lfs.mroot.rbyd.weight == 0); assert(lfs.mroot.rbyd.weight == 0);
// assert that our attrs are still in the mroot/mtree // assert that our attrs are still in the mroot/mtree
lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'a'); assert(buffer[0] == 'a');
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'b'); assert(buffer[0] == 'b');
@@ -1915,13 +1915,13 @@ code = '''
assert(lfs.mroot.rbyd.weight == 0); assert(lfs.mroot.rbyd.weight == 0);
// assert that our attrs are still in the mroot/mtree // assert that our attrs are still in the mroot/mtree
lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'a'); assert(buffer[0] == 'a');
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'b'); assert(buffer[0] == 'b');
@@ -1976,13 +1976,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -1998,13 +1998,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -2062,7 +2062,7 @@ code = '''
// double check // double check
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
@@ -2090,7 +2090,7 @@ code = '''
// double check // double check
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
@@ -2121,7 +2121,7 @@ code = '''
lfsr_mdir_t mdir; lfsr_mdir_t mdir;
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
@@ -2130,7 +2130,7 @@ code = '''
if (sim[i]) { if (sim[i]) {
lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3, lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} else { } else {
@@ -2145,7 +2145,7 @@ code = '''
// try looking up each entry // try looking up each entry
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
@@ -2154,7 +2154,7 @@ code = '''
if (sim[i]) { if (sim[i]) {
lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3, lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} else { } else {
@@ -2201,7 +2201,7 @@ code = '''
// assert our entry was created // assert our entry was created
uint8_t buffer[2]; uint8_t buffer[2];
lfsr_mdir_get(&lfs, &mdir, 2, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, 2) => 2; buffer, 2) => 2;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -2958,7 +2958,7 @@ code = '''
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mtree_namelookup(&lfs, 0, "a", 1, lfsr_mtree_namelookup(&lfs, 0, "a", 1,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 2; buffer, sizeof(buffer)) => 2;
assert(memcmp(buffer, "\0a", 2) == 0); assert(memcmp(buffer, "\0a", 2) == 0);
@@ -2969,7 +2969,7 @@ code = '''
// assert that our entry is still in the mtree // assert that our entry is still in the mtree
lfsr_mtree_namelookup(&lfs, 0, "a", 1, lfsr_mtree_namelookup(&lfs, 0, "a", 1,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 2; buffer, sizeof(buffer)) => 2;
assert(memcmp(buffer, "\0a", 2) == 0); assert(memcmp(buffer, "\0a", 2) == 0);
@@ -3072,13 +3072,13 @@ code = '''
assert(lfs.mroot.rbyd.weight == 0); assert(lfs.mroot.rbyd.weight == 0);
// assert that our attrs are still in the mroot/mtree // assert that our attrs are still in the mroot/mtree
lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'a'); assert(buffer[0] == 'a');
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'b'); assert(buffer[0] == 'b');
@@ -3092,13 +3092,13 @@ code = '''
assert(lfs.mroot.rbyd.weight == 0); assert(lfs.mroot.rbyd.weight == 0);
// assert that our attrs are still in the mroot/mtree // assert that our attrs are still in the mroot/mtree
lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &lfs.mroot, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'a'); assert(buffer[0] == 'a');
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_UATTR(1), lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_UATTR(1),
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[0] == 'b'); assert(buffer[0] == 'b');
@@ -3207,13 +3207,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -3229,13 +3229,13 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
@@ -3360,19 +3360,19 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'c'); assert(buffer[1] == 'c');
@@ -3388,19 +3388,19 @@ code = '''
// assert that our entries are still in the mtree // assert that our entries are still in the mtree
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'b'); assert(buffer[1] == 'b');
lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &mdir) => 0;
assert(mdir.rbyd.weight == 1); assert(mdir.rbyd.weight == 1);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'c'); assert(buffer[1] == 'c');
@@ -3496,7 +3496,7 @@ code = '''
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mtree_namelookup(&lfs, 0, "a", 1, lfsr_mtree_namelookup(&lfs, 0, "a", 1,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 2; buffer, sizeof(buffer)) => 2;
assert(memcmp(buffer, "\0a", 2) == 0); assert(memcmp(buffer, "\0a", 2) == 0);
@@ -3507,7 +3507,7 @@ code = '''
// assert that our entry is still in the mtree // assert that our entry is still in the mtree
lfsr_mtree_namelookup(&lfs, 0, "a", 1, lfsr_mtree_namelookup(&lfs, 0, "a", 1,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 2; buffer, sizeof(buffer)) => 2;
assert(memcmp(buffer, "\0a", 2) == 0); assert(memcmp(buffer, "\0a", 2) == 0);
@@ -3543,7 +3543,7 @@ code = '''
LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0; LFSR_ATTR(REG, +1, BUF(name, 4)))) => 0;
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} }
@@ -3610,14 +3610,14 @@ code = '''
lfsr_mdir_t mdir; lfsr_mdir_t mdir;
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
name[0] = '\0'; name[0] = '\0';
sprintf(name+1, "%03x", i); sprintf(name+1, "%03x", i);
lfsr_mtree_seek(&lfs, &mdir, +1) => 0; lfsr_mtree_seek(&lfs, &mdir, +1) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} }
@@ -3628,14 +3628,14 @@ code = '''
// try looking up each entry // try looking up each entry
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
name[0] = '\0'; name[0] = '\0';
sprintf(name+1, "%03x", i); sprintf(name+1, "%03x", i);
lfsr_mtree_seek(&lfs, &mdir, +1) => 0; lfsr_mtree_seek(&lfs, &mdir, +1) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} }
@@ -3689,7 +3689,7 @@ code = '''
// double check // double check
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} }
@@ -3757,7 +3757,7 @@ code = '''
lfsr_mdir_t mdir; lfsr_mdir_t mdir;
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
uint8_t buffer[256]; uint8_t buffer[256];
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
@@ -3766,7 +3766,7 @@ code = '''
if (sim[i]) { if (sim[i]) {
lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3, lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} else { } else {
@@ -3781,7 +3781,7 @@ code = '''
// try looking up each entry // try looking up each entry
lfsr_mtree_lookup(&lfs, 0, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0, &mdir) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_BOOKMARK, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_BOOKMARK,
buffer, sizeof(buffer)) => 1; buffer, sizeof(buffer)) => 1;
for (lfs_size_t i = 0; i < N; i++) { for (lfs_size_t i = 0; i < N; i++) {
char name[256]; char name[256];
@@ -3790,7 +3790,7 @@ code = '''
if (sim[i]) { if (sim[i]) {
lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3, lfsr_mtree_namelookup(&lfs, 0, (const char*)name+1, 3,
&mdir, NULL, NULL) => 0; &mdir, NULL, NULL) => 0;
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, sizeof(buffer)) => 4; buffer, sizeof(buffer)) => 4;
assert(memcmp(buffer, name, 4) == 0); assert(memcmp(buffer, name, 4) == 0);
} else { } else {
@@ -3909,7 +3909,7 @@ code = '''
// assert that our entry is still in the mroot // assert that our entry is still in the mroot
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');
@@ -3978,7 +3978,7 @@ code = '''
// assert that our attr is still in the mroot // assert that our attr is still in the mroot
lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0;
assert(mdir.rbyd.weight == 2); assert(mdir.rbyd.weight == 2);
lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, lfsr_mdir_get(&lfs, &mdir, LFSR_TAG_REG,
buffer, SIZE) => SIZE; buffer, SIZE) => SIZE;
assert(buffer[1] == 'a'); assert(buffer[1] == 'a');