*: use squareball

yeah, changed my mind again :)

16 files changed, 504 insertions, 447 deletions

diff --git a/src/blogc/content-parser.c b/src/blogc/content-parser.c
index 106e3c8..680c5f7 100644
--- a/src/blogc/content-parser.c
+++ b/src/blogc/content-parser.c
@@ -9,9 +9,9 @@
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
+#include <squareball.h>
 
 #include "content-parser.h"
-#include "../common/utils.h"
 
 // this is a half ass implementation of a markdown-like syntax. bugs are
 // expected. feel free to improve the parser and add new features.
@@ -22,7 +22,7 @@ blogc_slugify(const char *str)
 {
     if (str == NULL)
         return NULL;
-    char *new_str = bc_strdup(str);
+    char *new_str = sb_strdup(str);
     int diff = 'a' - 'A';  // just to avoid magic numbers
     for (size_t i = 0; new_str[i] != '\0'; i++) {
         if (new_str[i] >= 'a' && new_str[i] <= 'z')
@@ -60,13 +60,13 @@ htmlentities(char c)
 
 
 static void
-htmlentities_append(bc_string_t *str, char c)
+htmlentities_append(sb_string_t *str, char c)
 {
     const char *e = htmlentities(c);
     if (e == NULL)
-        bc_string_append_c(str, c);
+        sb_string_append_c(str, c);
     else
-        bc_string_append(str, e);
+        sb_string_append(str, e);
 }
 
 
@@ -75,10 +75,10 @@ blogc_htmlentities(const char *str)
 {
     if (str == NULL)
         return NULL;
-    bc_string_t *rv = bc_string_new();
+    sb_string_t *rv = sb_string_new();
     for (size_t i = 0; str[i] != '\0'; i++)
         htmlentities_append(rv, str[i]);
-    return bc_string_free(rv, false);
+    return sb_string_free(rv, false);
 }
 
 
@@ -87,7 +87,7 @@ blogc_fix_description(const char *paragraph)
 {
     if (paragraph == NULL)
         return NULL;
-    bc_string_t *rv = bc_string_new();
+    sb_string_t *rv = sb_string_new();
     bool last = false;
     bool newline = false;
     char *tmp = NULL;
@@ -101,12 +101,12 @@ blogc_fix_description(const char *paragraph)
             case '\n':
                 if (newline)
                     break;
-                tmp = bc_strndup(paragraph + start, current - start);
-                bc_string_append(rv, bc_str_strip(tmp));
+                tmp = sb_strndup(paragraph + start, current - start);
+                sb_string_append(rv, sb_str_strip(tmp));
                 free(tmp);
                 tmp = NULL;
                 if (!last)
-                    bc_string_append_c(rv, ' ');
+                    sb_string_append_c(rv, ' ');
                 start = current + 1;
                 newline = true;
                 break;
@@ -117,8 +117,8 @@ blogc_fix_description(const char *paragraph)
             break;
         current++;
     }
-    tmp = blogc_htmlentities(bc_str_strip(rv->str));
-    bc_string_free(rv, true);
+    tmp = blogc_htmlentities(sb_str_strip(rv->str));
+    sb_string_free(rv, true);
     return tmp;
 }
 
@@ -190,7 +190,7 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
     size_t start_link = 0;
     char *link1 = NULL;
 
-    bc_string_t *rv = bc_string_new();
+    sb_string_t *rv = sb_string_new();
 
     blogc_content_parser_inline_state_t state = CONTENT_INLINE_START;
 
@@ -244,15 +244,15 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     state = CONTENT_INLINE_ASTERISK_DOUBLE;
                     break;
                 }
-                tmp = bc_str_find(src + current, '*');
+                tmp = sb_str_find(src + current, '*');
                 if (tmp == NULL || ((tmp - src) >= src_len)) {
-                    bc_string_append_c(rv, '*');
+                    sb_string_append_c(rv, '*');
                     state = CONTENT_INLINE_START;
                     continue;
                 }
                 tmp2 = blogc_content_parse_inline_internal(
                     src + current, (tmp - src) - current);
-                bc_string_append_printf(rv, "<em>%s</em>", tmp2);
+                sb_string_append_printf(rv, "<em>%s</em>", tmp2);
                 current = tmp - src;
                 tmp = NULL;
                 free(tmp2);
@@ -263,21 +263,21 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
             case CONTENT_INLINE_ASTERISK_DOUBLE:
                 tmp = src + current;
                 do {
-                    tmp = bc_str_find(tmp, '*');
+                    tmp = sb_str_find(tmp, '*');
                     if (((tmp - src) < src_len) && *(tmp + 1) == '*') {
                         break;
                     }
                     tmp++;
                 } while (tmp != NULL && (tmp - src) < src_len);
                 if (tmp == NULL || ((tmp - src) >= src_len)) {
-                    bc_string_append_c(rv, '*');
-                    bc_string_append_c(rv, '*');
+                    sb_string_append_c(rv, '*');
+                    sb_string_append_c(rv, '*');
                     state = CONTENT_INLINE_START;
                     continue;
                 }
                 tmp2 = blogc_content_parse_inline_internal(
                     src + current, (tmp - src) - current);
-                bc_string_append_printf(rv, "<strong>%s</strong>", tmp2);
+                sb_string_append_printf(rv, "<strong>%s</strong>", tmp2);
                 current = tmp - src + 1;
                 tmp = NULL;
                 free(tmp2);
@@ -290,15 +290,15 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     state = CONTENT_INLINE_UNDERSCORE_DOUBLE;
                     break;
                 }
-                tmp = bc_str_find(src + current, '_');
+                tmp = sb_str_find(src + current, '_');
                 if (tmp == NULL || ((tmp - src) >= src_len)) {
-                    bc_string_append_c(rv, '_');
+                    sb_string_append_c(rv, '_');
                     state = CONTENT_INLINE_START;
                     continue;
                 }
                 tmp2 = blogc_content_parse_inline_internal(
                     src + current, (tmp - src) - current);
-                bc_string_append_printf(rv, "<em>%s</em>", tmp2);
+                sb_string_append_printf(rv, "<em>%s</em>", tmp2);
                 current = tmp - src;
                 tmp = NULL;
                 free(tmp2);
@@ -309,21 +309,21 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
             case CONTENT_INLINE_UNDERSCORE_DOUBLE:
                 tmp = src + current;
                 do {
-                    tmp = bc_str_find(tmp, '_');
+                    tmp = sb_str_find(tmp, '_');
                     if (((tmp - src) < src_len) && *(tmp + 1) == '_') {
                         break;
                     }
                     tmp++;
                 } while (tmp != NULL && (tmp - src) < src_len);
                 if (tmp == NULL || ((tmp - src) >= src_len)) {
-                    bc_string_append_c(rv, '_');
-                    bc_string_append_c(rv, '_');
+                    sb_string_append_c(rv, '_');
+                    sb_string_append_c(rv, '_');
                     state = CONTENT_INLINE_START;
                     continue;
                 }
                 tmp2 = blogc_content_parse_inline_internal(
                     src + current, (tmp - src) - current);
-                bc_string_append_printf(rv, "<strong>%s</strong>", tmp2);
+                sb_string_append_printf(rv, "<strong>%s</strong>", tmp2);
                 current = tmp - src + 1;
                 tmp = NULL;
                 free(tmp2);
@@ -336,19 +336,19 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     state = CONTENT_INLINE_BACKTICKS_DOUBLE;
                     break;
                 }
-                tmp = bc_str_find(src + current, '`');
+                tmp = sb_str_find(src + current, '`');
                 if (tmp == NULL || ((tmp - src) >= src_len)) {
-                    bc_string_append_c(rv, '`');
+                    sb_string_append_c(rv, '`');
                     state = CONTENT_INLINE_START;
                     continue;
                 }
-                tmp3 = bc_strndup(src + current, (tmp - src) - current);
+                tmp3 = sb_strndup(src + current, (tmp - src) - current);
                 tmp2 = blogc_htmlentities(tmp3);
                 free(tmp3);
                 tmp3 = NULL;
-                bc_string_append(rv, "<code>");
-                bc_string_append_escaped(rv, tmp2);
-                bc_string_append(rv, "</code>");
+                sb_string_append(rv, "<code>");
+                sb_string_append_escaped(rv, tmp2);
+                sb_string_append(rv, "</code>");
                 current = tmp - src;
                 tmp = NULL;
                 free(tmp2);
@@ -359,25 +359,25 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
             case CONTENT_INLINE_BACKTICKS_DOUBLE:
                 tmp = src + current;
                 do {
-                    tmp = bc_str_find(tmp, '`');
+                    tmp = sb_str_find(tmp, '`');
                     if (((tmp - src) < src_len) && *(tmp + 1) == '`') {
                         break;
                     }
                     tmp++;
                 } while (tmp != NULL && (tmp - src) < src_len);
                 if (tmp == NULL || ((tmp - src) >= src_len)) {
-                    bc_string_append_c(rv, '`');
-                    bc_string_append_c(rv, '`');
+                    sb_string_append_c(rv, '`');
+                    sb_string_append_c(rv, '`');
                     state = CONTENT_INLINE_START;
                     continue;
                 }
-                tmp3 = bc_strndup(src + current, (tmp - src) - current);
+                tmp3 = sb_strndup(src + current, (tmp - src) - current);
                 tmp2 = blogc_htmlentities(tmp3);
                 free(tmp3);
                 tmp3 = NULL;
-                bc_string_append(rv, "<code>");
-                bc_string_append_escaped(rv, tmp2);
-                bc_string_append(rv, "</code>");
+                sb_string_append(rv, "<code>");
+                sb_string_append_escaped(rv, tmp2);
+                sb_string_append(rv, "</code>");
                 current = tmp - src + 1;
                 tmp = NULL;
                 free(tmp2);
@@ -398,24 +398,24 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
             case CONTENT_INLINE_LINK_AUTO:
                 tmp = src + current;
                 do {
-                    tmp = bc_str_find(tmp, ']');
+                    tmp = sb_str_find(tmp, ']');
                     if (((tmp - src) < src_len) && *(tmp + 1) == ']') {
                         break;
                     }
                     tmp++;
                 } while (tmp != NULL && (tmp - src) < src_len);
                 if (tmp == NULL || ((tmp - src) >= src_len)) {
-                    bc_string_append_c(rv, '[');
-                    bc_string_append_c(rv, '[');
+                    sb_string_append_c(rv, '[');
+                    sb_string_append_c(rv, '[');
                     state = CONTENT_INLINE_START;
                     continue;
                 }
-                tmp2 = bc_strndup(src + current, (tmp - src) - current);
-                bc_string_append(rv, "<a href=\"");
-                bc_string_append_escaped(rv, tmp2);
-                bc_string_append(rv, "\">");
-                bc_string_append_escaped(rv, tmp2);
-                bc_string_append(rv, "</a>");
+                tmp2 = sb_strndup(src + current, (tmp - src) - current);
+                sb_string_append(rv, "<a href=\"");
+                sb_string_append_escaped(rv, tmp2);
+                sb_string_append(rv, "\">");
+                sb_string_append_escaped(rv, tmp2);
+                sb_string_append(rv, "</a>");
                 current = tmp - src + 1;
                 tmp = NULL;
                 free(tmp2);
@@ -434,7 +434,7 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                 }
                 if (c == ']') {
                     if (--count == 0) {
-                        link1 = bc_strndup(src + start_link, current - start_link);
+                        link1 = sb_strndup(src + start_link, current - start_link);
                         state = CONTENT_INLINE_LINK_URL_START;
                     }
                 }
@@ -448,7 +448,7 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     start = current + 1;
                     break;
                 }
-                bc_string_append_c(rv, '[');
+                sb_string_append_c(rv, '[');
                 state = CONTENT_INLINE_START;
                 current = start_link;
                 start_link = 0;
