From 932679668fc44839727ae350a1c2e94b26bcfc0a Mon Sep 17 00:00:00 2001

From: Nir Soffer <nsoffer@redhat.com>

Date: Sat, 6 Nov 2021 00:03:11 +0200

Subject: [PATCH] common/utils/vector: Rename `size` to `len`

The field `size` may be confusing with the size of the underlying array.

Rename to `len`, a common term for this concept.

Tested with "make check" as regular user, tests that need root or

external libraries (vddk) are not tested.

Ported from libnbd commit cc0567e9aed7e6b40a44bf8eac0a262ac7314fec.

(cherry picked from commit 0b0eece73f04963a66b9adc507e5cbaba608660b)

---

 common/allocators/allocator.c        |   2 +-

 common/allocators/malloc.c           |   2 +-

 common/allocators/sparse.c           |   6 +-

 common/allocators/zstd.c             |   6 +-

 common/regions/regions.h             |   6 +-

 common/utils/environ.c               |   2 +-

 common/utils/test-vector.c           |   2 +-

 common/utils/vector.h                |  52 ++++++------

 filters/ddrescue/ddrescue.c          |   2 +-

 filters/exitwhen/exitwhen.c          |   2 +-

 filters/extentlist/extentlist.c      |  14 ++--

 filters/multi-conn/multi-conn.c      |  16 ++--

 plugins/cc/cc.c                      |   4 +-

 plugins/data/data.c                  |   4 +-

 plugins/data/format.c                | 114 +++++++++++++--------------

 plugins/eval/eval.c                  |   2 +-

 plugins/floppy/directory-lfn.c       |  24 +++---

 plugins/floppy/floppy.c              |   2 +-

 plugins/floppy/virtual-floppy.c      |  32 ++++----

 plugins/iso/iso.c                    |   4 +-

 plugins/nbd/nbd.c                    |   6 +-

 plugins/partitioning/partition-mbr.c |   8 +-

 plugins/partitioning/partitioning.c  |  18 ++---

 plugins/partitioning/virtual-disk.c  |  12 +--

 plugins/partitioning/virtual-disk.h  |   2 +-

 plugins/split/split.c                |  14 ++--

 plugins/ssh/ssh.c                    |   2 +-

 plugins/vddk/reexec.c                |   8 +-

 plugins/vddk/stats.c                 |   4 +-

 plugins/vddk/worker.c                |   4 +-

 server/exports.c                     |   6 +-

 server/extents.c                     |  22 +++---

 server/main.c                        |   2 +-

 server/sockets.c                     |   8 +-

 wrapper.c                            |   4 +-

 35 files changed, 209 insertions(+), 209 deletions(-)

diff --git a/common/allocators/allocator.c b/common/allocators/allocator.c

index d306a842..019c68cd 100644

--- a/common/allocators/allocator.c

+++ b/common/allocators/allocator.c

@@ -137,7 +137,7 @@ create_allocator (const char *type, bool debug)

     return NULL;

   /* See if we can find the allocator. */

