migrate codebase to use squareball. again :)feature/squareball

19 files changed, 477 insertions, 474 deletions

diff --git a/src/blogc-make/atom.c b/src/blogc-make/atom.c
index 6749658..47b9ee3 100644
--- a/src/blogc-make/atom.c
+++ b/src/blogc-make/atom.c
@@ -10,8 +10,8 @@
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "settings.h"
 #include "utils.h"
 #include "atom.h"
@@ -53,32 +53,32 @@ bm_atom_generate(bm_settings_t *settings)
     if (settings == NULL)
         return NULL;
 
-    const char *atom_prefix = bc_trie_lookup(settings->settings, "atom_prefix");
-    const char *atom_ext = bc_trie_lookup(settings->settings, "atom_ext");
-    const char *post_prefix = bc_trie_lookup(settings->settings, "post_prefix");
-    const char *post_ext = bc_trie_lookup(settings->settings, "html_ext");
+    const char *atom_prefix = sb_trie_lookup(settings->settings, "atom_prefix");
+    const char *atom_ext = sb_trie_lookup(settings->settings, "atom_ext");
+    const char *post_prefix = sb_trie_lookup(settings->settings, "post_prefix");
+    const char *post_ext = sb_trie_lookup(settings->settings, "html_ext");
 
-    bc_string_t *atom_url = bc_string_new();
+    sb_string_t *atom_url = sb_string_new();
 
     if (atom_prefix[0] != '\0')
-        bc_string_append_c(atom_url, '/');
+        sb_string_append_c(atom_url, '/');
 
-    bc_string_append(atom_url, atom_prefix);
-    bc_string_append(atom_url, "{% ifdef FILTER_TAG %}/{{ FILTER_TAG }}");
+    sb_string_append(atom_url, atom_prefix);
+    sb_string_append(atom_url, "{% ifdef FILTER_TAG %}/{{ FILTER_TAG }}");
 
     if (atom_prefix[0] == '\0' && atom_ext[0] != '/')
-        bc_string_append(atom_url, "{% else %}/index");
+        sb_string_append(atom_url, "{% else %}/index");
 
-    bc_string_append(atom_url, "{% endif %}");
-    bc_string_append(atom_url, atom_ext);
+    sb_string_append(atom_url, "{% endif %}");
+    sb_string_append(atom_url, atom_ext);
 
     char *post_url = bm_generate_filename(NULL, post_prefix, "{{ FILENAME }}",
         post_ext);
 