@@ -460,13 +460,13 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     break;
                 }
                 if (c == ')') {
-                    tmp2 = bc_strndup(src + start, current - start);
+                    tmp2 = sb_strndup(src + start, current - start);
                     tmp3 = blogc_content_parse_inline(link1);
                     free(link1);
                     link1 = NULL;
-                    bc_string_append(rv, "<a href=\"");
-                    bc_string_append_escaped(rv, tmp2);
-                    bc_string_append_printf(rv, "\">%s</a>", tmp3);
+                    sb_string_append(rv, "<a href=\"");
+                    sb_string_append_escaped(rv, tmp2);
+                    sb_string_append_printf(rv, "\">%s</a>", tmp3);
                     free(tmp2);
                     tmp2 = NULL;
                     free(tmp3);
@@ -483,7 +483,7 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     start_link = current + 1;
                     break;
                 }
-                bc_string_append_c(rv, '!');
+                sb_string_append_c(rv, '!');
                 state = CONTENT_INLINE_START;
                 continue;
 
@@ -493,7 +493,7 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     break;
                 }
                 if (c == ']') {
-                    link1 = bc_strndup(src + start_link, current - start_link);
+                    link1 = sb_strndup(src + start_link, current - start_link);
                     state = CONTENT_INLINE_IMAGE_URL_START;
                 }
                 break;
@@ -506,8 +506,8 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     start = current + 1;
                     break;
                 }
-                bc_string_append_c(rv, '!');
-                bc_string_append_c(rv, '[');
+                sb_string_append_c(rv, '!');
+                sb_string_append_c(rv, '[');
                 state = CONTENT_INLINE_START;
                 current = start_link;
                 start_link = 0;
@@ -519,12 +519,12 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     break;
                 }
                 if (c == ')') {
-                    tmp2 = bc_strndup(src + start, current - start);
-                    bc_string_append(rv, "<img src=\"");
-                    bc_string_append_escaped(rv, tmp2);
-                    bc_string_append(rv, "\" alt=\"");
-                    bc_string_append_escaped(rv, link1);
-                    bc_string_append(rv, "\">");
+                    tmp2 = sb_strndup(src + start, current - start);
+                    sb_string_append(rv, "<img src=\"");
+                    sb_string_append_escaped(rv, tmp2);
+                    sb_string_append(rv, "\" alt=\"");
+                    sb_string_append_escaped(rv, link1);
+                    sb_string_append(rv, "\">");
                     free(tmp2);
                     tmp2 = NULL;
                     free(link1);
@@ -537,31 +537,31 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
             case CONTENT_INLINE_ENDASH:
                 if (c == '-') {
                     if (is_last) {
-                        bc_string_append(rv, "&ndash;");
+                        sb_string_append(rv, "&ndash;");
                         state = CONTENT_INLINE_START;  // wat
                         break;
                     }
                     state = CONTENT_INLINE_EMDASH;
                     break;
                 }
-                bc_string_append_c(rv, '-');
+                sb_string_append_c(rv, '-');
                 state = CONTENT_INLINE_START;
                 continue;
 
             case CONTENT_INLINE_EMDASH:
                 if (c == '-') {
-                    bc_string_append(rv, "&mdash;");
+                    sb_string_append(rv, "&mdash;");
                     state = CONTENT_INLINE_START;
                     break;
                 }
-                bc_string_append(rv, "&ndash;");
+                sb_string_append(rv, "&ndash;");
                 state = CONTENT_INLINE_START;
                 continue;
 
             case CONTENT_INLINE_LINE_BREAK_START:
                 if (c == ' ') {
                     if (is_last) {
-                        bc_string_append(rv, "<br />");
+                        sb_string_append(rv, "<br />");
                         state = CONTENT_INLINE_START;  // wat
                         break;
                     }
@@ -569,14 +569,14 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     state = CONTENT_INLINE_LINE_BREAK;
                     break;
                 }
-                bc_string_append_c(rv, ' ');
+                sb_string_append_c(rv, ' ');
                 state = CONTENT_INLINE_START;
                 continue;
 
             case CONTENT_INLINE_LINE_BREAK:
                 if (c == ' ') {
                     if (is_last) {
-                        bc_string_append(rv, "<br />");
+                        sb_string_append(rv, "<br />");
                         state = CONTENT_INLINE_START;  // wat
                         break;
                     }
@@ -584,12 +584,12 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
                     break;
                 }
                 if (c == '\n' || c == '\r') {
-                    bc_string_append_printf(rv, "<br />%c", c);
+                    sb_string_append_printf(rv, "<br />%c", c);
                     state = CONTENT_INLINE_START;
                     break;
                 }
                 for (size_t i = 0; i < count; i++)
-                    bc_string_append_c(rv, ' ');
+                    sb_string_append_c(rv, ' ');
                 state = CONTENT_INLINE_START;
                 continue;
         }
@@ -604,14 +604,14 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
         case CONTENT_INLINE_IMAGE_ALT:
         case CONTENT_INLINE_IMAGE_URL_START:
         case CONTENT_INLINE_IMAGE_URL:
-            bc_string_append_c(rv, '!');
+            sb_string_append_c(rv, '!');
 
         case CONTENT_INLINE_LINK_CONTENT:
         case CONTENT_INLINE_LINK_URL_START:
         case CONTENT_INLINE_LINK_URL:
             tmp2 = blogc_content_parse_inline(src + start_link);
-            bc_string_append_c(rv, '[');
-            bc_string_append_escaped(rv, tmp2);  // no need to free, as it wil be done below.
+            sb_string_append_c(rv, '[');
+            sb_string_append_escaped(rv, tmp2);  // no need to free, as it wil be done below.
             break;
 
         // add all the other states here explicitly, so the compiler helps us
@@ -636,7 +636,7 @@ blogc_content_parse_inline_internal(const char *src, size_t src_len)
     free(tmp3);
     free(link1);
 
-    return bc_string_free(rv, false);
+    return sb_string_free(rv, false);
 }
 
 
@@ -704,11 +704,11 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
 
     char d = '\0';
 
-    bc_slist_t *lines = NULL;
-    bc_slist_t *lines2 = NULL;
+    sb_slist_t *lines = NULL;
+    sb_slist_t *lines2 = NULL;
 
-    bc_string_t *rv = bc_string_new();
-    bc_string_t *tmp_str = NULL;
+    sb_string_t *rv = sb_string_new();
+    sb_string_t *tmp_str = NULL;
 
     blogc_content_parser_state_t state = CONTENT_START_LINE;
 
