aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Makefile7
-rwxr-xr-xell.c913
2 files changed, 920 insertions, 0 deletions
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..3810925
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,7 @@
+CFLAGS = -std=gnu99 -Wall
+all: ell
+ell: ell.c
+ $(CC) $(CFLAGS) $< -o $@
+clean:
+ rm ell
+.PHONY: all clean
diff --git a/ell.c b/ell.c
new file mode 100755
index 0000000..b0228fa
--- /dev/null
+++ b/ell.c
@@ -0,0 +1,913 @@
+#define _XOPEN_SOURCE 500
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <time.h>
+#include <stdbool.h>
+#include <strings.h>
+#include <math.h>
+
+#if defined __GNUC__
+#define ATTRIBUTE_PRINTF(x, y) __attribute__ ((format (printf, x, y)))
+#else // ! __GNUC__
+#define ATTRIBUTE_PRINTF(x, y)
+#endif // ! __GNUC__
+
+#define N_ELEMENTS(a) (sizeof (a) / sizeof ((a)[0]))
+
+// --- Utilities ---------------------------------------------------------------
+
+static char *format (const char *format, ...) ATTRIBUTE_PRINTF (1, 2);
+
+static char *
+strdup_vprintf (const char *format, va_list ap) {
+ va_list aq;
+ va_copy (aq, ap);
+ int size = vsnprintf (NULL, 0, format, aq);
+ va_end (aq);
+ if (size < 0)
+ return NULL;
+
+ char buf[size + 1];
+ size = vsnprintf (buf, sizeof buf, format, ap);
+ if (size < 0)
+ return NULL;
+
+ return strdup (buf);
+}
+
+static char *
+format (const char *format, ...) {
+ va_list ap;
+ va_start (ap, format);
+ char *result = strdup_vprintf (format, ap);
+ va_end (ap);
+ return result;
+}
+
+// --- Generic buffer ----------------------------------------------------------
+
+struct buffer {
+ char *s; ///< Buffer data
+ size_t alloc; ///< Number of bytes allocated
+ size_t len; ///< Number of bytes used
+ bool memory_failure; ///< Memory allocation failed
+};
+
+#define BUFFER_INITIALIZER { NULL, 0, 0, false }
+
+static bool
+buffer_append (struct buffer *self, const void *s, size_t n) {
+ if (self->memory_failure)
+ return false;
+
+ if (!self->s)
+ self->s = malloc (self->alloc = 8);
+ while (self->len + n > self->alloc)
+ self->s = realloc (self->s, self->alloc <<= 1);
+
+ if (!self->s) {
+ self->memory_failure = true;
+ return false;
+ }
+
+ memcpy (self->s + self->len, s, n);
+ self->len += n;
+ return true;
+}
+
+inline static bool
+buffer_append_c (struct buffer *self, char c) {
+ return buffer_append (self, &c, 1);
+}
+
+// --- Data types --------------------------------------------------------------
+
+enum item_type { ITEM_STRING, ITEM_LIST };
+
+struct item {
+ enum item_type type; ///< The type of this object
+ struct item *next; ///< Next item on the list/stack
+
+ struct item *head; ///< The head of the list
+ size_t len; ///< Length of the string (sans '\0')
+ char value[]; ///< The null-terminated string value
+};
+
+const char *
+item_type_to_str (enum item_type type) {
+ switch (type) {
+ case ITEM_STRING: return "string";
+ case ITEM_LIST: return "list";
+ }
+ abort ();
+}
+
+// --- Item management ---------------------------------------------------------
+
+static void item_free_list (struct item *);
+static struct item *new_clone_list (const struct item *);
+
+static void
+item_free (struct item *item) {
+ if (item->type == ITEM_LIST)
+ item_free_list (get_list (item));
+ free (item);
+}
+
+static void
+item_free_list (struct item *item) {
+ while (item) {
+ struct item *link = item;
+ item = item->next;
+ item_free (link);
+ }
+}
+
+static struct item *
+new_clone (const struct item *item) {
+ size_t size = sizeof *item;
+ if (item->type == ITEM_STRING)
+ size += item->len + 1;
+
+ struct item *clone = malloc (size);
+ if (!clone)
+ return NULL;
+
+ memcpy (clone, item, size);
+ if (item->type == ITEM_LIST) {
+ if (clone->head && !(clone->head = new_clone_list (clone->head))) {
+ free (clone);
+ return NULL;
+ }
+ }
+ clone->next = NULL;
+ return clone;
+}
+
+static struct item *
+new_clone_list (const struct item *item) {
+ struct item *head = NULL, *clone;
+ for (struct item **out = &head; item; item = item->next) {
+ if (!(clone = *out = new_clone (item))) {
+ item_free_list (head);
+ return NULL;
+ }
+ clone->next = NULL;
+ out = &clone->next;
+ }
+ return head;
+}
+
+static struct item *
+new_string (const char *s, ssize_t len) {
+ if (len < 0)
+ len = strlen (s);
+
+ struct item *item = calloc (1, sizeof *item + len + 1);
+ if (!item)
+ return NULL;
+
+ item->type = ITEM_STRING;
+ item->len = len;
+ memcpy (item->value, s, len);
+ item->value[len] = '\0';
+ return item;
+}
+
+static struct item *
+new_list (struct item *head) {
+ struct item *item = calloc (1, sizeof *item);
+ if (!item)
+ return NULL;
+
+ item->type = ITEM_LIST;
+ item->head = head;
+ return item;
+}
+
+// --- Lexer -------------------------------------------------------------------
+
+enum token {
+ T_ABORT, ///< EOF or error
+
+ T_LPAREN, ///< Left parenthesis
+ T_RPAREN, ///< Right parenthesis
+ T_LBRACKET, ///< Left bracket
+ T_RBRACKET, ///< Right bracket
+ T_LBRACE, ///< Left curly bracket
+ T_RBRACE, ///< Right curly bracket
+ T_STRING, ///< Everything else that's not space
+ T_NEWLINE, ///< New line
+ T_AT ///< At symbol
+};
+
+static const char *
+token_name (enum token token) {
+ switch (token) {
+ case T_ABORT: return "end of input";
+
+ case T_LPAREN: return "left parenthesis";
+ case T_RPAREN: return "right parenthesis";
+ case T_LBRACKET: return "left bracket";
+ case T_RBRACKET: return "right bracket";
+ case T_LBRACE: return "left brace";
+ case T_RBRACE: return "right brace";
+ case T_STRING: return "string";
+ case T_NEWLINE: return "newline";
+ case T_AT: return "at symbol";
+
+ default:
+ abort ();
+ return NULL;
+ }
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+struct lexer {
+ const char *p; ///< Current position in input
+ size_t len; ///< How many bytes of input are left
+
+ unsigned line; ///< Current line
+ unsigned column; ///< Current column
+
+ int64_t integer; ///< Parsed boolean or integer value
+ struct str string; ///< Parsed string value
+};
+
+/// Input has to be null-terminated anyway
+static void
+lexer_init (struct lexer *self, const char *p, size_t len) {
+ memset (self, 0, sizeof *self);
+ self->p = p;
+ self->len = len;
+ str_init (&self->string);
+}
+
+static void
+lexer_free (struct lexer *self) {
+ str_free (&self->string);
+}
+
+static bool lexer_is_word_char (int c) { return !strchr ("()[]{}\n@#'", c); }
+
+static int
+lexer_advance (struct lexer *self) {
+ int c = *self->p++;
+ if (c == '\n') {
+ self->column = 0;
+ self->line++;
+ } else
+ self->column++;
+
+ self->len--;
+ return c;
+}
+
+static void lexer_error (struct lexer *self,
+ struct error **e, const char *format, ...) ATTRIBUTE_PRINTF (3, 4);
+
+static void
+lexer_error (struct lexer *self, struct error **e, const char *format, ...) {
+ struct str description;
+ str_init (&description);
+
+ va_list ap;
+ va_start (ap, format);
+ str_append_vprintf (&description, format, ap);
+ va_end (ap);
+
+ if (self->report_line)
+ error_set (e, "near line %u, column %u: %s",
+ self->line + 1, self->column + 1, description.str);
+ else if (self->len)
+ error_set (e, "near character %u: %s",
+ self->column + 1, description.str);
+ else
+ error_set (e, "near end: %s", description.str);
+
+ str_free (&description);
+}
+
+static bool
+lexer_hexa_escape (struct lexer *self, struct str *output) {
+ int i;
+ unsigned char code = 0;
+
+ for (i = 0; self->len && i < 2; i++) {
+ unsigned char c = tolower (*self->p);
+ if (c >= '0' && c <= '9')
+ code = (code << 4) | (c - '0');
+ else if (c >= 'a' && c <= 'f')
+ code = (code << 4) | (c - 'a' + 10);
+ else
+ break;
+
+ lexer_advance (self);
+ }
+
+ if (!i)
+ return false;
+
+ str_append_c (output, code);
+ return true;
+}
+
+static bool
+lexer_escape_sequence
+ (struct lexer *self, struct str *output, struct error **e) {
+ if (!self->len) {
+ lexer_error (self, e, "premature end of escape sequence");
+ return false;
+ }
+
+ unsigned char c;
+ switch ((c = *self->p)) {
+ case '"': break;
+ case '\\': break;
+ case 'a': c = '\a'; break;
+ case 'b': c = '\b'; break;
+ case 'f': c = '\f'; break;
+ case 'n': c = '\n'; break;
+ case 'r': c = '\r'; break;
+ case 't': c = '\t'; break;
+ case 'v': c = '\v'; break;
+
+ case 'x':
+ case 'X':
+ lexer_advance (self);
+ if (lexer_hexa_escape (self, output))
+ return true;
+
+ lexer_error (self, e, "invalid hexadecimal escape");
+ return false;
+
+ default:
+ lexer_error (self, e, "unknown escape sequence");
+ return false;
+ }
+
+ str_append_c (output, c);
+ lexer_advance (self);
+ return true;
+}
+
+static bool
+lexer_string (struct lexer *self, struct str *output, struct error **e) {
+ unsigned char c;
+ while (self->len) {
+ if ((c = lexer_advance (self)) == '\'')
+ return true;
+ if (c != '\\')
+ str_append_c (output, c);
+ else if (!lexer_escape_sequence (self, output, e))
+ return false;
+ }
+ lexer_error (self, e, "premature end of string");
+ return false;
+}
+
+static enum token
+lexer_next (struct lexer *self, struct error **e) {
+ // Skip over any whitespace between tokens
+ while (self->len && isspace_ascii (*self->p) && *self->p != '\n')
+ lexer_advance (self);
+ if (!self->len)
+ return T_ABORT;
+
+ switch (*self->p) {
+ case '(': lexer_advance (self); return T_LPAREN;
+ case ')': lexer_advance (self); return T_RPAREN;
+ case '[': lexer_advance (self); return T_LBRACKET;
+ case ']': lexer_advance (self); return T_RBRACKET;
+ case '{': lexer_advance (self); return T_LBRACE;
+ case '}': lexer_advance (self); return T_RBRACE;
+ case '\n': lexer_advance (self); return T_NEWLINE;
+ case '@': lexer_advance (self); return T_AT;
+
+ case '#':
+ // Comments go until newline
+ while (self->len)
+ if (lexer_advance (self) == '\n')
+ return T_NEWLINE;
+ return T_ABORT;
+
+ case '\'':
+ lexer_advance (self);
+ str_reset (&self->string);
+ if (!lexer_string (self, &self->string, e))
+ return T_ABORT;
+ return T_STRING;
+ }
+
+ assert (lexer_is_word_char (*self->p));
+ str_reset (&self->string);
+ do
+ str_append_c (&self->string, lexer_advance (self));
+ while (lexer_is_word_char (*self->p));
+ return T_STRING;
+}
+
+// --- Parsing -----------------------------------------------------------------
+
+#define PARSE_ERROR_TABLE(XX) \
+ XX( OK, NULL ) \
+ XX( EOF, "unexpected end of input" ) \
+ XX( INVALID_HEXA_ESCAPE, "invalid hexadecimal escape sequence" ) \
+ XX( INVALID_ESCAPE, "unrecognized escape sequence" ) \
+ XX( MEMORY, "memory allocation failure" ) \
+ XX( FLOAT_RANGE, "floating point value out of range" ) \
+ XX( INTEGER_RANGE, "integer out of range" ) \
+ XX( INVALID_INPUT, "invalid input" ) \
+ XX( UNEXPECTED_INPUT, "unexpected input" )
+
+enum tokenizer_error {
+#define XX(x, y) PARSE_ERROR_ ## x,
+ PARSE_ERROR_TABLE (XX)
+#undef XX
+ PARSE_ERROR_COUNT
+};
+
+struct tokenizer {
+ const char *cursor;
+ enum tokenizer_error error;
+};
+
+static bool
+decode_hexa_escape (struct tokenizer *self, struct buffer *buf) {
+ int i;
+ char c, code = 0;
+
+ for (i = 0; i < 2; i++) {
+ c = tolower (*self->cursor);
+ if (c >= '0' && c <= '9')
+ code = (code << 4) | (c - '0');
+ else if (c >= 'a' && c <= 'f')
+ code = (code << 4) | (c - 'a' + 10);
+ else
+ break;
+
+ self->cursor++;
+ }
+
+ if (!i)
+ return false;
+
+ buffer_append_c (buf, code);
+ return true;
+}
+
+static bool
+decode_escape_sequence (struct tokenizer *self, struct buffer *buf) {
+ // Support some basic escape sequences from the C language
+ char c;
+ switch ((c = *self->cursor)) {
+ case '\0':
+ self->error = PARSE_ERROR_EOF;
+ return false;
+ case 'x':
+ case 'X':
+ self->cursor++;
+ if (decode_hexa_escape (self, buf))
+ return true;
+
+ self->error = PARSE_ERROR_INVALID_HEXA_ESCAPE;
+ return false;
+ default:
+ self->cursor++;
+ const char *from = "abfnrtv\"\\", *to = "\a\b\f\n\r\t\v\"\\", *x;
+ if ((x = strchr (from, c))) {
+ buffer_append_c (buf, to[x - from]);
+ return true;
+ }
+ self->error = PARSE_ERROR_INVALID_ESCAPE;
+ return false;
+ }
+}
+
+static struct item *
+parse_string (struct tokenizer *self) {
+ struct buffer buf = BUFFER_INITIALIZER;
+ struct item *item = NULL;
+ char c;
+
+ while (true)
+ switch ((c = *self->cursor++)) {
+ case '\0':
+ self->cursor--;
+ self->error = PARSE_ERROR_EOF;
+ goto end;
+ case '"':
+ if (buf.memory_failure
+ || !(item = new_string (buf.s, buf.len)))
+ self->error = PARSE_ERROR_MEMORY;
+ goto end;
+ case '\\':
+ if (decode_escape_sequence (self, &buf))
+ break;
+ goto end;
+ default:
+ buffer_append_c (&buf, c);
+ }
+
+end:
+ free (buf.s);
+ return item;
+}
+
+static struct item *
+parse_word (struct tokenizer *self) {
+ struct buffer buf = BUFFER_INITIALIZER;
+ struct item *item = NULL;
+ char c;
+
+ // Here we accept almost anything that doesn't break the grammar
+ while (!strchr (" []\"", (c = *self->cursor++)) && (unsigned char) c > ' ')
+ buffer_append_c (&buf, c);
+ self->cursor--;
+
+ if (buf.memory_failure)
+ self->error = PARSE_ERROR_MEMORY;
+ else if (!buf.len)
+ self->error = PARSE_ERROR_INVALID_INPUT;
+ else if (!(item = new_word (buf.s, buf.len)))
+ self->error = PARSE_ERROR_MEMORY;
+
+ free (buf.s);
+ return item;
+}
+
+static struct item *parse_item_list (struct tokenizer *);
+
+static struct item *
+parse_list (struct tokenizer *self) {
+ struct item *list = parse_item_list (self);
+ if (self->error) {
+ assert (list == NULL);
+ return NULL;
+ }
+ if (!*self->cursor) {
+ self->error = PARSE_ERROR_EOF;
+ item_free_list (list);
+ return NULL;
+ }
+ assert (*self->cursor == ']');
+ self->cursor++;
+ return new_list (list);
+}
+
+static struct item *
+parse_item (struct tokenizer *self) {
+ char c;
+ switch ((c = *self->cursor++)) {
+ case '[': return parse_list (self);
+ case '"': return parse_string (self);
+ default:;
+ }
+
+ self->cursor--;
+ return parse_word (self);
+}
+
+static struct item *
+parse_item_list (struct tokenizer *self) {
+ struct item *head = NULL;
+ struct item **tail = &head;
+
+ char c;
+ bool expected = true;
+ while ((c = *self->cursor) && c != ']') {
+ if (isspace (c)) {
+ self->cursor++;
+ expected = true;
+ continue;
+ } else if (!expected) {
+ self->error = PARSE_ERROR_UNEXPECTED_INPUT;
+ goto fail;
+ }
+
+ if (!(*tail = parse_item (self)))
+ goto fail;
+ tail = &(*tail)->next;
+ expected = false;
+ }
+ return head;
+
+fail:
+ item_free_list (head);
+ return NULL;
+}
+
+static struct item *
+parse (const char *s, const char **error) {
+ struct tokenizer self = { .cursor = s, .error = PARSE_ERROR_OK };
+ struct item *list = parse_item_list (&self);
+ if (!self.error && *self.cursor != '\0') {
+ self.error = PARSE_ERROR_UNEXPECTED_INPUT;
+ item_free_list (list);
+ list = NULL;
+ }
+
+#define XX(x, y) y,
+ static const char *strings[PARSE_ERROR_COUNT] =
+ { PARSE_ERROR_TABLE (XX) };
+#undef XX
+
+ static char error_buf[128];
+ if (self.error && error) {
+ snprintf (error_buf, sizeof error_buf, "at character %d: %s",
+ (int) (self.cursor - s) + 1, strings[self.error]);
+ *error = error_buf;
+ }
+ return list;
+}
+
+// --- Runtime -----------------------------------------------------------------
+
+struct context {
+ struct item *stack; ///< The current top of the stack
+ size_t stack_size; ///< Number of items on the stack
+
+ char *error; ///< Error information
+ bool error_is_fatal; ///< Whether the error can be catched
+ bool memory_failure; ///< Memory allocation failure
+
+ void *user_data; ///< User data
+};
+
+/// Internal handler for a function
+typedef bool (*handler_fn) (struct context *);
+
+struct fn {
+ struct fn *next; ///< The next link in the chain
+
+ handler_fn handler; ///< Internal C handler, or NULL
+ struct item *script; ///< Alternatively runtime code
+ char name[]; ///< The name of the function
+};
+
+struct fn *g_functions; ///< Maps words to functions
+
+static void
+context_init (struct context *ctx) {
+ ctx->stack = NULL;
+ ctx->stack_size = 0;
+
+ ctx->error = NULL;
+ ctx->error_is_fatal = false;
+ ctx->memory_failure = false;
+
+ ctx->user_data = NULL;
+}
+
+static void
+context_free (struct context *ctx) {
+ item_free_list (ctx->stack);
+ ctx->stack = NULL;
+
+ free (ctx->error);
+ ctx->error = NULL;
+}
+
+static bool
+set_error (struct context *ctx, const char *format, ...) {
+ free (ctx->error);
+
+ va_list ap;
+ va_start (ap, format);
+ ctx->error = strdup_vprintf (format, ap);
+ va_end (ap);
+
+ if (!ctx->error)
+ ctx->memory_failure = true;
+ return false;
+}
+
+static bool
+push (struct context *ctx, struct item *item) {
+ // The `item' is typically a result from new_<type>(), thus when it is null,
+ // that function must have failed. This is a shortcut for convenience.
+ if (!item) {
+ ctx->memory_failure = true;
+ return false;
+ }
+
+ assert (item->next == NULL);
+ item->next = ctx->stack;
+ ctx->stack = item;
+ ctx->stack_size++;
+ return true;
+}
+
+static bool execute (struct context *, struct item *);
+
+static bool
+call_function (struct context *ctx, const char *name) {
+ struct fn *iter;
+ for (iter = g_functions; iter; iter = iter->next)
+ if (!strcmp (name, iter->name))
+ goto found;
+ return set_error (ctx, "unknown function: %s", name);
+
+found:
+ if (iter->handler
+ ? iter->handler (ctx)
+ : execute (ctx, iter->script))
+ return true;
+
+ // In this case, `error' is NULL
+ if (ctx->memory_failure)
+ return false;
+
+ // This creates some form of a stack trace
+ char *tmp = ctx->error;
+ ctx->error = NULL;
+ set_error (ctx, "%s -> %s", name, tmp);
+ free (tmp);
+ return false;
+}
+
+static void
+free_function (struct fn *fn) {
+ item_free_list (fn->script);
+ free (fn);
+}
+
+static void
+unregister_function (const char *name) {
+ for (struct fn **iter = &g_functions; *iter; iter = &(*iter)->next)
+ if (!strcmp ((*iter)->name, name)) {
+ struct fn *tmp = *iter;
+ *iter = tmp->next;
+ free_function (tmp);
+ break;
+ }
+}
+
+static struct fn *
+prepend_new_fn (const char *name) {
+ struct fn *fn = calloc (1, sizeof *fn + strlen (name) + 1);
+ if (!fn)
+ return NULL;
+
+ strcpy (fn->name, name);
+ fn->next = g_functions;
+ return g_functions = fn;
+}
+
+static bool
+register_handler (const char *name, handler_fn handler) {
+ unregister_function (name);
+ struct fn *fn = prepend_new_fn (name);
+ if (!fn)
+ return false;
+ fn->handler = handler;
+ return true;
+}
+
+static bool
+register_script (const char *name, struct item *script) {
+ unregister_function (name);
+ struct fn *fn = prepend_new_fn (name);
+ if (!fn)
+ return false;
+ fn->script = script;
+ return true;
+}
+
+static bool
+execute (struct context *ctx, struct item *script) {
+ for (; script; script = script->next) {
+ if (script->type != ITEM_STRING) {
+ if (!push (ctx, new_clone (script)))
+ return false;
+ }
+ else if (!call_function (ctx, get_word (script)))
+ return false;
+ }
+ return true;
+}
+
+// --- Runtime library ---------------------------------------------------------
+
+#define defn(name) static bool name (struct context *ctx)
+
+static bool
+init_runtime_library_scripts (void) {
+ bool ok = true;
+
+ // It's much cheaper (and more fun) to define functions in terms of other
+ // ones. The "unit tests" serve a secondary purpose of showing the usage.
+ struct script {
+ const char *name; ///< Name of the function
+ const char *definition; ///< The defining script
+ } scripts[] = {
+ { "greet", "print (.. 'hello ' (.. @1))" },
+ };
+
+ for (size_t i = 0; i < N_ELEMENTS (scripts); i++) {
+ const char *error = NULL;
+ struct item *script = parse (scripts[i].definition, &error);
+ if (error) {
+ printf ("error parsing internal script `%s': %s\n",
+ scripts[i].definition, error);
+ ok = false;
+ } else
+ ok &= register_script (scripts[i].name, script);
+ }
+ return ok;
+}
+
+defn (fn_print) {
+ check_stack (1);
+ struct item *item = pop (ctx);
+ struct user_info *info = ctx->user_data;
+
+ struct buffer buf = BUFFER_INITIALIZER;
+ item_to_str (item, &buf);
+ item_free (item);
+ buffer_append_c (&buf, '\0');
+ if (buf.memory_failure) {
+ ctx->memory_failure = true;
+ return false;
+ }
+
+ printf ("%s\n", buf.s);
+ free (buf.s);
+ return true;
+}
+
+defn (fn_concatenate) {
+ // TODO: concatenate string arguments, error on list
+ return true;
+}
+
+static bool
+init_runtime_library (void)
+{
+ return register_handler ("..", fn_concatenate);
+ && register_handler ("print", fn_print);
+ && init_runtime_library_scripts ();
+}
+
+static void
+free_runtime_library (void) {
+ struct fn *next, *iter;
+ for (iter = g_functions; iter; iter = next) {
+ next = iter->next;
+ free_function (iter);
+ }
+}
+
+// --- Main --------------------------------------------------------------------
+
+static void
+process_message (const char *msg) {
+ // Finally parse and execute the macro
+ const char *error = NULL;
+ struct item *script = parse (msg, &error);
+ if (error) {
+ printf ("%s: %s\r\n", "parse error", error);
+ goto end;
+ }
+
+ struct context ctx;
+ context_init (&ctx);
+ ctx.user_data = &info;
+ execute (&ctx, script);
+ item_free_list (script);
+
+ const char *failure = NULL;
+ if (ctx.memory_failure)
+ failure = "memory allocation failure";
+ else if (ctx.error)
+ failure = ctx.error;
+ if (failure)
+ printf ("%s: %s\r\n", "runtime error", failure);
+ context_free (&ctx);
+end:
+ free (msg_ctx_quote);
+}
+
+int
+main (int argc, char *argv[]) {
+ freopen (NULL, "rb", stdin); setvbuf (stdin, NULL, _IOLBF, BUFSIZ);
+ freopen (NULL, "wb", stdout); setvbuf (stdout, NULL, _IOLBF, BUFSIZ);
+
+ if (!init_runtime_library ()
+ || !register_handler (".", fn_dot))
+ printf ("%s\n", "runtime library initialization failed");
+
+ // TODO: load the entirety of stdin and execute it
+ process_message ("print 'hello world\n'");
+
+ free_runtime_library ();
+ return 0;
+}
+
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-21 16:48:21 +0000