Bump liberty

1 files changed, 0 insertions, 1118 deletions

diff --git a/common.c b/common.c
index d37192e..8470171 100644
--- a/common.c
+++ b/common.c
@@ -30,8 +30,6 @@
 #endif // WANT_SYSLOG_LOGGING
 
 #include "liberty/liberty.c"
-#include <setjmp.h>
-#include <inttypes.h>
 #include <arpa/inet.h>
 #include <netinet/tcp.h>
 
@@ -47,18 +45,6 @@
 
 // --- To be moved to liberty --------------------------------------------------
 
-static void
-split_str (const char *s, const char *delimiters, struct str_vector *out)
-{
-	const char *begin = s, *end;
-	while ((end = strpbrk (begin, delimiters)))
-	{
-		str_vector_add_owned (out, xstrndup (begin, end - begin));
-		begin = ++end;
-	}
-	str_vector_add (out, begin);
-}
-
 static ssize_t
 str_vector_find (const struct str_vector *v, const char *s)
 {
@@ -1001,1107 +987,3 @@ ctcp_destroy (struct ctcp_chunk *list)
 	LIST_FOR_EACH (struct ctcp_chunk, iter, list)
 		ctcp_chunk_destroy (iter);
 }
-
-// --- Advanced configuration --------------------------------------------------
-
-// This is a new configuration format, superseding the one currently present
-// in liberty.  It's just a lot more complicated and allows key-value maps.
-// We need it in degesch to provide non-sucking user experience.
-
-enum config_item_type
-{
-	CONFIG_ITEM_NULL,                   ///< No value
-	CONFIG_ITEM_OBJECT,                 ///< Key-value map
-	CONFIG_ITEM_BOOLEAN,                ///< Truth value
-	CONFIG_ITEM_INTEGER,                ///< Integer
-	CONFIG_ITEM_STRING,                 ///< Arbitrary string of characters
-	CONFIG_ITEM_STRING_ARRAY            ///< Comma-separated list of strings
-};
-
-struct config_item
-{
-	enum config_item_type type;         ///< Type of the item
-	union
-	{
-		struct str_map object;          ///< Key-value data
-		bool boolean;                   ///< Boolean data
-		int64_t integer;                ///< Integer data
-		struct str string;              ///< String data
-	}
-	value;                              ///< The value of this item
-
-	struct config_schema *schema;       ///< Schema describing this value
-	void *user_data;                    ///< User value attached by schema owner
-};
-
-struct config_schema
-{
-	const char *name;                   ///< Name of the item
-	const char *comment;                ///< User-readable description
-
-	enum config_item_type type;         ///< Required type
-	const char *default_;               ///< Default as a configuration snippet
-
-	/// Check if the new value can be accepted.
-	/// In addition to this, "type" and having a default is considered.
-	bool (*validate) (const struct config_item *, struct error **e);
-
-	/// The value has changed
-	void (*on_change) (struct config_item *);
-};
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static const char *
-config_item_type_name (enum config_item_type type)
-{
-	switch (type)
-	{
-	case CONFIG_ITEM_NULL:          return "null";
-	case CONFIG_ITEM_BOOLEAN:       return "boolean";
-	case CONFIG_ITEM_INTEGER:       return "integer";
-	case CONFIG_ITEM_STRING:        return "string";
-	case CONFIG_ITEM_STRING_ARRAY:  return "string array";
-
-	default:
-		hard_assert (!"invalid config item type value");
-		return NULL;
-	}
-}
-
-static bool
-config_item_type_is_string (enum config_item_type type)
-{
-	return type == CONFIG_ITEM_STRING
-		|| type == CONFIG_ITEM_STRING_ARRAY;
-}
-
-static void
-config_item_free (struct config_item *self)
-{
-	switch (self->type)
-	{
-	case CONFIG_ITEM_STRING:
-	case CONFIG_ITEM_STRING_ARRAY:
-		str_free (&self->value.string);
-		break;
-	case CONFIG_ITEM_OBJECT:
-		str_map_free (&self->value.object);
-	default:
-		break;
-	}
-}
-
-static void
-config_item_destroy (struct config_item *self)
-{
-	config_item_free (self);
-	free (self);
-}
-
-/// Doesn't do any validations or handle schemas, just moves source data
-/// to the target item and destroys the source item
-static void
-config_item_move (struct config_item *self, struct config_item *source)
-{
-	// Not quite sure how to handle that
-	hard_assert (!source->schema);
-
-	config_item_free (self);
-	self->type = source->type;
-	memcpy (&self->value, &source->value, sizeof source->value);
-	free (source);
-}
-
-static struct config_item *
-config_item_new (enum config_item_type type)
-{
-	struct config_item *self = xcalloc (1, sizeof *self);
-	self->type = type;
-	return self;
-}
-
-static struct config_item *
-config_item_null (void)
-{
-	return config_item_new (CONFIG_ITEM_NULL);
-}
-
-static struct config_item *
-config_item_boolean (bool b)
-{
-	struct config_item *self = config_item_new (CONFIG_ITEM_BOOLEAN);
-	self->value.boolean = b;
-	return self;
-}
-
-static struct config_item *
-config_item_integer (int64_t i)
-{
-	struct config_item *self = config_item_new (CONFIG_ITEM_INTEGER);
-	self->value.integer = i;
-	return self;
-}
-
-static struct config_item *
-config_item_string (const struct str *s)
-{
-	struct config_item *self = config_item_new (CONFIG_ITEM_STRING);
-	str_init (&self->value.string);
-	hard_assert (utf8_validate
-		(self->value.string.str, self->value.string.len));
-	if (s) str_append_str (&self->value.string, s);
-	return self;
-}
-
-static struct config_item *
-config_item_string_from_cstr (const char *s)
-{
-	struct str tmp;
-	str_init (&tmp);
-	str_append (&tmp, s);
-	struct config_item *self = config_item_string (&tmp);
-	str_free (&tmp);
-	return self;
-}
-
-static struct config_item *
-config_item_string_array (const struct str *s)
-{
-	struct config_item *self = config_item_string (s);
-	self->type = CONFIG_ITEM_STRING_ARRAY;
-	return self;
-}
-
-static struct config_item *
-config_item_object (void)
-{
-	struct config_item *self = config_item_new (CONFIG_ITEM_OBJECT);
-	str_map_init (&self->value.object);
-	self->value.object.free = (void (*)(void *)) config_item_destroy;
-	return self;
-}
-
-static bool
-config_schema_accepts_type
-	(struct config_schema *self, enum config_item_type type)
-{
-	if (self->type == type)
-		return true;
-	// This is a bit messy but it has its purpose
-	if (config_item_type_is_string (self->type)
-	 && config_item_type_is_string (type))
-		return true;
-	return !self->default_ && type == CONFIG_ITEM_NULL;
-}
-
-static bool
-config_item_validate_by_schema (struct config_item *self,
-	struct config_schema *schema, struct error **e)
-{
-	struct error *error = NULL;
-	if (!config_schema_accepts_type (schema, self->type))
-		error_set (e, "invalid type of value, expected: %s%s",
-			config_item_type_name (schema->type),
-			!schema->default_ ? " (or null)" : "");
-	else if (schema->validate && !schema->validate (self, &error))
-	{
-		error_set (e, "%s: %s", "invalid value", error->message);
-		error_free (error);
-	}
-	else
-		return true;
-	return false;
-}
-
-static bool
-config_item_set_from (struct config_item *self, struct config_item *source,
-	struct error **e)
-{
-	struct config_schema *schema = self->schema;
-	if (!schema)
-	{
-		// Easy, we don't know what this item is
-		config_item_move (self, source);
-		return true;
-	}
-
-	if (!config_item_validate_by_schema (source, schema, e))
-		return false;
-
-	// Make sure the string subtype fits the schema
-	if (config_item_type_is_string (source->type)
-	 && config_item_type_is_string (schema->type))
-		source->type = schema->type;
-
-	config_item_move (self, source);
-
-	// Notify owner about the change so that they can apply it
-	if (schema->on_change)
-		schema->on_change (self);
-	return true;
-}
-
-static struct config_item *
-config_item_get (struct config_item *self, const char *path, struct error **e)
-{
-	hard_assert (self->type == CONFIG_ITEM_OBJECT);
-
-	struct str_vector v;
-	str_vector_init (&v);
-	split_str (path, ".", &v);
-
-	struct config_item *result = NULL;
-	size_t i = 0;
-	while (true)
-	{
-		const char *key = v.vector[i];
-		if (!*key)
-			error_set (e, "empty path element");
-		else if (!(self = str_map_find (&self->value.object, key)))
-			error_set (e, "`%s' not found in object", key);
-		else if (++i == v.len)
-			result = self;
-		else if (self->type != CONFIG_ITEM_OBJECT)
-			error_set (e, "`%s' is not an object", key);
-		else
-			continue;
-		break;
-	}
-	str_vector_free (&v);
-	return result;
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-struct config_writer
-{
-	struct str *output;
-	unsigned indent;
-};
-
-static void config_item_write_object_innards
-	(struct config_writer *self, struct config_item *object);
-
-static void
-config_item_write_string (struct str *output, const struct str *s)
-{
-	str_append_c (output, '"');
-	for (size_t i = 0; i < s->len; i++)
-	{
-		unsigned char c = s->str[i];
-		if      (c == '\n')  str_append        (output, "\\n");
-		else if (c == '\r')  str_append        (output, "\\r");
-		else if (c == '\t')  str_append        (output, "\\t");
-		else if (c == '\\')  str_append        (output, "\\\\");
-		else if (c == '"')   str_append        (output, "\\\"");
-		else if (c < 32)     str_append_printf (output, "\\x%02x", c);
-		else                 str_append_c      (output, c);
-	}
-	str_append_c (output, '"');
-}
-
-static void
-config_item_write_object
-	(struct config_writer *self, struct config_item *value)
-{
-	char indent[self->indent + 1];
-	memset (indent, '\t', self->indent);
-	indent[self->indent] = 0;
-
-	str_append_c (self->output, '{');
-	if (value->value.object.len)
-	{
-		self->indent++;
-		str_append_c (self->output, '\n');
-		config_item_write_object_innards (self, value);
-		self->indent--;
-		str_append (self->output, indent);
-	}
-	str_append_c (self->output, '}');
-}
-
-static void
-config_item_write_value (struct config_writer *self, struct config_item *value)
-{
-	switch (value->type)
-	{
-	case CONFIG_ITEM_NULL:
-		str_append (self->output, "null");
-		break;
-	case CONFIG_ITEM_BOOLEAN:
-		str_append (self->output, value->value.boolean ? "on" : "off");
-		break;
-	case CONFIG_ITEM_INTEGER:
-		str_append_printf (self->output, "%" PRIi64, value->value.integer);
-		break;
-	case CONFIG_ITEM_STRING:
-	case CONFIG_ITEM_STRING_ARRAY:
-		config_item_write_string (self->output, &value->value.string);
-		break;
-	case CONFIG_ITEM_OBJECT:
-		config_item_write_object (self, value);
-		break;
-	default:
-		hard_assert (!"invalid item type");
-	}
-}
-
-static void
-config_item_write_kv_pair (struct config_writer *self,
-	const char *key, struct config_item *value)
-{
-	char indent[self->indent + 1];
-	memset (indent, '\t', self->indent);
-	indent[self->indent] = 0;
-
-	if (value->schema && value->schema->comment)
-		str_append_printf (self->output,
-			"%s# %s\n", indent, value->schema->comment);
-
-	str_append_printf (self->output, "%s%s = ", indent, key);
-	config_item_write_value (self, value);
-	str_append_c (self->output, '\n');
-}
-
-static void
-config_item_write_object_innards
-	(struct config_writer *self, struct config_item *object)
-{
-	hard_assert (object->type == CONFIG_ITEM_OBJECT);
-
-	struct str_map_iter iter;
-	str_map_iter_init (&iter, &object->value.object);
-
-	struct config_item *value;
-	while ((value = str_map_iter_next (&iter)))
-		config_item_write_kv_pair (self, iter.link->key, value);
-}
-
-static void
-config_item_write (struct config_item *value,
-	bool object_innards, struct str *output)
-{
-	struct config_writer writer = { .output = output, .indent = 0 };
-	if (object_innards)
-		config_item_write_object_innards (&writer, value);
-	else
-		config_item_write_value (&writer, value);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-enum config_token
-{
-	CONFIG_T_ABORT,                     ///< EOF or error
-
-	CONFIG_T_WORD,                      ///< [a-zA-Z0-9_]+
-	CONFIG_T_EQUALS,                    ///< Equal sign
-	CONFIG_T_LBRACE,                    ///< Left curly bracket
-	CONFIG_T_RBRACE,                    ///< Right curly bracket
-	CONFIG_T_NEWLINE,                   ///< New line
-
-	CONFIG_T_NULL,                      ///< CONFIG_ITEM_NULL
-	CONFIG_T_BOOLEAN,                   ///< CONFIG_ITEM_BOOLEAN
-	CONFIG_T_INTEGER,                   ///< CONFIG_ITEM_INTEGER
-	CONFIG_T_STRING                     ///< CONFIG_ITEM_STRING{,_LIST}
-};
-
-static const char *
-config_token_name (enum config_token token)
-{
-	switch (token)
-	{
-	case CONFIG_T_ABORT:    return "end of input";
-
-	case CONFIG_T_WORD:     return "word";
-	case CONFIG_T_EQUALS:   return "equal sign";
-	case CONFIG_T_LBRACE:   return "left brace";
-	case CONFIG_T_RBRACE:   return "right brace";
-	case CONFIG_T_NEWLINE:  return "newline";
-
-	case CONFIG_T_NULL:     return "null value";
-	case CONFIG_T_BOOLEAN:  return "boolean";
-	case CONFIG_T_INTEGER:  return "integer";
-	case CONFIG_T_STRING:   return "string";
-
-	default:
-		hard_assert (!"invalid token value");
-		return NULL;
-	}
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-struct config_tokenizer
-{
-	const char *p;                      ///< Current position in input
-	size_t len;                         ///< How many bytes of input are left
-
-	bool report_line;                   ///< Whether to count lines at all
-	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
-config_tokenizer_init (struct config_tokenizer *self, const char *p, size_t len)
-{
-	memset (self, 0, sizeof *self);
-	self->p = p;
-	self->len = len;
-	self->report_line = true;
-	str_init (&self->string);
-}
-
-static void
-config_tokenizer_free (struct config_tokenizer *self)
-{
-	str_free (&self->string);
-}
-
-static bool
-config_tokenizer_is_word_char (int c)
-{
-	return isalnum_ascii (c) || c == '_';
-}
-
-static int
-config_tokenizer_advance (struct config_tokenizer *self)
-{
-	int c = *self->p++;
-	if (c == '\n' && self->report_line)
-	{
-		self->column = 0;
-		self->line++;
-	}
-	else
-		self->column++;
-
-	self->len--;
-	return c;
-}
-
-static void config_tokenizer_error (struct config_tokenizer *self,
-	struct error **e, const char *format, ...) ATTRIBUTE_PRINTF (3, 4);
-
-static void
-config_tokenizer_error (struct config_tokenizer *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
-config_tokenizer_hexa_escape (struct config_tokenizer *self, struct str *output)
-{
-	int i;
-	unsigned char code = 0;
-
-	for (i = 0; self->len && i < 2; i++)
-	{
-		unsigned char c = tolower_ascii (*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;
-
-		config_tokenizer_advance (self);
-	}
-
-	if (!i)
-		return false;
-
-	str_append_c (output, code);
-	return true;
-}
-
-static bool
-config_tokenizer_octal_escape
-	(struct config_tokenizer *self, struct str *output)
-{
-	int i;
-	unsigned char code = 0;
-
-	for (i = 0; self->len && i < 3; i++)
-	{
-		unsigned char c = *self->p;
-		if (c >= '0' && c <= '7')
-			code = (code << 3) | (c - '0');
-		else
-			break;
-
-		config_tokenizer_advance (self);
-	}
-
-	if (!i)
-		return false;
-
-	str_append_c (output, code);
-	return true;
-}
-
-static bool
-config_tokenizer_escape_sequence
-	(struct config_tokenizer *self, struct str *output, struct error **e)
-{
-	if (!self->len)
-	{
-		config_tokenizer_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':
-		config_tokenizer_advance (self);
-		if (config_tokenizer_hexa_escape (self, output))
-			return true;
-
-		config_tokenizer_error (self, e, "invalid hexadecimal escape");
-		return false;
-
-	default:
-		if (config_tokenizer_octal_escape (self, output))
-			return true;
-
-		config_tokenizer_error (self, e, "unknown escape sequence");
-		return false;
-	}
-
-	str_append_c (output, c);
-	config_tokenizer_advance (self);
-	return true;
-}
-
-static bool
-config_tokenizer_string
-	(struct config_tokenizer *self, struct str *output, struct error **e)
-{
-	unsigned char c;
-	while (self->len)
-	{
-		if ((c = config_tokenizer_advance (self)) == '"')
-			return true;
-		if (c != '\\')
-			str_append_c (output, c);
-		else if (!config_tokenizer_escape_sequence (self, output, e))
-			return false;
-	}
-	config_tokenizer_error (self, e, "premature end of string");
-	return false;
-}
-
-static enum config_token
-config_tokenizer_next (struct config_tokenizer *self, struct error **e)
-{
-	// Skip over any whitespace between tokens
-	while (self->len && isspace_ascii (*self->p) && *self->p != '\n')
-		config_tokenizer_advance (self);
-	if (!self->len)
-		return CONFIG_T_ABORT;
-
-	switch (*self->p)
-	{
-	case '\n':  config_tokenizer_advance (self);  return CONFIG_T_NEWLINE;
-	case '=':   config_tokenizer_advance (self);  return CONFIG_T_EQUALS;
-	case '{':   config_tokenizer_advance (self);  return CONFIG_T_LBRACE;
-	case '}':   config_tokenizer_advance (self);  return CONFIG_T_RBRACE;
-
-	case '#':
-		// Comments go until newline
-		while (self->len)
-			if (config_tokenizer_advance (self) == '\n')
-				return CONFIG_T_NEWLINE;
-		return CONFIG_T_ABORT;
-
-	case '"':
-		config_tokenizer_advance (self);
-		str_reset (&self->string);
-		if (!config_tokenizer_string (self, &self->string, e))
-			return CONFIG_T_ABORT;
-		if (!utf8_validate (self->string.str, self->string.len))
-		{
-			config_tokenizer_error (self, e, "not a valid UTF-8 string");
-			return CONFIG_T_ABORT;
-		}
-		return CONFIG_T_STRING;
-	}
-
-	char *end;
-	errno = 0;
-	self->integer = strtoll (self->p, &end, 10);
-	if (errno == ERANGE)
-	{
-		config_tokenizer_error (self, e, "integer out of range");
-		return CONFIG_T_ABORT;
-	}
-	if (end != self->p)
-	{
-		self->len -= end - self->p;
-		self->p = end;
-		return CONFIG_T_INTEGER;
-	}
-
-	if (!config_tokenizer_is_word_char (*self->p))
-	{
-		config_tokenizer_error (self, e, "invalid input");
-		return CONFIG_T_ABORT;
-	}
-
-	str_reset (&self->string);
-	do
-		str_append_c (&self->string, config_tokenizer_advance (self));
-	while (config_tokenizer_is_word_char (*self->p));
-
-	if (!strcmp (self->string.str, "null"))
-		return CONFIG_T_NULL;
-
-	bool boolean;
-	if (!set_boolean_if_valid (&boolean, self->string.str))
-		return CONFIG_T_WORD;
-
-	self->integer = boolean;
-	return CONFIG_T_BOOLEAN;
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-struct config_parser
-{
-	struct config_tokenizer tokenizer;  ///< Tokenizer
-
-	struct error *error;                ///< Tokenizer error
-	enum config_token token;            ///< Current token in the tokenizer
-	bool replace_token;                 ///< Replace the token
-};
-
-static void
-config_parser_init (struct config_parser *self, const char *script, size_t len)
-{
-	memset (self, 0, sizeof *self);
-	config_tokenizer_init (&self->tokenizer, script, len);
-
-	// As reading in tokens may cause exceptions, we wait for the first peek()
-	// to replace the initial CONFIG_T_ABORT.
-	self->replace_token = true;
-}
-
-static void
-config_parser_free (struct config_parser *self)
-{
-	config_tokenizer_free (&self->tokenizer);
-	if (self->error)
-		error_free (self->error);
-}
-
-static enum config_token
-config_parser_peek (struct config_parser *self, jmp_buf out)
-{
-	if (self->replace_token)
-	{
-		self->token = config_tokenizer_next (&self->tokenizer, &self->error);
-		if (self->error)
-			longjmp (out, 1);
-		self->replace_token = false;
-	}
-	return self->token;
-}
-
-static bool
-config_parser_accept
-	(struct config_parser *self, enum config_token token, jmp_buf out)
-{
-	return self->replace_token = (config_parser_peek (self, out) == token);
-}
-
-static void
-config_parser_expect
-	(struct config_parser *self, enum config_token token, jmp_buf out)
-{
-	if (config_parser_accept (self, token, out))
-		return;
-
-	config_tokenizer_error (&self->tokenizer, &self->error,
-		"unexpected `%s', expected `%s'",
-		config_token_name (self->token),
-		config_token_name (token));
-	longjmp (out, 1);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-// We don't need no generator, but a few macros will come in handy.
-// From time to time C just doesn't have the right features.
-
-#define PEEK()         config_parser_peek   (self, err)
-#define ACCEPT(token)  config_parser_accept (self, token, err)
-#define EXPECT(token)  config_parser_expect (self, token, err)
-#define SKIP_NL()      do {} while (ACCEPT (CONFIG_T_NEWLINE))
-
-static struct config_item *config_parser_parse_object
-	(struct config_parser *self, jmp_buf out);
-
-static struct config_item *
-config_parser_parse_value (struct config_parser *self, jmp_buf out)
-{
-	struct config_item *volatile result = NULL;
-	jmp_buf err;
-
-	if (setjmp (err))
-	{
-		if (result)
-			config_item_destroy (result);
-		longjmp (out, 1);
-	}
-
-	if (ACCEPT (CONFIG_T_LBRACE))
-	{
-		result = config_parser_parse_object (self, out);
-		SKIP_NL ();
-		EXPECT (CONFIG_T_RBRACE);
-		return result;
-	}
-	if (ACCEPT (CONFIG_T_NULL))
-		return config_item_null ();
-	if (ACCEPT (CONFIG_T_BOOLEAN))
-		return config_item_boolean (self->tokenizer.integer);
-	if (ACCEPT (CONFIG_T_INTEGER))
-		return config_item_integer (self->tokenizer.integer);
-	if (ACCEPT (CONFIG_T_STRING))
-		return config_item_string (&self->tokenizer.string);
-
-	config_tokenizer_error (&self->tokenizer, &self->error,
-		"unexpected `%s', expected a value",
-		config_token_name (self->token));
-	longjmp (out, 1);
-}
-
-/// Parse a single "key = value" assignment into @a object
-static bool
-config_parser_parse_kv_pair (struct config_parser *self,
-	struct config_item *object, jmp_buf out)
-{
-	char *volatile key = NULL;
-	jmp_buf err;
-
-	if (setjmp (err))
-	{
-		free (key);
-		longjmp (out, 1);
-	}
-
-	SKIP_NL ();
-
-	// Either this object's closing right brace if called recursively,
-	// or end of file when called on a whole configuration file
-	if (PEEK () == CONFIG_T_RBRACE
-	 || PEEK () == CONFIG_T_ABORT)
-		return false;
-
-	EXPECT (CONFIG_T_WORD);
-	key = xstrdup (self->tokenizer.string.str);
-	SKIP_NL ();
-
-	EXPECT (CONFIG_T_EQUALS);
-	SKIP_NL ();
-
-	str_map_set (&object->value.object, key,
-		config_parser_parse_value (self, err));
-
-	free (key);
-	key = NULL;
-
-	if (PEEK () == CONFIG_T_RBRACE
-	 || PEEK () == CONFIG_T_ABORT)
-		return false;
-
-	EXPECT (CONFIG_T_NEWLINE);
-	return true;
-}
-
-/// Parse the inside of an object definition
-static struct config_item *
-config_parser_parse_object (struct config_parser *self, jmp_buf out)
-{
-	struct config_item *volatile object = config_item_object ();
-	jmp_buf err;
-
-	if (setjmp (err))
-	{
-		config_item_destroy (object);
-		longjmp (out, 1);
-	}
-
-	while (config_parser_parse_kv_pair (self, object, err))
-		;
-	return object;
-}
-
-#undef PEEK
-#undef ACCEPT
-#undef EXPECT
-#undef SKIP_NL
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-/// Parse a configuration snippet either as an object or a bare value.
-/// If it's the latter (@a single_value_only), no newlines may follow.
-static struct config_item *
-config_item_parse (const char *script, size_t len,
-	bool single_value_only, struct error **e)
-{
-	struct config_parser parser;
-	config_parser_init (&parser, script, len);
-
-	struct config_item *volatile object = NULL;
-	jmp_buf err;
-
-	if (setjmp (err))
-	{
-		if (object)
-		{
-			config_item_destroy (object);
-			object = NULL;
-		}
-
-		error_propagate (e, parser.error);
-		parser.error = NULL;
-		goto end;
-	}
-
-	if (single_value_only)
-	{
-		// This is really only intended for in-program configuration
-		// and telling the line number would look awkward
-		parser.tokenizer.report_line = false;
-		object = config_parser_parse_value (&parser, err);
-	}
-	else
-		object = config_parser_parse_object (&parser, err);
-	config_parser_expect (&parser, CONFIG_T_ABORT, err);
-end:
-	config_parser_free (&parser);
-	return object;
-}
-
-/// Clone an item.  Schema assignments aren't retained.
-struct config_item *
-config_item_clone (struct config_item *self)
-{
-	// Oh well, it saves code
-	struct str tmp;
-	str_init (&tmp);
-	config_item_write (self, false, &tmp);
-	struct config_item *result =
-		config_item_parse (tmp.str, tmp.len, true, NULL);
-	str_free (&tmp);
-	return result;
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static struct config_item *
-config_schema_initialize_item (struct config_schema *schema,
-	struct config_item *parent, struct error **warning, struct error **e)
-{
-	hard_assert (parent->type == CONFIG_ITEM_OBJECT);
-	struct config_item *item =
-		str_map_find (&parent->value.object, schema->name);
-
-	struct error *error = NULL;
-	if (item && config_item_validate_by_schema (item, schema, &error))
-		goto keep_current;
-
-	if (error)
-	{
-		error_set (warning, "resetting configuration item "
-			"`%s' to default: %s", schema->name, error->message);
-		error_free (error);
-		error = NULL;
-	}
-
-	if (schema->default_)
-		item = config_item_parse
-			(schema->default_, strlen (schema->default_), true, &error);
-	else
-		item = config_item_null ();
-
-	if (error || !config_item_validate_by_schema (item, schema, &error))
-	{
-		error_set (e, "invalid default for configuration item `%s': %s",
-			schema->name, error->message);
-		error_free (error);
-
-		config_item_destroy (item);
-		return NULL;
-	}
-
-	// This will free the old item if there was any
-	str_map_set (&parent->value.object, schema->name, item);
-
-keep_current:
-	// Make sure the string subtype fits the schema
-	if (config_item_type_is_string (item->type)
-	 && config_item_type_is_string (schema->type))
-		item->type = schema->type;
-
-	item->schema = schema;
-	return item;
-}
-
-/// Assign schemas and user_data to multiple items at once;
-/// feel free to copy over and modify to suit your particular needs
-static void
-config_schema_apply_to_object (struct config_schema *schema_array,
-	struct config_item *object, void *user_data)
-{
-	while (schema_array->name)
-	{
-		struct error *warning = NULL, *e = NULL;
-		struct config_item *item = config_schema_initialize_item
-			(schema_array++, object, &warning, &e);
-
-		if (warning)
-		{
-			print_warning ("%s", warning->message);
-			error_free (warning);
-		}
-		if (e)
-			print_fatal ("%s", e->message);
-
-		item->user_data = user_data;
-	}
-}
-
-static void
-config_schema_call_changed (struct config_item *item)
-{
-	if (item->type == CONFIG_ITEM_OBJECT)
-	{
-		struct str_map_iter iter;
-		str_map_iter_init (&iter, &item->value.object);
-
-		struct config_item *child;
-		while ((child = str_map_iter_next (&iter)))
-			config_schema_call_changed (child);
-	}
-	else if (item->schema && item->schema->on_change)
-		item->schema->on_change (item);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-// XXX: the callbacks may be overdesigned and of little to no practical use
-
-typedef void (*config_module_load_fn)
-	(struct config_item *subtree, void *user_data);
-
-struct config_module
-{
-	char *name;                         ///< Name of the subtree
-	config_module_load_fn loader;       ///< Module config subtree loader
-	void *user_data;                    ///< User data
-};
-
-static void
-config_module_destroy (struct config_module *self)
-{
-	free (self->name);
-	free (self);
-}
-
-struct config
-{
-	struct str_map modules;             ///< Toplevel modules
-	struct config_item *root;           ///< CONFIG_ITEM_OBJECT
-};
-
-static void
-config_init (struct config *self)
-{
-	memset (self, 0, sizeof *self);
-	str_map_init (&self->modules);
-	self->modules.free = (str_map_free_fn) config_module_destroy;
-}
-
-static void
-config_free (struct config *self)
-{
-	str_map_free (&self->modules);
-	if (self->root)
-		config_item_destroy (self->root);
-}
-
-static void
-config_register_module (struct config *self,
-	const char *name, config_module_load_fn loader, void *user_data)
-{
-	struct config_module *module = xcalloc (1, sizeof *module);
-	module->name = xstrdup (name);
-	module->loader = loader;
-	module->user_data = user_data;
-
-	str_map_set (&self->modules, name, module);
-}
-
-static void
-config_load (struct config *self, struct config_item *root)
-{
-	hard_assert (root->type == CONFIG_ITEM_OBJECT);
-	if (self->root)
-		config_item_destroy (self->root);
-	self->root = root;
-
-	struct str_map_iter iter;
-	str_map_iter_init (&iter, &self->modules);
-
-	struct config_module *module;
-	while ((module = str_map_iter_next (&iter)))
-	{
-		struct config_item *subtree = str_map_find
-			(&root->value.object, module->name);
-		// Silently fix inputs that only a lunatic user could create
-		if (!subtree || subtree->type != CONFIG_ITEM_OBJECT)
-		{
-			subtree = config_item_object ();
-			str_map_set (&root->value.object, module->name, subtree);
-		}
-		if (module->loader)
-			module->loader (subtree, module->user_data);
-	}
-}