Rename path_* functions to pb_*

Just a whim; I always get the prefix wrong.

diff --git a/src/cache/local_cache.c b/src/cache/local_cache.c
index 406f3068502abc6b4181a19297dbbcdc860902ed..e9098a94ee9a4b3b83ffaf2c0a35efca3987bdb8 100644 (file)
--- a/src/cache/local_cache.c
+++ b/src/cache/local_cache.c
@@ -161,11 +161,11 @@ get_metadata_json_filename(char **filename)
        struct path_builder pb;
        int error;
 
-       path_init(&pb);
-       path_append(&pb, config_get_local_repository());
-       path_append(&pb, "metadata.json");
+       pb_init(&pb);
+       pb_append(&pb, config_get_local_repository());
+       pb_append(&pb, "metadata.json");
 
-       error = path_compile(&pb, filename);
+       error = pb_compile(&pb, filename);
        if (error) {
                pr_op_err("Unable to build metadata.json's path: %s",
                    strerror(error));
@@ -339,12 +339,12 @@ delete_node_file(struct cache_node *node, bool is_file)
        char *path;
        int error;
 
-       path_init(&pb);
+       pb_init(&pb);
        for (cursor = node; cursor != NULL; cursor = cursor->parent)
-               path_append(&pb, cursor->basename);
-       path_append(&pb, config_get_local_repository());
-       path_reverse(&pb);
-       error = path_compile(&pb, &path);
+               pb_append(&pb, cursor->basename);
+       pb_append(&pb, config_get_local_repository());
+       pb_reverse(&pb);
+       error = pb_compile(&pb, &path);
        if (error) {
                pr_val_err("Cannot override '%s'; path is bogus: %s",
                    node->basename, strerror(error));
@@ -527,12 +527,12 @@ static void cleanup_nodes(struct cache_node *node)
  * @force: ignore nonexistent files
  */
 static void
-path_rm_r(struct path_builder *pb, char const *filename, bool force)
+pb_rm_r(struct path_builder *pb, char const *filename, bool force)
 {
        char const *path;
        int error;
 
-       error = path_peek(pb, &path);
+       error = pb_peek(pb, &path);
        if (error) {
                pr_op_err("Path builder error code %d; cannot delete directory. (Basename is '%s')",
                    error, filename);
@@ -562,10 +562,10 @@ ctt_init(struct cache_tree_traverser *ctt, struct cache_node *node,
 
        while (node->children != NULL) {
                /* FIXME We need to recover from path too long... */
-               path_append(pb, node->basename);
+               pb_append(pb, node->basename);
                node = node->children;
        }
-       path_append(pb, "a");
+       pb_append(pb, "a");
        ctt->pb = pb;
        ctt->next = node;
        ctt->next_sibling = true;
@@ -579,9 +579,9 @@ ctt_next(struct cache_tree_traverser *ctt)
        if (next == NULL)
                return NULL;
 
-       path_pop(ctt->pb, true);
+       pb_pop(ctt->pb, true);
        if (ctt->next_sibling)
-               path_append(ctt->pb, next->basename);
+               pb_append(ctt->pb, next->basename);
 
        if (next->hh.next != NULL) {
                ctt->next = next->hh.next;
@@ -605,21 +605,21 @@ static void cleanup_files(struct cache_node *node, char const *name)
        struct cache_node *child, *tmp;
        int error;
 
-       path_init(&pb);
-       path_append(&pb, config_get_local_repository());
+       pb_init(&pb);
+       pb_append(&pb, config_get_local_repository());
 
        if (node == NULL) {
                /* File might exist but node doesn't: Delete file */
-               path_append(&pb, name);
-               path_rm_r(&pb, name, true);
-               path_cancel(&pb);
+               pb_append(&pb, name);
+               pb_rm_r(&pb, name, true);
+               pb_cancel(&pb);
                return;
        }
 
        ctt_init(&ctt, node, &pb);
 
        while ((node = ctt_next(&ctt)) != NULL) {
-               error = path_peek(&pb, &path);
+               error = pb_peek(&pb, &path);
                if (error) {
                        pr_op_err("Cannot clean up directory (basename is '%s'): %s",
                            node->basename, strerror(error));
@@ -666,9 +666,9 @@ static void cleanup_files(struct cache_node *node, char const *name)
                                child->flags |= CNF_FOUND;
                        } else {
                                /* File child's node does not exist: Delete. */
-                               path_append(&pb, file->d_name);
-                               path_rm_r(&pb, file->d_name, false);
-                               path_pop(&pb, true);
+                               pb_append(&pb, file->d_name);
+                               pb_rm_r(&pb, file->d_name, false);
+                               pb_pop(&pb, true);
                        }
                }
 
@@ -698,12 +698,12 @@ static void cleanup_files(struct cache_node *node, char const *name)
 
                if (node->children == NULL) {
                        /* Node is inactive and we rm'd its children: Delete. */
-                       path_rm_r(&pb, node->basename, false);
+                       pb_rm_r(&pb, node->basename, false);
                        delete_node(node);
                }
        }
 
-       path_cancel(&pb);
+       pb_cancel(&pb);
 }
 
 static int

diff --git a/src/cache/tmp.c b/src/cache/tmp.c
index 243de0158121fce2484c69499870850dc534e247..1c737817d64a9f88e89d9c8478ba4add2c724769 100644 (file)
--- a/src/cache/tmp.c
+++ b/src/cache/tmp.c
@@ -21,11 +21,11 @@ cache_tmpfile(char **filename)
 {
        struct path_builder pb;
 
-       path_init(&pb);
+       pb_init(&pb);
 
-       path_append(&pb, config_get_local_repository());
-       path_append(&pb, "tmp");
-       path_append_uint(&pb, atomic_fetch_add(&file_counter, 1u));
+       pb_append(&pb, config_get_local_repository());
+       pb_append(&pb, "tmp");
+       pb_append_uint(&pb, atomic_fetch_add(&file_counter, 1u));
 
-       return path_compile(&pb, filename);
+       return pb_compile(&pb, filename);
 }

diff --git a/src/data_structure/path_builder.c b/src/data_structure/path_builder.c
index bc49ee530fa97e3f47d97e0bea13885a9df16433..12ba006029e6beb0fdb02b2999aaf00af3d3b16a 100644 (file)
--- a/src/data_structure/path_builder.c
+++ b/src/data_structure/path_builder.c
@@ -15,7 +15,7 @@
 #define MAX_CAPACITY 4096
 
 void
-path_init(struct path_builder *pb)
+pb_init(struct path_builder *pb)
 {
        pb->string = pmalloc(INITIAL_CAPACITY);
        pb->len = 0;
@@ -27,7 +27,7 @@ path_init(struct path_builder *pb)
  * Returns true on success, false on failure.
  */
 static bool
-path_grow(struct path_builder *pb, size_t total_len)
+pb_grow(struct path_builder *pb, size_t total_len)
 {
        if (total_len > MAX_CAPACITY) {
                free(pb->string);
@@ -67,19 +67,13 @@ add(struct path_builder *pb, char const *addend, size_t addlen)
        size_t total_len;
 
        total_len = pb->len + addlen;
-       if (total_len > pb->capacity && !path_grow(pb, total_len))
+       if (total_len > pb->capacity && !pb_grow(pb, total_len))
                return;
 
        memcpy(pb->string + pb->len, addend, addlen);
        pb->len += addlen;
 }
 
-void
-path_append(struct path_builder *pb, char const *addend)
-{
-       path_append_limited(pb, addend, strlen(addend));
-}
-
 static void
 add_slashed(struct path_builder *pb, char const *addend, size_t addlen)
 {
@@ -91,7 +85,7 @@ add_slashed(struct path_builder *pb, char const *addend, size_t addlen)
                break;
        case 2:
                if (addend[0] == '.' && addend[1] == '.') {
-                       path_pop(pb, false);
+                       pb_pop(pb, false);
                        return;
                }
                break;
@@ -104,8 +98,8 @@ add_slashed(struct path_builder *pb, char const *addend, size_t addlen)
 }
 
 /* Do NOT include the null character in @addlen. */
-void
-path_append_limited(struct path_builder *pb, char const *addend, size_t addlen)
+static void
+pb_append_limited(struct path_builder *pb, char const *addend, size_t addlen)
 {
        char const *wall;
        char const *next_slash;
@@ -127,7 +121,13 @@ path_append_limited(struct path_builder *pb, char const *addend, size_t addlen)
 }
 
 void
-path_append_guri(struct path_builder *pb, struct rpki_uri *uri)
+pb_append(struct path_builder *pb, char const *addend)
+{
+       pb_append_limited(pb, addend, strlen(addend));
+}
+
+void
+pb_append_guri(struct path_builder *pb, struct rpki_uri *uri)
 {
        char const *guri;
        char const *colon;
@@ -140,14 +140,14 @@ path_append_guri(struct path_builder *pb, struct rpki_uri *uri)
 
        colon = strstr(guri, ":");
        schema_len = colon - guri;
-       path_append_limited(pb, guri, schema_len);
+       pb_append_limited(pb, guri, schema_len);
 
-       path_append_limited(pb, colon + 3,
+       pb_append_limited(pb, colon + 3,
            uri_get_global_len(uri) - schema_len - 3);
 }
 
 void
-path_append_uint(struct path_builder *pb, unsigned int num)
+pb_append_uint(struct path_builder *pb, unsigned int num)
 {
        size_t room;
        int num_len;
@@ -163,7 +163,7 @@ path_append_uint(struct path_builder *pb, unsigned int num)
        if (num_len < 0)
                goto bad_print;
        if (num_len >= room) {
-               if (!path_grow(pb, pb->len + num_len + 1))
+               if (!pb_grow(pb, pb->len + num_len + 1))
                        return;
 
                room = pb->capacity - pb->len;
@@ -184,7 +184,7 @@ bad_print:
 
 /* Removes the last component added. */
 void
-path_pop(struct path_builder *pb, bool fatal)
+pb_pop(struct path_builder *pb, bool fatal)
 {
        size_t i;
 
@@ -223,7 +223,7 @@ reverse_string(char *str, size_t len)
 
 /* Turns ab/cd/ef/gh into gh/ef/cd/ab. */
 void
-path_reverse(struct path_builder *pb)
+pb_reverse(struct path_builder *pb)
 {
        size_t min;
        size_t max;
@@ -250,7 +250,7 @@ path_reverse(struct path_builder *pb)
  * functions on @pb afterwards.
  */
 int
-path_peek(struct path_builder *pb, char const **result)
+pb_peek(struct path_builder *pb, char const **result)
 {
        add(pb, "\0", 1);
        if (pb->error)
@@ -263,7 +263,7 @@ path_peek(struct path_builder *pb, char const **result)
 
 /* Should not be called more than once. */
 int
-path_compile(struct path_builder *pb, char **result)
+pb_compile(struct path_builder *pb, char **result)
 {
        add(pb, "\0", 1);
        if (pb->error)
@@ -274,7 +274,7 @@ path_compile(struct path_builder *pb, char **result)
 }
 
 void
-path_cancel(struct path_builder *pb)
+pb_cancel(struct path_builder *pb)
 {
        free(pb->string);
 }

diff --git a/src/data_structure/path_builder.h b/src/data_structure/path_builder.h
index 73c0e1bed9dc95ae02257289452664548b7b6d4b..adc5fae48846d7d893dc2e452ef34e014ad99679 100644 (file)
--- a/src/data_structure/path_builder.h
+++ b/src/data_structure/path_builder.h
@@ -14,7 +14,7 @@ struct path_builder {
        int error;
 };
 
-void path_init(struct path_builder *);
+void pb_init(struct path_builder *);
 
 /*
  * Note, the append()s merge slashes:
@@ -27,18 +27,17 @@ void path_init(struct path_builder *);
  *     a///b + c//d = a/b/c/d
  */
 
-void path_append(struct path_builder *, char const *);
-void path_append_limited(struct path_builder *, char const *, size_t);
-void path_append_guri(struct path_builder *, struct rpki_uri *);
-void path_append_uint(struct path_builder *, unsigned int);
+void pb_append(struct path_builder *, char const *);
+void pb_append_guri(struct path_builder *, struct rpki_uri *);
+void pb_append_uint(struct path_builder *, unsigned int);
 
-void path_pop(struct path_builder *, bool);
+void pb_pop(struct path_builder *, bool);
 
-void path_reverse(struct path_builder *);
+void pb_reverse(struct path_builder *);
 
-int path_peek(struct path_builder *, char const **);
-int path_compile(struct path_builder *, char **);
+int pb_peek(struct path_builder *, char const **);
+int pb_compile(struct path_builder *, char **);
 
-void path_cancel(struct path_builder *);
+void pb_cancel(struct path_builder *);
 
 #endif /* SRC_DATA_STRUCTURE_PATH_BUILDER_H_ */

diff --git a/src/types/uri.c b/src/types/uri.c
index de616b7572bfbd54e06b329b3352cf7433b062cc..5fad50bf696164373b15d1c086a2498d33acbb9b 100644 (file)
--- a/src/types/uri.c
+++ b/src/types/uri.c
@@ -225,9 +225,9 @@ map_simple(struct rpki_uri *uri, char const *gprefix, char const *lprefix,
                return err;
        }
 
-       path_init(&pb);
-       path_append_guri(&pb, uri);
-       error = path_compile(&pb, &uri->local);
+       pb_init(&pb);
+       pb_append_guri(&pb, uri);
+       error = pb_compile(&pb, &uri->local);
        if (error)
                return error;
 
@@ -248,20 +248,20 @@ map_simple(struct rpki_uri *uri, char const *gprefix, char const *lprefix,
 static int
 map_caged(struct rpki_uri *uri)
 {
-       struct path_builder builder;
+       struct path_builder pb;
        struct rpki_uri *notification;
 
        notification = validation_get_notification_uri(state_retrieve());
        if (notification == NULL)
                pr_crit("Programming error: Notification not recorded.");
 
-       path_init(&builder);
+       pb_init(&pb);
 
-       path_append(&builder, "rrdp");
-       path_append_guri(&builder, notification);
-       path_append_guri(&builder, uri);
+       pb_append(&pb, "rrdp");
+       pb_append_guri(&pb, notification);
+       pb_append_guri(&pb, uri);
 
-       return path_compile(&builder, &uri->local);
+       return pb_compile(&pb, &uri->local);
 }
 
 static int

diff --git a/test/cache/local_cache_test.c b/test/cache/local_cache_test.c
index c01a9267ce04eb03c327d137ab753239cd40cbb9..01a82fffe7aed534b35b44f71559d2a29ad33349 100644 (file)
--- a/test/cache/local_cache_test.c
+++ b/test/cache/local_cache_test.c
@@ -191,7 +191,7 @@ validate_node(struct cache_node *expected, struct cache_node *expected_parent,
        }
        ck_assert_ptr_eq(expected_parent, actual->parent);
 
-       path_append(pb, expected->basename);
+       pb_append(pb, expected->basename);
 
        HASH_ITER(hh, expected->children, expected_child, tmp) {
                HASH_FIND_STR(actual->children, expected_child->basename,
@@ -208,7 +208,7 @@ validate_node(struct cache_node *expected, struct cache_node *expected_parent,
                        expected_not_found(actual_child);
        }
 
-       path_pop(pb, true);
+       pb_pop(pb, true);
 }
 
 static void
@@ -245,8 +245,8 @@ validate_file(struct cache_node *expected, struct path_builder *pb)
        if (expected == NULL)
                return;
 
-       path_append(pb, expected->basename);
-       ck_assert_int_eq(0, path_peek(pb, &path));
+       pb_append(pb, expected->basename);
+       ck_assert_int_eq(0, pb_peek(pb, &path));
 
        if (is_rsync(expected)) {
                /* Currently, the unit tests do not fake rsync files */
@@ -297,7 +297,7 @@ must_be_dir:
 
        closedir(dir);
 end:
-       path_pop(pb, true);
+       pb_pop(pb, true);
 }
 
 static void
@@ -320,13 +320,13 @@ validate_trees(struct cache_node *actual, struct cache_node *nodes,
                file_ls_R("tmp");
        }
 
-       path_init(&pb);
-       path_append(&pb, "tmp");
+       pb_init(&pb);
+       pb_append(&pb, "tmp");
 
        validate_node(nodes, NULL, actual, &pb);
        validate_file(files, &pb);
 
-       path_cancel(&pb);
+       pb_cancel(&pb);
 
        delete_node(nodes);
        if (nodes != files)

diff --git a/test/data_structure/path_builder_test.c b/test/data_structure/path_builder_test.c
index 8b0f339c32dac7c49efd73c43108f6a86ed516c1..4021a8a02007de9f6387a2d063916838b276ad37 100644 (file)
--- a/test/data_structure/path_builder_test.c
+++ b/test/data_structure/path_builder_test.c
@@ -20,15 +20,15 @@ __MOCK_ABORT(uri_get_global_len, size_t, 0, struct rpki_uri *uri)
        ck_assert_int_eq(_error, pb.error)
 
 #define CHECK_RESULTS(expected)                                                \
-       ck_assert_uint_eq(0, path_peek(&pb, &peek_result));             \
+       ck_assert_uint_eq(0, pb_peek(&pb, &peek_result));               \
        ck_assert_str_eq(expected, peek_result);                        \
-       ck_assert_uint_eq(0, path_compile(&pb, &compile_result));       \
+       ck_assert_uint_eq(0, pb_compile(&pb, &compile_result)); \
        ck_assert_str_eq(expected, compile_result);                     \
        free(compile_result);
 
 #define CHECK_ERROR                                                    \
-       ck_assert_uint_eq(EINVAL, path_peek(&pb, &peek_result));        \
-       ck_assert_uint_eq(EINVAL, path_compile(&pb, &compile_result));
+       ck_assert_uint_eq(EINVAL, pb_peek(&pb, &peek_result));  \
+       ck_assert_uint_eq(EINVAL, pb_compile(&pb, &compile_result));
 
 START_TEST(test_append)
 {
@@ -36,70 +36,70 @@ START_TEST(test_append)
        char const *peek_result;
        char *compile_result;
 
-       path_init(&pb);
-       path_append(&pb, "");
+       pb_init(&pb);
+       pb_append(&pb, "");
        CHECK_PB(0, 8, 0);
        CHECK_RESULTS("");
 
-       path_init(&pb);
-       path_append(&pb, "a");
+       pb_init(&pb);
+       pb_append(&pb, "a");
        CHECK_PB(1, 8, 0);
        CHECK_RESULTS("a");
 
-       path_init(&pb);
-       path_append(&pb, "a");
+       pb_init(&pb);
+       pb_append(&pb, "a");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "b");
+       pb_append(&pb, "b");
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("a/b");
 
-       path_init(&pb);
-       path_append(&pb, "a/b");
+       pb_init(&pb);
+       pb_append(&pb, "a/b");
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("a/b");
 
-       path_init(&pb);
-       path_append(&pb, "a/");
+       pb_init(&pb);
+       pb_append(&pb, "a/");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "b/");
+       pb_append(&pb, "b/");
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("a/b");
 
        /* notes from .h */
-       path_init(&pb);
-       path_append(&pb, "a/");
+       pb_init(&pb);
+       pb_append(&pb, "a/");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "b");
+       pb_append(&pb, "b");
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("a/b");
 
-       path_init(&pb);
-       path_append(&pb, "a");
+       pb_init(&pb);
+       pb_append(&pb, "a");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "/b");
+       pb_append(&pb, "/b");
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("a/b");
 
-       path_init(&pb);
-       path_append(&pb, "a/");
+       pb_init(&pb);
+       pb_append(&pb, "a/");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "/b");
+       pb_append(&pb, "/b");
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("a/b");
 
-       path_init(&pb);
-       path_append(&pb, "//a");
+       pb_init(&pb);
+       pb_append(&pb, "//a");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "///");
+       pb_append(&pb, "///");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "b////");
+       pb_append(&pb, "b////");
        CHECK_PB(3, 8, 0);
-       path_append(&pb, "/////c//////");
+       pb_append(&pb, "/////c//////");
        CHECK_PB(5, 8, 0);
        CHECK_RESULTS("a/b/c");
 
-       path_init(&pb);
-       path_append(&pb, "//a///b//c//");
+       pb_init(&pb);
+       pb_append(&pb, "//a///b//c//");
        CHECK_PB(5, 8, 0);
        CHECK_RESULTS("a/b/c");
 }
@@ -112,39 +112,39 @@ START_TEST(test_uint)
        char const *peek_result;
        char *compile_result;
 
-       path_init(&pb);
-       path_append_uint(&pb, 291);
+       pb_init(&pb);
+       pb_append_uint(&pb, 291);
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("123"); /* hex */
 
-       path_init(&pb);
-       path_append_uint(&pb, 19088743);
+       pb_init(&pb);
+       pb_append_uint(&pb, 19088743);
        CHECK_PB(7, 8, 0);
        CHECK_RESULTS("1234567");
 
-       path_init(&pb);
-       path_append_uint(&pb, 305419896);
+       pb_init(&pb);
+       pb_append_uint(&pb, 305419896);
        CHECK_PB(8, 16, 0);
        CHECK_RESULTS("12345678");
 
-       path_init(&pb);
-       path_append_uint(&pb, 74565);
+       pb_init(&pb);
+       pb_append_uint(&pb, 74565);
        CHECK_PB(5, 8, 0);
-       path_append_uint(&pb, 7);
+       pb_append_uint(&pb, 7);
        CHECK_PB(7, 8, 0);
        CHECK_RESULTS("12345/7");
 
-       path_init(&pb);
-       path_append_uint(&pb, 74565);
+       pb_init(&pb);
+       pb_append_uint(&pb, 74565);
        CHECK_PB(5, 8, 0);
-       path_append_uint(&pb, 120);
+       pb_append_uint(&pb, 120);
        CHECK_PB(8, 16, 0);
        CHECK_RESULTS("12345/78");
 
-       path_init(&pb);
-       path_append_uint(&pb, 74565);
+       pb_init(&pb);
+       pb_append_uint(&pb, 74565);
        CHECK_PB(5, 8, 0);
-       path_append_uint(&pb, 1929);
+       pb_append_uint(&pb, 1929);
        CHECK_PB(9, 16, 0);
        CHECK_RESULTS("12345/789");
 }
@@ -156,66 +156,66 @@ START_TEST(test_pop)
        char const *peek_result;
        char *compile_result;
 
-       path_init(&pb);
-       path_append(&pb, "a");
+       pb_init(&pb);
+       pb_append(&pb, "a");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "b");
+       pb_append(&pb, "b");
        CHECK_PB(3, 8, 0);
-       path_pop(&pb, false);
+       pb_pop(&pb, false);
        CHECK_PB(1, 8, 0);
        CHECK_RESULTS("a");
 
-       path_init(&pb);
-       path_append(&pb, "abc");
+       pb_init(&pb);
+       pb_append(&pb, "abc");
        CHECK_PB(3, 8, 0);
-       path_append(&pb, "def");
+       pb_append(&pb, "def");
        CHECK_PB(7, 8, 0);
-       path_pop(&pb, false);
+       pb_pop(&pb, false);
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("abc");
 
-       path_init(&pb);
-       path_append(&pb, "a");
+       pb_init(&pb);
+       pb_append(&pb, "a");
        CHECK_PB(1, 8, 0);
-       path_pop(&pb, false);
+       pb_pop(&pb, false);
        CHECK_PB(0, 8, 0);
        CHECK_RESULTS("");
 
-       path_init(&pb);
-       path_append(&pb, "/a");
+       pb_init(&pb);
+       pb_append(&pb, "/a");
        CHECK_PB(1, 8, 0);
-       path_pop(&pb, false);
+       pb_pop(&pb, false);
        CHECK_PB(0, 8, 0);
        CHECK_RESULTS("");
 
-       path_init(&pb);
-       path_pop(&pb, false);
+       pb_init(&pb);
+       pb_pop(&pb, false);
        CHECK_PB(0, 8, EINVAL);
        CHECK_ERROR;
 
-       path_init(&pb);
-       path_append(&pb, "a");
-       path_pop(&pb, false);
+       pb_init(&pb);
+       pb_append(&pb, "a");
+       pb_pop(&pb, false);
        CHECK_PB(0, 8, 0);
-       path_pop(&pb, false);
+       pb_pop(&pb, false);
        CHECK_PB(0, 8, EINVAL);
        CHECK_ERROR;
 
-//     path_init(&pb);
-//     path_append(&pb, "/");
+//     pb_init(&pb);
+//     pb_append(&pb, "/");
 //     CHECK_PB(1, 8, 0);
-//     path_pop(&pb);
+//     pb_pop(&pb);
 //     CHECK_PB(0, 8, 0);
 //     CHECK_RESULTS("");
 //
-//     path_init(&pb);
-//     path_append(&pb, "///");
+//     pb_init(&pb);
+//     pb_append(&pb, "///");
 //     CHECK_PB(3, 8, 0);
-//     path_pop(&pb);
+//     pb_pop(&pb);
 //     CHECK_PB(2, 8, 0);
-//     path_pop(&pb);
+//     pb_pop(&pb);
 //     CHECK_PB(1, 8, 0);
-//     path_pop(&pb);
+//     pb_pop(&pb);
 //     CHECK_PB(0, 8, 0);
 //     CHECK_RESULTS("");
 }
@@ -227,29 +227,29 @@ START_TEST(test_peek)
        char const *peek_result;
 
        /*
-        * Most of path_peek() has already been tested above,
+        * Most of pb_peek() has already been tested above,
         * just check it leaves the pb in a stable state.
         */
 
-       path_init(&pb);
+       pb_init(&pb);
 
-       path_peek(&pb, &peek_result);
+       pb_peek(&pb, &peek_result);
        ck_assert_str_eq("", peek_result);
 
-       path_append(&pb, "a");
-       path_peek(&pb, &peek_result);
+       pb_append(&pb, "a");
+       pb_peek(&pb, &peek_result);
        ck_assert_str_eq("a", peek_result);
 
-       path_append(&pb, "b");
-       path_peek(&pb, &peek_result);
+       pb_append(&pb, "b");
+       pb_peek(&pb, &peek_result);
        ck_assert_str_eq("a/b", peek_result);
 
-       path_pop(&pb, true);
-       path_peek(&pb, &peek_result);
+       pb_pop(&pb, true);
+       pb_peek(&pb, &peek_result);
        ck_assert_str_eq("a", peek_result);
 
-       path_pop(&pb, true);
-       path_peek(&pb, &peek_result);
+       pb_pop(&pb, true);
+       pb_peek(&pb, &peek_result);
        ck_assert_str_eq("", peek_result);
 
        free(pb.string);
@@ -263,105 +263,105 @@ START_TEST(test_reverse)
        char *compile_result;
 
        /* 0 components */
-       path_init(&pb);
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_reverse(&pb);
        CHECK_PB(0, 8, 0);
        CHECK_RESULTS("");
 
        /* 1 component */
-       path_init(&pb);
-       path_append(&pb, "a");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "a");
+       pb_reverse(&pb);
        CHECK_PB(1, 8, 0);
        CHECK_RESULTS("a");
 
        /* 2 components */
-       path_init(&pb);
-       path_append(&pb, "a");
-       path_append(&pb, "b");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "a");
+       pb_append(&pb, "b");
+       pb_reverse(&pb);
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("b/a");
 
-       path_init(&pb);
-       path_append(&pb, "abc");
-       path_append(&pb, "def");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "abc");
+       pb_append(&pb, "def");
+       pb_reverse(&pb);
        CHECK_PB(7, 8, 0);
        CHECK_RESULTS("def/abc");
 
-       path_init(&pb);
-       path_append(&pb, "abcd");
-       path_append(&pb, "efgh");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "abcd");
+       pb_append(&pb, "efgh");
+       pb_reverse(&pb);
        CHECK_PB(9, 16, 0);
        CHECK_RESULTS("efgh/abcd");
 