-    char *rv = bc_strdup_printf(atom_template, atom_url->str, atom_url->str,
+    char *rv = sb_strdup_printf(atom_template, atom_url->str, atom_url->str,
         post_url, post_url);
 
-    bc_string_free(atom_url, true);
+    sb_string_free(atom_url, true);
     free(post_url);
 
     return rv;
@@ -86,14 +86,14 @@ bm_atom_generate(bm_settings_t *settings)
 
 
 char*
-bm_atom_deploy(bm_settings_t *settings, bc_error_t **err)
+bm_atom_deploy(bm_settings_t *settings, sb_error_t **err)
 {
     if (settings == NULL || err == NULL || *err != NULL)
         return NULL;
 
-    if (NULL != bc_trie_lookup(settings->settings, "atom_legacy_entry_id")) {
-        *err = bc_error_new_printf(BLOGC_MAKE_ERROR_ATOM,
-            "'atom_legacy_entry_id' setting is not supported anymore. see "
+    if (NULL != sb_trie_lookup(settings->settings, "atom_legacy_entry_id")) {
+        *err = sb_strerror_new(
+            "atom: 'atom_legacy_entry_id' setting is not supported anymore. see "
             "https://blogc.rgm.io/news/blogc-0.16.1/ for details");
         return NULL;
     }
@@ -102,8 +102,8 @@ bm_atom_deploy(bm_settings_t *settings, bc_error_t **err)
     char fname[] = "/tmp/blogc-make_XXXXXX";
     int fd;
     if (-1 == (fd = mkstemp(fname))) {
-        *err = bc_error_new_printf(BLOGC_MAKE_ERROR_ATOM,
-            "Failed to create temporary atom template: %s", strerror(errno));
+        *err = sb_strerror_new_printf(
+            "atom: Failed to create temporary atom template: %s", strerror(errno));
         return NULL;
     }
 
@@ -115,8 +115,8 @@ bm_atom_deploy(bm_settings_t *settings, bc_error_t **err)
     }
 
     if (-1 == write(fd, content, strlen(content))) {
-        *err = bc_error_new_printf(BLOGC_MAKE_ERROR_ATOM,
-            "Failed to write to temporary atom template: %s", strerror(errno));
+        *err = sb_strerror_new_printf(
+            "atom: Failed to write to temporary atom template: %s", strerror(errno));
         free(content);
         close(fd);
         unlink(fname);
@@ -126,7 +126,7 @@ bm_atom_deploy(bm_settings_t *settings, bc_error_t **err)
     free(content);
     close(fd);
 
-    return bc_strdup(fname);
+    return sb_strdup(fname);
 }
 
 
diff --git a/src/blogc-make/atom.h b/src/blogc-make/atom.h
index 29a6dcb..d22b8ab 100644
--- a/src/blogc-make/atom.h
+++ b/src/blogc-make/atom.h
@@ -9,11 +9,12 @@
 #ifndef _MAKE_ATOM_H
 #define _MAKE_ATOM_H
 
-#include "../common/error.h"
+#include <squareball.h>
+
 #include "settings.h"
 
 char* bm_atom_generate(bm_settings_t *settings);
-char* bm_atom_deploy(bm_settings_t *settings, bc_error_t **err);
+char* bm_atom_deploy(bm_settings_t *settings, sb_error_t **err);
 void bm_atom_destroy(const char *fname);
 
 #endif /* _MAKE_ATOM_H */
diff --git a/src/blogc-make/ctx.c b/src/blogc-make/ctx.c
index 423b334..f856b6e 100644
--- a/src/blogc-make/ctx.c
+++ b/src/blogc-make/ctx.c
@@ -14,11 +14,11 @@
 #include <limits.h>
 #include <time.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include <stdbool.h>
 #include <string.h>
-#include "../common/error.h"
-#include "../common/file.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "atom.h"
 #include "settings.h"
 #include "exec.h"
@@ -33,13 +33,13 @@ bm_filectx_new(bm_ctx_t *ctx, const char *filename, const char *slug,
     if (ctx == NULL || filename == NULL)
         return NULL;
 
-    char *f = filename[0] == '/' ? bc_strdup(filename) :
-        bc_strdup_printf("%s/%s", ctx->root_dir, filename);
+    char *f = filename[0] == '/' ? sb_strdup(filename) :
+        sb_strdup_printf("%s/%s", ctx->root_dir, filename);
 
-    bm_filectx_t *rv = bc_malloc(sizeof(bm_filectx_t));
+    bm_filectx_t *rv = sb_malloc(sizeof(bm_filectx_t));
     rv->path = f;
-    rv->short_path = bc_strdup(filename);
-    rv->slug = bc_strdup(slug);
+    rv->short_path = sb_strdup(filename);
+    rv->slug = sb_strdup(slug);
 
     if (st == NULL) {
         struct stat buf;
@@ -62,14 +62,14 @@ bm_filectx_new(bm_ctx_t *ctx, const char *filename, const char *slug,
 }
 
 
-bc_slist_t*
-bm_filectx_new_r(bc_slist_t *l, bm_ctx_t *ctx, const char *filename)
+sb_slist_t*
+bm_filectx_new_r(sb_slist_t *l, bm_ctx_t *ctx, const char *filename)
 {
     if (ctx == NULL || filename == NULL)
         return NULL;
 
-    char *f = filename[0] == '/' ? bc_strdup(filename) :
-        bc_strdup_printf("%s/%s", ctx->root_dir, filename);
+    char *f = filename[0] == '/' ? sb_strdup(filename) :
+        sb_strdup_printf("%s/%s", ctx->root_dir, filename);
 
     struct stat buf;
     if (0 != stat(f, &buf)) {
@@ -88,7 +88,7 @@ bm_filectx_new_r(bc_slist_t *l, bm_ctx_t *ctx, const char *filename)
         while (NULL != (e = readdir(dir))) {
             if ((0 == strcmp(e->d_name, ".")) || (0 == strcmp(e->d_name, "..")))
                 continue;
-            char *tmp = bc_strdup_printf("%s/%s", filename, e->d_name);
+            char *tmp = sb_strdup_printf("%s/%s", filename, e->d_name);
             l = bm_filectx_new_r(l, ctx, tmp);
             free(tmp);
         }
@@ -98,7 +98,7 @@ bm_filectx_new_r(bc_slist_t *l, bm_ctx_t *ctx, const char *filename)
         return l;
     }
 
-    l = bc_slist_append(l, bm_filectx_new(ctx, filename, NULL, &buf));
+    l = sb_slist_append(l, bm_filectx_new(ctx, filename, NULL, &buf));
     free(f);
     return l;
 }
@@ -167,7 +167,7 @@ bm_filectx_free(bm_filectx_t *fctx)
 
 bm_ctx_t*
 bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
-    bc_error_t **err)
+    sb_error_t **err)
 {
     if (settings_file == NULL || err == NULL || *err != NULL)
         return NULL;
@@ -177,7 +177,7 @@ bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
         return NULL;
 
     size_t content_len;
-    char *content = bc_file_get_contents(abs_filename, true, &content_len,
+    char *content = sb_file_get_contents_utf8(abs_filename, &content_len,
         err);
     if (*err != NULL) {
         free(abs_filename);
@@ -192,16 +192,16 @@ bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
     }
     free(content);
 
-    const char *template_dir = bc_trie_lookup(settings->settings, "template_dir");
+    const char *template_dir = sb_trie_lookup(settings->settings, "template_dir");
     if (template_dir == NULL)
         template_dir = "";
 
     char *atom_template = NULL;
     bool atom_template_tmp = false;
-    const char *atom_template_conf = bc_trie_lookup(settings->settings,
+    const char *atom_template_conf = sb_trie_lookup(settings->settings,
         "atom_template");
     if (atom_template_conf != NULL) {
-        atom_template = bc_strdup_printf("%s/%s", template_dir, atom_template_conf);
+        atom_template = sb_strdup_printf("%s/%s", template_dir, atom_template_conf);
     }
     else {
         atom_template = bm_atom_deploy(settings, err);
@@ -215,7 +215,7 @@ bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
 
     bm_ctx_t *rv = NULL;
     if (base == NULL) {
-        rv = bc_malloc(sizeof(bm_ctx_t));
+        rv = sb_malloc(sizeof(bm_ctx_t));
         rv->blogc = bm_exec_find_binary(argv0, "blogc", "BLOGC");
         rv->blogc_runserver = bm_exec_find_binary(argv0, "blogc-runserver",
             "BLOGC_RUNSERVER");
@@ -229,23 +229,23 @@ bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
     rv->settings = settings;
 
     rv->settings_fctx = bm_filectx_new(rv, abs_filename, NULL, NULL);
-    rv->root_dir = bc_strdup(dirname(abs_filename));
+    rv->root_dir = sb_strdup(dirname(abs_filename));
     free(abs_filename);
 
     const char *output_dir = getenv("OUTPUT_DIR");
-    rv->short_output_dir = bc_strdup(output_dir != NULL ? output_dir : "_build");
+    rv->short_output_dir = sb_strdup(output_dir != NULL ? output_dir : "_build");
 
     if (rv->short_output_dir[0] == '/') {
-        rv->output_dir = bc_strdup(rv->short_output_dir);
+        rv->output_dir = sb_strdup(rv->short_output_dir);
     }
     else {
-        rv->output_dir = bc_strdup_printf("%s/%s", rv->root_dir,
+        rv->output_dir = sb_strdup_printf("%s/%s", rv->root_dir,
             rv->short_output_dir);
     }
 
     // can't return null and set error after this!
 
-    char *main_template = bc_strdup_printf("%s/%s", template_dir,
+    char *main_template = sb_strdup_printf("%s/%s", template_dir,
         bm_ctx_settings_lookup(rv, "main_template"));
     rv->main_template_fctx = bm_filectx_new(rv, main_template, NULL, NULL);
     free(main_template);
@@ -271,7 +271,7 @@ bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
         for (size_t i = 0; settings->posts[i] != NULL; i++) {
             char *f = bm_generate_filename(content_dir, post_prefix,
                 settings->posts[i], source_ext);
-            rv->posts_fctx = bc_slist_append(rv->posts_fctx,
+            rv->posts_fctx = sb_slist_append(rv->posts_fctx,
                 bm_filectx_new(rv, f, settings->posts[i], NULL));
             free(f);
         }
@@ -282,7 +282,7 @@ bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
         for (size_t i = 0; settings->pages[i] != NULL; i++) {
             char *f = bm_generate_filename(content_dir, NULL, settings->pages[i],
                 source_ext);
-            rv->pages_fctx = bc_slist_append(rv->pages_fctx,
+            rv->pages_fctx = sb_slist_append(rv->pages_fctx,
                 bm_filectx_new(rv, f, settings->pages[i], NULL));
             free(f);
         }
@@ -312,13 +312,13 @@ bm_ctx_reload(bm_ctx_t **ctx)
         // files
 
         // needs to dup path, because it may be freed when reloading.
-        char *tmp = bc_strdup((*ctx)->settings_fctx->path);
-        bc_error_t *err = NULL;
+        char *tmp = sb_strdup((*ctx)->settings_fctx->path);
+        sb_error_t *err = NULL;
         *ctx = bm_ctx_new(*ctx, tmp, NULL, &err);
         free(tmp);
         if (err != NULL) {
-            bc_error_print(err, "blogc-make");
-            bc_error_free(err);
+            fprintf(stderr, "blogc-make: error: %s\n", sb_error_to_string(err));
+            sb_error_free(err);
             return false;
         }
         return true;
@@ -328,13 +328,13 @@ bm_ctx_reload(bm_ctx_t **ctx)
     bm_filectx_reload((*ctx)->atom_template_fctx);
     bm_filectx_reload((*ctx)->listing_entry_fctx);
 
-    for (bc_slist_t *tmp = (*ctx)->posts_fctx; tmp != NULL; tmp = tmp->next)
+    for (sb_slist_t *tmp = (*ctx)->posts_fctx; tmp != NULL; tmp = tmp->next)
         bm_filectx_reload((bm_filectx_t*) tmp->data);
 
-    for (bc_slist_t *tmp = (*ctx)->pages_fctx; tmp != NULL; tmp = tmp->next)
+    for (sb_slist_t *tmp = (*ctx)->pages_fctx; tmp != NULL; tmp = tmp->next)
         bm_filectx_reload((bm_filectx_t*) tmp->data);
 
-    for (bc_slist_t *tmp = (*ctx)->copy_fctx; tmp != NULL; tmp = tmp->next)
+    for (sb_slist_t *tmp = (*ctx)->copy_fctx; tmp != NULL; tmp = tmp->next)
         bm_filectx_reload((bm_filectx_t*) tmp->data);
 
     return true;
@@ -370,11 +370,11 @@ bm_ctx_free_internal(bm_ctx_t *ctx)
     bm_filectx_free(ctx->listing_entry_fctx);
     ctx->listing_entry_fctx = NULL;
 
-    bc_slist_free_full(ctx->posts_fctx, (bc_free_func_t) bm_filectx_free);
+    sb_slist_free_full(ctx->posts_fctx, (sb_free_func_t) bm_filectx_free);
     ctx->posts_fctx = NULL;
-    bc_slist_free_full(ctx->pages_fctx, (bc_free_func_t) bm_filectx_free);
+    sb_slist_free_full(ctx->pages_fctx, (sb_free_func_t) bm_filectx_free);
     ctx->pages_fctx = NULL;
-    bc_slist_free_full(ctx->copy_fctx, (bc_free_func_t) bm_filectx_free);
+    sb_slist_free_full(ctx->copy_fctx, (sb_free_func_t) bm_filectx_free);
     ctx->copy_fctx = NULL;
 }
 
@@ -396,7 +396,7 @@ bm_ctx_settings_lookup(bm_ctx_t *ctx, const char *key)
 {
     if (ctx == NULL || ctx->settings == NULL || ctx->settings->settings == NULL)
         return NULL;
-    return bc_trie_lookup(ctx->settings->settings, key);
+    return sb_trie_lookup(ctx->settings->settings, key);
 }
 
 
diff --git a/src/blogc-make/ctx.h b/src/blogc-make/ctx.h
index a66d51c..c819b9e 100644
--- a/src/blogc-make/ctx.h
+++ b/src/blogc-make/ctx.h
@@ -12,9 +12,9 @@
 #include <sys/stat.h>
 #include <stdbool.h>
 #include <time.h>
+#include <squareball.h>
+
 #include "settings.h"
-#include "../common/error.h"
-#include "../common/utils.h"
 
 #ifdef __APPLE__
 #define st_mtim_tv_sec st_mtimespec.tv_sec
@@ -62,19 +62,19 @@ typedef struct {
     bm_filectx_t *settings_fctx;
     bm_filectx_t *listing_entry_fctx;
 
-    bc_slist_t *posts_fctx;
-    bc_slist_t *pages_fctx;
-    bc_slist_t *copy_fctx;
+    sb_slist_t *posts_fctx;
+    sb_slist_t *pages_fctx;
+    sb_slist_t *copy_fctx;
 } bm_ctx_t;
 
 bm_filectx_t* bm_filectx_new(bm_ctx_t *ctx, const char *filename, const char *slug,
     struct stat *st);
-bc_slist_t* bm_filectx_new_r(bc_slist_t *l, bm_ctx_t *ctx, const char *filename);
+sb_slist_t* bm_filectx_new_r(sb_slist_t *l, bm_ctx_t *ctx, const char *filename);
 bool bm_filectx_changed(bm_filectx_t *ctx, time_t *tv_sec, long *tv_nsec);
 void bm_filectx_reload(bm_filectx_t *ctx);
 void bm_filectx_free(bm_filectx_t *fctx);
 bm_ctx_t* bm_ctx_new(bm_ctx_t *base, const char *settings_file,
-    const char *argv0, bc_error_t **err);
+    const char *argv0, sb_error_t **err);
 bool bm_ctx_reload(bm_ctx_t **ctx);
 void bm_ctx_free_internal(bm_ctx_t *ctx);
 void bm_ctx_free(bm_ctx_t *ctx);
diff --git a/src/blogc-make/exec-native.c b/src/blogc-make/exec-native.c
index 179216a..0278c00 100644
--- a/src/blogc-make/exec-native.c
+++ b/src/blogc-make/exec-native.c
@@ -16,11 +16,10 @@
 #include <unistd.h>
 #include <libgen.h>
 #include <errno.h>
-#include "../common/error.h"
-#include "../common/file.h"
-#include "../common/utils.h"
-#include "exec-native.h"
+#include <squareball.h>
+
 #include "ctx.h"
+#include "exec-native.h"
 
 
 int
@@ -32,7 +31,7 @@ bm_exec_native_cp(bm_filectx_t *source, bm_filectx_t *dest, bool verbose)
         printf("  COPY     %s\n", dest->short_path);
     fflush(stdout);
 
-    char *fname = bc_strdup(dest->path);
+    char *fname = sb_strdup(dest->path);
     for (char *tmp = fname; *tmp != '\0'; tmp++) {
         if (*tmp != '/' && *tmp != '\\')
             continue;
@@ -67,8 +66,8 @@ bm_exec_native_cp(bm_filectx_t *source, bm_filectx_t *dest, bool verbose)
     }
 
     ssize_t nread;
-    char buffer[BC_FILE_CHUNK_SIZE];
-    while (0 < (nread = read(fd_from, buffer, BC_FILE_CHUNK_SIZE))) {
+    char buffer[128];
+    while (0 < (nread = read(fd_from, buffer, 128))) {
         char *out_ptr = buffer;
         do {
             ssize_t nwritten = write(fd_to, out_ptr, nread);
@@ -89,7 +88,7 @@ bm_exec_native_cp(bm_filectx_t *source, bm_filectx_t *dest, bool verbose)
 
 
 bool
-bm_exec_native_is_empty_dir(const char *dir, bc_error_t **err)
+bm_exec_native_is_empty_dir(const char *dir, sb_error_t **err)
 {
     DIR *d = opendir(dir);
     if (d == NULL) {
@@ -97,7 +96,7 @@ bm_exec_native_is_empty_dir(const char *dir, bc_error_t **err)
             return true;
         }
         if (err != NULL) {
-            *err = bc_error_new_printf(0, "failed to open directory (%s): %s\n",
+            *err = sb_strerror_new_printf("failed to open directory (%s): %s\n",
                 dir, strerror(errno));
         }
         return true;
@@ -114,7 +113,7 @@ bm_exec_native_is_empty_dir(const char *dir, bc_error_t **err)
 
     if (0 != closedir(d)) {
         if (err != NULL) {
-            *err = bc_error_new_printf(0, "failed to close directory (%s): %s\n",
+            *err = sb_strerror_new_printf("failed to close directory (%s): %s\n",
                 dir, strerror(errno));
         }
         return true;
@@ -143,16 +142,16 @@ bm_exec_native_rm(const char *output_dir, bm_filectx_t *dest, bool verbose)
 
     // blame freebsd's libc for all of those memory allocations around dirname
     // calls!
-    char *short_dir = bc_strdup(dirname(dest->short_path));
-    char *dir = bc_strdup(dirname(dest->path));
+    char *short_dir = sb_strdup(dirname(dest->short_path));
+    char *dir = sb_strdup(dirname(dest->path));
 
-    bc_error_t *err = NULL;
+    sb_error_t *err = NULL;
 
     while ((0 != strcmp(short_dir, ".")) && (0 != strcmp(short_dir, "/"))) {
         bool empty = bm_exec_native_is_empty_dir(dir, &err);
         if (err != NULL) {
-            fprintf(stderr, "blogc-make: error: %s\n", err->msg);
-            bc_error_free(err);
+            fprintf(stderr, "blogc-make: error: %s\n", sb_error_to_string(err));
+            sb_error_free(err);
             rv = 1;
             break;
         }
@@ -175,10 +174,10 @@ bm_exec_native_rm(const char *output_dir, bm_filectx_t *dest, bool verbose)
         }
 
         char *tmp = short_dir;
-        short_dir = bc_strdup(dirname(short_dir));
+        short_dir = sb_strdup(dirname(short_dir));
         free(tmp);
         tmp = dir;
-        dir = bc_strdup(dirname(dir));
+        dir = sb_strdup(dirname(dir));
         free(tmp);
     }
 
diff --git a/src/blogc-make/exec-native.h b/src/blogc-make/exec-native.h
index 56a1da1..7fe7575 100644
--- a/src/blogc-make/exec-native.h
+++ b/src/blogc-make/exec-native.h
@@ -10,11 +10,12 @@
 #define _MAKE_EXEC_NATIVE_H
 
 #include <stdbool.h>
-#include "../common/error.h"
+#include <squareball.h>
+
 #include "ctx.h"
 
 int bm_exec_native_cp(bm_filectx_t *source, bm_filectx_t *dest, bool verbose);
-bool bm_exec_native_is_empty_dir(const char *dir, bc_error_t **err);
+bool bm_exec_native_is_empty_dir(const char *dir, sb_error_t **err);
 int bm_exec_native_rm(const char *output_dir, bm_filectx_t *dest, bool verbose);
 
 #endif /* _MAKE_EXEC_NATIVE_H */
diff --git a/src/blogc-make/exec.c b/src/blogc-make/exec.c
index 74af2ed..89d4b0a 100644
--- a/src/blogc-make/exec.c
+++ b/src/blogc-make/exec.c
@@ -19,13 +19,11 @@
 #include <sysexits.h>
 #include <errno.h>
 #include <libgen.h>
-#include "../common/compat.h"
-#include "../common/error.h"
-#include "../common/file.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "ctx.h"
-#include "exec.h"
 #include "settings.h"
+#include "exec.h"
 
 
 char*
@@ -36,14 +34,14 @@ bm_exec_find_binary(const char *argv0, const char *bin, const char *env)
     // argv0, because the static binary may not be named `blogc`, and we
     // prefer to use our own `blogc` instead of some other version around.
     if (argv0 != NULL && bin != NULL && (0 == strcmp(bin, "blogc"))) {
-        return bc_shell_quote(argv0);
+        return sb_shell_quote(argv0);
     }
 #endif
 
     // first try: env var
     const char *env_bin = getenv(env);
     if (env_bin != NULL) {
-        return bc_shell_quote(env_bin);
+        return sb_shell_quote(env_bin);
     }
 
     // second try: same dir as current exec
@@ -55,13 +53,13 @@ bm_exec_find_binary(const char *argv0, const char *bin, const char *env)
     //   that relative paths will work as expected.
     // - windows path sep is not supported
     if (argv0 != NULL && (NULL != strchr(argv0, '/'))) {
-        char *path = bc_strdup(argv0);
-        char *dir = bc_strdup(dirname(path));
+        char *path = sb_strdup(argv0);
+        char *dir = sb_strdup(dirname(path));
         free(path);
-        char *tmp = bc_strdup_printf("%s/%s", dir, bin);
+        char *tmp = sb_strdup_printf("%s/%s", dir, bin);
         free(dir);
         if (0 == access(tmp, X_OK)) {
-            char *rv = bc_shell_quote(tmp);
+            char *rv = sb_shell_quote(tmp);
             free(tmp);
             return rv;
         }
@@ -69,28 +67,28 @@ bm_exec_find_binary(const char *argv0, const char *bin, const char *env)
     }
 
     // last try: $PATH
-    return bc_strdup(bin);
+    return sb_strdup(bin);
 }
 
 
 int
 bm_exec_command(const char *cmd, const char *input, char **output,
-    char **error, bc_error_t **err)
+    char **error, sb_error_t **err)
 {
     if (err == NULL || *err != NULL)
         return 1;
 
     int fd_in[2];
     if (-1 == pipe(fd_in)) {
-        *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
-            "Failed to create stdin pipe: %s", strerror(errno));
+        *err = sb_strerror_new_printf(
+            "exec: Failed to create stdin pipe: %s", strerror(errno));
         return 1;
     }
 
     int fd_out[2];
     if (-1 == pipe(fd_out)) {
-        *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
-            "Failed to create stdout pipe: %s", strerror(errno));
+        *err = sb_strerror_new_printf(
+            "exec: Failed to create stdout pipe: %s", strerror(errno));
         close(fd_in[0]);
         close(fd_in[1]);
         return 1;
@@ -98,8 +96,8 @@ bm_exec_command(const char *cmd, const char *input, char **output,
 
     int fd_err[2];
     if (-1 == pipe(fd_err)) {
-        *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
-            "Failed to create stderr pipe: %s", strerror(errno));
+        *err = sb_strerror_new_printf(
+            "exec: Failed to create stderr pipe: %s", strerror(errno));
         close(fd_in[0]);
         close(fd_in[1]);
         close(fd_out[0]);
@@ -109,8 +107,8 @@ bm_exec_command(const char *cmd, const char *input, char **output,
 
     pid_t pid = fork();
     if (pid == -1) {
-        *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
-            "Failed to fork: %s", strerror(errno));
+        *err = sb_strerror_new_printf(
+            "exec: Failed to fork: %s", strerror(errno));
         close(fd_in[0]);
         close(fd_in[1]);
         close(fd_out[0]);
@@ -149,8 +147,8 @@ bm_exec_command(const char *cmd, const char *input, char **output,
 
     if (input != NULL) {
         if (-1 == write(fd_in[1], input, strlen(input))) {
-            *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
-                "Failed to write to stdin pipe: %s", strerror(errno));
+            *err = sb_strerror_new_printf(
+                "exec: Failed to write to stdin pipe: %s", strerror(errno));
             close(fd_in[1]);
             close(fd_out[0]);
             close(fd_err[0]);
@@ -160,145 +158,145 @@ bm_exec_command(const char *cmd, const char *input, char **output,
 
     close(fd_in[1]);
 
-    char buffer[BC_FILE_CHUNK_SIZE];
+    char buffer[128];
     ssize_t s;
 
-    bc_string_t *out = NULL;
-    while(0 != (s = read(fd_out[0], buffer, BC_FILE_CHUNK_SIZE))) {
+    sb_string_t *out = NULL;
+    while(0 != (s = read(fd_out[0], buffer, 128))) {
         if (s == -1) {
-            *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
-                "Failed to read from stdout pipe: %s", strerror(errno));
+            *err = sb_strerror_new_printf(
+                "exec: Failed to read from stdout pipe: %s", strerror(errno));
             close(fd_out[0]);
             close(fd_err[0]);
-            bc_string_free(out, true);
+            sb_string_free(out, true);
             return 1;
         }
         if (out == NULL) {
-            out = bc_string_new();
+            out = sb_string_new();
         }
-        bc_string_append_len(out, buffer, s);
+        sb_string_append_len(out, buffer, s);
     }
     if (out != NULL) {
-        *output = bc_string_free(out, false);
+        *output = sb_string_free(out, false);
     }
     close(fd_out[0]);
 
     out = NULL;
-    while(0 != (s = read(fd_err[0], buffer, BC_FILE_CHUNK_SIZE))) {
+    while(0 != (s = read(fd_err[0], buffer, 128))) {
         if (s == -1) {
-            *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
-                "Failed to read from stderr pipe: %s", strerror(errno));
+            *err = sb_strerror_new_printf(
+                "exec: Failed to read from stderr pipe: %s", strerror(errno));
             close(fd_err[0]);
-            bc_string_free(out, true);
+            sb_string_free(out, true);
             return 1;
         }
         if (out == NULL)
-            out = bc_string_new();
-        bc_string_append_len(out, buffer, s);
+            out = sb_string_new();
+        sb_string_append_len(out, buffer, s);
     }
     if (out != NULL) {
-        *error = bc_string_free(out, false);
+        *error = sb_string_free(out, false);
     }
     close(fd_err[0]);
 
     int status;
     waitpid(pid, &status, 0);
 
-    return bc_compat_status_code(status);
+    return sb_compat_status_code(status);
 }
 
 
 static void
-list_variables(const char *key, const char *value, bc_string_t *str)
+list_variables(const char *key, const char *value, sb_string_t *str)
 {
-    char *tmp = bc_shell_quote(value);
-    bc_string_append_printf(str, " -D %s=%s", key, tmp);
+    char *tmp = sb_shell_quote(value);
+    sb_string_append_printf(str, " -D %s=%s", key, tmp);
     free(tmp);
 }
 
 
 char*
 bm_exec_build_blogc_cmd(const char *blogc_bin, bm_settings_t *settings,
-    bc_trie_t *global_variables, bc_trie_t *local_variables, const char *print,
+    sb_trie_t *global_variables, sb_trie_t *local_variables, const char *print,
     bool listing, const char *listing_entry, const char *template,
     const char *output, bool dev, bool sources_stdin)
 {
-    bc_string_t *rv = bc_string_new();
+    sb_string_t *rv = sb_string_new();
 
     const char *locale = NULL;
     if (settings != NULL) {
-        locale = bc_trie_lookup(settings->settings, "locale");
+        locale = sb_trie_lookup(settings->settings, "locale");
     }
     if (locale != NULL) {
-        char *tmp = bc_shell_quote(locale);
-        bc_string_append_printf(rv, "LC_ALL=%s ", tmp);
+        char *tmp = sb_shell_quote(locale);
+        sb_string_append_printf(rv, "LC_ALL=%s ", tmp);
         free(tmp);
     }
 
-    bc_string_append(rv, blogc_bin);
+    sb_string_append(rv, blogc_bin);
 
     if (settings != NULL) {
         if (settings->tags != NULL) {
-            char *tags = bc_strv_join(settings->tags, " ");
-            bc_string_append_printf(rv, " -D MAKE_TAGS='%s'", tags);
+            char *tags = sb_strv_join(settings->tags, " ");
+            sb_string_append_printf(rv, " -D MAKE_TAGS='%s'", tags);
             free(tags);
         }
 
-        bc_trie_foreach(settings->global,
-            (bc_trie_foreach_func_t) list_variables, rv);
+        sb_trie_foreach(settings->global,
+            (sb_trie_foreach_func_t) list_variables, rv);
     }
 
-    bc_trie_foreach(global_variables, (bc_trie_foreach_func_t) list_variables, rv);
-    bc_trie_foreach(local_variables, (bc_trie_foreach_func_t) list_variables, rv);
+    sb_trie_foreach(global_variables, (sb_trie_foreach_func_t) list_variables, rv);
+    sb_trie_foreach(local_variables, (sb_trie_foreach_func_t) list_variables, rv);
 
     if (dev) {
-        bc_string_append(rv, " -D MAKE_ENV_DEV=1 -D MAKE_ENV='dev'");
+        sb_string_append(rv, " -D MAKE_ENV_DEV=1 -D MAKE_ENV='dev'");
     }
 
     if (print != NULL) {
-        bc_string_append_printf(rv, " -p %s", print);
+        sb_string_append_printf(rv, " -p %s", print);
     }
 
     if (listing) {
-        bc_string_append(rv, " -l");
+        sb_string_append(rv, " -l");
         if (listing_entry != NULL) {
-            char *tmp = bc_shell_quote(listing_entry);
-            bc_string_append_printf(rv, " -e %s", tmp);
+            char *tmp = sb_shell_quote(listing_entry);
+            sb_string_append_printf(rv, " -e %s", tmp);
             free(tmp);
         }
     }
 
     if (template != NULL) {
-        char *tmp = bc_shell_quote(template);
-        bc_string_append_printf(rv, " -t %s", tmp);
+        char *tmp = sb_shell_quote(template);
+        sb_string_append_printf(rv, " -t %s", tmp);
         free(tmp);
     }
 
     if (output != NULL) {
-        char *tmp = bc_shell_quote(output);
-        bc_string_append_printf(rv, " -o %s", tmp);
+        char *tmp = sb_shell_quote(output);
+        sb_string_append_printf(rv, " -o %s", tmp);
         free(tmp);
     }
 
     if (sources_stdin) {
-        bc_string_append(rv, " -i");
+        sb_string_append(rv, " -i");
     }
 
-    return bc_string_free(rv, false);
+    return sb_string_free(rv, false);
 }
 
 
 int
-bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables, bc_trie_t *local_variables,
+bm_exec_blogc(bm_ctx_t *ctx, sb_trie_t *global_variables, sb_trie_t *local_variables,
     bool listing, bm_filectx_t *listing_entry, bm_filectx_t *template,
-    bm_filectx_t *output, bc_slist_t *sources, bool only_first_source)
+    bm_filectx_t *output, sb_slist_t *sources, bool only_first_source)
 {
     if (ctx == NULL)
         return 1;
 
-    bc_string_t *input = bc_string_new();
-    for (bc_slist_t *l = sources; l != NULL; l = l->next) {
-        bc_string_append_printf(input, "%s\n", ((bm_filectx_t*) l->data)->path);
+    sb_string_t *input = sb_string_new();
+    for (sb_slist_t *l = sources; l != NULL; l = l->next) {
+        sb_string_append_printf(input, "%s\n", ((bm_filectx_t*) l->data)->path);
         if (only_first_source)
             break;
     }
@@ -315,17 +313,17 @@ bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables, bc_trie_t *local_varia
 
     char *out = NULL;
     char *err = NULL;
-    bc_error_t *error = NULL;
+    sb_error_t *error = NULL;
 
     int rv = bm_exec_command(cmd, input->str, &out, &err, &error);
 
     if (error != NULL) {
-        bc_error_print(error, "blogc-make");
+        fprintf(stderr, "blogc-make: error: %s\n", sb_error_to_string(error));
         free(cmd);
         free(out);
         free(err);
-        bc_string_free(input, true);
-        bc_error_free(error);
+        sb_string_free(input, true);
+        sb_error_free(error);
         return 1;
     }
 
@@ -339,21 +337,21 @@ bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables, bc_trie_t *local_varia
                 "----------------------------->8-----------------------------\n"
                 "%s\n"
                 "----------------------------->8-----------------------------\n",
-                bc_str_strip(input->str));
+                sb_str_strip(input->str));
         }
         if (out != NULL) {
             fprintf(stderr, "\nSTDOUT:\n"
                 "----------------------------->8-----------------------------\n"
                 "%s\n"
                 "----------------------------->8-----------------------------\n",
-                bc_str_strip(out));
+                sb_str_strip(out));
         }
         if (err != NULL) {
             fprintf(stderr, "\nSTDERR:\n"
                 "----------------------------->8-----------------------------\n"
                 "%s\n"
                 "----------------------------->8-----------------------------\n",
-                bc_str_strip(err));
+                sb_str_strip(err));
         }
         fprintf(stderr, "\n");
     }
@@ -361,7 +359,7 @@ bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables, bc_trie_t *local_varia
         fprintf(stderr, "%s\n", err);
     }
 
-    bc_string_free(input, true);
+    sb_string_free(input, true);
     free(cmd);
     free(out);
     free(err);
@@ -371,16 +369,16 @@ bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables, bc_trie_t *local_varia
 
 
 char*
-bm_exec_blogc_get_variable(bm_ctx_t *ctx, bc_trie_t *global_variables,
-    bc_trie_t *local_variables, const char *variable, bool listing,
-    bc_slist_t *sources, bool only_first_source)
+bm_exec_blogc_get_variable(bm_ctx_t *ctx, sb_trie_t *global_variables,
+    sb_trie_t *local_variables, const char *variable, bool listing,
+    sb_slist_t *sources, bool only_first_source)
 {
     if (ctx == NULL)
         return NULL;
 
-    bc_string_t *input = bc_string_new();
-    for (bc_slist_t *l = sources; l != NULL; l = l->next) {
-        bc_string_append_printf(input, "%s\n", ((bm_filectx_t*) l->data)->path);
+    sb_string_t *input = sb_string_new();
+    for (sb_slist_t *l = sources; l != NULL; l = l->next) {
+        sb_string_append_printf(input, "%s\n", ((bm_filectx_t*) l->data)->path);
         if (only_first_source)
             break;
     }
@@ -394,14 +392,14 @@ bm_exec_blogc_get_variable(bm_ctx_t *ctx, bc_trie_t *global_variables,
 
     char *out = NULL;
     char *err = NULL;
-    bc_error_t *error = NULL;
+    sb_error_t *error = NULL;
 
     int rv = bm_exec_command(cmd, input->str, &out, &err, &error);
 
     if (error != NULL) {
-        bc_error_print(error, "blogc-make");
-        bc_error_free(error);
-        bc_string_free(input, true);
+        fprintf(stderr, "blogc-make: error: %s\n", sb_error_to_string(error));
+        sb_error_free(error);
+        sb_string_free(input, true);
         free(cmd);
         free(out);
         free(err);
@@ -410,8 +408,8 @@ bm_exec_blogc_get_variable(bm_ctx_t *ctx, bc_trie_t *global_variables,
 
     if (rv != 0) {
         if (rv != EX_CONFIG)
-            fprintf(stderr, "blogc-make: error: %s\n", bc_str_strip(err));
-        bc_string_free(input, true);
+            fprintf(stderr, "blogc-make: error: %s\n", sb_str_strip(err));
+        sb_string_free(input, true);
         free(cmd);
         free(out);
         free(err);
@@ -420,9 +418,9 @@ bm_exec_blogc_get_variable(bm_ctx_t *ctx, bc_trie_t *global_variables,
 
     char *val = NULL;
     if (out != NULL)
-        val = bc_strndup(out, strlen(out) - 1);
+        val = sb_strndup(out, strlen(out) - 1);
 
-    bc_string_free(input, true);
+    sb_string_free(input, true);
     free(cmd);
     free(out);
     free(err);
@@ -438,30 +436,30 @@ bm_exec_blogc_runserver(bm_ctx_t *ctx, const char *host, const char *port,
     if (ctx == NULL)
         return 1;
 
-    bc_string_t *cmd = bc_string_new();
+    sb_string_t *cmd = sb_string_new();
 
-    bc_string_append(cmd, ctx->blogc_runserver);
+    sb_string_append(cmd, ctx->blogc_runserver);
 
     if (host != NULL) {
-        char *tmp = bc_shell_quote(host);
-        bc_string_append_printf(cmd, " -t %s", tmp);
+        char *tmp = sb_shell_quote(host);
+        sb_string_append_printf(cmd, " -t %s", tmp);
         free(tmp);
     }
 
     if (port != NULL) {
-        char *tmp = bc_shell_quote(port);
-        bc_string_append_printf(cmd, " -p %s", tmp);
+        char *tmp = sb_shell_quote(port);
+        sb_string_append_printf(cmd, " -p %s", tmp);
         free(tmp);
     }
 
     if (threads != NULL) {
-        char *tmp = bc_shell_quote(threads);
-        bc_string_append_printf(cmd, " -m %s", tmp);
+        char *tmp = sb_shell_quote(threads);
+        sb_string_append_printf(cmd, " -m %s", tmp);
         free(tmp);
     }
 
-    char *tmp = bc_shell_quote(ctx->output_dir);
-    bc_string_append_printf(cmd, " %s", tmp);
+    char *tmp = sb_shell_quote(ctx->output_dir);
+    sb_string_append_printf(cmd, " %s", tmp);
     free(tmp);
 
     if (ctx->verbose)
@@ -472,8 +470,8 @@ bm_exec_blogc_runserver(bm_ctx_t *ctx, const char *host, const char *port,
 
     // we don't need pipes to run blogc-runserver, because it is "interactive"
     int status = system(cmd->str);
-    int rv = bc_compat_status_code(status);
-    bc_string_free(cmd, true);
+    int rv = sb_compat_status_code(status);
+    sb_string_free(cmd, true);
 
     if (rv != 0 && rv != 130) {
         if (rv == 127) {
diff --git a/src/blogc-make/exec.h b/src/blogc-make/exec.h
index 6bc206f..40d38b9 100644
--- a/src/blogc-make/exec.h
+++ b/src/blogc-make/exec.h
@@ -10,25 +10,25 @@
 #define _MAKE_EXEC_H
 
 #include <stdbool.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "ctx.h"
 #include "settings.h"
 
 char* bm_exec_find_binary(const char *argv0, const char *bin, const char *env);
 int bm_exec_command(const char *cmd, const char *input, char **output,
-    char **error, bc_error_t **err);
+    char **error, sb_error_t **err);
 char* bm_exec_build_blogc_cmd(const char *blogc_bin, bm_settings_t *settings,
-    bc_trie_t *global_variables, bc_trie_t *local_variables, const char *print,
+    sb_trie_t *global_variables, sb_trie_t *local_variables, const char *print,
     bool listing, const char *listing_entry, const char *template,
     const char *output, bool dev, bool sources_stdin);
-int bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables,
-    bc_trie_t *local_variables, bool listing, bm_filectx_t *listing_entry,
-    bm_filectx_t *template, bm_filectx_t *output, bc_slist_t *sources,
+int bm_exec_blogc(bm_ctx_t *ctx, sb_trie_t *global_variables,
+    sb_trie_t *local_variables, bool listing, bm_filectx_t *listing_entry,
+    bm_filectx_t *template, bm_filectx_t *output, sb_slist_t *sources,
     bool only_first_source);
-char* bm_exec_blogc_get_variable(bm_ctx_t *ctx, bc_trie_t *global_variables,
-    bc_trie_t *local_variables, const char *variable, bool listing,
-    bc_slist_t *sources, bool only_first_source);
+char* bm_exec_blogc_get_variable(bm_ctx_t *ctx, sb_trie_t *global_variables,
+    sb_trie_t *local_variables, const char *variable, bool listing,
+    sb_slist_t *sources, bool only_first_source);
 int bm_exec_blogc_runserver(bm_ctx_t *ctx, const char *host, const char *port,
     const char *threads);
 
diff --git a/src/blogc-make/httpd.c b/src/blogc-make/httpd.c
index adf9a9b..4412369 100644
--- a/src/blogc-make/httpd.c
+++ b/src/blogc-make/httpd.c
@@ -11,7 +11,8 @@
 #include <string.h>
 #include <pthread.h>
 #include <unistd.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "ctx.h"
 #include "exec.h"
 #include "reloader.h"
@@ -23,7 +24,7 @@
 
 typedef struct {
     bm_ctx_t *ctx;
-    bc_trie_t *args;
+    sb_trie_t *args;
 } bm_httpd_t;
 
 
@@ -32,8 +33,8 @@ httpd_thread(void *arg)
 {
     bm_httpd_t *httpd = arg;
 
-    int rv = bm_exec_blogc_runserver(httpd->ctx, bc_trie_lookup(httpd->args, "host"),
-        bc_trie_lookup(httpd->args, "port"), bc_trie_lookup(httpd->args, "threads"));
+    int rv = bm_exec_blogc_runserver(httpd->ctx, sb_trie_lookup(httpd->args, "host"),
+        sb_trie_lookup(httpd->args, "port"), sb_trie_lookup(httpd->args, "threads"));
 
     free(httpd);
 
@@ -45,8 +46,8 @@ httpd_thread(void *arg)
 
 
 int
-bm_httpd_run(bm_ctx_t **ctx, bm_rule_exec_func_t rule_exec, bc_slist_t *outputs,
-    bc_trie_t *args)
+bm_httpd_run(bm_ctx_t **ctx, bm_rule_exec_func_t rule_exec, sb_slist_t *outputs,
+    sb_trie_t *args)
 {
     // this is here to avoid that the httpd starts running in the middle of the
     // first build, as the reloader and the httpd are started in parallel.
@@ -76,7 +77,7 @@ bm_httpd_run(bm_ctx_t **ctx, bm_rule_exec_func_t rule_exec, bc_slist_t *outputs,
         return 1;
     }
 
-    bm_httpd_t *rv = bc_malloc(sizeof(bm_httpd_t));
+    bm_httpd_t *rv = sb_malloc(sizeof(bm_httpd_t));
     rv->ctx = *ctx;
     rv->args = args;
 
diff --git a/src/blogc-make/httpd.h b/src/blogc-make/httpd.h
index b0fa87d..2aa90b9 100644
--- a/src/blogc-make/httpd.h
+++ b/src/blogc-make/httpd.h
@@ -9,11 +9,12 @@
 #ifndef _MAKE_HTTPD_H
 #define _MAKE_HTTPD_H
 
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "ctx.h"
 #include "rules.h"
 
-int bm_httpd_run(bm_ctx_t **ctx, bm_rule_exec_func_t rule_exec, bc_slist_t *outputs,
-    bc_trie_t *args);
+int bm_httpd_run(bm_ctx_t **ctx, bm_rule_exec_func_t rule_exec, sb_slist_t *outputs,
+    sb_trie_t *args);
 
 #endif /* _MAKE_HTTPD_H */
diff --git a/src/blogc-make/main.c b/src/blogc-make/main.c
index 5b4a030..9b4bce0 100644
--- a/src/blogc-make/main.c
+++ b/src/blogc-make/main.c
@@ -14,8 +14,8 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "ctx.h"
 #include "rules.h"
 
@@ -60,9 +60,9 @@ main(int argc, char **argv)
     setlocale(LC_ALL, "");
 
     int rv = 0;
-    bc_error_t *err = NULL;
+    sb_error_t *err = NULL;
 
-    bc_slist_t *rules = NULL;
+    sb_slist_t *rules = NULL;
     bool verbose = false;
     bool dev = false;
     char *blogcfile = NULL;
@@ -85,9 +85,9 @@ main(int argc, char **argv)
                     break;
                 case 'f':
                     if (argv[i][2] != '\0')
-                        blogcfile = bc_strdup(argv[i] + 2);
+                        blogcfile = sb_strdup(argv[i] + 2);
                     else if (i + 1 < argc)
-                        blogcfile = bc_strdup(argv[++i]);
+                        blogcfile = sb_strdup(argv[++i]);
                     break;
 #ifdef MAKE_EMBEDDED
                 case 'm':
@@ -103,18 +103,18 @@ main(int argc, char **argv)
             }
         }
         else {
-            rules = bc_slist_append(rules, bc_strdup(argv[i]));
+            rules = sb_slist_append(rules, sb_strdup(argv[i]));
         }
     }
 
     if (rules == NULL) {
-        rules = bc_slist_append(rules, bc_strdup("all"));
+        rules = sb_slist_append(rules, sb_strdup("all"));
     }
 
     ctx = bm_ctx_new(NULL, blogcfile ? blogcfile : "blogcfile",
         argc > 0 ? argv[0] : NULL, &err);
     if (err != NULL) {
-        bc_error_print(err, "blogc-make");
+        fprintf(stderr, "blogc-make: error: %s\n", sb_error_to_string(err));
         rv = 1;
         goto cleanup;
     }
@@ -125,10 +125,10 @@ main(int argc, char **argv)
 
 cleanup:
 
-    bc_slist_free_full(rules, free);
+    sb_slist_free_full(rules, free);
     free(blogcfile);
     bm_ctx_free(ctx);
-    bc_error_free(err);
+    sb_error_free(err);
 
     return rv;
 }
diff --git a/src/blogc-make/reloader.c b/src/blogc-make/reloader.c
index fea8bd4..2fcbaf9 100644
--- a/src/blogc-make/reloader.c
+++ b/src/blogc-make/reloader.c
@@ -14,7 +14,8 @@
 #include <unistd.h>
 #include <pthread.h>
 #include <errno.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "ctx.h"
 #include "rules.h"
 #include "reloader.h"
@@ -36,7 +37,7 @@ sig_handler(int signum)
 
 int
 bm_reloader_run(bm_ctx_t **ctx, bm_rule_exec_func_t rule_exec,
-    bc_slist_t *outputs, bc_trie_t *args)
+    sb_slist_t *outputs, sb_trie_t *args)
 {
     // install ^C handler
     struct sigaction current_action;
diff --git a/src/blogc-make/reloader.h b/src/blogc-make/reloader.h
index f3fddf4..95332db 100644
--- a/src/blogc-make/reloader.h
+++ b/src/blogc-make/reloader.h
@@ -9,12 +9,13 @@
 #ifndef _MAKE_RELOADER_H
 #define _MAKE_RELOADER_H
 
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "ctx.h"
 #include "rules.h"
 
 int bm_reloader_run(bm_ctx_t **ctx, bm_rule_exec_func_t rule_exec,
-    bc_slist_t *outputs, bc_trie_t *args);
+    sb_slist_t *outputs, sb_trie_t *args);
 void bm_reloader_stop(int status_code);
 
 #endif /* _MAKE_RELOADER_H */
diff --git a/src/blogc-make/rules.c b/src/blogc-make/rules.c
index 06223c0..3b10bd2 100644
--- a/src/blogc-make/rules.c
+++ b/src/blogc-make/rules.c
@@ -11,7 +11,8 @@
 #include <string.h>
 #include <stdlib.h>
 #include <time.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "atom.h"
 #include "ctx.h"
 #include "exec.h"
@@ -24,36 +25,36 @@
 
 
 static void
-posts_ordering(bm_ctx_t *ctx, bc_trie_t *variables, const char *variable)
+posts_ordering(bm_ctx_t *ctx, sb_trie_t *variables, const char *variable)
 {
     if (ctx == NULL)
         return;  // something is wrong, let's not add any variable
 
     const char *value = bm_ctx_settings_lookup_str(ctx, variable);
     bool asc = 0 == strcasecmp(value, "asc");
-    bool sort = bc_str_to_bool(bm_ctx_settings_lookup(ctx, "posts_sort"));
+    bool sort = sb_str_to_bool(bm_ctx_settings_lookup(ctx, "posts_sort"));
 
     if (sort) {
-        bc_trie_insert(variables, "FILTER_SORT", bc_strdup("1"));
+        sb_trie_insert(variables, "FILTER_SORT", sb_strdup("1"));
     }
 
     if ((sort && asc) || (!sort && !asc)) {
-        bc_trie_insert(variables, "FILTER_REVERSE", bc_strdup("1"));
+        sb_trie_insert(variables, "FILTER_REVERSE", sb_strdup("1"));
     }
 }
 
 
 static void
-posts_pagination(bm_ctx_t *ctx, bc_trie_t *variables, const char *variable)
+posts_pagination(bm_ctx_t *ctx, sb_trie_t *variables, const char *variable)
 {
     if (ctx == NULL)
         return;  // something is wrong, let's not add any variable
 
     long posts_per_page = strtol(bm_ctx_settings_lookup_str(ctx, variable), NULL, 10);
     if (posts_per_page >= 0) {
-        bc_trie_insert(variables, "FILTER_PAGE", bc_strdup("1"));
-        bc_trie_insert(variables, "FILTER_PER_PAGE",
-            bc_strdup(bm_ctx_settings_lookup(ctx, variable)));
+        sb_trie_insert(variables, "FILTER_PAGE", sb_strdup("1"));
+        sb_trie_insert(variables, "FILTER_PER_PAGE",
+            sb_strdup(bm_ctx_settings_lookup(ctx, variable)));
     }
 }
 
@@ -71,7 +72,7 @@ posts_pagination_enabled(bm_ctx_t *ctx, const  char *variable)
 
 // INDEX RULE
 
-static bc_slist_t*
+static sb_slist_t*
 index_outputlist(bm_ctx_t *ctx)
 {
     if (ctx == NULL || ctx->settings->posts == NULL)
@@ -80,36 +81,36 @@ index_outputlist(bm_ctx_t *ctx)
     if (!posts_pagination_enabled(ctx, "posts_per_page"))
         return NULL;
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
 
     const char *index_prefix = bm_ctx_settings_lookup(ctx, "index_prefix");
     const char *html_ext = bm_ctx_settings_lookup(ctx, "html_ext");
 
     char *f = bm_generate_filename(ctx->short_output_dir, index_prefix, NULL,
         html_ext);
-    rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+    rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
     free(f);
 
     return rv;
 }
 
 static int
-index_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+index_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     if (ctx == NULL || ctx->settings->posts == NULL)
         return 0;
 
     int rv = 0;
 
-    bc_trie_t *variables = bc_trie_new(free);
+    sb_trie_t *variables = sb_trie_new(free);
     posts_pagination(ctx, variables, "posts_per_page");
     posts_ordering(ctx, variables, "html_order");
-    bc_trie_insert(variables, "DATE_FORMAT",
-        bc_strdup(bm_ctx_settings_lookup_str(ctx, "date_format")));
-    bc_trie_insert(variables, "MAKE_RULE", bc_strdup("index"));
-    bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("post"));
+    sb_trie_insert(variables, "DATE_FORMAT",
+        sb_strdup(bm_ctx_settings_lookup_str(ctx, "date_format")));
+    sb_trie_insert(variables, "MAKE_RULE", sb_strdup("index"));
+    sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("post"));
 
-    for (bc_slist_t *l = outputs; l != NULL; l = l->next) {
+    for (sb_slist_t *l = outputs; l != NULL; l = l->next) {
         bm_filectx_t *fctx = l->data;
         if (fctx == NULL)
             continue;
@@ -123,7 +124,7 @@ index_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
         }
     }
 
-    bc_trie_free(variables);
+    sb_trie_free(variables);
 
     return rv;
 }
@@ -131,7 +132,7 @@ index_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 
 // ATOM RULE
 
-static bc_slist_t*
+static sb_slist_t*
 atom_outputlist(bm_ctx_t *ctx)
 {
     if (ctx == NULL || ctx->settings->posts == NULL)
@@ -140,35 +141,35 @@ atom_outputlist(bm_ctx_t *ctx)
     if (!posts_pagination_enabled(ctx, "atom_posts_per_page"))
         return NULL;
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
 
     const char *atom_prefix = bm_ctx_settings_lookup(ctx, "atom_prefix");
     const char *atom_ext = bm_ctx_settings_lookup(ctx, "atom_ext");
 
     char *f = bm_generate_filename(ctx->short_output_dir, atom_prefix, NULL,
         atom_ext);
-    rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+    rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
     free(f);
 
     return rv;
 }
 
 static int
-atom_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+atom_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     if (ctx == NULL || ctx->settings->posts == NULL)
         return 0;
 
     int rv = 0;
 
-    bc_trie_t *variables = bc_trie_new(free);
+    sb_trie_t *variables = sb_trie_new(free);
     posts_pagination(ctx, variables, "atom_posts_per_page");
     posts_ordering(ctx, variables, "atom_order");
-    bc_trie_insert(variables, "DATE_FORMAT", bc_strdup("%Y-%m-%dT%H:%M:%SZ"));
-    bc_trie_insert(variables, "MAKE_RULE", bc_strdup("atom"));
-    bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("atom"));
+    sb_trie_insert(variables, "DATE_FORMAT", sb_strdup("%Y-%m-%dT%H:%M:%SZ"));
+    sb_trie_insert(variables, "MAKE_RULE", sb_strdup("atom"));
+    sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("atom"));
 
-    for (bc_slist_t *l = outputs; l != NULL; l = l->next) {
+    for (sb_slist_t *l = outputs; l != NULL; l = l->next) {
         bm_filectx_t *fctx = l->data;
         if (fctx == NULL)
             continue;
@@ -182,7 +183,7 @@ atom_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
         }
     }
 
-    bc_trie_free(variables);
+    sb_trie_free(variables);
 
     return rv;
 }
@@ -190,7 +191,7 @@ atom_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 
 // ATOM TAGS RULE
 
-static bc_slist_t*
+static sb_slist_t*
 atom_tags_outputlist(bm_ctx_t *ctx)
 {
     if (ctx == NULL || ctx->settings->posts == NULL || ctx->settings->tags == NULL)
@@ -199,7 +200,7 @@ atom_tags_outputlist(bm_ctx_t *ctx)
     if (!posts_pagination_enabled(ctx, "atom_posts_per_page"))
         return NULL;
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
 
     const char *atom_prefix = bm_ctx_settings_lookup(ctx, "atom_prefix");
     const char *atom_ext = bm_ctx_settings_lookup(ctx, "atom_ext");
@@ -207,7 +208,7 @@ atom_tags_outputlist(bm_ctx_t *ctx)
     for (size_t i = 0; ctx->settings->tags[i] != NULL; i++) {
         char *f = bm_generate_filename(ctx->short_output_dir, atom_prefix,
             ctx->settings->tags[i], atom_ext);
-        rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+        rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
         free(f);
     }
 
@@ -215,7 +216,7 @@ atom_tags_outputlist(bm_ctx_t *ctx)
 }
 
 static int
-atom_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+atom_tags_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     if (ctx == NULL || ctx->settings->posts == NULL || ctx->settings->tags == NULL)
         return 0;
@@ -223,20 +224,20 @@ atom_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
     int rv = 0;
     size_t i = 0;
 
-    bc_trie_t *variables = bc_trie_new(free);
+    sb_trie_t *variables = sb_trie_new(free);
     posts_pagination(ctx, variables, "atom_posts_per_page");
     posts_ordering(ctx, variables, "atom_order");
-    bc_trie_insert(variables, "DATE_FORMAT", bc_strdup("%Y-%m-%dT%H:%M:%SZ"));
-    bc_trie_insert(variables, "MAKE_RULE", bc_strdup("atom_tags"));
-    bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("atom"));
+    sb_trie_insert(variables, "DATE_FORMAT", sb_strdup("%Y-%m-%dT%H:%M:%SZ"));
+    sb_trie_insert(variables, "MAKE_RULE", sb_strdup("atom_tags"));
+    sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("atom"));
 
-    for (bc_slist_t *l = outputs; l != NULL; l = l->next, i++) {
+    for (sb_slist_t *l = outputs; l != NULL; l = l->next, i++) {
         bm_filectx_t *fctx = l->data;
         if (fctx == NULL)
             continue;
 
-        bc_trie_insert(variables, "FILTER_TAG",
-            bc_strdup(ctx->settings->tags[i]));
+        sb_trie_insert(variables, "FILTER_TAG",
+            sb_strdup(ctx->settings->tags[i]));
 
         if (bm_rule_need_rebuild(ctx->posts_fctx, ctx->settings_fctx, NULL, NULL,
                 fctx, false))
@@ -248,7 +249,7 @@ atom_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
         }
     }
 
-    bc_trie_free(variables);
+    sb_trie_free(variables);
 
     return rv;
 }
@@ -256,7 +257,7 @@ atom_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 
 // PAGINATION RULE
 
-static bc_slist_t*
+static sb_slist_t*
 pagination_outputlist(bm_ctx_t *ctx)
 {
     if (ctx == NULL || ctx->settings->posts == NULL)
@@ -265,13 +266,13 @@ pagination_outputlist(bm_ctx_t *ctx)
     if (!posts_pagination_enabled(ctx, "posts_per_page"))
         return NULL;
 
-    bc_trie_t *variables = bc_trie_new(free);
+    sb_trie_t *variables = sb_trie_new(free);
     posts_pagination(ctx, variables, "posts_per_page");
 
     char *last_page = bm_exec_blogc_get_variable(ctx, variables, NULL, "LAST_PAGE",
         true, ctx->posts_fctx, false);
 
-    bc_trie_free(variables);
+    sb_trie_free(variables);
 
     if (last_page == NULL)
         return NULL;
@@ -279,16 +280,16 @@ pagination_outputlist(bm_ctx_t *ctx)
     long pages = strtol(last_page, NULL, 10);
     free(last_page);
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
 
     const char *pagination_prefix = bm_ctx_settings_lookup(ctx, "pagination_prefix");
     const char *html_ext = bm_ctx_settings_lookup(ctx, "html_ext");
 
     for (size_t i = 0; i < pages; i++) {
-        char *j = bc_strdup_printf("%d", i + 1);
+        char *j = sb_strdup_printf("%d", i + 1);
         char *f = bm_generate_filename(ctx->short_output_dir, pagination_prefix,
             j, html_ext);
-        rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+        rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
         free(j);
         free(f);
     }
@@ -297,7 +298,7 @@ pagination_outputlist(bm_ctx_t *ctx)
 }
 
 static int
-pagination_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+pagination_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     if (ctx == NULL || ctx->settings->posts == NULL)
         return 0;
@@ -305,22 +306,22 @@ pagination_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
     int rv = 0;
     size_t page = 1;
 
-    bc_trie_t *variables = bc_trie_new(free);
+    sb_trie_t *variables = sb_trie_new(free);
     // not using posts_pagination because we set FILTER_PAGE anyway, and the
     // first value inserted in that function would be useless
-    bc_trie_insert(variables, "FILTER_PER_PAGE",
-        bc_strdup(bm_ctx_settings_lookup_str(ctx, "posts_per_page")));
+    sb_trie_insert(variables, "FILTER_PER_PAGE",
+        sb_strdup(bm_ctx_settings_lookup_str(ctx, "posts_per_page")));
     posts_ordering(ctx, variables, "html_order");
-    bc_trie_insert(variables, "DATE_FORMAT",
-        bc_strdup(bm_ctx_settings_lookup_str(ctx, "date_format")));
-    bc_trie_insert(variables, "MAKE_RULE", bc_strdup("pagination"));
-    bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("post"));
+    sb_trie_insert(variables, "DATE_FORMAT",
+        sb_strdup(bm_ctx_settings_lookup_str(ctx, "date_format")));
+    sb_trie_insert(variables, "MAKE_RULE", sb_strdup("pagination"));
+    sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("post"));
 
-    for (bc_slist_t *l = outputs; l != NULL; l = l->next, page++) {
+    for (sb_slist_t *l = outputs; l != NULL; l = l->next, page++) {
         bm_filectx_t *fctx = l->data;
         if (fctx == NULL)
             continue;
-        bc_trie_insert(variables, "FILTER_PAGE", bc_strdup_printf("%zu", page));
+        sb_trie_insert(variables, "FILTER_PAGE", sb_strdup_printf("%zu", page));
         if (bm_rule_need_rebuild(ctx->posts_fctx, ctx->settings_fctx,
                 ctx->listing_entry_fctx, ctx->main_template_fctx, fctx, false))
         {
@@ -331,7 +332,7 @@ pagination_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
         }
     }
 
-    bc_trie_free(variables);
+    sb_trie_free(variables);
 
     return rv;
 }
@@ -339,7 +340,7 @@ pagination_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 
 // PAGINATION TAGS RULE
 
-static bc_slist_t*
+static sb_slist_t*
 pagination_tags_outputlist(bm_ctx_t *ctx)
 {
     if (ctx == NULL || ctx->settings->posts == NULL || ctx->settings->tags == NULL)
@@ -348,23 +349,23 @@ pagination_tags_outputlist(bm_ctx_t *ctx)
     if (!posts_pagination_enabled(ctx, "posts_per_page"))
         return NULL;
 
-    bc_trie_t *variables = bc_trie_new(free);
+    sb_trie_t *variables = sb_trie_new(free);
     posts_pagination(ctx, variables, "posts_per_page");
 
     const char *tag_prefix = bm_ctx_settings_lookup(ctx, "tag_prefix");
     const char *pagination_prefix = bm_ctx_settings_lookup(ctx, "pagination_prefix");
     const char *html_ext = bm_ctx_settings_lookup(ctx, "html_ext");
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
 
     for (size_t k = 0; ctx->settings->tags[k] != NULL; k++) {
-        bc_trie_t *local = bc_trie_new(free);
-        bc_trie_insert(local, "FILTER_TAG", bc_strdup(ctx->settings->tags[k]));
+        sb_trie_t *local = sb_trie_new(free);
+        sb_trie_insert(local, "FILTER_TAG", sb_strdup(ctx->settings->tags[k]));
 
         char *last_page = bm_exec_blogc_get_variable(ctx, variables, local,
             "LAST_PAGE", true, ctx->posts_fctx, false);
 
-        bc_trie_free(local);
+        sb_trie_free(local);
 
         if (last_page == NULL)
             continue;
@@ -373,22 +374,22 @@ pagination_tags_outputlist(bm_ctx_t *ctx)
         free(last_page);
 
         for (size_t i = 0; i < pages; i++) {
-            char *j = bc_strdup_printf("%d", i + 1);
+            char *j = sb_strdup_printf("%d", i + 1);
             char *f = bm_generate_filename2(ctx->short_output_dir, tag_prefix,
                 ctx->settings->tags[k], pagination_prefix, j, html_ext);
-            rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+            rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
             free(j);
             free(f);
         }
     }
 
-    bc_trie_free(variables);
+    sb_trie_free(variables);
 
     return rv;
 }
 
 static int
-pagination_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+pagination_tags_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     if (ctx == NULL || ctx->settings->posts == NULL || ctx->settings->tags == NULL)
         return 0;
@@ -396,22 +397,22 @@ pagination_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
     int rv = 0;
     size_t page = 1;
 
-    bc_trie_t *variables = bc_trie_new(free);
+    sb_trie_t *variables = sb_trie_new(free);
     // not using posts_pagination because we set FILTER_PAGE anyway, and the
     // first value inserted in that function would be useless
-    bc_trie_insert(variables, "FILTER_PER_PAGE",
-        bc_strdup(bm_ctx_settings_lookup_str(ctx, "posts_per_page")));
+    sb_trie_insert(variables, "FILTER_PER_PAGE",
+        sb_strdup(bm_ctx_settings_lookup_str(ctx, "posts_per_page")));
     posts_ordering(ctx, variables, "html_order");
-    bc_trie_insert(variables, "DATE_FORMAT",
-        bc_strdup(bm_ctx_settings_lookup_str(ctx, "date_format")));
-    bc_trie_insert(variables, "MAKE_RULE", bc_strdup("pagination_tags"));
-    bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("post"));
+    sb_trie_insert(variables, "DATE_FORMAT",
+        sb_strdup(bm_ctx_settings_lookup_str(ctx, "date_format")));
+    sb_trie_insert(variables, "MAKE_RULE", sb_strdup("pagination_tags"));
+    sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("post"));
 
     const char *tag_prefix = bm_ctx_settings_lookup(ctx, "tag_prefix");
     const char *pagination_prefix = bm_ctx_settings_lookup(ctx, "pagination_prefix");
     const char *html_ext = bm_ctx_settings_lookup(ctx, "html_ext");
 
-    for (bc_slist_t *l = outputs; l != NULL; l = l->next) {
+    for (sb_slist_t *l = outputs; l != NULL; l = l->next) {
         bm_filectx_t *fctx = l->data;
         if (fctx == NULL)
             continue;
@@ -424,8 +425,8 @@ pagination_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 
             // it is impossible to have more output files per tag than the whole
             // amount of output pages
-            for (size_t k = 1; k <= bc_slist_length(outputs); k++) {
-                char *j = bc_strdup_printf("%d", k);
+            for (size_t k = 1; k <= sb_slist_length(outputs); k++) {
+                char *j = sb_strdup_printf("%d", k);
                 char *f = bm_generate_filename2(ctx->short_output_dir, tag_prefix,
                     ctx->settings->tags[i], pagination_prefix, j, html_ext);
                 free(j);
@@ -444,8 +445,8 @@ pagination_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
         if (tag == NULL)
             continue;
 
-        bc_trie_insert(variables, "FILTER_TAG", bc_strdup(tag));
-        bc_trie_insert(variables, "FILTER_PAGE", bc_strdup_printf("%zu", page));
+        sb_trie_insert(variables, "FILTER_TAG", sb_strdup(tag));
+        sb_trie_insert(variables, "FILTER_PAGE", sb_strdup_printf("%zu", page));
 
         if (bm_rule_need_rebuild(ctx->posts_fctx, ctx->settings_fctx,
                 ctx->listing_entry_fctx, ctx->main_template_fctx, fctx, false))
@@ -457,7 +458,7 @@ pagination_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
         }
     }
 
-    bc_trie_free(variables);
+    sb_trie_free(variables);
 
     return rv;
 }
@@ -465,13 +466,13 @@ pagination_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 
 // POSTS RULE
 
-static bc_slist_t*
+static sb_slist_t*
 posts_outputlist(bm_ctx_t *ctx)
 {
     if (ctx == NULL || ctx->settings->posts == NULL)
         return NULL;
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
 
     const char *post_prefix = bm_ctx_settings_lookup(ctx, "post_prefix");
     const char *html_ext = bm_ctx_settings_lookup(ctx, "html_ext");
@@ -479,7 +480,7 @@ posts_outputlist(bm_ctx_t *ctx)
     for (size_t i = 0; ctx->settings->posts[i] != NULL; i++) {
         char *f = bm_generate_filename(ctx->short_output_dir, post_prefix,
             ctx->settings->posts[i], html_ext);
-        rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+        rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
         free(f);
     }
 
@@ -487,22 +488,22 @@ posts_outputlist(bm_ctx_t *ctx)
 }
 
 static int
-posts_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+posts_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     if (ctx == NULL || ctx->settings->posts == NULL)
         return 0;
 
     int rv = 0;
 
-    bc_trie_t *variables = bc_trie_new(free);
-    bc_trie_insert(variables, "IS_POST", bc_strdup("1"));
-    bc_trie_insert(variables, "DATE_FORMAT",
-        bc_strdup(bm_ctx_settings_lookup(ctx, "date_format")));
+    sb_trie_t *variables = sb_trie_new(free);
+    sb_trie_insert(variables, "IS_POST", sb_strdup("1"));
+    sb_trie_insert(variables, "DATE_FORMAT",
+        sb_strdup(bm_ctx_settings_lookup(ctx, "date_format")));
     posts_ordering(ctx, variables, "html_order");
-    bc_trie_insert(variables, "MAKE_RULE", bc_strdup("posts"));
-    bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("post"));
+    sb_trie_insert(variables, "MAKE_RULE", sb_strdup("posts"));
+    sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("post"));
 
-    bc_slist_t *s, *o;
+    sb_slist_t *s, *o;
 
     for (s = ctx->posts_fctx, o = outputs; s != NULL && o != NULL;
             s = s->next, o = o->next)
@@ -514,17 +515,17 @@ posts_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
         if (bm_rule_need_rebuild(s, ctx->settings_fctx, NULL,
                 ctx->main_template_fctx, o_fctx, true))
         {
-            bc_trie_t *local = bc_trie_new(NULL);
-            bc_trie_insert(local, "MAKE_SLUG", s_fctx->slug);  // no need to copy
+            sb_trie_t *local = sb_trie_new(NULL);
+            sb_trie_insert(local, "MAKE_SLUG", s_fctx->slug);  // no need to copy
             rv = bm_exec_blogc(ctx, variables, local, false, NULL, ctx->main_template_fctx,
                 o_fctx, s, true);
-            bc_trie_free(local);
+            sb_trie_free(local);
             if (rv != 0)
                 break;
         }
     }
 
-    bc_trie_free(variables);
+    sb_trie_free(variables);
 
     return rv;
 }
@@ -532,7 +533,7 @@ posts_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 
 // TAGS RULE
 
-static bc_slist_t*
+static sb_slist_t*
 tags_outputlist(bm_ctx_t *ctx)
 {
     if (ctx == NULL || ctx->settings->posts == NULL || ctx->settings->tags == NULL)
@@ -541,7 +542,7 @@ tags_outputlist(bm_ctx_t *ctx)
     if (!posts_pagination_enabled(ctx, "posts_per_page"))
         return NULL;
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
 
     const char *tag_prefix = bm_ctx_settings_lookup(ctx, "tag_prefix");
     const char *html_ext = bm_ctx_settings_lookup(ctx, "html_ext");
@@ -549,7 +550,7 @@ tags_outputlist(bm_ctx_t *ctx)
     for (size_t i = 0; ctx->settings->tags[i] != NULL; i++) {
         char *f = bm_generate_filename(ctx->short_output_dir, tag_prefix,
             ctx->settings->tags[i], html_ext);
-        rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+        rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
         free(f);
     }
 
@@ -557,7 +558,7 @@ tags_outputlist(bm_ctx_t *ctx)
 }
 
 static int
-tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+tags_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     if (ctx == NULL || ctx->settings->posts == NULL || ctx->settings->tags == NULL)
         return 0;
@@ -565,21 +566,21 @@ tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
     int rv = 0;
     size_t i = 0;
 
-    bc_trie_t *variables = bc_trie_new(free);
+    sb_trie_t *variables = sb_trie_new(free);
     posts_pagination(ctx, variables, "posts_per_page");
     posts_ordering(ctx, variables, "html_order");
-    bc_trie_insert(variables, "DATE_FORMAT",
-        bc_strdup(bm_ctx_settings_lookup_str(ctx, "date_format")));
-    bc_trie_insert(variables, "MAKE_RULE", bc_strdup("tags"));
-    bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("post"));
+    sb_trie_insert(variables, "DATE_FORMAT",
+        sb_strdup(bm_ctx_settings_lookup_str(ctx, "date_format")));
+    sb_trie_insert(variables, "MAKE_RULE", sb_strdup("tags"));
+    sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("post"));
 
-    for (bc_slist_t *l = outputs; l != NULL; l = l->next, i++) {
+    for (sb_slist_t *l = outputs; l != NULL; l = l->next, i++) {
         bm_filectx_t *fctx = l->data;
         if (fctx == NULL)
             continue;
 
-        bc_trie_insert(variables, "FILTER_TAG",
-            bc_strdup(ctx->settings->tags[i]));
+        sb_trie_insert(variables, "FILTER_TAG",
+            sb_strdup(ctx->settings->tags[i]));
 
         if (bm_rule_need_rebuild(ctx->posts_fctx, ctx->settings_fctx,
                 ctx->listing_entry_fctx, ctx->main_template_fctx, fctx, false))
@@ -591,7 +592,7 @@ tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
         }
     }
 
-    bc_trie_free(variables);
+    sb_trie_free(variables);
 
     return rv;
 }
