enum prop_type {
CHILDREN = 0x00c1d500,
NAME = 0x00111100,
- NOTIFIER = 0x00071f00
+ NOTIFIER = 0x00071f00,
+ LENGTH = 0x00515300
};
struct tal_hdr {
char name[];
};
+struct length {
+ struct prop_hdr hdr; /* LENGTH */
+ size_t count;
+};
+
struct notifier {
struct prop_hdr hdr; /* NOTIFIER */
enum tal_notify_type types;
static void *allocate(size_t size)
{
- void *ret;
-
- /* Don't hand silly sizes to malloc. */
- if (size >> (CHAR_BIT*sizeof(size) - 1)) {
- call_error("allocation size overflow");
- return NULL;
- }
-
- ret = allocfn(size);
+ void *ret = allocfn(size);
if (!ret)
call_error("allocation failed");
else
return prop;
}
+static struct length *add_length_property(struct tal_hdr *t, size_t count)
+{
+ struct length *prop;
+
+ prop = allocate(sizeof(*prop));
+ if (prop) {
+ init_property(&prop->hdr, t, LENGTH);
+ prop->count = count;
+ }
+ return prop;
+}
+
static struct children *add_child_property(struct tal_hdr *parent,
struct tal_hdr *child)
{
return from_tal_hdr(debug_tal(child));
}
+static bool adjust_size(size_t *size, size_t count)
+{
+ /* Multiplication wrap */
+ if (count && unlikely(*size * count / *size != count))
+ goto overflow;
+
+ *size *= count;
+
+ /* Make sure we don't wrap adding header. */
+ if (*size + sizeof(struct tal_hdr) < sizeof(struct tal_hdr))
+ goto overflow;
+ return true;
+overflow:
+ call_error("allocation size overflow");
+ return false;
+}
+
+void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
+ bool add_count, const char *label)
+{
+ void *ret;
+
+ if (!adjust_size(&size, count))
+ return NULL;
+
+ ret = tal_alloc_(ctx, size, clear, label);
+ if (likely(ret) && add_count) {
+ if (unlikely(!add_length_property(to_tal_hdr(ret), count)))
+ ret = tal_free(ret);
+ }
+ return ret;
+}
+
void *tal_free(const tal_t *ctx)
{
if (ctx) {
return n->name;
}
+size_t tal_count(const tal_t *ptr)
+{
+ struct length *l;
+
+ l = find_property(debug_tal(to_tal_hdr(ptr)), LENGTH);
+ if (!l)
+ return 0;
+ return l->count;
+}
+
/* Start one past first child: make stopping natural in circ. list. */
static struct tal_hdr *first_child(struct tal_hdr *parent)
{
return from_tal_hdr(ignore_destroying_bit(t->parent_child)->parent);
}
-bool tal_resize_(tal_t **ctxp, size_t size)
+bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
{
struct tal_hdr *old_t, *t;
struct children *child;
+ struct length *len;
old_t = debug_tal(to_tal_hdr(*ctxp));
- /* Don't hand silly sizes to realloc. */
- if (size >> (CHAR_BIT*sizeof(size) - 1)) {
- call_error("Reallocation size overflow");
+ if (!adjust_size(&size, count))
return false;
- }
t = resizefn(old_t, size + sizeof(struct tal_hdr));
if (!t) {
if (notifiers)
notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
}
+ len = find_property(t, LENGTH);
+ if (len)
+ len->count = count;
if (notifiers)
notify(t, TAL_NOTIFY_RESIZE, (void *)size);
char *tal_strdup(const tal_t *ctx, const char *p)
{
/* We have to let through NULL for take(). */
- return tal_dup(ctx, char, p, p ? strlen(p) + 1: 1, 0);
+ return tal_dup_(ctx, p, 1, p ? strlen(p) + 1: 1, 0, false,
+ TAL_LABEL(char, "[]"));
}
char *tal_strndup(const tal_t *ctx, const char *p, size_t n)
} else
len = n;
- ret = tal_dup(ctx, char, p, len, 1);
+ ret = tal_dup_(ctx, p, 1, len, 1, false, TAL_LABEL(char, "[]"));
if (ret)
ret[len] = '\0';
return ret;
}
-void *tal_dup_(const tal_t *ctx, const void *p, size_t n, size_t extra,
+void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
+ size_t n, size_t extra, bool add_count,
const char *label)
{
void *ret;
+ size_t nbytes = size;
- /* Beware overflow! */
- if (n + extra < n || n + extra + sizeof(struct tal_hdr) < n) {
+ if (!adjust_size(&nbytes, n)) {
+ if (taken(p))
+ tal_free(p);
+ return NULL;
+ }
+
+ /* Beware addition overflow! */
+ if (n + extra < n) {
call_error("dup size overflow");
if (taken(p))
tal_free(p);
if (taken(p)) {
if (unlikely(!p))
return NULL;
- if (unlikely(!tal_resize_((void **)&p, n + extra)))
+ if (unlikely(!tal_resize_((void **)&p, size, n + extra)))
return tal_free(p);
if (unlikely(!tal_steal(ctx, p)))
return tal_free(p);
return (void *)p;
}
- ret = tal_alloc_(ctx, n + extra, false, label);
+
+ ret = tal_alloc_arr_(ctx, size, n + extra, false, add_count, label);
if (ret)
- memcpy(ret, p, n);
+ memcpy(ret, p, nbytes);
return ret;
}
struct children *c;
struct name *n;
struct notifier *no;
+ struct length *l;
if (is_literal(p)) {
printf(" \"%s\"", (const char *)p);
break;
no = (struct notifier *)p;
printf(" NOTIFIER(%p):fn=%p", p, no->u.notifyfn);
break;
+ case LENGTH:
+ l = (struct length *)p;
+ printf(" LENGTH(%p):count=%zu", p, l->count);
+ break;
default:
printf(" **UNKNOWN(%p):%i**", p, p->type);
}
struct prop_hdr *p;
struct name *name = NULL;
struct children *children = NULL;
+ struct length *length = NULL;
if (!in_bounds(t))
return check_err(t, errorstr, "invalid pointer");
"has two child nodes");
children = (struct children *)p;
break;
+ case LENGTH:
+ if (length)
+ return check_err(t, errorstr,
+ "has two lengths");
+ length = (struct length *)p;
+ break;
case NOTIFIER:
break;
case NAME:
* int *p = tal(NULL, int);
* *p = 1;
*/
-#define tal(ctx, type) \
+#define tal(ctx, type) \
((type *)tal_alloc_((ctx), sizeof(type), false, TAL_LABEL(type, "")))
/**
* p = talz(NULL, int);
* assert(*p == 0);
*/
-#define talz(ctx, type) \
+#define talz(ctx, type) \
((type *)tal_alloc_((ctx), sizeof(type), true, TAL_LABEL(type, "")))
/**
* @type: the type to allocate.
* @count: the number to allocate.
*
+ * Note that an object allocated with tal_arr() has a length property;
+ * see tal_count().
+ *
* Example:
* p = tal_arr(NULL, int, 2);
* p[0] = 0;
* p[1] = 1;
*/
-#define tal_arr(ctx, type, count) \
- ((type *)tal_alloc_((ctx), tal_sizeof_(sizeof(type), (count)), false, \
- TAL_LABEL(type, "[]")))
+#define tal_arr(ctx, type, count) \
+ ((type *)tal_alloc_arr_((ctx), sizeof(type), (count), false, \
+ true, TAL_LABEL(type, "[]")))
/**
* tal_arrz - allocate an array of zeroed objects.
* @type: the type to allocate.
* @count: the number to allocate.
*
+ * Note that an object allocated with tal_arrz() has a length property;
+ * see tal_count().
+ *
* Example:
* p = tal_arrz(NULL, int, 2);
* assert(p[0] == 0 && p[1] == 0);
*/
#define tal_arrz(ctx, type, count) \
- ((type *)tal_alloc_((ctx), tal_sizeof_(sizeof(type), (count)), true, \
- TAL_LABEL(type, "[]")))
+ ((type *)tal_alloc_arr_((ctx), sizeof(type), (count), true, \
+ true, TAL_LABEL(type, "[]")))
/**
* tal_resize - enlarge or reduce a tal_arr[z].
* @count: the number to allocate.
*
* This returns true on success (and may move *@p), or false on failure.
+ * If @p has a length property, it is updated on success.
*
* Example:
* tal_resize(&p, 100);
*/
#define tal_resize(p, count) \
- tal_resize_((void **)(p), tal_sizeof_(sizeof**(p), (count)))
+ tal_resize_((void **)(p), sizeof**(p), (count))
/**
* tal_steal - change the parent of a tal-allocated pointer.
*/
const char *tal_name(const tal_t *ptr);
+/**
+ * tal_count - get the count of objects in a tal_arr.
+ * @ptr: The tal allocated object array.
+ *
+ * Returns 0 if @ptr has no length property, but we aware that that is
+ * also a valid size!
+ */
+size_t tal_count(const tal_t *ptr);
+
/**
* tal_first - get the first tal object child.
* @root: The tal allocated object to start with, or NULL.
*/
#define tal_dup(ctx, type, p, n, extra) \
((type *)tal_dup_((ctx), tal_typechk_(p, type *), \
- tal_sizeof_(sizeof(type), (n)), \
- tal_sizeof_(sizeof(type), (extra)), \
- TAL_LABEL(type, "[]")))
+ sizeof(type), (n), (extra), \
+ true, TAL_LABEL(type, "[]")))
/**
* tal_strdup - duplicate a string
bool tal_set_name_(tal_t *ctx, const char *name, bool literal);
-static inline size_t tal_sizeof_(size_t size, size_t count)
-{
- /* Multiplication wrap */
- if (count && unlikely(size * count / size != count))
- return (size_t)-1024;
-
- size *= count;
-
- /* Make sure we don't wrap adding header. */
- if (size > (size_t)-1024)
- return (size_t)-1024;
-
- return size;
-}
-
#if HAVE_TYPEOF
#define tal_typeof(ptr) (__typeof__(ptr))
#if HAVE_STATEMENT_EXPR
#endif
void *tal_alloc_(const tal_t *ctx, size_t bytes, bool clear, const char *label);
+void *tal_alloc_arr_(const tal_t *ctx, size_t bytes, size_t count, bool clear,
+ bool add_count, const char *label);
-void *tal_dup_(const tal_t *ctx, const void *p, size_t n, size_t extra,
+void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
+ size_t n, size_t extra, bool add_count,
const char *label);
tal_t *tal_steal_(const tal_t *new_parent, const tal_t *t);
-bool tal_resize_(tal_t **ctxp, size_t size);
+bool tal_resize_(tal_t **ctxp, size_t size, size_t count);
bool tal_add_destructor_(const tal_t *ctx, void (*destroy)(void *me));
bool tal_del_destructor_(const tal_t *ctx, void (*destroy)(void *me));
--- /dev/null
+#include <ccan/tal/tal.h>
+#include <ccan/tal/tal.c>
+#include <ccan/tap/tap.h>
+
+int main(void)
+{
+ char *p1, *p2;
+
+ plan_tests(12);
+
+ p1 = tal(NULL, char);
+ ok1(p1);
+ ok1(tal_count(p1) == 0);
+
+ p2 = tal_arr(p1, char, 1);
+ ok1(p2);
+ ok1(tal_count(p2) == 1);
+ ok1(tal_resize(&p2, 2));
+ ok1(tal_count(p2) == 2);
+ ok1(tal_check(NULL, NULL));
+ tal_free(p2);
+
+ p2 = tal_arrz(p1, char, 7);
+ ok1(p2);
+ ok1(tal_count(p2) == 7);
+ ok1(tal_resize(&p2, 0));
+ ok1(tal_count(p2) == 0);
+ ok1(tal_check(NULL, NULL));
+ tal_free(p2);
+ tal_free(p1);
+
+ return exit_status();
+}
projects / ccan / commitdiff