aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/blogc-git-receiver/main.c1
-rw-r--r--src/blogc-git-receiver/post-receive.c41
-rw-r--r--src/blogc-git-receiver/post-receive.h4
-rw-r--r--src/blogc-git-receiver/pre-receive-parser.c5
-rw-r--r--src/blogc-git-receiver/pre-receive.c32
-rw-r--r--src/blogc-git-receiver/shell-command-parser.c13
-rw-r--r--src/blogc-git-receiver/shell.c13
-rw-r--r--src/blogc-make/atom.c21
-rw-r--r--src/blogc-make/atom.h5
-rw-r--r--src/blogc-make/ctx.c80
-rw-r--r--src/blogc-make/ctx.h14
-rw-r--r--src/blogc-make/error.c36
-rw-r--r--src/blogc-make/error.h20
-rw-r--r--src/blogc-make/exec-native.c31
-rw-r--r--src/blogc-make/exec-native.h5
-rw-r--r--src/blogc-make/exec.c156
-rw-r--r--src/blogc-make/exec.h12
-rw-r--r--src/blogc-make/main.c23
-rw-r--r--src/blogc-make/reloader.c7
-rw-r--r--src/blogc-make/reloader.h9
-rw-r--r--src/blogc-make/rules.c323
-rw-r--r--src/blogc-make/rules.h19
-rw-r--r--src/blogc-make/settings.c71
-rw-r--r--src/blogc-make/settings.h11
-rw-r--r--src/blogc-runserver/httpd-utils.c21
-rw-r--r--src/blogc-runserver/httpd.c31
-rw-r--r--src/blogc-runserver/main.c17
-rw-r--r--src/blogc-runserver/mime.c5
-rw-r--r--src/blogc/content-parser.c336
-rw-r--r--src/blogc/datetime-parser.c64
-rw-r--r--src/blogc/datetime-parser.h4
-rw-r--r--src/blogc/debug.c6
-rw-r--r--src/blogc/debug.h4
-rw-r--r--src/blogc/error.c39
-rw-r--r--src/blogc/error.h21
-rw-r--r--src/blogc/loader.c118
-rw-r--r--src/blogc/loader.h11
-rw-r--r--src/blogc/main.c71
-rw-r--r--src/blogc/renderer.c81
-rw-r--r--src/blogc/renderer.h16
-rw-r--r--src/blogc/source-parser.c56
-rw-r--r--src/blogc/source-parser.h7
-rw-r--r--src/blogc/template-parser.c106
-rw-r--r--src/blogc/template-parser.h11
-rw-r--r--src/common/config-parser.c431
-rw-r--r--src/common/config-parser.h31
-rw-r--r--src/common/error.c152
-rw-r--r--src/common/error.h46
-rw-r--r--src/common/file.c66
-rw-r--r--src/common/file.h20
-rw-r--r--src/common/stdin.c24
-rw-r--r--src/common/stdin.h14
-rw-r--r--src/common/utf8.c102
-rw-r--r--src/common/utf8.h21
-rw-r--r--src/common/utils.c667
-rw-r--r--src/common/utils.h107
56 files changed, 1051 insertions, 2607 deletions
diff --git a/src/blogc-git-receiver/main.c b/src/blogc-git-receiver/main.c
index c18bb14..76d3bdb 100644
--- a/src/blogc-git-receiver/main.c
+++ b/src/blogc-git-receiver/main.c
@@ -9,6 +9,7 @@
#include <stdio.h>
#include <string.h>
#include <libgen.h>
+
#include "shell.h"
#include "pre-receive.h"
#include "post-receive.h"
diff --git a/src/blogc-git-receiver/post-receive.c b/src/blogc-git-receiver/post-receive.c
index 3593bb5..a422b43 100644
--- a/src/blogc-git-receiver/post-receive.c
+++ b/src/blogc-git-receiver/post-receive.c
@@ -12,34 +12,31 @@
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
-#include "../common/utils.h"
-#include "../common/config-parser.h"
-#include "../common/error.h"
-#include "../common/file.h"
+#include <squareball.h>
char*
-bgr_post_receive_get_config_section(bc_config_t *config, const char *repo_path,
+bgr_post_receive_get_config_section(sb_config_t *config, const char *repo_path,
const char *home)
{
char *rv = NULL;
- char** sections = bc_config_list_sections(config);
+ char** sections = sb_config_list_sections(config);
for (size_t i = 0; sections[i] != NULL; i++) {
- if (bc_str_starts_with(sections[i], "repo:")) {
- char *tmp_repo = bc_strdup_printf("%s/repos/%s", home, sections[i] + 5);
+ if (sb_str_starts_with(sections[i], "repo:")) {
+ char *tmp_repo = sb_strdup_printf("%s/repos/%s", home, sections[i] + 5);
char *real_tmp_repo = realpath(tmp_repo, NULL); // maybe not needed
free(tmp_repo);
if (real_tmp_repo == NULL)
continue;
if (0 == strcmp(real_tmp_repo, repo_path)) {
- rv = bc_strdup(sections[i]);
+ rv = sb_strdup(sections[i]);
free(real_tmp_repo);
break;
}
free(real_tmp_repo);
}
}
- bc_strv_free(sections);
+ sb_strv_free(sections);
return rv;
}
@@ -57,7 +54,7 @@ bgr_post_receive_hook(int argc, char *argv[])
return 3;
}
- char *repo_path = bc_strdup(dirname(real_hooks_dir));
+ char *repo_path = sb_strdup(dirname(real_hooks_dir));
free(real_hooks_dir);
if (0 != chdir(repo_path)) {
fprintf(stderr, "error: failed to change to repository root\n");
@@ -72,7 +69,7 @@ bgr_post_receive_hook(int argc, char *argv[])
if ((0 == system("git config --local remote.mirror.pushurl > /dev/null")) ||
(0 == system("git config --local remote.mirror.url > /dev/null")))
{
- mirror = bc_strdup("mirror");
+ mirror = sb_strdup("mirror");
goto push;
}
@@ -83,7 +80,7 @@ bgr_post_receive_hook(int argc, char *argv[])
goto cleanup;
}
- char *config_file = bc_strdup_printf("%s/blogc-git-receiver.ini", home);
+ char *config_file = sb_strdup_printf("%s/blogc-git-receiver.ini", home);
if ((0 != access(config_file, F_OK))) {
fprintf(stderr, "warning: repository mirroring disabled\n");
free(config_file);
@@ -91,23 +88,23 @@ bgr_post_receive_hook(int argc, char *argv[])
}
size_t len;
- bc_error_t *err = NULL;
- char* config_content = bc_file_get_contents(config_file, true, &len, &err);
+ sb_error_t *err = NULL;
+ char* config_content = sb_file_get_contents_utf8(config_file, &len, &err);
if (err != NULL) {
fprintf(stderr, "warning: failed to read configuration file (%s), "
"mirroring disabled: %s\n", config_file, err->msg);
- bc_error_free(err);
+ sb_error_free(err);
free(config_file);
free(config_content);
goto cleanup;
}
- bc_config_t *config = bc_config_parse(config_content, len, NULL, &err);
+ sb_config_t *config = sb_config_parse(config_content, len, NULL, &err);
free(config_content);
if (err != NULL) {
fprintf(stderr, "warning: failed to parse configuration file (%s), "
"mirroring disabled: %s\n", config_file, err->msg);
- bc_error_free(err);
+ sb_error_free(err);
free(config_file);
goto cleanup;
}
@@ -117,13 +114,13 @@ bgr_post_receive_hook(int argc, char *argv[])
home);
if (config_section == NULL) {
fprintf(stderr, "warning: repository mirroring disabled\n");
- bc_config_free(config);
+ sb_config_free(config);
goto cleanup;
}
- mirror = bc_strdup(bc_config_get(config, config_section, "mirror"));
+ mirror = sb_strdup(sb_config_get(config, config_section, "mirror"));
free(config_section);
- bc_config_free(config);
+ sb_config_free(config);
if (mirror == NULL) {
fprintf(stderr, "warning: repository mirroring disabled\n");
@@ -133,7 +130,7 @@ bgr_post_receive_hook(int argc, char *argv[])
push:
{
- char *git_cmd = bc_strdup_printf("git push --mirror %s", mirror);
+ char *git_cmd = sb_strdup_printf("git push --mirror %s", mirror);
if (0 != system(git_cmd))
fprintf(stderr, "warning: failed push to git mirror\n");
free(git_cmd);
diff --git a/src/blogc-git-receiver/post-receive.h b/src/blogc-git-receiver/post-receive.h
index 97f7c82..2b549b1 100644
--- a/src/blogc-git-receiver/post-receive.h
+++ b/src/blogc-git-receiver/post-receive.h
@@ -9,9 +9,9 @@
#ifndef _POST_RECEIVE_H
#define _POST_RECEIVE_H
-#include "../common/config-parser.h"
+#include <squareball.h>
-char* bgr_post_receive_get_config_section(bc_config_t *config,
+char* bgr_post_receive_get_config_section(sb_config_t *config,
const char *repo_path, const char *home);
int bgr_post_receive_hook(int argc, char *argv[]);
diff --git a/src/blogc-git-receiver/pre-receive-parser.c b/src/blogc-git-receiver/pre-receive-parser.c
index b379903..a335daa 100644
--- a/src/blogc-git-receiver/pre-receive-parser.c
+++ b/src/blogc-git-receiver/pre-receive-parser.c
@@ -8,7 +8,8 @@
#include <stdlib.h>
#include <string.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "pre-receive-parser.h"
typedef enum {
@@ -67,7 +68,7 @@ bgr_pre_receive_parse(const char *input)
if ((current - start == 17) &&
(0 == strncmp("refs/heads/master", input + start, 17)))
{
- return bc_strndup(input + start_new, start - 1 - start_new);
+ return sb_strndup(input + start_new, start - 1 - start_new);
}
break;
}
diff --git a/src/blogc-git-receiver/pre-receive.c b/src/blogc-git-receiver/pre-receive.c
index e8ac1d3..b785e6d 100644
--- a/src/blogc-git-receiver/pre-receive.c
+++ b/src/blogc-git-receiver/pre-receive.c
@@ -15,8 +15,8 @@
#include <dirent.h>
#include <time.h>
#include <libgen.h>
-#include "../common/utils.h"
-#include "../common/stdin.h"
+#include <squareball.h>
+
#include "pre-receive-parser.h"
#include "pre-receive.h"
@@ -56,7 +56,7 @@ rmdir_recursive(const char *dir)
while (NULL != (e = readdir(d))) {
if ((0 == strcmp(e->d_name, ".")) || (0 == strcmp(e->d_name, "..")))
continue;
- char *f = bc_strdup_printf("%s/%s", dir, e->d_name);
+ char *f = sb_strdup_printf("%s/%s", dir, e->d_name);
if (0 != stat(f, &buf)) {
fprintf(stderr, "error: failed to stat directory entry (%s): %s\n",
e->d_name, strerror(errno));
@@ -102,7 +102,7 @@ bgr_pre_receive_hook(int argc, char *argv[])
return 3;
}
- char *repo_dir = bc_strdup(dirname(real_hooks_dir));
+ char *repo_dir = sb_strdup(dirname(real_hooks_dir));
free(real_hooks_dir);
if (0 != chdir(repo_dir)) {
fprintf(stderr, "error: failed to change to repository root\n");
@@ -111,7 +111,7 @@ bgr_pre_receive_hook(int argc, char *argv[])
}
if (NULL == getenv("GIT_DIR")) {
- char *htdocs_sym = bc_strdup_printf("%s/htdocs", repo_dir);
+ char *htdocs_sym = sb_strdup_printf("%s/htdocs", repo_dir);
if (0 != access(htdocs_sym, R_OK)) {
fprintf(stderr, "error: no previous build found. nothing to "
"rebuild.\n");
@@ -127,20 +127,20 @@ bgr_pre_receive_hook(int argc, char *argv[])
rv = 3;
goto cleanup;
}
- char **pieces = bc_str_split(basename(build_dir), '-', 2);
+ char **pieces = sb_str_split(basename(build_dir), '-', 2);
free(build_dir);
- if (bc_strv_length(pieces) != 2) {
+ if (sb_strv_length(pieces) != 2) {
fprintf(stderr, "error: failed to parse the hash of last built "
"commit.\n");
- bc_strv_free(pieces);
+ sb_strv_free(pieces);
rv = 3;
goto cleanup;
}
- master = bc_strdup(pieces[0]);
- bc_strv_free(pieces);
+ master = sb_strdup(pieces[0]);
+ sb_strv_free(pieces);
}
else {
- char *input = bc_stdin_read();
+ char *input = sb_stdin_get_contents();
master = bgr_pre_receive_parse(input);
free(input);
}
@@ -158,7 +158,7 @@ bgr_pre_receive_hook(int argc, char *argv[])
}
tmpdir = dir;
- char *git_archive_cmd = bc_strdup_printf(
+ char *git_archive_cmd = sb_strdup_printf(
"git archive \"%s\" | tar -x -C \"%s\" -f -", master, tmpdir);
if (0 != system(git_archive_cmd)) {
fprintf(stderr, "error: failed to extract git content to temporary "
@@ -184,11 +184,11 @@ bgr_pre_receive_hook(int argc, char *argv[])
}
unsigned long epoch = time(NULL);
- output_dir = bc_strdup_printf("%s/builds/%s-%lu", home, master, epoch);
+ output_dir = sb_strdup_printf("%s/builds/%s-%lu", home, master, epoch);
if (0 == access(output_dir, F_OK)) {
char *tmp = output_dir;
- output_dir = bc_strdup_printf("%s-", tmp);
+ output_dir = sb_strdup_printf("%s-", tmp);
free(tmp);
}
@@ -202,7 +202,7 @@ bgr_pre_receive_hook(int argc, char *argv[])
rv = 3;
goto cleanup;
}
- build_cmd = bc_strdup_printf("OUTPUT_DIR=\"%s\" blogc-make -V all",
+ build_cmd = sb_strdup_printf("OUTPUT_DIR=\"%s\" blogc-make -V all",
output_dir);
}
else if ((0 == access("Makefile", F_OK)) || (0 == access("GNUMakefile", F_OK))) {
@@ -224,7 +224,7 @@ bgr_pre_receive_hook(int argc, char *argv[])
rv = 3;
goto cleanup;
}
- build_cmd = bc_strdup_printf(
+ build_cmd = sb_strdup_printf(
"%s -j%d OUTPUT_DIR=\"%s\" BLOGC_GIT_RECEIVER=1", make_impl,
cpu_count(), output_dir);
}
diff --git a/src/blogc-git-receiver/shell-command-parser.c b/src/blogc-git-receiver/shell-command-parser.c
index 05a68fd..842c67a 100644
--- a/src/blogc-git-receiver/shell-command-parser.c
+++ b/src/blogc-git-receiver/shell-command-parser.c
@@ -9,7 +9,8 @@
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "shell-command-parser.h"
typedef enum {
@@ -28,7 +29,7 @@ bgr_shell_command_parse(const char *command)
size_t start = 0;
size_t command_len = strlen(command);
- bc_string_t *rv = bc_string_new();
+ sb_string_t *rv = sb_string_new();
for (size_t current = 0; current < command_len; current++) {
@@ -76,7 +77,7 @@ bgr_shell_command_parse(const char *command)
case START_ESCAPED:
if (c == '!' || c == '\'') {
- bc_string_append_c(rv, c);
+ sb_string_append_c(rv, c);
state = START_REPO;
break;
}
@@ -84,7 +85,7 @@ bgr_shell_command_parse(const char *command)
case REPO:
if (c == '\'') {
- bc_string_append_len(rv, command + start, current - start);
+ sb_string_append_len(rv, command + start, current - start);
state = START_REPO;
break;
}
@@ -93,9 +94,9 @@ bgr_shell_command_parse(const char *command)
}
if (rv->len > 0)
- return bc_string_free(rv, false);
+ return sb_string_free(rv, false);
error:
- bc_string_free(rv, true);
+ sb_string_free(rv, true);
return NULL;
}
diff --git a/src/blogc-git-receiver/shell.c b/src/blogc-git-receiver/shell.c
index 1ad8f20..8ed08d0 100644
--- a/src/blogc-git-receiver/shell.c
+++ b/src/blogc-git-receiver/shell.c
@@ -13,7 +13,8 @@
#include <unistd.h>
#include <errno.h>
#include <sys/stat.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "shell-command-parser.h"
#include "shell.h"
@@ -50,15 +51,15 @@ bgr_shell(int argc, char *argv[])
goto cleanup;
}
- repo = bc_strdup_printf("%s/repos/%s", home, tmp_repo);
- quoted_repo = bc_shell_quote(repo);
+ repo = sb_strdup_printf("%s/repos/%s", home, tmp_repo);
+ quoted_repo = sb_shell_quote(repo);
free(tmp_repo);
if (0 == strncmp(argv[2], "git-upload-", 11)) // no need to check len here
goto git_exec;
if (0 != access(repo, F_OK)) {
- char *git_init_cmd = bc_strdup_printf(
+ char *git_init_cmd = sb_strdup_printf(
"git init --bare %s > /dev/null", quoted_repo);
if (0 != system(git_init_cmd)) {
fprintf(stderr, "error: failed to create git repository: %s\n",
@@ -136,9 +137,9 @@ git_exec:
goto cleanup;
}
- // static allocation instead of bc_strdup_printf to avoid leaks
+ // static allocation instead of sb_strdup_printf to avoid leaks
char buffer[4096];
- char *command = bc_strdup(argv[2]);
+ char *command = sb_strdup(argv[2]);
char *p;
for (p = command; *p != ' ' && *p != '\0'; p++);
if (*p == ' ')
diff --git a/src/blogc-make/atom.c b/src/blogc-make/atom.c
index d5f5387..327d39b 100644
--- a/src/blogc-make/atom.c
+++ b/src/blogc-make/atom.c
@@ -10,8 +10,9 @@
#include <string.h>
#include <errno.h>
#include <unistd.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
+#include "error.h"
#include "settings.h"
#include "atom.h"
@@ -49,7 +50,7 @@ static const char atom_template[] =
char*
-bm_atom_deploy(bm_settings_t *settings, bc_error_t **err)
+bm_atom_deploy(bm_settings_t *settings, sb_error_t **err)
{
if (err == NULL || *err != NULL)
return NULL;
@@ -58,20 +59,20 @@ bm_atom_deploy(bm_settings_t *settings, bc_error_t **err)
char fname[] = "/tmp/blogc-make_XXXXXX";
int fd;
if (-1 == (fd = mkstemp(fname))) {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_ATOM,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_ATOM,
"Failed to create temporary atom template: %s", strerror(errno));
return NULL;
}
- const char *atom_prefix = bc_trie_lookup(settings->settings, "atom_prefix");
- const char *atom_ext = bc_trie_lookup(settings->settings, "atom_ext");
- const char *post_prefix = bc_trie_lookup(settings->settings, "post_prefix");
+ const char *atom_prefix = sb_trie_lookup(settings->settings, "atom_prefix");
+ const char *atom_ext = sb_trie_lookup(settings->settings, "atom_ext");
+ const char *post_prefix = sb_trie_lookup(settings->settings, "post_prefix");
- char *content = bc_strdup_printf(atom_template, atom_prefix, atom_ext,
+ char *content = sb_strdup_printf(atom_template, atom_prefix, atom_ext,
atom_prefix, atom_ext, post_prefix, post_prefix);
if (-1 == write(fd, content, strlen(content))) {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_ATOM,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_ATOM,
"Failed to write to temporary atom template: %s", strerror(errno));
free(content);
close(fd);
@@ -82,7 +83,7 @@ bm_atom_deploy(bm_settings_t *settings, bc_error_t **err)
free(content);
close(fd);
- return bc_strdup(fname);
+ return sb_strdup(fname);
}
diff --git a/src/blogc-make/atom.h b/src/blogc-make/atom.h
index 9f47adc..0bf8bdb 100644
--- a/src/blogc-make/atom.h
+++ b/src/blogc-make/atom.h
@@ -9,10 +9,11 @@
#ifndef _MAKE_ATOM_H
#define _MAKE_ATOM_H
-#include "../common/error.h"
+#include <squareball.h>
+
#include "settings.h"
-char* bm_atom_deploy(bm_settings_t *settings, bc_error_t **err);
+char* bm_atom_deploy(bm_settings_t *settings, sb_error_t **err);
void bm_atom_destroy(const char *fname);
#endif /* _MAKE_ATOM_H */
diff --git a/src/blogc-make/ctx.c b/src/blogc-make/ctx.c
index 0a3f9a0..2784268 100644
--- a/src/blogc-make/ctx.c
+++ b/src/blogc-make/ctx.c
@@ -14,10 +14,10 @@
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
-#include "../common/error.h"
-#include "../common/file.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "atom.h"
+#include "error.h"
#include "settings.h"
#include "exec.h"
#include "ctx.h"
@@ -30,13 +30,13 @@ bm_filectx_new(bm_ctx_t *ctx, const char *filename, const char *slug,
if (ctx == NULL || filename == NULL)
return NULL;
- char *f = filename[0] == '/' ? bc_strdup(filename) :
- bc_strdup_printf("%s/%s", ctx->root_dir, filename);
+ char *f = filename[0] == '/' ? sb_strdup(filename) :
+ sb_strdup_printf("%s/%s", ctx->root_dir, filename);
- bm_filectx_t *rv = bc_malloc(sizeof(bm_filectx_t));
+ bm_filectx_t *rv = sb_malloc(sizeof(bm_filectx_t));
rv->path = f;
- rv->short_path = bc_strdup(filename);
- rv->slug = bc_strdup(slug);
+ rv->short_path = sb_strdup(filename);
+ rv->slug = sb_strdup(slug);
if (st == NULL) {
struct stat buf;
@@ -59,14 +59,14 @@ bm_filectx_new(bm_ctx_t *ctx, const char *filename, const char *slug,
}
-bc_slist_t*
-bm_filectx_new_r(bc_slist_t *l, bm_ctx_t *ctx, const char *filename)
+sb_slist_t*
+bm_filectx_new_r(sb_slist_t *l, bm_ctx_t *ctx, const char *filename)
{
if (ctx == NULL || filename == NULL)
return NULL;
- char *f = filename[0] == '/' ? bc_strdup(filename) :
- bc_strdup_printf("%s/%s", ctx->root_dir, filename);
+ char *f = filename[0] == '/' ? sb_strdup(filename) :
+ sb_strdup_printf("%s/%s", ctx->root_dir, filename);
struct stat buf;
if (0 != stat(f, &buf)) {
@@ -85,7 +85,7 @@ bm_filectx_new_r(bc_slist_t *l, bm_ctx_t *ctx, const char *filename)
while (NULL != (e = readdir(dir))) {
if ((0 == strcmp(e->d_name, ".")) || (0 == strcmp(e->d_name, "..")))
continue;
- char *tmp = bc_strdup_printf("%s/%s", filename, e->d_name);
+ char *tmp = sb_strdup_printf("%s/%s", filename, e->d_name);
l = bm_filectx_new_r(l, ctx, tmp);
free(tmp);
}
@@ -95,7 +95,7 @@ bm_filectx_new_r(bc_slist_t *l, bm_ctx_t *ctx, const char *filename)
return l;
}
- l = bc_slist_append(l, bm_filectx_new(ctx, filename, NULL, &buf));
+ l = sb_slist_append(l, bm_filectx_new(ctx, filename, NULL, &buf));
free(f);
return l;
}
@@ -164,13 +164,13 @@ bm_filectx_free(bm_filectx_t *fctx)
bm_ctx_t*
bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
- bc_error_t **err)
+ sb_error_t **err)
{
if (settings_file == NULL || err == NULL || *err != NULL)
return NULL;
size_t content_len;
- char *content = bc_file_get_contents(settings_file, true, &content_len,
+ char *content = sb_file_get_contents_utf8(settings_file, &content_len,
err);
if (*err != NULL)
return NULL;
@@ -189,7 +189,7 @@ bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
bm_ctx_t *rv = NULL;
if (base == NULL) {
- rv = bc_malloc(sizeof(bm_ctx_t));
+ rv = sb_malloc(sizeof(bm_ctx_t));
rv->blogc = bm_exec_find_binary(argv0, "blogc", "BLOGC");
rv->blogc_runserver = bm_exec_find_binary(argv0, "blogc-runserver",
"BLOGC_RUNSERVER");
@@ -208,39 +208,39 @@ bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
free(real_filename);
const char *output_dir = getenv("OUTPUT_DIR");
- rv->short_output_dir = bc_strdup(output_dir != NULL ? output_dir : "_build");
+ rv->short_output_dir = sb_strdup(output_dir != NULL ? output_dir : "_build");
if (rv->short_output_dir[0] == '/') {
- rv->output_dir = bc_strdup(rv->short_output_dir);
+ rv->output_dir = sb_strdup(rv->short_output_dir);
}
else {
- rv->output_dir = bc_strdup_printf("%s/%s", rv->root_dir,
+ rv->output_dir = sb_strdup_printf("%s/%s", rv->root_dir,
rv->short_output_dir);
}
// can't return null and set error after this!
- const char *template_dir = bc_trie_lookup(settings->settings,
+ const char *template_dir = sb_trie_lookup(settings->settings,
"template_dir");
- char *main_template = bc_strdup_printf("%s/%s", template_dir,
- bc_trie_lookup(settings->settings, "main_template"));
+ char *main_template = sb_strdup_printf("%s/%s", template_dir,
+ sb_trie_lookup(settings->settings, "main_template"));
rv->main_template_fctx = bm_filectx_new(rv, main_template, NULL, NULL);
free(main_template);
rv->atom_template_fctx = bm_filectx_new(rv, atom_template, NULL, NULL);
free(atom_template);
- const char *content_dir = bc_trie_lookup(settings->settings, "content_dir");
- const char *post_prefix = bc_trie_lookup(settings->settings, "post_prefix");
- const char *source_ext = bc_trie_lookup(settings->settings, "source_ext");
+ const char *content_dir = sb_trie_lookup(settings->settings, "content_dir");
+ const char *post_prefix = sb_trie_lookup(settings->settings, "post_prefix");
+ const char *source_ext = sb_trie_lookup(settings->settings, "source_ext");
rv->posts_fctx = NULL;
if (settings->posts != NULL) {
for (size_t i = 0; settings->posts[i] != NULL; i++) {
- char *f = bc_strdup_printf("%s/%s/%s%s", content_dir, post_prefix,
+ char *f = sb_strdup_printf("%s/%s/%s%s", content_dir, post_prefix,
settings->posts[i], source_ext);
- rv->posts_fctx = bc_slist_append(rv->posts_fctx,
+ rv->posts_fctx = sb_slist_append(rv->posts_fctx,
bm_filectx_new(rv, f, settings->posts[i], NULL));
free(f);
}
@@ -249,9 +249,9 @@ bm_ctx_new(bm_ctx_t *base, const char *settings_file, const char *argv0,
rv->pages_fctx = NULL;
if (settings->pages != NULL) {
for (size_t i = 0; settings->pages[i] != NULL; i++) {
- char *f = bc_strdup_printf("%s/%s%s", content_dir,
+ char *f = sb_strdup_printf("%s/%s%s", content_dir,
settings->pages[i], source_ext);
- rv->pages_fctx = bc_slist_append(rv->pages_fctx,
+ rv->pages_fctx = sb_slist_append(rv->pages_fctx,
bm_filectx_new(rv, f, settings->pages[i], NULL));
free(f);
}
@@ -281,13 +281,13 @@ bm_ctx_reload(bm_ctx_t **ctx)
// files
// needs to dup path, because it may be freed when reloading.
- char *tmp = bc_strdup((*ctx)->settings_fctx->path);
- bc_error_t *err = NULL;
+ char *tmp = sb_strdup((*ctx)->settings_fctx->path);
+ sb_error_t *err = NULL;
*ctx = bm_ctx_new(*ctx, tmp, NULL, &err);
free(tmp);
if (err != NULL) {
- bc_error_print(err, "blogc-make");
- bc_error_free(err);
+ bm_error_print(err);
+ sb_error_free(err);
return false;
}
return true;
@@ -296,13 +296,13 @@ bm_ctx_reload(bm_ctx_t **ctx)
bm_filectx_reload((*ctx)->main_template_fctx);
bm_filectx_reload((*ctx)->atom_template_fctx);
- for (bc_slist_t *tmp = (*ctx)->posts_fctx; tmp != NULL; tmp = tmp->next)
+ for (sb_slist_t *tmp = (*ctx)->posts_fctx; tmp != NULL; tmp = tmp->next)
bm_filectx_reload((bm_filectx_t*) tmp->data);
- for (bc_slist_t *tmp = (*ctx)->pages_fctx; tmp != NULL; tmp = tmp->next)
+ for (sb_slist_t *tmp = (*ctx)->pages_fctx; tmp != NULL; tmp = tmp->next)
bm_filectx_reload((bm_filectx_t*) tmp->data);
- for (bc_slist_t *tmp = (*ctx)->copy_fctx; tmp != NULL; tmp = tmp->next)
+ for (sb_slist_t *tmp = (*ctx)->copy_fctx; tmp != NULL; tmp = tmp->next)
bm_filectx_reload((bm_filectx_t*) tmp->data);
return true;
@@ -334,11 +334,11 @@ bm_ctx_free_internal(bm_ctx_t *ctx)
bm_filectx_free(ctx->settings_fctx);
ctx->settings_fctx = NULL;
- bc_slist_free_full(ctx->posts_fctx, (bc_free_func_t) bm_filectx_free);
+ sb_slist_free_full(ctx->posts_fctx, (sb_free_func_t) bm_filectx_free);
ctx->posts_fctx = NULL;
- bc_slist_free_full(ctx->pages_fctx, (bc_free_func_t) bm_filectx_free);
+ sb_slist_free_full(ctx->pages_fctx, (sb_free_func_t) bm_filectx_free);
ctx->pages_fctx = NULL;
- bc_slist_free_full(ctx->copy_fctx, (bc_free_func_t) bm_filectx_free);
+ sb_slist_free_full(ctx->copy_fctx, (sb_free_func_t) bm_filectx_free);
ctx->copy_fctx = NULL;
}
diff --git a/src/blogc-make/ctx.h b/src/blogc-make/ctx.h
index 2adfc94..70691b5 100644
--- a/src/blogc-make/ctx.h
+++ b/src/blogc-make/ctx.h
@@ -12,9 +12,9 @@
#include <sys/stat.h>
#include <stdbool.h>
#include <time.h>
+#include <squareball.h>
+
#include "settings.h"
-#include "../common/error.h"
-#include "../common/utils.h"
#ifdef __APPLE__
#define st_mtim_tv_sec st_mtimespec.tv_sec
@@ -60,19 +60,19 @@ typedef struct {
bm_filectx_t *atom_template_fctx;
bm_filectx_t *settings_fctx;
- bc_slist_t *posts_fctx;
- bc_slist_t *pages_fctx;
- bc_slist_t *copy_fctx;
+ sb_slist_t *posts_fctx;
+ sb_slist_t *pages_fctx;
+ sb_slist_t *copy_fctx;
} bm_ctx_t;
bm_filectx_t* bm_filectx_new(bm_ctx_t *ctx, const char *filename, const char *slug,
struct stat *st);
-bc_slist_t* bm_filectx_new_r(bc_slist_t *l, bm_ctx_t *ctx, const char *filename);
+sb_slist_t* bm_filectx_new_r(sb_slist_t *l, bm_ctx_t *ctx, const char *filename);
bool bm_filectx_changed(bm_filectx_t *ctx, time_t *tv_sec, long *tv_nsec);
void bm_filectx_reload(bm_filectx_t *ctx);
void bm_filectx_free(bm_filectx_t *fctx);
bm_ctx_t* bm_ctx_new(bm_ctx_t *base, const char *settings_file,
- const char *argv0, bc_error_t **err);
+ const char *argv0, sb_error_t **err);
bool bm_ctx_reload(bm_ctx_t **ctx);
void bm_ctx_free_internal(bm_ctx_t *ctx);
void bm_ctx_free(bm_ctx_t *ctx);
diff --git a/src/blogc-make/error.c b/src/blogc-make/error.c
new file mode 100644
index 0000000..f02f5ea
--- /dev/null
+++ b/src/blogc-make/error.c
@@ -0,0 +1,36 @@
+/*
+ * 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
+bm_error_print(sb_error_t *err)
+{
+ if (err == NULL)
+ return;
+
+ fprintf(stderr, "blogc-make: ");
+
+ switch((bm_error_type_t) err->code) {
+ case BLOGC_MAKE_ERROR_SETTINGS:
+ fprintf(stderr, "error: settings: %s\n", err->msg);
+ break;
+ case BLOGC_MAKE_ERROR_EXEC:
+ fprintf(stderr, "error: exec: %s\n", err->msg);
+ break;
+ case BLOGC_MAKE_ERROR_ATOM:
+ fprintf(stderr, "error: atom: %s\n", err->msg);
+ break;
+ default:
+ fprintf(stderr, "error: %s\n", err->msg);
+ }
+}
diff --git a/src/blogc-make/error.h b/src/blogc-make/error.h
new file mode 100644
index 0000000..52f9326
--- /dev/null
+++ b/src/blogc-make/error.h
@@ -0,0 +1,20 @@
+/*
+ * 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 _MAKE_ERROR_H
+#define _MAKE_ERROR_H
+
+typedef enum {
+ BLOGC_MAKE_ERROR_SETTINGS = 100,
+ BLOGC_MAKE_ERROR_EXEC,
+ BLOGC_MAKE_ERROR_ATOM,
+} bm_error_type_t;
+
+void bm_error_print(sb_error_t *err);
+
+#endif /* _MAKE_ERROR_H */
diff --git a/src/blogc-make/exec-native.c b/src/blogc-make/exec-native.c
index ae5517d..1b517ff 100644
--- a/src/blogc-make/exec-native.c
+++ b/src/blogc-make/exec-native.c
@@ -16,12 +16,13 @@
#include <unistd.h>
#include <libgen.h>
#include <errno.h>
-#include "../common/error.h"
-#include "../common/file.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "exec-native.h"
#include "ctx.h"
+#define BM_FILE_CHUNK_SIZE 1024
+
int
bm_exec_native_cp(bm_filectx_t *source, bm_filectx_t *dest, bool verbose)
@@ -32,7 +33,7 @@ bm_exec_native_cp(bm_filectx_t *source, bm_filectx_t *dest, bool verbose)
printf(" COPY %s\n", dest->short_path);
fflush(stdout);
- char *fname = bc_strdup(dest->path);
+ char *fname = sb_strdup(dest->path);
for (char *tmp = fname; *tmp != '\0'; tmp++) {
if (*tmp != '/' && *tmp != '\\')
continue;
@@ -67,8 +68,8 @@ bm_exec_native_cp(bm_filectx_t *source, bm_filectx_t *dest, bool verbose)
}
ssize_t nread;
- char buffer[BC_FILE_CHUNK_SIZE];
- while (0 < (nread = read(fd_from, buffer, BC_FILE_CHUNK_SIZE))) {
+ char buffer[BM_FILE_CHUNK_SIZE];
+ while (0 < (nread = read(fd_from, buffer, BM_FILE_CHUNK_SIZE))) {
char *out_ptr = buffer;
do {
ssize_t nwritten = write(fd_to, out_ptr, nread);
@@ -89,7 +90,7 @@ bm_exec_native_cp(bm_filectx_t *source, bm_filectx_t *dest, bool verbose)
bool
-bm_exec_native_is_empty_dir(const char *dir, bc_error_t **err)
+bm_exec_native_is_empty_dir(const char *dir, sb_error_t **err)
{
DIR *d = opendir(dir);
if (d == NULL) {
@@ -97,7 +98,7 @@ bm_exec_native_is_empty_dir(const char *dir, bc_error_t **err)
return true;
}
if (err != NULL) {
- *err = bc_error_new_printf(0, "failed to open directory (%s): %s\n",
+ *err = sb_error_new_printf(0, "failed to open directory (%s): %s\n",
dir, strerror(errno));
}
return true;
@@ -114,7 +115,7 @@ bm_exec_native_is_empty_dir(const char *dir, bc_error_t **err)
if (0 != closedir(d)) {
if (err != NULL) {
- *err = bc_error_new_printf(0, "failed to close directory (%s): %s\n",
+ *err = sb_error_new_printf(0, "failed to close directory (%s): %s\n",
dir, strerror(errno));
}
return true;
@@ -143,16 +144,16 @@ bm_exec_native_rm(const char *output_dir, bm_filectx_t *dest, bool verbose)
// blame freebsd's libc for all of those memory allocations around dirname
// calls!
- char *short_dir = bc_strdup(dirname(dest->short_path));
- char *dir = bc_strdup(dirname(dest->path));
+ char *short_dir = sb_strdup(dirname(dest->short_path));
+ char *dir = sb_strdup(dirname(dest->path));
- bc_error_t *err = NULL;
+ sb_error_t *err = NULL;
while ((0 != strcmp(short_dir, ".")) && (0 != strcmp(short_dir, "/"))) {
bool empty = bm_exec_native_is_empty_dir(dir, &err);
if (err != NULL) {
fprintf(stderr, "blogc-make: error: %s\n", err->msg);
- bc_error_free(err);
+ sb_error_free(err);
rv = 3;
break;
}
@@ -175,10 +176,10 @@ bm_exec_native_rm(const char *output_dir, bm_filectx_t *dest, bool verbose)
}
char *tmp = short_dir;
- short_dir = bc_strdup(dirname(short_dir));
+ short_dir = sb_strdup(dirname(short_dir));
free(tmp);
tmp = dir;
- dir = bc_strdup(dirname(dir));
+ dir = sb_strdup(dirname(dir));
free(tmp);
}
diff --git a/src/blogc-make/exec-native.h b/src/blogc-make/exec-native.h
index b6db3cc..fc264d2 100644
--- a/src/blogc-make/exec-native.h
+++ b/src/blogc-make/exec-native.h
@@ -10,11 +10,12 @@
#define _MAKE_EXEC_NATIVE_H
#include <stdbool.h>
-#include "../common/error.h"
+#include <squareball.h>
+
#include "ctx.h"
int bm_exec_native_cp(bm_filectx_t *source, bm_filectx_t *dest, bool verbose);
-bool bm_exec_native_is_empty_dir(const char *dir, bc_error_t **err);
+bool bm_exec_native_is_empty_dir(const char *dir, sb_error_t **err);
int bm_exec_native_rm(const char *output_dir, bm_filectx_t *dest, bool verbose);
#endif /* _MAKE_EXEC_NATIVE_H */
diff --git a/src/blogc-make/exec.c b/src/blogc-make/exec.c
index aaae523..5fa86f4 100644
--- a/src/blogc-make/exec.c
+++ b/src/blogc-make/exec.c
@@ -18,13 +18,15 @@
#include <sys/wait.h>
#include <errno.h>
#include <libgen.h>
-#include "../common/error.h"
-#include "../common/file.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "ctx.h"
+#include "error.h"
#include "exec.h"
#include "settings.h"
+#define BM_FILE_CHUNK_SIZE 1024
+
char*
bm_exec_find_binary(const char *argv0, const char *bin, const char *env)
@@ -34,14 +36,14 @@ bm_exec_find_binary(const char *argv0, const char *bin, const char *env)
// argv0, because the static binary may not be named `blogc`, and we
// prefer to use our own `blogc` instead of some other version around.
if (argv0 != NULL && bin != NULL && (0 == strcmp(bin, "blogc"))) {
- return bc_shell_quote(argv0);
+ return sb_shell_quote(argv0);
}
#endif
// first try: env var
const char *env_bin = getenv(env);
if (env_bin != NULL) {
- return bc_shell_quote(env_bin);
+ return sb_shell_quote(env_bin);
}
// second try: same dir as current exec
@@ -53,13 +55,13 @@ bm_exec_find_binary(const char *argv0, const char *bin, const char *env)
// that relative paths will work as expected.
// - windows path sep is not supported
if (argv0 != NULL && (NULL != strchr(argv0, '/'))) {
- char *path = bc_strdup(argv0);
- char *dir = bc_strdup(dirname(path));
+ char *path = sb_strdup(argv0);
+ char *dir = sb_strdup(dirname(path));
free(path);
- char *tmp = bc_strdup_printf("%s/%s", dir, bin);
+ char *tmp = sb_strdup_printf("%s/%s", dir, bin);
free(dir);
if (0 == access(tmp, X_OK)) {
- char *rv = bc_shell_quote(tmp);
+ char *rv = sb_shell_quote(tmp);
free(tmp);
return rv;
}
@@ -67,27 +69,27 @@ bm_exec_find_binary(const char *argv0, const char *bin, const char *env)
}
// last try: $PATH
- return bc_strdup(bin);
+ return sb_strdup(bin);
}
int
bm_exec_command(const char *cmd, const char *input, char **output,
- char **error, bc_error_t **err)
+ char **error, sb_error_t **err)
{
if (err == NULL || *err != NULL)
return 3;
int fd_in[2];
if (-1 == pipe(fd_in)) {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
"Failed to create stdin pipe: %s", strerror(errno));
return 3;
}
int fd_out[2];
if (-1 == pipe(fd_out)) {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
"Failed to create stdout pipe: %s", strerror(errno));
close(fd_in[0]);
close(fd_in[1]);
@@ -96,7 +98,7 @@ bm_exec_command(const char *cmd, const char *input, char **output,
int fd_err[2];
if (-1 == pipe(fd_err)) {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
"Failed to create stderr pipe: %s", strerror(errno));
close(fd_in[0]);
close(fd_in[1]);
@@ -107,7 +109,7 @@ bm_exec_command(const char *cmd, const char *input, char **output,
pid_t pid = fork();
if (pid == -1) {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
"Failed to fork: %s", strerror(errno));
close(fd_in[0]);
close(fd_in[1]);
@@ -147,7 +149,7 @@ bm_exec_command(const char *cmd, const char *input, char **output,
if (input != NULL) {
if (-1 == write(fd_in[1], input, strlen(input))) {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
"Failed to write to stdin pipe: %s", strerror(errno));
close(fd_in[1]);
close(fd_out[0]);
@@ -158,44 +160,44 @@ bm_exec_command(const char *cmd, const char *input, char **output,
close(fd_in[1]);
- char buffer[BC_FILE_CHUNK_SIZE];
+ char buffer[BM_FILE_CHUNK_SIZE];
ssize_t s;
- bc_string_t *out = NULL;
- while(0 != (s = read(fd_out[0], buffer, BC_FILE_CHUNK_SIZE))) {
+ sb_string_t *out = NULL;
+ while(0 != (s = read(fd_out[0], buffer, BM_FILE_CHUNK_SIZE))) {
if (s == -1) {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
"Failed to read from stdout pipe: %s", strerror(errno));
close(fd_out[0]);
close(fd_err[0]);
- bc_string_free(out, true);
+ sb_string_free(out, true);
return 3;
}
if (out == NULL) {
- out = bc_string_new();
+ out = sb_string_new();
}
- bc_string_append_len(out, buffer, s);
+ sb_string_append_len(out, buffer, s);
}
if (out != NULL) {
- *output = bc_string_free(out, false);
+ *output = sb_string_free(out, false);
}
close(fd_out[0]);
out = NULL;
- while(0 != (s = read(fd_err[0], buffer, BC_FILE_CHUNK_SIZE))) {
+ while(0 != (s = read(fd_err[0], buffer, BM_FILE_CHUNK_SIZE))) {
if (s == -1) {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_EXEC,
"Failed to read from stderr pipe: %s", strerror(errno));
close(fd_err[0]);
- bc_string_free(out, true);
+ sb_string_free(out, true);
return 3;
}
if (out == NULL)
- out = bc_string_new();
- bc_string_append_len(out, buffer, s);
+ out = sb_string_new();
+ sb_string_append_len(out, buffer, s);
}
if (out != NULL) {
- *error = bc_string_free(out, false);
+ *error = sb_string_free(out, false);
}
close(fd_err[0]);
@@ -207,86 +209,86 @@ bm_exec_command(const char *cmd, const char *input, char **output,
static void
-list_variables(const char *key, const char *value, bc_string_t *str)
+list_variables(const char *key, const char *value, sb_string_t *str)
{
- char *tmp = bc_shell_quote(value);
- bc_string_append_printf(str, " -D %s=%s", key, tmp);
+ char *tmp = sb_shell_quote(value);
+ sb_string_append_printf(str, " -D %s=%s", key, tmp);
free(tmp);
}
char*
bm_exec_build_blogc_cmd(const char *blogc_bin, bm_settings_t *settings,
- bc_trie_t *global_variables, bc_trie_t *local_variables, bool listing,
+ sb_trie_t *global_variables, sb_trie_t *local_variables, bool listing,
const char *template, const char *output, bool dev, bool sources_stdin)
{
- bc_string_t *rv = bc_string_new();
+ sb_string_t *rv = sb_string_new();
const char *locale = NULL;
if (settings != NULL) {
- locale = bc_trie_lookup(settings->settings, "locale");
+ locale = sb_trie_lookup(settings->settings, "locale");
}
if (locale != NULL) {
- char *tmp = bc_shell_quote(locale);
- bc_string_append_printf(rv, "LC_ALL=%s ", tmp);
+ char *tmp = sb_shell_quote(locale);
+ sb_string_append_printf(rv, "LC_ALL=%s ", tmp);
free(tmp);
}
- bc_string_append(rv, blogc_bin);
+ sb_string_append(rv, blogc_bin);
if (settings != NULL) {
if (settings->tags != NULL) {
- char *tags = bc_strv_join(settings->tags, " ");
- bc_string_append_printf(rv, " -D MAKE_TAGS='%s'", tags);
+ char *tags = sb_strv_join(settings->tags, " ");
+ sb_string_append_printf(rv, " -D MAKE_TAGS='%s'", tags);
free(tags);
}
- bc_trie_foreach(settings->global,
- (bc_trie_foreach_func_t) list_variables, rv);
+ sb_trie_foreach(settings->global,
+ (sb_trie_foreach_func_t) list_variables, rv);
}
- bc_trie_foreach(global_variables, (bc_trie_foreach_func_t) list_variables, rv);
- bc_trie_foreach(local_variables, (bc_trie_foreach_func_t) list_variables, rv);
+ sb_trie_foreach(global_variables, (sb_trie_foreach_func_t) list_variables, rv);
+ sb_trie_foreach(local_variables, (sb_trie_foreach_func_t) list_variables, rv);
if (dev) {
- bc_string_append(rv, " -D MAKE_ENV_DEV=1 -D MAKE_ENV='dev'");
+ sb_string_append(rv, " -D MAKE_ENV_DEV=1 -D MAKE_ENV='dev'");
}
if (listing) {
- bc_string_append(rv, " -l");
+ sb_string_append(rv, " -l");
}
if (template != NULL) {
- char *tmp = bc_shell_quote(template);
- bc_string_append_printf(rv, " -t %s", tmp);
+ char *tmp = sb_shell_quote(template);
+ sb_string_append_printf(rv, " -t %s", tmp);
free(tmp);
}
if (output != NULL) {
- char *tmp = bc_shell_quote(output);
- bc_string_append_printf(rv, " -o %s", tmp);
+ char *tmp = sb_shell_quote(output);
+ sb_string_append_printf(rv, " -o %s", tmp);
free(tmp);
}
if (sources_stdin) {
- bc_string_append(rv, " -i");
+ sb_string_append(rv, " -i");
}
- return bc_string_free(rv, false);
+ return sb_string_free(rv, false);
}
int
-bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables, bc_trie_t *local_variables,
- bool listing, bm_filectx_t *template, bm_filectx_t *output, bc_slist_t *sources,
+bm_exec_blogc(bm_ctx_t *ctx, sb_trie_t *global_variables, sb_trie_t *local_variables,
+ bool listing, bm_filectx_t *template, bm_filectx_t *output, sb_slist_t *sources,
bool only_first_source)
{
if (ctx == NULL)
return 3;
- bc_string_t *input = bc_string_new();
- for (bc_slist_t *l = sources; l != NULL; l = l->next) {
- bc_string_append_printf(input, "%s\n", ((bm_filectx_t*) l->data)->path);
+ sb_string_t *input = sb_string_new();
+ for (sb_slist_t *l = sources; l != NULL; l = l->next) {
+ sb_string_append_printf(input, "%s\n", ((bm_filectx_t*) l->data)->path);
if (only_first_source)
break;
}
@@ -303,7 +305,7 @@ bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables, bc_trie_t *local_varia
char *out = NULL;
char *err = NULL;
- bc_error_t *error = NULL;
+ sb_error_t *error = NULL;
int rv = bm_exec_command(cmd, input->str, &out, &err, &error);
@@ -312,12 +314,12 @@ bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables, bc_trie_t *local_varia
}
if (error != NULL) {
- bc_error_print(error, "blogc-make");
+ bm_error_print(error);
free(cmd);
free(out);
free(err);
- bc_string_free(input, true);
- bc_error_free(error);
+ sb_string_free(input, true);
+ sb_error_free(error);
return 3;
}
@@ -332,27 +334,27 @@ bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables, bc_trie_t *local_varia
"----------------------------->8-----------------------------\n"
"%s\n"
"----------------------------->8-----------------------------\n",
- bc_str_strip(input->str));
+ sb_str_strip(input->str));
}
if (out != NULL) {
fprintf(stderr, "\nSTDOUT:\n"
"----------------------------->8-----------------------------\n"
"%s\n"
"----------------------------->8-----------------------------\n",
- bc_str_strip(out));
+ sb_str_strip(out));
}
}
else {
fprintf(stderr,
"blogc-make: error: Failed to execute command (%d)", rv);
if (err != NULL) {
- fprintf(stderr, ":\n%s", bc_str_strip(err));
+ fprintf(stderr, ":\n%s", sb_str_strip(err));
}
fprintf(stderr, "\n");
}
}
- bc_string_free(input, true);
+ sb_string_free(input, true);
free(cmd);
free(out);
free(err);
@@ -368,30 +370,30 @@ bm_exec_blogc_runserver(bm_ctx_t *ctx, const char *host, const char *port,
if (ctx == NULL)
return 3;
- bc_string_t *cmd = bc_string_new();
+ sb_string_t *cmd = sb_string_new();
- bc_string_append(cmd, ctx->blogc_runserver);
+ sb_string_append(cmd, ctx->blogc_runserver);
if (host != NULL) {
- char *tmp = bc_shell_quote(host);
- bc_string_append_printf(cmd, " -t %s", tmp);
+ char *tmp = sb_shell_quote(host);
+ sb_string_append_printf(cmd, " -t %s", tmp);
free(tmp);
}
if (port != NULL) {
- char *tmp = bc_shell_quote(port);
- bc_string_append_printf(cmd, " -p %s", tmp);
+ char *tmp = sb_shell_quote(port);
+ sb_string_append_printf(cmd, " -p %s", tmp);
free(tmp);
}
if (threads != NULL) {
- char *tmp = bc_shell_quote(threads);
- bc_string_append_printf(cmd, " -m %s", tmp);
+ char *tmp = sb_shell_quote(threads);
+ sb_string_append_printf(cmd, " -m %s", tmp);
free(tmp);
}
- char *tmp = bc_shell_quote(ctx->output_dir);
- bc_string_append_printf(cmd, " %s", tmp);
+ char *tmp = sb_shell_quote(ctx->output_dir);
+ sb_string_append_printf(cmd, " %s", tmp);
free(tmp);
if (ctx->verbose)
@@ -403,7 +405,7 @@ bm_exec_blogc_runserver(bm_ctx_t *ctx, const char *host, const char *port,
// we don't need pipes to run blogc-runserver, because it is "interactive"
int status = system(cmd->str);
int rv = WEXITSTATUS(status);
- bc_string_free(cmd, true);
+ sb_string_free(cmd, true);
if (rv != 0 && rv != 130) {
if (rv == 127) {
diff --git a/src/blogc-make/exec.h b/src/blogc-make/exec.h
index 85f2a44..a2acd1b 100644
--- a/src/blogc-make/exec.h
+++ b/src/blogc-make/exec.h
@@ -10,19 +10,19 @@
#define _MAKE_EXEC_H
#include <stdbool.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "ctx.h"
#include "settings.h"
char* bm_exec_find_binary(const char *argv0, const char *bin, const char *env);
int bm_exec_command(const char *cmd, const char *input, char **output,
- char **error, bc_error_t **err);
+ char **error, sb_error_t **err);
char* bm_exec_build_blogc_cmd(const char *blogc_bin, bm_settings_t *settings,
- bc_trie_t *global_variables, bc_trie_t *local_variables, bool listing,
+ sb_trie_t *global_variables, sb_trie_t *local_variables, bool listing,
const char *template, const char *output, bool dev, bool sources_stdin);
-int bm_exec_blogc(bm_ctx_t *ctx, bc_trie_t *global_variables, bc_trie_t *local_variables,
- bool listing, bm_filectx_t *template, bm_filectx_t *output, bc_slist_t *sources,
+int bm_exec_blogc(bm_ctx_t *ctx, sb_trie_t *global_variables, sb_trie_t *local_variables,
+ bool listing, bm_filectx_t *template, bm_filectx_t *output, sb_slist_t *sources,
bool only_first_source);
int bm_exec_blogc_runserver(bm_ctx_t *ctx, const char *host, const char *port,
const char *threads);
diff --git a/src/blogc-make/main.c b/src/blogc-make/main.c
index 3ce1f8a..45a0613 100644
--- a/src/blogc-make/main.c
+++ b/src/blogc-make/main.c
@@ -14,9 +14,10 @@
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "ctx.h"
+#include "error.h"
#include "rules.h"
@@ -60,9 +61,9 @@ main(int argc, char **argv)
setlocale(LC_ALL, "");
int rv = 0;
- bc_error_t *err = NULL;
+ sb_error_t *err = NULL;
- bc_slist_t *rules = NULL;
+ sb_slist_t *rules = NULL;
bool verbose = false;
bool dev = false;
char *blogcfile = NULL;
@@ -85,9 +86,9 @@ main(int argc, char **argv)
break;
case 'f':
if (argv[i][2] != '\0')
- blogcfile = bc_strdup(argv[i] + 2);
+ blogcfile = sb_strdup(argv[i] + 2);
else if (i + 1 < argc)
- blogcfile = bc_strdup(argv[++i]);
+ blogcfile = sb_strdup(argv[++i]);
break;
#ifdef MAKE_EMBEDDED
case 'm':
@@ -103,18 +104,18 @@ main(int argc, char **argv)
}
}
else {
- rules = bc_slist_append(rules, bc_strdup(argv[i]));
+ rules = sb_slist_append(rules, sb_strdup(argv[i]));
}
}
if (rules == NULL) {
- rules = bc_slist_append(rules, bc_strdup("all"));
+ rules = sb_slist_append(rules, sb_strdup("all"));
}
ctx = bm_ctx_new(NULL, blogcfile ? blogcfile : "blogcfile",
argc > 0 ? argv[0] : NULL, &err);
if (err != NULL) {
- bc_error_print(err, "blogc-make");
+ bm_error_print(err);
rv = 3;
goto cleanup;
}
@@ -125,10 +126,10 @@ main(int argc, char **argv)
cleanup:
- bc_slist_free_full(rules, free);
+ sb_slist_free_full(rules, free);
free(blogcfile);
bm_ctx_free(ctx);
- bc_error_free(err);
+ sb_error_free(err);
return rv;
}
diff --git a/src/blogc-make/reloader.c b/src/blogc-make/reloader.c
index 6b30974..12ca202 100644
--- a/src/blogc-make/reloader.c
+++ b/src/blogc-make/reloader.c
@@ -11,7 +11,8 @@
#include <string.h>
#include <unistd.h>
#include <pthread.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "ctx.h"
#include "rules.h"
#include "reloader.h"
@@ -47,7 +48,7 @@ bm_reloader_thread(void *arg)
bm_reloader_t*
bm_reloader_new(bm_ctx_t *ctx, bm_rule_exec_func_t rule_exec,
- bc_slist_t *outputs, bc_trie_t *args)
+ sb_slist_t *outputs, sb_trie_t *args)
{
// first rule_exec call is syncronous, to do a 'sanity check'
if (0 != rule_exec(ctx, outputs, args))
@@ -70,7 +71,7 @@ bm_reloader_new(bm_ctx_t *ctx, bm_rule_exec_func_t rule_exec,
return NULL;
}
- bm_reloader_t *rv = bc_malloc(sizeof(bm_reloader_t));
+ bm_reloader_t *rv = sb_malloc(sizeof(bm_reloader_t));
rv->ctx = ctx;
rv->rule_exec = rule_exec;
rv->outputs = outputs;
diff --git a/src/blogc-make/reloader.h b/src/blogc-make/reloader.h
index 40d2fe9..5067738 100644
--- a/src/blogc-make/reloader.h
+++ b/src/blogc-make/reloader.h
@@ -10,20 +10,21 @@
#define _MAKE_RELOADER_H
#include <stdbool.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "ctx.h"
#include "rules.h"
typedef struct {
bm_ctx_t *ctx;
bm_rule_exec_func_t rule_exec;
- bc_slist_t *outputs;
- bc_trie_t *args;
+ sb_slist_t *outputs;
+ sb_trie_t *args;
bool running;
} bm_reloader_t;
bm_reloader_t* bm_reloader_new(bm_ctx_t *ctx, bm_rule_exec_func_t rule_exec,
- bc_slist_t *outputs, bc_trie_t *args);
+ sb_slist_t *outputs, sb_trie_t *args);
void bm_reloader_stop(bm_reloader_t *reloader);
#endif /* _MAKE_RELOADER_H */
diff --git a/src/blogc-make/rules.c b/src/blogc-make/rules.c
index 8464bd2..958641c 100644
--- a/src/blogc-make/rules.c
+++ b/src/blogc-make/rules.c
@@ -12,7 +12,8 @@
#include <stdlib.h>
#include <time.h>
#include <math.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "ctx.h"
#include "exec.h"
#include "exec-native.h"
@@ -22,75 +23,75 @@
static void
-posts_ordering(bm_ctx_t *ctx, bc_trie_t *variables, const char *variable)
+posts_ordering(bm_ctx_t *ctx, sb_trie_t *variables, const char *variable)
{
if (ctx == NULL || ctx->settings == NULL || ctx->settings->settings == NULL)
return; // something is wrong, let's not add any variable
- const char *value = bc_trie_lookup(ctx->settings->settings, variable);
+ const char *value = sb_trie_lookup(ctx->settings->settings, variable);
if (value != NULL && ((0 == strcmp(value, "ASC")) || (0 == strcmp(value, "asc"))))
return; // user explicitly asked for ASC
- bc_trie_insert(variables, "FILTER_REVERSE", bc_strdup("1"));
+ sb_trie_insert(variables, "FILTER_REVERSE", sb_strdup("1"));
}
static void
-posts_pagination(bm_ctx_t *ctx, bc_trie_t *variables, const char *variable)
+posts_pagination(bm_ctx_t *ctx, sb_trie_t *variables, const char *variable)
{
if (ctx == NULL || ctx->settings == NULL || ctx->settings->settings == NULL)
return; // something is wrong, let's not add any variable
long posts_per_page = strtol(
- bc_trie_lookup(ctx->settings->settings, variable),
+ sb_trie_lookup(ctx->settings->settings, variable),
NULL, 10); // FIXME: improve
if (posts_per_page >= 0) {
- bc_trie_insert(variables, "FILTER_PAGE", bc_strdup("1"));
- bc_trie_insert(variables, "FILTER_PER_PAGE",
- bc_strdup(bc_trie_lookup(ctx->settings->settings, variable)));
+ sb_trie_insert(variables, "FILTER_PAGE", sb_strdup("1"));
+ sb_trie_insert(variables, "FILTER_PER_PAGE",
+ sb_strdup(sb_trie_lookup(ctx->settings->settings, variable)));
}
}
// INDEX RULE
-static bc_slist_t*
+static sb_slist_t*
index_outputlist(bm_ctx_t *ctx)
{
if (ctx == NULL || ctx->settings->posts == NULL)
return NULL;
- bc_slist_t *rv = NULL;
- const char *html_ext = bc_trie_lookup(ctx->settings->settings,
+ sb_slist_t *rv = NULL;
+ const char *html_ext = sb_trie_lookup(ctx->settings->settings,
"html_ext");
- const char *index_prefix = bc_trie_lookup(ctx->settings->settings,
+ const char *index_prefix = sb_trie_lookup(ctx->settings->settings,
"index_prefix");
bool is_index = (index_prefix == NULL) && (html_ext[0] == '/');
- char *f = bc_strdup_printf("%s%s%s%s", ctx->short_output_dir,
+ char *f = sb_strdup_printf("%s%s%s%s", ctx->short_output_dir,
is_index ? "" : "/", is_index ? "" : index_prefix,
html_ext);
- rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+ rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
free(f);
return rv;
}
static int
-index_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+index_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
if (ctx == NULL || ctx->settings->posts == NULL)
return 0;
int rv = 0;
- bc_trie_t *variables = bc_trie_new(free);
+ sb_trie_t *variables = sb_trie_new(free);
posts_pagination(ctx, variables, "posts_per_page");
posts_ordering(ctx, variables, "html_order");
- bc_trie_insert(variables, "DATE_FORMAT",
- bc_strdup(bc_trie_lookup(ctx->settings->settings, "date_format")));
- bc_trie_insert(variables, "MAKE_RULE", bc_strdup("index"));
- bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("post"));
+ sb_trie_insert(variables, "DATE_FORMAT",
+ sb_strdup(sb_trie_lookup(ctx->settings->settings, "date_format")));
+ sb_trie_insert(variables, "MAKE_RULE", sb_strdup("index"));
+ sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("post"));
- for (bc_slist_t *l = outputs; l != NULL; l = l->next) {
+ for (sb_slist_t *l = outputs; l != NULL; l = l->next) {
bm_filectx_t *fctx = l->data;
if (fctx == NULL)
continue;
@@ -104,7 +105,7 @@ index_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
}
}
- bc_trie_free(variables);
+ sb_trie_free(variables);
return rv;
}
@@ -112,39 +113,39 @@ index_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
// ATOM RULE
-static bc_slist_t*
+static sb_slist_t*
atom_outputlist(bm_ctx_t *ctx)
{
if (ctx == NULL || ctx->settings->posts == NULL)
return NULL;
- bc_slist_t *rv = NULL;
- const char *atom_prefix = bc_trie_lookup(ctx->settings->settings,
+ sb_slist_t *rv = NULL;
+ const char *atom_prefix = sb_trie_lookup(ctx->settings->settings,
"atom_prefix");
- const char *atom_ext = bc_trie_lookup(ctx->settings->settings, "atom_ext");
- char *f = bc_strdup_printf("%s/%s%s", ctx->short_output_dir,
+ const char *atom_ext = sb_trie_lookup(ctx->settings->settings, "atom_ext");
+ char *f = sb_strdup_printf("%s/%s%s", ctx->short_output_dir,
atom_prefix, atom_ext);
- rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+ rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
free(f);
return rv;
}
static int
-atom_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+atom_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
if (ctx == NULL || ctx->settings->posts == NULL)
return 0;
int rv = 0;
- bc_trie_t *variables = bc_trie_new(free);
+ sb_trie_t *variables = sb_trie_new(free);
posts_pagination(ctx, variables, "atom_posts_per_page");
posts_ordering(ctx, variables, "atom_order");
- bc_trie_insert(variables, "DATE_FORMAT", bc_strdup("%Y-%m-%dT%H:%M:%SZ"));
- bc_trie_insert(variables, "MAKE_RULE", bc_strdup("atom"));
- bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("atom"));
+ sb_trie_insert(variables, "DATE_FORMAT", sb_strdup("%Y-%m-%dT%H:%M:%SZ"));
+ sb_trie_insert(variables, "MAKE_RULE", sb_strdup("atom"));
+ sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("atom"));
- for (bc_slist_t *l = outputs; l != NULL; l = l->next) {
+ for (sb_slist_t *l = outputs; l != NULL; l = l->next) {
bm_filectx_t *fctx = l->data;
if (fctx == NULL)
continue;
@@ -158,7 +159,7 @@ atom_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
}
}
- bc_trie_free(variables);
+ sb_trie_free(variables);
return rv;
}
@@ -166,27 +167,27 @@ atom_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
// ATOM TAGS RULE
-static bc_slist_t*
+static sb_slist_t*
atom_tags_outputlist(bm_ctx_t *ctx)
{
if (ctx == NULL || ctx->settings->posts == NULL || ctx->settings->tags == NULL)
return NULL;
- bc_slist_t *rv = NULL;
- const char *atom_prefix = bc_trie_lookup(ctx->settings->settings,
+ sb_slist_t *rv = NULL;
+ const char *atom_prefix = sb_trie_lookup(ctx->settings->settings,
"atom_prefix");
- const char *atom_ext = bc_trie_lookup(ctx->settings->settings, "atom_ext");
+ const char *atom_ext = sb_trie_lookup(ctx->settings->settings, "atom_ext");
for (size_t i = 0; ctx->settings->tags[i] != NULL; i++) {
- char *f = bc_strdup_printf("%s/%s/%s%s", ctx->short_output_dir,
+ char *f = sb_strdup_printf("%s/%s/%s%s", ctx->short_output_dir,
atom_prefix, ctx->settings->tags[i], atom_ext);
- rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+ rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
free(f);
}
return rv;
}
static int
-atom_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+atom_tags_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
if (ctx == NULL || ctx->settings->posts == NULL || ctx->settings->tags == NULL)
return 0;
@@ -194,20 +195,20 @@ atom_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
int rv = 0;
size_t i = 0;
- bc_trie_t *variables = bc_trie_new(free);
+ sb_trie_t *variables = sb_trie_new(free);
posts_pagination(ctx, variables, "atom_posts_per_page");
posts_ordering(ctx, variables, "atom_order");
- bc_trie_insert(variables, "DATE_FORMAT", bc_strdup("%Y-%m-%dT%H:%M:%SZ"));
- bc_trie_insert(variables, "MAKE_RULE", bc_strdup("atom_tags"));
- bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("atom"));
+ sb_trie_insert(variables, "DATE_FORMAT", sb_strdup("%Y-%m-%dT%H:%M:%SZ"));
+ sb_trie_insert(variables, "MAKE_RULE", sb_strdup("atom_tags"));
+ sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("atom"));
- for (bc_slist_t *l = outputs; l != NULL; l = l->next, i++) {
+ for (sb_slist_t *l = outputs; l != NULL; l = l->next, i++) {
bm_filectx_t *fctx = l->data;
if (fctx == NULL)
continue;
- bc_trie_insert(variables, "FILTER_TAG",
- bc_strdup(ctx->settings->tags[i]));
+ sb_trie_insert(variables, "FILTER_TAG",
+ sb_strdup(ctx->settings->tags[i]));
if (bm_rule_need_rebuild(ctx->posts_fctx, ctx->settings_fctx, NULL,
fctx, false))
@@ -219,7 +220,7 @@ atom_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
}
}
- bc_trie_free(variables);
+ sb_trie_free(variables);
return rv;
}
@@ -227,38 +228,38 @@ atom_tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
// PAGINATION RULE
-static bc_slist_t*
+static sb_slist_t*
pagination_outputlist(bm_ctx_t *ctx)
{
if (ctx == NULL || ctx->settings->posts == NULL)
return NULL;
- long num_posts = bc_slist_length(ctx->posts_fctx);
+ long num_posts = sb_slist_length(ctx->posts_fctx);
long posts_per_page = strtol(
- bc_trie_lookup(ctx->settings->settings, "posts_per_page"),
+ sb_trie_lookup(ctx->settings->settings, "posts_per_page"),
NULL, 10); // FIXME: improve
if (posts_per_page <= 0)
return NULL;
size_t pages = ceilf(((float) num_posts) / posts_per_page);
- const char *pagination_prefix = bc_trie_lookup(ctx->settings->settings,
+ const char *pagination_prefix = sb_trie_lookup(ctx->settings->settings,
"pagination_prefix");
- const char *html_ext = bc_trie_lookup(ctx->settings->settings,
+ const char *html_ext = sb_trie_lookup(ctx->settings->settings,
"html_ext");
- bc_slist_t *rv = NULL;
+ sb_slist_t *rv = NULL;
for (size_t i = 0; i < pages; i++) {
- char *f = bc_strdup_printf("%s/%s/%d%s", ctx->short_output_dir,
+ char *f = sb_strdup_printf("%s/%s/%d%s", ctx->short_output_dir,
pagination_prefix, i + 1, html_ext);
- rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+ rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
free(f);
}
return rv;
}
static int
-pagination_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+pagination_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
if (ctx == NULL || ctx->settings->posts == NULL)
return 0;
@@ -266,22 +267,22 @@ pagination_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
int rv = 0;
size_t page = 1;
- bc_trie_t *variables = bc_trie_new(free);
+ sb_trie_t *variables = sb_trie_new(free);
// not using posts_pagination because we set FILTER_PAGE anyway, and the
// first value inserted in that function would be useless
- bc_trie_insert(variables, "FILTER_PER_PAGE",
- bc_strdup(bc_trie_lookup(ctx->settings->settings, "posts_per_page")));
+ sb_trie_insert(variables, "FILTER_PER_PAGE",
+ sb_strdup(sb_trie_lookup(ctx->settings->settings, "posts_per_page")));
posts_ordering(ctx, variables, "html_order");
- bc_trie_insert(variables, "DATE_FORMAT",
- bc_strdup(bc_trie_lookup(ctx->settings->settings, "date_format")));
- bc_trie_insert(variables, "MAKE_RULE", bc_strdup("pagination"));
- bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("post"));
+ sb_trie_insert(variables, "DATE_FORMAT",
+ sb_strdup(sb_trie_lookup(ctx->settings->settings, "date_format")));
+ sb_trie_insert(variables, "MAKE_RULE", sb_strdup("pagination"));
+ sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("post"));
- for (bc_slist_t *l = outputs; l != NULL; l = l->next, page++) {
+ for (sb_slist_t *l = outputs; l != NULL; l = l->next, page++) {
bm_filectx_t *fctx = l->data;
if (fctx == NULL)
continue;
- bc_trie_insert(variables, "FILTER_PAGE", bc_strdup_printf("%zu", page));
+ sb_trie_insert(variables, "FILTER_PAGE", sb_strdup_printf("%zu", page));
if (bm_rule_need_rebuild(ctx->posts_fctx, ctx->settings_fctx,
ctx->main_template_fctx, fctx, false))
{
@@ -292,7 +293,7 @@ pagination_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
}
}
- bc_trie_free(variables);
+ sb_trie_free(variables);
return rv;
}
@@ -300,44 +301,44 @@ pagination_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
// POSTS RULE
-static bc_slist_t*
+static sb_slist_t*
posts_outputlist(bm_ctx_t *ctx)
{
if (ctx == NULL || ctx->settings->posts == NULL)
return NULL;
- const char *post_prefix = bc_trie_lookup(ctx->settings->settings,
+ const char *post_prefix = sb_trie_lookup(ctx->settings->settings,
"post_prefix");
- const char *html_ext = bc_trie_lookup(ctx->settings->settings,
+ const char *html_ext = sb_trie_lookup(ctx->settings->settings,
"html_ext");
- bc_slist_t *rv = NULL;
+ sb_slist_t *rv = NULL;
for (size_t i = 0; ctx->settings->posts[i] != NULL; i++) {
- char *f = bc_strdup_printf("%s/%s/%s%s", ctx->short_output_dir,
+ char *f = sb_strdup_printf("%s/%s/%s%s", ctx->short_output_dir,
post_prefix, ctx->settings->posts[i], html_ext);
- rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+ rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
free(f);
}
return rv;
}
static int
-posts_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+posts_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
if (ctx == NULL || ctx->settings->posts == NULL)
return 0;
int rv = 0;
- bc_trie_t *variables = bc_trie_new(free);
- bc_trie_insert(variables, "IS_POST", bc_strdup("1"));
- bc_trie_insert(variables, "DATE_FORMAT",
- bc_strdup(bc_trie_lookup(ctx->settings->settings, "date_format")));
+ sb_trie_t *variables = sb_trie_new(free);
+ sb_trie_insert(variables, "IS_POST", sb_strdup("1"));
+ sb_trie_insert(variables, "DATE_FORMAT",
+ sb_strdup(sb_trie_lookup(ctx->settings->settings, "date_format")));
posts_ordering(ctx, variables, "html_order");
- bc_trie_insert(variables, "MAKE_RULE", bc_strdup("posts"));
- bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("post"));
+ sb_trie_insert(variables, "MAKE_RULE", sb_strdup("posts"));
+ sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("post"));
- bc_slist_t *s, *o;
+ sb_slist_t *s, *o;
for (s = ctx->posts_fctx, o = outputs; s != NULL && o != NULL;
s = s->next, o = o->next)
@@ -349,17 +350,17 @@ posts_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
if (bm_rule_need_rebuild(s, ctx->settings_fctx,
ctx->main_template_fctx, o_fctx, true))
{
- bc_trie_t *local = bc_trie_new(NULL);
- bc_trie_insert(local, "MAKE_SLUG", s_fctx->slug); // no need to copy
+ sb_trie_t *local = sb_trie_new(NULL);
+ sb_trie_insert(local, "MAKE_SLUG", s_fctx->slug); // no need to copy
rv = bm_exec_blogc(ctx, variables, local, false, ctx->main_template_fctx,
o_fctx, s, true);
- bc_trie_free(local);
+ sb_trie_free(local);
if (rv != 0)
break;
}
}
- bc_trie_free(variables);
+ sb_trie_free(variables);
return rv;
}
@@ -367,27 +368,27 @@ posts_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
// TAGS RULE
-static bc_slist_t*
+static sb_slist_t*
tags_outputlist(bm_ctx_t *ctx)
{
if (ctx == NULL || ctx->settings->posts == NULL || ctx->settings->tags == NULL)
return NULL;
- bc_slist_t *rv = NULL;
- const char *tag_prefix = bc_trie_lookup(ctx->settings->settings,
+ sb_slist_t *rv = NULL;
+ const char *tag_prefix = sb_trie_lookup(ctx->settings->settings,
"tag_prefix");
- const char *html_ext = bc_trie_lookup(ctx->settings->settings, "html_ext");
+ const char *html_ext = sb_trie_lookup(ctx->settings->settings, "html_ext");
for (size_t i = 0; ctx->settings->tags[i] != NULL; i++) {
- char *f = bc_strdup_printf("%s/%s/%s%s", ctx->short_output_dir,
+ char *f = sb_strdup_printf("%s/%s/%s%s", ctx->short_output_dir,
tag_prefix, ctx->settings->tags[i], html_ext);
- rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+ rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
free(f);
}
return rv;
}
static int
-tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+tags_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
if (ctx == NULL || ctx->settings->posts == NULL || ctx->settings->tags == NULL)
return 0;
@@ -395,21 +396,21 @@ tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
int rv = 0;
size_t i = 0;
- bc_trie_t *variables = bc_trie_new(free);
+ sb_trie_t *variables = sb_trie_new(free);
posts_pagination(ctx, variables, "atom_posts_per_page");
posts_ordering(ctx, variables, "html_order");
- bc_trie_insert(variables, "DATE_FORMAT",
- bc_strdup(bc_trie_lookup(ctx->settings->settings, "date_format")));
- bc_trie_insert(variables, "MAKE_RULE", bc_strdup("tags"));
- bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("post"));
+ sb_trie_insert(variables, "DATE_FORMAT",
+ sb_strdup(sb_trie_lookup(ctx->settings->settings, "date_format")));
+ sb_trie_insert(variables, "MAKE_RULE", sb_strdup("tags"));
+ sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("post"));
- for (bc_slist_t *l = outputs; l != NULL; l = l->next, i++) {
+ for (sb_slist_t *l = outputs; l != NULL; l = l->next, i++) {
bm_filectx_t *fctx = l->data;
if (fctx == NULL)
continue;
- bc_trie_insert(variables, "FILTER_TAG",
- bc_strdup(ctx->settings->tags[i]));
+ sb_trie_insert(variables, "FILTER_TAG",
+ sb_strdup(ctx->settings->tags[i]));
if (bm_rule_need_rebuild(ctx->posts_fctx, ctx->settings_fctx,
ctx->main_template_fctx, fctx, false))
@@ -421,7 +422,7 @@ tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
}
}
- bc_trie_free(variables);
+ sb_trie_free(variables);
return rv;
}
@@ -429,42 +430,42 @@ tags_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
// PAGES RULE
-static bc_slist_t*
+static sb_slist_t*
pages_outputlist(bm_ctx_t *ctx)
{
if (ctx == NULL || ctx->settings->pages == NULL)
return NULL;
- const char *html_ext = bc_trie_lookup(ctx->settings->settings, "html_ext");
+ const char *html_ext = sb_trie_lookup(ctx->settings->settings, "html_ext");
- bc_slist_t *rv = NULL;
+ sb_slist_t *rv = NULL;
for (size_t i = 0; ctx->settings->pages[i] != NULL; i++) {
bool is_index = (0 == strcmp(ctx->settings->pages[i], "index"))
&& (html_ext[0] == '/');
- char *f = bc_strdup_printf("%s%s%s%s", ctx->short_output_dir,
+ char *f = sb_strdup_printf("%s%s%s%s", ctx->short_output_dir,
is_index ? "" : "/", is_index ? "" : ctx->settings->pages[i],
html_ext);
- rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+ rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
free(f);
}
return rv;
}
static int
-pages_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+pages_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
if (ctx == NULL || ctx->settings->pages == NULL)
return 0;
int rv = 0;
- bc_trie_t *variables = bc_trie_new(free);
- bc_trie_insert(variables, "DATE_FORMAT",
- bc_strdup(bc_trie_lookup(ctx->settings->settings, "date_format")));
- bc_trie_insert(variables, "MAKE_RULE", bc_strdup("pages"));
- bc_trie_insert(variables, "MAKE_TYPE", bc_strdup("page"));
+ sb_trie_t *variables = sb_trie_new(free);
+ sb_trie_insert(variables, "DATE_FORMAT",
+ sb_strdup(sb_trie_lookup(ctx->settings->settings, "date_format")));
+ sb_trie_insert(variables, "MAKE_RULE", sb_strdup("pages"));
+ sb_trie_insert(variables, "MAKE_TYPE", sb_strdup("page"));
- bc_slist_t *s, *o;
+ sb_slist_t *s, *o;
for (s = ctx->pages_fctx, o = outputs; s != NULL && o != NULL;
s = s->next, o = o->next)
@@ -476,17 +477,17 @@ pages_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
if (bm_rule_need_rebuild(s, ctx->settings_fctx,
ctx->main_template_fctx, o_fctx, true))
{
- bc_trie_t *local = bc_trie_new(NULL);
- bc_trie_insert(local, "MAKE_SLUG", s_fctx->slug); // no need to copy
+ sb_trie_t *local = sb_trie_new(NULL);
+ sb_trie_insert(local, "MAKE_SLUG", s_fctx->slug); // no need to copy
rv = bm_exec_blogc(ctx, variables, local, false, ctx->main_template_fctx,
o_fctx, s, true);
- bc_trie_free(local);
+ sb_trie_free(local);
if (rv != 0)
break;
}
}
- bc_trie_free(variables);
+ sb_trie_free(variables);
return rv;
}
@@ -494,33 +495,33 @@ pages_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
// COPY FILES RULE
-static bc_slist_t*
+static sb_slist_t*
copy_outputlist(bm_ctx_t *ctx)
{
if (ctx == NULL || ctx->settings->copy == NULL)
return NULL;
- bc_slist_t *rv = NULL;
+ sb_slist_t *rv = NULL;
// we iterate over ctx->copy_fctx list instead of ctx->settings->copy,
// because bm_ctx_new() expands directories into its files, recursively.
- for (bc_slist_t *s = ctx->copy_fctx; s != NULL; s = s->next) {
- char *f = bc_strdup_printf("%s/%s", ctx->short_output_dir,
+ for (sb_slist_t *s = ctx->copy_fctx; s != NULL; s = s->next) {
+ char *f = sb_strdup_printf("%s/%s", ctx->short_output_dir,
((bm_filectx_t*) s->data)->short_path);
- rv = bc_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
+ rv = sb_slist_append(rv, bm_filectx_new(ctx, f, NULL, NULL));
free(f);
}
return rv;
}
static int
-copy_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+copy_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
if (ctx == NULL || ctx->settings->copy == NULL)
return 0;
int rv = 0;
- bc_slist_t *s, *o;
+ sb_slist_t *s, *o;
for (s = ctx->copy_fctx, o = outputs; s != NULL && o != NULL;
s = s->next, o = o->next)
@@ -542,18 +543,18 @@ copy_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
// CLEAN RULE
-static bc_slist_t*
+static sb_slist_t*
clean_outputlist(bm_ctx_t *ctx)
{
return bm_rule_list_built_files(ctx);
}
static int
-clean_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+clean_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
int rv = 0;
- for (bc_slist_t *l = outputs; l != NULL; l = l->next) {
+ for (sb_slist_t *l = outputs; l != NULL; l = l->next) {
bm_filectx_t *fctx = l->data;
if (fctx == NULL)
continue;
@@ -573,21 +574,21 @@ clean_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
}
-static int all_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args);
+static int all_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args);
// RUNSERVER RULE
static int
-runserver_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+runserver_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
bm_reloader_t *reloader = bm_reloader_new(ctx, all_exec, outputs, args);
if (reloader == NULL) {
return 3;
}
- int rv = bm_exec_blogc_runserver(ctx, bc_trie_lookup(args, "host"),
- bc_trie_lookup(args, "port"), bc_trie_lookup(args, "threads"));
+ int rv = bm_exec_blogc_runserver(ctx, sb_trie_lookup(args, "host"),
+ sb_trie_lookup(args, "port"), sb_trie_lookup(args, "threads"));
bm_reloader_stop(reloader);
return rv;
@@ -680,7 +681,7 @@ const bm_rule_t rules[] = {
// ALL RULE
static int
-all_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
+all_exec(bm_ctx_t *ctx, sb_slist_t *outputs, sb_trie_t *args)
{
for (size_t i = 0; rules[i].name != NULL; i++) {
if (!rules[i].generate_files) {
@@ -696,30 +697,30 @@ all_exec(bm_ctx_t *ctx, bc_slist_t *outputs, bc_trie_t *args)
}
-bc_trie_t*
+sb_trie_t*
bm_rule_parse_args(const char *sep)
{
if (sep == NULL || *sep == '\0' || *sep != ':')
return NULL;
- bc_trie_t *rv = bc_trie_new(free);
+ sb_trie_t *rv = sb_trie_new(free);
char *end = (char*) sep + 1;
char *kv_sep;
while (NULL != (kv_sep = strchr(end, '='))) {
- char *key = bc_strndup(end, kv_sep - end);
+ char *key = sb_strndup(end, kv_sep - end);
end = kv_sep + 1;
kv_sep = strchr(end, ',');
if (kv_sep == NULL)
kv_sep = strchr(end, '\0');
- char *value = bc_strndup(end, kv_sep - end);
- bc_trie_insert(rv, key, value);
+ char *value = sb_strndup(end, kv_sep - end);
+ sb_trie_insert(rv, key, value);
free(key);
if (*kv_sep == '\0')
break;
end = kv_sep + 1;
}
if (kv_sep == NULL) {
- bc_trie_free(rv);
+ sb_trie_free(rv);
return NULL;
}
return rv;
@@ -727,7 +728,7 @@ bm_rule_parse_args(const char *sep)
int
-bm_rule_executor(bm_ctx_t *ctx, bc_slist_t *rule_list)
+bm_rule_executor(bm_ctx_t *ctx, sb_slist_t *rule_list)
{
if (ctx == NULL)
return 3;
@@ -735,12 +736,12 @@ bm_rule_executor(bm_ctx_t *ctx, bc_slist_t *rule_list)
const bm_rule_t *rule = NULL;
int rv = 0;
- for (bc_slist_t *l = rule_list; l != NULL; l = l->next) {
+ for (sb_slist_t *l = rule_list; l != NULL; l = l->next) {
char *rule_str = l->data;
char *sep = strchr(rule_str, ':');
- bc_trie_t *args = NULL;
+ sb_trie_t *args = NULL;
if (sep == NULL) {
sep = strchr(rule_str, '\0');
}
@@ -775,26 +776,26 @@ bm_rule_executor(bm_ctx_t *ctx, bc_slist_t *rule_list)
int
-bm_rule_execute(bm_ctx_t *ctx, const bm_rule_t *rule, bc_trie_t *args)
+bm_rule_execute(bm_ctx_t *ctx, const bm_rule_t *rule, sb_trie_t *args)
{
if (ctx == NULL || rule == NULL)
return 3;
- bc_slist_t *outputs = NULL;
+ sb_slist_t *outputs = NULL;
if (rule->outputlist_func != NULL) {
outputs = rule->outputlist_func(ctx);
}
int rv = rule->exec_func(ctx, outputs, args);
- bc_slist_free_full(outputs, (bc_free_func_t) bm_filectx_free);
+ sb_slist_free_full(outputs, (sb_free_func_t) bm_filectx_free);
return rv;
}
bool
-bm_rule_need_rebuild(bc_slist_t *sources, bm_filectx_t *settings,
+bm_rule_need_rebuild(sb_slist_t *sources, bm_filectx_t *settings,
bm_filectx_t *template, bm_filectx_t *output, bool only_first_source)
{
if (output == NULL || !output->readable)
@@ -802,19 +803,19 @@ bm_rule_need_rebuild(bc_slist_t *sources, bm_filectx_t *settings,
bool rv = false;
- bc_slist_t *s = NULL;
+ sb_slist_t *s = NULL;
if (settings != NULL)
- s = bc_slist_append(s, settings);
+ s = sb_slist_append(s, settings);
if (template != NULL)
- s = bc_slist_append(s, template);
+ s = sb_slist_append(s, template);
- for (bc_slist_t *l = sources; l != NULL; l = l->next) {
- s = bc_slist_append(s, l->data);
+ for (sb_slist_t *l = sources; l != NULL; l = l->next) {
+ s = sb_slist_append(s, l->data);
if (only_first_source)
break;
}
- for (bc_slist_t *l = s; l != NULL; l = l->next) {
+ for (sb_slist_t *l = s; l != NULL; l = l->next) {
bm_filectx_t *source = l->data;
if (source == NULL || !source->readable) {
// this is unlikely to happen, but lets just say that we need
@@ -834,29 +835,29 @@ bm_rule_need_rebuild(bc_slist_t *sources, bm_filectx_t *settings,
}
}
- bc_slist_free(s);
+ sb_slist_free(s);
return rv;
}
-bc_slist_t*
+sb_slist_t*
bm_rule_list_built_files(bm_ctx_t *ctx)
{
if (ctx == NULL)
return NULL;
- bc_slist_t *rv = NULL;
+ sb_slist_t *rv = NULL;
for (size_t i = 0; rules[i].name != NULL; i++) {
if (!rules[i].generate_files) {
continue;
}
- bc_slist_t *o = rules[i].outputlist_func(ctx);
- for (bc_slist_t *l = o; l != NULL; l = l->next) {
- rv = bc_slist_append(rv, l->data);
+ sb_slist_t *o = rules[i].outputlist_func(ctx);
+ for (sb_slist_t *l = o; l != NULL; l = l->next) {
+ rv = sb_slist_append(rv, l->data);
}
- bc_slist_free(o);
+ sb_slist_free(o);
}
return rv;
}
diff --git a/src/blogc-make/rules.h b/src/blogc-make/rules.h
index 1604e13..9dd910d 100644
--- a/src/blogc-make/rules.h
+++ b/src/blogc-make/rules.h
@@ -10,12 +10,13 @@
#define _MAKE_RULES_H
#include <stdbool.h>
+#include <squareball.h>
+
#include "ctx.h"
-#include "../common/utils.h"
-typedef bc_slist_t* (*bm_rule_outputlist_func_t) (bm_ctx_t *ctx);
-typedef int (*bm_rule_exec_func_t) (bm_ctx_t *ctx, bc_slist_t *outputs,
- bc_trie_t *args);
+typedef sb_slist_t* (*bm_rule_outputlist_func_t) (bm_ctx_t *ctx);
+typedef int (*bm_rule_exec_func_t) (bm_ctx_t *ctx, sb_slist_t *outputs,
+ sb_trie_t *args);
typedef struct {
const char *name;
@@ -25,12 +26,12 @@ typedef struct {
bool generate_files;
} bm_rule_t;
-bc_trie_t* bm_rule_parse_args(const char *sep);
-int bm_rule_executor(bm_ctx_t *ctx, bc_slist_t *rule_list);
-int bm_rule_execute(bm_ctx_t *ctx, const bm_rule_t *rule, bc_trie_t *args);
-bool bm_rule_need_rebuild(bc_slist_t *sources, bm_filectx_t *settings,
+sb_trie_t* bm_rule_parse_args(const char *sep);
+int bm_rule_executor(bm_ctx_t *ctx, sb_slist_t *rule_list);
+int bm_rule_execute(bm_ctx_t *ctx, const bm_rule_t *rule, sb_trie_t *args);
+bool bm_rule_need_rebuild(sb_slist_t *sources, bm_filectx_t *settings,
bm_filectx_t *template, bm_filectx_t *output, bool only_first_source);
-bc_slist_t* bm_rule_list_built_files(bm_ctx_t *ctx);
+sb_slist_t* bm_rule_list_built_files(bm_ctx_t *ctx);
void bm_rule_print_help(void);
#endif /* _MAKE_RULES_H */
diff --git a/src/blogc-make/settings.c b/src/blogc-make/settings.c
index 9e24d41..1f3341d 100644
--- a/src/blogc-make/settings.c
+++ b/src/blogc-make/settings.c
@@ -9,10 +9,9 @@
#include <libgen.h>
#include <stdbool.h>
#include <stdlib.h>
-#include "../common/config-parser.h"
-#include "../common/error.h"
-#include "../common/file.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
+#include "error.h"
#include "settings.h"
@@ -73,7 +72,7 @@ static const char* list_sections[] = {
bm_settings_t*
-bm_settings_parse(const char *content, size_t content_len, bc_error_t **err)
+bm_settings_parse(const char *content, size_t content_len, sb_error_t **err)
{
if (err == NULL || *err != NULL)
return NULL;
@@ -81,15 +80,15 @@ bm_settings_parse(const char *content, size_t content_len, bc_error_t **err)
if (content == NULL)
return NULL;
- bc_config_t *config = bc_config_parse(content, content_len, list_sections,
+ sb_config_t *config = sb_config_parse(content, content_len, list_sections,
err);
if (config == NULL || (err != NULL && *err != NULL))
return NULL;
- bm_settings_t *rv = bc_malloc(sizeof(bm_settings_t));
+ bm_settings_t *rv = sb_malloc(sizeof(bm_settings_t));
rv->root_dir = NULL;
- rv->global = bc_trie_new(free);
- rv->settings = bc_trie_new(free);
+ rv->global = sb_trie_new(free);
+ rv->settings = sb_trie_new(free);
rv->posts = NULL;
rv->pages = NULL;
rv->copy = NULL;
@@ -99,12 +98,12 @@ bm_settings_parse(const char *content, size_t content_len, bc_error_t **err)
// even if I never released a version with it, but some people is using
// it already.
const char *section = NULL;
- char **global = bc_config_list_keys(config, "global");
+ char **global = sb_config_list_keys(config, "global");
if (global != NULL) {
section = "global";
}
else {
- global = bc_config_list_keys(config, "environment");
+ global = sb_config_list_keys(config, "environment");
if (global != NULL) {
section = "environment";
}
@@ -117,24 +116,24 @@ bm_settings_parse(const char *content, size_t content_len, bc_error_t **err)
for (size_t i = 0; global[i] != NULL; i++) {
for (size_t j = 0; global[i][j] != '\0'; j++) {
if (!((global[i][j] >= 'A' && global[i][j] <= 'Z') || global[i][j] == '_')) {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_SETTINGS,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_SETTINGS,
"Invalid [%s] key: %s", section, global[i]);
- bc_strv_free(global);
+ sb_strv_free(global);
bm_settings_free(rv);
rv = NULL;
goto cleanup;
}
}
- bc_trie_insert(rv->global, global[i],
- bc_strdup(bc_config_get(config, section, global[i])));
+ sb_trie_insert(rv->global, global[i],
+ sb_strdup(sb_config_get(config, section, global[i])));
}
}
- bc_strv_free(global);
+ sb_strv_free(global);
for (size_t i = 0; required_global[i] != NULL; i++) {
- const char *value = bc_trie_lookup(rv->global, required_global[i]);
+ const char *value = sb_trie_lookup(rv->global, required_global[i]);
if (value == NULL || value[0] == '\0') {
- *err = bc_error_new_printf(BLOGC_MAKE_ERROR_SETTINGS,
+ *err = sb_error_new_printf(BLOGC_MAKE_ERROR_SETTINGS,
"[%s] key required but not found or empty: %s", section,
required_global[i]);
bm_settings_free(rv);
@@ -144,46 +143,46 @@ bm_settings_parse(const char *content, size_t content_len, bc_error_t **err)
}
for (size_t i = 0; default_settings[i].key != NULL; i++) {
- const char *value = bc_config_get_with_default(
+ const char *value = sb_config_get_with_default(
config, "settings", default_settings[i].key,
default_settings[i].default_value);
if (value != NULL) {
- bc_trie_insert(rv->settings, default_settings[i].key,
- bc_strdup(value));
+ sb_trie_insert(rv->settings, default_settings[i].key,
+ sb_strdup(value));
}
}
- rv->posts = bc_config_get_list(config, "posts");
- rv->pages = bc_config_get_list(config, "pages");
- rv->tags = bc_config_get_list(config, "tags");
+ rv->posts = sb_config_get_list(config, "posts");
+ rv->pages = sb_config_get_list(config, "pages");
+ rv->tags = sb_config_get_list(config, "tags");
// this is for backward compatibility too.
- rv->copy = bc_config_get_list(config, "copy");
+ rv->copy = sb_config_get_list(config, "copy");
if (rv->copy == NULL)
- rv->copy = bc_config_get_list(config, "copy_files");
+ rv->copy = sb_config_get_list(config, "copy_files");
cleanup:
- bc_config_free(config);
+ sb_config_free(config);
return rv;
}
bm_settings_t*
-bm_settings_parse_file(const char *filename, bc_error_t **err)
+bm_settings_parse_file(const char *filename, sb_error_t **err)
{
if (err == NULL || *err != NULL)
return NULL;
size_t content_len;
- char *content = bc_file_get_contents(filename, true, &content_len, err);
+ char *content = sb_file_get_contents_utf8(filename, &content_len, err);
if (*err != NULL)
return NULL;
bm_settings_t *rv = bm_settings_parse(content, content_len, err);
char *real_filename = realpath(filename, NULL);
- rv->root_dir = bc_strdup(dirname(real_filename));
+ rv->root_dir = sb_strdup(dirname(real_filename));
free(real_filename);
free(content);
return rv;
@@ -196,11 +195,11 @@ bm_settings_free(bm_settings_t *settings)
if (settings == NULL)
return;
free(settings->root_dir);
- bc_trie_free(settings->global);
- bc_trie_free(settings->settings);
- bc_strv_free(settings->posts);
- bc_strv_free(settings->pages);
- bc_strv_free(settings->copy);
- bc_strv_free(settings->tags);
+ sb_trie_free(settings->global);
+ sb_trie_free(settings->settings);
+ sb_strv_free(settings->posts);
+ sb_strv_free(settings->pages);
+ sb_strv_free(settings->copy);
+ sb_strv_free(settings->tags);
free(settings);
}
diff --git a/src/blogc-make/settings.h b/src/blogc-make/settings.h
index b1ea117..d524d23 100644
--- a/src/blogc-make/settings.h
+++ b/src/blogc-make/settings.h
@@ -10,13 +10,12 @@
#define _MAKE_SETTINGS_H
#include <stddef.h>
-#include "../common/error.h"
-#include "../common/utils.h"
+#include <squareball.h>
typedef struct {
char *root_dir;
- bc_trie_t *global;
- bc_trie_t *settings;
+ sb_trie_t *global;
+ sb_trie_t *settings;
char **posts;
char **pages;
char **copy;
@@ -24,8 +23,8 @@ typedef struct {
} bm_settings_t;
bm_settings_t* bm_settings_parse(const char *content, size_t content_len,
- bc_error_t **err);
-bm_settings_t* bm_settings_parse_file(const char *filename, bc_error_t **err);
+ sb_error_t **err);
+bm_settings_t* bm_settings_parse_file(const char *filename, sb_error_t **err);
void bm_settings_free(bm_settings_t *settings);
#endif /* _MAKE_SETTINGS_H */
diff --git a/src/blogc-runserver/httpd-utils.c b/src/blogc-runserver/httpd-utils.c
index 7a49bf2..c1df2c8 100644
--- a/src/blogc-runserver/httpd-utils.c
+++ b/src/blogc-runserver/httpd-utils.c
@@ -9,14 +9,15 @@
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "httpd-utils.h"
char*
br_readline(int socket)
{
- bc_string_t *rv = bc_string_new();
+ sb_string_t *rv = sb_string_new();
char buffer[READLINE_BUFFER_SIZE];
ssize_t len;
bool end = false;
@@ -30,7 +31,7 @@ br_readline(int socket)
end = true;
break;
}
- bc_string_append_c(rv, buffer[i]);
+ sb_string_append_c(rv, buffer[i]);
}
}
if (len < READLINE_BUFFER_SIZE) {
@@ -38,7 +39,7 @@ br_readline(int socket)
}
}
- return bc_string_free(rv, false);
+ return sb_string_free(rv, false);
}
@@ -58,7 +59,7 @@ br_hextoi(const char c)
char*
br_urldecode(const char *str)
{
- bc_string_t *rv = bc_string_new();
+ sb_string_t *rv = sb_string_new();
for (size_t i = 0; i < strlen(str); i++) {
switch (str[i]) {
@@ -67,22 +68,22 @@ br_urldecode(const char *str)
int p1 = br_hextoi(str[i + 1]) * 16;
int p2 = br_hextoi(str[i + 2]);
if (p1 >= 0 && p2 >= 0) {
- bc_string_append_c(rv, p1 + p2);
+ sb_string_append_c(rv, p1 + p2);
i += 2;
continue;
}
}
- bc_string_append_c(rv, '%');
+ sb_string_append_c(rv, '%');
break;
case '+':
- bc_string_append_c(rv, ' ');
+ sb_string_append_c(rv, ' ');
break;
default:
- bc_string_append_c(rv, str[i]);
+ sb_string_append_c(rv, str[i]);
}
}
- return bc_string_free(rv, false);
+ return sb_string_free(rv, false);
}
diff --git a/src/blogc-runserver/httpd.c b/src/blogc-runserver/httpd.c
index 9680229..b08a915 100644
--- a/src/blogc-runserver/httpd.c
+++ b/src/blogc-runserver/httpd.c
@@ -19,9 +19,8 @@
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
-#include "../common/error.h"
-#include "../common/file.h"
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "mime.h"
#include "httpd-utils.h"
@@ -43,7 +42,7 @@ typedef struct {
static void
error(int socket, int status_code, const char *error)
{
- char *str = bc_strdup_printf(
+ char *str = sb_strdup_printf(
"HTTP/1.0 %d %s\r\n"
"Content-Type: text/html\r\n"
"Content-Length: %zu\r\n"
@@ -74,8 +73,8 @@ handle_request(void *arg)
unsigned short status_code = 200;
- char **pieces = bc_str_split(conn_line, ' ', 3);
- if (bc_strv_length(pieces) != 3) {
+ char **pieces = sb_str_split(conn_line, ' ', 3);
+ if (sb_strv_length(pieces) != 3) {
status_code = 400;
error(client_socket, 400, "Bad Request");
goto point1;
@@ -87,9 +86,9 @@ handle_request(void *arg)
goto point1;
}
- char **pieces2 = bc_str_split(pieces[1], '?', 2);
+ char **pieces2 = sb_str_split(pieces[1], '?', 2);
char *path = br_urldecode(pieces2[0]);
- bc_strv_free(pieces2);
+ sb_strv_free(pieces2);
if (path == NULL) {
status_code = 400;
@@ -97,7 +96,7 @@ handle_request(void *arg)
goto point2;
}
- char *abs_path = bc_strdup_printf("%s/%s", docroot, path);
+ char *abs_path = sb_strdup_printf("%s/%s", docroot, path);
char *real_path = realpath(abs_path, NULL);
free(abs_path);
@@ -155,7 +154,7 @@ handle_request(void *arg)
if (add_slash) {
// production webservers usually returns 301 in such cases, but 302 is
// better for development/testing.
- char *tmp = bc_strdup_printf(
+ char *tmp = sb_strdup_printf(
"HTTP/1.0 302 Found\r\n"
"Location: %s/\r\n"
"Content-Length: 0\r\n"
@@ -171,16 +170,16 @@ handle_request(void *arg)
}
size_t len;
- bc_error_t *err = NULL;
- char* contents = bc_file_get_contents(real_path, false, &len, &err);
+ sb_error_t *err = NULL;
+ char* contents = sb_file_get_contents(real_path, &len, &err);
if (err != NULL) {
status_code = 500;
error(client_socket, 500, "Internal Server Error");
- bc_error_free(err);
+ sb_error_free(err);
goto point4;
}
- char *out = bc_strdup_printf(
+ char *out = sb_strdup_printf(
"HTTP/1.0 200 OK\r\n"
"Content-Type: %s\r\n"
"Content-Length: %zu\r\n"
@@ -207,7 +206,7 @@ point1:
fprintf(stderr, "[Thread-%zu] %s - - \"%s\" %d\n", thread_id + 1,
ip, conn_line, status_code);
free(conn_line);
- bc_strv_free(pieces);
+ sb_strv_free(pieces);
point0:
free(ip);
close(client_socket);
@@ -227,7 +226,7 @@ br_httpd_get_ip(int af, const struct sockaddr *addr)
struct sockaddr_in *a = (struct sockaddr_in*) addr;
inet_ntop(af, &(a->sin_addr), host, INET6_ADDRSTRLEN);
}
- return bc_strdup(host);
+ return sb_strdup(host);
}
diff --git a/src/blogc-runserver/main.c b/src/blogc-runserver/main.c
index b9b831a..318652d 100644
--- a/src/blogc-runserver/main.c
+++ b/src/blogc-runserver/main.c
@@ -13,7 +13,8 @@
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "httpd.h"
@@ -66,9 +67,9 @@ main(int argc, char **argv)
char *endptr;
char *tmp_host = getenv("BLOGC_RUNSERVER_DEFAULT_HOST");
- char *default_host = bc_strdup(tmp_host != NULL ? tmp_host : "127.0.0.1");
+ char *default_host = sb_strdup(tmp_host != NULL ? tmp_host : "127.0.0.1");
char *tmp_port = getenv("BLOGC_RUNSERVER_DEFAULT_PORT");
- char *default_port = bc_strdup(tmp_port != NULL ? tmp_port : "8080");
+ char *default_port = sb_strdup(tmp_port != NULL ? tmp_port : "8080");
size_t args = 0;
@@ -83,15 +84,15 @@ main(int argc, char **argv)
goto cleanup;
case 't':
if (argv[i][2] != '\0')
- host = bc_strdup(argv[i] + 2);
+ host = sb_strdup(argv[i] + 2);
else
- host = bc_strdup(argv[++i]);
+ host = sb_strdup(argv[++i]);
break;
case 'p':
if (argv[i][2] != '\0')
- port = bc_strdup(argv[i] + 2);
+ port = sb_strdup(argv[i] + 2);
else
- port = bc_strdup(argv[++i]);
+ port = sb_strdup(argv[++i]);
break;
case 'm':
if (argv[i][2] != '\0')
@@ -120,7 +121,7 @@ main(int argc, char **argv)
goto cleanup;
}
args++;
- docroot = bc_strdup(argv[i]);
+ docroot = sb_strdup(argv[i]);
}
}
diff --git a/src/blogc-runserver/mime.c b/src/blogc-runserver/mime.c
index 18c787c..554fed9 100644
--- a/src/blogc-runserver/mime.c
+++ b/src/blogc-runserver/mime.c
@@ -9,7 +9,8 @@
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
-#include "../common/utils.h"
+#include <squareball.h>
+
#include "httpd-utils.h"
@@ -153,7 +154,7 @@ br_mime_guess_index(const char *path)
{
char *found = NULL;
for (size_t i = 0; content_types[i].index != NULL; i++) {
- char *f = bc_strdup_printf("%s/%s", path, content_types[i].index);
+ char *f = sb_strdup_printf("%s/%s", path, content_types[i].index);
if (0 == access(f, F_OK)) {
found = f;
break;
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 */
diff --git a/src/common/config-parser.c b/src/common/config-parser.c
deleted file mode 100644
index 235209e..0000000
--- a/src/common/config-parser.c
+++ /dev/null
@@ -1,431 +0,0 @@
-/*
- * 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 <stdbool.h>
-#include <stdlib.h>
-#include <string.h>
-#include "error.h"
-#include "utils.h"
-#include "config-parser.h"
-
-
-typedef enum {
- CONFIG_START = 1,
- CONFIG_SECTION_START,
- CONFIG_SECTION,
- CONFIG_SECTION_KEY,
- CONFIG_SECTION_VALUE_START,
- CONFIG_SECTION_VALUE_QUOTE,
- CONFIG_SECTION_VALUE_POST_QUOTED,
- CONFIG_SECTION_VALUE,
- CONFIG_SECTION_LIST_START,
- CONFIG_SECTION_LIST_QUOTE,
- CONFIG_SECTION_LIST_POST_QUOTED,
- CONFIG_SECTION_LIST,
-} bc_configparser_state_t;
-
-typedef enum {
- CONFIG_SECTION_TYPE_MAP = 1,
- CONFIG_SECTION_TYPE_LIST,
-} bc_configparser_section_type_t;
-
-typedef struct {
- bc_configparser_section_type_t type;
- void *data;
-} bc_configparser_section_t;
-
-
-static void
-free_section(bc_configparser_section_t *section)
-{
- if (section == NULL)
- return;
-
- switch (section->type) {
- case CONFIG_SECTION_TYPE_MAP:
- bc_trie_free(section->data);
- break;
- case CONFIG_SECTION_TYPE_LIST:
- bc_slist_free_full(section->data, free);
- break;
- }
- free(section);
-}
-
-
-bc_config_t*
-bc_config_parse(const char *src, size_t src_len, const char *list_sections[],
- bc_error_t **err)
-{
- if (err == NULL || *err != NULL)
- return NULL;
-
- size_t current = 0;
- size_t start = 0;
-
- bc_configparser_section_t *section = NULL;
-
- char *section_name = NULL;
- char *key = NULL;
- bc_string_t *value = NULL;
- bool escaped = false;
-
- bc_config_t *rv = bc_malloc(sizeof(bc_config_t));
- rv->root = bc_trie_new((bc_free_func_t) free_section);
-
- bc_configparser_state_t state = CONFIG_START;
-
- while (current < src_len) {
- char c = src[current];
- bool is_last = current == src_len - 1;
-
- if (escaped) {
- bc_string_append_c(value, c);
- escaped = false;
- current++;
- continue;
- }
-
- if (value != NULL && c == '\\') {
- escaped = true;
- current++;
- continue;
- }
-
- switch (state) {
-
- case CONFIG_START:
- if (c == '#' || c == ';') {
- while (current < src_len) {
- if (src[current] == '\r' || src[current] == '\n')
- break;
- current++;
- }
- break;
- }
- if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
- break;
- if (c == '[') {
- state = CONFIG_SECTION_START;
- break;
- }
- if (section != NULL) {
- start = current;
- switch (section->type) {
- case CONFIG_SECTION_TYPE_MAP:
- state = CONFIG_SECTION_KEY;
- break;
- case CONFIG_SECTION_TYPE_LIST:
- state = CONFIG_SECTION_LIST_START;
- if (value == NULL)
- value = bc_string_new();
- break;
- }
- continue;
- }
- *err = bc_error_parser(BC_ERROR_CONFIG_PARSER, src, src_len,
- current, "File must start with section.");
- break;
-
- case CONFIG_SECTION_START:
- start = current;
- state = CONFIG_SECTION;
- break;
-
- case CONFIG_SECTION:
- if (c == ']') {
- section_name = bc_strndup(src + start, current - start);
- section = bc_malloc(sizeof(bc_configparser_section_t));
- section->type = CONFIG_SECTION_TYPE_MAP;
- if (list_sections != NULL) {
- for (size_t i = 0; list_sections[i] != NULL; i++) {
- if (0 == strcmp(section_name, list_sections[i])) {
- section->type = CONFIG_SECTION_TYPE_LIST;
- break;
- }
- }
- }
- switch (section->type) {
- case CONFIG_SECTION_TYPE_MAP:
- section->data = bc_trie_new(free);
- break;
- case CONFIG_SECTION_TYPE_LIST:
- section->data = NULL;
- break;
- }
- bc_trie_insert(rv->root, section_name, section);
- free(section_name);
- section_name = NULL;
- state = CONFIG_START;
- break;
- }
- if (c != '\r' && c != '\n')
- break;
- *err = bc_error_parser(BC_ERROR_CONFIG_PARSER, src, src_len,
- current, "Section names can't have new lines.");
- break;
-
- case CONFIG_SECTION_KEY:
- if (c == '=') {
- key = bc_strndup(src + start, current - start);
- state = CONFIG_SECTION_VALUE_START;
- if (value == NULL)
- value = bc_string_new();
- break;
- }
- if (c != '\r' && c != '\n' && !is_last)
- break;
- // key without value, should we support it?
- size_t end = is_last && c != '\n' && c != '\r' ? src_len :
- current;
- key = bc_strndup(src + start, end - start);
- *err = bc_error_parser(BC_ERROR_CONFIG_PARSER, src, src_len,
- current, "Key without value: %s.", key);
- free(key);
- key = NULL;
- break;
-
- case CONFIG_SECTION_VALUE_START:
- if (c == ' ' || c == '\t' || c == '\f' || c == '\v')
- break;
- if (c == '"') {
- state = CONFIG_SECTION_VALUE_QUOTE;
- break;
- }
- bc_string_append_c(value, c);
- state = CONFIG_SECTION_VALUE;
- break;
-
- case CONFIG_SECTION_VALUE_QUOTE:
- if (c == '"') {
- bc_trie_insert(section->data, bc_str_strip(key),
- bc_string_free(value, false));
- free(key);
- key = NULL;
- value = NULL;
- state = CONFIG_SECTION_VALUE_POST_QUOTED;
- break;
- }
- bc_string_append_c(value, c);
- break;
-
- case CONFIG_SECTION_VALUE_POST_QUOTED:
- if (c == ' ' || c == '\t' || c == '\f' || c == '\v')
- break;
- if (c == '\r' || c == '\n' || is_last) {
- state = CONFIG_START;
- break;
- }
- *err = bc_error_parser(BC_ERROR_CONFIG_PARSER, src, src_len,
- current, "Invalid value for key, should not have anything "
- "after quotes.");
- break;
-
- case CONFIG_SECTION_VALUE:
- if (c == '\r' || c == '\n' || is_last) {
- if (is_last && c != '\r' && c != '\n')
- bc_string_append_c(value, c);
- bc_trie_insert(section->data, bc_str_strip(key),
- bc_strdup(bc_str_rstrip(value->str)));
- free(key);
- key = NULL;
- bc_string_free(value, true);
- value = NULL;
- state = CONFIG_START;
- break;
- }
- bc_string_append_c(value, c);
- break;
-
- case CONFIG_SECTION_LIST_START:
- if (c == ' ' || c == '\t' || c == '\f' || c == '\v')
- break;
- if (c == '"') {
- state = CONFIG_SECTION_LIST_QUOTE;
- break;
- }
- bc_string_append_c(value, c);
- state = CONFIG_SECTION_LIST;
- break;
-
- case CONFIG_SECTION_LIST_QUOTE:
- if (c == '"') {
- section->data = bc_slist_append(section->data,
- bc_string_free(value, false));
- value = NULL;
- state = CONFIG_SECTION_LIST_POST_QUOTED;
- break;
-
- }
- bc_string_append_c(value, c);
- break;
-
- case CONFIG_SECTION_LIST_POST_QUOTED:
- if (c == ' ' || c == '\t' || c == '\f' || c == '\v')
- break;
- if (c == '\r' || c == '\n' || is_last) {
- state = CONFIG_START;
- break;
- }
- *err = bc_error_parser(BC_ERROR_CONFIG_PARSER, src, src_len,
- current, "Invalid value for list item, should not have "
- "anything after quotes.");
- break;
-
- case CONFIG_SECTION_LIST:
- if (c == '\r' || c == '\n' || is_last) {
- if (is_last && c != '\r' && c != '\n')
- bc_string_append_c(value, c);
- section->data = bc_slist_append(section->data,
- bc_strdup(bc_str_strip(value->str)));
- bc_string_free(value, true);
- value = NULL;
- state = CONFIG_START;
- break;
-
- }
- bc_string_append_c(value, c);
- break;
-
- }
-
- if (*err != NULL) {
- bc_config_free(rv);
- rv = NULL;
- break;
- }
-
- current++;
- }
-
- free(section_name);
- free(key);
- bc_string_free(value, true);
-
- return rv;
-}
-
-
-static void
-list_keys(const char *key, const char *value, bc_slist_t **l)
-{
- *l = bc_slist_append(*l, bc_strdup(key));
-}
-
-
-char**
-bc_config_list_sections(bc_config_t *config)
-{
- if (config == NULL)
- return NULL;
-
- bc_slist_t *l = NULL;
- bc_trie_foreach(config->root, (bc_trie_foreach_func_t) list_keys, &l);
-
- char **rv = bc_malloc(sizeof(char*) * (bc_slist_length(l) + 1));
-
- size_t i = 0;
- for (bc_slist_t *tmp = l; tmp != NULL; tmp = tmp->next, i++)
- rv[i] = tmp->data;
- rv[i] = NULL;
-
- bc_slist_free(l);
-
- return rv;
-}
-
-
-char**
-bc_config_list_keys(bc_config_t *config, const char *section)
-{
- if (config == NULL)
- return NULL;
-
- bc_configparser_section_t *s = bc_trie_lookup(config->root, section);
- if (s == NULL)
- return NULL;
-
- if (s->type != CONFIG_SECTION_TYPE_MAP)
- return NULL;
-
- bc_slist_t *l = NULL;
- bc_trie_foreach(s->data, (bc_trie_foreach_func_t) list_keys, &l);
-
- char **rv = bc_malloc(sizeof(char*) * (bc_slist_length(l) + 1));
-
- size_t i = 0;
- for (bc_slist_t *tmp = l; tmp != NULL; tmp = tmp->next, i++)
- rv[i] = tmp->data;
- rv[i] = NULL;
-
- bc_slist_free(l);
-
- return rv;
-}
-
-
-const char*
-bc_config_get(bc_config_t *config, const char *section, const char *key)
-{
- if (config == NULL)
- return NULL;
-
- bc_configparser_section_t *s = bc_trie_lookup(config->root, section);
- if (s == NULL)
- return NULL;
-
- if (s->type != CONFIG_SECTION_TYPE_MAP)
- return NULL;
-
- return bc_trie_lookup(s->data, key);
-}
-
-
-const char*
-bc_config_get_with_default(bc_config_t *config, const char *section, const char *key,
- const char *default_)
-{
- const char *rv = bc_config_get(config, section, key);
- if (rv == NULL)
- return default_;
- return rv;
-}
-
-
-char**
-bc_config_get_list(bc_config_t *config, const char *section)
-{
- if (config == NULL)
- return NULL;
-
- bc_configparser_section_t *s = bc_trie_lookup(config->root, section);
- if (s == NULL)
- return NULL;
-
- if (s->type != CONFIG_SECTION_TYPE_LIST)
- return NULL;
-
- char **rv = bc_malloc(sizeof(char*) * (bc_slist_length(s->data) + 1));
-
- size_t i = 0;
- for (bc_slist_t *tmp = s->data; tmp != NULL; tmp = tmp->next, i++)
- rv[i] = bc_strdup(tmp->data);
- rv[i] = NULL;
-
- return rv;
-}
-
-
-void
-bc_config_free(bc_config_t *config)
-{
- if (config == NULL)
- return;
- bc_trie_free(config->root);
- free(config);
-}
diff --git a/src/common/config-parser.h b/src/common/config-parser.h
deleted file mode 100644
index e8068f6..0000000
--- a/src/common/config-parser.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * 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 _CONFIG_PARSER_H
-#define _CONFIG_PARSER_H
-
-#include <stddef.h>
-#include "utils.h"
-#include "error.h"
-
-typedef struct {
- bc_trie_t *root;
-} bc_config_t;
-
-bc_config_t* bc_config_parse(const char *src, size_t src_len,
- const char *list_sections[], bc_error_t **err);
-char** bc_config_list_sections(bc_config_t *config);
-char** bc_config_list_keys(bc_config_t *config, const char *section);
-const char* bc_config_get(bc_config_t *config, const char *section,
- const char *key);
-const char* bc_config_get_with_default(bc_config_t *config, const char *section,
- const char *key, const char *default_);
-char** bc_config_get_list(bc_config_t *config, const char *section);
-void bc_config_free(bc_config_t *config);
-
-#endif /* _CONFIG_PARSER_H */
diff --git a/src/common/error.c b/src/common/error.c
deleted file mode 100644
index 19f369c..0000000
--- a/src/common/error.c
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * 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 <stdlib.h>
-#include <stdarg.h>
-#include "error.h"
-#include "utils.h"
-
-
-bc_error_t*
-bc_error_new(bc_error_type_t type, const char *msg)
-{
- bc_error_t *err = bc_malloc(sizeof(bc_error_t));
- err->type = type;
- err->msg = bc_strdup(msg);
- return err;
-}
-
-
-bc_error_t*
-bc_error_new_printf(bc_error_type_t type, const char *format, ...)
-{
- va_list ap;
- va_start(ap, format);
- char *tmp = bc_strdup_vprintf(format, ap);
- va_end(ap);
- bc_error_t *rv = bc_error_new(type, tmp);
- free(tmp);
- return rv;
-}
-
-
-bc_error_t*
-bc_error_parser(bc_error_type_t type, const char *src, size_t src_len,
- size_t current, const char *format, ...)
-{
- va_list ap;
- va_start(ap, format);
- char *msg = bc_strdup_vprintf(format, ap);
- va_end(ap);
-
- size_t lineno = 1;
- size_t linestart = 0;
- size_t lineend = 0;
- size_t pos = 1;
-
- for (size_t i = 0; i < src_len; i++) {
- char c = src[i];
- if (i < current) {
- if ((i + 1) < src_len) {
- if ((c == '\n' && src[i + 1] == '\r') ||
- (c == '\r' && src[i + 1] == '\n'))
- {
- lineno++;
- i++;
- pos = 1;
- if ((i + 1) < src_len)
- linestart = i + 1;
- continue;
- }
- }
- if (c == '\n' || c == '\r') {
- lineno++;
- pos = 1;
- if ((i + 1) < src_len)
- linestart = i + 1;
- continue;
- }
- pos++;
- }
- else if (c == '\n' || c == '\r') {
- lineend = i;
- break;
- }
- }
-
- if (lineend <= linestart && src_len >= linestart)
- lineend = src_len;
-
- char *line = bc_strndup(src + linestart, lineend - linestart);
-
- bc_error_t *rv = NULL;
-
- if (line[0] == '\0') // "near" message isn't useful if line is empty
- rv = bc_error_new(type, msg);
- else
- rv = bc_error_new_printf(type,
- "%s\nError occurred near line %d, position %d: %s", msg, lineno,
- pos, line);
-
- free(msg);
- free(line);
-
- return rv;
-}
-
-
-// error handling is centralized here for the sake of simplicity :/
-void
-bc_error_print(bc_error_t *err, const char *prefix)
-{
- if (err == NULL)
- return;
-
- if (prefix != NULL)
- fprintf(stderr, "%s: ", prefix);
-
- switch(err->type) {
- case BC_ERROR_CONFIG_PARSER:
- fprintf(stderr, "error: config-parser: %s\n", err->msg);
- break;
- case BC_ERROR_FILE:
- fprintf(stderr, "error: file: %s\n", err->msg);
- break;
- 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;
- case BLOGC_MAKE_ERROR_SETTINGS:
- fprintf(stderr, "error: settings: %s\n", err->msg);
- break;
- case BLOGC_MAKE_ERROR_EXEC:
- fprintf(stderr, "error: exec: %s\n", err->msg);
- break;
- default:
- fprintf(stderr, "error: %s\n", err->msg);
- }
-}
-
-
-void
-bc_error_free(bc_error_t *err)
-{
- if (err == NULL)
- return;
- free(err->msg);
- free(err);
-}
diff --git a/src/common/error.h b/src/common/error.h
deleted file mode 100644
index 34aab74..0000000
--- a/src/common/error.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * 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
-
-#include <stddef.h>
-
-// error handling is centralized here for the sake of simplicity :/
-typedef enum {
-
- // errors for src/common
- BC_ERROR_CONFIG_PARSER = 1,
- BC_ERROR_FILE,
-
- // errors for src/blogc
- BLOGC_ERROR_SOURCE_PARSER = 100,
- BLOGC_ERROR_TEMPLATE_PARSER,
- BLOGC_ERROR_LOADER,
- BLOGC_WARNING_DATETIME_PARSER,
-
- // errors for src/blogc-make
- BLOGC_MAKE_ERROR_SETTINGS = 300,
- BLOGC_MAKE_ERROR_EXEC,
- BLOGC_MAKE_ERROR_ATOM,
-
-} bc_error_type_t;
-
-typedef struct {
- char *msg;
- bc_error_type_t type;
-} bc_error_t;
-
-bc_error_t* bc_error_new(bc_error_type_t type, const char *msg);
-bc_error_t* bc_error_new_printf(bc_error_type_t type, const char *format, ...);
-bc_error_t* bc_error_parser(bc_error_type_t type, const char *src,
- size_t src_len, size_t current, const char *format, ...);
-void bc_error_print(bc_error_t *err, const char *prefix);
-void bc_error_free(bc_error_t *err);
-
-#endif /* _ERROR_H */
diff --git a/src/common/file.c b/src/common/file.c
deleted file mode 100644
index adfc22e..0000000
--- a/src/common/file.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * 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 <errno.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include "file.h"
-#include "error.h"
-#include "utf8.h"
-#include "utils.h"
-
-
-char*
-bc_file_get_contents(const char *path, bool utf8, size_t *len, bc_error_t **err)
-{
- if (path == NULL || err == NULL || *err != NULL)
- return NULL;
-
- *len = 0;
- FILE *fp = fopen(path, "r");
-
- if (fp == NULL) {
- int tmp_errno = errno;
- *err = bc_error_new_printf(BC_ERROR_FILE,
- "Failed to open file (%s): %s", path, strerror(tmp_errno));
- return NULL;
- }
-
- bc_string_t *str = bc_string_new();
- char buffer[BC_FILE_CHUNK_SIZE];
- char *tmp;
-
- while (!feof(fp)) {
- size_t read_len = fread(buffer, sizeof(char), BC_FILE_CHUNK_SIZE, fp);
-
- tmp = buffer;
-
- if (utf8 && str->len == 0 && read_len > 0) {
- // skipping BOM before validation, for performance. should be safe
- // enough
- size_t skip = bc_utf8_skip_bom((uint8_t*) buffer, read_len);
- read_len -= skip;
- tmp += skip;
- }
-
- *len += read_len;
- bc_string_append_len(str, tmp, read_len);
- }
- fclose(fp);
-
- if (utf8 && !bc_utf8_validate_str(str)) {
- *err = bc_error_new_printf(BC_ERROR_FILE,
- "File content is not valid UTF-8: %s", path);
- bc_string_free(str, true);
- return NULL;
- }
-
- return bc_string_free(str, false);
-}
diff --git a/src/common/file.h b/src/common/file.h
deleted file mode 100644
index 91224fc..0000000
--- a/src/common/file.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * 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 _FILE_H
-#define _FILE_H
-
-#include <stddef.h>
-#include <stdbool.h>
-#include "error.h"
-
-#define BC_FILE_CHUNK_SIZE 1024
-
-char* bc_file_get_contents(const char *path, bool utf8, size_t *len, bc_error_t **err);
-
-#endif /* _FILE_H */
diff --git a/src/common/stdin.c b/src/common/stdin.c
deleted file mode 100644
index 0c2afd1..0000000
--- a/src/common/stdin.c
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * 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 <stdbool.h>
-#include <stdio.h>
-#include "utils.h"
-#include "stdin.h"
-
-
-// splitted in single file to make it easier to test
-char*
-bc_stdin_read(void)
-{
- int c;
- bc_string_t *rv = bc_string_new();
- while (EOF != (c = fgetc(stdin)))
- bc_string_append_c(rv, c);
- return bc_string_free(rv, false);
-}
diff --git a/src/common/stdin.h b/src/common/stdin.h
deleted file mode 100644
index 825b1bb..0000000
--- a/src/common/stdin.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- * 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 _STDIN_H
-#define _STDIN_H
-
-char* bc_stdin_read(void);
-
-#endif /* _STDIN_H */
diff --git a/src/common/utf8.c b/src/common/utf8.c
deleted file mode 100644
index 5c7b51f..0000000
--- a/src/common/utf8.c
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * blogc: A blog compiler.
- * Copyright (c) 2008-2010 Bjoern Hoehrmann <bjoern@hoehrmann.de>
- * Copyright (c) 2014-2017 Rafael G. Martins <rafael@rafaelmartins.eng.br>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-// Based on Bjoern Hoehrmann's algorithm.
-// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include "utils.h"
-
-#define UTF8_ACCEPT 0
-#define UTF8_REJECT 12
-
-
-static const uint8_t utf8d[] = {
- // The first part of the table maps bytes to character classes that
- // to reduce the size of the transition table and create bitmasks.
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
- 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
- 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
- 8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
- 10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
-
- // The second part is a transition table that maps a combination
- // of a state of the automaton and a character class to a state.
- 0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12,
- 12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12,
- 12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12,
- 12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12,
- 12,36,12,12,12,12,12,12,12,12,12,12,
-};
-
-
-static uint32_t inline
-decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
- uint32_t type = utf8d[byte];
-
- *codep = (*state != UTF8_ACCEPT) ?
- (byte & 0x3fu) | (*codep << 6) :
- (0xff >> type) & (byte);
-
- *state = utf8d[256 + *state + type];
- return *state;
-}
-
-
-bool
-bc_utf8_validate(const uint8_t *str, size_t len)
-{
- uint32_t codepoint;
- uint32_t state = 0;
-
- for (size_t i = 0; i < len; i++)
- decode(&state, &codepoint, str[i]);
-
- return state == UTF8_ACCEPT;
-}
-
-
-bool
-bc_utf8_validate_str(bc_string_t *str)
-{
- return bc_utf8_validate((uint8_t*) str->str, str->len);
-}
-
-
-size_t
-bc_utf8_skip_bom(const uint8_t *str, size_t len)
-{
- if (len < 3)
- return 0;
-
- if (str[0] == 0xef && str[1] == 0xbb && str[2] == 0xbf)
- return 3;
-
- return 0;
-}
diff --git a/src/common/utf8.h b/src/common/utf8.h
deleted file mode 100644
index 206a2cc..0000000
--- a/src/common/utf8.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * 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 _UTF_8_H
-#define _UTF_8_H
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include "utils.h"
-
-bool bc_utf8_validate(const uint8_t *str, size_t len);
-bool bc_utf8_validate_str(bc_string_t *str);
-size_t bc_utf8_skip_bom(const uint8_t *str, size_t len);
-
-#endif /* _UTF_8_H */
diff --git a/src/common/utils.c b/src/common/utils.c
deleted file mode 100644
index 563d8ab..0000000
--- a/src/common/utils.c
+++ /dev/null
@@ -1,667 +0,0 @@
-/*
- * 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.
- */
-
-#define BC_STRING_CHUNK_SIZE 128
-
-#include <string.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "utils.h"
-
-
-void*
-bc_malloc(size_t size)
-{
- // simple things simple!
- void *rv = malloc(size);
- if (rv == NULL) {
- fprintf(stderr, "fatal: Failed to allocate memory!\n");
- abort();
- }
- return rv;
-}
-
-
-void*
-bc_realloc(void *ptr, size_t size)
-{
- // simple things even simpler :P
- void *rv = realloc(ptr, size);
- if (rv == NULL && size != 0) {
- fprintf(stderr, "fatal: Failed to reallocate memory!\n");
- free(ptr);
- abort();
- }
- return rv;
-}
-
-
-bc_slist_t*
-bc_slist_append(bc_slist_t *l, void *data)
-{
- bc_slist_t *node = bc_malloc(sizeof(bc_slist_t));
- node->data = data;
- node->next = NULL;
- if (l == NULL) {
- l = node;
- }
- else {
- bc_slist_t *tmp;
- for (tmp = l; tmp->next != NULL; tmp = tmp->next);
- tmp->next = node;
- }
- return l;
-}
-
-
-bc_slist_t*
-bc_slist_prepend(bc_slist_t *l, void *data)
-{
- bc_slist_t *node = bc_malloc(sizeof(bc_slist_t));
- node->data = data;
- node->next = l;
- l = node;
- return l;
-}
-
-
-void
-bc_slist_free_full(bc_slist_t *l, bc_free_func_t free_func)
-{
- while (l != NULL) {
- bc_slist_t *tmp = l->next;
- if ((free_func != NULL) && (l->data != NULL))
- free_func(l->data);
- free(l);
- l = tmp;
- }
-}
-
-
-void
-bc_slist_free(bc_slist_t *l)
-{
- bc_slist_free_full(l, NULL);
-}
-
-
-size_t
-bc_slist_length(bc_slist_t *l)
-{
- if (l == NULL)
- return 0;
- size_t i;
- bc_slist_t *tmp;
- for (tmp = l, i = 0; tmp != NULL; tmp = tmp->next, i++);
- return i;
-}
-
-
-char*
-bc_strdup(const char *s)
-{
- if (s == NULL)
- return NULL;
- size_t l = strlen(s);
- char *tmp = malloc(l + 1);
- if (tmp == NULL)
- return NULL;
- memcpy(tmp, s, l + 1);
- return tmp;
-}
-
-
-char*
-bc_strndup(const char *s, size_t n)
-{
- if (s == NULL)
- return NULL;
- size_t l = strnlen(s, n);
- char *tmp = malloc(l + 1);
- if (tmp == NULL)
- return NULL;
- memcpy(tmp, s, l);
- tmp[l] = '\0';
- return tmp;
-}
-
-
-char*
-bc_strdup_vprintf(const char *format, va_list ap)
-{
- va_list ap2;
- va_copy(ap2, ap);
- int l = vsnprintf(NULL, 0, format, ap2);
- va_end(ap2);
- if (l < 0)
- return NULL;
- char *tmp = malloc(l + 1);
- if (!tmp)
- return NULL;
- int l2 = vsnprintf(tmp, l + 1, format, ap);
- if (l2 < 0) {
- free(tmp);
- return NULL;
- }
- return tmp;
-}
-
-
-char*
-bc_strdup_printf(const char *format, ...)
-{
- va_list ap;
- va_start(ap, format);
- char *tmp = bc_strdup_vprintf(format, ap);
- va_end(ap);
- return tmp;
-}
-
-
-bool
-bc_str_starts_with(const char *str, const char *prefix)
-{
- int str_l = strlen(str);
- int str_lp = strlen(prefix);
- if (str_lp > str_l)
- return false;
- return strncmp(str, prefix, str_lp) == 0;
-}
-
-
-bool
-bc_str_ends_with(const char *str, const char *suffix)
-{
- int str_l = strlen(str);
- int str_ls = strlen(suffix);
- if (str_ls > str_l)
- return false;
- return strcmp(str + str_l - str_ls, suffix) == 0;
-}
-
-
-char*
-bc_str_lstrip(char *str)
-{
- if (str == NULL)
- return NULL;
- int i;
- size_t str_len = strlen(str);
- for (i = 0; i < str_len; i++) {
- if ((str[i] != ' ') && (str[i] != '\t') && (str[i] != '\n') &&
- (str[i] != '\r') && (str[i] != '\t') && (str[i] != '\f') &&
- (str[i] != '\v'))
- {
- str += i;
- break;
- }
- if (i == str_len - 1) {
- str += str_len;
- break;
- }
- }
- return str;
-}
-
-
-char*
-bc_str_rstrip(char *str)
-{
- if (str == NULL)
- return NULL;
- int i;
- size_t str_len = strlen(str);
- for (i = str_len - 1; i >= 0; i--) {
- if ((str[i] != ' ') && (str[i] != '\t') && (str[i] != '\n') &&
- (str[i] != '\r') && (str[i] != '\t') && (str[i] != '\f') &&
- (str[i] != '\v'))
- {
- str[i + 1] = '\0';
- break;
- }
- if (i == 0) {
- str[0] = '\0';
- break;
- }
- }
- return str;
-}
-
-
-char*
-bc_str_strip(char *str)
-{
- return bc_str_lstrip(bc_str_rstrip(str));
-}
-
-
-char**
-bc_str_split(const char *str, char c, size_t max_pieces)
-{
- if (str == NULL)
- return NULL;
- char **rv = bc_malloc(sizeof(char*));
- size_t i, start = 0, count = 0;
- for (i = 0; i < strlen(str) + 1; i++) {
- if (str[0] == '\0')
- break;
- if ((str[i] == c && (!max_pieces || count + 1 < max_pieces)) || str[i] == '\0') {
- rv = bc_realloc(rv, (count + 1) * sizeof(char*));
- rv[count] = bc_malloc(i - start + 1);
- memcpy(rv[count], str + start, i - start);
- rv[count++][i - start] = '\0';
- start = i + 1;
- }
- }
- rv = bc_realloc(rv, (count + 1) * sizeof(char*));
- rv[count] = NULL;
- return rv;
-}
-
-
-char*
-bc_str_replace(const char *str, const char search, const char *replace)
-{
- char **pieces = bc_str_split(str, search, 0);
- if (pieces == NULL)
- return NULL;
- char* rv = bc_strv_join(pieces, replace);
- bc_strv_free(pieces);
- if (rv == NULL)
- return bc_strdup(str);
- return rv;
-}
-
-
-char*
-bc_str_find(const char *str, char c)
-{
- // this is somewhat similar to strchr, but respects '\' escaping.
- if (str == NULL)
- return NULL;
- if (c == '\0')
- return (char*) str + strlen(str);
- for (size_t i = 0; str[i] != '\0'; i++) {
- if (str[i] == '\\') {
- i++;
- continue;
- }
- if (str[i] == c) {
- return (char*) str + i;
- }
- }
- return NULL;
-}
-
-
-void
-bc_strv_free(char **strv)
-{
- if (strv == NULL)
- return;
- for (size_t i = 0; strv[i] != NULL; i++)
- free(strv[i]);
- free(strv);
-}
-
-
-char*
-bc_strv_join(char **strv, const char *separator)
-{
- if (strv == NULL || separator == NULL)
- return NULL;
- bc_string_t *str = bc_string_new();
- for (size_t i = 0; strv[i] != NULL; i++) {
- str = bc_string_append(str, strv[i]);
- if (strv[i + 1] != NULL)
- str = bc_string_append(str, separator);
- }
- return bc_string_free(str, false);
-}
-
-
-size_t
-bc_strv_length(char **strv)
-{
- if (strv == NULL)
- return 0;
- size_t i;
- for (i = 0; strv[i] != NULL; i++);
- return i;
-}
-
-
-bc_string_t*
-bc_string_new(void)
-{
- bc_string_t* rv = bc_malloc(sizeof(bc_string_t));
- rv->str = NULL;
- rv->len = 0;
- rv->allocated_len = 0;
-
- // initialize with empty string
- rv = bc_string_append(rv, "");
-
- return rv;
-}
-
-
-char*
-bc_string_free(bc_string_t *str, bool free_str)
-{
- if (str == NULL)
- return NULL;
- char *rv = NULL;
- if (free_str)
- free(str->str);
- else
- rv = str->str;
- free(str);
- return rv;
-}
-
-
-bc_string_t*
-bc_string_dup(bc_string_t *str)
-{
- if (str == NULL)
- return NULL;
- bc_string_t* new = bc_string_new();
- return bc_string_append_len(new, str->str, str->len);
-}
-
-
-bc_string_t*
-bc_string_append_len(bc_string_t *str, const char *suffix, size_t len)
-{
- if (str == NULL)
- return NULL;
- if (suffix == NULL)
- return str;
- size_t old_len = str->len;
- str->len += len;
- if (str->len + 1 > str->allocated_len) {
- str->allocated_len = (((str->len + 1) / BC_STRING_CHUNK_SIZE) + 1) * BC_STRING_CHUNK_SIZE;
- str->str = bc_realloc(str->str, str->allocated_len);
- }
- memcpy(str->str + old_len, suffix, len);
- str->str[str->len] = '\0';
- return str;
-}
-
-
-bc_string_t*
-bc_string_append(bc_string_t *str, const char *suffix)
-{
- if (str == NULL)
- return NULL;
- const char *my_suffix = suffix == NULL ? "" : suffix;
- return bc_string_append_len(str, my_suffix, strlen(my_suffix));
-}
-
-
-bc_string_t*
-bc_string_append_c(bc_string_t *str, char c)
-{
- if (str == NULL)
- return NULL;
- size_t old_len = str->len;
- str->len += 1;
- if (str->len + 1 > str->allocated_len) {
- str->allocated_len = (((str->len + 1) / BC_STRING_CHUNK_SIZE) + 1) * BC_STRING_CHUNK_SIZE;
- str->str = bc_realloc(str->str, str->allocated_len);
- }
- str->str[old_len] = c;
- str->str[str->len] = '\0';
- return str;
-}
-
-
-bc_string_t*
-bc_string_append_printf(bc_string_t *str, const char *format, ...)
-{
- if (str == NULL)
- return NULL;
- va_list ap;
- va_start(ap, format);
- char *tmp = bc_strdup_vprintf(format, ap);
- va_end(ap);
- str = bc_string_append(str, tmp);
- free(tmp);
- return str;
-}
-
-
-bc_string_t*
-bc_string_append_escaped(bc_string_t *str, const char *suffix)
-{
- if (str == NULL)
- return NULL;
- if (suffix == NULL)
- return str;
- bool escaped = false;
- for (size_t i = 0; suffix[i] != '\0'; i++) {
- if (suffix[i] == '\\' && !escaped) {
- escaped = true;
- continue;
- }
- escaped = false;
- str = bc_string_append_c(str, suffix[i]);
- }
- return str;
-}
-
-
-bc_trie_t*
-bc_trie_new(bc_free_func_t free_func)
-{
- bc_trie_t *trie = bc_malloc(sizeof(bc_trie_t));
- trie->root = NULL;
- trie->free_func = free_func;
- return trie;
-}
-
-
-static void
-bc_trie_free_node(bc_trie_t *trie, bc_trie_node_t *node)
-{
- if (trie == NULL || node == NULL)
- return;
- if (node->data != NULL && trie->free_func != NULL)
- trie->free_func(node->data);
- bc_trie_free_node(trie, node->next);
- bc_trie_free_node(trie, node->child);
- free(node);
-}
-
-
-void
-bc_trie_free(bc_trie_t *trie)
-{
- if (trie == NULL)
- return;
- bc_trie_free_node(trie, trie->root);
- free(trie);
-}
-
-
-void
-bc_trie_insert(bc_trie_t *trie, const char *key, void *data)
-{
- if (trie == NULL || key == NULL || data == NULL)
- return;
-
- bc_trie_node_t *parent = NULL;
- bc_trie_node_t *previous;
- bc_trie_node_t *current;
- bc_trie_node_t *tmp;
-
- while (1) {
-
- if (trie->root == NULL || (parent != NULL && parent->child == NULL)) {
- current = bc_malloc(sizeof(bc_trie_node_t));
- current->key = *key;
- current->data = NULL;
- current->next = NULL;
- current->child = NULL;
- if (trie->root == NULL)
- trie->root = current;
- else
- parent->child = current;
- parent = current;
- goto clean;
- }
-
- tmp = parent == NULL ? trie->root : parent->child;
- previous = NULL;
-
- while (tmp != NULL && tmp->key != *key) {
- previous = tmp;
- tmp = tmp->next;
- }
-
- parent = tmp;
-
- if (previous == NULL || parent != NULL)
- goto clean;
-
- current = bc_malloc(sizeof(bc_trie_node_t));
- current->key = *key;
- current->data = NULL;
- current->next = NULL;
- current->child = NULL;
- previous->next = current;
- parent = current;
-
-clean:
- if (*key == '\0') {
- if (parent->data != NULL && trie->free_func != NULL)
- trie->free_func(parent->data);
- parent->data = data;
- break;
- }
- key++;
- }
-}
-
-
-void*
-bc_trie_lookup(bc_trie_t *trie, const char *key)
-{
- if (trie == NULL || trie->root == NULL || key == NULL)
- return NULL;
-
- bc_trie_node_t *parent = trie->root;
- bc_trie_node_t *tmp;
- while (1) {
- for (tmp = parent; tmp != NULL; tmp = tmp->next) {
-
- if (tmp->key == *key) {
- if (tmp->key == '\0')
- return tmp->data;
- parent = tmp->child;
- break;
- }
- }
- if (tmp == NULL)
- return NULL;
-
- if (*key == '\0')
- break;
- key++;
- }
- return NULL;
-}
-
-
-static void
-bc_trie_size_node(bc_trie_node_t *node, size_t *count)
-{
- if (node == NULL || count == NULL)
- return;
-
- if (node->key == '\0')
- (*count)++;
-
- bc_trie_size_node(node->next, count);
- bc_trie_size_node(node->child, count);
-}
-
-
-size_t
-bc_trie_size(bc_trie_t *trie)
-{
- if (trie == NULL)
- return 0;
-
- size_t count = 0;
- bc_trie_size_node(trie->root, &count);
- return count;
-}
-
-
-static void
-bc_trie_foreach_node(bc_trie_node_t *node, bc_string_t *str,
- bc_trie_foreach_func_t func, void *user_data)
-{
- if (node == NULL || str == NULL || func == NULL)
- return;
-
- if (node->key == '\0')
- func(str->str, node->data, user_data);
-
- if (node->child != NULL) {
- bc_string_t *child = bc_string_dup(str);
- child = bc_string_append_c(child, node->key);
- bc_trie_foreach_node(node->child, child, func, user_data);
- bc_string_free(child, true);
- }
-
- if (node->next != NULL)
- bc_trie_foreach_node(node->next, str, func, user_data);
-}
-
-
-void
-bc_trie_foreach(bc_trie_t *trie, bc_trie_foreach_func_t func,
- void *user_data)
-{
- if (trie == NULL || trie->root == NULL || func == NULL)
- return;
-
- bc_string_t *str = bc_string_new();
- bc_trie_foreach_node(trie->root, str, func, user_data);
- bc_string_free(str, true);
-}
-
-
-char*
-bc_shell_quote(const char *command)
-{
- bc_string_t *rv = bc_string_new();
- bc_string_append_c(rv, '\'');
- if (command != NULL) {
- for (size_t i = 0; i < strlen(command); i++) {
- switch (command[i]) {
- case '!':
- bc_string_append(rv, "'\\!'");
- break;
- case '\'':
- bc_string_append(rv, "'\\''");
- break;
- default:
- bc_string_append_c(rv, command[i]);
- }
- }
- }
- bc_string_append_c(rv, '\'');
- return bc_string_free(rv, false);
-}
diff --git a/src/common/utils.h b/src/common/utils.h
deleted file mode 100644
index 0f05c96..0000000
--- a/src/common/utils.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * 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 _UTILS_H
-#define _UTILS_H
-
-#include <stddef.h>
-#include <stdarg.h>
-#include <stdbool.h>
-
-
-// memory
-
-typedef void (*bc_free_func_t) (void *ptr);
-
-void* bc_malloc(size_t size);
-void* bc_realloc(void *ptr, size_t size);
-
-
-// slist
-
-typedef struct _bc_slist_t {
- struct _bc_slist_t *next;
- void *data;
-} bc_slist_t;
-
-bc_slist_t* bc_slist_append(bc_slist_t *l, void *data);
-bc_slist_t* bc_slist_prepend(bc_slist_t *l, void *data);
-void bc_slist_free(bc_slist_t *l);
-void bc_slist_free_full(bc_slist_t *l, bc_free_func_t free_func);
-size_t bc_slist_length(bc_slist_t *l);
-
-
-// strfuncs
-
-char* bc_strdup(const char *s);
-char* bc_strndup(const char *s, size_t n);
-char* bc_strdup_vprintf(const char *format, va_list ap);
-char* bc_strdup_printf(const char *format, ...);
-bool bc_str_starts_with(const char *str, const char *prefix);
-bool bc_str_ends_with(const char *str, const char *suffix);
-char* bc_str_lstrip(char *str);
-char* bc_str_rstrip(char *str);
-char* bc_str_strip(char *str);
-char** bc_str_split(const char *str, char c, size_t max_pieces);
-char* bc_str_replace(const char *str, const char search, const char *replace);
-char* bc_str_find(const char *str, char c);
-void bc_strv_free(char **strv);
-char* bc_strv_join(char **strv, const char *separator);
-size_t bc_strv_length(char **strv);
-
-
-// string
-
-typedef struct {
- char *str;
- size_t len;
- size_t allocated_len;
-} bc_string_t;
-
-bc_string_t* bc_string_new(void);
-char* bc_string_free(bc_string_t *str, bool free_str);
-bc_string_t* bc_string_dup(bc_string_t *str);
-bc_string_t* bc_string_append_len(bc_string_t *str, const char *suffix, size_t len);
-bc_string_t* bc_string_append(bc_string_t *str, const char *suffix);
-bc_string_t* bc_string_append_c(bc_string_t *str, char c);
-bc_string_t* bc_string_append_printf(bc_string_t *str, const char *format, ...);
-bc_string_t* bc_string_append_escaped(bc_string_t *str, const char *suffix);
-
-
-// trie
-
-typedef struct _bc_trie_node_t {
- char key;
- void *data;
- struct _bc_trie_node_t *next, *child;
-} bc_trie_node_t;
-
-struct _bc_trie_t {
- bc_trie_node_t *root;
- bc_free_func_t free_func;
-};
-
-typedef struct _bc_trie_t bc_trie_t;
-
-typedef void (*bc_trie_foreach_func_t)(const char *key, void *data,
- void *user_data);
-
-bc_trie_t* bc_trie_new(bc_free_func_t free_func);
-void bc_trie_free(bc_trie_t *trie);
-void bc_trie_insert(bc_trie_t *trie, const char *key, void *data);
-void* bc_trie_lookup(bc_trie_t *trie, const char *key);
-size_t bc_trie_size(bc_trie_t *trie);
-void bc_trie_foreach(bc_trie_t *trie, bc_trie_foreach_func_t func,
- void *user_data);
-
-
-// shell
-
-char* bc_shell_quote(const char *command);
-
-#endif /* _UTILS_H */