@@ -599,20 +600,20 @@ tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 
 // PAGES RULE
 
-static bc_slist_t*
+static sb_slist_t*
 pages_outputlist(bm_ctx_t *ctx)
 {
     if (ctx == NULL || ctx->settings->pages == NULL)
         return NULL;
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
 
     const char *html_ext = bm_ctx_settings_lookup(ctx, "html_ext");
 
     for (size_t i = 0; ctx->settings->pages[i] != NULL; i++) {
         char *f = bm_generate_filename(ctx->short_output_dir, NULL,
             ctx->settings->pages[i], html_ext);
-        rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+        rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
         free(f);
     }
 
@@ -620,20 +621,20 @@ pages_outputlist(bm_ctx_t *ctx)
 }
 
 static int
-pages_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+pages_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     if (ctx == NULL || ctx->settings->pages == NULL)
         return 0;
 
     int rv = 0;
 
-    bc_trie_t *variables = bc_trie_new(free);
-    bc_trie_insert(variables, "DATE_FORMAT",
-        bc_strdup(bm_ctx_settings_lookup(ctx, "date_format")));
-    bc_trie_insert(variables, "MAKE_RULE", bc_strdup("pages"));
-    bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("page"));
+    sb_trie_t *variables = sb_trie_new(free);
+    sb_trie_insert(variables, "DATE_FORMAT",
+        sb_strdup(bm_ctx_settings_lookup(ctx, "date_format")));
+    sb_trie_insert(variables, "MAKE_RULE", sb_strdup("pages"));
+    sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("page"));
 
