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)
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));
/* 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) {
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;
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);
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);