tal: remove unused assigned var (scan-build warning)

[ccan] / ccan / tal / tal.c

diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c
index 1934a01318a3f09060614e144d189fff8467469b..df4020ea07e4997b6888d9418cf521fa74437e6a 100644 (file)
--- a/ccan/tal/tal.c
+++ b/ccan/tal/tal.c
@@ -630,31 +630,16 @@ tal_t *tal_first(const tal_t *root)
        return from_tal_hdr(c);
 }
 
-tal_t *tal_next(const tal_t *root, const tal_t *prev)
+tal_t *tal_next(const tal_t *prev)
 {
-        struct tal_hdr *c, *t = debug_tal(to_tal_hdr(prev)), *top;
+        struct tal_hdr *next, *prevhdr = debug_tal(to_tal_hdr(prev));
+       struct list_head *head;
 
-        /* Children? */
-       c = first_child(t);
-       if (c)
-               return from_tal_hdr(c);
-
-        top = to_tal_hdr_or_null(root);
-        do {
-               struct tal_hdr *next;
-               struct list_node *end;
-
-               end = &ignore_destroying_bit(t->parent_child)->children.n;
-
-               next = list_entry(t->list.next, struct tal_hdr, list);
-               if (&next->list != end)
-                       return from_tal_hdr(next);
-
-                /* OK, go back to parent. */
-                t = ignore_destroying_bit(t->parent_child)->parent;
-        } while (t != top);
-
-        return NULL;
+       head = &ignore_destroying_bit(prevhdr->parent_child)->children;
+       next = list_next(head, prevhdr, list);
+       if (!next)
+               return NULL;
+       return from_tal_hdr(next);
 }
 
 tal_t *tal_parent(const tal_t *ctx)
@@ -670,13 +655,13 @@ tal_t *tal_parent(const tal_t *ctx)
         return from_tal_hdr(ignore_destroying_bit(t->parent_child)->parent);
 }
 
-bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
+bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear)
 {
         struct tal_hdr *old_t, *t;
         struct children *child;
        struct prop_hdr **lenp;
        struct length len;
-       size_t extra = 0;
+       size_t extra = 0, elemsize = size;
 
         old_t = debug_tal(to_tal_hdr(*ctxp));
 
@@ -688,7 +673,8 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
                /* Copy here, in case we're shrinking! */
                len = *(struct length *)*lenp;
                extra = extra_for_length(size);
-       }
+       } else /* If we don't have an old length, we can't clear! */
+               assert(!clear);
 
         t = resizefn(old_t, sizeof(struct tal_hdr) + size + extra);
        if (!t) {
@@ -700,6 +686,12 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
        if (lenp) {
                struct length *new_len;
 
+               /* Clear between old end and new end. */
+               if (clear && count > len.count) {
+                       char *old_end = (char *)(t + 1) + len.count * elemsize;
+                       memset(old_end, 0, elemsize * (count - len.count));
+               }
+
                new_len = (struct length *)((char *)(t + 1) + size);
                len.count = count;
                *new_len = len;
@@ -753,7 +745,7 @@ bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)
        assert(src < *ctxp
               || (char *)src >= (char *)(*ctxp) + (size * old_count));
 
-       if (!tal_resize_(ctxp, size, old_count + count))
+       if (!tal_resize_(ctxp, size, old_count + count, false))
                goto out;
 
        memcpy((char *)*ctxp + size * old_count, src, count * size);
@@ -789,7 +781,7 @@ void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
        if (taken(p)) {
                if (unlikely(!p))
                        return NULL;
-               if (unlikely(!tal_resize_((void **)&p, size, n + extra)))
+               if (unlikely(!tal_resize_((void **)&p, size, n + extra, false)))
                        return tal_free(p);
                if (unlikely(!tal_steal(ctx, p)))
                        return tal_free(p);
@@ -914,7 +906,6 @@ static bool check_node(struct children *parent_child,
                        if (name)
                                return check_err(t, errorstr,
                                                 "has extra literal");
-                       name = (struct name *)p;
                        break;
                }
                if (!in_bounds(p))