ltk

config.c (41413B)

---

 /*
  * Copyright (c) 2022-2024 lumidify <nobody@lumidify.org>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
 /* FIXME: This really is horrible. */
 
 #include <ctype.h>
 #include <string.h>
 #include <limits.h>
 
 #include "util.h"
 #include "memory.h"
 #include "config.h"
 #include "sort_search.h"
 #include "widget_internal.h"
 
 GEN_SORT_SEARCH_HELPERS(keybinding, ltk_keybinding_cb, text)
 GEN_SORT_SEARCH_HELPERS(theme, ltk_theme_parseinfo, key)
 LTK_ARRAY_INIT_IMPL(keypress, ltk_keypress_cfg)
 LTK_ARRAY_INIT_IMPL(keyrelease, ltk_keyrelease_cfg)
 
 static ltk_general_config general_config;
 static ltk_language_mapping *mappings = NULL;
 static size_t mappings_alloc = 0, mappings_len = 0;
 
 static ltk_array(cmd) *ltk_parse_cmd(const char *cmdtext, size_t len);
 
 static ltk_theme_parseinfo general_parseinfo[] = {
 	{"line-editor", THEME_CMD, {.cmd = &general_config.line_editor}, {.cmd = NULL}, 0, 0, 0},
 	{"option-chooser", THEME_CMD, {.cmd = &general_config.option_chooser}, {.cmd = NULL}, 0, 0, 0},
 	{"dpi-scale", THEME_DOUBLE, {.d = &general_config.dpi_scale}, {.d = 1.0}, 10, 10000, 0},
 	{"explicit-focus", THEME_BOOL, {.b = &general_config.explicit_focus}, {.b = 0}, 0, 0, 0},
 	{"all-activatable", THEME_BOOL, {.b = &general_config.all_activatable}, {.b = 0}, 0, 0, 0},
 	{"fixed-dpi", THEME_DOUBLE, {.d = &general_config.fixed_dpi}, {.d = 96.0}, 100, 400000, 0},
 	/* FIXME: warning if set to true but xrandr not enabled */
 #if USE_XRANDR
 	{"mixed-dpi", THEME_BOOL, {.b = &general_config.mixed_dpi}, {.b = 1}, 0, 0, 0},
 #else
 	{"mixed-dpi", THEME_BOOL, {.b = &general_config.mixed_dpi}, {.b = 0}, 0, 0, 0},
 #endif
 };
 
 /* just to use the same interface for all theme sections */
 static void
 ltk_general_get_theme_parseinfo(ltk_theme_parseinfo **parseinfo, size_t *len) {
 	*parseinfo = general_parseinfo;
 	*len = LENGTH(general_parseinfo);
 }
 
 static struct {
 	const char *name;
 	void (*get_parseinfo)(
 		ltk_keybinding_cb **press_cbs_ret, size_t *press_len_ret,
 		ltk_keybinding_cb **release_cbs_ret, size_t *release_len_ret,
 		ltk_array(keypress) **presses_ret, ltk_array(keyrelease) **releases_ret
 	);
 } keybinding_handlers[] = {
 	{"combobox", &ltk_combobox_get_keybinding_parseinfo},
 	{"entry", &ltk_entry_get_keybinding_parseinfo},
 	{"window", &ltk_window_get_keybinding_parseinfo},
 };
 
 static struct theme_handlerinfo {
 	const char *name;
 	void (*get_parseinfo)(ltk_theme_parseinfo **parseinfo, size_t *len);
 	const char *parent;
 	int finished;
 } theme_handlers[] = {
 	{"general", &ltk_general_get_theme_parseinfo, NULL, 0},
 	{"theme:window", &ltk_window_get_theme_parseinfo, NULL, 0},
 	{"theme:button", &ltk_button_get_theme_parseinfo, "theme:window", 0},
 	{"theme:entry", &ltk_entry_get_theme_parseinfo, "theme:window", 0},
 	{"theme:label", &ltk_label_get_theme_parseinfo, "theme:window", 0},
 	{"theme:scrollbar", &ltk_scrollbar_get_theme_parseinfo, "theme:window", 0},
 	{"theme:menu", &ltk_menu_get_theme_parseinfo, "theme:window", 0},
 	{"theme:menuentry", &ltk_menuentry_get_theme_parseinfo, "theme:window", 0},
 	{"theme:submenu", &ltk_submenu_get_theme_parseinfo, "theme:window", 0},
 	{"theme:submenuentry", &ltk_submenuentry_get_theme_parseinfo, "theme:window", 0},
 	{"theme:checkbutton", &ltk_checkbutton_get_theme_parseinfo, "theme:window", 0},
 	{"theme:radiobutton", &ltk_radiobutton_get_theme_parseinfo, "theme:window", 0},
 	{"theme:combobox", &ltk_combobox_get_theme_parseinfo, "theme:window", 0},
 };
 
 GEN_SORT_SEARCH_HELPERS(themehandler, struct theme_handlerinfo, name)
 
 static void
 sort_themehandlers(void) {
 	ltk_theme_parseinfo *parseinfo;
 	size_t len;
 	themehandler_sort(theme_handlers, LENGTH(theme_handlers));
 	for (size_t i = 0; i < LENGTH(theme_handlers); i++) {
 		theme_handlers[i].get_parseinfo(&parseinfo, &len);
 		theme_sort(parseinfo, len);
 	}
 }
 
 LTK_ARRAY_INIT_FUNC_DECL_STATIC(cmdpiece, struct ltk_cmd_piece)
 LTK_ARRAY_INIT_IMPL_STATIC(cmdpiece, struct ltk_cmd_piece)
 LTK_ARRAY_INIT_FUNC_DECL_STATIC(cmd, ltk_array(cmdpiece) *)
 LTK_ARRAY_INIT_IMPL_STATIC(cmd, ltk_array(cmdpiece) *)
 
 static void
 cmd_piece_free_helper(struct ltk_cmd_piece p) {
 	if (p.text)
 		ltk_free(p.text);
 }
 
 static void
 cmd_free_helper(ltk_array(cmdpiece) *arr) {
 	ltk_array_destroy_deep(cmdpiece, arr, &cmd_piece_free_helper);
 }
 
 static ltk_array(cmd) *
 copy_cmd(ltk_array(cmd) *cmd) {
 	ltk_array(cmd) *cmdcopy = ltk_array_create(cmd, ltk_array_len(cmd));
 	for (size_t i = 0; i < ltk_array_len(cmd); i++) {
 		ltk_array(cmdpiece) *piece = ltk_array_get(cmd, i);
 		ltk_array(cmdpiece) *piececopy = ltk_array_create(cmdpiece, ltk_array_len(piece));
 		for (size_t j = 0; j < ltk_array_len(piece); j++) {
 			struct ltk_cmd_piece p = {NULL, ltk_array_get(piece, j).type};
 			if (ltk_array_get(piece, j).text)
 				p.text = ltk_strdup(ltk_array_get(piece, j).text);
 			ltk_array_append(cmdpiece, piececopy, p);
 		}
 		ltk_array_append(cmd, cmdcopy, piececopy);
 	}
 	return cmdcopy;
 }
 
 /* FIXME: handle '#' or no '#' in color specification */
 static int
 handle_theme_setting(ltk_renderdata *renderdata, ltk_theme_parseinfo *entry, const char *value) {
 	const char *errstr = NULL;
 	char *endptr = NULL;
 	/* FIXME: better warnings */
 	long long ll;
 	switch (entry->type) {
 	case THEME_INT:
 		if (entry->max > INT_MAX)
 			entry->max = INT_MAX;
 		if (entry->min < INT_MIN)
 			entry->min = INT_MIN;
 		*(entry->ptr.i) = ltk_strtonum(value, entry->min, entry->max, &errstr);
 		if (errstr)
 			return 1;
 		entry->initialized = 1;
 		break;
 	case THEME_DOUBLE:
 		/* FIXME: maybe overflow prevention here as well */
 		ll = ltk_strtoscalednum(value, entry->min, entry->max, &endptr, &errstr);
 		if (errstr || *endptr != '\0')
 			return 1;
 		*(entry->ptr.d) = ll / 100.0;
 		entry->initialized = 1;
 		break;
 	case THEME_UINT:
 		if (entry->max > INT_MAX)
 			entry->max = INT_MAX;
 		if (entry->min < 0)
 			entry->min = 0;
 		*(entry->ptr.u) = ltk_strtonum(value, entry->min, entry->max, &errstr);
 		if (errstr)
 			return 1;
 		entry->initialized = 1;
 		break;
 	case THEME_SIZE:
 		if (entry->max > INT_MAX)
 			entry->max = INT_MAX;
 		if (entry->min < INT_MIN)
 			entry->min = INT_MIN;
 		entry->ptr.size->unit = LTK_UNIT_PX;
 		entry->ptr.size->val = ltk_strtoscalednum(value, entry->min, entry->max, &endptr, &errstr);
 		if (errstr)
 			return 1;
 		if (*endptr == '\0') {
 			/* NOP */
 		} else if (!strcmp(endptr, "px")) {
 			entry->ptr.size->unit = LTK_UNIT_PX;
 		} else if (!strcmp(endptr, "pt")) {
 			entry->ptr.size->unit = LTK_UNIT_PT;
 		} else if (!strcmp(endptr, "mm")) {
 			entry->ptr.size->unit = LTK_UNIT_MM;
 		} else {
 			return 1;
 		}
 		entry->initialized = 1;
 		break;
 	case THEME_STRING:
 		*(entry->ptr.str) = ltk_strdup(value);
 		entry->initialized = 1;
 		break;
 	case THEME_COLOR:
 		/* FIXME: warning message possibly misleading because this can fail for reasons
 		   other than an invalid color specification */
 		if (!(*(entry->ptr.color) = ltk_color_create(renderdata, value)))
 			return 1;
 		entry->initialized = 1;
 		break;
 	case THEME_CMD:
 		if (!(*(entry->ptr.cmd) = ltk_parse_cmd(value, strlen(value))))
 			return 1;
 		entry->initialized = 1;
 		break;
 	case THEME_BOOL:
 		if (strcmp(value, "true") == 0) {
 			*(entry->ptr.b) = 1;
 		} else if (strcmp(value, "false") == 0) {
 			*(entry->ptr.b) = 0;
 		} else {
 			return 1;
 		}
 		entry->initialized = 1;
 		break;
 	case THEME_BORDERSIDES:
 		*(entry->ptr.border) = LTK_BORDER_NONE;
 		for (const char *c = value; *c != '\0'; c++) {
 			switch (*c) {
 			case 't':
 				*(entry->ptr.border) |= LTK_BORDER_TOP;
 				break;
 			case 'b':
 				*(entry->ptr.border) |= LTK_BORDER_BOTTOM;
 				break;
 			case 'l':
 				*(entry->ptr.border) |= LTK_BORDER_LEFT;
 				break;
 			case 'r':
 				*(entry->ptr.border) |= LTK_BORDER_RIGHT;
 				break;
 			default:
 				return 1;
 			}
 		}
 		entry->initialized = 1;
 		break;
 	default:
 		ltk_fatal("Invalid theme setting type. This should not happen.\n");
 	}
 	return 0;
 }
 
 static int
 fill_single_theme_defaults(ltk_renderdata *renderdata, struct theme_handlerinfo *handler) {
 	ltk_theme_parseinfo *parseinfo;
 	size_t len;
 	if (handler->finished)
 		return 0;
 	handler->get_parseinfo(&parseinfo, &len);
 	ltk_theme_parseinfo *parent_parseinfo = NULL;
 	size_t parent_len = 0;
 	if (handler->parent) {
 		struct theme_handlerinfo *parent_handler = themehandler_get_entry(
 			theme_handlers, LENGTH(theme_handlers), handler->parent, strlen(handler->parent)
 		);
 		/* Yes, this will cause an infinite loop if there's a cycle in the parent
 		   relationship. However, there is absolutely no reason to construct such a cycle. */
 		/* FIXME: warning if not found */
 		if (parent_handler) {
 			if (fill_single_theme_defaults(renderdata, parent_handler))
 				return 1;
 			parent_handler->get_parseinfo(&parent_parseinfo, &parent_len);
 		}
 	}
 	for (size_t i = 0; i < len; i++) {
 		ltk_theme_parseinfo *e = &parseinfo[i];
 		if (e->initialized)
 			continue;
 		ltk_theme_parseinfo *ep = parent_parseinfo ?
 			theme_get_entry(parent_parseinfo, parent_len, e->key, strlen(e->key)) : NULL;
 		switch (e->type) {
 		case THEME_INT:
 			*(e->ptr.i) = ep ? *(ep->ptr.i) : e->defaultval.i;
 			e->initialized = 1;
 			break;
 		case THEME_UINT:
 			*(e->ptr.u) = ep ? *(ep->ptr.u) : e->defaultval.u;
 			e->initialized = 1;
 			break;
 		case THEME_DOUBLE:
 			*(e->ptr.d) = ep ? *(ep->ptr.d) : e->defaultval.d;
 			e->initialized = 1;
 			break;
 		case THEME_SIZE:
 			*(e->ptr.size) = ep ? *(ep->ptr.size) : e->defaultval.size;
 			e->initialized = 1;
 			break;
 		case THEME_STRING:
 			if (ep)
 				*(e->ptr.str) = *(ep->ptr.str) ? ltk_strdup(*(ep->ptr.str)) : NULL;
 			else if (e->defaultval.str)
 				*(e->ptr.str) = ltk_strdup(e->defaultval.str);
 			else
 				*(e->ptr.str) = NULL;
 			e->initialized = 1;
 			break;
 		case THEME_COLOR:
 			if (ep) {
 				if (!(*(e->ptr.color) = ltk_color_copy(renderdata, *(ep->ptr.color))))
 					return 1;
 			} else if (!e->defaultval.color) {
 				return 1; /* colors must always be initialized */
 			} else if (!(*(e->ptr.color) = ltk_color_create(renderdata, e->defaultval.color))) {
 				return 1;
 			}
 			e->initialized = 1;
 			break;
 		case THEME_CMD:
 			if (ep) {
 				/* There is no reason to ever use this, but whatever */
 				if (!(*(e->ptr.cmd) = copy_cmd(*(ep->ptr.cmd))))
 					return 1;
 			} else if (!e->defaultval.cmd) {
 				*(e->ptr.cmd) = NULL;
 			} else if (!(*(e->ptr.cmd) = ltk_parse_cmd(e->defaultval.cmd, strlen(e->defaultval.cmd)))) {
 				return 1;
 			}
 			e->initialized = 1;
 			break;
 		case THEME_BOOL:
 			*(e->ptr.b) = ep ? *(ep->ptr.b) : e->defaultval.b;
 			e->initialized = 1;
 			break;
 		case THEME_BORDERSIDES:
 			*(e->ptr.border) = ep ? *(ep->ptr.border) : e->defaultval.border;
 			e->initialized = 1;
 			break;
 		default:
 			ltk_fatal("Invalid theme setting type. This should not happen.\n");
 		}
 	}
 	handler->finished = 1;
 	return 0;
 }
 
 static int
 fill_theme_defaults(ltk_renderdata *renderdata) {
 	for (size_t j = 0; j < LENGTH(theme_handlers); j++) {
 		if (fill_single_theme_defaults(renderdata, &theme_handlers[j]))
 			return 1;
 	}
 	return 0;
 }
 
 static void
 uninitialize_theme(ltk_renderdata *renderdata) {
 	ltk_theme_parseinfo *parseinfo;
 	size_t len;
 	for (size_t j = 0; j < LENGTH(theme_handlers); j++) {
 		theme_handlers[j].get_parseinfo(&parseinfo, &len);
 		theme_handlers[j].finished = 0;
 		for (size_t i = 0; i < len; i++) {
 			ltk_theme_parseinfo *e = &parseinfo[i];
 			if (!e->initialized)
 				continue;
 			switch (e->type) {
 			case THEME_STRING:
 				ltk_free(*(e->ptr.str));
 				e->initialized = 0;
 				break;
 			case THEME_COLOR:
 				ltk_color_destroy(renderdata, *(e->ptr.color));
 				e->initialized = 0;
 				break;
 			case THEME_CMD:
 				ltk_array_destroy_deep(cmd, *(e->ptr.cmd), &cmd_free_helper);
 				e->initialized = 0;
 				break;
 			case THEME_SIZE:
 			case THEME_INT:
 			case THEME_UINT:
 			case THEME_BOOL:
 			case THEME_BORDERSIDES:
 			case THEME_DOUBLE:
 				e->initialized = 0;
 				break;
 			default:
 				ltk_fatal("Invalid theme setting type. This should not happen.\n");
 			}
 		}
 	}
 }
 
 static int
 register_keypress(ltk_array(keypress) *bindings, ltk_keybinding_cb *arr, size_t arrlen, const char *func_name, size_t func_len, ltk_keypress_binding b) {
 	ltk_keybinding_cb *cb = keybinding_get_entry(arr, arrlen, func_name, func_len);
 	if (!cb)
 		return 1;
 	ltk_keypress_cfg cfg = {b, *cb};
 	ltk_array_append(keypress, bindings, cfg);
 	return 0;
 }
 
 static int
 register_keyrelease(ltk_array(keyrelease) *bindings, ltk_keybinding_cb *arr, size_t arrlen, const char *func_name, size_t func_len, ltk_keyrelease_binding b) {
 	ltk_keybinding_cb *cb = keybinding_get_entry(arr, arrlen, func_name, func_len);
 	if (!cb)
 		return 1;
 	ltk_keyrelease_cfg cfg = {b, *cb};
 	ltk_array_append(keyrelease, bindings, cfg);
 	return 0;
 }
 
 static int
 handle_keypress_binding(const char *widget_name, size_t wlen, const char *name, size_t nlen, ltk_keypress_binding b) {
 	ltk_keybinding_cb *press_cbs = NULL, *release_cbs = NULL;
 	size_t press_len = 0, release_len = 0;
 	ltk_array(keypress) *presses = NULL;
 	ltk_array(keyrelease) *releases = NULL;
 	for (size_t i = 0; i < LENGTH(keybinding_handlers); i++) {
 		if (str_array_equal(keybinding_handlers[i].name, widget_name, wlen)) {
 			keybinding_handlers[i].get_parseinfo(
 				&press_cbs, &press_len, &release_cbs, &release_len, &presses, &releases
 			);
 			if (!press_cbs || !presses)
 				return 1;
 			return register_keypress(presses, press_cbs, press_len, name, nlen, b);
 		}
 	}
 	return 1;
 }
 
 static int
 handle_keyrelease_binding(const char *widget_name, size_t wlen, const char *name, size_t nlen, ltk_keyrelease_binding b) {
 	ltk_keybinding_cb *press_cbs = NULL, *release_cbs = NULL;
 	size_t press_len = 0, release_len = 0;
 	ltk_array(keypress) *presses = NULL;
 	ltk_array(keyrelease) *releases = NULL;
 	for (size_t i = 0; i < LENGTH(keybinding_handlers); i++) {
 		if (str_array_equal(keybinding_handlers[i].name, widget_name, wlen)) {
 			keybinding_handlers[i].get_parseinfo(
 				&press_cbs, &press_len, &release_cbs, &release_len, &presses, &releases
 			);
 			if (!release_cbs || !releases)
 				return 1;
 			return register_keyrelease(releases, release_cbs, release_len, name, nlen, b);
 		}
 	}
 	return 1;
 }
 
 static void
 sort_keybindings(void) {
 	ltk_keybinding_cb *press_cbs = NULL, *release_cbs = NULL;
 	size_t press_len = 0, release_len = 0;
 	ltk_array(keypress) *presses = NULL;
 	ltk_array(keyrelease) *releases = NULL;
 	for (size_t i = 0; i < LENGTH(keybinding_handlers); i++) {
 		keybinding_handlers[i].get_parseinfo(
 			&press_cbs, &press_len, &release_cbs, &release_len, &presses, &releases
 		);
 		if (press_cbs)
 			keybinding_sort(press_cbs, press_len);
 		if (release_cbs)
 			keybinding_sort(release_cbs, release_len);
 	}
 }
 
 static void
 destroy_keypress_cfg(ltk_keypress_cfg cfg) {
 	ltk_free(cfg.b.text);
 	ltk_free(cfg.b.rawtext);
 }
 
 void
 ltk_keypress_bindings_destroy(ltk_array(keypress) *arr) {
         ltk_array_destroy_deep(keypress, arr, &destroy_keypress_cfg);
 }
 
 void
 ltk_keyrelease_bindings_destroy(ltk_array(keyrelease) *arr) {
         ltk_array_destroy(keyrelease, arr);
 }
 
 static void sort_keysyms(void);
 static int parse_keysym(char *text, size_t len, ltk_keysym *sym_ret);
 
 enum toktype {
 	STRING,
 	SECTION,
 	EQUALS,
 	NEWLINE,
 	ERROR,
 	END
 };
 
 #if 0
 static const char *
 toktype_str(enum toktype type) {
 	switch (type) {
 	case STRING:
 		return "string";
 		break;
 	case SECTION:
 		return "section";
 		break;
 	case EQUALS:
 		return "equals";
 		break;
 	case NEWLINE:
 		return "newline";
 		break;
 	case ERROR:
 		return "error";
 		break;
 	case END:
 		return "end of file";
 		break;
 	default:
 		return "unknown";
 	}
 }
 #endif
 
 struct token {
 	char *text;
 	size_t len;
 	enum toktype type;
 	size_t line;        /* line in original input */
 	size_t line_offset; /* offset from start of line */
 };
 
 struct lexstate {
 	const char *filename;
 	char *text;
 	size_t len;        /* length of text */
 	size_t cur;        /* current byte position */
 	size_t cur_line;   /* current line */
 	size_t line_start; /* byte offset of start of current line */
 };
 
 static struct token
 next_token(struct lexstate *s) {
 	char c;
 	struct token tok;
 	int finished = 0;
 	while (1) {
 		if (s->cur >= s->len)
 			return (struct token){NULL, 0, END, s->cur_line, s->cur - s->line_start + 1};
 		while (isspace(c = s->text[s->cur])) {
 			s->cur++;
 			if (c == '\n') {
 				struct token tok = (struct token){s->text + s->cur - 1, 1, NEWLINE, s->cur_line, s->cur - s->line_start};
 				s->cur_line++;
 				s->line_start = s->cur;
 				return tok;
 			}
 			if (s->cur >= s->len)
 				return (struct token){NULL, 0, END, s->cur_line, s->cur - s->line_start + 1};
 		}
 
 		switch (s->text[s->cur]) {
 		case '#':
 			s->cur++;
 			while (s->cur < s->len && s->text[s->cur] != '\n')
 				s->cur++;
 			continue;
 		case '[':
 			s->cur++;
 			tok = (struct token){s->text + s->cur, 0, SECTION, s->cur_line, s->cur - s->line_start + 1};
 			finished = 0;
 			while (s->cur < s->len) {
 				char c = s->text[s->cur];
 				if (c == '\n') {
 					break;
 				} else if (c == ']') {
 					s->cur++;
 					finished = 1;
 					break;
 				} else  {
 					tok.len++;
 				}
 				s->cur++;
 			}
 			if (!finished) {
 				tok.text = "Unfinished section name";
 				tok.len = strlen("Unfinished section name");
 				tok.type = ERROR;
 			}
 			break;
 		case '=':
 			tok = (struct token){s->text + s->cur, 1, EQUALS, s->cur_line, s->cur - s->line_start + 1};
 			s->cur++;
 			break;
 		case '"':
 			/* FIXME: error if next char is not whitespace or end */
 			s->cur++;
 			tok = (struct token){s->text + s->cur, 0, STRING, s->cur_line, s->cur - s->line_start + 1};
 			size_t shift = 0, bs = 0;
 			finished = 0;
 			while (s->cur < s->len) {
 				char c = s->text[s->cur];
 				if (c == '\n') {
 					break;
 				} else if (c == '\\') {
 					shift += bs;
 					tok.len += bs;
 					bs = (bs + 1) % 2;
 				} else if (c == '"') {
 					if (bs) {
 						shift++;
 						tok.len++;
 						bs = 0;
 					} else {
 						s->cur++;
 						finished = 1;
 						break;
 					}
 				} else {
 					tok.len++;
 				}
 				s->text[s->cur - shift] = s->text[s->cur];
 				s->cur++;
 			}
 			if (!finished) {
 				tok.text = "Unfinished string";
 				tok.len = strlen("Unfinished string");
 				tok.type = ERROR;
 			}
 			break;
 		default:
 			tok = (struct token){s->text + s->cur, 1, STRING, s->cur_line, s->cur - s->line_start + 1};
 			s->cur++;
 			while (s->cur < s->len) {
 				char c = s->text[s->cur];
 				if (isspace(c) || c == '=') {
 					break;
 				} else if (c == '"') {
 					tok.text = "Unexpected start of string";
 					tok.len = strlen("Unexpected start of string");
 					tok.type = ERROR;
 					tok.line_offset = s->cur - s->line_start + 1;
 				} else if (c == '[' || c == ']') {
 					tok.text = "Unexpected start or end of section name";
 					tok.len = strlen("Unexpected start or end of section name");
 					tok.type = ERROR;
 					tok.line_offset = s->cur - s->line_start + 1;
 				}
 				tok.len++;
 				s->cur++;
 			}
 		}
 		return tok;
 	}
 }
 
 #undef MIN
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 
 static int
 parse_modmask(char *modmask_str, size_t len, ltk_mod_type *mask_ret) {
 	size_t cur = 0;
 	*mask_ret = 0;
 	while (cur < len) {
 		if (str_array_equal("shift", modmask_str + cur, MIN(5, len - cur))) {
 			cur += 5;
 			*mask_ret |= LTK_MOD_SHIFT;
 		} else if (str_array_equal("ctrl", modmask_str + cur, MIN(4, len - cur))) {
 			cur += 4;
 			*mask_ret |= LTK_MOD_CTRL;
 		} else if (str_array_equal("alt", modmask_str + cur, MIN(3, len - cur))) {
 			cur += 3;
 			*mask_ret |= LTK_MOD_ALT;
 		} else if (str_array_equal("super", modmask_str + cur, MIN(5, len - cur))) {
 			cur += 5;
 			*mask_ret |= LTK_MOD_SUPER;
 		} else if (str_array_equal("any", modmask_str + cur, MIN(3, len - cur))) {
 			cur += 3;
 			*mask_ret = UINT_MAX;
 		} else {
 			return 1;
 		}
 		if (cur < len && modmask_str[cur] != '|')
 			return 1;
 		else
 			cur++;
 	}
 	return 0;
 }
 
 static int
 parse_flags(char *text, size_t len, ltk_key_binding_flags *flags_ret) {
 	if (str_array_equal("run-always", text, len))
 		*flags_ret = LTK_KEY_BINDING_RUN_ALWAYS;
 	else
 		return 1;
 	return 0;
 }
 
 static int
 parse_keypress_binding(
     struct lexstate *s, struct token *tok,
     ltk_keypress_binding *binding_ret,
     char **func_name_ret, size_t *func_len_ret,
     char **errstr) {
 	ltk_keypress_binding b = {NULL, NULL, LTK_KEY_NONE, LTK_MOD_NONE, LTK_KEY_BINDING_NOFLAGS};
 	*tok = next_token(s);
 	char *msg = NULL;
 	if (tok->type != STRING) {
 		msg = "Invalid token type";
 		goto error;
 	}
 	*func_name_ret = tok->text;
 	*func_len_ret = tok->len;
 	struct token prevtok;
 	int text_init = 0, rawtext_init = 0, sym_init = 0, mods_init = 0, flags_init = 0;
 	while (1) {
 		*tok = next_token(s);
 		if (tok->type == NEWLINE || tok->type == END)
 			break;
 		prevtok = *tok;
 		*tok = next_token(s);
 		if (prevtok.type != STRING) {
 			msg = "Invalid token type";
 			*tok = prevtok;
 			goto error;
 		} else if (tok->type != STRING) {
 			msg = "Invalid token type";
 			goto error;
 		} else if (str_array_equal("text", prevtok.text, prevtok.len)) {
 			if (rawtext_init) {
 				msg = "Rawtext already specified";
 				goto error;
 			} else if (sym_init) {
 				msg = "Keysym already specified";
 				goto error;
 			} else if (text_init) {
 				msg = "Duplicate text specification";
 				goto error;
 			}
 			b.text = ltk_strndup(tok->text, tok->len);
 			text_init = 1;
 		} else if (str_array_equal("rawtext", prevtok.text, prevtok.len)) {
 			if (text_init) {
 				msg = "Text already specified";
 				goto error;
 			} else if (sym_init) {
 				msg = "Keysym already specified";
 				goto error;
 			} else if (rawtext_init) {
 				msg = "Duplicate rawtext specification";
 				goto error;
 			}
 			b.rawtext = ltk_strndup(tok->text, tok->len);
 			rawtext_init = 1;
 		} else if (str_array_equal("sym", prevtok.text, prevtok.len)) {
 			if (text_init) {
 				msg = "Text already specified";
 				goto error;
 			} else if (rawtext_init) {
 				msg = "Rawtext already specified";
 				goto error;
 			} else if (sym_init) {
 				msg = "Duplicate keysym specification";
 				goto error;
 			} else if (parse_keysym(tok->text, tok->len, &b.sym)) {
 				msg = "Invalid keysym specification";
 				goto error;
 			}
 			sym_init = 1;
 		} else if (str_array_equal("mods", prevtok.text, prevtok.len)) {
 			if (mods_init) {
 				msg = "Duplicate mods specification";
 				goto error;
 			} else if (parse_modmask(tok->text, tok->len, &b.mods)) {
 				msg = "Invalid mods specification";
 				goto error;
 			}
 			mods_init = 1;
 		} else if (str_array_equal("flags", prevtok.text, prevtok.len)) {
 			if (flags_init) {
 				msg = "Duplicate flags specification";
 				goto error;
 			} else if (parse_flags(tok->text, tok->len, &b.flags)) {
 				msg = "Invalid flags specification";
 				goto error;
 			}
 			flags_init = 1;
 		} else {
 			msg = "Invalid keyword";
 			*tok = prevtok;
 			goto error;
 		}
 	};
 	if (!text_init && !rawtext_init && !sym_init) {
 		msg = "One of text, rawtext, and sym must be initialized";
 		goto error;
 	}
 	*binding_ret = b;
 	return 0;
 error:
 	ltk_free(b.text);
 	ltk_free(b.rawtext);
 	if (msg) {
 		*errstr = ltk_print_fmt(
 		    "%s, line %zu, offset %zu: %s", s->filename, tok->line, tok->line_offset, msg
 		);
 	} else {
 		*errstr = NULL;
 	}
 	return 1;
 }
 
 static int
 parse_keybinding(
     struct lexstate *s,
     struct token *tok,
     char *widget,
     size_t len,
     char **errstr) {
 	char *msg = NULL;
 	*tok = next_token(s);
 	if (tok->type == SECTION || tok->type == END) {
 		return -1;
 	} else if (tok->type == NEWLINE) {
 		return 0; /* empty line */
 	} else if (tok->type != STRING) {
 		msg = "Invalid token type";
 		goto error;
 	} else if (str_array_equal("bind-keypress", tok->text, tok->len)) {
 		ltk_keypress_binding b;
 		char *name;
 		size_t nlen;
 		if (parse_keypress_binding(s, tok, &b, &name, &nlen, errstr))
 			return 1;
 		if (handle_keypress_binding(widget, len, name, nlen, b)) {
 			msg = "Invalid key binding";
 			goto error;
 		}
 	} else if (str_array_equal("bind-keyrelease", tok->text, tok->len)) {
 		ltk_keypress_binding b;
 		char *name;
 		size_t nlen;
 		if (parse_keypress_binding(s, tok, &b, &name, &nlen, errstr))
 			return 1;
 		if (b.text || b.rawtext) {
 			ltk_free(b.text);
 			ltk_free(b.rawtext);
 			msg = "Text and rawtext may only be specified for keypress bindings";
 			goto error;
 		}
 		if (handle_keyrelease_binding(widget, len, name, nlen, (ltk_keyrelease_binding){b.sym, b.mods, b.flags})) {
 			msg = "Invalid key binding";
 			goto error;
 		}
 	} else {
 		msg = "Invalid statement";
 		goto error;
 	}
 	return 0;
 error:
 	if (msg) {
 		*errstr = ltk_print_fmt(
 		    "%s, line %zu, offset %zu: %s", s->filename, tok->line, tok->line_offset, msg
 		);
 	}
 	return 1;
 }
 
 static void
 push_lang_mapping(void) {
 	if (mappings_alloc == mappings_len) {
 		mappings_alloc = ideal_array_size(mappings_alloc, mappings_len + 1);
 		mappings = ltk_reallocarray(mappings, mappings_alloc, sizeof(ltk_language_mapping));
 	}
 	mappings[mappings_len].lang = NULL;
 	mappings[mappings_len].mappings = NULL;
 	mappings[mappings_len].mappings_alloc = 0;
 	mappings[mappings_len].mappings_len = 0;
 	mappings_len++;
 }
 
 static void
 push_text_mapping(char *text1, size_t len1, char *text2, size_t len2) {
 	if (mappings_len == 0)
 		return; /* I guess just fail silently... */
 	ltk_language_mapping *m = &mappings[mappings_len - 1];
 	if (m->mappings_alloc == m->mappings_len) {
 		m->mappings_alloc = ideal_array_size(m->mappings_alloc, m->mappings_len + 1);
 		m->mappings = ltk_reallocarray(m->mappings, m->mappings_alloc, sizeof(ltk_keytext_mapping));
 	}
 	m->mappings[m->mappings_len].from = ltk_strndup(text1, len1);
 	m->mappings[m->mappings_len].to = ltk_strndup(text2, len2);
 	m->mappings_len++;
 }
 
 void
 ltk_config_cleanup(ltk_renderdata *renderdata) {
 	if (mappings) {
 		for (size_t i = 0; i < mappings_len; i++) {
 			ltk_free(mappings[i].lang);
 			for (size_t j = 0; j < mappings[i].mappings_len; j++) {
 				ltk_free(mappings[i].mappings[j].from);
 				ltk_free(mappings[i].mappings[j].to);
 			}
 			ltk_free(mappings[i].mappings);
 		}
 		ltk_free(mappings);
 		mappings = NULL;
 		mappings_len = mappings_alloc = 0;
 	}
 	uninitialize_theme(renderdata);
 }
 
 /* FIXME: error if not initialized */
 ltk_general_config *
 ltk_config_get_general(void) {
 	return &general_config;
 }
 
 int
 ltk_config_get_language_index(char *lang, size_t *idx_ret) {
 	if (!mappings)
 		return 1;
 	for (size_t i = 0; i < mappings_len; i++) {
 		if (!strcmp(lang, mappings[i].lang)) {
 			*idx_ret = i;
 			return 0;
 		}
 	}
 	return 1;
 }
 
 ltk_language_mapping *
 ltk_config_get_language_mapping(size_t idx) {
 	if (idx >= mappings_len)
 		return NULL;
 	return &mappings[idx];
 }
 
 static int
 str_array_prefix(const char *str, const char *ar, size_t len) {
 	size_t slen = strlen(str);
 	if (len < slen)
 		return 0;
 	return !strncmp(str, ar, slen);
 }
 
 /* FIXME: The current model is kind of weird because most parts of the config
    are stored in the other object files. This makes it difficult to support
    reloading of the config since the old config needs to be kept until the
    new config has been successfully loaded, but the parseinfos include direct
    pointers to the config. It might be better to just have one huge config
    struct that includes everything. That would also make it a bit clearer when
    something hasn't been initialized yet. */
 /* WARNING: errstr must be freed! */
 /* FIXME: make ltk_load_file give size_t; handle errors there (copy from ledit) */
 static int
 load_from_text(
     ltk_renderdata *renderdata,
     const char *filename,
     char *file_contents,
     size_t len,
     char **errstr) {
 	sort_keysyms();
 	sort_keybindings();
 	sort_themehandlers();
 
 	struct lexstate s = {filename, file_contents, len, 0, 1, 0};
 	struct token tok = next_token(&s);
 	int start_of_line = 1;
 	char *msg = NULL;
 	struct token secttok;
 	txtbuf *themeval = txtbuf_new();
 	while (tok.type != END) {
 		switch (tok.type) {
 		case SECTION:
 			if (!start_of_line) {
 				msg = "Section can only start at new line";
 				goto error;
 			}
 			secttok = tok;
 			tok = next_token(&s);
 			if (tok.type != NEWLINE && tok.type != END) {
 				msg = "Section must be alone on line";
 				goto error;
 			}
 			if (str_array_prefix("key-binding:", secttok.text, secttok.len)) {
 				int ret = 0;
 				char *widget = secttok.text + strlen("key-binding:");
 				size_t len = secttok.len - strlen("key-binding:");
 				while (1) {
 					if ((ret = parse_keybinding(&s, &tok, widget, len, errstr)) > 0) {
 						goto errornomsg;
 					} else if (ret < 0) {
 						start_of_line = 1;
 						break;
 					}
 				}
 			} else if (str_array_equal("key-mapping", secttok.text, secttok.len)) {
 				int lang_init = 0;
 				push_lang_mapping();
 				struct token prev1tok, prev2tok;
 				while (1) {
 					tok = next_token(&s);
 					if (tok.type == SECTION || tok.type == END)
 						break;
 					else if (tok.type == NEWLINE)
 						continue;
 					prev2tok = tok;
 					tok = next_token(&s);
 					prev1tok = tok;
 					tok = next_token(&s);
 					if (prev2tok.type != STRING) {
 						msg = "Invalid statement in language mapping";
 						goto error;
 					}
 					if (str_array_equal("language", prev2tok.text, prev2tok.len)) {
 						if (prev1tok.type != EQUALS || tok.type != STRING) {
 							msg = "Invalid language assignment";
 							goto error;
 						} else if (lang_init) {
 							msg = "Language already set";
 							goto error;
 						}
 						mappings[mappings_len - 1].lang = ltk_strndup(tok.text, tok.len);
 						lang_init = 1;
 					} else if (str_array_equal("map", prev2tok.text, prev2tok.len)) {
 						if (prev1tok.type != STRING || tok.type != STRING) {
 							msg = "Invalid map statement";
 							goto error;
 						}
 						push_text_mapping(prev1tok.text, prev1tok.len, tok.text, tok.len);
 					} else {
 						msg = "Invalid statement in language mapping";
 						goto error;
 					}
 					tok = next_token(&s);
 					if (tok.type == END) {
 						break;
 					} else if (tok.type != NEWLINE) {
 						msg = "Invalid statement in language mapping";
 						goto error;
 					}
 					start_of_line = 1;
 				}
 				if (!lang_init) {
 					msg = "Language not set for language mapping";
 					goto error;
 				}
 			} else {
 				struct token prev1tok, prev2tok;
 				struct theme_handlerinfo *handler = themehandler_get_entry(
 					theme_handlers, LENGTH(theme_handlers), secttok.text, secttok.len
 				);
 				if (!handler) {
 					msg = "Invalid section";
 					goto error;
 				}
 				ltk_theme_parseinfo *parseinfo;
 				size_t parseinfo_len;
 				handler->get_parseinfo(&parseinfo, &parseinfo_len);
 				while (1) {
 					tok = next_token(&s);
 					if (tok.type == SECTION || tok.type == END)
 						break;
 					else if (tok.type == NEWLINE)
 						continue;
 					prev2tok = tok;
 					tok = next_token(&s);
 					prev1tok = tok;
 					tok = next_token(&s);
 					if (prev2tok.type != STRING || prev1tok.type != EQUALS || tok.type != STRING) {
 						msg = "Syntax error in assignment statement";
 						goto error;
 					}
 					ltk_theme_parseinfo *parse_entry = theme_get_entry(
 						parseinfo, parseinfo_len, prev2tok.text, prev2tok.len
 					);
 					if (!parse_entry) {
 						msg = "Invalid left-hand side in assignment statement";
 						goto error;
 					} else if (parse_entry->initialized) {
 						msg = "Duplicate assignment";
 						goto error;
 					}
 					/* temporarly copy to txtbuf so it is NUL-terminated (the alternative
 					   would be to use replacements for ltk_strtonum, etc. that accept
 					   a length parameter) */
 					txtbuf_set_textn(themeval, tok.text, tok.len);
 					if (handle_theme_setting(renderdata, parse_entry, themeval->text)) {
 						msg = "Invalid right-hand side in assignment";
 						goto error;
 					}
 					tok = next_token(&s);
 					if (tok.type == END) {
 						break;
 					} else if (tok.type != NEWLINE) {
 						msg = "Syntax error in assignment statement";
 						goto error;
 					}
 					start_of_line = 1;
 				}
 			}
 			break;
 		case NEWLINE:
 			start_of_line = 1;
 			break;
 		default:
 			msg = "Invalid token";
 			goto error;
 			break;
 		}
 	}
 	/* FIXME: better error reporting */
 	if (fill_theme_defaults(renderdata)) {
 		*errstr = ltk_strdup("Unable to load theme defaults");
 		goto errornomsg;
 	}
 	txtbuf_destroy(themeval);
 	return 0;
 error:
 	if (msg) {
 		*errstr = ltk_print_fmt(
 		    "%s, line %zu, offset %zu: %s", filename, tok.line, tok.line_offset, msg
 		);
 	}
 errornomsg:
 	ltk_config_cleanup(renderdata);
 	txtbuf_destroy(themeval);
 	return 1;
 }
 
 int
 ltk_config_parsefile(ltk_renderdata *renderdata, const char *filename, char **errstr) {
 	unsigned long len = 0;
 	char *ferrstr = NULL;
 	char *file_contents = ltk_read_file(filename, &len, &ferrstr);
 	if (!file_contents) {
 		*errstr = ltk_print_fmt("Unable to open file \"%s\": %s", filename, ferrstr);
 		return 1;
 	}
 	int ret = load_from_text(renderdata, filename, file_contents, len, errstr);
 	ltk_free(file_contents);
 	return ret;
 }
 
 /* FIXME: update this */
 static const char *default_config = "[general]\n"
 "explicit-focus = true\n"
 "all-activatable = true\n"
 "[key-binding:window]\n"
 "bind-keypress move-next sym tab\n"
 "bind-keypress move-prev sym tab mods shift\n"
 "bind-keypress move-next text n\n"
 "bind-keypress move-prev text p\n"
 "bind-keypress focus-active sym return\n"
 "bind-keypress unfocus-active sym escape\n"
 "bind-keypress set-pressed sym return flags run-always\n"
 "bind-keyrelease unset-pressed sym return flags run-always\n"
 "[key-mapping]\n"
 "language = \"English (US)\"\n";
 
 /* FIXME: improve this configuration */
 int
 ltk_config_load_default(ltk_renderdata *renderdata, char **errstr) {
 	char *config_copied = ltk_strdup(default_config);
 	int ret = load_from_text(renderdata, "<default config>", config_copied, strlen(config_copied), errstr);
 	ltk_free(config_copied);
 	return ret;
 }
 
 /* FIXME: which additional ones are needed here? */
 static struct keysym_mapping {
 	char *name;
 	ltk_keysym keysym;
 } keysym_map[] = {
 	{"backspace", LTK_KEY_BACKSPACE},
 	{"begin", LTK_KEY_BEGIN},
 	{"break", LTK_KEY_BREAK},
 	{"cancel", LTK_KEY_CANCEL},
 	{"clear", LTK_KEY_CLEAR},
 	{"delete", LTK_KEY_DELETE},
 	{"down", LTK_KEY_DOWN},
 	{"end", LTK_KEY_END},
 	{"escape", LTK_KEY_ESCAPE},
 	{"execute", LTK_KEY_EXECUTE},
 
 	{"f1", LTK_KEY_F1},
 	{"f10", LTK_KEY_F10},
 	{"f11", LTK_KEY_F11},
 	{"f12", LTK_KEY_F12},
 	{"f2", LTK_KEY_F2},
 	{"f3", LTK_KEY_F3},
 	{"f4", LTK_KEY_F4},
 	{"f5", LTK_KEY_F5},
 	{"f6", LTK_KEY_F6},
 	{"f7", LTK_KEY_F7},
 	{"f8", LTK_KEY_F8},
 	{"f9", LTK_KEY_F9},
 
 	{"find", LTK_KEY_FIND},
 	{"help", LTK_KEY_HELP},
 	{"home", LTK_KEY_HOME},
 	{"insert", LTK_KEY_INSERT},
 
 	{"kp-0", LTK_KEY_KP_0},
 	{"kp-1", LTK_KEY_KP_1},
 	{"kp-2", LTK_KEY_KP_2},
 	{"kp-3", LTK_KEY_KP_3},
 	{"kp-4", LTK_KEY_KP_4},
 	{"kp-5", LTK_KEY_KP_5},
 	{"kp-6", LTK_KEY_KP_6},
 	{"kp-7", LTK_KEY_KP_7},
 	{"kp-8", LTK_KEY_KP_8},
 	{"kp-9", LTK_KEY_KP_9},
 	{"kp-add", LTK_KEY_KP_ADD},
 	{"kp-begin", LTK_KEY_KP_BEGIN},
 	{"kp-decimal", LTK_KEY_KP_DECIMAL},
 	{"kp-delete", LTK_KEY_KP_DELETE},
 	{"kp-divide", LTK_KEY_KP_DIVIDE},
 	{"kp-down", LTK_KEY_KP_DOWN},
 	{"kp-end", LTK_KEY_KP_END},
 	{"kp-enter", LTK_KEY_KP_ENTER},
 	{"kp-equal", LTK_KEY_KP_EQUAL},
 	{"kp-home", LTK_KEY_KP_HOME},
 	{"kp-insert", LTK_KEY_KP_INSERT},
 	{"kp-left", LTK_KEY_KP_LEFT},
 	{"kp-multiply", LTK_KEY_KP_MULTIPLY},
 	{"kp-next", LTK_KEY_KP_NEXT},
 	{"kp-page-down", LTK_KEY_KP_PAGE_DOWN},
 	{"kp-page-up", LTK_KEY_KP_PAGE_UP},
 	{"kp-prior", LTK_KEY_KP_PRIOR},
 	{"kp-right", LTK_KEY_KP_RIGHT},
 	{"kp-separator", LTK_KEY_KP_SEPARATOR},
 	{"kp-space", LTK_KEY_KP_SPACE},
 	{"kp-subtract", LTK_KEY_KP_SUBTRACT},
 	{"kp-tab", LTK_KEY_KP_TAB},
 	{"kp-up", LTK_KEY_KP_UP},
 
 	{"left", LTK_KEY_LEFT},
 	{"left-tab", LTK_KEY_LEFT_TAB},
 	{"linefeed", LTK_KEY_LINEFEED},
 	{"menu", LTK_KEY_MENU},
 	{"mode-switch", LTK_KEY_MODE_SWITCH},
 	{"next", LTK_KEY_NEXT},
 	{"num-lock", LTK_KEY_NUM_LOCK},
 	{"page-down", LTK_KEY_PAGE_DOWN},
 	{"page-up", LTK_KEY_PAGE_UP},
 	{"pause", LTK_KEY_PAUSE},
 	{"print", LTK_KEY_PRINT},
 	{"prior", LTK_KEY_PRIOR},
 
 	{"redo", LTK_KEY_REDO},
 	{"return", LTK_KEY_RETURN},
 	{"right", LTK_KEY_RIGHT},
 	{"script-switch", LTK_KEY_SCRIPT_SWITCH},
 	{"scroll-lock", LTK_KEY_SCROLL_LOCK},
 	{"select", LTK_KEY_SELECT},
 	{"space", LTK_KEY_SPACE},
 	{"sysreq", LTK_KEY_SYS_REQ},
 	{"tab", LTK_KEY_TAB},
 	{"up", LTK_KEY_UP},
 	{"undo", LTK_KEY_UNDO},
 };
 
 GEN_SORT_SEARCH_HELPERS(keysym, struct keysym_mapping, name)
 
 static void
 sort_keysyms(void) {
 	keysym_sort(keysym_map, LENGTH(keysym_map));
 }
 
 static int
 parse_keysym(char *keysym_str, size_t len, ltk_keysym *sym) {
 	struct keysym_mapping *km = keysym_get_entry(keysym_map, LENGTH(keysym_map), keysym_str, len);
 	if (!km)
 		return 1;
 	*sym = km->keysym;
 	return 0;
 }
 
 /* FIXME: this is really ugly */
 /* FIXME: this handles double-quote, but the config parser already uses that, so
    it's kind of weird because it's parsed twice (also backslashes are parsed twice). */
 static ltk_array(cmd) *
 ltk_parse_cmd(const char *cmdtext, size_t len) {
 	int bs = 0;
 	int in_sqstr = 0;
 	int in_dqstr = 0;
 	int in_ws = 1;
 	int inout_used = 0, input_used = 0, output_used = 0;
 	char c;
 	size_t cur_start = 0;
 	int offset = 0;
 	ltk_array(cmdpiece) *cur_arg = ltk_array_create(cmdpiece, 1);
 	ltk_array(cmd) *cmd = ltk_array_create(cmd, 4);
 	char *cmdcopy = ltk_strndup(cmdtext, len);
 	for (size_t i = 0; i < len; i++) {
 		c = cmdcopy[i];
 		if (c == '\\') {
 			if (bs) {
 				offset++;
 				bs = 0;
 			} else {
 				bs = 1;
 			}
 		} else if (isspace(c)) {
 			if (!in_sqstr && !in_dqstr) {
 				if (bs) {
 					if (in_ws) {
 						in_ws = 0;
 						cur_start = i;
 						offset = 0;
 					} else {
 						offset++;
 					}
 					bs = 0;
 				} else if (!in_ws) {
 					/* FIXME: shouldn't this be < instead of <=? */
 					if (cur_start <= i - offset) {
 						struct ltk_cmd_piece p = {ltk_strndup(cmdcopy + cur_start, i - cur_start - offset), LTK_CMD_TEXT};
 						ltk_array_append(cmdpiece, cur_arg, p);
 					}
 					/* FIXME: cmd is named horribly */
 					ltk_array_append(cmd, cmd, cur_arg);
 					cur_arg = ltk_array_create(cmdpiece, 1);
 					in_ws = 1;
 					offset = 0;
 				}
 			/* FIXME: parsing weird here - bs just ignored */
 			} else if (bs) {
 				bs = 0;
 			}
 		} else if (c == '%') {
 			if (bs) {
 				if (in_ws) {
 					cur_start = i;
 					offset = 0;
 				} else {
 					offset++;
 				}
 				bs = 0;
 			} else if (!in_sqstr && i < len - 1 && (cmdcopy[i + 1] == 'f' || cmdcopy[i + 1] == 'i' || cmdcopy[i + 1] == 'o')) {
 				if (!in_ws && cur_start < i - offset) {
 					struct ltk_cmd_piece p = {ltk_strndup(cmdcopy + cur_start, i - cur_start - offset), LTK_CMD_TEXT};
 					ltk_array_append(cmdpiece, cur_arg, p);
 				}
 				struct ltk_cmd_piece p = {NULL, LTK_CMD_INOUT_FILE};
 				switch (cmdcopy[i + 1]) {
 				case 'f':
 					p.type = LTK_CMD_INOUT_FILE;
 					if (input_used || output_used)
 						goto error;
 					inout_used = 1;
 					break;
 				case 'i':
 					p.type = LTK_CMD_INPUT_FILE;
 					if (inout_used)
 						goto error;
 					input_used = 1;
 					break;
 				case 'o':
 					p.type = LTK_CMD_OUTPUT_FILE;
 					if (inout_used)
 						goto error;
 					output_used = 1;
 					break;
 				default:
 					ltk_fatal("Impossible.");
 				}
 				ltk_array_append(cmdpiece, cur_arg, p);
 				i++;
 				cur_start = i + 1;
 				offset = 0;
 			} else if (in_ws) {
 				cur_start = i;
 				offset = 0;
 			}
 			in_ws = 0;
 		} else if (c == '"') {
 			if (in_sqstr) {
 				bs = 0;
 			} else if (bs) {
 				if (in_ws) {
 					cur_start = i;
 					offset = 0;
 				} else {
 					offset++;
 				}
 				bs = 0;
 			} else if (in_dqstr) {
 				offset++;
 				in_dqstr = 0;
 				continue;
 			} else {
 				in_dqstr = 1;
 				if (in_ws) {
 					cur_start = i + 1;
 					offset = 0;
 				} else {
 					offset++;
 					continue;
 				}
 			}
 			in_ws = 0;
 		} else if (c == '\'') {
 			if (in_dqstr) {
 				bs = 0;
 			} else if (bs) {
 				if (in_ws) {
 					cur_start = i;
 					offset = 0;
 				} else {
 					offset++;
 				}
 				bs = 0;
 			} else if (in_sqstr) {
 				offset++;
 				in_sqstr = 0;
 				continue;
 			} else {
 				in_sqstr = 1;
 				if (in_ws) {
 					cur_start = i + 1;
 					offset = 0;
 				} else {
 					offset++;
 					continue;
 				}
 			}
 			in_ws = 0;
 		} else if (bs) {
 			if (!in_sqstr && !in_dqstr) {
 				if (in_ws) {
 					cur_start = i;
 					offset = 0;
 				} else {
 					offset++;
 				}
 			}
 			bs = 0;
 			in_ws = 0;
 		} else {
 			if (in_ws) {
 				cur_start = i;
 				offset = 0;
 			}
 			in_ws = 0;
 		}
 		cmdcopy[i - offset] = cmdcopy[i];
 	}
 	/* FIXME: proper error messages with errstr */
 	if (in_sqstr || in_dqstr) {
 		/*ltk_warn("Unterminated string in command\n");*/
 		goto error;
 	}
 	if (!in_ws) {
 		if (cur_start <= len - offset) {
 			struct ltk_cmd_piece p = {ltk_strndup(cmdcopy + cur_start, len - cur_start - offset), LTK_CMD_TEXT};
 			ltk_array_append(cmdpiece, cur_arg, p);
 		}
 		ltk_array_append(cmd, cmd, cur_arg);
 		cur_arg = NULL;
 	}
 	if (cmd->len == 0) {
 		/*ltk_warn("Empty command\n");*/
 		goto error;
 	}
 	ltk_free(cmdcopy);
 	return cmd;
 error:
 	ltk_free(cmdcopy);
 	if (cur_arg)
 		ltk_array_destroy_deep(cmdpiece, cur_arg, &cmd_piece_free_helper);
 	ltk_array_destroy_deep(cmd, cmd, &cmd_free_helper);
 	return NULL;
 }