-       path_init(&pb);
-       path_append(&pb, "abc");
-       path_append(&pb, "efgh");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "abc");
+       pb_append(&pb, "efgh");
+       pb_reverse(&pb);
        CHECK_PB(8, 8, 0);
        CHECK_RESULTS("efgh/abc");
 
-       path_init(&pb);
-       path_append(&pb, "abcd");
-       path_append(&pb, "fgh");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "abcd");
+       pb_append(&pb, "fgh");
+       pb_reverse(&pb);
        CHECK_PB(8, 8, 0);
        CHECK_RESULTS("fgh/abcd");
 
        /* 3 components */
-       path_init(&pb);
-       path_append(&pb, "abc");
-       path_append(&pb, "def");
-       path_append(&pb, "ghi");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "abc");
+       pb_append(&pb, "def");
+       pb_append(&pb, "ghi");
+       pb_reverse(&pb);
        CHECK_PB(11, 16, 0);
        CHECK_RESULTS("ghi/def/abc");
 
-       path_init(&pb);
-       path_append(&pb, "ab");
-       path_append(&pb, "cde");
-       path_append(&pb, "fghi");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "ab");
+       pb_append(&pb, "cde");
+       pb_append(&pb, "fghi");
+       pb_reverse(&pb);
        CHECK_PB(11, 16, 0);
        CHECK_RESULTS("fghi/cde/ab");
 
        /* 4 components */
