Import configuration module from uirc3

It seems to be mature enough, and it's just a bit too useful.

1 files changed, 1118 insertions, 0 deletions

diff --git a/liberty.c b/liberty.c
index 1b136ed..ba5a64d 100644
--- a/liberty.c
+++ b/liberty.c
@@ -29,9 +29,11 @@
 #include <stdarg.h>
 #include <stdint.h>
 #include <stdbool.h>
+#include <inttypes.h>
 #include <ctype.h>
 #include <time.h>
 #include <limits.h>
+#include <setjmp.h>
 
 #include <unistd.h>
 #include <sys/wait.h>
@@ -2452,6 +2454,18 @@ base64_encode (const void *data, size_t len, struct str *output)
 // --- Utilities ---------------------------------------------------------------
 
 static void
+cstr_split (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 void
 cstr_split_ignore_empty (const char *s, char delimiter, struct str_vector *out)
 {
 	const char *begin = s, *end;
@@ -3714,6 +3728,1110 @@ connector_add_target (struct connector *self,
 
 #endif // LIBERTY_WANT_POLLER
 
+// --- Advanced configuration --------------------------------------------------
+
+// This is a more powerful configuration format, adding key-value maps and
+// simplifying item validation and dynamic handling of changes.  All strings
+// must be encoded in UTF-8.
+
+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);
+	cstr_split (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);
+	}
+}
+
 // --- Protocol modules --------------------------------------------------------
 
 #include "liberty-proto.c"