script: watch all memory allocations

And some other miscellaneous changes.

Now it should be ready for the real life.

1 files changed, 475 insertions, 360 deletions

diff --git a/plugins/script b/plugins/script
index a9de176..42960c1 100755
--- a/plugins/script
+++ b/plugins/script
@@ -15,7 +15,7 @@
 //
 // If you don't like something, just change it; this is just an experiment.
 //
-// NOTE: it is really easy to crash and abuse.  Be careful.
+// NOTE: it is relatively easy to abuse.  Be careful.
 //
 
 #define _XOPEN_SOURCE 500
@@ -48,25 +48,33 @@
 static char *strdup_printf (const char *format, ...) ATTRIBUTE_PRINTF (1, 2);
 
 static char *
-strdup_printf (const char *format, ...)
+strdup_vprintf (const char *format, va_list ap)
 {
-	va_list ap;
-	va_start (ap, format);
-	int size = vsnprintf (NULL, 0, format, ap);
-	va_end (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];
-	va_start (ap, format);
 	size = vsnprintf (buf, sizeof buf, format, ap);
-	va_end (ap);
 	if (size < 0)
 		return NULL;
 
 	return strdup (buf);
 }
 
+static char *
+strdup_printf (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
@@ -74,26 +82,37 @@ 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}
+#define BUFFER_INITIALIZER { NULL, 0, 0, false }
 
-static void
+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 void
+inline static bool
 buffer_append_c (struct buffer *self, char c)
 {
-	buffer_append (self, &c, 1);
+	return buffer_append (self, &c, 1);
 }
 
 // --- Data types --------------------------------------------------------------
@@ -225,11 +244,19 @@ new_clone (const struct item *item)
 	case ITEM_LIST:     size = sizeof (struct item_list);     break;
 	}
 
-	struct item *clone = memcpy (malloc (size), item, size);
+	struct item *clone = malloc (size);
+	if (!clone)
+		return NULL;
+
+	memcpy (clone, item, size);
 	if (item->type == ITEM_LIST)
 	{
 		struct item_list *x = (struct item_list *) clone;
-		x->head = new_clone_list (x->head);
+		if (x->head && !(x->head = new_clone_list (x->head)))
+		{
+			free (clone);
+			return NULL;
+		}
 	}
 	clone->next = NULL;
 	return clone;
@@ -238,10 +265,14 @@ new_clone (const struct item *item)
 static struct item *
 new_clone_list (const struct item *item)
 {
-	struct item *head = NULL;
+	struct item *head = NULL, *clone;
 	for (struct item **out = &head; item; item = item->next)
 	{
-		struct item *clone = *out = new_clone (item);
+		if (!(clone = *out = new_clone (item)))
+		{
+			item_free_list (head);
+			return NULL;
+		}
 		clone->next = NULL;
 		out = &clone->next;
 	}
@@ -269,6 +300,9 @@ static struct item *
 new_word (const char *s, ssize_t len)
 {
 	struct item *item = new_string (s, len);
+	if (!item)
+		return NULL;
+
 	item->type = ITEM_WORD;
 	return item;
 }
@@ -277,6 +311,9 @@ static struct item *
 new_integer (long long value)
 {
 	struct item_integer *item = calloc (1, sizeof *item);
+	if (!item)
+		return NULL;
+
 	item->type = ITEM_INTEGER;
 	item->value = value;
 	return (struct item *) item;
@@ -286,6 +323,9 @@ static struct item *
 new_float (long double value)
 {
 	struct item_float *item = calloc (1, sizeof *item);
+	if (!item)
+		return NULL;
+
 	item->type = ITEM_FLOAT;
 	item->value = value;
 	return (struct item *) item;
@@ -295,6 +335,9 @@ static struct item *
 new_list (struct item *head)
 {
 	struct item_list *item = calloc (1, sizeof *item);
+	if (!item)
+		return NULL;
+
 	item->type = ITEM_LIST;
 	item->head = head;
 	return (struct item *) item;
@@ -302,10 +345,29 @@ new_list (struct item *head)
 
 // --- 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;
-	const char *error;
+	enum tokenizer_error error;
 };
 
 static bool
@@ -365,7 +427,7 @@ decode_escape_sequence (struct tokenizer *self, struct buffer *buf)
 	switch ((c = *self->cursor))
 	{
 	case '\0':
-		self->error = "unexpected end of input";
+		self->error = PARSE_ERROR_EOF;
 		return false;
 	case 'x':
 	case 'X':
@@ -373,7 +435,7 @@ decode_escape_sequence (struct tokenizer *self, struct buffer *buf)
 		if (decode_hexa_escape (self, buf))
 			return true;
 
-		self->error = "invalid hexadecimal escape sequence";
+		self->error = PARSE_ERROR_INVALID_HEXA_ESCAPE;
 		return false;
 	default:
 		if (decode_octal_escape (self, buf))
@@ -387,7 +449,7 @@ decode_escape_sequence (struct tokenizer *self, struct buffer *buf)
 			return true;
 		}
 
-		self->error = "unrecognized escape sequence";
+		self->error = PARSE_ERROR_INVALID_ESCAPE;
 		return false;
 	}
 }
@@ -396,6 +458,7 @@ static struct item *
 parse_string (struct tokenizer *self)
 {
 	struct buffer buf = BUFFER_INITIALIZER;
+	struct item *item = NULL;
 	char c;
 
 	while (true)
@@ -403,25 +466,24 @@ parse_string (struct tokenizer *self)
 	{
 	case '\0':
 		self->cursor--;
-		self->error = "unexpected end of input";
-		goto fail;
+		self->error = PARSE_ERROR_EOF;
+		goto end;
 	case '"':
-	{
-		struct item *item = new_string (buf.s, buf.len);
-		free (buf.s);
-		return item;
-	}
+		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))
-			goto fail;
-		break;
+		if (decode_escape_sequence (self, &buf))
+			break;
+		goto end;
 	default:
 		buffer_append_c (&buf, c);
 	}
 
-fail:
+end:
 	free (buf.s);
-	return NULL;
+	return item;
 }
 
 static struct item *
@@ -444,25 +506,30 @@ try_parse_number (struct tokenizer *self)
 		return NULL;
 
 	// Only use the floating point result if it parses more characters:
+	struct item *item;
 	if (float_end > int_end)
 	{
 		if (float_errno == ERANGE)
 		{
-			self->error = "floating point value out of range";
+			self->error = PARSE_ERROR_FLOAT_RANGE;
 			return NULL;
 		}
 		self->cursor = float_end;
-		return new_float (float_value);
+		if (!(item = new_float (float_value)))
+			self->error = PARSE_ERROR_MEMORY;
+		return item;
 	}
 	else
 	{
 		if (int_errno == ERANGE)
 		{
-			self->error = "integer out of range";
+			self->error = PARSE_ERROR_INTEGER_RANGE;
 			return NULL;
 		}
 		self->cursor = int_end;
-		return new_integer (int_value);
+		if (!(item = new_integer (int_value)))
+			self->error = PARSE_ERROR_MEMORY;
+		return item;
 	}
 }
 