@@ -835,16 +835,16 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                 if (c == '\n' || c == '\r' || is_last) {
                     end = is_last && c != '\n' && c != '\r' ? src_len :
                         (real_end != 0 ? real_end : current);
-                    tmp = bc_strndup(src + start, end - start);
+                    tmp = sb_strndup(src + start, end - start);
                     if (first_header != NULL && *first_header == NULL)
                         *first_header = blogc_htmlentities(tmp);
                     parsed = blogc_content_parse_inline(tmp);
                     slug = blogc_slugify(tmp);
                     if (slug == NULL)
-                        bc_string_append_printf(rv, "<h%d>%s</h%d>%s",
+                        sb_string_append_printf(rv, "<h%d>%s</h%d>%s",
                             header_level, parsed, header_level, line_ending);
                     else
-                        bc_string_append_printf(rv, "<h%d id=\"%s\">%s</h%d>%s",
+                        sb_string_append_printf(rv, "<h%d id=\"%s\">%s</h%d>%s",
                             header_level, slug, parsed, header_level,
                             line_ending);
                     free(slug);
@@ -868,8 +868,8 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
 
             case CONTENT_HTML_END:
                 if (c == '\n' || c == '\r' || is_last) {
-                    tmp = bc_strndup(src + start, end - start);
-                    bc_string_append_printf(rv, "%s%s", tmp, line_ending);
+                    tmp = sb_strndup(src + start, end - start);
+                    sb_string_append_printf(rv, "%s%s", tmp, line_ending);
                     free(tmp);
                     tmp = NULL;
                     state = CONTENT_START_LINE;
@@ -882,7 +882,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
             case CONTENT_BLOCKQUOTE:
                 if (c == ' ' || c == '\t')
                     break;
-                prefix = bc_strndup(src + start, current - start);
+                prefix = sb_strndup(src + start, current - start);
                 state = CONTENT_BLOCKQUOTE_START;
                 break;
 
@@ -890,16 +890,16 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                 if (c == '\n' || c == '\r' || is_last) {
                     end = is_last && c != '\n' && c != '\r' ? src_len :
                         (real_end != 0 ? real_end : current);
-                    tmp = bc_strndup(src + start2, end - start2);
-                    if (bc_str_starts_with(tmp, prefix)) {
-                        lines = bc_slist_append(lines, bc_strdup(tmp + strlen(prefix)));
+                    tmp = sb_strndup(src + start2, end - start2);
+                    if (sb_str_starts_with(tmp, prefix)) {
+                        lines = sb_slist_append(lines, sb_strdup(tmp + strlen(prefix)));
                         state = CONTENT_BLOCKQUOTE_END;
                     }
                     else {
                         state = CONTENT_PARAGRAPH;
                         free(prefix);
                         prefix = NULL;
-                        bc_slist_free_full(lines, free);
+                        sb_slist_free_full(lines, free);
                         lines = NULL;
                         if (is_last) {
                             free(tmp);
@@ -915,21 +915,21 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
 
             case CONTENT_BLOCKQUOTE_END:
                 if (c == '\n' || c == '\r' || is_last) {
-                    tmp_str = bc_string_new();
-                    for (bc_slist_t *l = lines; l != NULL; l = l->next)
-                        bc_string_append_printf(tmp_str, "%s%s", l->data,
+                    tmp_str = sb_string_new();
+                    for (sb_slist_t *l = lines; l != NULL; l = l->next)
+                        sb_string_append_printf(tmp_str, "%s%s", l->data,
                             line_ending);
                     // do not propagate title and description to blockquote parsing,
                     // because we just want paragraphs from first level of
                     // content.
                     tmp = blogc_content_parse(tmp_str->str, NULL, NULL, NULL);
-                    bc_string_append_printf(rv, "<blockquote>%s</blockquote>%s",
+                    sb_string_append_printf(rv, "<blockquote>%s</blockquote>%s",
                         tmp, line_ending);
                     free(tmp);
                     tmp = NULL;
-                    bc_string_free(tmp_str, true);
+                    sb_string_free(tmp_str, true);
                     tmp_str = NULL;
-                    bc_slist_free_full(lines, free);
+                    sb_slist_free_full(lines, free);
                     lines = NULL;
                     free(prefix);
                     prefix = NULL;
@@ -945,7 +945,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
             case CONTENT_CODE:
                 if (c == ' ' || c == '\t')
                     break;
-                prefix = bc_strndup(src + start, current - start);
+                prefix = sb_strndup(src + start, current - start);
                 state = CONTENT_CODE_START;
                 break;
 
@@ -953,16 +953,16 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                 if (c == '\n' || c == '\r' || is_last) {
                     end = is_last && c != '\n' && c != '\r' ? src_len :
                         (real_end != 0 ? real_end : current);
-                    tmp = bc_strndup(src + start2, end - start2);
-                    if (bc_str_starts_with(tmp, prefix)) {
-                        lines = bc_slist_append(lines, bc_strdup(tmp + strlen(prefix)));
+                    tmp = sb_strndup(src + start2, end - start2);
+                    if (sb_str_starts_with(tmp, prefix)) {
+                        lines = sb_slist_append(lines, sb_strdup(tmp + strlen(prefix)));
                         state = CONTENT_CODE_END;
                     }
                     else {
                         state = CONTENT_PARAGRAPH;
                         free(prefix);
                         prefix = NULL;
-                        bc_slist_free_full(lines, free);
+                        sb_slist_free_full(lines, free);
                         lines = NULL;
                         free(tmp);
                         tmp = NULL;
@@ -978,18 +978,18 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
 
             case CONTENT_CODE_END:
                 if (c == '\n' || c == '\r' || is_last) {
-                    bc_string_append(rv, "<pre><code>");
-                    for (bc_slist_t *l = lines; l != NULL; l = l->next) {
+                    sb_string_append(rv, "<pre><code>");
+                    for (sb_slist_t *l = lines; l != NULL; l = l->next) {
                         char *tmp_line = blogc_htmlentities(l->data);
                         if (l->next == NULL)
-                            bc_string_append_printf(rv, "%s", tmp_line);
+                            sb_string_append_printf(rv, "%s", tmp_line);
                         else
-                            bc_string_append_printf(rv, "%s%s", tmp_line,
+                            sb_string_append_printf(rv, "%s%s", tmp_line,
                                 line_ending);
                         free(tmp_line);
                     }
-                    bc_string_append_printf(rv, "</code></pre>%s", line_ending);
-                    bc_slist_free_full(lines, free);
+                    sb_string_append_printf(rv, "</code></pre>%s", line_ending);
+                    sb_slist_free_full(lines, free);
                     lines = NULL;
                     free(prefix);
                     prefix = NULL;
@@ -1015,7 +1015,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                 }
                 if (c == ' ' || c == '\t')
                     break;
-                prefix = bc_strndup(src + start, current - start);
+                prefix = sb_strndup(src + start, current - start);
                 state = CONTENT_UNORDERED_LIST_START;
                 break;
 
@@ -1036,7 +1036,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                     break;
                 }
                 if (c == '\n' || c == '\r' || is_last) {
-                    bc_string_append_printf(rv, "<hr />%s", line_ending);
+                    sb_string_append_printf(rv, "<hr />%s", line_ending);
                     state = CONTENT_START_LINE;
                     start = current;
                     d = '\0';
@@ -1049,30 +1049,30 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                 if (c == '\n' || c == '\r' || is_last) {
                     end = is_last && c != '\n' && c != '\r' ? src_len :
                         (real_end != 0 ? real_end : current);
-                    tmp = bc_strndup(src + start2, end - start2);
-                    tmp2 = bc_strdup_printf("%-*s", strlen(prefix), "");
-                    if (bc_str_starts_with(tmp, prefix)) {
+                    tmp = sb_strndup(src + start2, end - start2);
+                    tmp2 = sb_strdup_printf("%-*s", strlen(prefix), "");
+                    if (sb_str_starts_with(tmp, prefix)) {
                         if (lines2 != NULL) {
-                            tmp_str = bc_string_new();
-                            for (bc_slist_t *l = lines2; l != NULL; l = l->next) {
+                            tmp_str = sb_string_new();
+                            for (sb_slist_t *l = lines2; l != NULL; l = l->next) {
                                 if (l->next == NULL)
-                                    bc_string_append_printf(tmp_str, "%s", l->data);
+                                    sb_string_append_printf(tmp_str, "%s", l->data);
                                 else
-                                    bc_string_append_printf(tmp_str, "%s%s", l->data,
+                                    sb_string_append_printf(tmp_str, "%s%s", l->data,
                                         line_ending);
                             }
-                            bc_slist_free_full(lines2, free);
+                            sb_slist_free_full(lines2, free);
                             lines2 = NULL;
                             parsed = blogc_content_parse_inline(tmp_str->str);
-                            bc_string_free(tmp_str, true);
-                            lines = bc_slist_append(lines, bc_strdup(parsed));
+                            sb_string_free(tmp_str, true);
+                            lines = sb_slist_append(lines, sb_strdup(parsed));
                             free(parsed);
                             parsed = NULL;
                         }
-                        lines2 = bc_slist_append(lines2, bc_strdup(tmp + strlen(prefix)));
+                        lines2 = sb_slist_append(lines2, sb_strdup(tmp + strlen(prefix)));
                     }
-                    else if (bc_str_starts_with(tmp, tmp2)) {
-                        lines2 = bc_slist_append(lines2, bc_strdup(tmp + strlen(prefix)));
+                    else if (sb_str_starts_with(tmp, tmp2)) {
+                        lines2 = sb_slist_append(lines2, sb_strdup(tmp + strlen(prefix)));
                     }
                     else {
                         state = CONTENT_PARAGRAPH_END;
@@ -1082,8 +1082,8 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                         tmp2 = NULL;
                         free(prefix);
                         prefix = NULL;
-                        bc_slist_free_full(lines, free);
-                        bc_slist_free_full(lines2, free);
+                        sb_slist_free_full(lines, free);
+                        sb_slist_free_full(lines2, free);
                         lines = NULL;
                         if (is_last)
                             continue;
@@ -1102,28 +1102,28 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                 if (c == '\n' || c == '\r' || is_last) {
                     if (lines2 != NULL) {
                         // FIXME: avoid repeting the code below
-                        tmp_str = bc_string_new();
-                        for (bc_slist_t *l = lines2; l != NULL; l = l->next) {
+                        tmp_str = sb_string_new();
+                        for (sb_slist_t *l = lines2; l != NULL; l = l->next) {
                             if (l->next == NULL)
-                                bc_string_append_printf(tmp_str, "%s", l->data);
+                                sb_string_append_printf(tmp_str, "%s", l->data);
                             else
-                                bc_string_append_printf(tmp_str, "%s%s", l->data,
+                                sb_string_append_printf(tmp_str, "%s%s", l->data,
                                     line_ending);
                         }
-                        bc_slist_free_full(lines2, free);
+                        sb_slist_free_full(lines2, free);
                         lines2 = NULL;
                         parsed = blogc_content_parse_inline(tmp_str->str);
-                        bc_string_free(tmp_str, true);
-                        lines = bc_slist_append(lines, bc_strdup(parsed));
+                        sb_string_free(tmp_str, true);
+                        lines = sb_slist_append(lines, sb_strdup(parsed));
                         free(parsed);
                         parsed = NULL;
                     }
-                    bc_string_append_printf(rv, "<ul>%s", line_ending);
-                    for (bc_slist_t *l = lines; l != NULL; l = l->next)
-                        bc_string_append_printf(rv, "<li>%s</li>%s", l->data,
+                    sb_string_append_printf(rv, "<ul>%s", line_ending);
+                    for (sb_slist_t *l = lines; l != NULL; l = l->next)
+                        sb_string_append_printf(rv, "<li>%s</li>%s", l->data,
                             line_ending);
-                    bc_string_append_printf(rv, "</ul>%s", line_ending);
-                    bc_slist_free_full(lines, free);
+                    sb_string_append_printf(rv, "</ul>%s", line_ending);
+                    sb_slist_free_full(lines, free);
                     lines = NULL;
                     free(prefix);
                     prefix = NULL;
@@ -1160,30 +1160,30 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                 if (c == '\n' || c == '\r' || is_last) {
                     end = is_last && c != '\n' && c != '\r' ? src_len :
                         (real_end != 0 ? real_end : current);
-                    tmp = bc_strndup(src + start2, end - start2);
-                    tmp2 = bc_strdup_printf("%-*s", prefix_len, "");
+                    tmp = sb_strndup(src + start2, end - start2);
+                    tmp2 = sb_strdup_printf("%-*s", prefix_len, "");
                     if (blogc_is_ordered_list_item(tmp, prefix_len)) {
                         if (lines2 != NULL) {
-                            tmp_str = bc_string_new();
-                            for (bc_slist_t *l = lines2; l != NULL; l = l->next) {
+                            tmp_str = sb_string_new();
+                            for (sb_slist_t *l = lines2; l != NULL; l = l->next) {
                                 if (l->next == NULL)
-                                    bc_string_append_printf(tmp_str, "%s", l->data);
+                                    sb_string_append_printf(tmp_str, "%s", l->data);
                                 else
-                                    bc_string_append_printf(tmp_str, "%s%s", l->data,
+                                    sb_string_append_printf(tmp_str, "%s%s", l->data,
                                         line_ending);
                             }
-                            bc_slist_free_full(lines2, free);
+                            sb_slist_free_full(lines2, free);
                             lines2 = NULL;
                             parsed = blogc_content_parse_inline(tmp_str->str);
-                            bc_string_free(tmp_str, true);
-                            lines = bc_slist_append(lines, bc_strdup(parsed));
+                            sb_string_free(tmp_str, true);
+                            lines = sb_slist_append(lines, sb_strdup(parsed));
                             free(parsed);
                             parsed = NULL;
                         }
-                        lines2 = bc_slist_append(lines2, bc_strdup(tmp + prefix_len));
+                        lines2 = sb_slist_append(lines2, sb_strdup(tmp + prefix_len));
                     }
-                    else if (bc_str_starts_with(tmp, tmp2)) {
-                        lines2 = bc_slist_append(lines2, bc_strdup(tmp + prefix_len));
+                    else if (sb_str_starts_with(tmp, tmp2)) {
+                        lines2 = sb_slist_append(lines2, sb_strdup(tmp + prefix_len));
                     }
                     else {
                         state = CONTENT_PARAGRAPH_END;
@@ -1193,8 +1193,8 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                         tmp2 = NULL;
                         free(parsed);
                         parsed = NULL;
-                        bc_slist_free_full(lines, free);
-                        bc_slist_free_full(lines2, free);
+                        sb_slist_free_full(lines, free);
+                        sb_slist_free_full(lines2, free);
                         lines = NULL;
                         if (is_last)
                             continue;
@@ -1213,28 +1213,28 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
                 if (c == '\n' || c == '\r' || is_last) {
                     if (lines2 != NULL) {
                         // FIXME: avoid repeting the code below
-                        tmp_str = bc_string_new();
-                        for (bc_slist_t *l = lines2; l != NULL; l = l->next) {
+                        tmp_str = sb_string_new();
+                        for (sb_slist_t *l = lines2; l != NULL; l = l->next) {
                             if (l->next == NULL)
-                                bc_string_append_printf(tmp_str, "%s", l->data);
+                                sb_string_append_printf(tmp_str, "%s", l->data);
                             else
-                                bc_string_append_printf(tmp_str, "%s%s", l->data,
+                                sb_string_append_printf(tmp_str, "%s%s", l->data,
                                     line_ending);
                         }
-                        bc_slist_free_full(lines2, free);
+                        sb_slist_free_full(lines2, free);
                         lines2 = NULL;
                         parsed = blogc_content_parse_inline(tmp_str->str);
-                        bc_string_free(tmp_str, true);
-                        lines = bc_slist_append(lines, bc_strdup(parsed));
+                        sb_string_free(tmp_str, true);
+                        lines = sb_slist_append(lines, sb_strdup(parsed));
                         free(parsed);
                         parsed = NULL;
                     }
-                    bc_string_append_printf(rv, "<ol>%s", line_ending);
-                    for (bc_slist_t *l = lines; l != NULL; l = l->next)
-                        bc_string_append_printf(rv, "<li>%s</li>%s", l->data,
+                    sb_string_append_printf(rv, "<ol>%s", line_ending);
+                    for (sb_slist_t *l = lines; l != NULL; l = l->next)
+                        sb_string_append_printf(rv, "<li>%s</li>%s", l->data,
                             line_ending);
-                    bc_string_append_printf(rv, "</ol>%s", line_ending);
-                    bc_slist_free_full(lines, free);
+                    sb_string_append_printf(rv, "</ol>%s", line_ending);
+                    sb_slist_free_full(lines, free);
                     lines = NULL;
                     free(prefix);
                     prefix = NULL;
@@ -1258,11 +1258,11 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
 
             case CONTENT_PARAGRAPH_END:
                 if (c == '\n' || c == '\r' || is_last) {
-                    tmp = bc_strndup(src + start, end - start);
+                    tmp = sb_strndup(src + start, end - start);
                     if (description != NULL && *description == NULL)
                         *description = blogc_fix_description(tmp);
                     parsed = blogc_content_parse_inline(tmp);
-                    bc_string_append_printf(rv, "<p>%s</p>%s", parsed,
+                    sb_string_append_printf(rv, "<p>%s</p>%s", parsed,
                         line_ending);
                     free(parsed);
                     parsed = NULL;
@@ -1280,5 +1280,5 @@ blogc_content_parse(const char *src, size_t *end_excerpt, char **first_header,
         current++;
     }
 
-    return bc_string_free(rv, false);
+    return sb_string_free(rv, false);
 }
diff --git a/src/blogc/datetime-parser.c b/src/blogc/datetime-parser.c
index b7f26e5..5022034 100644
--- a/src/blogc/datetime-parser.c
+++ b/src/blogc/datetime-parser.c
@@ -15,10 +15,10 @@
 #endif /* HAVE_TIME_H */
 
 #include <string.h>
+#include <squareball.h>
 
+#include "error.h"
 #include "datetime-parser.h"
-#include "../common/error.h"
-#include "../common/utils.h"
 
 
 typedef enum {
@@ -47,14 +47,14 @@ typedef enum {
 
 char*
 blogc_convert_datetime(const char *orig, const char *format,
-    bc_error_t **err)
+    sb_error_t **err)
 {
     if (err == NULL || *err != NULL)
         return NULL;
 
 #ifndef HAVE_TIME_H
 
-    *err = bc_error_new(BLOGC_WARNING_DATETIME_PARSER,
+    *err = sb_error_new(BLOGC_WARNING_DATETIME_PARSER,
         "Your operating system does not supports the datetime functionalities "
         "used by blogc. Sorry.");
     return NULL;
@@ -80,7 +80,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_SECOND_YEAR;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid first digit of year. "
                     "Found '%c', must be integer >= 0 and <= 9.", c);
                 break;
@@ -91,7 +91,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_THIRD_YEAR;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid second digit of year. "
                     "Found '%c', must be integer >= 0 and <= 9.", c);
                 break;
@@ -102,7 +102,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_FOURTH_YEAR;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid third digit of year. "
                     "Found '%c', must be integer >= 0 and <= 9.", c);
                 break;
@@ -111,7 +111,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                 if (c >= '0' && c <= '9') {
                     tmp += c - diff - 1900;
                     if (tmp < 0) {
-                        *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                        *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                             "Invalid year. Found %d, must be >= 1900.",
                             tmp + 1900);
                         break;
@@ -120,7 +120,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_FIRST_HYPHEN;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid fourth digit of year. "
                     "Found '%c', must be integer >= 0 and <= 9.", c);
                 break;
@@ -131,7 +131,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_FIRST_MONTH;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid separator between year and month. "
                     "Found '%c', must be '-'.", c);
                 break;
@@ -142,7 +142,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_SECOND_MONTH;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid first digit of month. "
                     "Found '%c', must be integer >= 0 and <= 1.", c);
                 break;
@@ -151,7 +151,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                 if (c >= '0' && c <= '9') {
                     tmp += c - diff - 1;
                     if (tmp < 0 || tmp > 11) {
-                        *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                        *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                             "Invalid month. Found %d, must be >= 1 and <= 12.",
                             tmp + 1);
                         break;
@@ -160,7 +160,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_SECOND_HYPHEN;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid second digit of month. "
                     "Found '%c', must be integer >= 0 and <= 9.", c);
                 break;
@@ -171,7 +171,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_FIRST_DAY;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid separator between month and day. "
                     "Found '%c', must be '-'.", c);
                 break;
@@ -182,7 +182,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_SECOND_DAY;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid first digit of day. "
                     "Found '%c', must be integer >= 0 and <= 3.", c);
                 break;
@@ -191,7 +191,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                 if (c >= '0' && c <= '9') {
                     tmp += c - diff;
                     if (tmp < 1 || tmp > 31) {
-                        *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                        *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                             "Invalid day. Found %d, must be >= 1 and <= 31.",
                             tmp);
                         break;
@@ -200,7 +200,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_SPACE;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid second digit of day. "
                     "Found '%c', must be integer >= 0 and <= 9.", c);
                 break;
@@ -211,7 +211,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_FIRST_HOUR;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid separator between date and time. "
                     "Found '%c', must be ' ' (empty space).", c);
                 break;
@@ -222,7 +222,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_SECOND_HOUR;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid first digit of hours. "
                     "Found '%c', must be integer >= 0 and <= 2.", c);
                 break;
@@ -231,7 +231,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                 if (c >= '0' && c <= '9') {
                     tmp += c - diff;
                     if (tmp < 0 || tmp > 23) {
-                        *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                        *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                             "Invalid hours. Found %d, must be >= 0 and <= 23.",
                             tmp);
                         break;
@@ -240,7 +240,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_FIRST_COLON;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid second digit of hours. "
                     "Found '%c', must be integer >= 0 and <= 9.", c);
                 break;
@@ -251,7 +251,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_FIRST_MINUTE;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid separator between hours and minutes. "
                     "Found '%c', must be ':'.", c);
                 break;
@@ -262,7 +262,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_SECOND_MINUTE;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid first digit of minutes. "
                     "Found '%c', must be integer >= 0 and <= 5.", c);
                 break;
@@ -274,7 +274,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                         // this won't happen because we are restricting the digits
                         // to 00-59 already, but lets keep the code here for
                         // reference.
-                        *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                        *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                             "Invalid minutes. Found %d, must be >= 0 and <= 59.",
                             tmp);
                         break;
@@ -283,7 +283,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_SECOND_COLON;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid second digit of minutes. "
                     "Found '%c', must be integer >= 0 and <= 9.", c);
                 break;
@@ -294,7 +294,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_FIRST_SECOND;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid separator between minutes and seconds. "
                     "Found '%c', must be ':'.", c);
                 break;
@@ -305,7 +305,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_SECOND_SECOND;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid first digit of seconds. "
                     "Found '%c', must be integer >= 0 and <= 6.", c);
                 break;
@@ -314,7 +314,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                 if (c >= '0' && c <= '9') {
                     tmp += c - diff;
                     if (tmp < 0 || tmp > 60) {
-                        *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                        *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                             "Invalid seconds. Found %d, must be >= 0 and <= 60.",
                             tmp);
                         break;
@@ -323,7 +323,7 @@ blogc_convert_datetime(const char *orig, const char *format,
                     state = DATETIME_DONE;
                     break;
                 }
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid second digit of seconds. "
                     "Found '%c', must be integer >= 0 and <= 9.", c);
                 break;
@@ -355,7 +355,7 @@ blogc_convert_datetime(const char *orig, const char *format,
             case DATETIME_SECOND_MINUTE:
             case DATETIME_FIRST_SECOND:
             case DATETIME_SECOND_SECOND:
-                *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+                *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
                     "Invalid datetime string. "
                     "Found '%s', formats allowed are: 'yyyy-mm-dd hh:mm:ss', "
                     "'yyyy-mm-dd hh:ss', 'yyyy-mm-dd hh' and 'yyyy-mm-dd'.",
@@ -374,13 +374,13 @@ blogc_convert_datetime(const char *orig, const char *format,
 
     char buf[1024];
     if (0 == strftime(buf, sizeof(buf), format, &t)) {
-        *err = bc_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
+        *err = sb_error_new_printf(BLOGC_WARNING_DATETIME_PARSER,
             "Failed to format DATE variable, FORMAT is too long: %s",
             format);
         return NULL;
     }
 
-    return bc_strdup(buf);
+    return sb_strdup(buf);
 
 #endif
 }
diff --git a/src/blogc/datetime-parser.h b/src/blogc/datetime-parser.h
index 1af9ed6..c03d68b 100644
--- a/src/blogc/datetime-parser.h
+++ b/src/blogc/datetime-parser.h
@@ -9,9 +9,9 @@
 #ifndef _DATETIME_H
 #define _DATETIME_H
 
-#include "../common/error.h"
+#include <squareball.h>
 
 char* blogc_convert_datetime(const char *orig, const char *format,
-    bc_error_t **err);
+    sb_error_t **err);
 
 #endif /* _DATETIME_H */
diff --git a/src/blogc/debug.c b/src/blogc/debug.c
index afb2fe3..5ddd89d 100644
--- a/src/blogc/debug.c
+++ b/src/blogc/debug.c
@@ -7,9 +7,9 @@
  */
 
 #include <stdio.h>
+#include <squareball.h>
 
 #include "template-parser.h"
-#include "../common/utils.h"
 #include "debug.h"
 
 
@@ -34,9 +34,9 @@ get_operator(blogc_template_operator_t op)
 
 
 void
-blogc_debug_template(bc_slist_t *ast)
+blogc_debug_template(sb_slist_t *ast)
 {
-    for (bc_slist_t *tmp = ast; tmp != NULL; tmp = tmp->next) {
+    for (sb_slist_t *tmp = ast; tmp != NULL; tmp = tmp->next) {
         blogc_template_node_t *data = tmp->data;
         fprintf(stderr, "DEBUG: <TEMPLATE ");
         switch (data->type) {
diff --git a/src/blogc/debug.h b/src/blogc/debug.h
index c7c1fbe..710b5a8 100644
--- a/src/blogc/debug.h
+++ b/src/blogc/debug.h
@@ -9,8 +9,8 @@
 #ifndef ___DEBUG_H
 #define ___DEBUG_H
 
-#include "../common/utils.h"
+#include <squareball.h>
 
-void blogc_debug_template(bc_slist_t *ast);
+void blogc_debug_template(sb_slist_t *ast);
 
 #endif /* ___DEBUG_H */
diff --git a/src/blogc/error.c b/src/blogc/error.c
new file mode 100644
index 0000000..1563789
--- /dev/null
+++ b/src/blogc/error.c
@@ -0,0 +1,39 @@
+/*
+ * blogc: A blog compiler.
+ * Copyright (C) 2014-2017 Rafael G. Martins <rafael@rafaelmartins.eng.br>
+ *
+ * This program can be distributed under the terms of the BSD License.
+ * See the file LICENSE.
+ */
+
+#include <stdio.h>
+#include <squareball.h>
+
+#include "error.h"
+
+
+void
+blogc_error_print(sb_error_t *err)
+{
+    if (err == NULL)
+        return;
+
+    fprintf(stderr, "blogc: ");
+
+    switch((blogc_error_type_t) err->code) {
+        case BLOGC_ERROR_SOURCE_PARSER:
+            fprintf(stderr, "error: source: %s\n", err->msg);
+            break;
+        case BLOGC_ERROR_TEMPLATE_PARSER:
+            fprintf(stderr, "error: template: %s\n", err->msg);
+            break;
+        case BLOGC_ERROR_LOADER:
+            fprintf(stderr, "error: loader: %s\n", err->msg);
+            break;
+        case BLOGC_WARNING_DATETIME_PARSER:
+            fprintf(stderr, "warning: datetime: %s\n", err->msg);
+            break;
+        default:
+            fprintf(stderr, "error: %s\n", err->msg);
+    }
+}
diff --git a/src/blogc/error.h b/src/blogc/error.h
new file mode 100644
index 0000000..16df6bd
--- /dev/null
+++ b/src/blogc/error.h
@@ -0,0 +1,21 @@
+/*
+ * blogc: A blog compiler.
+ * Copyright (C) 2014-2017 Rafael G. Martins <rafael@rafaelmartins.eng.br>
+ *
+ * This program can be distributed under the terms of the BSD License.
+ * See the file LICENSE.
+ */
+
+#ifndef _ERROR_H
+#define _ERROR_H
+
+typedef enum {
+    BLOGC_ERROR_SOURCE_PARSER = 100,
+    BLOGC_ERROR_TEMPLATE_PARSER,
+    BLOGC_ERROR_LOADER,
+    BLOGC_WARNING_DATETIME_PARSER,
+} blogc_error_type_t;
+
+void blogc_error_print(sb_error_t *err);
+
+#endif /* _ERROR_H */
diff --git a/src/blogc/loader.c b/src/blogc/loader.c
index 0525198..fc79641 100644
--- a/src/blogc/loader.c
+++ b/src/blogc/loader.c
@@ -12,12 +12,12 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <squareball.h>
+
+#include "error.h"
 #include "source-parser.h"
 #include "template-parser.h"
 #include "loader.h"
-#include "../common/error.h"
-#include "../common/file.h"
-#include "../common/utils.h"
 
 
 char*
@@ -29,7 +29,7 @@ blogc_get_filename(const char *f)
     if (strlen(f) == 0)
         return NULL;
 
-    char *filename = bc_strdup(f);
+    char *filename = sb_strdup(f);
 
     // keep a pointer to original string
     char *tmp = filename;
@@ -50,46 +50,46 @@ blogc_get_filename(const char *f)
         }
     }
 
-    char *final_filename = bc_strdup(tmp);
+    char *final_filename = sb_strdup(tmp);
     free(filename);
 
     return final_filename;
 }
 
 
-bc_slist_t*
-blogc_template_parse_from_file(const char *f, bc_error_t **err)
+sb_slist_t*
+blogc_template_parse_from_file(const char *f, sb_error_t **err)
 {
     if (err == NULL || *err != NULL)
         return NULL;
 
     size_t len;
-    char *s = bc_file_get_contents(f, true, &len, err);
+    char *s = sb_file_get_contents_utf8(f, &len, err);
     if (s == NULL)
         return NULL;
-    bc_slist_t *rv = blogc_template_parse(s, len, err);
+    sb_slist_t *rv = blogc_template_parse(s, len, err);
     free(s);
     return rv;
 }
 
 
-bc_trie_t*
-blogc_source_parse_from_file(const char *f, bc_error_t **err)
+sb_trie_t*
+blogc_source_parse_from_file(const char *f, sb_error_t **err)
 {
     if (err == NULL || *err != NULL)
         return NULL;
 
     size_t len;
-    char *s = bc_file_get_contents(f, true, &len, err);
+    char *s = sb_file_get_contents_utf8(f, &len, err);
     if (s == NULL)
         return NULL;
-    bc_trie_t *rv = blogc_source_parse(s, len, err);
+    sb_trie_t *rv = blogc_source_parse(s, len, err);
 
     // set FILENAME variable
     if (rv != NULL) {
         char *filename = blogc_get_filename(f);
         if (filename != NULL)
-            bc_trie_insert(rv, "FILENAME", filename);
+            sb_trie_insert(rv, "FILENAME", filename);
     }
 
     free(s);
@@ -97,30 +97,30 @@ blogc_source_parse_from_file(const char *f, bc_error_t **err)
 }
 
 
-bc_slist_t*
-blogc_source_parse_from_files(bc_trie_t *conf, bc_slist_t *l, bc_error_t **err)
+sb_slist_t*
+blogc_source_parse_from_files(sb_trie_t *conf, sb_slist_t *l, sb_error_t **err)
 {
     if (err == NULL || *err != NULL)
         return NULL;
 
-    bool reverse = bc_trie_lookup(conf, "FILTER_REVERSE");
-    bc_slist_t* sources = NULL;
-    for (bc_slist_t *tmp = l; tmp != NULL; tmp = tmp->next) {
+    bool reverse = sb_trie_lookup(conf, "FILTER_REVERSE");
+    sb_slist_t* sources = NULL;
+    for (sb_slist_t *tmp = l; tmp != NULL; tmp = tmp->next) {
         if (reverse) {
-            sources = bc_slist_prepend(sources, tmp->data);
+            sources = sb_slist_prepend(sources, tmp->data);
         }
         else {
-            sources = bc_slist_append(sources, tmp->data);
+            sources = sb_slist_append(sources, tmp->data);
         }
     }
 
-    bc_error_t *tmp_err = NULL;
-    bc_slist_t *rv = NULL;
+    sb_error_t *tmp_err = NULL;
+    sb_slist_t *rv = NULL;
     size_t with_date = 0;
 
-    const char *filter_tag = bc_trie_lookup(conf, "FILTER_TAG");
-    const char *filter_page = bc_trie_lookup(conf, "FILTER_PAGE");
-    const char *filter_per_page = bc_trie_lookup(conf, "FILTER_PER_PAGE");
+    const char *filter_tag = sb_trie_lookup(conf, "FILTER_TAG");
+    const char *filter_page = sb_trie_lookup(conf, "FILTER_PAGE");
+    const char *filter_per_page = sb_trie_lookup(conf, "FILTER_PER_PAGE");
 
     const char *ptr;
     char *endptr;
@@ -146,27 +146,27 @@ blogc_source_parse_from_files(bc_trie_t *conf, bc_slist_t *l, bc_error_t **err)
     size_t end = start + per_page;
     size_t counter = 0;
 
-    for (bc_slist_t *tmp = sources; tmp != NULL; tmp = tmp->next) {
+    for (sb_slist_t *tmp = sources; tmp != NULL; tmp = tmp->next) {
         char *f = tmp->data;
-        bc_trie_t *s = blogc_source_parse_from_file(f, &tmp_err);
+        sb_trie_t *s = blogc_source_parse_from_file(f, &tmp_err);
         if (s == NULL) {
-            *err = bc_error_new_printf(BLOGC_ERROR_LOADER,
+            *err = sb_error_new_printf(BLOGC_ERROR_LOADER,
                 "An error occurred while parsing source file: %s\n\n%s",
                 f, tmp_err->msg);
-            bc_error_free(tmp_err);
+            sb_error_free(tmp_err);
             tmp_err = NULL;
-            bc_slist_free_full(rv, (bc_free_func_t) bc_trie_free);
+            sb_slist_free_full(rv, (sb_free_func_t) sb_trie_free);
             rv = NULL;
             break;
         }
         if (filter_tag != NULL) {
-            const char *tags_str = bc_trie_lookup(s, "TAGS");
+            const char *tags_str = sb_trie_lookup(s, "TAGS");
             // if user wants to filter by tag and no tag is provided, skip it
             if (tags_str == NULL) {
-                bc_trie_free(s);
+                sb_trie_free(s);
                 continue;
             }
-            char **tags = bc_str_split(tags_str, ' ', 0);
+            char **tags = sb_str_split(tags_str, ' ', 0);
             bool found = false;
             for (size_t i = 0; tags[i] != NULL; i++) {
                 if (tags[i][0] == '\0')
@@ -174,68 +174,68 @@ blogc_source_parse_from_files(bc_trie_t *conf, bc_slist_t *l, bc_error_t **err)
                 if (0 == strcmp(tags[i], filter_tag))
                     found = true;
             }
-            bc_strv_free(tags);
+            sb_strv_free(tags);
             if (!found) {
-                bc_trie_free(s);
+                sb_trie_free(s);
                 continue;
             }
         }
         if (filter_page != NULL) {
             if (counter < start || counter >= end) {
                 counter++;
-                bc_trie_free(s);
+                sb_trie_free(s);
                 continue;
             }
             counter++;
         }
-        if (bc_trie_lookup(s, "DATE") != NULL)
+        if (sb_trie_lookup(s, "DATE") != NULL)
             with_date++;
-        rv = bc_slist_append(rv, s);
+        rv = sb_slist_append(rv, s);
     }
 
-    bc_slist_free(sources);
+    sb_slist_free(sources);
 
-    if (with_date > 0 && with_date < bc_slist_length(rv)) {
-        *err = bc_error_new_printf(BLOGC_ERROR_LOADER,
+    if (with_date > 0 && with_date < sb_slist_length(rv)) {
+        *err = sb_error_new_printf(BLOGC_ERROR_LOADER,
             "'DATE' variable provided for at least one source file, but not "
             "for all source files. It must be provided for all files.\n");
-        bc_slist_free_full(rv, (bc_free_func_t) bc_trie_free);
+        sb_slist_free_full(rv, (sb_free_func_t) sb_trie_free);
         rv = NULL;
     }
 
     bool first = true;
-    for (bc_slist_t *tmp = rv; tmp != NULL; tmp = tmp->next) {
-        bc_trie_t *s = tmp->data;
+    for (sb_slist_t *tmp = rv; tmp != NULL; tmp = tmp->next) {
+        sb_trie_t *s = tmp->data;
         if (first) {
-            const char *val = bc_trie_lookup(s, "DATE");
+            const char *val = sb_trie_lookup(s, "DATE");
             if (val != NULL)
-                bc_trie_insert(conf, "DATE_FIRST", bc_strdup(val));
-            val = bc_trie_lookup(s, "FILENAME");
+                sb_trie_insert(conf, "DATE_FIRST", sb_strdup(val));
+            val = sb_trie_lookup(s, "FILENAME");
             if (val != NULL)
-                bc_trie_insert(conf, "FILENAME_FIRST", bc_strdup(val));
+                sb_trie_insert(conf, "FILENAME_FIRST", sb_strdup(val));
             first = false;
         }
         if (tmp->next == NULL) {  // last
-            const char *val = bc_trie_lookup(s, "DATE");
+            const char *val = sb_trie_lookup(s, "DATE");
             if (val != NULL)
-                bc_trie_insert(conf, "DATE_LAST", bc_strdup(val));
-            val = bc_trie_lookup(s, "FILENAME");
+                sb_trie_insert(conf, "DATE_LAST", sb_strdup(val));
+            val = sb_trie_lookup(s, "FILENAME");
             if (val != NULL)
-                bc_trie_insert(conf, "FILENAME_LAST", bc_strdup(val));
+                sb_trie_insert(conf, "FILENAME_LAST", sb_strdup(val));
         }
     }
 
     if (filter_page != NULL) {
         size_t last_page = ceilf(((float) counter) / per_page);
-        bc_trie_insert(conf, "CURRENT_PAGE", bc_strdup_printf("%ld", page));
+        sb_trie_insert(conf, "CURRENT_PAGE", sb_strdup_printf("%ld", page));
         if (page > 1)
-            bc_trie_insert(conf, "PREVIOUS_PAGE", bc_strdup_printf("%ld", page - 1));
+            sb_trie_insert(conf, "PREVIOUS_PAGE", sb_strdup_printf("%ld", page - 1));
         if (page < last_page)
-            bc_trie_insert(conf, "NEXT_PAGE", bc_strdup_printf("%ld", page + 1));
-        if (bc_slist_length(rv) > 0)
-            bc_trie_insert(conf, "FIRST_PAGE", bc_strdup("1"));
+            sb_trie_insert(conf, "NEXT_PAGE", sb_strdup_printf("%ld", page + 1));
+        if (sb_slist_length(rv) > 0)
+            sb_trie_insert(conf, "FIRST_PAGE", sb_strdup("1"));
         if (last_page > 0)
-            bc_trie_insert(conf, "LAST_PAGE", bc_strdup_printf("%d", last_page));
+            sb_trie_insert(conf, "LAST_PAGE", sb_strdup_printf("%d", last_page));
     }
 
     return rv;
diff --git a/src/blogc/loader.h b/src/blogc/loader.h
index d9b9e0d..1cff711 100644
--- a/src/blogc/loader.h
+++ b/src/blogc/loader.h
@@ -9,13 +9,12 @@
 #ifndef _LOADER_H
 #define _LOADER_H
 
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
 
 char* blogc_get_filename(const char *f);
-bc_slist_t* blogc_template_parse_from_file(const char *f, bc_error_t **err);
-bc_trie_t* blogc_source_parse_from_file(const char *f, bc_error_t **err);
-bc_slist_t* blogc_source_parse_from_files(bc_trie_t *conf, bc_slist_t *l,
-    bc_error_t **err);
+sb_slist_t* blogc_template_parse_from_file(const char *f, sb_error_t **err);
+sb_trie_t* blogc_source_parse_from_file(const char *f, sb_error_t **err);
+sb_slist_t* blogc_source_parse_from_files(sb_trie_t *conf, sb_slist_t *l,
+    sb_error_t **err);
 
 #endif /* _LOADER_H */
diff --git a/src/blogc/main.c b/src/blogc/main.c
index 0b7c1ad..c93b9d1 100644
--- a/src/blogc/main.c
+++ b/src/blogc/main.c
@@ -21,14 +21,13 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
+#include <squareball.h>
 
 #include "debug.h"
+#include "error.h"
 #include "template-parser.h"
 #include "loader.h"
 #include "renderer.h"
-#include "../common/error.h"
-#include "../common/utf8.h"
-#include "../common/utils.h"
 
 #ifdef MAKE_EMBEDDED
 extern int bm_main(int argc, char **argv);
@@ -88,7 +87,7 @@ blogc_print_usage(void)
 static void
 blogc_mkdir_recursive(const char *filename)
 {
-    char *fname = bc_strdup(filename);
+    char *fname = sb_strdup(filename);
     for (char *tmp = fname; *tmp != '\0'; tmp++) {
         if (*tmp != '/' && *tmp != '\\')
             continue;
@@ -120,8 +119,8 @@ blogc_mkdir_recursive(const char *filename)
 }
 
 
-static bc_slist_t*
-blogc_read_stdin_to_list(bc_slist_t *l)
+static sb_slist_t*
+blogc_read_stdin_to_list(sb_slist_t *l)
 {
     char buffer[4096];
     while (NULL != fgets(buffer, 4096, stdin)) {
@@ -136,7 +135,7 @@ blogc_read_stdin_to_list(bc_slist_t *l)
             buffer[len - 1] = '\0';
         if (strlen(buffer) == 0)
             continue;
-        l = bc_slist_append(l, bc_strdup(buffer));
+        l = sb_slist_append(l, sb_strdup(buffer));
     }
     return l;
 }
@@ -161,9 +160,9 @@ main(int argc, char **argv)
     char *tmp = NULL;
     char **pieces = NULL;
 
-    bc_slist_t *sources = NULL;
-    bc_trie_t *config = bc_trie_new(free);
-    bc_trie_insert(config, "BLOGC_VERSION", bc_strdup(PACKAGE_VERSION));
+    sb_slist_t *sources = NULL;
+    sb_trie_t *config = sb_trie_new(free);
+    sb_trie_insert(config, "BLOGC_VERSION", sb_strdup(PACKAGE_VERSION));
 
     for (size_t i = 1; i < argc; i++) {
         tmp = NULL;
@@ -186,21 +185,21 @@ main(int argc, char **argv)
                     break;
                 case 't':
                     if (argv[i][2] != '\0')
-                        template = bc_strdup(argv[i] + 2);
+                        template = sb_strdup(argv[i] + 2);
                     else if (i + 1 < argc)
-                        template = bc_strdup(argv[++i]);
+                        template = sb_strdup(argv[++i]);
                     break;
                 case 'o':
                     if (argv[i][2] != '\0')
-                        output = bc_strdup(argv[i] + 2);
+                        output = sb_strdup(argv[i] + 2);
                     else if (i + 1 < argc)
-                        output = bc_strdup(argv[++i]);
+                        output = sb_strdup(argv[++i]);
                     break;
                 case 'p':
                     if (argv[i][2] != '\0')
-                        print = bc_strdup(argv[i] + 2);
+                        print = sb_strdup(argv[i] + 2);
                     else if (i + 1 < argc)
-                        print = bc_strdup(argv[++i]);
+                        print = sb_strdup(argv[++i]);
                     break;
                 case 'D':
                     if (argv[i][2] != '\0')
@@ -208,16 +207,16 @@ main(int argc, char **argv)
                     else if (i + 1 < argc)
                         tmp = argv[++i];
                     if (tmp != NULL) {
-                        if (!bc_utf8_validate((uint8_t*) tmp, strlen(tmp))) {
+                        if (!sb_utf8_validate((uint8_t*) tmp, strlen(tmp))) {
                             fprintf(stderr, "blogc: error: invalid value for "
                                 "-D (must be valid UTF-8 string): %s\n", tmp);
                             goto cleanup;
                         }
-                        pieces = bc_str_split(tmp, '=', 2);
-                        if (bc_strv_length(pieces) != 2) {
+                        pieces = sb_str_split(tmp, '=', 2);
+                        if (sb_strv_length(pieces) != 2) {
                             fprintf(stderr, "blogc: error: invalid value for "
                                 "-D (must have an '='): %s\n", tmp);
-                            bc_strv_free(pieces);
+                            sb_strv_free(pieces);
                             rv = 3;
                             goto cleanup;
                         }
@@ -228,13 +227,13 @@ main(int argc, char **argv)
                                 fprintf(stderr, "blogc: error: invalid value "
                                     "for -D (configuration key must be uppercase "
                                     "with '_'): %s\n", pieces[0]);
-                                bc_strv_free(pieces);
+                                sb_strv_free(pieces);
                                 rv = 3;
                                 goto cleanup;
                             }
                         }
-                        bc_trie_insert(config, pieces[0], bc_strdup(pieces[1]));
-                        bc_strv_free(pieces);
+                        sb_trie_insert(config, pieces[0], sb_strdup(pieces[1]));
+                        sb_strv_free(pieces);
                         pieces = NULL;
                     }
                     break;
@@ -252,7 +251,7 @@ main(int argc, char **argv)
             }
         }
         else {
-            sources = bc_slist_append(sources, bc_strdup(argv[i]));
+            sources = sb_slist_append(sources, sb_strdup(argv[i]));
         }
 
 #ifdef MAKE_EMBEDDED
@@ -267,14 +266,14 @@ main(int argc, char **argv)
     if (input_stdin)
         sources = blogc_read_stdin_to_list(sources);
 
-    if (!listing && bc_slist_length(sources) == 0) {
+    if (!listing && sb_slist_length(sources) == 0) {
         blogc_print_usage();
         fprintf(stderr, "blogc: error: one source file is required\n");
         rv = 3;
         goto cleanup;
     }
 
-    if (!listing && bc_slist_length(sources) > 1) {
+    if (!listing && sb_slist_length(sources) > 1) {
         blogc_print_usage();
         fprintf(stderr, "blogc: error: only one source file should be provided, "
             "if running without '-l'\n");
@@ -282,17 +281,17 @@ main(int argc, char **argv)
         goto cleanup;
     }
 
-    bc_error_t *err = NULL;
+    sb_error_t *err = NULL;
 
-    bc_slist_t *s = blogc_source_parse_from_files(config, sources, &err);
+    sb_slist_t *s = blogc_source_parse_from_files(config, sources, &err);
     if (err != NULL) {
-        bc_error_print(err, "blogc");
+        blogc_error_print(err);
         rv = 3;
         goto cleanup2;
     }
 
     if (print != NULL) {
-        const char *val = bc_trie_lookup(config, print);
+        const char *val = sb_trie_lookup(config, print);
         if (val == NULL) {
             fprintf(stderr, "blogc: error: configuration variable not found: %s\n",
                 print);
@@ -311,9 +310,9 @@ main(int argc, char **argv)
         goto cleanup2;
     }
 
-    bc_slist_t* l = blogc_template_parse_from_file(template, &err);
+    sb_slist_t* l = blogc_template_parse_from_file(template, &err);
     if (err != NULL) {
-        bc_error_print(err, "blogc");
+        blogc_error_print(err);
         rv = 3;
         goto cleanup3;
     }
@@ -348,13 +347,13 @@ cleanup4:
 cleanup3:
     blogc_template_free_ast(l);
 cleanup2:
-    bc_slist_free_full(s, (bc_free_func_t) bc_trie_free);
-    bc_error_free(err);
+    sb_slist_free_full(s, (sb_free_func_t) sb_trie_free);
+    sb_error_free(err);
 cleanup:
-    bc_trie_free(config);
+    sb_trie_free(config);
     free(template);
     free(output);
     free(print);
-    bc_slist_free_full(sources, free);
+    sb_slist_free_full(sources, free);
     return rv;
 }
diff --git a/src/blogc/renderer.c b/src/blogc/renderer.c
index 73edf9a..3c77e50 100644
--- a/src/blogc/renderer.c
+++ b/src/blogc/renderer.c
@@ -11,66 +11,67 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <squareball.h>
+
 #include "datetime-parser.h"
+#include "error.h"
 #include "template-parser.h"
 #include "renderer.h"
-#include "../common/error.h"
-#include "../common/utils.h"
 
 
 const char*
-blogc_get_variable(const char *name, bc_trie_t *global, bc_trie_t *local)
+blogc_get_variable(const char *name, sb_trie_t *global, sb_trie_t *local)
 {
     const char *rv = NULL;
     if (local != NULL) {
-        rv = bc_trie_lookup(local, name);
+        rv = sb_trie_lookup(local, name);
         if (rv != NULL)
             return rv;
     }
     if (global != NULL)
-        rv = bc_trie_lookup(global, name);
+        rv = sb_trie_lookup(global, name);
     return rv;
 }
 
 
 char*
-blogc_format_date(const char *date, bc_trie_t *global, bc_trie_t *local)
+blogc_format_date(const char *date, sb_trie_t *global, sb_trie_t *local)
 {
     const char *date_format = blogc_get_variable("DATE_FORMAT", global, local);
     if (date == NULL)
         return NULL;
     if (date_format == NULL)
-        return bc_strdup(date);
+        return sb_strdup(date);
 
-    bc_error_t *err = NULL;
+    sb_error_t *err = NULL;
     char *rv = blogc_convert_datetime(date, date_format, &err);
     if (err != NULL) {
-        bc_error_print(err, "blogc");
-        bc_error_free(err);
-        return bc_strdup(date);
+        blogc_error_print(err);
+        sb_error_free(err);
+        return sb_strdup(date);
     }
     return rv;
 }
 
 
 char*
-blogc_format_variable(const char *name, bc_trie_t *global, bc_trie_t *local,
-    bc_slist_t *foreach_var)
+blogc_format_variable(const char *name, sb_trie_t *global, sb_trie_t *local,
+    sb_slist_t *foreach_var)
 {
     // if used asked for a variable that exists, just return it right away
     const char *value = blogc_get_variable(name, global, local);
     if (value != NULL)
-        return bc_strdup(value);
+        return sb_strdup(value);
 
     // do the same for special variable 'FOREACH_ITEM'
     if (0 == strcmp(name, "FOREACH_ITEM")) {
         if (foreach_var != NULL && foreach_var->data != NULL) {
-            return bc_strdup(foreach_var->data);
+            return sb_strdup(foreach_var->data);
         }
         return NULL;
     }
 
-    char *var = bc_strdup(name);
+    char *var = sb_strdup(name);
 
     size_t i;
     size_t last = strlen(var);
@@ -95,7 +96,7 @@ blogc_format_variable(const char *name, bc_trie_t *global, bc_trie_t *local,
 
     bool must_format = false;
 
-    if (bc_str_ends_with(var, "_FORMATTED")) {
+    if (sb_str_ends_with(var, "_FORMATTED")) {
         var[strlen(var) - 10] = '\0';
         must_format = true;
     }
@@ -114,23 +115,23 @@ blogc_format_variable(const char *name, bc_trie_t *global, bc_trie_t *local,
     char *rv = NULL;
 
     if (must_format) {
-        if (bc_str_starts_with(name, "DATE_")) {
+        if (sb_str_starts_with(name, "DATE_")) {
             rv = blogc_format_date(value, global, local);
         }
         else {
             fprintf(stderr, "warning: no formatter found for '%s', "
                 "ignoring.\n", var);
-            rv = bc_strdup(value);
+            rv = sb_strdup(value);
         }
     }
     else {
-        rv = bc_strdup(value);
+        rv = sb_strdup(value);
     }
 
     free(var);
 
     if (len > 0) {
-        char *tmp = bc_strndup(rv, len);
+        char *tmp = sb_strndup(rv, len);
         free(rv);
         rv = tmp;
     }
@@ -139,19 +140,19 @@ blogc_format_variable(const char *name, bc_trie_t *global, bc_trie_t *local,
 }
 
 
-bc_slist_t*
-blogc_split_list_variable(const char *name, bc_trie_t *global, bc_trie_t *local)
+sb_slist_t*
+blogc_split_list_variable(const char *name, sb_trie_t *global, sb_trie_t *local)
 {
     const char *value = blogc_get_variable(name, global, local);
     if (value == NULL)
         return NULL;
 
-    bc_slist_t *rv = NULL;
+    sb_slist_t *rv = NULL;
 
-    char **tmp = bc_str_split(value, ' ', 0);
+    char **tmp = sb_str_split(value, ' ', 0);
     for (size_t i = 0; tmp[i] != NULL; i++) {
         if (tmp[i][0] != '\0')  // ignore empty strings
-            rv = bc_slist_append(rv, tmp[i]);
+            rv = sb_slist_append(rv, tmp[i]);
         else
             free(tmp[i]);
     }
@@ -162,25 +163,25 @@ blogc_split_list_variable(const char *name, bc_trie_t *global, bc_trie_t *local)
 
 
 char*
-blogc_render(bc_slist_t *tmpl, bc_slist_t *sources, bc_trie_t *config, bool listing)
+blogc_render(sb_slist_t *tmpl, sb_slist_t *sources, sb_trie_t *config, bool listing)
 {
     if (tmpl == NULL)
         return NULL;
 
-    bc_slist_t *current_source = NULL;
-    bc_slist_t *listing_start = NULL;
+    sb_slist_t *current_source = NULL;
+    sb_slist_t *listing_start = NULL;
 
-    bc_string_t *str = bc_string_new();
+    sb_string_t *str = sb_string_new();
 
-    bc_trie_t *tmp_source = NULL;
+    sb_trie_t *tmp_source = NULL;
     char *config_value = NULL;
     char *defined = NULL;
 
     size_t if_count = 0;
 
-    bc_slist_t *foreach_var = NULL;
-    bc_slist_t *foreach_var_start = NULL;
-    bc_slist_t *foreach_start = NULL;
+    sb_slist_t *foreach_var = NULL;
+    sb_slist_t *foreach_var_start = NULL;
+    sb_slist_t *foreach_start = NULL;
 
     bool if_not = false;
     bool inside_block = false;
@@ -189,7 +190,7 @@ blogc_render(bc_slist_t *tmpl, bc_slist_t *sources, bc_trie_t *config, bool list
 
     int cmp = 0;
 
-    bc_slist_t *tmp = tmpl;
+    sb_slist_t *tmp = tmpl;
     while (tmp != NULL) {
         blogc_template_node_t *node = tmp->data;
 
@@ -197,7 +198,7 @@ blogc_render(bc_slist_t *tmpl, bc_slist_t *sources, bc_trie_t *config, bool list
 
             case BLOGC_TEMPLATE_NODE_CONTENT:
                 if (node->data[0] != NULL)
-                    bc_string_append(str, node->data[0]);
+                    sb_string_append(str, node->data[0]);
                 break;
 
             case BLOGC_TEMPLATE_NODE_BLOCK:
@@ -254,7 +255,7 @@ blogc_render(bc_slist_t *tmpl, bc_slist_t *sources, bc_trie_t *config, bool list
                     config_value = blogc_format_variable(node->data[0],
                         config, inside_block ? tmp_source : NULL, foreach_var);
                     if (config_value != NULL) {
-                        bc_string_append(str, config_value);
+                        sb_string_append(str, config_value);
                         free(config_value);
                         config_value = NULL;
                         break;
@@ -296,7 +297,7 @@ blogc_render(bc_slist_t *tmpl, bc_slist_t *sources, bc_trie_t *config, bool list
                             (node->data[1][0] == '"') &&
                             (node->data[1][strlen(node->data[1]) - 1] == '"'))
                         {
-                            defined2 = bc_strndup(node->data[1] + 1,
+                            defined2 = sb_strndup(node->data[1] + 1,
                                 strlen(node->data[1]) - 2);
                         }
                         else {
@@ -445,7 +446,7 @@ blogc_render(bc_slist_t *tmpl, bc_slist_t *sources, bc_trie_t *config, bool list
                     }
                 }
                 foreach_start = NULL;
-                bc_slist_free_full(foreach_var_start, free);
+                sb_slist_free_full(foreach_var_start, free);
                 foreach_var_start = NULL;
                 break;
         }
@@ -455,5 +456,5 @@ blogc_render(bc_slist_t *tmpl, bc_slist_t *sources, bc_trie_t *config, bool list
     // no need to free temporary variables here. the template parser makes sure
     // that templates are sane and statements are closed.
 
-    return bc_string_free(str, false);
+    return sb_string_free(str, false);
 }
diff --git a/src/blogc/renderer.h b/src/blogc/renderer.h
index 4685caf..eb2b93f 100644
--- a/src/blogc/renderer.h
+++ b/src/blogc/renderer.h
@@ -10,15 +10,15 @@
 #define _RENDERER_H
 
 #include <stdbool.h>
-#include "../common/utils.h"
+#include <squareball.h>
 
-const char* blogc_get_variable(const char *name, bc_trie_t *global, bc_trie_t *local);
-char* blogc_format_date(const char *date, bc_trie_t *global, bc_trie_t *local);
-char* blogc_format_variable(const char *name, bc_trie_t *global, bc_trie_t *local,
-    bc_slist_t *foreach_var);
-bc_slist_t* blogc_split_list_variable(const char *name, bc_trie_t *global,
-    bc_trie_t *local);
-char* blogc_render(bc_slist_t *tmpl, bc_slist_t *sources, bc_trie_t *config,
+const char* blogc_get_variable(const char *name, sb_trie_t *global, sb_trie_t *local);
+char* blogc_format_date(const char *date, sb_trie_t *global, sb_trie_t *local);
+char* blogc_format_variable(const char *name, sb_trie_t *global, sb_trie_t *local,
+    sb_slist_t *foreach_var);
+sb_slist_t* blogc_split_list_variable(const char *name, sb_trie_t *global,
+    sb_trie_t *local);
+char* blogc_render(sb_slist_t *tmpl, sb_slist_t *sources, sb_trie_t *config,
     bool listing);
 
 #endif /* _RENDERER_H */
diff --git a/src/blogc/source-parser.c b/src/blogc/source-parser.c
index cabc033..5cb2863 100644
--- a/src/blogc/source-parser.c
+++ b/src/blogc/source-parser.c
@@ -8,11 +8,11 @@
 
 #include <stdlib.h>
 #include <string.h>
+#include <squareball.h>
 
 #include "content-parser.h"
+#include "error.h"
 #include "source-parser.h"
-#include "../common/error.h"
-#include "../common/utils.h"
 
 
 typedef enum {
@@ -26,8 +26,8 @@ typedef enum {
 } blogc_source_parser_state_t;
 
 
-bc_trie_t*
-blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
+sb_trie_t*
+blogc_source_parse(const char *src, size_t src_len, sb_error_t **err)
 {
     if (err == NULL || *err != NULL)
         return NULL;
@@ -39,7 +39,7 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
     char *key = NULL;
     char *tmp = NULL;
     char *content = NULL;
-    bc_trie_t *rv = bc_trie_new(free);
+    sb_trie_t *rv = sb_trie_new(free);
 
     blogc_source_parser_state_t state = SOURCE_START;
 
@@ -60,7 +60,7 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
                     state = SOURCE_SEPARATOR;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
                     current,
                     "Can't find a configuration key or the content separator.");
                 break;
@@ -69,7 +69,7 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
                 if ((c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_')
                     break;
                 if (c == ':') {
-                    key = bc_strndup(src + start, current - start);
+                    key = sb_strndup(src + start, current - start);
                     if (((current - start == 8) &&
                          (0 == strncmp("FILENAME", src + start, 8))) ||
                         ((current - start == 7) &&
@@ -93,7 +93,7 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
                         ((current - start == 13) &&
                          (0 == strncmp("BLOGC_VERSION", src + start, 13))))
                     {
-                        *err = bc_error_new_printf(BLOGC_ERROR_SOURCE_PARSER,
+                        *err = sb_error_new_printf(BLOGC_ERROR_SOURCE_PARSER,
                             "'%s' variable is forbidden in source files. It will "
                             "be set for you by the compiler.", key);
                         break;
@@ -101,7 +101,7 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
                     state = SOURCE_CONFIG_VALUE_START;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
                     current, "Invalid configuration key.");
                 break;
 
@@ -111,7 +111,7 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
                     start = current;
                     break;
                 }
-                bc_trie_insert(rv, key, bc_strdup(""));
+                sb_trie_insert(rv, key, sb_strdup(""));
                 free(key);
                 key = NULL;
                 state = SOURCE_START;
@@ -119,8 +119,8 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
 
             case SOURCE_CONFIG_VALUE:
                 if (c == '\n' || c == '\r') {
-                    tmp = bc_strndup(src + start, current - start);
-                    bc_trie_insert(rv, key, bc_strdup(bc_str_strip(tmp)));
+                    tmp = sb_strndup(src + start, current - start);
+                    sb_trie_insert(rv, key, sb_strdup(sb_str_strip(tmp)));
                     free(tmp);
                     free(key);
                     key = NULL;
@@ -135,7 +135,7 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
                     state = SOURCE_CONTENT_START;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
                     current,
                     "Invalid content separator. Must be more than one '-' characters.");
                 break;
@@ -149,18 +149,18 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
 
             case SOURCE_CONTENT:
                 if (current == (src_len - 1)) {
-                    tmp = bc_strndup(src + start, src_len - start);
-                    bc_trie_insert(rv, "RAW_CONTENT", tmp);
+                    tmp = sb_strndup(src + start, src_len - start);
+                    sb_trie_insert(rv, "RAW_CONTENT", tmp);
                     char *first_header = NULL;
                     char *description = NULL;
                     content = blogc_content_parse(tmp, &end_excerpt,
                         &first_header, &description);
                     if (first_header != NULL) {
                         // do not override source-provided first_header.
-                        if (NULL == bc_trie_lookup(rv, "FIRST_HEADER")) {
+                        if (NULL == sb_trie_lookup(rv, "FIRST_HEADER")) {
                             // no need to free, because we are transfering memory
                             // ownership to the trie.
-                            bc_trie_insert(rv, "FIRST_HEADER", first_header);
+                            sb_trie_insert(rv, "FIRST_HEADER", first_header);
                         }
                         else {
                             free(first_header);
@@ -168,18 +168,18 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
                     }
                     if (description != NULL) {
                         // do not override source-provided description.
-                        if (NULL == bc_trie_lookup(rv, "DESCRIPTION")) {
+                        if (NULL == sb_trie_lookup(rv, "DESCRIPTION")) {
                             // no need to free, because we are transfering memory
                             // ownership to the trie.
-                            bc_trie_insert(rv, "DESCRIPTION", description);
+                            sb_trie_insert(rv, "DESCRIPTION", description);
                         }
                         else {
                             free(description);
                         }
                     }
-                    bc_trie_insert(rv, "CONTENT", content);
-                    bc_trie_insert(rv, "EXCERPT", end_excerpt == 0 ?
-                        bc_strdup(content) : bc_strndup(content, end_excerpt));
+                    sb_trie_insert(rv, "CONTENT", content);
+                    sb_trie_insert(rv, "EXCERPT", end_excerpt == 0 ?
+                        sb_strdup(content) : sb_strndup(content, end_excerpt));
                 }
                 break;
         }
@@ -190,28 +190,28 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
         current++;
     }
 
-    if (*err == NULL && bc_trie_size(rv) == 0) {
+    if (*err == NULL && sb_trie_size(rv) == 0) {
 
         // ok, nothing found in the config trie, but no error set either.
         // let's try to be nice with the users and provide some reasonable
         // output. :)
         switch (state) {
             case SOURCE_START:
-                *err = bc_error_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
                     current, "Your source file is empty.");
                 break;
             case SOURCE_CONFIG_KEY:
-                *err = bc_error_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
                     current, "Your last configuration key is missing ':' and "
                     "the value");
                 break;
             case SOURCE_CONFIG_VALUE_START:
-                *err = bc_error_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
                     current, "Configuration value not provided for '%s'.",
                     key);
                 break;
             case SOURCE_CONFIG_VALUE:
-                *err = bc_error_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_SOURCE_PARSER, src, src_len,
                     current, "No line ending after the configuration value for "
                     "'%s'.", key);
                 break;
@@ -224,7 +224,7 @@ blogc_source_parse(const char *src, size_t src_len, bc_error_t **err)
 
     if (*err != NULL) {
         free(key);
-        bc_trie_free(rv);
+        sb_trie_free(rv);
         return NULL;
     }
 
diff --git a/src/blogc/source-parser.h b/src/blogc/source-parser.h
index da2509e..d0a95a9 100644
--- a/src/blogc/source-parser.h
+++ b/src/blogc/source-parser.h
@@ -10,10 +10,9 @@
 #define _SOURCE_PARSER_H
 
 #include <stddef.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
 
-bc_trie_t* blogc_source_parse(const char *src, size_t src_len,
-    bc_error_t **err);
+sb_trie_t* blogc_source_parse(const char *src, size_t src_len,
+    sb_error_t **err);
 
 #endif /* _SOURCE_PARSER_H */
diff --git a/src/blogc/template-parser.c b/src/blogc/template-parser.c
index b085a33..f73cd53 100644
--- a/src/blogc/template-parser.c
+++ b/src/blogc/template-parser.c
@@ -9,10 +9,10 @@
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
+#include <squareball.h>
 
+#include "error.h"
 #include "template-parser.h"
-#include "../common/error.h"
-#include "../common/utils.h"
 
 
 typedef enum {
@@ -41,8 +41,8 @@ typedef enum {
 } blogc_template_parser_state_t;
 
 
-bc_slist_t*
-blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
+sb_slist_t*
+blogc_template_parse(const char *src, size_t src_len, sb_error_t **err)
 {
     if (err == NULL || *err != NULL)
         return NULL;
@@ -63,7 +63,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
     bool foreach_open = false;
     bool block_foreach_open = false;
 
-    bc_slist_t *ast = NULL;
+    sb_slist_t *ast = NULL;
     blogc_template_node_t *node = NULL;
 
     /*
@@ -94,21 +94,21 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
 
             case TEMPLATE_START:
                 if (last) {
-                    node = bc_malloc(sizeof(blogc_template_node_t));
+                    node = sb_malloc(sizeof(blogc_template_node_t));
                     node->type = type;
                     if (lstrip_next) {
-                        tmp = bc_strndup(src + start, src_len - start);
-                        node->data[0] = bc_strdup(bc_str_lstrip(tmp));
+                        tmp = sb_strndup(src + start, src_len - start);
+                        node->data[0] = sb_strdup(sb_str_lstrip(tmp));
                         free(tmp);
                         tmp = NULL;
                         lstrip_next = false;
                     }
                     else {
-                        node->data[0] = bc_strndup(src + start, src_len - start);
+                        node->data[0] = sb_strndup(src + start, src_len - start);
                     }
                     node->op = 0;
                     node->data[1] = NULL;
-                    ast = bc_slist_append(ast, node);
+                    ast = sb_slist_append(ast, node);
                     previous = node;
                     node = NULL;
                 }
@@ -125,21 +125,21 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     else
                         state = TEMPLATE_VARIABLE_START;
                     if (end > start) {
-                        node = bc_malloc(sizeof(blogc_template_node_t));
+                        node = sb_malloc(sizeof(blogc_template_node_t));
                         node->type = type;
                         if (lstrip_next) {
-                            tmp = bc_strndup(src + start, end - start);
-                            node->data[0] = bc_strdup(bc_str_lstrip(tmp));
+                            tmp = sb_strndup(src + start, end - start);
+                            node->data[0] = sb_strdup(sb_str_lstrip(tmp));
                             free(tmp);
                             tmp = NULL;
                             lstrip_next = false;
                         }
                         else {
-                            node->data[0] = bc_strndup(src + start, end - start);
+                            node->data[0] = sb_strndup(src + start, end - start);
                         }
                         node->op = 0;
                         node->data[1] = NULL;
-                        ast = bc_slist_append(ast, node);
+                        ast = sb_slist_append(ast, node);
                         previous = node;
                         node = NULL;
                     }
@@ -153,7 +153,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     if ((previous != NULL) &&
                         (previous->type == BLOGC_TEMPLATE_NODE_CONTENT))
                     {
-                        previous->data[0] = bc_str_rstrip(previous->data[0]);  // does not need copy
+                        previous->data[0] = sb_str_rstrip(previous->data[0]);  // does not need copy
                     }
                     state = TEMPLATE_BLOCK_START;
                     break;
@@ -169,13 +169,13 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     break;
                 }
                 if (c == '-') {
-                    *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                    *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                         src_len, current,
                         "Invalid statement syntax. Duplicated whitespace "
                         "cleaner before statement.");
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid statement syntax. Must begin with lowercase letter.");
                 break;
@@ -195,7 +195,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                             block_foreach_open = foreach_open;
                             break;
                         }
-                        *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER,
+                        *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER,
                             src, src_len, current, "Blocks can't be nested.");
                         break;
                     }
@@ -204,14 +204,14 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     {
                         if (block_open) {
                             if (if_count != block_if_count) {
-                                *err = bc_error_new_printf(BLOGC_ERROR_TEMPLATE_PARSER,
+                                *err = sb_error_new_printf(BLOGC_ERROR_TEMPLATE_PARSER,
                                     "%d open 'if', 'ifdef' and/or 'ifndef' statements "
                                     "were not closed inside a '%s' block!",
                                     if_count - block_if_count, block_type);
                                 break;
                             }
                             if (!block_foreach_open && foreach_open) {
-                                *err = bc_error_new_printf(BLOGC_ERROR_TEMPLATE_PARSER,
+                                *err = sb_error_new_printf(BLOGC_ERROR_TEMPLATE_PARSER,
                                     "An open 'foreach' statement was not closed "
                                     "inside a '%s' block!", block_type);
                                 break;
@@ -221,7 +221,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                             block_open = false;
                             break;
                         }
-                        *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER,
+                        *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER,
                             src, src_len, current,
                             "'endblock' statement without an open 'block' statement.");
                         break;
@@ -268,13 +268,13 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                                 else_open = true;
                                 break;
                             }
-                            *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER,
+                            *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER,
                                 src, src_len, current,
                                 "More than one 'else' statement for an open 'if', "
                                 "'ifdef' or 'ifndef' statement.");
                             break;
                         }
-                        *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER,
+                        *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER,
                             src, src_len, current,
                             "'else' statement without an open 'if', 'ifdef' or "
                             "'ifndef' statement.");
@@ -292,7 +292,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                             else_open = false;
                             break;
                         }
-                        *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER,
+                        *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER,
                             src, src_len, current,
                             "'endif' statement without an open 'if', 'ifdef' or "
                             "'ifndef' statement.");
@@ -308,7 +308,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                             foreach_open = true;
                             break;
                         }
-                        *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER,
+                        *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER,
                             src, src_len, current, "'foreach' statements can't "
                             "be nested.");
                         break;
@@ -324,14 +324,14 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                             foreach_open = false;
                             break;
                         }
-                        *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER,
+                        *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER,
                             src, src_len, current,
                             "'endforeach' statement without an open 'foreach' "
                             "statement.");
                         break;
                     }
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid statement type: Allowed types are: 'block', "
                     "'endblock', 'if', 'ifdef', 'ifndef', 'else', 'endif', "
@@ -346,7 +346,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     start = current;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid block syntax. Must begin with lowercase letter.");
                 break;
@@ -380,7 +380,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                         break;
                     }
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid block type. Allowed types are: 'entry', 'listing' "
                     "and 'listing_once'.");
@@ -394,7 +394,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     start = current;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid variable name. Must begin with uppercase letter.");
                 break;
@@ -410,7 +410,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                         state = TEMPLATE_BLOCK_END_WHITESPACE_CLEANER;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid variable name. Must be uppercase letter, number "
                     "or '_'.");
@@ -446,7 +446,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                 }
                 op_start = 0;
                 op_end = 0;
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid 'if' operand. Must be double-quoted static "
                     "string or variable.");
@@ -476,7 +476,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     start = current;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid foreach variable name. Must begin with uppercase "
                     "letter.");
@@ -490,7 +490,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     state = TEMPLATE_BLOCK_END_WHITESPACE_CLEANER;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid foreach variable name. Must be uppercase letter, "
                     "number or '_'.");
@@ -512,13 +512,13 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     break;
                 }
                 if (c == '-') {
-                    *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                    *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                         src_len, current,
                         "Invalid statement syntax. Duplicated whitespace "
                         "cleaner after statement.");
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid statement syntax. Must end with '%%}'.");
                 break;
@@ -532,7 +532,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     start = current;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid variable name. Must begin with uppercase letter.");
                 break;
@@ -550,7 +550,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     state = TEMPLATE_CLOSE_BRACKET;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid variable name. Must be uppercase letter, number "
                     "or '_'.");
@@ -563,7 +563,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     state = TEMPLATE_CLOSE_BRACKET;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid statement syntax. Must end with '}}'.");
                 break;
@@ -589,7 +589,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                                 tmp_op = BLOGC_TEMPLATE_OP_NEQ;
                         }
                         if (tmp_op == 0) {
-                            *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER,
+                            *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER,
                                 src, src_len, op_start,
                                 "Invalid 'if' operator. Must be '<', '>', "
                                 "'<=', '>=', '==' or '!='.");
@@ -600,21 +600,21 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                         op_start = 0;
                         op_end = 0;
                     }
-                    node = bc_malloc(sizeof(blogc_template_node_t));
+                    node = sb_malloc(sizeof(blogc_template_node_t));
                     node->type = type;
                     node->op = tmp_op;
                     node->data[0] = NULL;
                     node->data[1] = NULL;
                     if (end > start)
-                        node->data[0] = bc_strndup(src + start, end - start);
+                        node->data[0] = sb_strndup(src + start, end - start);
                     if (end2 > start2) {
-                        node->data[1] = bc_strndup(src + start2, end2 - start2);
+                        node->data[1] = sb_strndup(src + start2, end2 - start2);
                         start2 = 0;
                         end2 = 0;
                     }
                     if (type == BLOGC_TEMPLATE_NODE_BLOCK)
                         block_type = node->data[0];
-                    ast = bc_slist_append(ast, node);
+                    ast = sb_slist_append(ast, node);
                     previous = node;
                     node = NULL;
                     state = TEMPLATE_START;
@@ -622,7 +622,7 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
                     start = current + 1;
                     break;
                 }
-                *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
+                *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src,
                     src_len, current,
                     "Invalid statement syntax. Must end with '}'.");
                 break;
@@ -637,17 +637,17 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
 
     if (*err == NULL) {
         if (state == TEMPLATE_BLOCK_IF_STRING_OPERAND)
-            *err = bc_error_parser(BLOGC_ERROR_TEMPLATE_PARSER, src, src_len,
+            *err = sb_error_new_printf_parser(BLOGC_ERROR_TEMPLATE_PARSER, src, src_len,
                 start2, "Found an open double-quoted string.");
         else if (if_count != 0)
-            *err = bc_error_new_printf(BLOGC_ERROR_TEMPLATE_PARSER,
+            *err = sb_error_new_printf(BLOGC_ERROR_TEMPLATE_PARSER,
                 "%d open 'if', 'ifdef' and/or 'ifndef' statements were not closed!",
                 if_count);
         else if (block_open)
-            *err = bc_error_new(BLOGC_ERROR_TEMPLATE_PARSER,
+            *err = sb_error_new(BLOGC_ERROR_TEMPLATE_PARSER,
                 "An open block was not closed!");
         else if (foreach_open)
-            *err = bc_error_new(BLOGC_ERROR_TEMPLATE_PARSER,
+            *err = sb_error_new(BLOGC_ERROR_TEMPLATE_PARSER,
                 "An open 'foreach' statement was not closed!");
     }
 
@@ -665,9 +665,9 @@ blogc_template_parse(const char *src, size_t src_len, bc_error_t **err)
 
 
 void
-blogc_template_free_ast(bc_slist_t *ast)
+blogc_template_free_ast(sb_slist_t *ast)
 {
-    for (bc_slist_t *tmp = ast; tmp != NULL; tmp = tmp->next) {
+    for (sb_slist_t *tmp = ast; tmp != NULL; tmp = tmp->next) {
         blogc_template_node_t *data = tmp->data;
         if (data == NULL)
             continue;
@@ -675,5 +675,5 @@ blogc_template_free_ast(bc_slist_t *ast)
         free(data->data[1]);
         free(data);
     }
-    bc_slist_free(ast);
+    sb_slist_free(ast);
 }
diff --git a/src/blogc/template-parser.h b/src/blogc/template-parser.h
index d08ccd9..0b73bc4 100644
--- a/src/blogc/template-parser.h
+++ b/src/blogc/template-parser.h
@@ -10,8 +10,7 @@
 #define _TEMPLATE_PARSER_H
 
 #include <stddef.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
 
 /*
  * note: whitespace cleaners are NOT added to AST. we fix strings right during
@@ -48,11 +47,11 @@ typedef struct {
     // 2 slots to store node data.
     char *data[2];
 
-    bc_slist_t *childs;
+    sb_slist_t *childs;
 } blogc_template_node_t;
 
-bc_slist_t* blogc_template_parse(const char *src, size_t src_len,
-    bc_error_t **err);
-void blogc_template_free_ast(bc_slist_t *ast);
+sb_slist_t* blogc_template_parse(const char *src, size_t src_len,
+    sb_error_t **err);
+void blogc_template_free_ast(sb_slist_t *ast);
 
 #endif /* _TEMPLATE_PARSER_H */