misc

1 files changed, 413 insertions, 0 deletions

diff --git a/scripts/jezup.c b/scripts/jezup.c
new file mode 100644
index 0000000..b09e8d5
--- /dev/null
+++ b/scripts/jezup.c
@@ -0,0 +1,413 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <string.h>
+#include "neostr.h"
+
+#define owned /* needs to be freed */
+#define borrowed /* does not need to be freed */
+
+/* Global Variables */
+bool debug = 0;
+
+/* Structures */
+enum result 
+{
+    result_success,
+    result_error,
+};
+
+typedef struct char_ptr 
+{
+    borrowed char *ptr;
+    size_t        size;
+} char_ptr;
+
+struct Jezup
+{
+    borrowed const char *registered_input_file;
+    borrowed const char *registered_template_file;
+    owned char *input_str;
+    owned char *template_str;
+};
+
+/* Functions */
+owned char   *char_ptr_copy_alloc(char_ptr cp);
+bool         char_ptr_is_null(char_ptr cp);
+char_ptr     char_ptr_new(borrowed char *ptr, size_t size);
+char_ptr     char_ptr_new_null(void);
+owned char   *freadall(const char *path);
+void         jezup_free(struct Jezup *jz);
+struct Jezup jezup_new(void);
+enum result  jezup_register_input_file(struct Jezup *jz, const char *file);
+enum result  jezup_register_template_file(struct Jezup *jz, const char *file);
+char_ptr     jezup_get_date(const struct Jezup *jz, bool *has_date);
+char_ptr     jezup_get_title(const struct Jezup *jz);
+char_ptr     jezup_get_contents(const struct Jezup *jz);
+owned char   *jezup_substitute(struct Jezup *jz);
+owned char   *jezup_substitute_into_html(const struct Jezup *jz);
+void         dbg(const char *fmt, ...);
+void         usage(void);
+
+/* Function Implementations */
+
+/* Given a char_ptr, copy the pointed to segment as a new allocation and 
+ * return the pointer to the newly allocated memory. Caller to free(). */
+owned char *
+char_ptr_copy_alloc(char_ptr cp)
+{
+    char *buf = (char*)malloc(cp.size);
+    if (!buf) 
+	return NULL;
+
+    strncpy(buf, cp.ptr, cp.size);
+    buf[cp.size] = '\0';
+    return buf;
+}
+
+bool
+char_ptr_is_null(char_ptr cp)
+{
+    return (!cp.ptr && cp.size == 0);
+}
+
+char_ptr
+char_ptr_new(borrowed char *ptr, size_t size)
+{
+    return (char_ptr) { ptr, size };
+}
+
+char_ptr
+char_ptr_new_null(void)
+{
+    return (char_ptr) { (char*)NULL, 0 };
+}
+
+
+owned char * /* caller to free */
+freadall(const char *path)
+{
+    FILE *f;
+    long fsize;
+    char *buf;
+
+    f = fopen(path, "rb");
+    if (!f)
+	goto error;
+    fseek(f, 0, SEEK_END);
+    fsize = ftell(f);
+    fseek(f, 0, SEEK_SET);
+
+    buf = (char*)malloc(fsize + 1);
+    if (!buf) 
+	goto error;
+
+    fread(buf, fsize, 1, f);
+    fclose(f);
+
+    buf[fsize] = 0;
+    return buf;
+
+error:
+    fclose(f);
+    return NULL;
+}
+
+struct Jezup
+jezup_new(void)
+{
+    return (struct Jezup) { NULL, NULL, NULL, NULL };
+}
+
+void
+jezup_free(struct Jezup *jz) 
+{
+    free(jz->input_str);
+    free(jz->template_str);
+}
+
+enum result
+jezup_register_input_file(struct Jezup *jz, const char *file)
+{
+    if (!file)
+	return result_error;
+
+    jz->registered_input_file = file;
+
+    /* read contents of file */
+    jz->input_str = freadall(file);
+
+    if (!jz->input_str)
+        return result_error;
+    else
+        return result_success;
+}
+
+enum result 
+jezup_register_template_file(struct Jezup *jz, const char *file)
+{
+    if (!file)
+	return result_error;
+
+    jz->registered_template_file = file;
+
+    /* read contents of file */
+    jz->template_str = freadall(file);
+
+    if (!jz->template_str)
+        return result_error;
+    else
+        return result_success;
+}
+
+char_ptr
+jezup_get_date(const struct Jezup *jz, bool *has_date)
+{
+    char_ptr p;
+
+    /* Iterate just until the first newline ... */
+    p = (char_ptr) { jz->input_str, 0 };
+    for (; *(p.ptr + p.size) != '\n'; p.size++);
+    p.size++; /* account for the newline */
+    p.ptr = p.ptr + p.size; /* set current position to date pos */
+    p.size = 0; /* reset size to be changed lower down */
+
+    /* If the next character is a newline, there is no date and we return NULL. */
+    if (*p.ptr == '\n')
+    {
+	*has_date = false;
+	return char_ptr_new_null();
+    }
+
+    /* We have content on the second line, so return this. */
+    for (; *(p.ptr + p.size) != NULL; p.size++)
+	if (*(p.ptr + p.size) == '\n')
+	    break;
+
+    *has_date = true;
+    return p;
+
+
+}
+
+char_ptr
+jezup_get_title(const struct Jezup *jz)
+{
+    /* The title guaranteed to be the contents of the first line, and 
+     * must be populated. As such, we scan until the first newline. */
+    char_ptr p;
+    p = (char_ptr) { jz->input_str, 0 };
+
+    for (; *(p.ptr + p.size) != NULL; p.size++)
+        if (*(p.ptr + p.size) == '\n')
+            break;
+
+    return p;
+}
+
+char_ptr
+jezup_get_contents(const struct Jezup *jz)
+{
+    char_ptr p;
+    bool first;
+    size_t tmp;
+
+    p = char_ptr_new(jz->input_str, 0);
+    first = false;
+
+    for (; *(p.ptr + p.size) != NULL; p.size++)
+    {
+        if (*(p.ptr + p.size) == '\n' && first)
+            goto found;
+        else if (*(p.ptr + p.size) == '\n' && !first)
+            first = true;
+        else 
+            first = false;
+    }
+
+    return char_ptr_new_null();
+
+found:
+    tmp = p.size; /* we need to swap p.size into p.ptr */
+    p.ptr += p.size + 1;
+    p.size = strlen(jz->input_str) - tmp;
+    return p;
+}
+
+/* Takes a char_ptr to the contents, and allocates a new owned string 
+ * with the contents converted to HTML. 
+ */
+owned char *
+jezup_to_html(const struct Jezup *jz, char_ptr cp)
+{
+    /* This function should substitute each part of a Jezup syntax into the 
+     * equivalent structure in HTML. Additionally, each paragraph should be 
+     * placed within <p></p> tags.
+     * HTML	Jezup
+     * <p>	Any string of text separated by at most one newline, and not 
+     *          falling under any other tag. 
+     * <hN>     #, ##, ###, etc. at the beginning of the line. 
+     * 
+     */
+
+    /* Placing each paragraph within <p></p>. */
+    // 1) identify paragraph, surround with <p></p>
+    // A <p> tag is placed at the start of a sequence, and following each 
+    // newline, if followed by: 
+    // 1. (</p><ol>), - (</p><ul>), \n (</p>)
+    char *tmp = char_ptr_copy_alloc(cp);
+    char *result0 = neostr_linewise_replace_prefix_with_circumfix(tmp, "# ", "<h1>", "</h1>");
+    char *result1 = neostr_linewise_replace_prefix_with_circumfix(result0, "## ", "<h2>", "</h2>");
+    char *result2 = neostr_linewise_replace_prefix_with_circumfix(result1, "### ", "<h3>", "</h3>");
+
+    free(tmp);
+    free(result0);
+    free(result1);
+
+    return result2;
+    
+}
+ 
+owned char *
+jezup_substitute_into_html(const struct Jezup *jz)
+{
+    char_ptr title, date, contents;
+    owned const char *contents_as_html, *result0, *result1, *result2;
+    bool has_date;
+
+    title, date, contents = char_ptr_new_null();
+
+    title    = jezup_get_title(jz);
+    if (char_ptr_is_null(title))
+	return NULL;
+    dbg("jezup_substitute_into_html: title nonnull");
+
+    date     = jezup_get_date(jz, &has_date);
+    dbg("jezup_substitute_into_html: date nonnull");
+
+    contents = jezup_get_contents(jz);
+    if (char_ptr_is_null(contents))
+	return NULL;
+    dbg("jezup_substitute_into_html: contents nonnull");
+
+    contents_as_html = jezup_to_html(jz, contents);
+    if (!contents_as_html)
+	return NULL;
+    dbg("jezup_substitute_into_html: contents as html nonnull");
+
+
+    /* Substitute */
+    char *alloc_title = NULL, *alloc_date = NULL, *alloc_contents = NULL;
+
+    /* substitute title */
+    alloc_title = char_ptr_copy_alloc(title);
+    result0 = neostr_replace_all(jz->template_str, "$$TITLE$$", alloc_title);
+
+    /* date */
+    if (!char_ptr_is_null(date))
+    {
+	alloc_date  = char_ptr_copy_alloc(date);
+	result1 = neostr_replace_all(result0, "$$DATE$$", alloc_date); 
+    }
+    else /* so result1 is valid */
+    {
+	result1 = result0;
+    }
+
+    /* content */
+    result2 = neostr_replace_all(result1, "$$CONTENT$$", contents_as_html);
+
+    free(result0); 
+    free(alloc_title); 
+    free(alloc_contents);
+    free(contents_as_html);
+
+    if (!char_ptr_is_null(date)) /* to stop double-free if date not subbed */
+        free(result1);
+    else
+	free(alloc_date);
+
+    return result2;
+    // freelist: result0, result1, contents_as_html, alloc_title, _date, _contents
+}
+
+void
+dbg(const char *fmt, ...)
+{
+    if (!debug)
+	return;
+
+    va_list ap;
+     
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+
+    printf("%s\n", fmt);
+}
+
+void
+usage(void)
+{
+    printf("jezup: convert Jezup to HTML\n");
+    printf("  Jezup is a Markdown-like language with a specific syntax to \n"
+	   "  provide a title and date. The first line must be the title; \n"
+	   "  the second line can optionally contain a date, and the      \n"
+	   "  contents follow after this with a Markdown syntax.          \n"
+	   "The syntax is:                                                \n"
+	   "  jezup -i INPUT_FILE -o OUTPUT_FILE -t HTML_TEMPLATE         \n"
+	  );
+
+}
+
+
+int main(int argc, char **argv)
+{
+    struct Jezup jezup;
+    int i; 
+    char *arg = NULL, *output = NULL, *input = NULL, *template = NULL;
+    enum result res = result_error;
+
+    for (i = 0; i < argc; ++i)
+    {
+	arg = argv[i];
+	if (!strcmp(arg, "-o"))
+	    output = argv[++i];
+	else if (!strcmp(arg, "-i"))
+	    input = argv[++i];
+	else if (!strcmp(arg, "-t"))
+	    template = argv[++i];
+	else if (!strcmp(arg, "-d"))
+	    debug = true;
+	else if (!strcmp(arg, "-h"))
+	{
+	    usage(); return 0;
+	}
+	else
+	    ;
+    }
+
+    jezup = jezup_new();
+
+    res = jezup_register_input_file(&jezup, input);
+    if (res != result_success)
+	goto error;
+    dbg("registered input");
+
+    jezup_register_template_file(&jezup, template);
+    if (res != result_success)
+	goto error;
+    dbg("registered template");
+
+    output = jezup_substitute_into_html(&jezup);
+    dbg("substituted into html");
+
+    printf("%s\n", output);
+
+    return 0;
+    error:
+	jezup_free(&jezup);
+	fprintf(stderr, "error\n");
+	return -1;
+}