-       path_init(&pb);
-       path_append(&pb, "a");
-       path_append(&pb, "b");
-       path_append(&pb, "c");
-       path_append(&pb, "d");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "a");
+       pb_append(&pb, "b");
+       pb_append(&pb, "c");
+       pb_append(&pb, "d");
+       pb_reverse(&pb);
        CHECK_PB(7, 8, 0);
        CHECK_RESULTS("d/c/b/a");
 
-       path_init(&pb);
-       path_append(&pb, "ab");
-       path_append(&pb, "cd");
-       path_append(&pb, "ef");
-       path_append(&pb, "gh");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "ab");
+       pb_append(&pb, "cd");
+       pb_append(&pb, "ef");
+       pb_append(&pb, "gh");
+       pb_reverse(&pb);
        CHECK_PB(11, 16, 0);
        CHECK_RESULTS("gh/ef/cd/ab");
 
-       path_init(&pb);
-       path_append(&pb, "a");
-       path_append(&pb, "bcd");
-       path_append(&pb, "efgh");
-       path_append(&pb, "ijklm");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "a");
+       pb_append(&pb, "bcd");
+       pb_append(&pb, "efgh");
+       pb_append(&pb, "ijklm");
+       pb_reverse(&pb);
        CHECK_PB(16, 16, 0);
        CHECK_RESULTS("ijklm/efgh/bcd/a");
 