@@ -470,6 +537,7 @@ 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
@@ -477,13 +545,13 @@ parse_word (struct tokenizer *self)
 		buffer_append_c (&buf, c);
 	self->cursor--;
 
-	if (!buf.len)
-	{
-		self->error = "invalid input";
-		return NULL;
-	}
+	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;
 
-	struct item *item = new_word (buf.s, buf.len);
 	free (buf.s);
 	return item;
 }
@@ -501,7 +569,7 @@ parse_list (struct tokenizer *self)
 	}
 	if (!*self->cursor)
 	{
-		self->error = "unexpected end of input";
+		self->error = PARSE_ERROR_EOF;
 		item_free_list (list);
 		return NULL;
 	}
@@ -546,7 +614,7 @@ parse_item_list (struct tokenizer *self)
 		}
 		else if (!expected)
 		{
-			self->error = "unexpected input";
+			self->error = PARSE_ERROR_UNEXPECTED_INPUT;
 			goto fail;
 		}
 
@@ -563,22 +631,29 @@ fail:
 }
 
 static struct item *
-parse (const char *s, char **error)
+parse (const char *s, const char **error)
 {
-	struct tokenizer self;
-	self.cursor = s;
-	self.error = NULL;
-
+	struct tokenizer self = { .cursor = s, .error = PARSE_ERROR_OK };
 	struct item *list = parse_item_list (&self);
 	if (!self.error && *self.cursor != '\0')
 	{
-		self.error = "unexpected input";
+		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)
-		*error = strdup_printf ("at character %d: %s",
-			(int) (self.cursor - s) + 1, self.error);
+	{
+		snprintf (error_buf, sizeof error_buf, "at character %d: %s",
+			(int) (self.cursor - s) + 1, strings[self.error]);
+		*error = error_buf;
+	}
 	return list;
 }
 
@@ -596,6 +671,7 @@ struct context
 
 	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
 };
@@ -625,6 +701,7 @@ context_init (struct context *ctx)
 
 	ctx->error = NULL;
 	ctx->error_is_fatal = false;
+	ctx->memory_failure = false;
 
 	ctx->user_data = NULL;
 }
@@ -639,13 +716,37 @@ context_free (struct context *ctx)
 	ctx->error = NULL;
 }
 
-static void
+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
@@ -653,9 +754,8 @@ bump_reductions (struct context *ctx)
 {
 	if (++ctx->reduction_count >= ctx->reduction_limit)
 	{
-		ctx->error = strdup ("reduction limit reached");
 		ctx->error_is_fatal = true;
-		return false;
+		return set_error (ctx, "reduction limit reached");
 	}
 	return true;
 }
@@ -669,9 +769,7 @@ call_function (struct context *ctx, const char *name)
 	for (iter = g_functions; iter; iter = iter->next)
 		if (!strcmp (name, iter->name))
 			goto found;
-
-	ctx->error = strdup_printf ("unknown function: %s", name);
-	return false;
+	return set_error (ctx, "unknown function: %s", name);
 
 found:
 	if (!bump_reductions (ctx))
@@ -682,14 +780,26 @@ found:
 		: 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 *error = strdup_printf ("%s -> %s", name, ctx->error);
-	free (ctx->error);
-	ctx->error = error;
+	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)
@@ -697,9 +807,7 @@ unregister_function (const char *name)
 		{
 			struct fn *tmp = *iter;
 			*iter = tmp->next;
-			if (tmp->script)
-				item_free_list (tmp->script);
-			free (tmp);
+			free_function (tmp);
 			break;
 		}
 }
@@ -708,23 +816,34 @@ 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 void
+static bool
 register_handler (const char *name, handler_fn handler)
 {
 	unregister_function (name);
-	prepend_new_fn (name)->handler = handler;
+	struct fn *fn = prepend_new_fn (name);
+	if (!fn)
+		return false;
+	fn->handler = handler;
+	return true;
 }
 
-static void
+static bool
 register_script (const char *name, struct item *script)
 {
 	unregister_function (name);
-	prepend_new_fn (name)->script = script;
+	struct fn *fn = prepend_new_fn (name);
+	if (!fn)
+		return false;
+	fn->script = script;
+	return true;
 }
 
 static bool
@@ -734,9 +853,9 @@ execute (struct context *ctx, struct item *script)
 	{
 		if (script->type != ITEM_WORD)
 		{
-			if (!bump_reductions (ctx))
+			if (!bump_reductions (ctx)
+			 || !push (ctx, new_clone (script)))
 				return false;
-			push (ctx, new_clone (script));
 		}
 		else if (!call_function (ctx, get_word (script)))
 			return false;
@@ -750,7 +869,7 @@ execute (struct context *ctx, struct item *script)
 
 #define check_stack(n)                                                         \
 	if (ctx->stack_size < n) {                                                 \
-		ctx->error = strdup ("stack underflow");                               \
+		set_error (ctx, "stack underflow");                                    \
 		return 0;                                                              \
 	}
 
@@ -768,9 +887,8 @@ check_type (struct context *ctx, const void *item_, enum item_type type)
 	if (item->type == type)
 		return true;
 
-	ctx->error = strdup_printf ("invalid type: expected `%s', got `%s'",
+	return set_error (ctx, "invalid type: expected `%s', got `%s'",
 		item_type_to_str (type), item_type_to_str (item->type));
-	return false;
 }
 
 static struct item *
@@ -812,8 +930,7 @@ defn (fn_to_string)
 	case ITEM_WORD:
 		item->type = ITEM_STRING;
 	case ITEM_STRING:
-		push (ctx, item);
-		return true;
+		return push (ctx, item);
 
 	case ITEM_FLOAT:
 		value = strdup_printf ("%Lf", get_float (item));
@@ -823,18 +940,22 @@ defn (fn_to_string)
 		break;
 
 	default:
-		ctx->error = strdup_printf ("cannot convert `%s' to `%s'",
+		set_error (ctx, "cannot convert `%s' to `%s'",
 			item_type_to_str (item->type), item_type_to_str (ITEM_STRING));
 		item_free (item);
 		return false;
 	}
 
 	item_free (item);
+	if (!value)
+	{
+		ctx->memory_failure = true;
+		return false;
+	}
+
 	item = new_string (value, -1);
 	free (value);
-
-	push (ctx, item);
-	return true;
+	return push (ctx, item);
 }
 
 defn (fn_to_integer)
