check_type: fix incorrect documentation.

[ccan] / ccan / strset / strset.c

diff --git a/ccan/strset/strset.c b/ccan/strset/strset.c
index 8088db47e808e3adb40f5bf583a6a8e6babeec59..06b0d7a76c35fe119353310888b4dbf1828d949b 100644 (file)
--- a/ccan/strset/strset.c
+++ b/ccan/strset/strset.c
@@ -19,6 +19,7 @@
 #include <ccan/ilog/ilog.h>
 #include <assert.h>
 #include <stdlib.h>
+#include <errno.h>
 
 struct node {
        /* To differentiate us from strings. */
@@ -56,16 +57,17 @@ static const char *closest(struct strset n, const char *member)
        return n.u.s;
 }
 
-char *strset_test(const struct strset *set, const char *member)
+char *strset_get(const struct strset *set, const char *member)
 {
        const char *str;
 
-       /* Empty set? */
-       if (!set->u.n)
-               return NULL;
-       str = closest(*set, member);
-       if (streq(member, str))
-               return (char *)str;
+       /* Non-empty set? */
+       if (set->u.n) {
+               str = closest(*set, member);
+               if (streq(member, str))
+                       return (char *)str;
+       }
+       errno = ENOENT;
        return NULL;
 }
 
@@ -75,8 +77,10 @@ static bool set_string(struct strset *set,
        /* Substitute magic empty node if this is the empty string */
        if (unlikely(!member[0])) {
                n->u.n = malloc(sizeof(*n->u.n));
-               if (unlikely(!n->u.n))
+               if (unlikely(!n->u.n)) {
+                       errno = ENOMEM;
                        return false;
+               }
                n->u.n->nul_byte = '\0';
                n->u.n->byte_num = (size_t)-1;
                /* Attach the string to child[0] */
@@ -86,7 +90,7 @@ static bool set_string(struct strset *set,
        return true;
 }
 
-bool strset_set(struct strset *set, const char *member)
+bool strset_add(struct strset *set, const char *member)
 {
        size_t len = strlen(member);
        const u8 *bytes = (const u8 *)member;
@@ -108,6 +112,7 @@ bool strset_set(struct strset *set, const char *member)
        for (byte_num = 0; str[byte_num] == member[byte_num]; byte_num++) {
                if (member[byte_num] == '\0') {
                        /* All identical! */
+                       errno = EEXIST;
                        return false;
                }
        }
@@ -122,7 +127,7 @@ bool strset_set(struct strset *set, const char *member)
        /* Allocate new node. */
        newn = malloc(sizeof(*newn));
        if (!newn) {
-               /* FIXME */
+               errno = ENOMEM;
                return false;
        }
        newn->nul_byte = '\0';
@@ -158,7 +163,7 @@ bool strset_set(struct strset *set, const char *member)
        return true;
 }
 
-char *strset_clear(struct strset *set, const char *member)
+char *strset_del(struct strset *set, const char *member)
 {
        size_t len = strlen(member);
        const u8 *bytes = (const u8 *)member;
@@ -167,8 +172,10 @@ char *strset_clear(struct strset *set, const char *member)
        u8 direction = 0; /* prevent bogus gcc warning. */
 
        /* Empty set? */
-       if (!set->u.n)
+       if (!set->u.n) {
+               errno = ENOENT;
                return NULL;
+       }
 
        /* Find closest, but keep track of parent. */
        n = set;
@@ -180,8 +187,10 @@ char *strset_clear(struct strset *set, const char *member)
                if (unlikely(n->u.n->byte_num == (size_t)-1)) {
                        const char *empty_str = n->u.n->child[0].u.s;
 
-                       if (member[0])
+                       if (member[0]) {
+                               errno = ENOENT;
                                return NULL;
+                       }
 
                        /* Sew empty string back so remaining logic works */
                        free(n->u.n);
@@ -199,8 +208,10 @@ char *strset_clear(struct strset *set, const char *member)
        }
 
        /* Did we find it? */
-       if (!streq(member, n->u.s))
+       if (!streq(member, n->u.s)) {
+               errno = ENOENT;
                return NULL;
+       }
 
        ret = n->u.s;
 
@@ -218,19 +229,19 @@ char *strset_clear(struct strset *set, const char *member)
 }
 
 static bool iterate(struct strset n,
-                   bool (*handle)(const char *, void *), void *data)
+                   bool (*handle)(const char *, void *), const void *data)
 {
        if (n.u.s[0])
-               return handle(n.u.s, data);
+               return handle(n.u.s, (void *)data);
        if (unlikely(n.u.n->byte_num == (size_t)-1))
-               return handle(n.u.n->child[0].u.s, data);
+               return handle(n.u.n->child[0].u.s, (void *)data);
 
        return iterate(n.u.n->child[0], handle, data)
-               || iterate(n.u.n->child[1], handle, data);
+               && iterate(n.u.n->child[1], handle, data);
 }
 
 void strset_iterate_(const struct strset *set,
-                    bool (*handle)(const char *, void *), void *data)
+                    bool (*handle)(const char *, void *), const void *data)
 {
        /* Empty set? */
        if (!set->u.n)
@@ -279,20 +290,20 @@ const struct strset *strset_prefix(const struct strset *set, const char *prefix)
        return top;
 }
 
-static void destroy(struct strset n)
+static void clear(struct strset n)
 {
        if (!n.u.s[0]) {
                if (likely(n.u.n->byte_num != (size_t)-1)) {
-                       destroy(n.u.n->child[0]);
-                       destroy(n.u.n->child[1]);
+                       clear(n.u.n->child[0]);
+                       clear(n.u.n->child[1]);
                }
                free(n.u.n);
        }
 }
 
-void strset_destroy(struct strset *set)
+void strset_clear(struct strset *set)
 {
        if (set->u.n)
-               destroy(*set);
+               clear(*set);
        set->u.n = NULL;
 }