-       path_init(&pb);
-       path_append(&pb, "abcdefghijklmnopq");
-       path_append(&pb, "r");
-       path_append(&pb, "stu");
-       path_append(&pb, "vx");
-       path_reverse(&pb);
+       pb_init(&pb);
+       pb_append(&pb, "abcdefghijklmnopq");
+       pb_append(&pb, "r");
+       pb_append(&pb, "stu");
+       pb_append(&pb, "vx");
+       pb_reverse(&pb);
        CHECK_PB(26, 32, 0);
        CHECK_RESULTS("vx/stu/r/abcdefghijklmnopq");
 }
@@ -373,69 +373,69 @@ START_TEST(test_normalization)
        char const *peek_result;
        char *compile_result;
 
-       path_init(&pb);
-       path_append(&pb, ".");
+       pb_init(&pb);
+       pb_append(&pb, ".");
        CHECK_PB(0, 8, 0);
        CHECK_RESULTS("");
 
-       path_init(&pb);
-       path_append(&pb, "a");
+       pb_init(&pb);
+       pb_append(&pb, "a");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, ".");
+       pb_append(&pb, ".");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "b");
+       pb_append(&pb, "b");
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("a/b");
 
-       path_init(&pb);
-       path_append(&pb, ".");
+       pb_init(&pb);
+       pb_append(&pb, ".");
        CHECK_PB(0, 8, 0);
