pkg update and first config fix

org-brain not working, add org-roam

lisp/emacsql-sqlite/sqlite/Makefile

@@ -0,0 +1,19 @@
+-include ../.config.mk
+
+.POSIX:
+LDLIBS = -ldl -lm
+CFLAGS = -O2 -Wall -Wextra -Wno-implicit-fallthrough \
+    -DSQLITE_THREADSAFE=0 \
+    -DSQLITE_DEFAULT_FOREIGN_KEYS=1 \
+    -DSQLITE_ENABLE_FTS5 \
+    -DSQLITE_ENABLE_FTS4 \
+    -DSQLITE_ENABLE_FTS3_PARENTHESIS \
+    -DSQLITE_ENABLE_RTREE \
+    -DSQLITE_ENABLE_JSON1 \
+    -DSQLITE_SOUNDEX
+
+emacsql-sqlite: emacsql.c sqlite3.c
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ emacsql.c sqlite3.c $(LDLIBS)
+
+clean:
+	rm -f emacsql-sqlite

lisp/emacsql-sqlite/sqlite/emacsql.c

@@ -0,0 +1,183 @@
+/* This is free and unencumbered software released into the public domain.  */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "sqlite3.h"
+
+#define TRUE 1
+#define FALSE 0
+
+char* escape(const char *message) {
+    int i, count = 0, length_orig = strlen(message);
+    for (i = 0; i < length_orig; i++) {
+        if (strchr("\"\\", message[i])) {
+            count++;
+        }
+    }
+    char *copy = malloc(length_orig + count + 1);
+    char *p = copy;
+    while (*message) {
+        if (strchr("\"\\", *message)) {
+            *p = '\\';
+            p++;
+        }
+        *p = *message;
+        message++;
+        p++;
+    }
+    *p = '\0';
+    return copy;
+}
+
+void send_error(int code, const char *message) {
+    char *escaped = escape(message);
+    printf("error %d \"%s\"\n", code, escaped);
+    free(escaped);
+}
+
+typedef struct {
+    char *buffer;
+    size_t size;
+} buffer;
+
+buffer* buffer_create() {
+    buffer *buffer = malloc(sizeof(*buffer));
+    buffer->size = 4096;
+    buffer->buffer = malloc(buffer->size * sizeof(char));
+    return buffer;
+}
+
+int buffer_grow(buffer *buffer) {
+    unsigned factor = 2;
+    char *newbuffer = realloc(buffer->buffer, buffer->size * factor);
+    if (newbuffer == NULL) {
+        return FALSE;
+    }
+    buffer->buffer = newbuffer;
+    buffer->size *= factor;
+    return TRUE;
+}
+
+int buffer_read(buffer *buffer, size_t count) {
+    while (buffer->size < count + 1) {
+        if (buffer_grow(buffer) == FALSE) {
+            return FALSE;
+        }
+    }
+    size_t in = fread((void *) buffer->buffer, 1, count, stdin);
+    buffer->buffer[count] = '\0';
+    return in == count;
+}
+
+void buffer_free(buffer *buffer) {
+    free(buffer->buffer);
+    free(buffer);
+}
+
+int main(int argc, char **argv) {
+    char *file = NULL;
+    if (argc != 2) {
+        fprintf(stderr,
+                "error: require exactly one argument, the DB filename\n");
+        exit(EXIT_FAILURE);
+    } else {
+        file = argv[1];
+    }
+
+    /* On Windows stderr is not always unbuffered. */
+#if defined(_WIN32) || defined(WIN32) || defined(__MINGW32__)
+    setvbuf(stderr, NULL, _IONBF, 0);
+#endif
+
+    sqlite3* db = NULL;
+    if (sqlite3_initialize() != SQLITE_OK) {
+        fprintf(stderr, "error: failed to initialize sqlite\n");
+        exit(EXIT_FAILURE);
+    }
+    int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
+    if (sqlite3_open_v2(file, &db, flags, NULL) != SQLITE_OK) {
+        fprintf(stderr, "error: failed to open %s\n", file);
+        exit(EXIT_FAILURE);
+    }
+
+    buffer *input = buffer_create();
+    while (TRUE) {
+        printf("#\n");
+        fflush(stdout);
+
+        /* Gather input from Emacs. */
+        unsigned length;
+        int result = scanf("%u ", &length);
+        if (result == EOF) {
+            break;
+        } else if (result != 1) {
+            send_error(SQLITE_ERROR, "middleware parsing error");
+            break;  /* stream out of sync: quit program */
+        }
+        if (!buffer_read(input, length)) {
+            send_error(SQLITE_NOMEM, "middleware out of memory");
+            continue;
+        }
+
+        /* Parse SQL statement. */
+        sqlite3_stmt *stmt = NULL;
+        result = sqlite3_prepare_v2(db, input->buffer, length, &stmt, NULL);
+        if (result != SQLITE_OK) {
+            send_error(sqlite3_errcode(db), sqlite3_errmsg(db));
+            continue;
+        }
+
+        /* Print out rows. */
+        int first = TRUE, ncolumns = sqlite3_column_count(stmt);
+        printf("(");
+        while (sqlite3_step(stmt) == SQLITE_ROW) {
+            if (first) {
+                printf("(");
+                first = FALSE;
+            } else {
+                printf("\n (");
+            }
+            int i;
+            for (i = 0; i < ncolumns; i++) {
+                if (i > 0) {
+                    printf(" ");
+                }
+                int type = sqlite3_column_type(stmt, i);
+                switch (type) {
+                case SQLITE_INTEGER:
+                    printf("%lld", sqlite3_column_int64(stmt, i));
+                    break;
+                case SQLITE_FLOAT:
+                    printf("%f", sqlite3_column_double(stmt, i));
+                    break;
+                case SQLITE_NULL:
+                    printf("nil");
+                    break;
+                case SQLITE_TEXT:
+                    fwrite(sqlite3_column_text(stmt, i), 1,
+                           sqlite3_column_bytes(stmt, i), stdout);
+                    break;
+                case SQLITE_BLOB:
+                    printf("nil");
+                    break;
+                }
+            }
+            printf(")");
+        }
+        printf(")\n");
+        if (sqlite3_finalize(stmt) != SQLITE_OK) {
+            /* Despite any error code, the statement is still freed.
+             * http://stackoverflow.com/a/8391872
+             */
+            send_error(sqlite3_errcode(db), sqlite3_errmsg(db));
+        } else {
+            printf("success\n");
+        }
+    }
+    buffer_free(input);
+
+    sqlite3_close(db);
+    sqlite3_shutdown();
+    return EXIT_SUCCESS;
+}