-    bc_slist_t *s, *o;
+    sb_slist_t *s, *o;
 
     for (s = ctx->pages_fctx, o = outputs; s != NULL && o != NULL;
             s = s->next, o = o->next)
@@ -645,17 +646,17 @@ pages_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
         if (bm_rule_need_rebuild(s, ctx->settings_fctx, NULL,
                 ctx->main_template_fctx, o_fctx, true))
         {
-            bc_trie_t *local = bc_trie_new(NULL);
-            bc_trie_insert(local, "MAKE_SLUG", s_fctx->slug); // no need to copy
+            sb_trie_t *local = sb_trie_new(NULL);
+            sb_trie_insert(local, "MAKE_SLUG", s_fctx->slug); // no need to copy
             rv = bm_exec_blogc(ctx, variables, local, false, NULL, ctx->main_template_fctx,
                 o_fctx, s, true);
-            bc_trie_free(local);
+            sb_trie_free(local);
             if (rv != 0)
                 break;
         }
     }
 
-    bc_trie_free(variables);
+    sb_trie_free(variables);
 
     return rv;
 }
@@ -663,20 +664,20 @@ pages_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 
 // COPY FILES RULE
 
-static bc_slist_t*
+static sb_slist_t*
 copy_outputlist(bm_ctx_t *ctx)
 {
     if (ctx == NULL || ctx->settings->copy == NULL)
         return NULL;
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
 
     // we iterate over ctx->copy_fctx list instead of ctx->settings->copy,
     // because bm_ctx_new() expands directories into its files, recursively.
-    for (bc_slist_t *s = ctx->copy_fctx; s != NULL; s = s->next) {
-        char *f = bc_strdup_printf("%s/%s", ctx->short_output_dir,
+    for (sb_slist_t *s = ctx->copy_fctx; s != NULL; s = s->next) {
+        char *f = sb_strdup_printf("%s/%s", ctx->short_output_dir,
             ((bm_filectx_t*) s->data)->short_path);
-        rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+        rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
         free(f);
     }
 
@@ -684,14 +685,14 @@ copy_outputlist(bm_ctx_t *ctx)
 }
 
 static int
-copy_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+copy_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     if (ctx == NULL || ctx->settings->copy == NULL)
         return 0;
 
     int rv = 0;
 
-    bc_slist_t *s, *o;
+    sb_slist_t *s, *o;
 
     for (s = ctx->copy_fctx, o = outputs; s != NULL && o != NULL;
             s = s->next, o = o->next)
@@ -713,18 +714,18 @@ copy_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 
 // CLEAN RULE
 
-static bc_slist_t*
+static sb_slist_t*
 clean_outputlist(bm_ctx_t *ctx)
 {
     return bm_rule_list_built_files(ctx);
 }
 
 static int
-clean_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+clean_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     int rv = 0;
 
-    for (bc_slist_t *l = outputs; l != NULL; l = l->next) {
+    for (sb_slist_t *l = outputs; l != NULL; l = l->next) {
         bm_filectx_t *fctx = l->data;
         if (fctx == NULL)
             continue;
@@ -744,13 +745,13 @@ clean_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 }
 
 
-static int all_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args);
+static int all_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args);
 
 
 // RUNSERVER RULE
 
 static int
-runserver_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+runserver_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     return bm_httpd_run(&ctx, all_exec, outputs, args);
 }