-       path_append(&pb, ".");
+       pb_append(&pb, ".");
        CHECK_PB(0, 8, 0);
-       path_append(&pb, "a");
+       pb_append(&pb, "a");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, ".");
+       pb_append(&pb, ".");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, ".");
+       pb_append(&pb, ".");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "b");
+       pb_append(&pb, "b");
        CHECK_PB(3, 8, 0);
-       path_append(&pb, ".");
+       pb_append(&pb, ".");
        CHECK_PB(3, 8, 0);
-       path_append(&pb, ".");
+       pb_append(&pb, ".");
        CHECK_PB(3, 8, 0);
        CHECK_RESULTS("a/b");
 
-       path_init(&pb);
-       path_append(&pb, "..");
+       pb_init(&pb);
+       pb_append(&pb, "..");
        CHECK_PB(0, 8, EINVAL);
        CHECK_ERROR;
 
-       path_init(&pb);
-       path_append(&pb, "a");
+       pb_init(&pb);
+       pb_append(&pb, "a");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "b");
+       pb_append(&pb, "b");
        CHECK_PB(3, 8, 0);
-       path_append(&pb, "..");
+       pb_append(&pb, "..");
        CHECK_PB(1, 8, 0);
        CHECK_RESULTS("a");
 
-       path_init(&pb);
-       path_append(&pb, "a");
+       pb_init(&pb);
+       pb_append(&pb, "a");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "b");
+       pb_append(&pb, "b");
        CHECK_PB(3, 8, 0);
-       path_append(&pb, "..");
+       pb_append(&pb, "..");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, ".");
+       pb_append(&pb, ".");
        CHECK_PB(1, 8, 0);
-       path_append(&pb, "..");
+       pb_append(&pb, "..");
        CHECK_PB(0, 8, 0);
        CHECK_RESULTS("");
 
        /* dot dot injection */
-       path_init(&pb);
-       path_append(&pb, "a/../b");
+       pb_init(&pb);
+       pb_append(&pb, "a/../b");
        CHECK_PB(1, 8, 0);
        CHECK_RESULTS("b");
 }