@@ -846,8 +967,7 @@ defn (fn_to_integer)
 	switch (item->type)
 	{
 	case ITEM_INTEGER:
-		push (ctx, item);
-		return true;
+		return push (ctx, item);
 	case ITEM_FLOAT:
 		value = get_float (item);
 		break;
@@ -860,21 +980,19 @@ defn (fn_to_integer)
 		if (end != s && *s == '\0')
 			break;
 
-		ctx->error = strdup ("integer conversion error");
 		item_free (item);
-		return false;
+		return set_error (ctx, "integer conversion error");
 	}
 
 	default:
-		ctx->error = strdup_printf ("cannot convert `%s' to `%s'",
+		set_error (ctx, "cannot convert `%s' to `%s'",
 			item_type_to_str (item->type), item_type_to_str (ITEM_INTEGER));
 		item_free (item);
 		return false;
 	}
 
 	item_free (item);
-	push (ctx, new_integer (value));
-	return true;
+	return push (ctx, new_integer (value));
 }
 
 defn (fn_to_float)
@@ -886,8 +1004,7 @@ defn (fn_to_float)
 	switch (item->type)
 	{
 	case ITEM_FLOAT:
-		push (ctx, item);
-		return true;
+		return push (ctx, item);
 	case ITEM_INTEGER:
 		value = get_integer (item);
 		break;
@@ -900,21 +1017,19 @@ defn (fn_to_float)
 		if (end != s && *s == '\0')
 			break;
 
-		ctx->error = strdup ("float conversion error");
 		item_free (item);
-		return false;
+		return set_error (ctx, "float conversion error");
 	}
 
 	default:
-		ctx->error = strdup_printf ("cannot convert `%s' to `%s'",
+		set_error (ctx, "cannot convert `%s' to `%s'",
 			item_type_to_str (item->type), item_type_to_str (ITEM_FLOAT));
 		item_free (item);
 		return false;
 	}
 
 	item_free (item);
-	push (ctx, new_float (value));
-	return true;
+	return push (ctx, new_float (value));
 }
 
 // - - Miscellaneous - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -927,7 +1042,7 @@ defn (fn_length)
 	switch (item->type)
 	{
 	case ITEM_STRING:
-		push (ctx, new_integer (((struct item_string *) item)->len));
+		success = push (ctx, new_integer (((struct item_string *) item)->len));
 		break;
 	case ITEM_LIST:
 	{
@@ -935,12 +1050,11 @@ defn (fn_length)
 		struct item *iter;
 		for (iter = get_list (item); iter; iter = iter->next)
 			length++;
-		push (ctx, new_integer (length));
+		success = push (ctx, new_integer (length));
 		break;
 	}
 	default:
-		ctx->error = strdup ("invalid type");
-		success = false;
+		success = set_error (ctx, "invalid type");
 	}
 	item_free (item);
 	return success;
@@ -951,8 +1065,7 @@ defn (fn_length)
 defn (fn_dup)
 {
 	check_stack (1);
-	push (ctx, new_clone (ctx->stack));
-	return true;
+	return push (ctx, new_clone (ctx->stack));
 }
 
 defn (fn_drop)
@@ -965,11 +1078,8 @@ defn (fn_drop)
 defn (fn_swap)
 {
 	check_stack (2);
-	struct item *second = pop (ctx);
-	struct item *first  = pop (ctx);
-	push (ctx, second);
-	push (ctx, first);
-	return true;
+	struct item *second = pop (ctx), *first = pop (ctx);
+	return push (ctx, second) && push (ctx, first);
 }
 
 defn (fn_call)
@@ -989,20 +1099,20 @@ defn (fn_dip)
 	struct item *item   = pop (ctx);
 	bool success = check_type (ctx, script, ITEM_LIST)
 		&& execute (ctx, get_list (script));
-	if (success)
-		push (ctx, item);
-	else
-		item_free (item);
 	item_free (script);
-	return success;
+	if (!success)
+	{
+		item_free (item);
+		return false;
+	}
+	return push (ctx, item);
 }
 
 defn (fn_unit)
 {
 	check_stack (1);
 	struct item *item = pop (ctx);
-	push (ctx, new_list (item));
-	return true;
+	return push (ctx, new_list (item));
 }
 
 defn (fn_cons)
@@ -1018,8 +1128,7 @@ defn (fn_cons)
 	}
 	item->next = get_list (list);
 	((struct item_list *) list)->head = item;
-	push (ctx, list);
-	return true;
+	return push (ctx, list);
 }
 
 defn (fn_cat)
@@ -1040,11 +1149,10 @@ defn (fn_cat)
 	while (*tail)
 		tail = &(*tail)->next;
 	*tail = get_list (scnd);
-	push (ctx, frst);
 
 	((struct item_list *) scnd)->head = NULL;
 	item_free (scnd);
-	return true;
+	return push (ctx, frst);
 }
 
 defn (fn_uncons)
@@ -1056,14 +1164,12 @@ defn (fn_uncons)
 	struct item *first = get_list (list);
 	if (!first)
 	{
-		ctx->error = strdup ("list is empty");
+		set_error (ctx, "list is empty");
 		goto fail;
 	}
 	((struct item_list *) list)->head = first->next;
 	first->next = NULL;
-	push (ctx, first);
-	push (ctx, list);
-	return true;
+	return push (ctx, first) && push (ctx, list);
 fail:
 	item_free (list);
 	return false;
@@ -1072,7 +1178,7 @@ fail:
 // - - Logical - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 static bool
-to_boolean (struct context *ctx, struct item *item)
+to_boolean (struct context *ctx, struct item *item, bool *ok)
 {
 	switch (item->type)
 	{
@@ -1083,9 +1189,8 @@ to_boolean (struct context *ctx, struct item *item)
 	case ITEM_FLOAT:
 		return get_float   (item) != 0.;
 	default:
-		ctx->error = strdup_printf ("cannot convert `%s' to boolean",
-			item_type_to_str (item->type));
-		return false;
+		return (*ok = set_error (ctx, "cannot convert `%s' to boolean",
+			item_type_to_str (item->type)));
 	}
 }
 
@@ -1093,12 +1198,10 @@ defn (fn_not)
 {
 	check_stack (1);
 	struct item *item = pop (ctx);
-	bool result = !to_boolean (ctx, item);
+	bool ok = true;
+	bool result = !to_boolean (ctx, item, &ok);
 	item_free (item);
-	if (ctx->error)
-		return false;
-	push (ctx, new_integer (result));
-	return true;
+	return ok && push (ctx, new_integer (result));
 }
 
 defn (fn_and)
@@ -1106,11 +1209,11 @@ defn (fn_and)
 	check_stack (2);
 	struct item *op1 = pop (ctx);
 	struct item *op2 = pop (ctx);
-	bool result = to_boolean (ctx, op1) && to_boolean (ctx, op2);
+	bool ok = true;
+	bool result = to_boolean (ctx, op1, &ok) && to_boolean (ctx, op2, &ok);
 	item_free (op1);
 	item_free (op2);