@@ -759,7 +760,7 @@ runserver_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 // WATCH RULE
 
 static int
-watch_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+watch_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     return bm_reloader_run(&ctx, all_exec, outputs, args);
 }
@@ -768,7 +769,7 @@ watch_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 // ATOM DUMP RULE
 
 static int
-atom_dump_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+atom_dump_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     char *content = bm_atom_generate(ctx->settings);
     if (content == NULL)
@@ -887,7 +888,7 @@ const bm_rule_t rules[] = {
 // ALL RULE
 
 static int
-all_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+all_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
 {
     for (size_t i = 0; rules[i].name != NULL; i++) {
         if (!rules[i].generate_files) {
@@ -904,30 +905,30 @@ all_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
 }
 
 
-bc_trie_t*
+sb_trie_t*
 bm_rule_parse_args(const char *sep)
 {
     if (sep == NULL || *sep == '\0' || *sep != ':')
         return NULL;
 
-    bc_trie_t *rv = bc_trie_new(free);
+    sb_trie_t *rv = sb_trie_new(free);
     char *end = (char*) sep + 1;
     char *kv_sep;
     while (NULL != (kv_sep = strchr(end, '='))) {
-        char *key = bc_strndup(end, kv_sep - end);
+        char *key = sb_strndup(end, kv_sep - end);
         end = kv_sep + 1;
         kv_sep = strchr(end, ',');
         if (kv_sep == NULL)
             kv_sep = strchr(end, '\0');
-        char *value = bc_strndup(end, kv_sep - end);
-        bc_trie_insert(rv, key, value);
+        char *value = sb_strndup(end, kv_sep - end);
+        sb_trie_insert(rv, key, value);
         free(key);
         if (*kv_sep == '\0')
             break;
         end = kv_sep + 1;
     }
     if (kv_sep == NULL) {
-        bc_trie_free(rv);
+        sb_trie_free(rv);
         return NULL;
     }
 
@@ -936,7 +937,7 @@ bm_rule_parse_args(const char *sep)
 
 
 int
-bm_rule_executor(bm_ctx_t *ctx, bc_slist_t *rule_list)
+bm_rule_executor(bm_ctx_t *ctx, sb_slist_t *rule_list)
 {
     if (ctx == NULL)
         return 1;
@@ -944,12 +945,12 @@ bm_rule_executor(bm_ctx_t *ctx, bc_slist_t *rule_list)
     const bm_rule_t *rule = NULL;
     int rv = 0;
 
-    for (bc_slist_t *l = rule_list; l != NULL; l = l->next) {
+    for (sb_slist_t *l = rule_list; l != NULL; l = l->next) {
 
         char *rule_str = l->data;
         char *sep = strchr(rule_str, ':');
 
-        bc_trie_t *args = NULL;
+        sb_trie_t *args = NULL;
         if (sep == NULL) {
             sep = strchr(rule_str, '\0');
         }
@@ -985,26 +986,26 @@ bm_rule_executor(bm_ctx_t *ctx, bc_slist_t *rule_list)
 
 
 int
-bm_rule_execute(bm_ctx_t *ctx, const bm_rule_t *rule, bc_trie_t *args)
+bm_rule_execute(bm_ctx_t *ctx, const bm_rule_t *rule, sb_trie_t *args)
 {
     if (ctx == NULL || rule == NULL)
         return 1;
 
-    bc_slist_t *outputs = NULL;
+    sb_slist_t *outputs = NULL;
     if (rule->outputlist_func != NULL) {
         outputs = rule->outputlist_func(ctx);
     }
 
     int rv = rule->exec_func(ctx, outputs, args);
 
-    bc_slist_free_full(outputs, (bc_free_func_t) bm_filectx_free);
+    sb_slist_free_full(outputs, (sb_free_func_t) bm_filectx_free);
 
     return rv;
 }
 
 
 bool
-bm_rule_need_rebuild(bc_slist_t *sources, bm_filectx_t *settings,
+bm_rule_need_rebuild(sb_slist_t *sources, bm_filectx_t *settings,
     bm_filectx_t *listing_entry, bm_filectx_t *template, bm_filectx_t *output,
     bool only_first_source)
 {
@@ -1013,21 +1014,21 @@ bm_rule_need_rebuild(bc_slist_t *sources, bm_filectx_t *settings,
 
     bool rv = false;
 
-    bc_slist_t *s = NULL;
+    sb_slist_t *s = NULL;
     if (settings != NULL)
-        s = bc_slist_append(s, settings);
+        s = sb_slist_append(s, settings);
     if (template != NULL)
-        s = bc_slist_append(s, template);
+        s = sb_slist_append(s, template);
     if (listing_entry != NULL)
-        s = bc_slist_append(s, listing_entry);
+        s = sb_slist_append(s, listing_entry);
 
-    for (bc_slist_t *l = sources; l != NULL; l = l->next) {
-        s = bc_slist_append(s, l->data);
+    for (sb_slist_t *l = sources; l != NULL; l = l->next) {
+        s = sb_slist_append(s, l->data);
         if (only_first_source)
             break;
     }
 
-    for (bc_slist_t *l = s; l != NULL; l = l->next) {
+    for (sb_slist_t *l = s; l != NULL; l = l->next) {
         bm_filectx_t *source = l->data;
         if (source == NULL || !source->readable) {
             // this is unlikely to happen, but lets just say that we need
@@ -1047,29 +1048,29 @@ bm_rule_need_rebuild(bc_slist_t *sources, bm_filectx_t *settings,
         }
     }
 
-    bc_slist_free(s);
+    sb_slist_free(s);
 
     return rv;
 }
 
 
-bc_slist_t*
+sb_slist_t*
 bm_rule_list_built_files(bm_ctx_t *ctx)
 {
     if (ctx == NULL)
         return NULL;
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
     for (size_t i = 0; rules[i].name != NULL; i++) {
         if (!rules[i].generate_files) {
             continue;
         }
 
-        bc_slist_t *o = rules[i].outputlist_func(ctx);
-        for (bc_slist_t *l = o; l != NULL; l = l->next) {
-            rv = bc_slist_append(rv, l->data);
+        sb_slist_t *o = rules[i].outputlist_func(ctx);
+        for (sb_slist_t *l = o; l != NULL; l = l->next) {
+            rv = sb_slist_append(rv, l->data);
         }
-        bc_slist_free(o);
+        sb_slist_free(o);
     }
 
     return rv;
diff --git a/src/blogc-make/rules.h b/src/blogc-make/rules.h
index 29ba27e..d532084 100644
--- a/src/blogc-make/rules.h
+++ b/src/blogc-make/rules.h
@@ -10,12 +10,13 @@
 #define _MAKE_RULES_H
 
 #include <stdbool.h>
+#include <squareball.h>
+
 #include "ctx.h"
-#include "../common/utils.h"
 
-typedef bc_slist_t* (*bm_rule_outputlist_func_t) (bm_ctx_t *ctx);
-typedef int (*bm_rule_exec_func_t) (bm_ctx_t *ctx, bc_slist_t *outputs,
-    bc_trie_t *args);
+typedef sb_slist_t* (*bm_rule_outputlist_func_t) (bm_ctx_t *ctx);
+typedef int (*bm_rule_exec_func_t) (bm_ctx_t *ctx, sb_slist_t *outputs,
+    sb_trie_t *args);
 
 typedef struct {
     const char *name;
@@ -25,13 +26,13 @@ typedef struct {
     bool generate_files;
 } bm_rule_t;
 
-bc_trie_t* bm_rule_parse_args(const char *sep);
-int bm_rule_executor(bm_ctx_t *ctx, bc_slist_t *rule_list);
-int bm_rule_execute(bm_ctx_t *ctx, const bm_rule_t *rule, bc_trie_t *args);
-bool bm_rule_need_rebuild(bc_slist_t *sources, bm_filectx_t *settings,
+sb_trie_t* bm_rule_parse_args(const char *sep);
+int bm_rule_executor(bm_ctx_t *ctx, sb_slist_t *rule_list);
+int bm_rule_execute(bm_ctx_t *ctx, const bm_rule_t *rule, sb_trie_t *args);
+bool bm_rule_need_rebuild(sb_slist_t *sources, bm_filectx_t *settings,
     bm_filectx_t *listing_entry, bm_filectx_t *template, bm_filectx_t *output,
     bool only_first_source);
-bc_slist_t* bm_rule_list_built_files(bm_ctx_t *ctx);
+sb_slist_t* bm_rule_list_built_files(bm_ctx_t *ctx);
 void bm_rule_print_help(void);
 
 #endif /* _MAKE_RULES_H */
diff --git a/src/blogc-make/settings.c b/src/blogc-make/settings.c
index be976e3..796f1b4 100644
--- a/src/blogc-make/settings.c
+++ b/src/blogc-make/settings.c
@@ -9,10 +9,8 @@
 #include <libgen.h>
 #include <stdbool.h>
 #include <stdlib.h>
-#include "../common/config-parser.h"
-#include "../common/error.h"
-#include "../common/file.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
 #include "settings.h"
 
 
@@ -77,7 +75,7 @@ static const char* list_sections[] = {
 
 
 bm_settings_t*
-bm_settings_parse(const char *content, size_t content_len, bc_error_t **err)
+bm_settings_parse(const char *content, size_t content_len, sb_error_t **err)
 {
     if (err == NULL || *err != NULL)
         return NULL;
@@ -85,14 +83,14 @@ bm_settings_parse(const char *content, size_t content_len, bc_error_t **err)
     if (content == NULL)
         return NULL;
 
-    bc_config_t *config = bc_config_parse(content, content_len, list_sections,
+    sb_config_t *config = sb_config_parse(content, content_len, list_sections,
         err);
     if (config == NULL || (err != NULL && *err != NULL))
         return NULL;
 
-    bm_settings_t *rv = bc_malloc(sizeof(bm_settings_t));
-    rv->global = bc_trie_new(free);
-    rv->settings = bc_trie_new(free);
+    bm_settings_t *rv = sb_malloc(sizeof(bm_settings_t));
+    rv->global = sb_trie_new(free);
+    rv->settings = sb_trie_new(free);
     rv->posts = NULL;
     rv->pages = NULL;
     rv->copy = NULL;
@@ -102,12 +100,12 @@ bm_settings_parse(const char *content, size_t content_len, bc_error_t **err)
     // even if I never released a version with it, but some people is using
     // it already.
     const char *section = NULL;
-    char **global = bc_config_list_keys(config, "global");
+    char **global = sb_config_list_keys(config, "global");
     if (global != NULL) {
         section = "global";
     }
     else {
-        global = bc_config_list_keys(config, "environment");
+        global = sb_config_list_keys(config, "environment");
         if (global != NULL) {
             section = "environment";
         }
@@ -120,25 +118,25 @@ bm_settings_parse(const char *content, size_t content_len, bc_error_t **err)
         for (size_t i = 0; global[i] != NULL; i++) {
             for (size_t j = 0; global[i][j] != '\0'; j++) {
                 if (!((global[i][j] >= 'A' && global[i][j] <= 'Z') || global[i][j] == '_')) {
-                    *err = bc_error_new_printf(BLOGC_MAKE_ERROR_SETTINGS,
-                        "Invalid [%s] key: %s", section, global[i]);
-                    bc_strv_free(global);
+                    *err = sb_strerror_new_printf(
+                        "settings: Invalid [%s] key: %s", section, global[i]);
+                    sb_strv_free(global);
                     bm_settings_free(rv);
                     rv = NULL;
                     goto cleanup;
                 }
             }
-            bc_trie_insert(rv->global, global[i],
-                bc_strdup(bc_config_get(config, section, global[i])));
+            sb_trie_insert(rv->global, global[i],
+                sb_strdup(sb_config_get(config, section, global[i])));
         }
     }
-    bc_strv_free(global);
+    sb_strv_free(global);
 
     for (size_t i = 0; required_global[i] != NULL; i++) {
-        const char *value = bc_trie_lookup(rv->global, required_global[i]);
+        const char *value = sb_trie_lookup(rv->global, required_global[i]);
         if (value == NULL || value[0] == '\0') {
-            *err = bc_error_new_printf(BLOGC_MAKE_ERROR_SETTINGS,
-                "[%s] key required but not found or empty: %s", section,
+            *err = sb_strerror_new_printf(
+                "settings: [%s] key required but not found or empty: %s", section,
                 required_global[i]);
             bm_settings_free(rv);
             rv = NULL;
@@ -147,27 +145,27 @@ bm_settings_parse(const char *content, size_t content_len, bc_error_t **err)
     }
 
     for (size_t i = 0; default_settings[i].key != NULL; i++) {
-        const char *value = bc_config_get_with_default(
+        const char *value = sb_config_get_with_default(
             config, "settings", default_settings[i].key,
             default_settings[i].default_value);
         if (value != NULL) {
-            bc_trie_insert(rv->settings, default_settings[i].key,
-                bc_strdup(value));
+            sb_trie_insert(rv->settings, default_settings[i].key,
+                sb_strdup(value));
         }
     }
 
-    rv->posts = bc_config_get_list(config, "posts");
-    rv->pages = bc_config_get_list(config, "pages");
-    rv->tags = bc_config_get_list(config, "tags");
+    rv->posts = sb_config_get_list(config, "posts");
+    rv->pages = sb_config_get_list(config, "pages");
+    rv->tags = sb_config_get_list(config, "tags");
 
     // this is for backward compatibility too.
-    rv->copy = bc_config_get_list(config, "copy");
+    rv->copy = sb_config_get_list(config, "copy");
     if (rv->copy == NULL)
-        rv->copy = bc_config_get_list(config, "copy_files");
+        rv->copy = sb_config_get_list(config, "copy_files");
 
 cleanup:
 
-    bc_config_free(config);
+    sb_config_free(config);
 
     return rv;
 }
@@ -178,11 +176,11 @@ bm_settings_free(bm_settings_t *settings)
 {
     if (settings == NULL)
         return;
-    bc_trie_free(settings->global);
-    bc_trie_free(settings->settings);
-    bc_strv_free(settings->posts);
-    bc_strv_free(settings->pages);
-    bc_strv_free(settings->copy);
-    bc_strv_free(settings->tags);
+    sb_trie_free(settings->global);
+    sb_trie_free(settings->settings);
+    sb_strv_free(settings->posts);
+    sb_strv_free(settings->pages);
+    sb_strv_free(settings->copy);
+    sb_strv_free(settings->tags);
     free(settings);
 }
diff --git a/src/blogc-make/settings.h b/src/blogc-make/settings.h
index 69fdbb6..a147df6 100644
--- a/src/blogc-make/settings.h
+++ b/src/blogc-make/settings.h
@@ -10,12 +10,11 @@
 #define _MAKE_SETTINGS_H
 
 #include <stddef.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
 
 typedef struct {
-    bc_trie_t *global;
-    bc_trie_t *settings;
+    sb_trie_t *global;
+    sb_trie_t *settings;
     char **posts;
     char **pages;
     char **copy;
@@ -23,7 +22,7 @@ typedef struct {
 } bm_settings_t;
 
 bm_settings_t* bm_settings_parse(const char *content, size_t content_len,
-    bc_error_t **err);
+    sb_error_t **err);
 void bm_settings_free(bm_settings_t *settings);
 
 #endif /* _MAKE_SETTINGS_H */
diff --git a/src/blogc-make/utils.c b/src/blogc-make/utils.c
index 8f69e44..f2bd777 100644
--- a/src/blogc-make/utils.c
+++ b/src/blogc-make/utils.c
@@ -11,8 +11,9 @@
 #include <stdbool.h>
 #include <string.h>
 #include <unistd.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
+#include "utils.h"
 
 #ifndef PATH_MAX
 #define PATH_MAX 4096
@@ -30,42 +31,42 @@ bm_generate_filename(const char *dir, const char *prefix, const char *fname,
     bool is_index = have_fname && have_ext && (
         (0 == strcmp(fname, "index")) && ext[0] == '/') && !have_prefix;
 
-    bc_string_t *rv = bc_string_new();
+    sb_string_t *rv = sb_string_new();
 
     if (dir != NULL && (have_prefix || have_fname || have_ext))
-        bc_string_append(rv, dir);
+        sb_string_append(rv, dir);
 
     if ((have_prefix || have_fname || have_ext_noslash) && !is_index)
-        bc_string_append_c(rv, '/');
+        sb_string_append_c(rv, '/');
 
     if (have_prefix)
-        bc_string_append(rv, prefix);
+        sb_string_append(rv, prefix);
 
     // with fname we have posts, pages and tags
     if (have_fname) {
         if (have_prefix && have_fname && fname[0] != '/')
-            bc_string_append_c(rv, '/');
+            sb_string_append_c(rv, '/');
         if (!is_index)
-            bc_string_append(rv, fname);
+            sb_string_append(rv, fname);
     }
 
     // no fname means index
     else if (have_ext_noslash) {
         if (have_fname)
-            bc_string_append_c(rv, '/');
+            sb_string_append_c(rv, '/');
         if (!have_prefix)
-            bc_string_append(rv, "index");
+            sb_string_append(rv, "index");
     }
 
     if (have_ext)
-        bc_string_append(rv, ext);
+        sb_string_append(rv, ext);
 
     if (rv->len == 0) {
-        bc_string_free(rv, true);
+        sb_string_free(rv, true);
         return NULL;
     }
 
-    return bc_string_free(rv, false);
+    return sb_string_free(rv, false);
 }
 
 
@@ -77,52 +78,52 @@ bm_generate_filename2(const char *dir, const char *prefix, const char *fname,
     bool have_fname = fname != NULL && fname[0] != '\0';
     bool have_prefix2 = prefix2 != NULL && prefix2[0] != '\0';
 
-    bc_string_t *p = bc_string_new();
+    sb_string_t *p = sb_string_new();
 
     if (have_prefix)
-        bc_string_append(p, prefix);
+        sb_string_append(p, prefix);
 
     if (have_prefix && (have_fname || have_prefix2))
-        bc_string_append_c(p, '/');
+        sb_string_append_c(p, '/');
 
     if (have_fname)
-        bc_string_append(p, fname);
+        sb_string_append(p, fname);
 
     if (have_fname && have_prefix2)
-        bc_string_append_c(p, '/');
+        sb_string_append_c(p, '/');
 
     if (have_prefix2)
-        bc_string_append(p, prefix2);
+        sb_string_append(p, prefix2);
 
     char *rv = bm_generate_filename(dir, p->str, fname2, ext);
-    bc_string_free(p, true);
+    sb_string_free(p, true);
 
     return rv;
 }
 
 
 char*
-bm_abspath(const char *path, bc_error_t **err)
+bm_abspath(const char *path, sb_error_t **err)
 {
     if (err == NULL || *err != NULL)
         return NULL;
 
     if (path[0] == '/') {
-        return bc_strdup(path);
+        return sb_strdup(path);
     }
 
     char cwd[PATH_MAX];
     if (NULL == getcwd(cwd, sizeof(cwd))) {
-        *err = bc_error_new_printf(BLOGC_MAKE_ERROR_UTILS,
-            "Failed to detect absolute path (%s): %s", path, strerror(errno));
+        *err = sb_strerror_new_printf(
+            "utils: Failed to detect absolute path (%s): %s", path, strerror(errno));
         return NULL;
     }
 
     if (cwd[0] != '/') {
-        *err = bc_error_new_printf(BLOGC_MAKE_ERROR_UTILS,
-            "Failed to get current working directory: %s", cwd);
+        *err = sb_strerror_new_printf(
+            "utils: Failed to get current working directory: %s", cwd);
         return NULL;
     }
 
-    return bc_strdup_printf("%s/%s", cwd, path);
+    return sb_strdup_printf("%s/%s", cwd, path);
 }
diff --git a/src/blogc-make/utils.h b/src/blogc-make/utils.h
index cbcfc0e..f17d6fe 100644
--- a/src/blogc-make/utils.h
+++ b/src/blogc-make/utils.h
@@ -9,12 +9,12 @@
 #ifndef _MAKE_UTILS_H
 #define _MAKE_UTILS_H
 
-#include "../common/error.h"
+#include <squareball.h>
 
 char* bm_generate_filename(const char *dir, const char *prefix, const char *fname,
     const char *ext);
 char* bm_generate_filename2(const char *dir, const char *prefix, const char *fname,
     const char *prefix2, const char *fname2, const char *ext);
-char* bm_abspath(const char *path, bc_error_t **err);
+char* bm_abspath(const char *path, sb_error_t **err);
 
 #endif /* _MAKE_UTILS_H */