-  for (i = 0; i < allocators.size; ++i) {

+  for (i = 0; i < allocators.len; ++i) {

     if (strncmp (type, allocators.ptr[i]->type, type_len) == 0) {

       ret = allocators.ptr[i]->create (&params);

       break;

diff --git a/common/allocators/malloc.c b/common/allocators/malloc.c

index f7474465..eea44432 100644

--- a/common/allocators/malloc.c

+++ b/common/allocators/malloc.c

@@ -241,7 +241,7 @@ m_alloc_create (const void *paramsv)

   size_t i;

   /* Parse the optional mlock=true|false parameter. */

-  for (i = 0; i < params->size; ++i) {

+  for (i = 0; i < params->len; ++i) {

     if (strcmp (params->ptr[i].key, "mlock") == 0) {

       int r = nbdkit_parse_bool (params->ptr[i].value);

       if (r == -1) return NULL;

diff --git a/common/allocators/sparse.c b/common/allocators/sparse.c

index ca508c35..7c6d1636 100644

--- a/common/allocators/sparse.c

+++ b/common/allocators/sparse.c

@@ -150,7 +150,7 @@ sparse_array_free (struct allocator *a)

   size_t i;

   if (sa) {

-    for (i = 0; i < sa->l1_dir.size; ++i)

+    for (i = 0; i < sa->l1_dir.len; ++i)

       free_l2_dir (sa->l1_dir.ptr[i].l2_dir);

     free (sa->l1_dir.ptr);

     pthread_mutex_destroy (&sa->lock);

@@ -184,7 +184,7 @@ insert_l1_entry (struct sparse_array *sa, const struct l1_entry *entry)

 {

   size_t i;

-  for (i = 0; i < sa->l1_dir.size; ++i) {

+  for (i = 0; i < sa->l1_dir.len; ++i) {

     if (entry->offset < sa->l1_dir.ptr[i].offset) {

       /* Insert new entry before i'th directory entry. */

       if (l1_dir_insert (&sa->l1_dir, *entry, i) == -1) {

@@ -508,7 +508,7 @@ sparse_array_create (const void *paramsv)

   const allocator_parameters *params  = paramsv;

   struct sparse_array *sa;

-  if (params->size > 0) {

+  if (params->len > 0) {

     nbdkit_error ("allocator=sparse does not take extra parameters");

     return NULL;

   }

diff --git a/common/allocators/zstd.c b/common/allocators/zstd.c

index 81fe4ed0..1675d21c 100644

--- a/common/allocators/zstd.c

+++ b/common/allocators/zstd.c

@@ -136,7 +136,7 @@ zstd_array_free (struct allocator *a)

     ZSTD_freeCCtx (za->zcctx);

     ZSTD_freeDStream (za->zdstrm);

-    for (i = 0; i < za->l1_dir.size; ++i)

+    for (i = 0; i < za->l1_dir.len; ++i)

       free_l2_dir (za->l1_dir.ptr[i].l2_dir);

     free (za->l1_dir.ptr);

     pthread_mutex_destroy (&za->lock);

@@ -170,7 +170,7 @@ insert_l1_entry (struct zstd_array *za, const struct l1_entry *entry)

 {

   size_t i;

-  for (i = 0; i < za->l1_dir.size; ++i) {

+  for (i = 0; i < za->l1_dir.len; ++i) {

     if (entry->offset < za->l1_dir.ptr[i].offset) {

       /* Insert new entry before i'th directory entry. */

       if (l1_dir_insert (&za->l1_dir, *entry, i) == -1) {

@@ -600,7 +600,7 @@ zstd_array_create (const void *paramsv)

   const allocator_parameters *params  = paramsv;

   struct zstd_array *za;

-  if (params->size > 0) {

+  if (params->len > 0) {

     nbdkit_error ("allocator=zstd does not take extra parameters");

     return NULL;

   }

diff --git a/common/regions/regions.h b/common/regions/regions.h

index 6dfd5d88..3d562316 100644

--- a/common/regions/regions.h

+++ b/common/regions/regions.h

@@ -84,17 +84,17 @@ extern void free_regions (regions *regions)

 static inline size_t __attribute__((__nonnull__ (1)))

 nr_regions (regions *rs)

 {

-  return rs->size;

+  return rs->len;

 }

 /* Return the virtual size of the disk. */

 static inline int64_t __attribute__((__nonnull__ (1)))

 virtual_size (regions *rs)

 {

-  if (rs->size == 0)

+  if (rs->len == 0)

     return 0;

   else

-    return rs->ptr[rs->size-1].end + 1;

+    return rs->ptr[rs->len-1].end + 1;

 }

 /* Look up the region corresponding to the given offset.  If the

diff --git a/common/utils/environ.c b/common/utils/environ.c

index e70976cb..2ad996eb 100644

--- a/common/utils/environ.c

+++ b/common/utils/environ.c

@@ -82,7 +82,7 @@ copy_environ (char **env, ...)

     /* Search for key in the existing environment.  It's O(n^2) ... */

     len = strlen (key);

-    for (i = 0; i < ret.size; ++i) {

+    for (i = 0; i < ret.len; ++i) {

       if (strncmp (key, ret.ptr[i], len) == 0 && ret.ptr[i][len] == '=') {

         /* Replace the existing key. */

         free (ret.ptr[i]);

diff --git a/common/utils/test-vector.c b/common/utils/test-vector.c

index 28af59b8..6d89a281 100644

--- a/common/utils/test-vector.c

+++ b/common/utils/test-vector.c

@@ -73,7 +73,7 @@ test_int64_vector (void)

     assert (v.ptr[i] == i);

   int64_vector_remove (&v, 1);

-  assert (v.size == 9);

+  assert (v.len == 9);

   assert (v.ptr[1] == 2);

   tmp = 10;

diff --git a/common/utils/vector.h b/common/utils/vector.h

index 782dcba6..1d04f812 100644

--- a/common/utils/vector.h

+++ b/common/utils/vector.h

@@ -59,14 +59,14 @@

  *

  *   string_vector names = empty_vector;

  *

- * where ‘names.ptr[]’ will be an array of strings and ‘names.size’

+ * where ‘names.ptr[]’ will be an array of strings and ‘names.len’

  * will be the number of strings.  There are no get/set accessors.  To

  * iterate over the strings you can use the ‘.ptr’ field directly:

  *

- *   for (size_t i = 0; i < names.size; ++i)

+ *   for (size_t i = 0; i < names.len; ++i)

  *     printf ("%s\n", names.ptr[i]);

  *

- * Initializing with ‘empty_vector’ sets ‘.ptr = NULL’ and ‘.size = 0’.

+ * Initializing with ‘empty_vector’ sets ‘.ptr = NULL’ and ‘.len = 0’.

  *

  * DEFINE_VECTOR_TYPE also defines utility functions.  For the full

  * list see the definition below, but useful functions include:

@@ -84,15 +84,15 @@

  */

 #define DEFINE_VECTOR_TYPE(name, type)                                  \

   struct name {                                                         \

-    type *ptr;                 /* Pointer to array of items. */         \

-    size_t size;               /* Number of valid items in the array. */ \

-    size_t cap;                /* Maximum number of items. */           \

+    type *ptr;              /* Pointer to array of items. */            \

+    size_t len;             /* Number of valid items in the array. */   \

+    size_t cap;             /* Maximum number of items. */              \

   };                                                                    \

   typedef struct name name;                                             \

                                                                         \

   /* Reserve n elements at the end of the vector.  Note space is        \

-   * allocated but the vector size is not increased and the new         \

-   * elements are not initialized.                                      \

+   * allocated and capacity is increased, but the vector length         \

+   * is not increased and the new elements are not initialized.         \

    */                                                                   \

   static inline int                                                     \

   name##_reserve (name *v, size_t n)                                    \

@@ -101,17 +101,17 @@

                                    sizeof (type));                      \

   }                                                                     \

                                                                         \

-  /* Insert at i'th element.  i=0 => beginning  i=size => append */     \

+  /* Insert at i'th element.  i=0 => beginning  i=len => append */      \

   static inline int                                                     \

   name##_insert (name *v, type elem, size_t i)                          \

   {                                                                     \

-    assert (i <= v->size);                                              \

-    if (v->size >= v->cap) {                                            \

+    assert (i <= v->len);                                               \

+    if (v->len >= v->cap) {                                             \

       if (name##_reserve (v, 1) == -1) return -1;                       \

     }                                                                   \

-    memmove (&v->ptr[i+1], &v->ptr[i], (v->size-i) * sizeof (elem));    \

+    memmove (&v->ptr[i+1], &v->ptr[i], (v->len-i) * sizeof (elem));     \

     v->ptr[i] = elem;                                                   \

-    v->size++;                                                          \

+    v->len++;                                                           \

     return 0;                                                           \

   }                                                                     \

                                                                         \

@@ -119,16 +119,16 @@

   static inline int                                                     \

   name##_append (name *v, type elem)                                    \

   {                                                                     \

-    return name##_insert (v, elem, v->size);                            \

+    return name##_insert (v, elem, v->len);                             \

   }                                                                     \

                                                                         \

-  /* Remove i'th element.  i=0 => beginning  i=size-1 => end */         \

+  /* Remove i'th element.  i=0 => beginning  i=len-1 => end */          \

   static inline void                                                    \

   name##_remove (name *v, size_t i)                                     \

   {                                                                     \

-    assert (i < v->size);                                               \

-    memmove (&v->ptr[i], &v->ptr[i+1], (v->size-i-1) * sizeof (type));  \

-    v->size--;                                                          \

+    assert (i < v->len);                                                \

+    memmove (&v->ptr[i], &v->ptr[i+1], (v->len-i-1) * sizeof (type));   \

+    v->len--;                                                           \

   }                                                                     \

                                                                         \

   /* Remove all elements and deallocate the vector. */                  \

@@ -137,7 +137,7 @@

   {                                                                     \

     free (v->ptr);                                                      \

     v->ptr = NULL;                                                      \

-    v->size = v->cap = 0;                                               \

+    v->len = v->cap = 0;                                                \

   }                                                                     \

                                                                         \

   /* Iterate over the vector, calling f() on each element. */           \

@@ -145,7 +145,7 @@

   name##_iter (name *v, void (*f) (type elem))                          \

   {                                                                     \

     size_t i;                                                           \

-    for (i = 0; i < v->size; ++i)                                       \

+    for (i = 0; i < v->len; ++i)                                        \

       f (v->ptr[i]);                                                    \

   }                                                                     \

                                                                         \

@@ -154,7 +154,7 @@

   name##_sort (name *v,                                                 \

                int (*compare) (const type *p1, const type *p2))         \

   {                                                                     \

-    qsort (v->ptr, v->size, sizeof (type), (void *) compare);           \

+    qsort (v->ptr, v->len, sizeof (type), (void *) compare);            \

   }                                                                     \

                                                                         \

   /* Search for an exactly matching element in the vector using a       \

@@ -164,7 +164,7 @@

   name##_search (const name *v, const void *key,                        \

                  int (*compare) (const void *key, const type *v))       \

   {                                                                     \

-    return bsearch (key, v->ptr, v->size, sizeof (type),                \

+    return bsearch (key, v->ptr, v->len, sizeof (type),                 \

                     (void *) compare);                                  \

   }                                                                     \

                                                                         \

@@ -175,22 +175,22 @@

     /* Note it's allowed for v and copy to be the same pointer. */      \

     type *vptr = v->ptr;                                                \

     type *newptr;                                                       \

-    size_t len = v->size * sizeof (type);                               \

+    size_t len = v->len * sizeof (type);                                \

                                                                         \

     newptr = malloc (len);                                              \

     if (newptr == NULL) return -1;                                      \

     memcpy (newptr, vptr, len);                                         \

     copy->ptr = newptr;                                                 \

-    copy->size = copy->cap = v->size;                                   \

+    copy->len = copy->cap = v->len;                                     \

     return 0;                                                           \

   }                                                                     \

                                                                         \

-#define empty_vector { .ptr = NULL, .size = 0, .cap = 0 }

+#define empty_vector { .ptr = NULL, .len = 0, .cap = 0 }

 struct generic_vector {

   void *ptr;

-  size_t size;

+  size_t len;

   size_t cap;

 };

diff --git a/filters/ddrescue/ddrescue.c b/filters/ddrescue/ddrescue.c

index 7b1c9c1e..218c8ee5 100644

--- a/filters/ddrescue/ddrescue.c

+++ b/filters/ddrescue/ddrescue.c

@@ -180,7 +180,7 @@ ddrescue_pread (nbdkit_next *next,

 {

   size_t i;

-  for (i = 0; i < map.ranges.size; i++) {

+  for (i = 0; i < map.ranges.len; i++) {

     if (map.ranges.ptr[i].status != '+')

       continue;

     if (offset >= map.ranges.ptr[i].start && offset <= map.ranges.ptr[i].end) {

diff --git a/filters/exitwhen/exitwhen.c b/filters/exitwhen/exitwhen.c

index 543af058..83e99953 100644

--- a/filters/exitwhen/exitwhen.c

+++ b/filters/exitwhen/exitwhen.c

@@ -143,7 +143,7 @@ check_for_event (void)

   size_t i;

   if (!exiting) {

-    for (i = 0; i < events.size; ++i) {

+    for (i = 0; i < events.len; ++i) {

       const struct event *event = &events.ptr[i];

       switch (event->type) {

diff --git a/filters/extentlist/extentlist.c b/filters/extentlist/extentlist.c

index 7e6f1b78..c91fbfea 100644

--- a/filters/extentlist/extentlist.c

+++ b/filters/extentlist/extentlist.c

@@ -134,7 +134,7 @@ parse_extentlist (void)

   assert (extentlist != NULL);

   assert (extents.ptr == NULL);

-  assert (extents.size == 0);

+  assert (extents.len == 0);

   fp = fopen (extentlist, "r");

   if (!fp) {

@@ -200,7 +200,7 @@ parse_extentlist (void)

   /* There must not be overlaps at this point. */

   end = 0;

-  for (i = 0; i < extents.size; ++i) {

+  for (i = 0; i < extents.len; ++i) {

     if (extents.ptr[i].offset < end ||

         extents.ptr[i].offset + extents.ptr[i].length < extents.ptr[i].offset) {

       nbdkit_error ("extents in the extent list are overlapping");

@@ -210,8 +210,8 @@ parse_extentlist (void)

   }

   /* If there's a gap at the beginning, insert a hole|zero extent. */

-  if (extents.size == 0 || extents.ptr[0].offset > 0) {

-    end = extents.size == 0 ? UINT64_MAX : extents.ptr[0].offset;

+  if (extents.len == 0 || extents.ptr[0].offset > 0) {

+    end = extents.len == 0 ? UINT64_MAX : extents.ptr[0].offset;

     if (extent_list_insert (&extents,

                             (struct extent){.offset = 0, .length = end,

                                             .type = HOLE},

@@ -224,7 +224,7 @@ parse_extentlist (void)

   /* Now insert hole|zero extents after every extent where there

    * is a gap between that extent and the next one.

    */

-  for (i = 0; i < extents.size-1; ++i) {

+  for (i = 0; i < extents.len-1; ++i) {

     end = extents.ptr[i].offset + extents.ptr[i].length;

     if (end < extents.ptr[i+1].offset)

       if (extent_list_insert (&extents,

@@ -238,7 +238,7 @@ parse_extentlist (void)

   }

   /* If there's a gap at the end, insert a hole|zero extent. */

-  end = extents.ptr[extents.size-1].offset + extents.ptr[extents.size-1].length;

+  end = extents.ptr[extents.len-1].offset + extents.ptr[extents.len-1].length;

   if (end < UINT64_MAX) {

     if (extent_list_append (&extents,

                             (struct extent){.offset = end,

@@ -250,7 +250,7 @@ parse_extentlist (void)

   }

   /* Debug the final list. */

-  for (i = 0; i < extents.size; ++i) {

+  for (i = 0; i < extents.len; ++i) {

     nbdkit_debug ("extentlist: "

                   "extent[%zu] = %" PRIu64 "-%" PRIu64 " (length %" PRIu64 ")"

                   " type %" PRIu32,

diff --git a/filters/multi-conn/multi-conn.c b/filters/multi-conn/multi-conn.c

index a6a25ef9..c7421a39 100644

--- a/filters/multi-conn/multi-conn.c

+++ b/filters/multi-conn/multi-conn.c

@@ -207,14 +207,14 @@ multi_conn_prepare (nbdkit_next *next, void *handle, int readonly)

   ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);

   if (byname) {

     g = NULL;

-    for (i = 0; i < groups.size; i++)

+    for (i = 0; i < groups.len; i++)

       if (strcmp (groups.ptr[i]->name, h->name) == 0) {

         g = groups.ptr[i];

         break;

       }

   }

   else

-    g = groups.size ? groups.ptr[0] : NULL;

+    g = groups.len ? groups.ptr[0] : NULL;

   if (!g) {

     g = calloc (1, sizeof *g);

@@ -230,7 +230,7 @@ multi_conn_prepare (nbdkit_next *next, void *handle, int readonly)

   }

   if (conns_vector_append (&g->conns, h) == -1) {

     if (new_group) {

-      group_vector_remove (&groups, groups.size - 1);

+      group_vector_remove (&groups, groups.len - 1);

       free (g->name);

       free (g);

     }

@@ -251,14 +251,14 @@ multi_conn_finalize (nbdkit_next *next, void *handle)

   assert (h->group);

   /* XXX should we add a config param to flush if the client forgot? */

-  for (i = 0; i < h->group->conns.size; i++) {

+  for (i = 0; i < h->group->conns.len; i++) {

     if (h->group->conns.ptr[i] == h) {

       conns_vector_remove (&h->group->conns, i);

       break;

     }

   }

-  if (h->group->conns.size == 0) {

-    for (i = 0; i < groups.size; i++)

+  if (h->group->conns.len == 0) {

+    for (i = 0; i < groups.len; i++)

       if (groups.ptr[i] == h->group) {

         group_vector_remove (&groups, i);

         free (h->group->name);

@@ -451,7 +451,7 @@ multi_conn_flush (nbdkit_next *next,

   assert (h->group);

   if (h->mode == EMULATE) {

     ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);

-    for (i = 0; i < h->group->conns.size; i++) {

+    for (i = 0; i < h->group->conns.len; i++) {

       h2 = h->group->conns.ptr[i];

       if (track == OFF || (h->group->dirty &&

                            (track == FAST || h2->dirty & READ)) ||

@@ -474,7 +474,7 @@ multi_conn_flush (nbdkit_next *next,

     case CONN:

       if (next->can_multi_conn (next) == 1) {

         ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);

-        for (i = 0; i < h->group->conns.size; i++)

+        for (i = 0; i < h->group->conns.len; i++)

           h->group->conns.ptr[i]->dirty = 0;

         h->group->dirty = 0;

       }

diff --git a/plugins/cc/cc.c b/plugins/cc/cc.c

index 3251f312..c8c3c86b 100644

--- a/plugins/cc/cc.c

+++ b/plugins/cc/cc.c

@@ -292,12 +292,12 @@ cc_config_complete (void)

   if (subplugin.load)

     subplugin.load ();

   if (subplugin.config) {

-    for (i = 0; i < params.size; ++i) {

+    for (i = 0; i < params.len; ++i) {

       if (subplugin.config (params.ptr[i].key, params.ptr[i].value) == -1)

         return -1;

     }

   }

-  else if (params.size > 0) {

+  else if (params.len > 0) {

     /* Just print the first one in the error message. */

     nbdkit_error ("unknown parameter: %s", params.ptr[0].key);

     return -1;

diff --git a/plugins/data/data.c b/plugins/data/data.c

index 03bcc8a5..960cf97d 100644

--- a/plugins/data/data.c

+++ b/plugins/data/data.c

@@ -158,7 +158,7 @@ get_extra_param (const char *name)

 {

   size_t i;

-  for (i = 0; i < params.size; ++i) {

+  for (i = 0; i < params.len; ++i) {

     if (strcmp (params.ptr[i].key, name) == 0)

       return params.ptr[i].value;

   }

@@ -176,7 +176,7 @@ data_config_complete (void)

     return -1;

   }

-  if (data_seen != DATA && params.size != 0) {

+  if (data_seen != DATA && params.len != 0) {

     nbdkit_error ("extra parameters passed and not using data='...'");

     return -1;

   }

diff --git a/plugins/data/format.c b/plugins/data/format.c

index d351f79a..986a0f6e 100644

--- a/plugins/data/format.c

+++ b/plugins/data/format.c

@@ -83,7 +83,7 @@ substring (string s, size_t offset, size_t len)

   string r = empty_vector;

   for (i = 0; i < len; ++i) {

-    assert (offset+i < s.size);

+    assert (offset+i < s.len);

     if (string_append (&r, s.ptr[offset+i]) == -1) {

       nbdkit_error ("realloc: %m");

       exit (EXIT_FAILURE);

@@ -167,7 +167,7 @@ static expr_list expr_table;

 static node_id

 new_node (const expr_t e)

 {

-  if (expr_table.size == 0) {

+  if (expr_table.len == 0) {

     static const expr_t enull = { .t = EXPR_NULL };

     if (expr_list_append (&expr_table, enull) == -1)

       goto out_of_memory;

@@ -179,14 +179,14 @@ new_node (const expr_t e)

     nbdkit_error ("realloc");

     exit (EXIT_FAILURE);

   }

-  return expr_table.size-1;

+  return expr_table.len-1;

 }

 /* Get an expression by node_id. */

 static expr_t

 get_node (node_id id)

 {

-  assert (id < expr_table.size);

+  assert (id < expr_table.len);

   return expr_table.ptr[id];

 }

@@ -196,7 +196,7 @@ free_expr_table (void)

   size_t i;

   expr_t e;

-  for (i = 0; i < expr_table.size; ++i) {

+  for (i = 0; i < expr_table.len; ++i) {

     e = get_node (i);

     switch (e.t) {

     case EXPR_LIST:   free (e.list.ptr); break;

@@ -344,7 +344,7 @@ debug_expr (node_id id, int level)

     break;

   case EXPR_LIST:

     nbdkit_debug ("%s(", debug_indent (level));

-    for (i = 0; i < e.list.size; ++i)

+    for (i = 0; i < e.list.len; ++i)

       debug_expr (e.list.ptr[i], level+1);

     nbdkit_debug ("%s)", debug_indent (level));

     break;

@@ -370,7 +370,7 @@ debug_expr (node_id id, int level)

     CLEANUP_FREE_STRING string s = empty_vector;

     static const char hex[] = "0123456789abcdef";

-    for (i = 0; i < e.string.size; ++i) {

+    for (i = 0; i < e.string.len; ++i) {

       char c = e.string.ptr[i];

       if (ascii_isprint ((char) c))

         string_append (&s, e.string.ptr[i]);

@@ -445,7 +445,7 @@ read_data_format (const char *value, struct allocator *a, uint64_t *size_rtn)

   uint64_t offset = 0;

   int r = -1;

-  assert (expr_table.size == 0);

+  assert (expr_table.len == 0);

   /* Run the parser across the entire string, returning the top level

    * expression.

@@ -600,11 +600,11 @@ parser (int level, const char *value, size_t *start, size_t len,

     case '*':                   /* expr*N */

       i++;

-      if (list.size == 0) {

+      if (list.len == 0) {

         nbdkit_error ("*N must follow an expression");

         return -1;

       }

-      if (! is_data_expr (get_node (list.ptr[list.size-1]))) {

+      if (! is_data_expr (get_node (list.ptr[list.len-1]))) {

         nbdkit_error ("*N cannot be applied to this type of expression");

         return -1;

       }

@@ -619,18 +619,18 @@ parser (int level, const char *value, size_t *start, size_t len,

         nbdkit_error ("*N not numeric");

         return -1;

       }

-      id = list.ptr[list.size-1];

-      list.size--;

+      id = list.ptr[list.len-1];

+      list.len--;

       APPEND_EXPR (new_node (expr (EXPR_REPEAT, id, (uint64_t) i64)));

       break;

     case '[':                 /* expr[k:m] */

       i++;

-      if (list.size == 0) {

+      if (list.len == 0) {

         nbdkit_error ("[N:M] must follow an expression");

         return -1;

       }

-      if (! is_data_expr (get_node (list.ptr[list.size-1]))) {

+      if (! is_data_expr (get_node (list.ptr[list.len-1]))) {

         nbdkit_error ("[N:M] cannot be applied to this type of expression");

         return -1;

       }

@@ -647,8 +647,8 @@ parser (int level, const char *value, size_t *start, size_t len,

         nbdkit_error ("enclosed pattern (...)[N:M] not numeric");

         return -1;

       }

-      id = list.ptr[list.size-1];

-      list.size--;

+      id = list.ptr[list.len-1];

+      list.len--;

       APPEND_EXPR (new_node (expr (EXPR_SLICE, id, i64, m)));

       break;

@@ -720,11 +720,11 @@ parser (int level, const char *value, size_t *start, size_t len,

       i++;

       if (value[i] != '>') goto parse_error;

       i++;

-      if (list.size == 0) {

+      if (list.len == 0) {

         nbdkit_error ("-> must follow an expression");

         return -1;

       }

-      if (! is_data_expr (get_node (list.ptr[list.size-1]))) {

+      if (! is_data_expr (get_node (list.ptr[list.len-1]))) {

         nbdkit_error ("-> cannot be applied to this type of expression");

         return -1;

       }

@@ -735,9 +735,9 @@ parser (int level, const char *value, size_t *start, size_t len,

         nbdkit_error ("strndup: %m");

         return -1;

       }

-      id = list.ptr[list.size-1];

+      id = list.ptr[list.len-1];

       i += flen;

-      list.size--;

+      list.len--;

       APPEND_EXPR (new_node (expr (EXPR_ASSIGN, name, id)));

       break;

     }

@@ -1023,7 +1023,7 @@ parse_word (const char *value, size_t *start, size_t len, string *rtn)

   }

   memcpy (copy.ptr, &value[*start], n);

   copy.ptr[n] = '\0';

-  copy.size = n + 1;

+  copy.len = n + 1;

   *start = i;

   /* Reserve enough space in the return buffer for the longest

@@ -1036,22 +1036,22 @@ parse_word (const char *value, size_t *start, size_t len, string *rtn)

   /* Parse the rest of {le|be}{16|32|64}: */

   if (strncmp (copy.ptr, "le16:", 5) == 0) {

-    endian = little; rtn->size = 2;

+    endian = little; rtn->len = 2;

   }

   else if (strncmp (copy.ptr, "le32:", 5) == 0) {

-    endian = little; rtn->size = 4;

+    endian = little; rtn->len = 4;

   }

   else if (strncmp (copy.ptr, "le64:", 5) == 0) {

-    endian = little; rtn->size = 8;

+    endian = little; rtn->len = 8;

   }

   else if (strncmp (copy.ptr, "be16:", 5) == 0) {

-    endian = big; rtn->size = 2;

+    endian = big; rtn->len = 2;

   }

   else if (strncmp (copy.ptr, "be32:", 5) == 0) {

-    endian = big; rtn->size = 4;

+    endian = big; rtn->len = 4;

   }

   else if (strncmp (copy.ptr, "be64:", 5) == 0) {

-    endian = big; rtn->size = 8;

+    endian = big; rtn->len = 8;