-	push (ctx, new_integer (result));
-	return !ctx->error;
+	return ok && push (ctx, new_integer (result));
 }
 
 defn (fn_or)
@@ -1118,13 +1221,12 @@ defn (fn_or)
 	check_stack (2);
 	struct item *op1 = pop (ctx);
 	struct item *op2 = pop (ctx);
-	bool result = to_boolean (ctx, op1) || ctx->error || to_boolean (ctx, op2);
+	bool ok = true;
+	bool result = to_boolean (ctx, op1, &ok)
+		|| !ok || to_boolean (ctx, op2, &ok);
 	item_free (op1);
 	item_free (op2);
-	if (ctx->error)
-		return false;
-	push (ctx, new_integer (result));
-	return true;
+	return ok && push (ctx, new_integer (result));
 }
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -1136,11 +1238,12 @@ defn (fn_if)
 	struct item *then_ = pop (ctx);
 	struct item *cond_ = pop (ctx);
 
-	bool condition = to_boolean (ctx, cond_);
+	bool ok = true;
+	bool condition = to_boolean (ctx, cond_, &ok);
 	item_free (cond_);
 
 	bool success = false;
-	if (!ctx->error
+	if (ok
 	 && check_type (ctx, then_, ITEM_LIST)
 	 && check_type (ctx, else_, ITEM_LIST))
 		success = execute (ctx, condition
@@ -1164,17 +1267,16 @@ defn (fn_try)
 
 	if (!execute (ctx, get_list (try)))
 	{
-		if (ctx->error_is_fatal)
+		if (ctx->memory_failure || ctx->error_is_fatal)
 			goto fail;
 
-		push (ctx, new_string (ctx->error, -1));
+		success = push (ctx, new_string (ctx->error, -1));
 		free (ctx->error);
 		ctx->error = NULL;
 
-		if (!execute (ctx, get_list (catch)))
-			goto fail;
+		if (success)
+			success = execute (ctx, get_list (catch));
 	}
-	success = true;
 
 fail:
 	item_free (try);
@@ -1199,8 +1301,8 @@ defn (fn_map)
 	struct item *result = NULL, **tail = &result;
 	for (struct item *iter = get_list (list); iter; iter = iter->next)
 	{
-		push (ctx, new_clone (iter));
-		if (!execute (ctx, get_list (fn))
+		if (!push (ctx, new_clone (iter))
+		 || !execute (ctx, get_list (fn))
 		 || !check_stack_safe (ctx, 1))
 			goto fail;
 
@@ -1212,13 +1314,13 @@ defn (fn_map)
 
 fail:
 	set_list (list, result);
-	if (success)
-		push (ctx, list);
-	else
-		item_free (list);
-
 	item_free (fn);
-	return success;
+	if (!success)
+	{
+		item_free (list);
+		return false;
+	}
+	return push (ctx, list);
 }
 
 defn (fn_filter)
@@ -1235,24 +1337,25 @@ defn (fn_filter)
 	}
 
 	bool success = false;
+	bool ok = true;
 	struct item *result = NULL, **tail = &result;
 	for (struct item *iter = get_list (list); iter; iter = iter->next)
 	{
-		push (ctx, new_clone (iter));
-		if (!execute (ctx, get_list (fn))
+		if (!push (ctx, new_clone (iter))
+		 || !execute (ctx, get_list (fn))
 		 || !check_stack_safe (ctx, 1))
 			goto fail;
 
 		struct item *item = pop (ctx);
-		bool survived = to_boolean (ctx, item);
+		bool survived = to_boolean (ctx, item, &ok);
 		item_free (item);
-		if (ctx->error)
+		if (!ok)
 			goto fail;
-
 		if (!survived)
 			continue;
 
-		item = new_clone (iter);
+		if (!(item = new_clone (iter)))
+			goto fail;
 		*tail = item;
 		tail = &item->next;
 	}
@@ -1260,13 +1363,13 @@ defn (fn_filter)
 
 fail:
 	set_list (list, result);
-	if (success)
-		push (ctx, list);
-	else
-		item_free (list);
-
 	item_free (fn);
-	return success;
+	if (!success)
+	{
+		item_free (list);
+		return false;
+	}
+	return push (ctx, list);
 }
 
 defn (fn_fold)
@@ -1285,11 +1388,9 @@ defn (fn_fold)
 
 	push (ctx, null);
 	for (struct item *iter = get_list (list); iter; iter = iter->next)
-	{
-		push (ctx, new_clone (iter));
-		if (!execute (ctx, get_list (op)))
+		if (!push (ctx, new_clone (iter))
+		 || !execute (ctx, get_list (op)))
 			goto fail;
-	}
 	success = true;
 
 fail:
@@ -1309,11 +1410,9 @@ defn (fn_each)
 		goto fail;
 
 	for (struct item *iter = get_list (list); iter; iter = iter->next)
-	{
-		push (ctx, new_clone (iter));
-		if (!execute (ctx, get_list (op)))
+		if (!push (ctx, new_clone (iter))
+		 || !execute (ctx, get_list (op)))
 			goto fail;
-	}
 	success = true;
 
 fail:
@@ -1334,10 +1433,7 @@ push_repeated_string (struct context *ctx, struct item *op1, struct item *op2)
 	assert (repeat->type == ITEM_INTEGER);
 
 	if (repeat->value < 0)
-	{
-		ctx->error = strdup ("cannot multiply a string by a negative value");
-		return false;
-	}
+		return set_error (ctx, "cannot multiply a string by a negative value");
 
 	char *buf = NULL;
 	size_t len = string->len * repeat->value;
@@ -1352,15 +1448,10 @@ push_repeated_string (struct context *ctx, struct item *op1, struct item *op2)
 		memcpy (buf + i, string->value, string->len);
 	struct item *item = new_string (buf, len);
 	free (buf);
-	if (!item)
-		goto allocation_fail;
-
-	push (ctx, item);
-	return true;
+	return push (ctx, item);
 
 allocation_fail:
-	// TODO: resolve the memory issues correctly, watch _all_ allocations
-	ctx->error = strdup ("memory allocation failed");
+	ctx->memory_failure = true;
 	return false;
 }
 
@@ -1369,30 +1460,27 @@ defn (fn_times)
 	check_stack (2);
 	struct item *op2 = pop (ctx);
 	struct item *op1 = pop (ctx);
-	bool success = true;
 
+	bool ok;
 	if      (op1->type == ITEM_INTEGER && op2->type == ITEM_INTEGER)
-		push (ctx, new_integer (get_integer (op1) * get_integer (op2)));
+		ok = push (ctx, new_integer (get_integer (op1) * get_integer (op2)));
 	else if (op1->type == ITEM_INTEGER && op2->type == ITEM_FLOAT)
-		push (ctx, new_float   (get_integer (op1) * get_float   (op2)));
+		ok = push (ctx, new_float   (get_integer (op1) * get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_FLOAT)
-		push (ctx, new_float   (get_float   (op1) * get_float   (op2)));
+		ok = push (ctx, new_float   (get_float   (op1) * get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_INTEGER)
-		push (ctx, new_float   (get_float   (op1) * get_integer (op2)));
+		ok = push (ctx, new_float   (get_float   (op1) * get_integer (op2)));
 	else if (op1->type == ITEM_INTEGER && op2->type == ITEM_STRING)
-		success = push_repeated_string (ctx, op2, op1);
+		ok = push_repeated_string (ctx, op2, op1);
 	else if (op1->type == ITEM_STRING  && op2->type == ITEM_INTEGER)
-		success = push_repeated_string (ctx, op1, op2);
+		ok = push_repeated_string (ctx, op1, op2);
 	else
-	{
-		ctx->error = strdup_printf ("cannot multiply `%s' and `%s'",
+		ok = set_error (ctx, "cannot multiply `%s' and `%s'",
 			item_type_to_str (op1->type), item_type_to_str (op2->type));
-		success = false;
-	}
 
 	item_free (op1);
 	item_free (op2);
-	return success;
+	return ok;
 }
 
 defn (fn_pow)
@@ -1400,27 +1488,24 @@ defn (fn_pow)
 	check_stack (2);
 	struct item *op2 = pop (ctx);
 	struct item *op1 = pop (ctx);
-	bool success = true;
 
+	bool ok;
 	if      (op1->type == ITEM_INTEGER && op2->type == ITEM_INTEGER)
 		// TODO: implement this properly, outputting an integer
-		push (ctx, new_float (powl (get_integer (op1), get_integer (op2))));
+		ok = push (ctx, new_float (powl (get_integer (op1), get_integer (op2))));
 	else if (op1->type == ITEM_INTEGER && op2->type == ITEM_FLOAT)
-		push (ctx, new_float (powl (get_integer (op1), get_float   (op2))));
+		ok = push (ctx, new_float (powl (get_integer (op1), get_float   (op2))));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_FLOAT)
-		push (ctx, new_float (powl (get_float   (op1), get_float   (op2))));
+		ok = push (ctx, new_float (powl (get_float   (op1), get_float   (op2))));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_INTEGER)
-		push (ctx, new_float (powl (get_float   (op1), get_integer (op2))));
+		ok = push (ctx, new_float (powl (get_float   (op1), get_integer (op2))));
 	else
-	{
-		ctx->error = strdup_printf ("cannot exponentiate `%s' and `%s'",
+		ok = set_error (ctx, "cannot exponentiate `%s' and `%s'",
 			item_type_to_str (op1->type), item_type_to_str (op2->type));
-		success = false;
-	}
 
 	item_free (op1);
 	item_free (op2);
-	return success;
+	return ok;
 }
 
 defn (fn_div)
@@ -1428,34 +1513,28 @@ defn (fn_div)
 	check_stack (2);
 	struct item *op2 = pop (ctx);
 	struct item *op1 = pop (ctx);
-	bool success = true;
 
+	bool ok;
 	if (op1->type == ITEM_INTEGER && op2->type == ITEM_INTEGER)
 	{
 		if (get_integer (op2) == 0)
-		{
-			ctx->error = strdup ("division by zero");
-			success = false;
-		}
+			ok = set_error (ctx, "division by zero");
 		else
-			push (ctx, new_integer (get_integer (op1) / get_integer (op2)));
+			ok = push (ctx, new_integer (get_integer (op1) / get_integer (op2)));
 	}
 	else if (op1->type == ITEM_INTEGER && op2->type == ITEM_FLOAT)
-		push (ctx, new_float (get_integer (op1) / get_float   (op2)));
+		ok = push (ctx, new_float (get_integer (op1) / get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_FLOAT)
-		push (ctx, new_float (get_float   (op1) / get_float   (op2)));
+		ok = push (ctx, new_float (get_float   (op1) / get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_INTEGER)
-		push (ctx, new_float (get_float   (op1) / get_integer (op2)));
+		ok = push (ctx, new_float (get_float   (op1) / get_integer (op2)));
 	else
-	{
-		ctx->error = strdup_printf ("cannot divide `%s' and `%s'",
+		ok = set_error (ctx, "cannot divide `%s' and `%s'",
 			item_type_to_str (op1->type), item_type_to_str (op2->type));
-		success = false;
-	}
 
 	item_free (op1);
 	item_free (op2);
-	return success;
+	return ok;
 }
 
 defn (fn_mod)
@@ -1463,34 +1542,28 @@ defn (fn_mod)
 	check_stack (2);
 	struct item *op2 = pop (ctx);
 	struct item *op1 = pop (ctx);
-	bool success = true;
 
+	bool ok;
 	if (op1->type == ITEM_INTEGER && op2->type == ITEM_INTEGER)
 	{
 		if (get_integer (op2) == 0)
-		{
-			ctx->error = strdup ("division by zero");
-			success = false;
-		}
+			ok = set_error (ctx, "division by zero");
 		else
-			push (ctx, new_integer (get_integer (op1) % get_integer (op2)));
+			ok = push (ctx, new_integer (get_integer (op1) % get_integer (op2)));
 	}
 	else if (op1->type == ITEM_INTEGER && op2->type == ITEM_FLOAT)
-		push (ctx, new_float (fmodl (get_integer (op1), get_float   (op2))));
+		ok = push (ctx, new_float (fmodl (get_integer (op1), get_float   (op2))));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_FLOAT)
-		push (ctx, new_float (fmodl (get_float   (op1), get_float   (op2))));
+		ok = push (ctx, new_float (fmodl (get_float   (op1), get_float   (op2))));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_INTEGER)
-		push (ctx, new_float (fmodl (get_float   (op1), get_integer (op2))));
+		ok = push (ctx, new_float (fmodl (get_float   (op1), get_integer (op2))));
 	else
-	{
-		ctx->error = strdup_printf ("cannot divide `%s' and `%s'",
+		ok = set_error (ctx, "cannot divide `%s' and `%s'",
 			item_type_to_str (op1->type), item_type_to_str (op2->type));
-		success = false;
-	}
 
 	item_free (op1);
 	item_free (op2);
-	return success;
+	return ok;
 }
 
 static bool
@@ -1515,15 +1588,10 @@ push_concatenated_string (struct context *ctx,
 	memcpy (buf + s1->len, s2->value, s2->len);
 	struct item *item = new_string (buf, len);
 	free (buf);
-	if (!item)
-		goto allocation_fail;
-
-	push (ctx, item);
-	return true;
+	return push (ctx, item);
 
 allocation_fail:
-	// TODO: resolve the memory issues correctly, watch _all_ allocations
-	ctx->error = strdup ("memory allocation failed");
+	ctx->memory_failure = true;
 	return false;
 
 }
@@ -1533,28 +1601,25 @@ defn (fn_plus)
 	check_stack (2);
 	struct item *op2 = pop (ctx);
 	struct item *op1 = pop (ctx);
-	bool success = true;
 
+	bool ok;
 	if      (op1->type == ITEM_INTEGER && op2->type == ITEM_INTEGER)
-		push (ctx, new_integer (get_integer (op1) + get_integer (op2)));
+		ok = push (ctx, new_integer (get_integer (op1) + get_integer (op2)));
 	else if (op1->type == ITEM_INTEGER && op2->type == ITEM_FLOAT)
-		push (ctx, new_float   (get_integer (op1) + get_float   (op2)));
+		ok = push (ctx, new_float   (get_integer (op1) + get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_FLOAT)
-		push (ctx, new_float   (get_float   (op1) + get_float   (op2)));
+		ok = push (ctx, new_float   (get_float   (op1) + get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_INTEGER)
-		push (ctx, new_float   (get_float   (op1) + get_integer (op2)));
+		ok = push (ctx, new_float   (get_float   (op1) + get_integer (op2)));
 	else if (op1->type == ITEM_STRING  && op2->type == ITEM_STRING)
-		success = push_concatenated_string (ctx, op1, op2);
+		ok = push_concatenated_string (ctx, op1, op2);
 	else
-	{
-		ctx->error = strdup_printf ("cannot add `%s' and `%s'",
+		ok = set_error (ctx, "cannot add `%s' and `%s'",
 			item_type_to_str (op1->type), item_type_to_str (op2->type));
-		success = false;
-	}
 
 	item_free (op1);
 	item_free (op2);
-	return success;
+	return ok;
 }
 
 defn (fn_minus)
@@ -1562,26 +1627,23 @@ defn (fn_minus)
 	check_stack (2);
 	struct item *op2 = pop (ctx);
 	struct item *op1 = pop (ctx);
-	bool success = true;
 
+	bool ok;
 	if      (op1->type == ITEM_INTEGER && op2->type == ITEM_INTEGER)
-		push (ctx, new_integer (get_integer (op1) - get_integer (op2)));
+		ok = push (ctx, new_integer (get_integer (op1) - get_integer (op2)));
 	else if (op1->type == ITEM_INTEGER && op2->type == ITEM_FLOAT)
-		push (ctx, new_float   (get_integer (op1) - get_float   (op2)));
+		ok = push (ctx, new_float   (get_integer (op1) - get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_FLOAT)
-		push (ctx, new_float   (get_float   (op1) - get_float   (op2)));
+		ok = push (ctx, new_float   (get_float   (op1) - get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_INTEGER)
-		push (ctx, new_float   (get_float   (op1) - get_integer (op2)));
+		ok = push (ctx, new_float   (get_float   (op1) - get_integer (op2)));
 	else
-	{
-		ctx->error = strdup_printf ("cannot subtract `%s' and `%s'",
+		ok = set_error (ctx, "cannot subtract `%s' and `%s'",
 			item_type_to_str (op1->type), item_type_to_str (op2->type));
-		success = false;
-	}
 
 	item_free (op1);
 	item_free (op2);
-	return success;
+	return ok;
 }
 
 // - - Comparison  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -1637,32 +1699,29 @@ defn (fn_eq)
 	check_stack (2);
 	struct item *op2 = pop (ctx);
 	struct item *op1 = pop (ctx);
-	bool success = true;
 
+	bool ok;
 	if      (op1->type == ITEM_INTEGER && op2->type == ITEM_INTEGER)
-		push (ctx, new_integer (get_integer (op1) == get_integer (op2)));
+		ok = push (ctx, new_integer (get_integer (op1) == get_integer (op2)));
 	else if (op1->type == ITEM_INTEGER && op2->type == ITEM_FLOAT)
-		push (ctx, new_integer (get_integer (op1) == get_float   (op2)));
+		ok = push (ctx, new_integer (get_integer (op1) == get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_FLOAT)
-		push (ctx, new_integer (get_float   (op1) == get_float   (op2)));
+		ok = push (ctx, new_integer (get_float   (op1) == get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_INTEGER)
-		push (ctx, new_integer (get_float   (op1) == get_integer (op2)));
+		ok = push (ctx, new_integer (get_float   (op1) == get_integer (op2)));
 	else if (op1->type == ITEM_LIST    && op2->type == ITEM_LIST)
-		push (ctx, new_integer (compare_lists
+		ok = push (ctx, new_integer (compare_lists
 			(get_list (op1), get_list (op2))));
 	else if (op1->type == ITEM_STRING  && op2->type == ITEM_STRING)
-		push (ctx, new_integer (compare_strings
+		ok = push (ctx, new_integer (compare_strings
 			((struct item_string *)(op1), (struct item_string *)(op2)) == 0));
 	else
-	{
-		ctx->error = strdup_printf ("cannot compare `%s' and `%s'",
+		ok = set_error (ctx, "cannot compare `%s' and `%s'",
 			item_type_to_str (op1->type), item_type_to_str (op2->type));
-		success = false;
-	}
 
 	item_free (op1);
 	item_free (op2);
-	return success;
+	return ok;
 }
 
 defn (fn_lt)
@@ -1670,44 +1729,39 @@ defn (fn_lt)
 	check_stack (2);
 	struct item *op2 = pop (ctx);
 	struct item *op1 = pop (ctx);
-	bool success = true;
 
+	bool ok;
 	if      (op1->type == ITEM_INTEGER && op2->type == ITEM_INTEGER)
-		push (ctx, new_integer (get_integer (op1) < get_integer (op2)));
+		ok = push (ctx, new_integer (get_integer (op1) < get_integer (op2)));
 	else if (op1->type == ITEM_INTEGER && op2->type == ITEM_FLOAT)
-		push (ctx, new_integer (get_integer (op1) < get_float   (op2)));
+		ok = push (ctx, new_integer (get_integer (op1) < get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_FLOAT)
-		push (ctx, new_integer (get_float   (op1) < get_float   (op2)));
+		ok = push (ctx, new_integer (get_float   (op1) < get_float   (op2)));
 	else if (op1->type == ITEM_FLOAT   && op2->type == ITEM_INTEGER)
-		push (ctx, new_integer (get_float   (op1) < get_integer (op2)));
+		ok = push (ctx, new_integer (get_float   (op1) < get_integer (op2)));
 	else if (op1->type == ITEM_STRING  && op2->type == ITEM_STRING)
-		push (ctx, new_integer (compare_strings
+		ok = push (ctx, new_integer (compare_strings
 			((struct item_string *)(op1), (struct item_string *)(op2)) < 0));
 	else
-	{
-		ctx->error = strdup_printf ("cannot compare `%s' and `%s'",
+		ok = set_error (ctx, "cannot compare `%s' and `%s'",
 			item_type_to_str (op1->type), item_type_to_str (op2->type));
-		success = false;
-	}
 
 	item_free (op1);
 	item_free (op2);
-	return success;
+	return ok;
 }
 
 // - - Utilities - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 defn (fn_rand)
 {
-	push (ctx, new_float ((long double) rand ()
+	return push (ctx, new_float ((long double) rand ()
 		/ ((long double) RAND_MAX + 1)));
-	return true;
 }
 
 defn (fn_time)
 {
-	push (ctx, new_integer (time (NULL)));
-	return true;
+	return push (ctx, new_integer (time (NULL)));
 }
 
 // XXX: this is a bit too constrained; combines strftime() with gmtime()
@@ -1723,7 +1777,7 @@ defn (fn_strftime)
 
 	if (get_integer (time_) < 0)
 	{
-		ctx->error = strdup ("invalid time value");
+		set_error (ctx, "invalid time value");
 		goto fail;
 	}
 
@@ -1732,8 +1786,7 @@ defn (fn_strftime)
 	struct tm tm;
 	gmtime_r (&time__, &tm);
 	buf[strftime (buf, sizeof buf, get_string (format), &tm)] = '\0';
-	push (ctx, new_string (buf, -1));
-	success = true;
+	success = push (ctx, new_string (buf, -1));
 
 fail:
 	item_free (time_);
@@ -1784,12 +1837,14 @@ item_to_str (const struct item *item, struct buffer *buf)
 		break;
 	}
 	case ITEM_INTEGER:
-		x = strdup_printf ("%lld", get_integer (item));
+		if (!(x = strdup_printf ("%lld", get_integer (item))))
+			goto alloc_failure;
 		buffer_append (buf, x, strlen (x));
 		free (x);
 		break;
 	case ITEM_FLOAT:
-		x = strdup_printf ("%Lf", get_float (item));
+		if (!(x = strdup_printf ("%Lf", get_float (item))))
+			goto alloc_failure;
 		buffer_append (buf, x, strlen (x));
 		free (x);
 		break;
@@ -1799,18 +1854,26 @@ item_to_str (const struct item *item, struct buffer *buf)
 		buffer_append_c (buf, ']');
 		break;
 	}
+	return;
+
+alloc_failure:
+	// This is a bit hackish but it simplifies stuff
+	buf->memory_failure = true;
+	free (buf->s);
+	buf->s = NULL;
 }
 
 static void
 item_list_to_str (const struct item *script, struct buffer *buf)
 {
-	bool first = true;
-	for (; script; script = script->next)
+	if (!script)
+		return;
+
+	item_to_str (script, buf);
+	while ((script = script->next))
 	{
-		if (!first)
-			buffer_append_c (buf, ' ');
+		buffer_append_c (buf, ' ');
 		item_to_str (script, buf);
-		first = false;
 	}
 }
 
@@ -1880,7 +1943,7 @@ read_message (void)
 	do
 	{
 		if (!fgets (buf, sizeof buf, stdin))
-			exit (EXIT_SUCCESS);
+			return NULL;
 		size_t len = strlen (buf);
 
 		// Just to be on the safe side, if the line overflows our buffer,
@@ -1908,7 +1971,7 @@ get_config (const char *key)
 {
 	printf ("ZYKLONB get_config :%s\r\n", key);
 	struct message *msg = read_message ();
-	if (msg->n_params <= 0)
+	if (!msg || msg->n_params <= 0)
 		exit (EXIT_FAILURE);
 	return msg->params[0];
 }
@@ -1917,9 +1980,11 @@ get_config (const char *key)
 
 // TODO: implement more functions; try to avoid writing them in C
 
-static void
+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
@@ -1957,107 +2022,136 @@ init_runtime_library_scripts (void)
 
 	for (size_t i = 0; i < N_ELEMENTS (scripts); i++)
 	{
-		char *error = NULL;
+		const char *error = NULL;
 		struct item *script = parse (scripts[i].definition, &error);
 		if (error)
 		{
 			printf (BOT_PRINT "error parsing internal script `%s': %s\r\n",
 				scripts[i].definition, error);
-			free (error);
-			continue;
+			ok = false;
 		}
-		register_script (scripts[i].name, script);
+		else
+			ok &= register_script (scripts[i].name, script);
 	}
 
 	struct context ctx;
 	for (size_t i = 0; i < N_ELEMENTS (scripts); i++)
 	{
-		char *error = NULL;
+		const char *error = NULL;
 		struct item *script = parse (scripts[i].unit_test, &error);
 		if (error)
 		{
 			printf (BOT_PRINT "error parsing unit test for `%s': %s\r\n",
 				scripts[i].name, error);
-			free (error);
+			ok = false;
 			continue;
 		}
 		context_init (&ctx);
 		execute (&ctx, script);
 		item_free_list (script);
-		if (ctx.error || ctx.stack_size != 1
-		 || ctx.stack->type != ITEM_INTEGER || get_integer (ctx.stack) != 1)
+
+		const char *failure = NULL;
+		if (ctx.memory_failure)
+			failure = "memory allocation failure";
+		else if (ctx.error)
+			failure = ctx.error;
+		else if (ctx.stack_size != 1)
+			failure = "too many results on the stack";
+		else if (ctx.stack->type != ITEM_INTEGER)
+			failure = "result is not an integer";
+		else if (get_integer (ctx.stack) != 1)
+			failure = "wrong test result";
+		if (failure)
+		{
 			printf (BOT_PRINT "error executing unit test for `%s': %s\r\n",
-				scripts[i].name, ctx.error ? ctx.error : "wrong test result");
+				scripts[i].name, failure);
+			ok = false;
+		}
 		context_free (&ctx);
 	}
+	return ok;
 }
 
-static void
+static bool
 init_runtime_library (void)
 {
+	bool ok = true;
+
 	// Type detection
-	register_handler ("string?",  fn_is_string);
-	register_handler ("word?",    fn_is_word);
-	register_handler ("integer?", fn_is_integer);
-	register_handler ("float?",   fn_is_float);
-	register_handler ("list?",    fn_is_list);
+	ok &= register_handler ("string?",  fn_is_string);
+	ok &= register_handler ("word?",    fn_is_word);
+	ok &= register_handler ("integer?", fn_is_integer);
+	ok &= register_handler ("float?",   fn_is_float);
+	ok &= register_handler ("list?",    fn_is_list);
 
 	// Type conversion
-	register_handler (">string",  fn_to_string);
-	register_handler (">integer", fn_to_integer);
-	register_handler (">float",   fn_to_float);
+	ok &= register_handler (">string",  fn_to_string);
+	ok &= register_handler (">integer", fn_to_integer);
+	ok &= register_handler (">float",   fn_to_float);
 
 	// Miscellaneous
-	register_handler ("length",   fn_length);
+	ok &= register_handler ("length",   fn_length);
 
 	// Basic stack manipulation
-	register_handler ("dup",      fn_dup);
-	register_handler ("drop",     fn_drop);
-	register_handler ("swap",     fn_swap);
+	ok &= register_handler ("dup",      fn_dup);
+	ok &= register_handler ("drop",     fn_drop);
+	ok &= register_handler ("swap",     fn_swap);
 
 	// Calling stuff
-	register_handler ("call",     fn_call);
-	register_handler ("dip",      fn_dip);
+	ok &= register_handler ("call",     fn_call);
+	ok &= register_handler ("dip",      fn_dip);
 
 	// Control flow
-	register_handler ("if",       fn_if);
-	register_handler ("try",      fn_try);
+	ok &= register_handler ("if",       fn_if);
+	ok &= register_handler ("try",      fn_try);
 
 	// List processing
-	register_handler ("map",      fn_map);
-	register_handler ("filter",   fn_filter);
-	register_handler ("fold",     fn_fold);
-	register_handler ("each",     fn_each);
+	ok &= register_handler ("map",      fn_map);
+	ok &= register_handler ("filter",   fn_filter);
+	ok &= register_handler ("fold",     fn_fold);
+	ok &= register_handler ("each",     fn_each);
 
 	// List manipulation
-	register_handler ("unit",     fn_unit);
-	register_handler ("cons",     fn_cons);
-	register_handler ("cat",      fn_cat);
-	register_handler ("uncons",   fn_uncons);
+	ok &= register_handler ("unit",     fn_unit);
+	ok &= register_handler ("cons",     fn_cons);
+	ok &= register_handler ("cat",      fn_cat);
+	ok &= register_handler ("uncons",   fn_uncons);
 
 	// Arithmetic operations
-	register_handler ("+",        fn_plus);
-	register_handler ("-",        fn_minus);
-	register_handler ("*",        fn_times);
-	register_handler ("^",        fn_pow);
-	register_handler ("/",        fn_div);
-	register_handler ("%",        fn_mod);
+	ok &= register_handler ("+",        fn_plus);
+	ok &= register_handler ("-",        fn_minus);
+	ok &= register_handler ("*",        fn_times);
+	ok &= register_handler ("^",        fn_pow);
+	ok &= register_handler ("/",        fn_div);
+	ok &= register_handler ("%",        fn_mod);
 
 	// Comparison
-	register_handler ("=",        fn_eq);
-	register_handler ("<",        fn_lt);
+	ok &= register_handler ("=",        fn_eq);
+	ok &= register_handler ("<",        fn_lt);
 
 	// Logical operations
-	register_handler ("not",      fn_not);
-	register_handler ("and",      fn_and);
-	register_handler ("or",       fn_or);
+	ok &= register_handler ("not",      fn_not);
+	ok &= register_handler ("and",      fn_and);
+	ok &= register_handler ("or",       fn_or);
 
 	// Utilities
-	register_handler ("rand",     fn_rand);
-	register_handler ("time",     fn_time);
-	register_handler ("strftime", fn_strftime);
+	ok &= register_handler ("rand",     fn_rand);
+	ok &= register_handler ("time",     fn_time);
+	ok &= register_handler ("strftime", fn_strftime);
 
-	init_runtime_library_scripts ();
+	ok &= init_runtime_library_scripts ();
+	return ok;
+}
+
+static void
+free_runtime_library (void)
+{
+	struct fn *next, *iter;
+	for (iter = g_functions; iter; iter = next)
+	{
+		next = iter->next;
+		free_function (iter);
+	}
 }
 
 // --- Function database -------------------------------------------------------
@@ -2097,6 +2191,12 @@ defn (fn_dot)
 	item_to_str (item, &buf);
 	item_free (item);
 	buffer_append_c (&buf, '\0');
+	if (buf.memory_failure)
+	{
+		ctx->memory_failure = true;
+		return false;
+	}
+
 	printf ("PRIVMSG %s :%s%s\r\n", info->ctx, info->ctx_quote, buf.s);
 	free (buf.s);
 	return true;
@@ -2105,7 +2205,9 @@ defn (fn_dot)
 static void
 process_message (struct message *msg)
 {
-	if (strcasecmp (msg->command, "PRIVMSG") || msg->n_params < 2)
+	if (!msg->prefix
+	 || strcasecmp (msg->command, "PRIVMSG")
+	 || msg->n_params < 2)
 		return;
 	char *line = msg->params[1];
 
@@ -2133,18 +2235,23 @@ process_message (struct message *msg)
 	else
 		msg_ctx_quote = strdup ("");
 
+	if (!msg_ctx_quote)
+	{
+		printf (BOT_PRINT "%s\r\n", "memory allocation failure");
+		return;
+	}
+
 	struct user_info info;
 	info.ctx = msg_ctx;
 	info.ctx_quote = msg_ctx_quote;
 
 	// Finally parse and execute the macro
-	char *error = NULL;
+	const char *error = NULL;
 	struct item *script = parse (line, &error);
 	if (error)
 	{
 		printf ("PRIVMSG %s :%s%s: %s\r\n",
 			msg_ctx, msg_ctx_quote, "parse error", error);
-		free (error);
 		goto end;
 	}
 
@@ -2153,9 +2260,15 @@ process_message (struct message *msg)
 	ctx.user_data = &info;
 	execute (&ctx, script);
 	item_free_list (script);
-	if (ctx.error)
+
+	const char *failure = NULL;
+	if (ctx.memory_failure)
+		failure = "memory allocation failure";
+	else if (ctx.error)
+		failure = ctx.error;
+	if (failure)
 		printf ("PRIVMSG %s :%s%s: %s\r\n",
-			msg_ctx, msg_ctx_quote, "runtime error", ctx.error);
+			msg_ctx, msg_ctx_quote, "runtime error", failure);
 	context_free (&ctx);
 end:
 	free (msg_ctx_quote);
@@ -2177,16 +2290,18 @@ main (int argc, char *argv[])
 	(void) setrlimit (RLIMIT_AS, &limit);
 
 	read_db ();
-	init_runtime_library ();
-	register_handler (".", fn_dot);
+	if (!init_runtime_library ()
+	 || !register_handler (".", fn_dot))
+		printf (BOT_PRINT "%s\r\n", "runtime library initialization failed");
 
 	g_prefix = strdup (get_config ("prefix"));
 	printf ("ZYKLONB register\r\n");
-	while (true)
-	{
-		struct message *msg = read_message ();
+	struct message *msg;
+	while ((msg = read_message ()))
 		process_message (msg);
-	}
+
+	free_runtime_library ();
+	free (g_prefix);
 	return 0;
 }