lorid

chordpro.c (195581B)

---

 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <stdarg.h>
 #include <unistd.h>
 #include <string.h>
 #include <strings.h>
 #include <ctype.h>
 #include <errno.h>
 #include <limits.h>
 #include <time.h>
 #include "core.h"
 #include "chordpro.h"
 #include "chord_diagram.h"
 #include "config.h"
 
 static const char *font_styles[] = { "normal", "oblique", "italic" };
 static const char *font_weights[] = { "normal", "bold" };
 static const char *line_styles[] = { "single", "double", "none" };
 static const char *chord_qualifiers[] = { "m", "", "+", "°" };
 static const char *section_types[] = { "", "", "chorus", "verse", "bridge", "tab", "grid", "custom" };
 extern const struct InstrumentInfo instruments[];
 
 static const char *state_enums[] = {
 	"STATE_LYRICS",
 	"STATE_BACKSLASH",
 	"STATE_DIRECTIVE_NAME",
 	"STATE_DIRECTIVE_VALUE",
 	"STATE_CHORD",
 	"STATE_ANNOTATION",
 	"STATE_TAB",
 	"STATE_GRID",
 	"STATE_MARKUP_TAG",
 	"STATE_MARKUP_TAG_START",
 	"STATE_MARKUP_TAG_END",
 	"STATE_MARKUP_ATTR_NAME",
 	"STATE_MARKUP_ATTR_VALUE",
 	"STATE_COMMENT",
 	"STATE_MAYBE_METADATA_SUBSTITUTION",
 	"STATE_METADATA_SUBSTITUTION"
 };
 
 struct StyleProperty default_style_properties[] = {
 	// TODO: footer are missing
 	{ TEXT_TYPE_CHORD, STYLE_PROPERTY_TYPE_FONT, { .font_name = NULL } },
 	{ TEXT_TYPE_CHORD, STYLE_PROPERTY_TYPE_SIZE, { .font_size = EMPTY_DOUBLE } },
 	{ TEXT_TYPE_CHORD, STYLE_PROPERTY_TYPE_COLOR, { .foreground_color = NULL } },
 	{ TEXT_TYPE_CHORUS, STYLE_PROPERTY_TYPE_FONT, { .font_name = NULL } },
 	{ TEXT_TYPE_CHORUS, STYLE_PROPERTY_TYPE_SIZE, { .font_size = EMPTY_DOUBLE } },
 	{ TEXT_TYPE_CHORUS, STYLE_PROPERTY_TYPE_COLOR, { .foreground_color = NULL } },
 	{ TEXT_TYPE_GRID, STYLE_PROPERTY_TYPE_FONT, { .font_name = NULL } },
 	{ TEXT_TYPE_GRID, STYLE_PROPERTY_TYPE_SIZE, { .font_size = EMPTY_DOUBLE } },
 	{ TEXT_TYPE_GRID, STYLE_PROPERTY_TYPE_COLOR, { .foreground_color = NULL } },
 	{ TEXT_TYPE_TAB, STYLE_PROPERTY_TYPE_FONT, { .font_name = NULL } },
 	{ TEXT_TYPE_TAB, STYLE_PROPERTY_TYPE_SIZE, { .font_size = EMPTY_DOUBLE } },
 	{ TEXT_TYPE_TAB, STYLE_PROPERTY_TYPE_COLOR, { .foreground_color = NULL } },
 	{ TEXT_TYPE_TEXT, STYLE_PROPERTY_TYPE_FONT, { .font_name = NULL } },
 	{ TEXT_TYPE_TEXT, STYLE_PROPERTY_TYPE_SIZE, { .font_size = EMPTY_DOUBLE } },
 	{ TEXT_TYPE_TEXT, STYLE_PROPERTY_TYPE_COLOR, { .foreground_color = NULL } },
 	{ TEXT_TYPE_TITLE, STYLE_PROPERTY_TYPE_FONT, { .font_name = NULL } },
 	{ TEXT_TYPE_TITLE, STYLE_PROPERTY_TYPE_SIZE, { .font_size = EMPTY_DOUBLE } },
 	{ TEXT_TYPE_TITLE, STYLE_PROPERTY_TYPE_COLOR, { .foreground_color = NULL } },
 	{ TEXT_TYPE_TOC, STYLE_PROPERTY_TYPE_FONT, { .font_name = NULL } },
 	{ TEXT_TYPE_TOC, STYLE_PROPERTY_TYPE_SIZE, { .font_size = EMPTY_DOUBLE } },
 	{ TEXT_TYPE_TOC, STYLE_PROPERTY_TYPE_COLOR, { .foreground_color = NULL } },
 	{ TEXT_TYPE_LABEL, STYLE_PROPERTY_TYPE_FONT, { .font_name = NULL } },
 	{ TEXT_TYPE_LABEL, STYLE_PROPERTY_TYPE_SIZE, { .font_size = EMPTY_DOUBLE } },
 	{ TEXT_TYPE_LABEL, STYLE_PROPERTY_TYPE_COLOR, { .foreground_color = NULL } },
 };
 
 static const char *chord_extensions_major[] = {
 	"2", "3", "4", "5", "6", "69", "7", "7-5",
 	"7#5", "7#9", "7#9#5", "7#9b5", "7#9#11",
 	"7b5", "7b9", "7b9#5", "7b9#9", "7b9#11", "7b9b13", "7b9b5", "7b9sus", "7b13", "7b13sus",
 	"7-9", "7-9#11", "7-9#5", "7-9#9", "7-9-13", "7-9-5", "7-9sus",
 	"711",
 	"7#11",
 	"7-13", "7-13sus",
 	"7sus", "7susadd3",
 	"7+",
 	"7alt",
 	"9",
 	"9+",
 	"9#5",
 	"9b5",
 	"9-5",
 	"9sus",
 	"9add6",
 	"maj7", "maj711", "maj7#11", "maj13", "maj7#5", "maj7sus2", "maj7sus4",
 	"^7", "^711", "^7#11", "^7#5", "^7sus2", "^7sus4",
 	"maj9", "maj911",
 	"^9", "^911",
 	"^13",
 	"^9#11",
 	"11",
 	"911",
 	"9#11",
 	"13",
 	"13#11",
 	"13#9",
 	"13b9",
 	"alt",
 	"add2", "add4", "add9",
 	"sus2", "sus4", "sus9",
 	"6sus2", "6sus4",
 	"7sus2", "7sus4",
 	"13sus2", "13sus4",
 	NULL
 };
 
 static const char *chord_extensions_minor[] = {
 	// INFO: https://www.chordpro.org/beta/chordpro-chords/#extensions-for-minor-chords
 	"#5",
 	"#5",
 	"m11",
 	"-11",
 	"m6",
 	"-6",
 	"m69",
 	"-69",
 	"m7b5",
 	"-7b5",
 	"m7-5",
 	"-7-5",
 	"mmaj7",
 	"-maj7",
 	"mmaj9",
 	"-maj9",
 	"m9maj7",
 	"-9maj7",
 	"m9^7",
 	"-9^7",
 	"madd9",
 	"-add9",
 	"mb6",
 	"-b6",
 	"m#7",
 	"-#7",
 	"msus4", "msus9",
 	"-sus4", "-sus9",
 	"m7sus4",
 	"-7sus4",
 	// INFO: custom
 	"m7",
 	"m9",
 	"m",
 	NULL
 };
 
 static bool g_show_info_logs = false;
 
 #ifdef ENABLE_DEBUG
 
 static const char *alignment_enums[] = {
 	"ALIGNMENT_LEFT",
 	"ALIGNMENT_CENTER",
 	"ALIGNMENT_RIGHT"
 };
 
 static const char *anchor_enums[] = {
 	"ANCHOR_PAPER",
 	"ANCHOR_PAGE",
 	"ANCHOR_COLUMN",
 	"ANCHOR_LINE",
 	"ANCHOR_FLOAT"
 };
 
 static const char *chord_qualifier_enums[] = {
 	"CHORD_QUALIFIER_MIN",
 	"CHORD_QUALIFIER_MAJ",
 	"CHORD_QUALIFIER_AUG",
 	"CHORD_QUALIFIER_DIM"
 };
 
 static const char *directive_type_enums[] = {
 	"DIRECTIVE_TYPE_ENVIRONMENT",
 	"DIRECTIVE_TYPE_METADATA",
 	"DIRECTIVE_TYPE_FORMATTING",
 	"DIRECTIVE_TYPE_IMAGE",
 	"DIRECTIVE_TYPE_PREAMBLE",
 	"DIRECTIVE_TYPE_FONT",
 	"DIRECTIVE_TYPE_CHORD",
 	"DIRECTIVE_TYPE_OUTPUT",
 	"DIRECTIVE_TYPE_EXTENSION",
 	"DIRECTIVE_TYPE_CUSTOM"
 };
 
 static const char *section_type_enums[] = {
 	"SECTION_TYPE_UNINITIALIZED",
 	"SECTION_TYPE_NEWSONG",
 	"SECTION_TYPE_CHORUS",
 	"SECTION_TYPE_VERSE",
 	"SECTION_TYPE_BRIDGE",
 	"SECTION_TYPE_TAB",
 	"SECTION_TYPE_GRID",
 	"SECTION_TYPE_CUSTOM"
 };
 
 static const char *position_enums[] = {
 	"POSITION_START",
 	"POSITION_END",
 	"POSITION_NO"
 };
 
 static const char *text_type_enums[] = {
 	"TEXT_TYPE_CHORD",
 	"TEXT_TYPE_ANNOT",
 	"TEXT_TYPE_CHORUS",
 	"TEXT_TYPE_FOOTER",
 	"TEXT_TYPE_GRID",
 	"TEXT_TYPE_TAB",
 	"TEXT_TYPE_TOC",
 	"TEXT_TYPE_TOC_TITLE",
 	"TEXT_TYPE_TEXT",
 	"TEXT_TYPE_TITLE",
 	"TEXT_TYPE_SUBTITLE",
 	"TEXT_TYPE_LABEL",
 	"TEXT_TYPE_COMMENT",
 	"TEXT_TYPE_COMMENT_ITALIC",
 	"TEXT_TYPE_COMMENT_BOX"
 };
 
 static const char *style_property_type_enums[] = {
 	"STYLE_PROPERTY_TYPE_FONT",
 	"STYLE_PROPERTY_TYPE_SIZE",
 	"STYLE_PROPERTY_TYPE_COLOR"
 };
 
 void
 cho_debug_chord_print(struct ChoChord *chord)
 {
 	printf("---- BEGIN CHORD ----\n");
 	printf("is_canonical: %d\n", chord->is_canonical);
 	printf("name: '%s'\n", chord->name);
 	if (chord->root) {
 		printf("root: '%s'\n", chord->root);
 	} else {
 		printf("root: 'NULL'\n");
 	}
 	printf("qual: '%s'\n", chord_qualifier_enums[chord->qual]);
 	if (chord->ext) {
 		printf("ext: '%s'\n", chord->ext);
 	} else {
 		printf("ext: 'NULL'\n");
 	}
 	if (chord->bass) {
 		printf("bass: '%s'\n", chord->bass);
 	} else {
 		printf("bass: 'NULL'\n");
 	}
 	printf("---- END CHORD ------\n");
 }
 
 #endif /* ENABLE_DEBUG */
 
 void
 cho_log_enable_info_logs(void)
 {
 	g_show_info_logs = true;
 }
 
 static void
 cho_log(struct ChoContext *ctx, enum LogLevel level, const char *msg, ...)
 {
 	va_list va;
 
 	va_start(va, msg);
 	util_vlog(ctx->chordpro_filepath, ctx->line_no, level, msg, va);
 }
 
 static inline bool
 is_whitespace(char c)
 {
 	if (c == '\t' || c == ' ') {
 		return true;
 	}
 	return false;
 }
 
 struct RGBColor *
 cho_rgbcolor_new(uint8_t red, uint8_t green, uint8_t blue)
 {
 	struct RGBColor *color = emalloc(sizeof(struct RGBColor));
 	color->red = red;
 	color->green = green;
 	color->blue = blue;
 	return color;
 }
 
 static struct RGBColor *
 cho_rgbcolor_copy(struct RGBColor *color)
 {
 	struct RGBColor *copy = emalloc(sizeof(struct RGBColor));
 	copy->red = color->red;
 	copy->green = color->green;
 	copy->blue = color->blue;
 	return copy;
 }
 
 static const char *
 cho_rgbcolor_to_string(struct RGBColor *color)
 {
 	constexpr int str_len = 8;
 	static char str[str_len];
 	snprintf((char *)&str, str_len, "#%02X%02X%02X", color->red, color->green, color->blue);
 	return (const char *)&str;
 }
 
 static struct RGBColor *
 cho_rgbcolor_parse(const char *str)
 {
 	struct RGBColor *color = emalloc(sizeof(struct RGBColor));
 	size_t len = strlen(str);
 	char tmp[3];
 	long primary_color;
 	if (len == 7) {
 		tmp[2] = 0;
 		if (str[1] == '0' && str[2] == '0') {
 			color->red = 0;
 		} else {
 			tmp[0] = str[1];
 			tmp[1] = str[2];
 			primary_color = strtol((char *)&tmp, NULL, 16);
 			if (primary_color == 0) {
 				goto ERR;
 			} else {
 				color->red = primary_color;
 			}
 		}
 		if (str[3] == '0' && str[4] == '0') {
 			color->green = 0;
 		} else {
 			tmp[0] = str[3];
 			tmp[1] = str[4];
 			primary_color = strtol((char *)&tmp, NULL, 16);
 			if (primary_color == 0) {
 				goto ERR;
 			} else {
 				color->green = primary_color;
 			}
 		}
 		if (str[5] == '0' && str[6] == '0') {
 			color->blue = 0;
 		} else {
 			tmp[0] = str[5];
 			tmp[1] = str[6];
 			primary_color = strtol((char *)&tmp, NULL, 16);
 			if (primary_color == 0) {
 				goto ERR;
 			} else {
 				color->blue = primary_color;
 			}
 		}
 	} else if (len == 4) {
 		tmp[2] = 0;
 		if (str[1] == '0') {
 			color->red = 0;
 		} else {
 			tmp[0] = str[1];
 			tmp[1] = str[1];
 			primary_color = strtol((char *)&tmp, NULL, 16);
 			if (primary_color == 0) {
 				goto ERR;
 			} else {
 				color->red = primary_color;
 			}
 		}
 		if (str[2] == '0') {
 			color->green = 0;
 		} else {
 			tmp[0] = str[2];
 			tmp[1] = str[2];
 			primary_color = strtol((char *)&tmp, NULL, 16);
 			if (primary_color == 0) {
 				goto ERR;
 			} else {
 				color->green = primary_color;
 			}
 		}
 		if (str[3] == '0') {
 			color->blue = 0;
 		} else {
 			tmp[0] = str[3];
 			tmp[1] = str[3];
 			primary_color = strtol((char *)&tmp, NULL, 16);
 			if (primary_color == 0) {
 				goto ERR;
 			} else {
 				color->blue = primary_color;
 			}
 		}
 	} else {
 		goto ERR;
 	}
 	return color;
 	ERR:
 	free(color);
 	return NULL;
 }
 
 struct RGBColor *
 cho_color_parse(const char *str)
 {
 	struct RGBColor *color;
 
 	if (str[0] == '#') {
 		color = cho_rgbcolor_parse(str);
 		if (!color) {
 			DEBUG("cho_rgbcolor_parse failed.");
 			return NULL;
 		}
 	} else {
 		color = emalloc(sizeof(struct RGBColor));
 		if (!strcmp(str, "red")) {
 			color->red = 255;
 			color->green = 48;
 			color->blue = 48;
 		} else if (!strcmp(str, "green")) {
 			color->red = 0;
 			color->green = 126;
 			color->blue = 0;
 		} else if (!strcmp(str, "blue")) {
 			color->red = 0;
 			color->green = 0;
 			color->blue = 255;
 		} else if (!strcmp(str, "yellow")) {
 			color->red = 255;
 			color->green = 255;
 			color->blue = 0;
 		} else if (!strcmp(str, "magenta")) {
 			color->red = 255;
 			color->green = 48;
 			color->blue = 255;
 		} else if (!strcmp(str, "cyan")) {
 			color->red = 82;
 			color->green = 255;
 			color->blue = 255;
 		} else if (!strcmp(str, "white")) {
 			color->red = 255;
 			color->green = 255;
 			color->blue = 255;
 		} else if (!strcmp(str, "grey")) {
 			color->red = 191;
 			color->green = 191;
 			color->blue = 191;
 		} else if (!strcmp(str, "black")) {
 			color->red = 0;
 			color->green = 0;
 			color->blue = 0;
 		} else {
 			free(color);
 			return NULL;
 		}
 	}
 	return color;
 }
 
 inline struct RGBColor *
 cho_color_copy(struct RGBColor *color)
 {
 	return cho_rgbcolor_copy(color);
 }
 
 static struct Font *
 cho_font_new(void)
 {
 	struct Font *font = emalloc(sizeof(struct Font));
 	font->family = NULL;
 	font->style = FONT_STYLE_ROMAN;
 	font->weight = FONT_WEIGHT_REGULAR;
 	font->size = DEFAULT_FONT_SIZE;
 	return font;
 }
 
 struct Font *
 cho_font_copy(struct Font *font)
 {
 	struct Font *copy = emalloc(sizeof(struct Font));
 	copy->family = font->family ? strdup(font->family) : NULL;
 	copy->style = font->style;
 	copy->weight = font->weight;
 	copy->size = font->size;
 	return copy;
 }
 
 void
 cho_font_free(struct Font *font)
 {
 	if (!font) {
 		return;
 	}
 	free(font->family);
 	free(font);
 }
 
 void
 cho_fonts_free(struct Font **fonts)
 {
 	if (!fonts) {
 		return;
 	}
 	struct Font **f;
 	for (f = fonts; *f; f++) {
 		cho_font_free(*f);
 	}
 	free(fonts);
 }
 
 enum FontStyle
 cho_font_style_parse(const char *str, bool *error)
 {
 	*error = false;
 	if (!strcmp(str, font_styles[FONT_STYLE_ITALIC])) {
 		return FONT_STYLE_ITALIC;
 	} else if (!strcmp(str, font_styles[FONT_STYLE_OBLIQUE])) {
 		return FONT_STYLE_OBLIQUE;
 	} else if (!strcmp(str, font_styles[FONT_STYLE_ROMAN])) {
 		return FONT_STYLE_ROMAN;
 	}
 	*error = true;
 	return FONT_STYLE_ITALIC; // unused
 }
 
 const char *
 cho_font_style_to_config_string(enum FontStyle style)
 {
 	return font_styles[style];
 }
 
 enum FontWeight
 cho_font_weight_parse(const char *str, bool *error)
 {
 	*error = false;
 	if (!strcmp(str, font_weights[FONT_WEIGHT_BOLD])) {
 		return FONT_WEIGHT_BOLD;
 	} else if (!strcmp(str, font_weights[FONT_WEIGHT_REGULAR])) {
 		return FONT_WEIGHT_REGULAR;
 	}
 	*error = true;
 	return FONT_WEIGHT_BOLD; // unused
 }
 
 const char *
 cho_font_weight_to_config_string(enum FontWeight weight)
 {
 	return font_weights[weight];
 }
 
 static void
 cho_font_print_as_toml(struct Font *font, const char *section)
 {
 	printf("[output.styles.%s.font]\n", section);
 	printf("family = \"%s\"\n", font->family);
 	printf("style = \"%s\"\n", cho_font_style_to_config_string(font->style));
 	printf("weight = \"%s\"\n", cho_font_weight_to_config_string(font->weight));
 	printf("size = %.1f\n\n", font->size);
 }
 
 void
 cho_font_print(struct Font *font)
 {
 	printf("---- BEGIN FONT ----\n");
 	if (font->family) {
 		printf("font family: %s\n", font->family);
 	} else {
 		printf("font family: NULL\n");
 	}
 	printf("font style: %s\n", cho_font_style_to_config_string(font->style));
 	printf("font weight: %s\n", cho_font_weight_to_config_string(font->weight));
 	printf("font size: %f\n", font->size);
 	printf("---- END FONT ------\n");
 }
 
 enum LineStyle
 cho_linestyle_parse(const char *str, bool *error)
 {
 	*error = false;
 	if (!strcmp(str, line_styles[LINE_STYLE_SINGLE])) {
 		return LINE_STYLE_SINGLE;
 	} else if (!strcmp(str, line_styles[LINE_STYLE_DOUBLE])) {
 		return LINE_STYLE_DOUBLE;
 	} else if (!strcmp(str, line_styles[LINE_STYLE_NONE])) {
 		return LINE_STYLE_NONE;
 	}
 	*error = true;
 	return LINE_STYLE_SINGLE; // unused
 }
 
 const char *
 cho_linestyle_to_config_string(enum LineStyle linestyle)
 {
 	return line_styles[linestyle];
 }
 
 #ifdef ENABLE_DEBUG
 
 static void
 cho_debug_the_default_style_properties(void)
 {
 	unsigned int i;
 	for (i = 0; i<LENGTH(default_style_properties); i++) {
 		printf(
 			"%s %s ",
 			text_type_enums[default_style_properties[i].ttype],
 			style_property_type_enums[default_style_properties[i].type]
 		);
 		switch (default_style_properties[i].type) {
 		case STYLE_PROPERTY_TYPE_FONT:
 			if (default_style_properties[i].u.font_name)
 				printf("%s\n", default_style_properties[i].u.font_name);
 			else
 				printf("NULL\n");
 			break;
 		case STYLE_PROPERTY_TYPE_SIZE:
 			printf("%.1f\n", default_style_properties[i].u.font_size);
 			break;
 		case STYLE_PROPERTY_TYPE_COLOR:
 			if (default_style_properties[i].u.foreground_color)
 				printf("%s\n", cho_rgbcolor_to_string(default_style_properties[i].u.foreground_color));
 			else
 				printf("NULL\n");
 			break;
 		default:
 			printf("Invalid StylePropertyType value '%d'.\n", default_style_properties[i].type);
 		}
 	}
 }
 
 void
 cho_debug_style_print(struct ChoStyle *style)
 {
 	printf("---- BEGIN STYLE ----\n");
 	cho_font_print(style->font);
 	printf("foreground_color: %s\n", cho_rgbcolor_to_string(style->foreground_color));
 	printf("background_color: %s\n", cho_rgbcolor_to_string(style->background_color));
 	printf("underline_style: %s\n", cho_linestyle_to_config_string(style->underline_style));
 	printf("underline_color: %s\n", cho_rgbcolor_to_string(style->underline_color));
 	printf("overline_style: %s\n", cho_linestyle_to_config_string(style->overline_style));
 	printf("overline_color: %s\n", cho_rgbcolor_to_string(style->overline_color));
 	printf("strikethrough: %d\n", style->strikethrough);
 	printf("strikethrough_color: %s\n", cho_rgbcolor_to_string(style->strikethrough_color));
 	printf("boxed: %d\n", style->boxed);
 	printf("boxed_color: %s\n", cho_rgbcolor_to_string(style->boxed_color));
 	printf("rise: %f\n", style->rise);
 	if (style->href)
 		printf("href: %s\n", style->href);
 	else
 		printf("href: NULL\n");
 	printf("---- END STYLE ------\n\n");
 }
 
 #endif /* ENABLE_DEBUG */
 
 static bool
 cho_style_property_apply_default(
 	enum TextType current_ttype,
 	enum StylePropertyType ptype,
 	struct ChoStyle *style
 )
 {
 	unsigned int i;
 	for (i = 0; i<LENGTH(default_style_properties); i++) {
 		if (
 			default_style_properties[i].ttype == current_ttype &&
 			default_style_properties[i].type == ptype
 		) {
 			switch (ptype) {
 			case STYLE_PROPERTY_TYPE_FONT:
 				if (default_style_properties[i].u.font_name) {
 					free(style->font->family);
 					style->font->family = strdup(default_style_properties[i].u.font_name);
 					return true;
 				} else {
 					return false;
 				}
 				break;
 			case STYLE_PROPERTY_TYPE_SIZE:
 				if (default_style_properties[i].u.font_size != EMPTY_DOUBLE) {
 					style->font->size = default_style_properties[i].u.font_size;
 					return true;
 				} else {
 					return false;
 				}
 				break;
 			case STYLE_PROPERTY_TYPE_COLOR:
 				if (default_style_properties[i].u.foreground_color) {
 					free(style->foreground_color);
 					style->foreground_color = cho_rgbcolor_copy(default_style_properties[i].u.foreground_color);
 					return true;
 				} else {
 					return false;
 				}
 				break;
 			}
 		}
 	}
 	return false;
 }
 
 static void
 cho_style_apply_default(enum TextType current_ttype, struct ChoStyle *style)
 {
 	if (current_ttype == TEXT_TYPE_CHORUS) {
 		if (!cho_style_property_apply_default(TEXT_TYPE_CHORUS, STYLE_PROPERTY_TYPE_FONT, style)) {
 			cho_style_property_apply_default(TEXT_TYPE_TEXT, STYLE_PROPERTY_TYPE_FONT, style);
 		}
 		if (!cho_style_property_apply_default(TEXT_TYPE_CHORUS, STYLE_PROPERTY_TYPE_SIZE, style)) {
 			cho_style_property_apply_default(TEXT_TYPE_TEXT, STYLE_PROPERTY_TYPE_SIZE, style);
 		}
 		if (!cho_style_property_apply_default(TEXT_TYPE_CHORUS, STYLE_PROPERTY_TYPE_COLOR, style)) {
 			cho_style_property_apply_default(TEXT_TYPE_TEXT, STYLE_PROPERTY_TYPE_COLOR, style);
 		}
 	} else {
 		cho_style_property_apply_default(current_ttype, STYLE_PROPERTY_TYPE_FONT, style);
 		cho_style_property_apply_default(current_ttype, STYLE_PROPERTY_TYPE_SIZE, style);
 		cho_style_property_apply_default(current_ttype, STYLE_PROPERTY_TYPE_COLOR, style);
 	}
 }
 
 struct ChoStyle *
 cho_style_new(void)
 {
 	struct ChoStyle *style = emalloc(sizeof(struct ChoStyle));
 	style->font = cho_font_new();
 	style->foreground_color = cho_rgbcolor_new(20, 20, 20);
 	style->background_color = cho_rgbcolor_new(255, 255, 255);
 	style->underline_style = LINE_STYLE_NONE;
 	style->underline_color = cho_rgbcolor_new(20, 20, 20);
 	style->overline_style = LINE_STYLE_NONE;
 	style->overline_color = cho_rgbcolor_new(20, 20, 20);
 	style->strikethrough = false;
 	style->strikethrough_color = cho_rgbcolor_new(20, 20, 20);
 	style->boxed = false;
 	style->boxed_color = cho_rgbcolor_new(20, 20, 20);
 	style->rise = 0.0;
 	style->href = NULL;
 	return style;
 }
 
 struct ChoStyle *
 cho_style_copy(struct ChoStyle *style)
 {
 	struct ChoStyle *copy = emalloc(sizeof(struct ChoStyle));
 	copy->font = cho_font_copy(style->font);
 	copy->foreground_color = cho_rgbcolor_copy(style->foreground_color);
 	copy->background_color = cho_rgbcolor_copy(style->background_color);
 	copy->underline_style = style->underline_style;
 	copy->underline_color = cho_rgbcolor_copy(style->underline_color);
 	copy->overline_style = style->overline_style;
 	copy->overline_color = cho_rgbcolor_copy(style->overline_color);
 	copy->strikethrough = style->strikethrough;
 	copy->strikethrough_color = cho_rgbcolor_copy(style->strikethrough_color);
 	copy->boxed = style->boxed;
 	copy->boxed_color = cho_rgbcolor_copy(style->boxed_color);
 	copy->rise = style->rise;
 	copy->href = style->href ? strdup(style->href) : NULL;
 	return copy;
 }
 
 static void
 cho_style_complement(
 	struct ChoStyle *old,
 	struct ChoStyle *new,
 	struct ChoStylePresence *presence
 )
 {
 	if (presence->font.family) {
 		free(old->font->family);
 		old->font->family = strdup(new->font->family);
 	}
 	if (presence->font.style) {
 		old->font->style = new->font->style;
 	}
 	if (presence->font.weight) {
 		old->font->weight = new->font->weight;
 	}
 	if (presence->font.size) {
 		old->font->size = new->font->size;
 	}
 	if (presence->foreground_color) {
 		free(old->foreground_color);
 		old->foreground_color = cho_rgbcolor_copy(new->foreground_color);
 	}
 	if (presence->background_color) {
 		free(old->background_color);
 		old->background_color = cho_rgbcolor_copy(new->background_color);
 	}
 	if (presence->underline_style) {
 		old->underline_style = new->underline_style;
 	}
 	if (presence->underline_color) {
 		free(old->underline_color);
 		old->underline_color = cho_rgbcolor_copy(new->underline_color);
 	}
 	if (presence->overline_style) {
 		old->overline_style = new->overline_style;
 	}
 	if (presence->overline_color) {
 		free(old->overline_color);
 		old->overline_color = cho_rgbcolor_copy(new->overline_color);
 	}
 	if (presence->strikethrough) {
 		old->strikethrough = new->strikethrough;
 	}
 	if (presence->strikethrough_color) {
 		free(old->strikethrough_color);
 		old->strikethrough_color = cho_rgbcolor_copy(new->strikethrough_color);
 	}
 	if (presence->boxed) {
 		old->boxed = new->boxed;
 	}
 	if (presence->boxed_color) {
 		free(old->boxed_color);
 		old->boxed_color = cho_rgbcolor_copy(new->boxed_color);
 	}
 	if (presence->rise) {
 		old->rise = new->rise;
 	}
 	if (presence->href) {
 		free(old->href);
 		old->href = strdup(new->href);
 	}
 }
 
 static struct ChoStyle *
 cho_style_new_from_config(struct ChoContext *ctx, enum TextType ttype)
 {
 	return cho_style_copy(ctx->config->output->styles[ttype]);
 }
 
 static struct ChoStyle *
 cho_style_new_default(struct ChoContext *ctx)
 {
 	struct ChoStyle *style = cho_style_new_from_config(ctx, ctx->current_ttype);
 	if (!style) {
 		DEBUG("cho_style_new_from_config failed.");
 		return NULL;
 	}
 	cho_style_apply_default(ctx->current_ttype, style);
 	return style;
 }
 
 void
 cho_style_free(struct ChoStyle *style)
 {
 	if (!style) {
 		return;
 	}
 	cho_font_free(style->font);
 	free(style->foreground_color);
 	free(style->background_color);
 	free(style->underline_color);
 	free(style->overline_color);
 	free(style->strikethrough_color);
 	free(style->boxed_color);
 	free(style->href);
 	free(style);
 }
 
 static struct Font *
 cho_style_font_desc_parse(const char *font_desc, struct ChoStylePresence *presence)
 {
 	size_t len;
 	int w, n;
 	int name_until = EMPTY_INT;
 	char *c, *word;
 	char **words = NULL;
 	double size = -1.0;
 	struct Font *font;
 
 	len = strlen(font_desc);
 	if (len == 0) {
 		return NULL;
 	}
 	char str[len+1];
 	strcpy((char *)&str, font_desc);
 	for (c = (char *)&str, w = 0; (word = strtok(c, " ")); w++) {
 		words = erealloc(words, (w+1) * sizeof(char *));
 		words[w] = word;
 		c = NULL;
 	}
 	words = erealloc(words, (w+1) * sizeof(char *));
 	words[w] = NULL;
 	font = cho_font_new();
 	for (w = 0; words[w]; w++) {
 		if (!strcasecmp(words[w], "italic")) {
 			font->style = FONT_STYLE_ITALIC;
 			presence->font.style = true;
 			if (name_until == EMPTY_INT) {
 				name_until = w;
 			}
 		} else if (!strcasecmp(words[w], "bold")) {
 			font->weight = FONT_WEIGHT_BOLD;
 			presence->font.weight = true;
 			if (name_until == EMPTY_INT) {
 				name_until = w;
 			}
 		} else if (!strcasecmp(words[w], "oblique")) {
 			font->style = FONT_STYLE_OBLIQUE;
 			presence->font.style = true;
 			if (name_until == EMPTY_INT) {
 				name_until = w;
 			}
 		/*
 		 * TODO: Is it smart to treat 'regular' as a font weight
 		 * and 'normal' as a font style. The words are very similar.
 		 * But what is the alternative?
 		 * */
 		} else if (!strcasecmp(words[w], "regular")) {
 			font->weight = FONT_WEIGHT_REGULAR;
 			presence->font.weight = true;
 			if (name_until == EMPTY_INT) {
 				name_until = w;
 			}
 		} else if (!strcasecmp(words[w], "normal")) {
 			font->style = FONT_STYLE_ROMAN;
 			presence->font.style = true;
 			if (name_until == EMPTY_INT) {
 				name_until = w;
 			}
 		/*
 		 * TODO: The following code is commented because it is unclear whether the
 		 * words 'sans' and 'serif' are part of the font name or not. It is clear that
 		 * e.g. given the word 'sans' the user wants a font with a family of sans and
 		 * not e.g. monospace but when searching for the font with fontconfig an exact
 		 * font name has to be provided. Maybe I should try all possible font names
 		 * and return the first successful finding.
 		*/
 		/* } else if (strcasecmp(words[w], "sans") == 0) {
 			font->family = FONT_FAMILY_SANS;
 			if (name_until == EMPTY_INT)
 				name_until = w;
 		} else if (strcasecmp(words[w], "serif") == 0) {
 			font->family = FONT_FAMILY_SERIF;
 			if (name_until == EMPTY_INT)
 				name_until = w;
 		} else if (!strcasecmp(words[w], "monospace")) {
 			font->family = FONT_FAMILY_MONOSPACE;
 			presence->font.family = true;
 			if (name_until == EMPTY_INT) {
 				name_until = w;
 			} */
 		} else {
 			size = strtod(words[w], NULL);
 			if (size == 0.0) {
 				continue;
 			}
 			font->size = size;
 			presence->font.size = true;
 			if (name_until == EMPTY_INT) {
 				name_until = w;
 			}
 		}
 	}
 	if (name_until == EMPTY_INT) {
 		name_until = w;
 	}
 	if (name_until > 0) {
 		for (w = 0, n = 0; w<name_until; w++) {
 			len = strlen(words[w]);
 			font->family = erealloc(font->family, (n+len+1) * sizeof(char));
 			memcpy(&font->family[n], words[w], len);
 			n += len;
 			font->family[n] = ' ';
 			n++;
 		}
 		n--;
 		font->family[n] = '\0';
 		presence->font.family = true;
 	}
 	free(words);
 	return font;
 }
 
 static struct ChoStyle *
 cho_style_parse(
 	struct ChoContext *ctx,
 	const char *tag_name,
 	struct Attr **attrs,
 	struct ChoStyle *inherited_style,
 	struct ChoStylePresence *presence
 )
 {
 	size_t value_len, last_char;
 	struct RGBColor *rgb_color;
 	struct ChoStyle *style;
 	struct Font *font;
 	struct Attr **a;
 
 	if (inherited_style) {
 		style = cho_style_copy(inherited_style);
 	} else {
 		style = cho_style_new_default(ctx);
 	}
 	if (!strcmp(tag_name, "span")) {
 		if (attrs) {
 			for (a = attrs; *a; a++) {
 				if (!strcmp((*a)->name, "font_desc")) {
 					font = cho_style_font_desc_parse((*a)->value, presence);
 					if (font) {
 						if (!font->family) {
 							font->family = strdup(style->font->family);
 						}
 						cho_font_free(style->font);
 						style->font = font;
 					}
 				} else if (
 					!strcmp((*a)->name, "font_family") ||
 					!strcmp((*a)->name, "face")
 				) {
 					free(style->font->family);
 					style->font->family = strdup((*a)->value);
 				} else if (!strcmp((*a)->name, "size")) {
 					value_len = strlen((*a)->value);
 					last_char = value_len - 1;
 					if ((*a)->value[last_char] == '%') {
 						if (value_len < 5) {
 							(*a)->value[last_char] = 0;
 							int percentage = atoi((*a)->value);
 							if (percentage != 0 && percentage <= 100) {
 								style->font->size *= percentage / 100.0;
 								presence->font.size = true;
 							} else {
 								cho_log(ctx, LOG_ERR, "Attribute 'size' of markup tag '%s' has an invalid percentage '%d'.", tag_name, percentage);
 								goto ERR;
 							}
 						} else {
 							cho_log(ctx, LOG_ERR, "Attribute 'size' of markup tag '%s' has an invalid percentage '%s'.", tag_name, (*a)->value);
 							goto ERR;
 						}
 					} else if (isdigit((*a)->value[0]) != 0) {
 						double size = strtod((*a)->value, NULL);
 						if (size != 0.0) {
 							style->font->size = size;
 							presence->font.size = true;
 						} else {
 							cho_log(ctx, LOG_ERR, "Attribute 'size' of markup tag '%s' has an invalid number '%.1f'.", tag_name, size);
 							goto ERR;
 						}
 					} else if (!strcmp((*a)->value, "xx-small")) {
 						style->font->size *= 0.8;
 						style->font->size *= 0.8;
 						style->font->size *= 0.8;
 						presence->font.size = true;
 					} else if (!strcmp((*a)->value, "x-small")) {
 						style->font->size *= 0.8;
 						style->font->size *= 0.8;
 						presence->font.size = true;
 					} else if (!strcmp((*a)->value, "small")) {
 						style->font->size *= 0.8;
 						presence->font.size = true;
 					// } else if (!strcmp((*a)->value, "medium")) {
 					} else if (!strcmp((*a)->value, "large")) {
 						style->font->size *= 1.8;
 						presence->font.size = true;
 					} else if (!strcmp((*a)->value, "x-large")) {
 						style->font->size *= 1.8;
 						style->font->size *= 1.8;
 						presence->font.size = true;
 					} else if (!strcmp((*a)->value, "xx-large")) {
 						style->font->size *= 1.8;
 						style->font->size *= 1.8;
 						style->font->size *= 1.8;
 						presence->font.size = true;
 					} else if (!strcmp((*a)->value, "larger")) {
 						style->font->size *= 1.8;
 						presence->font.size = true;
 					} else if (!strcmp((*a)->value, "smaller")) {
 						style->font->size *= 0.8;
 						presence->font.size = true;
 					} else {
 						cho_log(ctx, LOG_ERR, "Attribute 'size' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					}
 				} else if (!strcmp((*a)->name, "style")) {
 					if (!strcmp((*a)->value, "normal")) {
 						style->font->style = FONT_STYLE_ROMAN;
 						presence->font.style = true;
 					} else if (!strcmp((*a)->value, "oblique")) {
 						style->font->style = FONT_STYLE_OBLIQUE;
 						presence->font.style = true;
 					} else if (!strcmp((*a)->value, "italic")) {
 						style->font->style = FONT_STYLE_ITALIC;
 						presence->font.style = true;
 					} else {
 						cho_log(ctx, LOG_ERR, "Attribute 'style' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					}
 				} else if (!strcmp((*a)->name, "weight")) {
 					if (!strcmp((*a)->value, "normal")) {
 						style->font->weight = FONT_WEIGHT_REGULAR;
 						presence->font.weight = true;
 					} else if (!strcmp((*a)->value, "bold")) {
 						style->font->weight = FONT_WEIGHT_BOLD;
 						presence->font.weight = true;
 					} else {
 						cho_log(ctx, LOG_ERR, "Attribute 'weight' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					}
 				} else if (!strcmp((*a)->name, "foreground")) {
 					rgb_color = cho_color_parse((*a)->value);
 					if (!rgb_color) {
 						DEBUG("cho_color_parse failed.");
 						cho_log(ctx, LOG_ERR, "Attribute 'foreground' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					} else {
 						free(style->foreground_color);
 						style->foreground_color = rgb_color;
 						presence->foreground_color = true;
 					}
 				} else if (!strcmp((*a)->name, "background")) {
 					rgb_color = cho_color_parse((*a)->value);
 					if (!rgb_color) {
 						DEBUG("cho_color_parse failed.");
 						cho_log(ctx, LOG_ERR, "Attribute 'background' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					} else {
 						free(style->background_color);
 						style->background_color = rgb_color;
 						presence->background_color = true;
 					}
 				} else if (!strcmp((*a)->name, "underline")) {
 					if (!strcmp((*a)->value, "single")) {
 						style->underline_style = LINE_STYLE_SINGLE;
 						presence->underline_style = true;
 					} else if (!strcmp((*a)->value, "double")) {
 						style->underline_style = LINE_STYLE_DOUBLE;
 						presence->underline_style = true;
 					} else if (!strcmp((*a)->value, "none")) {
 						style->underline_style = LINE_STYLE_NONE;
 						presence->underline_style = true;
 					} else {
 						cho_log(ctx, LOG_ERR, "Attribute 'underline' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					}
 				} else if (!strcmp((*a)->name, "underline_colour")) {
 					rgb_color = cho_color_parse((*a)->value);
 					if (!rgb_color) {
 						DEBUG("cho_color_parse failed.");
 						cho_log(ctx, LOG_ERR, "Attribute 'underline_colour' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					} else {
 						free(style->underline_color);
 						style->underline_color = rgb_color;
 						presence->underline_color = true;
 					}
 				} else if (!strcmp((*a)->name, "overline")) {
 					if (!strcmp((*a)->value, "single")) {
 						style->overline_style = LINE_STYLE_SINGLE;
 						presence->overline_style = true;
 					} else if (!strcmp((*a)->value, "double")) {
 						style->overline_style = LINE_STYLE_DOUBLE;
 						presence->overline_style = true;
 					} else if (!strcmp((*a)->value, "none")) {
 						style->overline_style = LINE_STYLE_NONE;
 						presence->overline_style = true;
 					} else {
 						cho_log(ctx, LOG_ERR, "Attribute 'overline' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					}
 				} else if (!strcmp((*a)->name, "overline_colour")) {
 					rgb_color = cho_color_parse((*a)->value);
 					if (!rgb_color) {
 						DEBUG("cho_color_parse failed.");
 						cho_log(ctx, LOG_ERR, "Attribute 'overline_colour' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					} else {
 						free(style->overline_color);
 						style->overline_color = rgb_color;
 						presence->overline_color = true;
 					}
 				} else if (!strcmp((*a)->name, "rise")) {
 					value_len = strlen((*a)->value);
 					last_char = value_len - 1;
 					if ((*a)->value[0] == '-') {
 						if ((*a)->value[last_char] == '%') {
 							if (value_len < 6) {
 								(*a)->value[last_char] = 0;
 								int percentage = atoi(&(*a)->value[1]);
 								if (percentage != 0 && percentage <= 100) {
 									style->rise = (style->font->size / 2) * percentage / 100.0;
 									presence->rise = true;
 								} else {
 									cho_log(ctx, LOG_ERR, "Attribute 'rise' of markup tag '%s' has an invalid percentage '%d'.", tag_name, percentage);
 									goto ERR;
 								}
 							}
 						} else if (isdigit((*a)->value[1]) != 0) {
 							double rise = strtod((*a)->value, NULL);
 							if (rise != 0.0) {
 								style->rise = rise;
 								presence->rise = true;
 							} else {
 								cho_log(ctx, LOG_ERR, "Attribute 'rise' of markup tag '%s' has an invalid number '%d'.", tag_name, rise);
 								goto ERR;
 							}
 						} else {
 							cho_log(ctx, LOG_ERR, "Attribute 'rise' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 							goto ERR;
 						}
 					} else {
 						if ((*a)->value[last_char] == '%') {
 							if (value_len < 5) {
 								(*a)->value[last_char] = 0;
 								int percentage = atoi((*a)->value);
 								if (percentage != 0 && percentage <= 100) {
 									// TODO: Test if that's right
 									double more = style->font->size / 2.0 * percentage / 100.0;
 									style->rise += more;
 									presence->rise = true;
 								} else {
 									cho_log(ctx, LOG_ERR, "Attribute 'rise' of markup tag '%s' has an invalid percentage '%d'.", tag_name, percentage);
 									goto ERR;
 								}
 							}
 						} else if (isdigit((*a)->value[0]) != 0) {
 							double rise = strtod((*a)->value, NULL);
 							if (rise != 0.0) {
 								style->rise = rise;
 								presence->rise = true;
 							} else {
 								cho_log(ctx, LOG_ERR, "Attribute 'rise' of markup tag '%s' has an invalid number '%d'.", tag_name, rise);
 								goto ERR;
 							}
 						} else {
 							cho_log(ctx, LOG_ERR, "Attribute 'rise' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 							goto ERR;
 						}
 					}
 				} else if (!strcmp((*a)->name, "strikethrough")) {
 					if (!strcmp((*a)->value, "true")) {
 						style->strikethrough = true;
 						presence->strikethrough = true;
 					} else if (!strcmp((*a)->value, "false")) {
 						style->strikethrough = false;
 						presence->strikethrough = true;
 					} else {
 						cho_log(ctx, LOG_ERR, "Attribute 'strikethrough' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					}
 				} else if (!strcmp((*a)->name, "strikethrough_colour")) {
 					rgb_color = cho_color_parse((*a)->value);
 					if (!rgb_color) {
 						DEBUG("cho_color_parse failed.");
 						cho_log(ctx, LOG_ERR, "Attribute 'strikethrough_colour' of markup tag '%s' has an invalid value '%s'.", tag_name, (*a)->value);
 						goto ERR;
 					} else {
 						free(style->strikethrough_color);
 						style->strikethrough_color = rgb_color;
 						presence->strikethrough_color = true;
 					}
 				} else if (!strcmp((*a)->name, "href")) {
 					style->href = strdup((*a)->value);
 					presence->href = true;
 				} else {
 					cho_log(ctx, LOG_ERR, "Attribute '%s' of markup tag '%s' is invalid.", (*a)->name, tag_name);
 					goto ERR;
 				}
 			}
 		} else {
 			cho_log(ctx, LOG_INFO, "'span' markup tag has no attributes and therefore no effect.");
 		}
 	} else if (!strcmp(tag_name, "b")) {
 		style->font->weight = FONT_WEIGHT_BOLD;
 		presence->font.weight = true;
 	} else if (!strcmp(tag_name, "big")) {
 		style->font->size *= 0.8;
 		presence->font.size = true;
 	} else if (!strcmp(tag_name, "i")) {
 		style->font->style = FONT_STYLE_ITALIC;
 		presence->font.style = true;
 	} else if (!strcmp(tag_name, "s")) {
 		style->strikethrough = true;
 		presence->strikethrough = true;
 	} else if (!strcmp(tag_name, "sub")) {
 		style->font->size *= 0.8;
 		style->rise = -style->font->size * 0.3;
 		presence->font.size = true;
 		presence->rise = true;
 	} else if (!strcmp(tag_name, "sup")) {
 		style->font->size *= 0.8;
 		style->rise = style->font->size * 0.3;
 		presence->font.size = true;
 		presence->rise = true;
 	} else if (!strcmp(tag_name, "small")) {
 		style->font->size *= 0.8;
 		presence->font.size = true;
 	} else if (!strcmp(tag_name, "tt")) {
 		style->font->family = strdup("monospace");
 		presence->font.family = true;
 	} else if (!strcmp(tag_name, "u")) {
 		style->underline_style = LINE_STYLE_SINGLE;
 		presence->underline_style = true;
 	} else {
 		cho_log(ctx, LOG_ERR, "Markup tag '%s' is invalid.", tag_name);
 		goto ERR;
 	}
 	return style;
 	ERR:
 	cho_style_free(style);
 	return NULL;
 }
 
 void
 cho_style_print_as_toml(struct ChoStyle *style, const char *section)
 {
 	printf("foreground_color = \"%s\"\n", cho_rgbcolor_to_string(style->foreground_color));
 	printf("background_color = \"%s\"\n", cho_rgbcolor_to_string(style->background_color));
 	printf("underline_style = \"%s\"\n", cho_linestyle_to_config_string(style->underline_style));
 	printf("underline_color = \"%s\"\n", cho_rgbcolor_to_string(style->underline_color));
 	printf("overline_style = \"%s\"\n", cho_linestyle_to_config_string(style->overline_style));
 	printf("overline_color = \"%s\"\n", cho_rgbcolor_to_string(style->overline_color));
 	printf("strikethrough = %s\n", style->strikethrough ? "true" : "false");
 	printf("strikethrough_color = \"%s\"\n", cho_rgbcolor_to_string(style->strikethrough_color));
 	printf("boxed = %s\n", style->boxed ? "true" : "false");
 	printf("boxed_color = \"%s\"\n", cho_rgbcolor_to_string(style->boxed_color));
 	printf("rise = %.1f\n", style->rise);
 	printf("href = \"%s\"\n\n", style->href ? style->href : "");
 	cho_font_print_as_toml(style->font, section);
 }
 
 static bool
 cho_style_change_default(struct StyleProperty sprop)
 {
 	unsigned int i;
 	for (i = 0; i<LENGTH(default_style_properties); i++) {
 		if (
 			default_style_properties[i].ttype == sprop.ttype &&
 			default_style_properties[i].type == sprop.type
 		) {
 			switch (sprop.type) {
 			case STYLE_PROPERTY_TYPE_FONT:
 				free(default_style_properties[i].u.font_name);
 				if (sprop.u.font_name) {
 					default_style_properties[i].u.font_name = strdup(sprop.u.font_name);
 				} else {
 					default_style_properties[i].u.font_name = NULL;
 				}
 				return true;
 			case STYLE_PROPERTY_TYPE_SIZE:
 				default_style_properties[i].u.font_size = sprop.u.font_size;
 				return true;
 			case STYLE_PROPERTY_TYPE_COLOR:
 				free(default_style_properties[i].u.foreground_color);
 				if (sprop.u.foreground_color) {
 					default_style_properties[i].u.foreground_color = cho_rgbcolor_copy(sprop.u.foreground_color);
 				} else {
 					default_style_properties[i].u.foreground_color = NULL;
 				}
 				return true;
 			}
 		}
 	}
 	return false;
 }
 
 static bool
 cho_style_reset_default(void)
 {
 	unsigned int i;
 	for (i = 0; i<LENGTH(default_style_properties); i++) {
 		switch (default_style_properties[i].type) {
 		case STYLE_PROPERTY_TYPE_FONT:
 			free(default_style_properties[i].u.font_name);
 			default_style_properties[i].u.font_name = NULL;
 			return true;
 		case STYLE_PROPERTY_TYPE_SIZE:
 			default_style_properties[i].u.font_size = EMPTY_DOUBLE;
 			return true;
 		case STYLE_PROPERTY_TYPE_COLOR:
 			free(default_style_properties[i].u.foreground_color);
 			default_style_properties[i].u.foreground_color = NULL;
 			return true;
 		}
 	}
 	return false;
 }
 
 static struct Attr *
 cho_tag_attr_new(void)
 {
 	struct Attr *attr = emalloc(sizeof(struct Attr));
 	attr->name = NULL;
 	attr->value = NULL;
 	return attr;
 }
 
 static void
 cho_tag_attr_free(struct Attr *attr)
 {
 	if (!attr) {
 		return;
 	}
 	free(attr->name);
 	free(attr->value);
 	free(attr);
 }
 
 static void
 cho_tag_attrs_free(struct Attr **attrs)
 {
 	if (!attrs) {
 		return;
 	}
 	struct Attr **a;
 	for (a = attrs; *a; a++) {
 		cho_tag_attr_free(*a);
 	}
 	free(attrs);
 }
 
 static struct Tag *
 cho_tag_new(void)
 {
 	struct Tag *tag = emalloc(sizeof(struct Tag));
 	tag->name = NULL;
 	tag->style = NULL;
 	tag->attrs = NULL;
 	tag->is_closed = false;
 	memset(&tag->style_presence, 0, sizeof(tag->style_presence));
 	return tag;
 }
 
 static void
 cho_tag_free(struct Tag *tag)
 {
 	if (!tag) {
 		return;
 	}
 	free(tag->name);
 	cho_style_free(tag->style);
 	if (tag->attrs) {
 		cho_tag_attrs_free(tag->attrs);
 	}
 	free(tag);
 }
 
 static bool
 cho_tag_close_last_unclosed(struct ChoContext *ctx, const char *tag_name, struct Tag **tags, int last_index)
 {
 	int i;
 	for (i = last_index; i >= 0; i--) {
 		if (!strcmp(tags[i]->name, tag_name) && !tags[i]->is_closed) {
 			tags[i]->is_closed = true;
 			return true;
 		}
 	}
 	cho_log(ctx, LOG_ERR, "Didn't find a start tag for the end tag '%s'.", tag_name);
 	return false;
 }
 
 static struct ChoStyle *
 cho_tag_style_inherit(struct Tag **tags, int prev_index)
 {
 	int i;
 	for (i = prev_index; i >= 0; i--) {
 		if (!tags[i]->is_closed) {
 			return tags[i]->style;
 		}
 	}
 	/*
 		INFO: Doesn't mean there is an error.
 		If no style can be inherited the
 		default style should be used.
 	*/
 	return NULL;
 }
 
 static struct ChoMetadata *
 cho_metadata_new(struct ChoContext *ctx)
 {
 	struct ChoMetadata *meta = emalloc(sizeof(struct ChoMetadata));
 	meta->name = NULL;
 	meta->value = NULL;
 	meta->style = cho_style_new_default(ctx);
 	return meta;
 }
 
 static void
 cho_metadata_free(struct ChoMetadata *meta)
 {
 	if (!meta) {
 		return;
 	}
 	free(meta->name);
 	free(meta->value);
 	cho_style_free(meta->style);
 	free(meta);
 }
 
 bool
 cho_metadata_value(
 	struct ChoMetadata **metadata,
 	const char *name,
 	const char *separator,
 	char **value,
 	struct ChoStyle **value_style
 )
 {
 	*value = NULL;
 	const char *c;
 	struct ChoMetadata **m;
 	int v = 0;
 	for (m = metadata; *m; m++) {
 		if (!strcmp((*m)->name, name)) {
 			if (*value) {
 				for (c = separator; *c; c++, v++) {
 					*value = erealloc(*value, (v+1) * sizeof(char));
 					(*value)[v] = *c;
 				}
 			}
 			for (c = (*m)->value; *c; c++, v++) {
 				*value = erealloc(*value, (v+1) * sizeof(char));
 				(*value)[v] = *c;
 			}
 			*value_style = (*m)->style;
 		}
 	}
 	if (*value) {
 		*value = erealloc(*value, (v+1) * sizeof(char));
 		(*value)[v] = 0;
 		return true;
 	}
 	return false;
 }
 
 static struct ChoMetadata *
 cho_metadata_split(struct ChoContext *ctx, const char *directive_value)
 {
 	struct ChoMetadata *meta = cho_metadata_new(ctx);
 	bool is_name = true;
 	char *value = str_remove_leading_whitespace(directive_value);
 	int n = 0;
 	int v = 0;
 	int i;
 	for (i = 0; value[i]; i++) {
 		if (is_name) {
 			if (value[i] == ' ') {
 				meta->name = erealloc(meta->name, (n+1) * sizeof(char));
 				meta->name[n] = 0;
 				is_name = false;
 			} else {
 				meta->name = erealloc(meta->name, (n+1) * sizeof(char));
 				meta->name[n] = value[i];
 				n++;
 			}
 		} else {
 			meta->value = erealloc(meta->value, (v+1) * sizeof(char));
 			meta->value[v] = value[i];
 			v++;
 		}
 	}
 	meta->value = erealloc(meta->value, (v+1) * sizeof(char));
 	meta->value[v] = 0;
 	free(value);
 	if (v > 1) {
 		return meta;
 	} else {
 		cho_metadata_free(meta);
 		cho_log(ctx, LOG_ERR, "Failed to parse directive 'meta'.");
 		return NULL;
 	}
 }
 
 static struct ChoMetadata **
 cho_metadata_load_default(struct ChoContext *ctx)
 {
 	struct ChoMetadata **meta = NULL;
 	struct InstrumentInfo ins_info;
 	struct tm *tt;
 	time_t t;
 	char *filename, *logged_in_user;
 	char time_str[64];
 	int i = 0;
 
 	logged_in_user = getenv("USER");
 	if (!logged_in_user) {
 		DEBUG("getenv(USER) failed.");
 		return NULL;
 	}
 	t = time(NULL);
 	tt = localtime(&t);
 	if (strftime((char *)&time_str, 64, "%a, %d. %b  %H:%M", tt) == 0) {
 		DEBUG("strftime failed.");
 		return NULL;
 	}
 	ins_info = config_instrument_get(ctx->config->output->diagram->instrument);
 	meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 	meta[i] = emalloc(sizeof(struct ChoMetadata));
 	meta[i]->name = strdup("chordpro");
 	meta[i]->value = strdup("ChordPro");
 	meta[i]->style = cho_style_new_default(ctx);
 	i++;
 	if (ctx->chordpro_filepath) {
 		filename = filepath_basename(ctx->chordpro_filepath);
 		meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 		meta[i] = emalloc(sizeof(struct ChoMetadata));
 		meta[i]->name = strdup("chordpro.songsource");
 		meta[i]->value = filename;
 		meta[i]->style = cho_style_new_default(ctx);
 		i++;
 	}
 	meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 	meta[i] = emalloc(sizeof(struct ChoMetadata));
 	meta[i]->name = strdup("chordpro.version");
 	meta[i]->value = strdup("6");
 	meta[i]->style = cho_style_new_default(ctx);
 	i++;
 	meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 	meta[i] = emalloc(sizeof(struct ChoMetadata));
 	meta[i]->name = strdup("instrument");
 	meta[i]->value = strdup(ins_info.name);
 	meta[i]->style = cho_style_new_default(ctx);
 	i++;
 	meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 	meta[i] = emalloc(sizeof(struct ChoMetadata));
 	meta[i]->name = strdup("instrument.type");
 	meta[i]->value = strdup(ins_info.name);
 	meta[i]->style = cho_style_new_default(ctx);
 	i++;
 	meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 	meta[i] = emalloc(sizeof(struct ChoMetadata));
 	meta[i]->name = strdup("instrument.description");
 	meta[i]->value = strdup(ins_info.description);
 	meta[i]->style = cho_style_new_default(ctx);
 	i++;
 	meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 	meta[i] = emalloc(sizeof(struct ChoMetadata));
 	meta[i]->name = strdup("today");
 	meta[i]->value = strdup(time_str);
 	meta[i]->style = cho_style_new_default(ctx);
 	i++;
 	meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 	meta[i] = emalloc(sizeof(struct ChoMetadata));
 	meta[i]->name = strdup("tuning");
 	meta[i]->value = strdup(ins_info.tuning);
 	meta[i]->style = cho_style_new_default(ctx);
 	i++;
 	meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 	meta[i] = emalloc(sizeof(struct ChoMetadata));
 	meta[i]->name = strdup("user");
 	meta[i]->value = strdup(logged_in_user);
 	meta[i]->style = cho_style_new_default(ctx);
 	i++;
 	meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 	meta[i] = emalloc(sizeof(struct ChoMetadata));
 	meta[i]->name = strdup("user.name");
 	meta[i]->value = strdup(logged_in_user);
 	meta[i]->style = cho_style_new_default(ctx);
 	i++;
 	meta = erealloc(meta, (i+1) * sizeof(struct ChoMetadata *));
 	meta[i] = emalloc(sizeof(struct ChoMetadata));
 	meta[i]->name = strdup("user.fullname");
 	meta[i]->value = strdup(logged_in_user);
 	meta[i]->style = cho_style_new_default(ctx);
 	i++;
 	ctx->m = i;
 	return meta;
 }
 
 static char *
 cho_metadata_substitution_replace(
 	struct ChoContext *ctx,
 	const char *name,
 	const char *value,
 	int index
 )
 {
 	struct ChoMetadata *m;
 	int n = 0;
 	int i;
 	if (index == 0) {
 		char *c;
 		char *out = NULL;
 		int o = 0;
 		if (value[0] != 0) {
 			for (i = 0; i<ctx->m; i++) {
 				m = ctx->songs[ctx->so]->metadata[i];
 				if (!strcmp(m->name, name) && !strcmp(m->value, value)) {
 					if (out) {
 						for (c = ctx->config->metadata_separator; *c; c++, o++) {
 							out = erealloc(out, (o+1) * sizeof(char));
 							out[o] = *c;
 						}
 					}
 					for (c = m->value; *c; c++, o++) {
 						out = erealloc(out, (o+1) * sizeof(char));
 						out[o] = *c;
 					}
 				}
 			}
 		} else {
 			for (i = 0; i<ctx->m; i++) {
 				m = ctx->songs[ctx->so]->metadata[i];
 				if (!strcmp(m->name, name)) {
 					if (out) {
 						for (c = ctx->config->metadata_separator; *c; c++, o++) {
 							out = erealloc(out, (o+1) * sizeof(char));
 							out[o] = *c;
 						}
 					}
 					for (c = m->value; *c; c++, o++) {
 						out = erealloc(out, (o+1) * sizeof(char));
 						out[o] = *c;
 					}
 				}
 			}
 		}
 		out = erealloc(out, (o+1) * sizeof(char));
 		out[o] = 0;
 		return out;
 	} else if (index < 0) {
 		if (value[0] != 0) {
 			for (i = ctx->m-1; i >= 0; i--) {
 				m = ctx->songs[ctx->so]->metadata[i];
 				if (!strcmp(m->name, name)) {
 					n--;
 					if (!strcmp(m->value, value) && n == index) {
 						return strdup(m->value);
 					}
 				}
 			}
 		} else {
 			for (i = ctx->m-1; i >= 0; i--) {
 				m = ctx->songs[ctx->so]->metadata[i];
 				if (!strcmp(m->name, name)) {
 					n--;
 					if (n == index) {
 						return strdup(m->value);
 					}
 				}
 			}
 		}
 	} else if (index > 0) {
 		if (value[0] != 0) {
 			for (i = 0; i<ctx->m; i++) {
 				m = ctx->songs[ctx->so]->metadata[i];
 				if (!strcmp(m->name, name)) {
 					n++;
 					if (!strcmp(m->value, value) && n == index) {
 						return strdup(m->value);
 					}
 				}
 			}
 		} else {
 			for (i = 0; i<ctx->m; i++) {
 				m = ctx->songs[ctx->so]->metadata[i];
 				if (!strcmp(m->name, name)) {
 					n++;
 					if (n == index) {
 						return strdup(m->value);
 					}
 				}
 			}
 		}
 	}
 	return NULL;
 }
 
 static char *
 cho_metadata_substitution_parse(
 	struct ChoContext *ctx,
 	const char *str,
 	const char *parent_name,
 	enum State state_before_substitution
 )
 {
 	bool substitution_exist = false;
 	int o = 0;
 	char *out = NULL;
 	int len = strlen(str);
 	int i;
 	for (i = 0; i<len; i++) {
 		if (str[i] == '%' && str[i+1] == '{') {
 			substitution_exist = true;
 			i += 2;
 			break;
 		}
 		out = erealloc(out, (o+1) * sizeof(char));
 		out[o] = str[i];
 		o++;
 	}
 
 	enum MetadataSubstitutionState state = METADATA_SUBSTITUTION_STATE_NAME;
 	enum AttrValueSyntax avs = ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED;
 	char name[128];
 	char name_index[8];
 	char value[4096];
 	char true_text[4096];
 	char false_text[4096];
 	name[0] = 0;
 	name_index[0] = 0;
 	value[0] = 0;
 	true_text[0] = 0;
 	false_text[0] = 0;
 	char prev_c = 0;
 	char c = 0;
 	int n = 0;
 	int nested_level = 0;
 	for (; i<len; i++) {
 		c = str[i];
 
 		if (prev_c == '%' && c == '{') {
 			nested_level++;
 		} else if (prev_c != '\\' && c == '}') {
 			if (nested_level == 0) {
 				i++;
 				break;
 			}
 			nested_level--;
 		}
 
 		switch (state) {
 		case METADATA_SUBSTITUTION_STATE_NAME: {
 			if (c == '=') {
 				name[n] = 0;
 				n = 0;
 				state = METADATA_SUBSTITUTION_STATE_VALUE;
 				break;
 			}
 			if (c == '.') {
 				name[n] = 0;
 				state = METADATA_SUBSTITUTION_STATE_NAME_OR_INDEX;
 				break;
 			}
 			if (prev_c != '\\' && c == '|') {
 				name[n] = 0;
 				n = 0;
 				state = METADATA_SUBSTITUTION_STATE_TRUE_TEXT;
 				break;
 			}
 			name[n] = c;
 			n++;
 			break;
 		}
 		case METADATA_SUBSTITUTION_STATE_NAME_OR_INDEX: {
 			if (c == '-' || isdigit(c)) {
 				n = 0;
 				name_index[n] = c;
 				n++;
 				state = METADATA_SUBSTITUTION_STATE_INDEX;
 				break;
 			} else
 			if (islower(c)) {
 				name[n] = '.';
 				n++;
 				name[n] = c;
 				n++;
 				state = METADATA_SUBSTITUTION_STATE_NAME;
 				break;
 			}
 			cho_log(ctx, LOG_ERR, "Invalid character after the dot.");
 			goto ERR;
 		}
 		case METADATA_SUBSTITUTION_STATE_INDEX: {
 			if (c == '=') {
 				name_index[n] = 0;
 				n = 0;
 				state = METADATA_SUBSTITUTION_STATE_VALUE;
 				break;
 			}
 			if (prev_c != '\\' && c == '|') {
 				name_index[n] = 0;
 				n = 0;
 				state = METADATA_SUBSTITUTION_STATE_TRUE_TEXT;
 				break;
 			}
 			if (!isdigit(c)) {
 				// TODO: Find a better term for 'metadata substitution name index'!
 				cho_log(ctx, LOG_ERR, "Specify a positive or negative number in metadata substitution name index.");
 				goto ERR;
 			}
 			name_index[n] = c;
 			n++;
 			break;
 		}
 		case METADATA_SUBSTITUTION_STATE_VALUE: {
 			if (avs == ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED) {
 				if (is_whitespace(c)) {
 					cho_log(ctx, LOG_ERR, "Whitespace character after equals sign is invalid.");
 					goto ERR;
 				}
 				if (c == '|') {
 					cho_log(ctx, LOG_ERR, "If you specify an equals sign then you have to provide a value.");
 					goto ERR;
 				}
 				if (c == '\'') {
 					avs = ATTRIBUTE_VALUE_SYNTAX_APOSTROPHE;
 				} else if (c == '"') {
 					avs = ATTRIBUTE_VALUE_SYNTAX_QUOTATION_MARK;
 				} else {
 					avs = ATTRIBUTE_VALUE_SYNTAX_UNQUOTED;
 					value[n] = c;
 					n++;
 				}
 				break;
 			}
 			if (prev_c != '\\' && c == '|') {
 				if (avs == ATTRIBUTE_VALUE_SYNTAX_APOSTROPHE) {
 					cho_log(ctx, LOG_ERR, "Can't find a matching \"\'\".");
 					goto ERR;
 				}
 				if (avs == ATTRIBUTE_VALUE_SYNTAX_QUOTATION_MARK) {
 					cho_log(ctx, LOG_ERR, "Can't find a matching '\"'.");
 					goto ERR;
 				}
 				if (avs == ATTRIBUTE_VALUE_SYNTAX_UNQUOTED) {
 					value[n] = 0;
 					n = 0;
 					state = METADATA_SUBSTITUTION_STATE_TRUE_TEXT;
 					break;
 				}
 				if (avs == ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED) {
 					state = METADATA_SUBSTITUTION_STATE_TRUE_TEXT;
 					break;
 				}
 				break;
 			}
 			if (
 				(avs == ATTRIBUTE_VALUE_SYNTAX_APOSTROPHE && c == '\'') ||
 				(avs == ATTRIBUTE_VALUE_SYNTAX_QUOTATION_MARK && c == '"') ||
 				(avs == ATTRIBUTE_VALUE_SYNTAX_UNQUOTED && c == ' ')
 			) {
 				value[n] = 0;
 				n = 0;
 				state = METADATA_SUBSTITUTION_STATE_WAIT_FOR_PIPE;
 				break;
 			}
 			value[n] = c;
 			n++;
 			break;
 		}
 		case METADATA_SUBSTITUTION_STATE_TRUE_TEXT: {
 			if (prev_c != '\\' && c == '|' && nested_level == 0) {
 				true_text[n] = 0;
 				n = 0;
 				state = METADATA_SUBSTITUTION_STATE_FALSE_TEXT;
 				break;
 			}
 			true_text[n] = c;
 			n++;
 			break;
 		}
 		case METADATA_SUBSTITUTION_STATE_FALSE_TEXT: {
 			false_text[n] = c;
 			n++;
 			break;
 		}
 		case METADATA_SUBSTITUTION_STATE_WAIT_FOR_PIPE: {
 			if (is_whitespace(c)) {
 				break;
 			}
 			if (c == '|') {
 				state = METADATA_SUBSTITUTION_STATE_TRUE_TEXT;
 				break;
 			}
 			break;
 		}
 		}
 		prev_c = c;
 	}
 	switch (state) {
 	case METADATA_SUBSTITUTION_STATE_NAME:
 		name[n] = 0;
 		break;
 	case METADATA_SUBSTITUTION_STATE_INDEX:
 		name_index[n] = 0;
 		break;
 	case METADATA_SUBSTITUTION_STATE_VALUE:
 		switch (avs) {
 		case ATTRIBUTE_VALUE_SYNTAX_APOSTROPHE:
 			cho_log(ctx, LOG_ERR, "Can't find a matching \"\'\".");
 			goto ERR;
 		case ATTRIBUTE_VALUE_SYNTAX_QUOTATION_MARK:
 			cho_log(ctx, LOG_ERR, "Can't find a matching '\"'.");
 			goto ERR;
 		case ATTRIBUTE_VALUE_SYNTAX_UNQUOTED:
 			value[n] = 0;
 			break;
 		default:
 		}
 		break;
 	case METADATA_SUBSTITUTION_STATE_TRUE_TEXT:
 		true_text[n] = 0;
 		break;
 	case METADATA_SUBSTITUTION_STATE_FALSE_TEXT:
 		false_text[n] = 0;
 		break;
 	default:
 	}
 	char *replaced, *substituted, *ch;
 	int index = 0;
 	if (name_index[0] != 0) {
 		index = atoi(name_index);
 		if (index == 0) {
 			DEBUG("atoi failed.");
 			goto ERR;
 		}
 	}
 	if (name[0] != 0) {
 		replaced = cho_metadata_substitution_replace(ctx, name, value, index);
 		if (replaced[0] != 0) {
 			if (true_text[0] != 0) {
 				substituted = cho_metadata_substitution_parse(ctx, true_text, name, STATE_METADATA_SUBSTITUTION);
 				for (ch = substituted; *ch; ch++) {
 					out = erealloc(out, (o+1) * sizeof(char));
 					out[o] = *ch;
 					o++;
 				}
 				free(substituted);
 			} else {
 				for (ch = replaced; *ch; ch++) {
 					out = erealloc(out, (o+1) * sizeof(char));
 					out[o] = *ch;
 					o++;
 				}
 			}
 		} else {
 			if (false_text[0] != 0) {
 				substituted = cho_metadata_substitution_parse(ctx, false_text, name, STATE_METADATA_SUBSTITUTION);
 				for (ch = substituted; *ch; ch++) {
 					out = erealloc(out, (o+1) * sizeof(char));
 					out[o] = *ch;
 					o++;
 				}
 				free(substituted);
 			} else {
 				if (index != 0) {
 					cho_log(ctx, LOG_WARN, "There is no metadata item named '%s.%d'.", name, index);
 				} else {
 					cho_log(ctx, LOG_WARN, "There is no metadata item named '%s'.", name);
 				}
 			}
 		}
 		free(replaced);
 	} else {
 		if (state_before_substitution != STATE_METADATA_SUBSTITUTION) {
 			cho_log(ctx, LOG_ERR, "An empty metadata substitution can only be used inside of another metadata substitution.");
 			goto ERR;
 		}
 		if (substitution_exist) {
 			replaced = cho_metadata_substitution_replace(ctx, parent_name, "", 0);
 			if (replaced[0] != 0) {
 				for (ch = replaced; *ch; ch++) {
 					out = erealloc(out, (o+1) * sizeof(char));
 					out[o] = *ch;
 					o++;
 				}
 			} else {
 				cho_log(ctx, LOG_WARN, "There is no metadata item named '%s'.", parent_name);
 			}
 			free(replaced);
 		}
 	}
 	for (; i<len; i++) {
 		out = erealloc(out, (o+1) * sizeof(char));
 		out[o] = str[i];
 		o++;
 	}
 	out = erealloc(out, (o+1) * sizeof(char));
 	out[o] = 0;
 	return out;
 	ERR:
 	free(out);
 	return NULL;
 }
 
 static bool
 transposition_parse(const char *str, int *transpose)
 {
 	long i;
 	char *endptr;
 	i = strtol(str, &endptr, 10);
 	if (str == endptr) {
 		return false;
 	}
 	if (i == LONG_MIN || i == LONG_MAX) {
 		return false;
 	}
 	if (i > INT_MAX) {
 		return false;
 	}
 	*transpose = (int)i;
 	return true;
 }
 
 static char *
 transposition_calc_chord_root(struct ChoContext *ctx, int index, enum NoteType type)
 {
 	int transpose = *ctx->transpose;
 	if (transpose == 0) {
 		switch (type) {
 		case NOTE_TYPE_NOTE:
 			return strdup(ctx->config->output->notes[index]->note);
 		case NOTE_TYPE_SHARP:
 			return strdup(ctx->config->output->notes[index]->sharp);
 		case NOTE_TYPE_FLAT:
 			return strdup(ctx->config->output->notes[index]->flat);
 		}
 	}
 	int new_index = index;
 	enum NoteType note_type = type;
 	int i;
 	if (transpose > 0) {
 		for (i = 0; i<transpose; i++) {
 			switch (note_type) {
 			case NOTE_TYPE_NOTE:
 				switch (new_index) {
 				case 2:
 					new_index++;
 					break;
 				case 6:
 					new_index = 0;
 					break;
 				default:
 					note_type = NOTE_TYPE_SHARP;
 				}
 				break;
 			case NOTE_TYPE_SHARP:
 				new_index++;
 				note_type = NOTE_TYPE_NOTE;
 				break;
 			case NOTE_TYPE_FLAT:
 				note_type = NOTE_TYPE_NOTE;
 				break;
 			}
 		}
 	} else {
 		for (i = transpose; i<0; i++) {
 			switch (note_type) {
 			case NOTE_TYPE_NOTE:
 				switch (new_index) {
 				case 0:
 					new_index = 6;
 					break;
 				case 3:
 					new_index--;
 					break;
 				default:
 					note_type = NOTE_TYPE_FLAT;
 				}
 				break;
 			case NOTE_TYPE_SHARP:
 				note_type = NOTE_TYPE_NOTE;
 				break;
 			case NOTE_TYPE_FLAT:
 				new_index--;
 				note_type = NOTE_TYPE_NOTE;
 				break;
 			}
 		}
 	}
 	switch (note_type) {
 	case NOTE_TYPE_NOTE:
 		return strdup(ctx->config->output->notes[new_index]->note);
 	case NOTE_TYPE_SHARP:
 		return strdup(ctx->config->output->notes[new_index]->sharp);
 	case NOTE_TYPE_FLAT:
 		return strdup(ctx->config->output->notes[new_index]->flat);
 	}
 	cho_log(ctx, LOG_ERR, "Invalid NoteType '%d'.", note_type);
 	return NULL;
 }
 
 static struct ChoChord *
 cho_chord_new(struct ChoContext *ctx)
 {
 	struct ChoChord *chord = emalloc(sizeof(struct ChoChord));
 	chord->style = cho_style_new_default(ctx);
 	chord->name = NULL;
 	chord->is_canonical = false;
 	chord->root = NULL;
 	chord->qual = -1;
 	chord->ext = NULL;
 	chord->bass = NULL;
 	chord->display = NULL;
 	return chord;
 }
 
 /* INFO: copy every field except for 'style' */
 static void
 cho_chord_complete(struct ChoChord *first, struct ChoChord *second)
 {
 	first->name = strdup(second->name);
 	first->is_canonical = second->is_canonical;
 	first->qual = second->qual;
 	if (second->root) {
 		first->root = strdup(second->root);
 	}
 	if (second->ext) {
 		first->ext = strdup(second->ext);
 	}
 	if (second->bass) {
 		first->bass = strdup(second->bass);
 	}
 }
 
 
 static void
 cho_chord_free(struct ChoChord *chord)
 {
 	if (!chord) {
 		return;
 	}
 	cho_style_free(chord->style);
 	free(chord->name);
 	free(chord->root);
 	free(chord->ext);
 	free(chord->bass);
 	free(chord->display);
 	free(chord);
 }
 
 static struct ChoChord *
 cho_chord_copy(struct ChoChord *chord)
 {
 	struct ChoChord *copy = emalloc(sizeof(struct ChoChord));
 	copy->style = cho_style_copy(chord->style);
 	copy->is_canonical = chord->is_canonical;
 	copy->qual = chord->qual;
 	copy->name = strdup(chord->name);
 	copy->root = chord->root ? strdup(chord->root) : NULL;
 	copy->ext = chord->ext ? strdup(chord->ext) : NULL;
 	copy->bass = chord->bass ? strdup(chord->bass) : NULL;
 	copy->display = chord->display ? strdup(chord->display) : NULL;
 	return copy;
 }
 
 bool
 cho_chords_has(struct ChoChord **chords, struct ChoChord *chord)
 {
 	if (!chords) {
 		return false;
 	}
 	struct ChoChord **c;
 	for (c = chords; *c; c++) {
 		if (
 			!str_compare((*c)->name, chord->name) &&
 			!str_compare((*c)->root, chord->root) &&
 			!str_compare((*c)->ext, chord->ext) &&
 			!str_compare((*c)->bass, chord->bass) &&
 			(*c)->qual == chord->qual
 		) {
 			return true;
 		}
 	}
 	return false;
 }
 
 int
 cho_chord_compare(const void *a, const void *b)
 {
 	struct ChoChord **aa = (struct ChoChord **)a;
 	struct ChoChord **bb = (struct ChoChord **)b;
 	return str_compare((*aa)->root, (*bb)->root);
 }
 
 size_t
 cho_chord_count(struct ChoChord **chords)
 {
 	if (!chords) {
 		return 0;
 	}
 	int i;
 	for (i = 0; chords[i]; i++);
 	return i;
 }
 
 void
 cho_chords_add(struct ChoChord ***chords, struct ChoChord *chord)
 {
 	int i = 0;
 	if (*chords) {
 		struct ChoChord **c;
 		for (c = *chords; *c; c++);
 		i = (int)(c - *chords);
 	}
 	*chords = erealloc(*chords, (i+2) * sizeof(struct ChoChord *));
 	(*chords)[i] = cho_chord_copy(chord);
 	(*chords)[i+1] = NULL;
 }
 
 void
 cho_chords_free(struct ChoChord **chords)
 {
 	if (!chords) {
 		return;
 	}
 	struct ChoChord **c;
 	for (c = chords; *c; c++) {
 		cho_chord_free(*c);
 	}
 	free(chords);
 }
 
 /* returns how many bytes make up the root; returns 0 if no root was found */
 static int
 cho_chord_root_parse(struct ChoContext *ctx, const char *str, struct ChoChord *chord)
 {
 	const char *note = NULL;
 	const char *sharp = NULL;
 	const char *flat = NULL;
 	char *transposed_root;
 	int i;
 	for (i = 0; i<7; i++) {
 		sharp = ctx->config->parser->notes[i]->sharp;
 		if (sharp && str_starts_with(str, sharp)) {
 			transposed_root = transposition_calc_chord_root(ctx, i, NOTE_TYPE_SHARP);
 			if (!transposed_root) {
 				DEBUG("transposition_calc_chord_root failed.");
 				return 0;
 			}
 			chord->root = transposed_root;
 			return strlen(sharp);
 		}
 		flat = ctx->config->parser->notes[i]->flat;
 		if (flat && str_starts_with(str, flat)) {
 			transposed_root = transposition_calc_chord_root(ctx, i, NOTE_TYPE_FLAT);
 			if (!transposed_root) {
 				DEBUG("transposition_calc_chord_root failed.");
 				return 0;
 			}
 			chord->root = transposed_root;
 			return strlen(flat);
 		}
 		note = ctx->config->parser->notes[i]->note;
 		if (str_starts_with(str, note)) {
 			transposed_root = transposition_calc_chord_root(ctx, i, NOTE_TYPE_NOTE);
 			if (!transposed_root) {
 				DEBUG("transposition_calc_chord_root failed.");
 				return 0;
 			}
 			chord->root = transposed_root;
 			return strlen(note);
 		}
 	}
 	return 0;
 }
 
 static char *
 cho_chord_qualifier_strip(const char *str)
 {
 	if (str_starts_with(str, "m") || str_starts_with(str, "-")) {
 		return strdup((char *)&str[1]);
 	}
 	return strdup(str);
 }
 
 static int
 cho_chord_qualifier_and_extension_parse(const char *str, struct ChoChord *chord)
 {
 	int i;
 	for (i = 0; chord_extensions_major[i]; i++) {
 		if (str_starts_with(str, chord_extensions_major[i])) {
 			chord->ext = strdup(chord_extensions_major[i]);
 			chord->qual = CHORD_QUALIFIER_MAJ;
 			return strlen(chord_extensions_major[i]);
 		}
 	}
 	for (i = 0; chord_extensions_minor[i]; i++) {
 		if (str_starts_with(str, chord_extensions_minor[i])) {
 			chord->ext = cho_chord_qualifier_strip(chord_extensions_minor[i]);
 			chord->qual = CHORD_QUALIFIER_MIN;
 			return strlen(chord_extensions_minor[i]);
 		}
 	}
 	if (str_starts_with(str, "aug")) {
 		chord->qual = CHORD_QUALIFIER_AUG;
 		return 3;
 	}
 	if (str_starts_with(str, "+")) {
 		chord->qual = CHORD_QUALIFIER_AUG;
 		return 1;
 	}
 	if (str_starts_with(str, "dim")) {
 		chord->qual = CHORD_QUALIFIER_DIM;
 		return 3;
 	}
 	if (str_starts_with(str, "0")) {
 		chord->qual = CHORD_QUALIFIER_DIM;
 		return 1;
 	}
 	if (str_starts_with(str, "ø")) {
 		chord->qual = CHORD_QUALIFIER_DIM;
 		return 1;
 	}
 	// TODO: What about 'ø', 'h', 'h7' and 'h9'?
 	// TODO: What about extensions after 'aug', '+', 'dim', '0'?
 	return 0;
 }
 
 static int
 cho_chord_bass_parse(struct ChoContext *ctx, const char *str, struct ChoChord *chord)
 {
 	if (str[0] == '/') {
 		const char *note = NULL;
 		const char *sharp = NULL;
 		const char *flat = NULL;
 		const char *out_note = NULL;
 		const char *out_sharp = NULL;
 		const char *out_flat = NULL;
 		int i;
 		for (i = 0; i<7; i++) {
 			sharp = ctx->config->parser->notes[i]->sharp;
 			out_sharp = ctx->config->output->notes[i]->sharp;
 			if (sharp && !strcmp((char *)&str[1], sharp)) {
 				chord->bass = strdup(out_sharp);
 				return strlen(sharp) + 1;
 			}
 			flat = ctx->config->parser->notes[i]->flat;
 			out_flat = ctx->config->output->notes[i]->flat;
 			if (flat && !strcmp((char *)&str[1], flat)) {
 				chord->bass = strdup(out_flat);
 				return strlen(flat) + 1;
 			}
 			note = ctx->config->parser->notes[i]->note;
 			out_note = ctx->config->parser->notes[i]->note;
 			if (!strcmp((char *)&str[1], note)) {
 				chord->bass = strdup(out_note);
 				return strlen(note) + 1;
 			}
 		}
 	}
 	return 0;
 }
 
 static struct ChoChord *
 cho_chord_parse(struct ChoContext *ctx, const char *str)
 {
 	struct ChoChord *chord = cho_chord_new(ctx);
 	struct ChordDiagram *diagram;
 	int i, ret;
 	size_t str_len = strlen(str);
 	size_t bytes_parsed = 0;
 
 	for (i = 0; i<ctx->dia; i++) {
 		diagram = ctx->songs[ctx->so]->diagrams[i];
 		if (
 			diagram->type == CHORD_DIAGRAM_CONTENT_CHORD_MAP &&
 			!strcmp(str, diagram->u.cm->name)
 		) {
 			chord->display = strdup(diagram->u.cm->display);
 		}
 	}
 	chord->name = strdup(str);
 	ret = cho_chord_root_parse(ctx, str, chord);
 	if (ret == 0) {
 		return chord;
 	}
 	chord->qual = CHORD_QUALIFIER_MAJ;
 	bytes_parsed += ret;
 	if (bytes_parsed == str_len) {
 		chord->is_canonical = true;
 		return chord;
 	}
 	ret = cho_chord_qualifier_and_extension_parse((const char *)&str[bytes_parsed], chord);
 	bytes_parsed += ret;
 	if (bytes_parsed == str_len) {
 		chord->is_canonical = true;
 		return chord;
 	}
 	ret = cho_chord_bass_parse(ctx, (const char *)&str[bytes_parsed], chord);
 	bytes_parsed += ret;
 	if (bytes_parsed == str_len) {
 		chord->is_canonical = true;
 		return chord;
 	}
 	return chord;
 }
 
 char *
 cho_chord_name_generate_common(struct ChoChord *chord, struct Config *config)
 {
 	struct Note **notes = config->output->notes;
 	struct Note *notes_common;
 	char *root = NULL;
 	char *name = NULL;
 	const char *qual;
 	int i;
 	int n = 0;
 	size_t name_len = 0;
 
 	if (chord->is_canonical) {
 		notes_common = config_notes_common();
 		for (i = 0; i<7; i++) {
 			if (!strcmp(notes[i]->note, chord->root)) {
 				root = notes_common[i].note;
 				break;
 			}
 			if (notes[i]->sharp && !strcmp(notes[i]->sharp, chord->root)) {
 				root = notes_common[i].sharp;
 				break;
 			}
 			if (notes[i]->flat && !strcmp(notes[i]->flat, chord->root)) {
 				root = notes_common[i].flat;
 				break;
 			}
 		}
 		free(notes_common);
 		name_len += strlen(root);
 		name = erealloc(name, name_len * sizeof(char));
 		for (i = 0; root[i]; i++, n++) {
 			name[n] = root[i];
 		}
 		qual = chord_qualifiers[chord->qual];
 		name_len += strlen(qual);
 		name = erealloc(name, name_len * sizeof(char));
 		for (i = 0; qual[i]; i++, n++) {
 			name[n] = qual[i];
 		}
 		if (chord->ext) {
 			name_len += strlen(chord->ext);
 			name = erealloc(name, name_len * sizeof(char));
 			for (i = 0; chord->ext[i]; i++, n++) {
 				name[n] = chord->ext[i];
 			}
 		}
 		if (chord->bass) {
 			name_len++;
 			name_len += strlen(chord->bass);
 			name = erealloc(name, name_len * sizeof(char));
 			name[n] = '/';
 			n++;
 			for (i = 0; chord->bass[i]; i++, n++) {
 				name[n] = chord->bass[i];
 			}
 		}
 		name_len++;
 		name = erealloc(name, name_len * sizeof(char));
 		name[n] = 0;
 		return name;
 	}
 	return strdup(chord->name);
 }
 
 char *
 cho_chord_name_generate(struct ChoChord *chord)
 {
 	int n = 0;
 	int i;
 	char *name = NULL;
 	const char *qual;
 	size_t name_len = 0;
 
 	if (chord->display) {
 		return strdup(chord->display);
 	}
 	if (chord->is_canonical) {
 		name_len += strlen(chord->root);
 		name = erealloc(name, name_len * sizeof(char));
 		for (i = 0; chord->root[i]; i++, n++) {
 			name[n] = chord->root[i];
 		}
 		qual = chord_qualifiers[chord->qual];
 		name_len += strlen(qual);
 		name = erealloc(name, name_len * sizeof(char));
 		for (i = 0; qual[i]; i++, n++) {
 			name[n] = qual[i];
 		}
 		if (chord->ext) {
 			name_len += strlen(chord->ext);
 			name = erealloc(name, name_len * sizeof(char));
 			for (i = 0; chord->ext[i]; i++, n++) {
 				name[n] = chord->ext[i];
 			}
 		}
 		if (chord->bass) {
 			name_len++;
 			name_len += strlen(chord->bass);
 			name = erealloc(name, name_len * sizeof(char));
 			name[n] = '/';
 			n++;
 			for (i = 0; chord->bass[i]; i++, n++) {
 				name[n] = chord->bass[i];
 			}
 		}
 		name_len++;
 		name = erealloc(name, name_len * sizeof(char));
 		name[n] = 0;
 		return name;
 	}
 	return strdup(chord->name);
 }
 
 static struct ChoImage *
 cho_image_new(void)
 {
 	struct ChoImage *image = emalloc(sizeof(struct ChoImage));
 	image->is_asset = false;
 	image->id = NULL;
 	image->src = NULL;
 	image->width = NULL;
 	image->height = NULL;
 	image->width_scale = NULL;
 	image->height_scale = NULL;
 	image->align = ALIGNMENT_CENTER;
 	image->border = EMPTY_DOUBLE;
 	image->spread_space = NULL;
 	image->href = NULL;
 	image->x = NULL;
 	image->y = NULL;
 	image->anchor = ANCHOR_FLOAT;
 	image->dx = NULL;
 	image->dy = NULL;
 	image->w = NULL;
 	image->h = NULL;
 	image->bbox = false;
 	return image;
 }
 
 static void
 cho_image_free(struct ChoImage *image)
 {
 	if (!image) {
 		return;
 	}
 	free(image->id);
 	free(image->src);
 	free(image->width);
 	free(image->height);
 	free(image->width_scale);
 	free(image->height_scale);
 	free(image->spread_space);
 	free(image->href);
 	free(image->x);
 	free(image->y);
 	free(image->dx);
 	free(image->dy);
 	free(image->w);
 	free(image->h);
 	free(image);
 }
 
 static struct ChoImage *
 cho_image_copy(struct ChoImage *image)
 {
 	struct ChoImage *copy = emalloc(sizeof(struct ChoImage));
 	copy->is_asset = image->is_asset;
 	copy->id = strdup(image->id);
 	copy->src = strdup(image->src);
 	copy->width = size_copy(image->width);
 	copy->height = size_copy(image->height);
 	copy->width_scale = size_copy(image->width_scale);
 	copy->height_scale = size_copy(image->height_scale);
 	copy->align = image->align;
 	copy->border = image->border;
 	copy->spread_space = size_copy(image->spread_space);
 	copy->href = strdup(image->href);
 	copy->x = size_copy(image->x);
 	copy->y = size_copy(image->y);
 	copy->anchor = image->anchor;
 	copy->dx = size_copy(image->dx);
 	copy->dy = size_copy(image->dy);
 	copy->w = size_copy(image->w);
 	copy->h = size_copy(image->h);
 	copy->bbox = image->bbox;
 	return copy;
 }
 
 static struct ChoImage *
 cho_image_find_asset(struct ChoContext *ctx, const char *id)
 {
 	int i;
 
 	for (i = 0; i<ctx->ia; i++) {
 		if (!strcmp(ctx->image_assets[i]->id, id)) {
 			return ctx->image_assets[i];
 		}
 	}
 	return NULL;
 }
 
 #ifdef ENABLE_DEBUG
 void
 cho_debug_image_print(struct ChoImage *image)
 {
 	printf("---- BEGIN IMAGE ----\n");
 	printf("is_asset: %d\n", image->is_asset);
 	if (image->id) {
 		printf("id: %s\n", image->id);
 	} else {
 		printf("id: NULL\n");
 	}
 	if (image->src) {
 		printf("src: %s\n", image->src);
 	} else {
 		printf("src: NULL\n");
 	}
 	if (image->width) {
 		printf("width: %s\n", size_to_string(image->width));
 	} else {
 		printf("width: NULL\n");
 	}
 	if (image->height) {
 		printf("height: %s\n", size_to_string(image->height));
 	} else {
 		printf("height: NULL\n");
 	}
 	if (image->width_scale) {
 		printf("width_scale: %s\n", size_to_string(image->width_scale));
 	} else {
 		printf("width_scale: NULL\n");
 	}
 	if (image->height_scale) {
 		printf("height_scale: %s\n", size_to_string(image->height_scale));
 	} else {
 		printf("height_scale: NULL\n");
 	}
 	printf("align: %s\n", alignment_enums[image->align]);
 	printf("border: %.1f\n", image->border);
 	if (image->spread_space) {
 		printf("spread_space: %s\n", size_to_string(image->spread_space));
 	} else {
 		printf("spread_space: NULL\n");
 	}
 	if (image->href) {
 		printf("href: %s\n", image->href);
 	} else {
 		printf("href: NULL\n");
 	}
 	if (image->x) {
 		printf("x: %s\n", size_to_string(image->x));
 	} else {
 		printf("x: NULL\n");
 	}
 	if (image->y) {
 		printf("y: %s\n", size_to_string(image->y));
 	} else {
 		printf("y: NULL\n");
 	}
 	printf("anchor: %s\n", anchor_enums[image->anchor]);
 	if (image->dx) {
 		printf("dx: %s\n", size_to_string(image->dx));
 	} else {
 		printf("dx: NULL\n");
 	}
 	if (image->dy) {
 		printf("dy: %s\n", size_to_string(image->dy));
 	} else {
 		printf("dy: NULL\n");
 	}
 	if (image->w) {
 		printf("w: %s\n", size_to_string(image->w));
 	} else {
 		printf("w: NULL\n");
 	}
 	if (image->h) {
 		printf("h: %s\n", size_to_string(image->h));
 	} else {
 		printf("h: NULL\n");
 	}
 	printf("bbox: %d\n", image->bbox);
 	printf("---- END IMAGE ------\n");
 }
 #endif /* ENABLE_DEBUG */
 
 static bool
 cho_image_option_parse(struct ChoContext *ctx, struct ChoImage *image, const char *name, const char *value)
 {
 	char *endptr;
 	struct Size *size = NULL;
 
 	if (!strcmp(name, "id")) {
 		image->id = strdup(value);
 	} else
 	if (!strcmp(name, "src")) {
 		image->src = filepath_resolve_tilde(value);
 		if (!image->src) {
 			DEBUG("filepath_resolve_tilde failed.");
 			goto ERR;
 		}
 	} else
 	if (!strcmp(name, "width")) {
 		size = size_create(value);
 		if (!size) {
 			cho_log(ctx, LOG_ERR, "Invalid value in option 'width' in image directive.");
 			goto ERR;
 		}
 		if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 			cho_log(ctx, LOG_ERR, "Invalid type of value in option 'width' in image directive. Allowed types are: points, percentage.");
 			goto ERR;
 		}
 		image->width = size;
 	} else
 	if (!strcmp(name, "height")) {
 		size = size_create(value);
 		if (!size) {
 			cho_log(ctx, LOG_ERR, "Invalid value in option 'height' in image directive.");
 			goto ERR;
 		}
 		if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 			cho_log(ctx, LOG_ERR, "Invalid type of value in option 'height' in image directive. Allowed types are: point, percentage.");
 			goto ERR;
 		}
 		image->height = size;
 	} else
 	if (!strcmp(name, "scale")) {
 		char *comma;
 		if ((comma = strchr(value, ','))) {
 			*comma = 0;
 			size = size_create(value);
 			if (!size) {
 				cho_log(ctx, LOG_ERR, "Invalid value in option 'scale' in image directive.");
 				goto ERR;
 			}
 			if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 				cho_log(ctx, LOG_ERR, "Invalid type of value in option 'scale' in image directive. Allowed types are: point, percentage.");
 				goto ERR;
 			}
 			image->width_scale = size;
 			size = size_create(++comma);
 			if (!size) {
 				cho_log(ctx, LOG_ERR, "Invalid value in option 'scale' in image directive.");
 				goto ERR;
 			}
 			if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 				cho_log(ctx, LOG_ERR, "Invalid type of value in option 'scale' in image directive. Allowed types are: point, percentage.");
 				goto ERR;
 			}
 			image->height_scale = size;
 		} else {
 			size = size_create(value);
 			if (!size) {
 				cho_log(ctx, LOG_ERR, "Invalid value in option 'scale' in image directive.");
 				goto ERR;
 			}
 			if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 				cho_log(ctx, LOG_ERR, "Invalid type of value in option 'scale' in image directive. Allowed types are: point, percentage.");
 				goto ERR;
 			}
 			image->width_scale = size;
 			image->height_scale = size_copy(size);
 		}
 	} else
 	if (!strcmp(name, "align")) {
 		if (!strcmp(value, "left")) {
 			image->align = ALIGNMENT_LEFT;
 		} else
 		if (!strcmp(value, "right")) {
 			image->align = ALIGNMENT_RIGHT;
 		} else
 		if (!strcmp(value, "center")) {
 			image->align = ALIGNMENT_CENTER;
 		} else {
 			cho_log(ctx, LOG_ERR, "Invalid value in option 'align' in image directive.");
 			goto ERR;
 		}
 	} else
 	if (!strcmp(name, "border")) {
 		image->border = strtod(value, &endptr);
 		if (value == endptr || errno == ERANGE) {
 			DEBUG("strtod failed.");
 			goto ERR;
 		}
 	} else
 	if (!strcmp(name, "spread")) {
 		size = size_create(value);
 		if (!size) {
 			cho_log(ctx, LOG_ERR, "Invalid value in option 'spread' in image directive.");
 			goto ERR;
 		}
 		if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 			cho_log(ctx, LOG_ERR, "Invalid type of value in option 'spread' in image directive. Allowed types are: point, percentage.");
 			goto ERR;
 		}
 		image->spread_space = size;
 	} else
 	if (!strcmp(name, "href")) {
 		image->href = strdup(value);
 	} else
 	if (!strcmp(name, "x")) {
 		size = size_create(value);
 		if (!size) {
 			cho_log(ctx, LOG_ERR, "Invalid value in option 'x' in image directive.");
 			goto ERR;
 		}
 		if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 			cho_log(ctx, LOG_ERR, "Invalid type of value in option 'x' in image directive. Allowed types are: point, percentage.");
 			goto ERR;
 		}
 		image->x = size;
 	} else
 	if (!strcmp(name, "y")) {
 		size = size_create(value);
 		if (!size) {
 			cho_log(ctx, LOG_ERR, "Invalid value in option 'y' in image directive.");
 			goto ERR;
 		}
 		if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 			cho_log(ctx, LOG_ERR, "Invalid type of value in option 'y' in image directive. Allowed types are: point, percentage.");
 			goto ERR;
 		}
 		image->y = size;
 	} else
 	if (!strcmp(name, "anchor")) {
 		if (!strcmp(value, "paper")) {
 			image->anchor = ANCHOR_PAPER;
 		} else
 		if (!strcmp(value, "page")) {
 			image->anchor = ANCHOR_PAGE;
 		} else
 		if (!strcmp(value, "column")) {
 			image->anchor = ANCHOR_COLUMN;
 		} else
 		if (!strcmp(value, "line")) {
 			image->anchor = ANCHOR_LINE;
 		} else
 		if (!strcmp(value, "float")) {
 			image->anchor = ANCHOR_FLOAT;
 		} else {
 			cho_log(ctx, LOG_ERR, "Invalid value in option 'anchor' in image directive.");
 			goto ERR;
 		}
 	}
 	return true;
 	ERR:
 	free(size);
 	return false;
 }
 
 static struct ChoImage *
 cho_image_directive_parse(struct ChoContext *ctx, const char *str)
 {
 	struct ChoImage *image = cho_image_new();
 	struct ChoImage *asset;
 	enum OptionState state = OPTION_STATE_NAME;
 	enum AttrValueSyntax avs = ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED;
 	char c;
 	char name[6+1];
 	char value[URL_MAX_LEN+1];
 	int n = 0;
 	int v = 0;
 	int option_count = 0;
 	int i;
 
 	memset(name, 0, sizeof(name));
 	memset(value, 0, sizeof(value));
 	for (i = 0; str[i]; i++) {
 		c = str[i];
 		switch (state) {
 		case OPTION_STATE_NAME:
 			if (is_whitespace(c)) {
 				if (n == 0) {
 					break;
 				} else {
 					name[n] = 0;
 					cho_log(ctx, LOG_ERR, "Option with name '%s' in image directive has no value.", name);
 					goto ERR;
 				}
 			}
 			if (c == '=') {
 				name[n] = 0;
 				state = OPTION_STATE_VALUE;
 				break;
 			}
 			if (n > 5) {
 				cho_log(ctx, LOG_ERR, "Option name in image directive is too long.");
 				goto ERR;
 			}
 			name[n] = c;
 			n++;
 			break;
 		case OPTION_STATE_VALUE:
 			if (avs == ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED) {
 				if (is_whitespace(c)) {
 					cho_log(ctx, LOG_ERR, "Whitespace character after equals sign in image directive is invalid.");
 					goto ERR;
 				}
 				if (c == '\'') {
 					avs = ATTRIBUTE_VALUE_SYNTAX_APOSTROPHE;
 				} else if (c == '"') {
 					avs = ATTRIBUTE_VALUE_SYNTAX_QUOTATION_MARK;
 				} else {
 					avs = ATTRIBUTE_VALUE_SYNTAX_UNQUOTED;
 					value[v] = c;
 					v++;
 				}
 				break;
 			}
 			if (c == '\n') {
 				cho_log(ctx, LOG_ERR, "Newline character inside an option value in image directive is invalid.");
 				goto ERR;
 			}
 			if (
 				(avs == ATTRIBUTE_VALUE_SYNTAX_APOSTROPHE && c == '\'') ||
 				(avs == ATTRIBUTE_VALUE_SYNTAX_QUOTATION_MARK && c == '"') ||
 				(avs == ATTRIBUTE_VALUE_SYNTAX_UNQUOTED && (c == ' ' || c == '\t'))
 			) {
 				value[v] = 0;
 				if (!cho_image_option_parse(ctx, image, name, value)) {
 					DEBUG("cho_image_option_parse failed.");
 					goto ERR;
 				}
 				option_count++;
 				memset(name, 0, n);
 				memset(value, 0, v);
 				n = 0;
 				v = 0;
 				avs = ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED;
 				state = OPTION_STATE_NAME;
 				break;
 			}
 			value[v] = c;
 			v++;
 			break;
 		}
 	}
 	if (avs == ATTRIBUTE_VALUE_SYNTAX_UNQUOTED) {
 		value[v] = 0;
 		if (!cho_image_option_parse(ctx, image, name, value)) {
 			DEBUG("cho_image_option_parse failed.");
 			goto ERR;
 		}
 		option_count++;
 	}
 	if (image->id) {
 		if (image->src) {
 			if (option_count > 2) {
 				cho_log(ctx, LOG_ERR, "Defining an image asset disallows any options other than 'id' and 'src'.");
 				goto ERR;
 			}
 			image->is_asset = true;
 		} else {
 			asset = cho_image_find_asset(ctx, image->id);
 			if (!asset) {
 				cho_log(ctx, LOG_ERR, "There is no image asset with the id '%s'.", image->id);
 				goto ERR;
 			}
 			image->src = strdup(asset->src);
 		}
 	}
 	return image;
 	ERR:
 	cho_image_free(image);
 	return NULL;
 }
 
 static struct ChoImage *
 cho_image_tag_parse(struct ChoContext *ctx, struct Attr **attrs)
 {
 	struct ChoImage *image = cho_image_new();
 	struct ChoImage *asset;
 	struct Size *size = NULL;
 	int a;
 
 	for (a = 0; attrs[a]; a++) {
 		if (!strcmp(attrs[a]->name, "src")) {
 			image->src = filepath_resolve_tilde(attrs[a]->value);
 			if (!image->src) {
 				DEBUG("filepath_resolve_tilde failed.");
 				goto ERR;
 			}
 		} else
 		if (!strcmp(attrs[a]->name, "id")) {
 			image->id = strdup(attrs[a]->value);
 		} else
 		if (!strcmp(attrs[a]->name, "width")) {
 			size = size_create(attrs[a]->value);
 			if (!size) {
 				cho_log(ctx, LOG_ERR, "Invalid value in attribute 'width' in 'img' tag.");
 				goto ERR;
 			}
 			if (size->type == SIZE_TYPE_PERCENT) {
 				cho_log(ctx, LOG_ERR, "Invalid type of value in attribute 'width' in 'img' tag. Allowed types are: point, em, ex.");
 				goto ERR;
 			}
 			image->width = size;
 		} else
 		if (!strcmp(attrs[a]->name, "height")) {
 			size = size_create(attrs[a]->value);
 			if (!size) {
 				cho_log(ctx, LOG_ERR, "Invalid value in attribute 'height' in 'img' tag.");
 				goto ERR;
 			}
 			if (size->type == SIZE_TYPE_PERCENT) {
 				cho_log(ctx, LOG_ERR, "Invalid type of value in attribute 'height' in 'img' tag. Allowed types are: point, em, ex.");
 				goto ERR;
 			}
 			image->height = size;
 		} else
 		if (!strcmp(attrs[a]->name, "dx")) {
 			size = size_create(attrs[a]->value);
 			if (!size) {
 				cho_log(ctx, LOG_ERR, "Invalid value in attribute 'dx' in 'img' tag.");
 				goto ERR;
 			}
 			if (size->type == SIZE_TYPE_PERCENT) {
 				cho_log(ctx, LOG_ERR, "Invalid type of value in attribute 'dx' in 'img' tag. Allowed types are: point, em, ex.");
 				goto ERR;
 			}
 			image->dx = size;
 		} else
 		if (!strcmp(attrs[a]->name, "dy")) {
 			size = size_create(attrs[a]->value);
 			if (!size) {
 				cho_log(ctx, LOG_ERR, "Invalid value in attribute 'dy' in 'img' tag.");
 				goto ERR;
 			}
 			if (size->type == SIZE_TYPE_PERCENT) {
 				cho_log(ctx, LOG_ERR, "Invalid type of value in attribute 'dy' in 'img' tag. Allowed types are: point, em, ex.");
 				goto ERR;
 			}
 			image->dy = size;
 		} else
 		if (!strcmp(attrs[a]->name, "scale")) {
 			char *comma;
 			if ((comma = strchr(attrs[a]->value, ','))) {
 				*comma = 0;
 				size = size_create(attrs[a]->value);
 				if (!size) {
 					cho_log(ctx, LOG_ERR, "Invalid value in attribute 'scale' in 'img' tag.");
 					goto ERR;
 				}
 				if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 					cho_log(ctx, LOG_ERR, "Invalid type of value in attribute 'scale' in 'img' tag. Allowed types are: point, percent");
 					goto ERR;
 				}
 				image->width_scale = size;
 				size = size_create(++comma);
 				if (!size) {
 					cho_log(ctx, LOG_ERR, "Invalid value in attribute 'scale' in 'img' tag.");
 					goto ERR;
 				}
 				if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 					cho_log(ctx, LOG_ERR, "Invalid type of value in attribute 'scale' in 'img' tag. Allowed types are: point, percent");
 					goto ERR;
 				}
 				image->height_scale = size;
 			} else {
 				size = size_create(attrs[a]->value);
 				if (!size) {
 					cho_log(ctx, LOG_ERR, "Invalid value in attribute 'scale' in 'img' tag.");
 					goto ERR;
 				}
 				if (size->type == SIZE_TYPE_EM || size->type == SIZE_TYPE_EX) {
 					cho_log(ctx, LOG_ERR, "Invalid type of value in attribute 'scale' in 'img' tag. Allowed types are: point, percent");
 					goto ERR;
 				}
 				image->width_scale = size;
 				image->height_scale = size_copy(size);
 			}
 		} else
 		if (!strcmp(attrs[a]->name, "align")) {
 			if (!strcmp(attrs[a]->value, "left")) {
 				image->align = ALIGNMENT_LEFT;
 			} else
 			if (!strcmp(attrs[a]->value, "right")) {
 				image->align = ALIGNMENT_RIGHT;
 			} else
 			if (!strcmp(attrs[a]->value, "center")) {
 				image->align = ALIGNMENT_CENTER;
 			} else {
 				cho_log(ctx, LOG_ERR, "Invalid value in attribute 'align' in 'img' tag.");
 				goto ERR;
 			}
 		} else
 		if (!strcmp(attrs[a]->name, "bbox")) {
 			if (!strcmp(attrs[a]->value, "1")) {
 				image->bbox = true;
 			} else
 			if (!strcmp(attrs[a]->value, "0")) {
 				image->bbox = false;
 			} else {
 				cho_log(ctx, LOG_ERR, "Invalid value in attribute 'bbox' in 'img' tag.");
 				goto ERR;
 			}
 		} else
 		if (!strcmp(attrs[a]->name, "w")) {
 			size = size_create(attrs[a]->value);
 			if (!size) {
 				cho_log(ctx, LOG_ERR, "Invalid value in attribute 'w' in 'img' tag.");
 				goto ERR;
 			}
 			if (size->type != SIZE_TYPE_POINT) {
 				cho_log(ctx, LOG_ERR, "Invalid type of value in attribute 'w' in 'img' tag. Allowed type is: point");
 				goto ERR;
 			}
 			image->w = size;
 		} else
 		if (!strcmp(attrs[a]->name, "h")) {
 			size = size_create(attrs[a]->value);
 			if (!size) {
 				cho_log(ctx, LOG_ERR, "Invalid value in attribute 'h' in 'img' tag.");
 				goto ERR;
 			}
 			if (size->type != SIZE_TYPE_POINT) {
 				cho_log(ctx, LOG_ERR, "Invalid type of value in attribute 'h' in 'img' tag. Allowed type is: point");
 				goto ERR;
 			}
 			image->h = size;
 		} else {
 			cho_log(ctx, LOG_ERR, "Invalid attribute '%s' in 'img' tag.", attrs[a]->name);
 			goto ERR;
 		}
 	}
 	if (image->id) {
 		if (image->src) {
 			cho_log(ctx, LOG_ERR, "'img' tag can't have both attributes 'id' and 'src' at the same time.");
 			goto ERR;
 		} else {
 			asset = cho_image_find_asset(ctx, image->id);
 			if (!asset) {
 				cho_log(ctx, LOG_ERR, "There is no image asset with the id '%s'.", image->id);
 				goto ERR;
 			}
 			image->src = strdup(asset->src);
 		}
 	} else {
 		if (!image->src) {
 			cho_log(ctx, LOG_ERR, "'img' tag has to have at least either the attribute 'id' or 'src'.");
 			goto ERR;
 		}
 	}
 	return image;
 	ERR:
 	cho_image_free(image);
 	free(size);
 	return NULL;
 }
 
 static int8_t
 char_to_positive_int(char c)
 {
 	if (c >= '0' && c <= '9') {
 		return c - 48;
 	}
 	return -1;
 }
 
 static int8_t
 finger_to_int(char c)
 {
 	if (c == '-' || c == 'x' || c == 'X' || c == 'N') {
 		return -1;
 	}
 	if (c >= '0' && c <= '9') {
 		return c - 48;
 	}
 	if (c >= 'A' && c <= 'Z') {
 		return c - 64;
 	}
 	return -2;
 }
 
 static struct ChordDiagram *
 cho_chord_diagram_parse(
 	struct ChoContext *ctx,
 	const char *str,
 	struct ChordDiagram **custom_diagrams,
 	int custom_diagrams_len
 )
 {
 	struct ChordDiagram *diagram = chord_diagram_new();
 	enum ChordDiagramState state = CHORD_DIAGRAM_STATE_NAME;
 	enum ChordDiagramContent current_content = CHORD_DIAGRAM_CONTENT_UNINITIALIZED;
 	enum ChordDiagramContent future_content = CHORD_DIAGRAM_CONTENT_UNINITIALIZED;
 	bool is_maybe_minus_one = false;
 	char name[20];
 	char option[10];
 	char key[3];
 	char base_fret[3];
 	char diagram_value[7+1];
 	char chord_to_copy[20];
 	char display[20];
 	int i = 0;
 	int f = 0;
 	int fret_count = 0;
 	int finger_count = 0;
 	int8_t number = -2;
 	long l;
 	const char *c;
 
 	for (c = str; *c; c++){
 		// printf("c '%c' state '%d'\n", c, state);
 		switch (state) {
 		case CHORD_DIAGRAM_STATE_NAME: {
 			if (is_whitespace(*c)) {
 				if (i == 0) {
 					break;
 				}
 				name[i] = 0;
 				i = 0;
 				state = CHORD_DIAGRAM_STATE_OPTION_NAME;
 				break;
 			}
 			if (i > 18) {
 				cho_log(ctx, LOG_ERR, "Chord name in chord diagram is too long.");
 				goto ERR;
 			}
 			name[i] = *c;
 			i++;
 			break;
 		}
 		case CHORD_DIAGRAM_STATE_OPTION_NAME: {
 			if (is_whitespace(*c)) {
 				if (i == 0) {
 					break;
 				}
 				option[i] = 0;
 				future_content = CHORD_DIAGRAM_CONTENT_UNINITIALIZED;
 				if (!strcmp(option, "base-fret")) {
 					state = CHORD_DIAGRAM_STATE_BASE_FRET;
 					future_content = CHORD_DIAGRAM_CONTENT_STRING;
 				} else
 				if (!strcmp(option, "frets")) {
 					state = CHORD_DIAGRAM_STATE_FRETS;
 					future_content = CHORD_DIAGRAM_CONTENT_STRING;
 				} else
 				if (!strcmp(option, "fingers")) {
 					state = CHORD_DIAGRAM_STATE_FINGERS;
 					future_content = CHORD_DIAGRAM_CONTENT_STRING;
 				} else
 				if (!strcmp(option, "keys")) {
 					state = CHORD_DIAGRAM_STATE_KEYS;
 					future_content = CHORD_DIAGRAM_CONTENT_KEYBOARD;
 				} else
 				if (!strcmp(option, "diagram")) {
 					state = CHORD_DIAGRAM_STATE_DIAGRAM;
 				} else
 				if (!strcmp(option, "copy")) {
 					state = CHORD_DIAGRAM_STATE_COPY;
 				} else
 				if (!strcmp(option, "display")) {
 					state = CHORD_DIAGRAM_STATE_DISPLAY;
 					future_content = CHORD_DIAGRAM_CONTENT_CHORD_MAP;
 				} else {
 					cho_log(ctx, LOG_ERR, "Invalid option '%s' in define directive.", option);
 					goto ERR;
 				}
 				memset(option, 0, i);
 				i = 0;
 				if (
 					current_content == CHORD_DIAGRAM_CONTENT_UNINITIALIZED &&
 					future_content != CHORD_DIAGRAM_CONTENT_UNINITIALIZED
 				) {
 					current_content = future_content;
 					switch (future_content) {
 					case CHORD_DIAGRAM_CONTENT_STRING:
 						diagram->type = CHORD_DIAGRAM_CONTENT_STRING;
 						diagram->u.sd = string_diagram_new();
 						diagram->u.sd->name = strdup(name);
 						break;
 					case CHORD_DIAGRAM_CONTENT_KEYBOARD:
 						diagram->type = CHORD_DIAGRAM_CONTENT_KEYBOARD;
 						diagram->u.kd = keyboard_diagram_new();
 						diagram->u.kd->name = strdup(name);
 						break;
 					case CHORD_DIAGRAM_CONTENT_CHORD_MAP:
 						diagram->type = CHORD_DIAGRAM_CONTENT_CHORD_MAP;
 						diagram->u.cm = chord_map_new();
 						diagram->u.cm->name = strdup(name);
 						break;
 					default:
 						DEBUG("'future_content' cannot be empty at this point.\n");
 						goto ERR;
 					}
 				}
 				break;
 			}
 			if (i > 8) {
 				cho_log(ctx, LOG_ERR, "Option in chord diagram is too long.");
 				goto ERR;
 			}
 			option[i] = *c;
 			i++;
 			break;
 		}
 		case CHORD_DIAGRAM_STATE_BASE_FRET: {
 			if (is_whitespace(*c)) {
 				if (i == 0) {
 					break;
 				}
 				base_fret[i] = 0;
 				i = 0;
 				l = str_to_number(base_fret);
 				if (l == -1) {
 					DEBUG("str_to_number failed.");
 					cho_log(ctx, LOG_ERR, "Invalid base-fret value '%s' in chord diagram.", base_fret);
 					goto ERR;
 				}
 				if (l == 0) {
 					cho_log(ctx, LOG_ERR, "Invalid base-fret value '%s' in chord diagram.", base_fret);
 					goto ERR;
 				}
 				diagram->u.sd->base_fret = (int8_t)l;
 				state = CHORD_DIAGRAM_STATE_OPTION_NAME;
 				break;
 			}
 			if (i > 1) {
 				cho_log(ctx, LOG_ERR, "base-fret value is too long.");
 				goto ERR;
 			}
 			base_fret[i] = *c;
 			i++;
 			break;
 		}
 		case CHORD_DIAGRAM_STATE_FRETS: {
 			number = -2;
 			if (is_whitespace(*c)) {
 				break;
 			}
 			if (*c == '-') {
 				is_maybe_minus_one = true;
 				break;
 			}
 			if (is_maybe_minus_one) {
 				if (*c == '1') {
 					number = -1;
 					is_maybe_minus_one = false;
 				} else {
 					cho_log(ctx, LOG_ERR, "Invalid frets value '-%c' in chord diagram.", *c);
 					goto ERR;
 				}
 			}
 			if (*c == 'N' || *c == 'x') {
 				number = -1;
 			} else
 			if (isalpha(*c)) {
 				f = 0;
 				state = CHORD_DIAGRAM_STATE_OPTION_NAME;
 				c--;
 				break;
 			}
 			if (number == -2) {
 				number = char_to_positive_int(*c);
 				if (number == -1) {
 					DEBUG("char_to_positive_int failed.");
 					cho_log(ctx, LOG_ERR, "Invalid frets value '%c' in chord diagram.", *c);
 					goto ERR;
 				}
 			}
 			if (f > 11) {
 				cho_log(ctx, LOG_ERR, "Too many fret values in chord diagram.");
 				goto ERR;
 			}
 			diagram->u.sd->frets[f] = number;
 			f++;
 			fret_count++;
 			break;
 		}
 		case CHORD_DIAGRAM_STATE_FINGERS: {
 			if (is_whitespace(*c)) {
 				break;
 			}
 			if (*c == 'b' || *c == 'f') {
 				f = 0;
 				state = CHORD_DIAGRAM_STATE_OPTION_NAME;
 				c--;
 				break;
 			}
 			number = finger_to_int(*c);
 			if (number == -2) {
 				cho_log(ctx, LOG_ERR, "Invalid fingers value '%c' in chord diagram.", *c);
 				goto ERR;
 			}
 			if (f > 11) {
 				cho_log(ctx, LOG_ERR, "Too many finger values in chord diagram.");
 				goto ERR;
 			}
 			diagram->u.sd->fingers[f] = number;
 			f++;
 			finger_count++;
 			break;
 		}
 		case CHORD_DIAGRAM_STATE_KEYS: {
 			if (is_whitespace(*c)) {
 				if (i == 0) {
 					break;
 				}
 				key[i] = 0;
 				i = 0;
 				l = str_to_number(key);
 				if (l == -1) {
 					DEBUG("str_to_number failed.");
 					cho_log(ctx, LOG_ERR, "Invalid number in keys in chord diagram.");
 					goto ERR;
 				}
 				if (f > 23) {
 					cho_log(ctx, LOG_ERR, "Too many key values in chord diagram.");
 					goto ERR;
 				}
 				diagram->u.kd->keys[f] = (int8_t)l;
 				f++;
 				break;
 			}
 			if (isalpha(*c)) {
 				state = CHORD_DIAGRAM_STATE_OPTION_NAME;
 				c--;
 				break;
 			}
 			if (i > 1) {
 				cho_log(ctx, LOG_ERR, "Too high key value in chord diagram. '%d'", i);
 				goto ERR;
 			}
 			key[i] = *c;
 			i++;
 			break;
 		}
 		case CHORD_DIAGRAM_STATE_DIAGRAM: {
 			if (is_whitespace(*c)) {
 				if (i == 0) {
 					break;
 				}
 				diagram_value[i] = 0;
 				i = 0;
 				if (!strcmp(diagram_value, "off")) {
 					diagram->show = false;
 				} else
 				if (!strcmp(diagram_value, "on")) {
 					// INFO: but this is already the default
 					diagram->show = true;
 				} else {
 					diagram->color = cho_color_parse(diagram_value);
 					if (!diagram->color) {
 						DEBUG("cho_color_parse failed.");
 						goto ERR;
 					}
 				}
 				state = CHORD_DIAGRAM_STATE_OPTION_NAME;
 				break;
 			}
 			diagram_value[i] = *c;
 			i++;
 			break;
 		}
 		case CHORD_DIAGRAM_STATE_COPY: {
 			if (is_whitespace(*c)) {
 				if (i == 0) {
 					break;
 				}
 				chord_to_copy[i] = 0;
 				if (current_content != CHORD_DIAGRAM_CONTENT_UNINITIALIZED) {
 					cho_log(ctx, LOG_ERR, "The define options 'base-fret', 'frets', 'fingers' and 'keys' are not allowed before the 'copy' option.");
 					goto ERR;
 				}
 				enum Instrument ins = ctx->config->output->diagram->instrument;
 				current_content = chord_diagram_duplicate(diagram, custom_diagrams, custom_diagrams_len, name, chord_to_copy, ins);
 				if (current_content == CHORD_DIAGRAM_CONTENT_UNINITIALIZED) {
 					cho_log(ctx, LOG_ERR, "Can't copy the diagram for the chord '%s'"
 							"because no previous definition was found and also"
 							"no predefined chord diagram for the instrument '%s'"
 							"was found.", chord_to_copy, instruments[ins].name);
 					goto ERR;
 				}
 				i = 0;
 				state = CHORD_DIAGRAM_STATE_OPTION_NAME;
 				break;
 			}
 			chord_to_copy[i] = *c;
 			i++;
 			break;
 		}
 		case CHORD_DIAGRAM_STATE_DISPLAY: {
 			if (is_whitespace(*c)) {
 				display[i] = 0;
 				i = 0;
 				diagram->u.cm->display = strdup(display);
 				break;
 			}
 			display[i] = *c;
 			i++;
 			break;
 		}
 		}
 	}
 	switch (state) {
 	case CHORD_DIAGRAM_STATE_BASE_FRET: {
 		base_fret[i] = 0;
 		i = 0;
 		l = str_to_number(base_fret);
 		if (l == -1) {
 			DEBUG("str_to_number failed.");
 			cho_log(ctx, LOG_ERR, "Invalid base-fret value '%s' in chord diagram.", base_fret);
 			goto ERR;
 		}
 		if (l == 0) {
 			cho_log(ctx, LOG_ERR, "Invalid base-fret value '%s' in chord diagram.", base_fret);
 			goto ERR;
 		}
 		diagram->u.sd->base_fret = (int8_t)l;
 		break;
 	}
 	case CHORD_DIAGRAM_STATE_KEYS: {
 		key[i] = 0;
 		if (strlen(key) > 0) {
 			l = str_to_number(key);
 			if (l == -1) {
 				DEBUG("str_to_number failed.");
 				cho_log(ctx, LOG_ERR, "Invalid number in keys in chord diagram.");
 				goto ERR;
 			}
 			if (f > 23) {
 				cho_log(ctx, LOG_ERR, "Too many key values in chord diagram.");
 				goto ERR;
 			}
 			diagram->u.kd->keys[f] = (int8_t)l;
 		}
 		break;
 	}
 	case CHORD_DIAGRAM_STATE_DIAGRAM: {
 		diagram_value[i] = 0;
 		if (!strcmp(diagram_value, "off")) {
 			diagram->show = false;
 		} else
 		if (!strcmp(diagram_value, "on")) {
 			// INFO: but this is already the default
 			diagram->show = true;
 		} else {
 			free(diagram->color);
 			diagram->color = cho_color_parse(diagram_value);
 			if (!diagram->color) {
 				DEBUG("cho_color_parse failed.");
 				goto ERR;
 			}
 		}
 		break;
 	}
 	case CHORD_DIAGRAM_STATE_COPY: {
 		chord_to_copy[i] = 0;
 		if (current_content != CHORD_DIAGRAM_CONTENT_UNINITIALIZED) {
 			cho_log(ctx, LOG_ERR, "The define options 'base-fret', 'frets',"
 					"'fingers' and 'keys' are not allowed before the 'copy'"
 					"option.");
 			goto ERR;
 		}
 		enum Instrument ins = ctx->config->output->diagram->instrument;
 		current_content = chord_diagram_duplicate(diagram, custom_diagrams, custom_diagrams_len, name, chord_to_copy, ins);
 		if (current_content == CHORD_DIAGRAM_CONTENT_UNINITIALIZED) {
 			cho_log(ctx, LOG_ERR, "Can't copy the diagram for the chord '%s' because"
 					"no previous definition was found and also no predefined"
 					"chord diagram for the instrument '%s' was found.",
 					chord_to_copy, instruments[ins].name);
 			goto ERR;
 		}
 		break;
 	}
 	case CHORD_DIAGRAM_STATE_DISPLAY: {
 		display[i] = 0;
 		diagram->u.cm->display = strdup(display);
 		break;
 	}
 	default:
 	}
 	if (
 		current_content == CHORD_DIAGRAM_CONTENT_STRING &&
 		fret_count > 0 &&
 		finger_count > 0 &&
 		fret_count != finger_count
 	) {
 		cho_log(ctx, LOG_ERR, "The number of frets (%d) and fingers (%d) in the chord diagram must be equal.", fret_count, finger_count);
 		goto ERR;
 	}
 	if (current_content == CHORD_DIAGRAM_CONTENT_UNINITIALIZED) {
 		cho_log(ctx, LOG_ERR, "The chord diagram is invalid.");
 		goto ERR;
 	}
 	return diagram;
 	ERR:
 	chord_diagram_free(diagram);
 	return NULL;
 }
 
 static struct ChoText *
 cho_text_new(struct ChoContext *ctx)
 {
 	struct ChoText *text = emalloc(sizeof(struct ChoText));
 	text->style = cho_style_new_default(ctx);
 	text->text = NULL;
 	return text;
 }
 
 static void
 cho_text_free(struct ChoText *text)
 {
 	if (!text) {
 		return;
 	}
 	cho_style_free(text->style);
 	free(text->text);
 	free(text);
 }
 
 void
 cho_texts_free(struct ChoText **texts)
 {
 	if (!texts) {
 		return;
 	}
 	struct ChoText **t;
 	for (t = texts; *t; t++) {
 		cho_text_free(*t);
 	}
 	free(texts);
 }
 
 static struct ChoText *
 cho_text_copy(struct ChoText *text)
 {
 	struct ChoText *copy = emalloc(sizeof(struct ChoText));
 	copy->style = cho_style_copy(text->style);
 	copy->text = strdup(text->text);
 	return copy;
 }
 
 static void
 cho_text_above_free(struct ChoLineItemAbove *text_above)
 {
 	if (!text_above) {
 		return;
 	}
 	if (text_above->is_chord) {
 		cho_chord_free(text_above->u.chord);
 	} else {
 		cho_text_free(text_above->u.annot);
 	}
 	free(text_above);
 }
 
 static struct ChoLineItemAbove *
 cho_text_above_copy(struct ChoLineItemAbove *text_above)
 {
 	struct ChoLineItemAbove *copy = emalloc(sizeof(struct ChoLineItemAbove));
 	copy->position = text_above->position;
 	copy->is_chord = text_above->is_chord;
 	if (copy->is_chord) {
 		copy->u.chord = cho_chord_copy(text_above->u.chord);
 	} else {
 		copy->u.annot = cho_text_copy(text_above->u.annot);
 	}
 	return copy;
 }
 
 static struct ChoLineItem *
 cho_line_item_new(struct ChoContext *ctx)
 {
 	struct ChoLineItem *item = emalloc(sizeof(struct ChoLineItem));
 	item->is_text = true;
 	item->u.text = cho_text_new(ctx);
 	return item;
 }
 
 static void
 cho_line_item_free(struct ChoLineItem *item)
 {
 	if (!item) {
 		return;
 	}
 	if (item->is_text) {
 		cho_text_free(item->u.text);
 	} else {
 		if (item->u.image) {
 			cho_image_free(item->u.image);
 		}
 	}
 	free(item);
 }
 
 static struct ChoLineItem *
 cho_line_item_copy(struct ChoLineItem *item)
 {
 	struct ChoLineItem *copy = emalloc(sizeof(struct ChoLineItem));
 	if (item->is_text) {
 		copy->is_text = true;
 		copy->u.text = cho_text_copy(item->u.text);
 	} else {
 		copy->is_text = false;
 		copy->u.image = cho_image_copy(item->u.image);
 	}
 	return copy;
 }
 
 static struct ChoLine *
 cho_line_new(void)
 {
 	struct ChoLine *line = emalloc(sizeof(struct ChoLine));
 	line->text_above = NULL;
 	line->items = NULL;
 	line->btype = BREAK_TYPE_LINE;
 	return line;
 }
 
 static void
 cho_line_free(struct ChoLine *line)
 {
 	if (!line) {
 		return;
 	}
 	struct ChoLineItem **it;
 	for (it = line->items; *it; it++) {
 		cho_line_item_free(*it);
 	}
 	struct ChoLineItemAbove **above;
 	for (above = line->text_above; *above; above++) {
 		cho_text_above_free(*above);
 	}
 	free(line->items);
 	free(line->text_above);
 	free(line);
 }
 
 static int
 cho_line_compute_text_above_position(struct ChoLine *line, int ly, int te)
 {
 	if (ly == 0) {
 		return te;
 	}
 	size_t lyrics_len = 0;
 	int i;
 	for (i = ly-1; i >= 0; i--) {
 		if (line->items[i]->is_text) {
 			lyrics_len += strlen(line->items[i]->u.text->text);
 		}
 	}
 	return lyrics_len + te;
 }
 
 static struct ChoSection *
 cho_section_new(void)
 {
 	struct ChoSection *section = emalloc(sizeof(struct ChoSection));
 	section->type = SECTION_TYPE_UNINITIALIZED;
 	section->label = NULL;
 	section->lines = NULL;
 	section->is_closed = false;
 	return section;
 }
 
 static void
 cho_section_free(struct ChoSection *section)
 {
 	if (!section) {
 		return;
 	}
 	if (section->label) {
 		cho_text_free(section->label);
 	}
 	if (section->lines) {
 		struct ChoLine **li;
 		for (li = section->lines; *li; li++) {
 			cho_line_free(*li);
 		}
 		free(section->lines);
 	}
 	free(section);
 }
 
 static struct ChoSection *
 cho_section_copy(struct ChoSection *section)
 {
 	struct ChoSection *copy = emalloc(sizeof(struct ChoSection));
 	copy->type = section->type;
 	if (section->label) {
 		copy->label = cho_text_copy(section->label);
 	} else {
 		copy->label = NULL;
 	}
 	copy->lines = NULL;
 	int li, c, ly;
 	for (li = 0; section->lines[li]; li++) {
 		copy->lines = erealloc(copy->lines, (li+1) * sizeof(struct ChoLine *));
 		copy->lines[li] = cho_line_new();
 		copy->lines[li]->btype = section->lines[li]->btype;
 		for (c = 0; section->lines[li]->text_above[c]; c++) {
 			copy->lines[li]->text_above = erealloc(copy->lines[li]->text_above, (c+1) * sizeof(struct ChoLineItemAbove *));
 			copy->lines[li]->text_above[c] = cho_text_above_copy(section->lines[li]->text_above[c]);
 		}
 		copy->lines[li]->text_above = erealloc(copy->lines[li]->text_above, (c+1) * sizeof(struct ChoLineItemAbove *));
 		copy->lines[li]->text_above[c] = NULL;
 		for (ly = 0; section->lines[li]->items[ly]; ly++) {
 			copy->lines[li]->items = erealloc(copy->lines[li]->items, (ly+1) * sizeof(struct ChoLineItem *));
 			copy->lines[li]->items[ly] = cho_line_item_copy(section->lines[li]->items[ly]);
 		}
 		copy->lines[li]->items = erealloc(copy->lines[li]->items, (ly+1) * sizeof(struct ChoLineItem *));
 		copy->lines[li]->items[ly] = NULL;
 	}
 	copy->lines = erealloc(copy->lines, (li+1) * sizeof(struct ChoLine *));
 	copy->lines[li] = NULL;
 	return copy;
 }
 
 static struct ChoSong *
 cho_song_new(struct ChoContext *ctx)
 {
 	struct ChoSong *song = emalloc(sizeof(struct ChoSong));
 	song->metadata = cho_metadata_load_default(ctx);
 	if (!song->metadata) {
 		DEBUG("cho_metadata_load_default failed.");
 		free(song);
 		return NULL;
 	}
 	song->sections = NULL;
 	song->diagrams = NULL;
 	memset(song->present_text_types, 0, TEXT_TYPE_LENGTH);
 	return song;
 }
 
 int
 cho_song_count(struct ChoSong **songs)
 {
 	int i;
 	for (i = 0; songs[i]; i++);
 	return i;
 }
 
 static const char *
 cho_song_get_title(struct ChoSong *song)
 {
 	struct ChoMetadata **m;
 	for (m = song->metadata; *m; m++) {
 		if (!strcmp((*m)->name, "sorttitle")) {
 			return (*m)->value;
 		}
 	}
 	for (m = song->metadata; *m; m++) {
 		if (!strcmp((*m)->name, "title")) {
 			return (*m)->value;
 		}
 	}
 	return NULL;
 }
 
 int
 cho_song_compare(const void *a, const void *b)
 {
 	struct ChoSong *song;
 	const char *a_title, *b_title;
 
 	song = *(struct ChoSong **)a;
 	a_title = cho_song_get_title(song);
 	song = *(struct ChoSong **)b;
 	b_title = cho_song_get_title(song);
 	return str_compare(a_title, b_title);
 }
 
 static void
 cho_song_free(struct ChoSong *song)
 {
 	if (!song) {
 		return;
 	}
 	struct ChoMetadata **m;
 	struct ChoSection **se;
 	struct ChordDiagram **dia;
 	for (m = song->metadata; *m; m++) {
 		cho_metadata_free(*m);
 	}
 	for (se = song->sections; *se; se++) {
 		cho_section_free(*se);
 	}
 	for (dia = song->diagrams; *dia; dia++) {
 		chord_diagram_free(*dia);
 	}
 	free(song->metadata);
 	free(song->sections);
 	free(song->diagrams);
 	free(song);
 }
 
 void
 cho_songs_free(struct ChoSong **songs)
 {
 	if (!songs) {
 		return;
 	}
 	struct ChoSong **so;
 	for (so = songs; *so; so++) {
 		cho_song_free(*so);
 	}
 	free(songs);
 }
 
 static struct ChoSection *
 cho_find_previous_chorus(struct ChoSection **sections, int se)
 {
 	int i;
 	for (i = se; i>=0; i--) {
 		if (sections[i]->type == SECTION_TYPE_CHORUS) {
 			return sections[i];
 		}
 	}
 	return NULL;
 }
 
 static struct ChoDirective *
 cho_directive_new(struct ChoContext *ctx)
 {
 	struct ChoDirective *directive = emalloc(sizeof(struct ChoDirective));
 	directive->stype = SECTION_TYPE_UNINITIALIZED;
 	directive->style = cho_style_new_default(ctx);
 	return directive;
 }
 
 static void
 cho_directive_free(struct ChoDirective *directive)
 {
 	if (!directive) {
 		return;
 	}
 	cho_style_free(directive->style);
 	free(directive);
 }
 
 static struct ChoDirective *
 cho_directive_parse(struct ChoContext *ctx, const char *name)
 {
 	struct ChoDirective *directive = cho_directive_new(ctx);
 	if (
 		!strcmp(name, "start_of_chorus") ||
 		!strcmp(name, "soc")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_START;
 		directive->stype = SECTION_TYPE_CHORUS;
 		directive->ttype = TEXT_TYPE_CHORUS;
 	} else
 	if (
 		!strcmp(name, "end_of_chorus") ||
 		!strcmp(name, "eoc")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_END;
 		directive->stype = SECTION_TYPE_CHORUS;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (!strcmp(name, "chorus")) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_NO;
 		directive->ttype = TEXT_TYPE_LABEL;
 	} else
 	if (
 		!strcmp(name, "start_of_verse") ||
 		!strcmp(name, "sov")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_START;
 		directive->stype = SECTION_TYPE_VERSE;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (
 		!strcmp(name, "end_of_verse") ||
 		!strcmp(name, "eov")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_END;
 		directive->stype = SECTION_TYPE_VERSE;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (
 		!strcmp(name, "start_of_bridge") ||
 		!strcmp(name, "sob")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_START;
 		directive->stype = SECTION_TYPE_BRIDGE;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (
 		!strcmp(name, "end_of_bridge") ||
 		!strcmp(name, "eob")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_END;
 		directive->stype = SECTION_TYPE_BRIDGE;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (
 		!strcmp(name, "start_of_tab") ||
 		!strcmp(name, "sot")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_START;
 		directive->stype = SECTION_TYPE_TAB;
 		directive->ttype = TEXT_TYPE_TAB;
 	} else
 	if (
 		!strcmp(name, "end_of_tab") ||
 		!strcmp(name, "eot")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_END;
 		directive->stype = SECTION_TYPE_TAB;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (
 		!strcmp(name, "start_of_grid") ||
 		!strcmp(name, "sog")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_START;
 		directive->stype = SECTION_TYPE_GRID;
 		directive->ttype = TEXT_TYPE_GRID;
 	} else
 	if (
 		!strcmp(name, "end_of_grid") ||
 		!strcmp(name, "eog")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_END;
 		directive->stype = SECTION_TYPE_GRID;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (
 		!strcmp(name, "title") ||
 		!strcmp(name, "t")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_METADATA;
 		directive->meta = METADATA_DIRECTIVE_TITLE;
 		cho_style_free(directive->style);
 		ctx->prev_ttype = ctx->current_ttype;
 		ctx->current_ttype = TEXT_TYPE_TITLE;
 		directive->style = cho_style_new_default(ctx);
 		ctx->current_ttype = ctx->prev_ttype;
 
 	} else
 	if (
 		!strcmp(name, "subtitle") ||
 		!strcmp(name, "st")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_METADATA;
 		directive->meta = METADATA_DIRECTIVE_SUBTITLE;
 		cho_style_free(directive->style);
 		ctx->prev_ttype = ctx->current_ttype;
 		ctx->current_ttype = TEXT_TYPE_SUBTITLE;
 		directive->style = cho_style_new_default(ctx);
 		ctx->current_ttype = ctx->prev_ttype;
 	} else
 	if (
 		!strcmp(name, "sorttitle") ||
 		!strcmp(name, "artist") ||
 		!strcmp(name, "composer") ||
 		!strcmp(name, "lyricist") ||
 		!strcmp(name, "copyright") ||
 		!strcmp(name, "album") ||
 		!strcmp(name, "year") ||
 		!strcmp(name, "key") ||
 		!strcmp(name, "time") ||
 		!strcmp(name, "tempo") ||
 		!strcmp(name, "duration") ||
 		!strcmp(name, "capo") ||
 		!strcmp(name, "meta") ||
 		!strcmp(name, "arranger")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_METADATA;
 		directive->meta = METADATA_DIRECTIVE_OTHER;
 	} else
 	if (
 		!strcmp(name, "comment") ||
 		!strcmp(name, "c") ||
 		!strcmp(name, "highlight")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_FORMATTING;
 		ctx->prev_ttype = ctx->current_ttype;
 		ctx->current_ttype = TEXT_TYPE_COMMENT;
 		cho_style_free(directive->style);
 		directive->style = cho_style_new_default(ctx);
 		ctx->current_ttype = ctx->prev_ttype;
 		directive->ttype = TEXT_TYPE_COMMENT;
 	} else
 	if (
 		!strcmp(name, "comment_italic") ||
 		!strcmp(name, "ci")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_FORMATTING;
 		ctx->prev_ttype = ctx->current_ttype;
 		ctx->current_ttype = TEXT_TYPE_COMMENT_ITALIC;
 		cho_style_free(directive->style);
 		directive->style = cho_style_new_default(ctx);
 		ctx->current_ttype = ctx->prev_ttype;
 		directive->ttype = TEXT_TYPE_COMMENT_ITALIC;
 	} else
 	if (
 		!strcmp(name, "comment_box") ||
 		!strcmp(name, "cb")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_FORMATTING;
 		ctx->prev_ttype = ctx->current_ttype;
 		ctx->current_ttype = TEXT_TYPE_COMMENT_BOX;
 		cho_style_free(directive->style);
 		directive->style = cho_style_new_default(ctx);
 		ctx->current_ttype = ctx->prev_ttype;
 		directive->ttype = TEXT_TYPE_COMMENT_BOX;
 	} else
 	if (!strcmp(name, "image")) {
 		directive->dtype = DIRECTIVE_TYPE_IMAGE;
 	} else
 	if (
 		!strcmp(name, "new_song") ||
 		!strcmp(name, "ns")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_PREAMBLE;
 		directive->stype = SECTION_TYPE_NEWSONG;
 	} else
 	if (
 		!strcmp(name, "chordfont") ||
 		!strcmp(name, "cf")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_FONT;
 		directive->ttype = TEXT_TYPE_CHORD;
 	} else
 	if (
 		!strcmp(name, "chordsize") ||
 		!strcmp(name, "cs")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_SIZE;
 		directive->ttype = TEXT_TYPE_CHORD;
 	} else
 	if (!strcmp(name, "chordcolour")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_COLOR;
 		directive->ttype = TEXT_TYPE_CHORD;
 	} else
 	if (!strcmp(name, "chorusfont")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_FONT;
 		directive->ttype = TEXT_TYPE_CHORUS;
 	} else
 	if (!strcmp(name, "chorussize")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_SIZE;
 		directive->ttype = TEXT_TYPE_CHORUS;
 	} else
 	if (!strcmp(name, "choruscolour")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_COLOR;
 		directive->ttype = TEXT_TYPE_CHORUS;
 	} else
 	if (!strcmp(name, "gridfont")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_FONT;
 		directive->ttype = TEXT_TYPE_GRID;
 	} else
 	if (!strcmp(name, "gridsize")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_SIZE;
 		directive->ttype = TEXT_TYPE_GRID;
 	} else
 	if (!strcmp(name, "gridcolour")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_COLOR;
 		directive->ttype = TEXT_TYPE_GRID;
 	} else
 	if (!strcmp(name, "tabfont")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_FONT;
 		directive->ttype = TEXT_TYPE_TAB;
 	} else
 	if (!strcmp(name, "tabsize")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_SIZE;
 		directive->ttype = TEXT_TYPE_TAB;
 	} else
 	if (!strcmp(name, "tabcolour")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_COLOR;
 		directive->ttype = TEXT_TYPE_TAB;
 	} else
 	if (
 		!strcmp(name, "textfont") ||
 		!strcmp(name, "tf")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_FONT;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (
 		!strcmp(name, "textsize") ||
 		!strcmp(name, "ts")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_SIZE;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (!strcmp(name, "textcolour")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_COLOR;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (!strcmp(name, "titlefont")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_FONT;
 		directive->ttype = TEXT_TYPE_TITLE;
 	} else
 	if (!strcmp(name, "titlesize")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_SIZE;
 		directive->ttype = TEXT_TYPE_TITLE;
 	} else
 	if (!strcmp(name, "titlecolour")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_COLOR;
 		directive->ttype = TEXT_TYPE_TITLE;
 	} else
 	if (!strcmp(name, "tocfont")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_FONT;
 		directive->ttype = TEXT_TYPE_TOC;
 	} else
 	if (!strcmp(name, "tocsize")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_SIZE;
 		directive->ttype = TEXT_TYPE_TOC;
 	} else
 	if (!strcmp(name, "toccolour")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_COLOR;
 		directive->ttype = TEXT_TYPE_TOC;
 	/* } else if (!strcmp(name, "footerfont")) {
 	} else if (!strcmp(name, "footersize")) {
 	} else if (!strcmp(name, "footercolour")) { */
 	} else
 	if (!strcmp(name, "labelfont")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_FONT;
 		directive->ttype = TEXT_TYPE_LABEL;
 	} else
 	if (!strcmp(name, "labelsize")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_SIZE;
 		directive->ttype = TEXT_TYPE_LABEL;
 	} else
 	if (!strcmp(name, "labelcolour")) {
 		directive->dtype = DIRECTIVE_TYPE_FONT;
 		directive->sprop = STYLE_PROPERTY_TYPE_COLOR;
 		directive->ttype = TEXT_TYPE_LABEL;
 	} else
 	if (!strcmp(name, "transpose")) {
 		directive->dtype = DIRECTIVE_TYPE_CHORD;
 		directive->ctype = CHORD_DIRECTIVE_TRANSPOSE;
 	} else
 	if (!strcmp(name, "define")) {
 		directive->dtype = DIRECTIVE_TYPE_CHORD;
 		directive->ctype = CHORD_DIRECTIVE_DEFINE;
 	/* } else if (!strcmp(name, "chord")) { */
 	} else
 	if (
 		!strcmp(name, "new_page") ||
 		!strcmp(name, "np")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_OUTPUT;
 		directive->btype = BREAK_TYPE_PAGE;
 	} else
 	if (
 		!strcmp(name, "column_break") ||
 		!strcmp(name, "colb")
 	) {
 		directive->dtype = DIRECTIVE_TYPE_OUTPUT;
 		directive->btype = BREAK_TYPE_COLUMN;
 	} else
 	if (str_starts_with(name, "start_of_")) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_START;
 		directive->stype = SECTION_TYPE_CUSTOM;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (str_starts_with(name, "end_of_")) {
 		directive->dtype = DIRECTIVE_TYPE_ENVIRONMENT;
 		directive->position = POSITION_END;
 		directive->stype = SECTION_TYPE_CUSTOM;
 		directive->ttype = TEXT_TYPE_TEXT;
 	} else
 	if (str_starts_with(name, "x_")) {
 		directive->dtype = DIRECTIVE_TYPE_EXTENSION;
 	} else {
 		directive->dtype = DIRECTIVE_TYPE_CUSTOM;
 	}
 	return directive;
 }
 
 static struct Attr **
 cho_attrs_parse(struct ChoContext *ctx, const char *str, const char *directive_name)
 {
 	struct Attr **attrs = NULL;
 	int a = 0;
 	enum OptionState state = OPTION_STATE_NAME;
 	enum AttrValueSyntax avs = ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED;
 	char name[5+1];
 	char value[URL_MAX_LEN+1];
 	int n = 0;
 	int v = 0;
 	memset(name, 0, sizeof(name));
 	memset(value, 0, sizeof(value));
 	const char *c;
 	for (c = str; *c; c++) {
 		switch (state) {
 		case OPTION_STATE_NAME:
 			if (is_whitespace(*c)) {
 				if (n == 0) {
 					break;
 				} else {
 					name[n] = 0;
 					cho_log(ctx, LOG_ERR, "Option with name '%s' in environment directive '%s' has no value.", name, directive_name);
 					goto ERR;
 				}
 			}
 			if (*c == '=') {
 				name[n] = 0;
 				state = OPTION_STATE_VALUE;
 				break;
 			}
 			if (n > 4) {
 				cho_log(ctx, LOG_ERR, "Option name in environment directive '%s' is too long.", directive_name);
 				goto ERR;
 			}
 			name[n] = *c;
 			n++;
 			break;
 		case OPTION_STATE_VALUE:
 			if (avs == ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED) {
 				if (is_whitespace(*c)) {
 					cho_log(ctx, LOG_ERR, "Whitespace character after equals sign in environment directive '%s' is invalid.", directive_name);
 					goto ERR;
 				}
 				if (*c == '\'') {
 					avs = ATTRIBUTE_VALUE_SYNTAX_APOSTROPHE;
 				} else if (*c == '"') {
 					avs = ATTRIBUTE_VALUE_SYNTAX_QUOTATION_MARK;
 				} else {
 					avs = ATTRIBUTE_VALUE_SYNTAX_UNQUOTED;
 					value[v] = *c;
 					v++;
 				}
 				break;
 			}
 			if (*c == '\n') {
 				cho_log(ctx, LOG_ERR, "Newline character inside an option value in environment directive '%s' is invalid.", directive_name);
 				goto ERR;
 			}
 			if (
 				(avs == ATTRIBUTE_VALUE_SYNTAX_APOSTROPHE && *c == '\'') ||
 				(avs == ATTRIBUTE_VALUE_SYNTAX_QUOTATION_MARK && *c == '"') ||
 				(avs == ATTRIBUTE_VALUE_SYNTAX_UNQUOTED && (*c == ' ' || *c == '\t'))
 			) {
 				value[v] = 0;
 				attrs = erealloc(attrs, (a+1) * sizeof(struct Attr *));
 				attrs[a] = emalloc(sizeof(struct Attr));
 				attrs[a]->name = strdup(name);
 				attrs[a]->value = strdup(value);
 				a++;
 				memset(name, 0, n);
 				n = 0;
 				memset(value, 0, v);
 				v = 0;
 				avs = ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED;
 				state = OPTION_STATE_NAME;
 				break;
 			}
 			value[v] = *c;
 			v++;
 			break;
 		}
 	}
 	if (avs == ATTRIBUTE_VALUE_SYNTAX_UNQUOTED) {
 		value[v] = 0;
 		attrs = erealloc(attrs, (a+1) * sizeof(struct Attr *));
 		attrs[a] = emalloc(sizeof(struct Attr));
 		attrs[a]->name = strdup(name);
 		attrs[a]->value = strdup(value);
 		a++;
 	}
 	attrs = erealloc(attrs, (a+1) * sizeof(struct Attr *));
 	attrs[a] = NULL;
 	return attrs;
 	ERR:
 	for (n = 0; n<a; n++) {
 		cho_tag_attr_free(attrs[n]);
 	}
 	free(attrs);
 	return NULL;
 }
 
 static char *
 cho_attrs_get(struct Attr **attrs, const char *name)
 {
 	struct Attr **a;
 	for (a = attrs; *a; a++) {
 		if (!strcmp((*a)->name, name)) {
 			return (*a)->value;
 		}
 	}
 	return NULL;
 }
 
 /* TODO: Only providing a label name like '{sog: Interlude}' is an error according to how I understand the spec. */
 static bool
 cho_grid_shape_parse_and_set(struct ChoContext *ctx, const char *str)
 {
 	enum {
 		BEFORE_FIRST_PLUS,
 		AFTER_FIRST_PLUS,
 		AFTER_SECOND_PLUS,
 		AFTER_X
 	} state = BEFORE_FIRST_PLUS;
 	const char *c;
 	char tmp[6+1];
 	int t = 0;
 	int measures = 0;
 	int beats = 0;
 	int i;
 	for (c = str; *c; c++) {
 		switch (state) {
 		case BEFORE_FIRST_PLUS:
 			if (*c == '+') {
 				tmp[t] = 0;
 				i = atoi(tmp);
 				if (i == 0) {
 					DEBUG("atoi failed.");
 					return false;
 				}
 				ctx->grid.left = i;
 				memset(tmp, 0, t);
 				t = 0;
 				state = AFTER_FIRST_PLUS;
 				break;
 			}
 			if (*c == 'x') {
 				tmp[t] = 0;
 				i = atoi(tmp);
 				if (i == 0) {
 					DEBUG("atoi failed.");
 					return false;
 				}
 				measures = i;
 				memset(tmp, 0, t);
 				t = 0;
 				state = AFTER_X;
 				break;
 			}
 			if (t > 5) {
 				cho_log(ctx, LOG_ERR, "Failed to parse the grid shape '%s'.", str);
 				return false;
 			}
 			tmp[t] = *c;
 			t++;
 			break;
 		case AFTER_FIRST_PLUS:
 			if (*c == '+') {
 				tmp[t] = 0;
 				i = atoi(tmp);
 				if (i == 0) {
 					DEBUG("atoi failed.");
 					return false;
 				}
 				ctx->grid.cells = i;
 				memset(tmp, 0, t);
 				t = 0;
 				state = AFTER_SECOND_PLUS;
 				break;
 			}
 			if (*c == 'x') {
 				tmp[t] = 0;
 				i = atoi(tmp);
 				if (i == 0) {
 					DEBUG("atoi failed.");
 					return false;
 				}
 				measures = i;
 				memset(tmp, 0, t);
 				t = 0;
 				state = AFTER_X;
 				break;
 			}
 			tmp[t] = *c;
 			t++;
 			break;
 		case AFTER_SECOND_PLUS:
 			tmp[t] = *c;
 			t++;
 			break;
 		case AFTER_X:
 			if (*c == '+') {
 				tmp[t] = 0;
 				i = atoi(tmp);
 				if (i == 0) {
 					DEBUG("atoi failed.");
 					return false;
 				}
 				beats = i;
 				ctx->grid.cells = measures * beats;
 				memset(tmp, 0, t);
 				t = 0;
 				state = AFTER_SECOND_PLUS;
 				break;
 			}
 			tmp[t] = *c;
 			t++;
 			break;
 		}
 	}
 	tmp[t] = 0;
 	i = atoi(tmp);
 	if (i == 0) {
 		DEBUG("atoi failed.");
 		return false;
 	}
 	switch (state) {
 	case BEFORE_FIRST_PLUS:
 		/* fallthrough */
 	case AFTER_FIRST_PLUS:
 		ctx->grid.cells = i;
 		break;
 	case AFTER_SECOND_PLUS:
 		ctx->grid.right = i;
 		break;
 	case AFTER_X:
 		beats = i;
 		ctx->grid.cells = measures * beats;
 		break;
 	}
 	return true;
 }
 
 static enum GridToken
 cho_grid_token_parse(struct ChoContext *ctx, const char *token, bool *err)
 {
 	struct ChoChord *chord;
 
 	*err = false;
 	if (!strcmp(token, ".")) {
 		return GRID_TOKEN_PLACEHOLDER;
 	} else
 	if (!strcmp(token, "/")) {
 		return GRID_TOKEN_PLACEHOLDER;
 	} else
 	if (!strcmp(token, "|")) {
 		return GRID_TOKEN_BAR_LINE_SYMBOL;
 	} else
 	if (!strcmp(token, "||")) {
 		return GRID_TOKEN_BAR_LINE_SYMBOL;
 	} else
 	if (!strcmp(token, "|.")) {
 		return GRID_TOKEN_BAR_LINE_SYMBOL;
 	} else
 	if (!strcmp(token, "|:")) {
 		return GRID_TOKEN_BAR_LINE_SYMBOL;
 	} else
 	if (!strcmp(token, ":|")) {
 		return GRID_TOKEN_BAR_LINE_SYMBOL;
 	} else
 	if (!strcmp(token, ":|:")) {
 		return GRID_TOKEN_BAR_LINE_SYMBOL;
 	} else
 	if (token[0] == '|' && isdigit(token[1])) {
 		return GRID_TOKEN_BAR_LINE_SYMBOL;
 	} else
 	if (!strcmp(token, "|2>")) {
 		return GRID_TOKEN_BAR_LINE_SYMBOL;
 	}
 	chord = cho_chord_parse(ctx, token);
 	if (chord->is_canonical) {
 		cho_chord_free(chord);
 		return GRID_TOKEN_CHORD;
 	}
 	cho_chord_free(chord);
 	*err = true;
 	return GRID_TOKEN_CHORD; // unused
 }
 
 static void
 cho_songs_close(struct ChoContext *ctx, struct ChoLine ***lines)
 {
 	if (!(*lines)[ctx->li]->items[ctx->lii]->u.text->text && !(*lines)[ctx->li]->text_above) {
 		if (ctx->lii == 0) {
 			cho_line_item_free((*lines)[ctx->li]->items[ctx->lii]);
 			free((*lines)[ctx->li]->items);
 			free((*lines)[ctx->li]);
 			(*lines)[ctx->li] = NULL;
 		} else {
 			cho_line_item_free((*lines)[ctx->li]->items[ctx->lii]);
 			(*lines)[ctx->li]->items[ctx->lii] = NULL;
 			(*lines)[ctx->li]->text_above = erealloc((*lines)[ctx->li]->text_above, (ctx->lia+1) * sizeof(struct ChoLineItemAbove *));
 			(*lines)[ctx->li]->text_above[ctx->lia] = NULL;
 			ctx->li++;
 			*lines = erealloc(*lines, (ctx->li+1) * sizeof(struct ChoLine *));
 			(*lines)[ctx->li] = NULL;
 		}
 	} else {
 		(*lines)[ctx->li]->items[ctx->lii]->u.text->text = erealloc((*lines)[ctx->li]->items[ctx->lii]->u.text->text, (ctx->te+1) * sizeof(char));
 		(*lines)[ctx->li]->items[ctx->lii]->u.text->text[ctx->te] = 0;
 		ctx->lii++;
 		(*lines)[ctx->li]->items = erealloc((*lines)[ctx->li]->items, (ctx->lii+1) * sizeof(struct ChoLineItem *));
 		(*lines)[ctx->li]->items[ctx->lii] = NULL;
 		(*lines)[ctx->li]->text_above = erealloc((*lines)[ctx->li]->text_above, (ctx->lia+1) * sizeof(struct ChoLineItemAbove *));
 		(*lines)[ctx->li]->text_above[ctx->lia] = NULL;
 		ctx->li++;
 		*lines = erealloc(*lines, (ctx->li+1) * sizeof(struct ChoLine *));
 		(*lines)[ctx->li] = NULL;
 	}
 	ctx->songs[ctx->so]->metadata = erealloc(ctx->songs[ctx->so]->metadata, (ctx->m+1) * sizeof(struct ChoMetadata *));
 	ctx->songs[ctx->so]->metadata[ctx->m] = NULL;
 	ctx->se++;
 	ctx->songs[ctx->so]->sections = erealloc(ctx->songs[ctx->so]->sections, (ctx->se+1) * sizeof(struct ChoSection *));
 	ctx->songs[ctx->so]->sections[ctx->se] = NULL;
 	ctx->songs[ctx->so]->diagrams = erealloc(ctx->songs[ctx->so]->diagrams, (ctx->dia+1) * sizeof(struct ChordDiagram *));
 	ctx->songs[ctx->so]->diagrams[ctx->dia] = NULL;
 	ctx->so++;
 	ctx->songs = erealloc(ctx->songs, (ctx->so+1) * sizeof(struct ChoSong *));
 	ctx->songs[ctx->so] = NULL;
 }
 
 static bool
 cho_context_init(
 	struct ChoContext *ctx,
 	struct Config *config,
 	const char *chordpro_filepath
 )
 {
 	ctx->is_chord_already_initialized = false;
 	ctx->is_maybe_end_of_tab_directive = false;
 	ctx->directive_has_tag = false;
 	ctx->chordpro_filepath = chordpro_filepath;
 	ctx->state = STATE_LYRICS;
 	ctx->state_before_comment = STATE_LYRICS;
 	ctx->state_before_tag = STATE_LYRICS;
 	ctx->state_before_backslash = STATE_LYRICS;
 	ctx->state_before_metadata_substitution = STATE_LYRICS;
 	ctx->current_ttype = TEXT_TYPE_TEXT;
 	ctx->prev_ttype = TEXT_TYPE_TEXT;
 	ctx->ann = 0;
 	ctx->at = 0;
 	ctx->atn = 0;
 	ctx->atv = 0;
 	ctx->ch = 0;
 	ctx->dia = 0;
 	ctx->dn = 0;
 	ctx->dv = 0;
 	ctx->gt = 0;
 	ctx->ia = 0;
 	ctx->li = 0;
 	ctx->lia = 0;
 	ctx->lii = 0;
 	ctx->m = 0;
 	ctx->ms = 0;
 	ctx->se = 0;
 	ctx->so = 0;
 	ctx->t = 0;
 	ctx->ta = -1;
 	ctx->te = 0;
 	ctx->th = 0;
 	ctx->nested_level = 0;
 	ctx->line_no = 1;
 	ctx->tags = NULL;
 	ctx->image_assets = NULL;
 	ctx->grid.cells = 8;
 	ctx->grid.left = 1;
 	ctx->grid.right = 1;
 	ctx->grid.bar_line_symbol_count = 0;
 	ctx->grid.bar_line_symbol_in_line_count = 0;
 	ctx->grid.tokens_per_cell = 0;
 	ctx->grid.expected_tokens_per_cell = 0;
 	ctx->config = config;
 	ctx->songs = emalloc(sizeof(struct ChoSong *));
 	ctx->songs[ctx->so] = cho_song_new(ctx);
 	if (!ctx->songs[ctx->so]) {
 		DEBUG("cho_song_new failed.");
 		free(ctx->songs);
 		return false;
 	}
 	ctx->transpose_history = emalloc((ctx->th+1) * sizeof(int *));
 	ctx->transpose_history[ctx->th] = 0;
 	ctx->transpose = &ctx->transpose_history[ctx->th];
 	ctx->th++;
 	ctx->songs[ctx->so]->sections = emalloc((ctx->se+1) * sizeof(struct ChoSection *));
 	ctx->songs[ctx->so]->sections[ctx->se] = cho_section_new();
 	// INFO: The first section has no start and end directive
 	ctx->songs[ctx->so]->sections[ctx->se]->is_closed = true;
 	ctx->songs[ctx->so]->sections[ctx->se]->lines = emalloc(sizeof(struct ChoLine *));
 	ctx->songs[ctx->so]->sections[ctx->se]->lines[ctx->li] = cho_line_new();
 	return true;
 }
 
 static void
 cho_context_cleanup(struct ChoContext *ctx)
 {
 	int i;
 
 	for (i = 0; i<=ctx->ta; i++) {
 		cho_tag_free(ctx->tags[i]);
 	}
 	free(ctx->tags);
 	free(ctx->transpose_history);
 	for (i = 0; i<ctx->ia; i++) {
 		cho_image_free(ctx->image_assets[i]);
 	}
 	free(ctx->image_assets);
 }
 
 static bool
 is_previous_section_closed(struct ChoContext *ctx)
 {
 	int i;
 
 	for (i = ctx->se; i>=0; i--) {
 		if (ctx->songs[ctx->so]->sections[i]->type == SECTION_TYPE_UNINITIALIZED) {
 			continue;
 		}
 		return ctx->songs[ctx->so]->sections[i]->is_closed ? true : false;
 	}
 	return true;
 }
 
 struct ChoSong **
 cho_songs_parse(const char *str, const char *chordpro_filepath, struct Config *config)
 {
 	enum AttrValueSyntax avs = ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED;
 	enum GridToken token;
 	struct Attr **directive_attrs = NULL;
 	struct ChoStyle *tag_style;
 	struct StyleProperty sprop;
 	struct ChoChord *tmp_chord;
 	struct ChoSection *chorus;
 	struct ChoImage *image;
 	struct ChordDiagram *diagram;
 	struct ChoDirective *directive = NULL;
 	struct ChoMetadata *metadata = NULL;
 	struct ChoLine ***lines;
 	struct ChoContext ctx;
 	bool err;
 	char *metadata_value, *shape;
 	char *stripped_directive_value = NULL;
 	char *label = NULL;
 	char directive_name[128];
 	char directive_value[4096];
 	char chord[CHORD_LEN];
 	char tag_start[6];
 	char tag_end[6];
 	char custom_directive[64];
 	char metadata_substitution[4096];
 	char grid_token[CHORD_LEN];
 	char c = 0;
 	char prev_c = '\n';
 	int transpose;
 
 	if (!cho_context_init(&ctx, config, chordpro_filepath)) {
 		DEBUG("cho_context_init failed.");
 		return NULL;
 	}
 
 	lines = &ctx.songs[ctx.so]->sections[ctx.se]->lines;
 	(*lines)[ctx.li]->items = emalloc(sizeof(struct ChoLineItem *));
 	(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 	ctx.songs[ctx.so]->present_text_types[TEXT_TYPE_TOC] = config->output->toc->show;
 	for (; *str; str++) {
 		c = *str;
 		// printf("state: %s, c: %c\n", state_enums[ctx.state], c);
 		if (c == '\r') {
 			continue;
 		}
 		switch (ctx.state) {
 		case STATE_LYRICS: {
 			if (prev_c == '\n' && c == '#') {
 				ctx.state_before_comment = STATE_LYRICS;
 				ctx.state = STATE_COMMENT;
 				break;
 			}
 			if (prev_c == '\n' && c == '{') {
 				ctx.state = STATE_DIRECTIVE_NAME;
 				break;
 			}
 			if (c == '[') {
 				ctx.state = STATE_CHORD;
 				break;
 			}
 			if (c == '<') {
 				if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 					if (strlen((*lines)[ctx.li]->items[ctx.lii]->u.text->text) == 0) {
 						cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 					} else {
 						ctx.lii++;
 					}
 				} else {
 					ctx.lii++;
 				}
 				ctx.te = 0;
 				(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 				(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 				ctx.state_before_tag = STATE_LYRICS;
 				ctx.state = STATE_MARKUP_TAG;
 				break;
 			}
 			if (c == '%') {
 				ctx.state_before_metadata_substitution = STATE_LYRICS;
 				ctx.state = STATE_MAYBE_METADATA_SUBSTITUTION;
 				break;
 			}
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c == '\\') {
 					ctx.state_before_backslash = STATE_LYRICS;
 					ctx.state = STATE_BACKSLASH;
 					ctx.te--; // INFO: This will later overwrite the backslash
 					break;
 				}
 				if (ctx.ta > -1 && !ctx.tags[ctx.ta]->is_closed && strcmp(ctx.tags[ctx.ta]->name, "img")) {
 					cho_log(&ctx, LOG_ERR, "Tag has to be closed on same line.");
 					DEBUG("Tag has to be closed on same line.");
 					goto ERR;
 				}
 				if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 					if (strlen((*lines)[ctx.li]->items[ctx.lii]->u.text->text) == 0) {
 						cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 						if (ctx.lii == 0) {
 							if (
 								!(*lines)[ctx.li]->text_above &&
 								(*lines)[ctx.li]->btype == BREAK_TYPE_LINE
 							) {
 								free((*lines)[ctx.li]->items);
 								free((*lines)[ctx.li]);
 								*lines = erealloc(*lines, (ctx.li+1) * sizeof(struct ChoLine *));
 								(*lines)[ctx.li] = cho_line_new();
 								(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 								(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 								break;
 							}
 						}
 					} else {
 						ctx.lii++;
 					}
 				} else {
 					ctx.lii++;
 				}
 				(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 				(*lines)[ctx.li]->items[ctx.lii] = NULL;
 				ctx.lii = 0;
 				ctx.te = 0;
 				(*lines)[ctx.li]->text_above = erealloc((*lines)[ctx.li]->text_above, (ctx.lia+1) * sizeof(struct ChoLineItemAbove *));
 				(*lines)[ctx.li]->text_above[ctx.lia] = NULL;
 				ctx.lia = 0;
 				ctx.li++;
 				*lines = erealloc(*lines, (ctx.li+1) * sizeof(struct ChoLine *));
 				(*lines)[ctx.li] = cho_line_new();
 				(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 				(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 				break;
 			}
 			(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 			(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = c;
 			ctx.te++;
 			break;
 		}
 		case STATE_BACKSLASH: {
 			if (!is_whitespace(c)) {
 				str--;
 				ctx.state = ctx.state_before_backslash;
 				break;
 			}
 			break;
 		}
 		case STATE_DIRECTIVE_NAME: {
 			if (c == '}') {
 				directive_name[ctx.dn] = 0;
 				ctx.dn = 0;
 				directive = cho_directive_parse(&ctx, directive_name);
 				/* printf(
 					"directive: '%s'\ndtype: %s, stype: %s, position: %s\n",
 					directive_name, cho_debug_dtype(directive->dtype), cho_debug_the_stype(directive->stype), cho_debug_the_pos(directive->position)
 				); */
 				switch (directive->dtype) {
 				case DIRECTIVE_TYPE_ENVIRONMENT: {
 					ctx.current_ttype = directive->ttype;
 					switch (directive->position) {
 					case POSITION_START: {
 						if (!is_previous_section_closed(&ctx)) {
 							cho_log(&ctx, LOG_ERR, "Can't start a new section when the previous one is not yet closed.");
 							goto ERR;
 						}
 						if (directive->stype == SECTION_TYPE_CUSTOM) {
 							memset(custom_directive, 0, sizeof(custom_directive));
 							strcpy(custom_directive, &directive_name[9]);
 						}
 						cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 						free((*lines)[ctx.li]->items);
 						ctx.lii = 0;
 						free((*lines)[ctx.li]);
 						(*lines)[ctx.li] = NULL;
 						ctx.se++;
 						ctx.songs[ctx.so]->sections = erealloc(ctx.songs[ctx.so]->sections, (ctx.se+1) * sizeof(struct ChoSection *));
 						ctx.songs[ctx.so]->sections[ctx.se] = cho_section_new();
 						ctx.songs[ctx.so]->sections[ctx.se]->type = directive->stype;
 						ctx.li = 0;
 						lines = &ctx.songs[ctx.so]->sections[ctx.se]->lines;
 						*lines = emalloc(sizeof(struct ChoLine *));
 						(*lines)[ctx.li] = cho_line_new();
 						(*lines)[ctx.li]->items = emalloc(sizeof(struct ChoLineItem *));
 						(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 						ctx.songs[ctx.so]->present_text_types[directive->ttype] = true;
 						switch (directive->stype) {
 						case SECTION_TYPE_TAB:
 							ctx.state = STATE_TAB;
 							break;
 						case SECTION_TYPE_GRID:
 							ctx.state = STATE_GRID;
 							break;
 						default:
 							ctx.state = STATE_LYRICS;
 						}
 						break;
 					}
 					case POSITION_END: {
 						if (directive->stype == ctx.songs[ctx.so]->sections[ctx.se]->type) {
 							if (directive->stype == SECTION_TYPE_CUSTOM) {
 								if (strcmp(custom_directive, &directive_name[7]) != 0) {
 									break;
 								}
 							}
 							if (directive->stype == SECTION_TYPE_GRID) {
 								ctx.grid.bar_line_symbol_count = 0;
 								ctx.grid.tokens_per_cell = 0;
 								ctx.grid.expected_tokens_per_cell = 0;
 							}
 							cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 							free((*lines)[ctx.li]->items);
 							ctx.lii = 0;
 							free((*lines)[ctx.li]);
 							(*lines)[ctx.li] = NULL;
 							ctx.songs[ctx.so]->sections[ctx.se]->is_closed = true;
 							ctx.se++;
 							ctx.songs[ctx.so]->sections = erealloc(ctx.songs[ctx.so]->sections, (ctx.se+1) * sizeof(struct ChoSection *));
 							ctx.songs[ctx.so]->sections[ctx.se] = cho_section_new();
 							ctx.li = 0;
 							lines = &ctx.songs[ctx.so]->sections[ctx.se]->lines;
 							*lines = emalloc(sizeof(struct ChoLine *));
 							(*lines)[ctx.li] = cho_line_new();
 							(*lines)[ctx.li]->items = emalloc(sizeof(struct ChoLineItem *));
 							(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 							ctx.state = STATE_LYRICS;
 						} else {
 							cho_log(&ctx, LOG_ERR, "Can't close a %s section that wasn't opened earlier.", section_types[directive->stype]);
 							goto ERR;
 						}
 						break;
 					}
 					case POSITION_NO: {
 						/* INFO: {chorus} */
 						chorus = cho_find_previous_chorus(ctx.songs[ctx.so]->sections, ctx.se);
 						if (chorus) {
 							if (config->output->chorus->quote) {
 								if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 									(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 									(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 								}
 								ctx.lii++;
 								(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 								(*lines)[ctx.li]->items[ctx.lii] = NULL;
 								ctx.lii = 0;
 								ctx.te = 0;
 								(*lines)[ctx.li]->text_above = erealloc((*lines)[ctx.li]->text_above, (ctx.lia+1) * sizeof(struct ChoLineItemAbove *));
 								(*lines)[ctx.li]->text_above[ctx.lia] = NULL;
 								ctx.lia = 0;
 								cho_line_free((*lines)[ctx.li]);
 								(*lines)[ctx.li] = NULL;
 								ctx.li = 0;
 								ctx.se++;
 								ctx.songs[ctx.so]->sections = erealloc(ctx.songs[ctx.so]->sections, (ctx.se+1) * sizeof(struct ChoSection *));
 								ctx.songs[ctx.so]->sections[ctx.se] = cho_section_copy(chorus);
 								ctx.se++;
 								ctx.songs[ctx.so]->sections = erealloc(ctx.songs[ctx.so]->sections, (ctx.se+1) * sizeof(struct ChoSection *));
 								ctx.songs[ctx.so]->sections[ctx.se] = cho_section_new();
 								lines = &ctx.songs[ctx.so]->sections[ctx.se]->lines;
 								*lines = emalloc(sizeof(struct ChoLine *));
 								(*lines)[ctx.li] = cho_line_new();
 								(*lines)[ctx.li]->items = emalloc(sizeof(struct ChoLineItem *));
 								(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 							} else {
 								if (chorus->label) {
 									label = strdup(chorus->label->text);
 								} else {
 									label = strdup(config->output->chorus->label);
 								}
 								if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 									(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 									(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 									if (strlen((*lines)[ctx.li]->items[ctx.lii]->u.text->text) == 0) {
 										cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 									} else {
 										ctx.lii++;
 									}
 								} else {
 									ctx.lii++;
 								}
 								(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 								(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 								cho_style_free((*lines)[ctx.li]->items[ctx.lii]->u.text->style);
 								ctx.current_ttype = TEXT_TYPE_LABEL;
 								(*lines)[ctx.li]->items[ctx.lii]->u.text->style = cho_style_new_default(&ctx);
 								(*lines)[ctx.li]->items[ctx.lii]->u.text->text = label;
 								ctx.te += strlen(label);
 							}
 						} else {
 							if (config->output->chorus->quote) {
 								cho_log(&ctx, LOG_WARN, "Can't quote chorus because it's not defined previously.");
 							}
 							label = strdup(config->output->chorus->label);
 							if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 								(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 								(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 								if (strlen((*lines)[ctx.li]->items[ctx.lii]->u.text->text) == 0) {
 									cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 								} else {
 									ctx.lii++;
 								}
 							} else {
 								ctx.lii++;
 							}
 							(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 							(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 							cho_style_free((*lines)[ctx.li]->items[ctx.lii]->u.text->style);
 							ctx.current_ttype = TEXT_TYPE_LABEL;
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->style = cho_style_new_default(&ctx);
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->text = label;
 							ctx.te += strlen(label);
 						}
 						break;
 					}
 					}
 					break;
 				}
 				case DIRECTIVE_TYPE_METADATA:
 					cho_log(&ctx, LOG_WARN, "Ignoring metadata directive '%s' because it has no value.", directive_name);
 					break;
 				case DIRECTIVE_TYPE_FORMATTING:
 					cho_log(&ctx, LOG_WARN, "Formatting directive '%s' has no value.", directive_name);
 					break;
 				case DIRECTIVE_TYPE_IMAGE:
 					cho_log(&ctx, LOG_ERR, "Directive 'image' has no value.");
 					goto ERR;
 				case DIRECTIVE_TYPE_PREAMBLE: {
 					// INFO: The only preamble directive is 'new_song'
 					cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 					free((*lines)[ctx.li]->items);
 					free((*lines)[ctx.li]);
 					(*lines)[ctx.li] = NULL;
 					ctx.songs[ctx.so]->metadata = erealloc(ctx.songs[ctx.so]->metadata, (ctx.m+1) * sizeof(struct ChoMetadata *));
 					ctx.songs[ctx.so]->metadata[ctx.m] = NULL;
 					ctx.se++;
 					ctx.songs[ctx.so]->sections = erealloc(ctx.songs[ctx.so]->sections, (ctx.se+1) * sizeof(struct ChoSection *));
 					ctx.songs[ctx.so]->sections[ctx.se] = NULL;
 					ctx.songs[ctx.so]->diagrams = erealloc(ctx.songs[ctx.so]->diagrams, (ctx.dia+1) * sizeof(struct ChordDiagram *));
 					ctx.songs[ctx.so]->diagrams[ctx.dia] = NULL;
 					if (!cho_style_reset_default()) {
 						DEBUG("cho_style_reset_default failed.");
 						goto ERR;
 					}
 					for (int e = 0; e<ctx.ia; e++) {
 						cho_image_free(ctx.image_assets[e]);
 					}
 					free(ctx.image_assets);
 					ctx.image_assets = NULL;
 					ctx.ia = 0;
 					ctx.so++;
 					ctx.songs = erealloc(ctx.songs, (ctx.so+1) * sizeof(struct ChoSong *)); 
 					ctx.songs[ctx.so] = cho_song_new(&ctx);
 					if (!ctx.songs[ctx.so]) {
 						DEBUG("cho_song_new failed.");
 						goto ERR;
 					}
 					free(ctx.transpose_history);
 					ctx.th = 0;
 					ctx.transpose_history = emalloc((ctx.th+1) * sizeof(int *));
 					ctx.transpose_history[ctx.th] = 0;
 					ctx.transpose = &ctx.transpose_history[ctx.th];
 					ctx.th++;
 					ctx.se = 0;
 					ctx.li = 0;
 					ctx.lii = 0;
 					// ctx.m = 0;
 					ctx.dia = 0;
 					ctx.songs[ctx.so]->sections = emalloc((ctx.se+1) * sizeof(struct ChoSection *));
 					ctx.songs[ctx.so]->sections[ctx.se] = cho_section_new();
 					lines = &ctx.songs[ctx.so]->sections[ctx.se]->lines;
 					*lines = erealloc(*lines, (ctx.li+1) * sizeof(struct ChoLine *));
 					(*lines)[ctx.li] = cho_line_new();
 					(*lines)[ctx.li]->items = emalloc(sizeof(struct ChoLineItem *));
 					(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 					break;
 				}
 				case DIRECTIVE_TYPE_FONT: {
 					sprop.ttype = directive->ttype;
 					sprop.type = directive->sprop;
 					switch (directive->sprop) {
 					case STYLE_PROPERTY_TYPE_FONT:
 						sprop.u.font_name = NULL;
 						break;
 					case STYLE_PROPERTY_TYPE_SIZE:
 						sprop.u.font_size = EMPTY_DOUBLE;
 						break;
 					case STYLE_PROPERTY_TYPE_COLOR:
 						sprop.u.foreground_color = NULL;
 						break;
 					}
 					if (!cho_style_change_default(sprop)) {
 						DEBUG("cho_style_change_default failed.");
 						goto ERR;
 					}
 					break;
 				}
 				case DIRECTIVE_TYPE_CHORD: {
 					switch (directive->ctype) {
 					case CHORD_DIRECTIVE_TRANSPOSE:
 						ctx.transpose--;
 						ctx.th--;
 						break;
 					case CHORD_DIRECTIVE_DEFINE:
 						cho_log(&ctx, LOG_WARN, "Ignoring chord directive '%s' because it has no value.", directive_name);
 						break;
 					}
 					break;
 				}
 				case DIRECTIVE_TYPE_OUTPUT:
 					(*lines)[ctx.li]->btype = directive->btype;
 					break;
 				case DIRECTIVE_TYPE_EXTENSION:
 					// INFO: Such a directive should not be logged.
 					break;
 				case DIRECTIVE_TYPE_CUSTOM:
 					cho_log(&ctx, LOG_INFO, "Ignoring custom directive '%s'.", directive_name);
 					break;
 				}
 				cho_directive_free(directive);
 				directive = NULL;
 				break;
 			}
 			if (c == '{') {
 				cho_log(&ctx, LOG_ERR, "Can't start a new directive if the previous one is not yet closed.");
 				goto ERR;
 			}
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c == '\\') {
 					ctx.state_before_backslash = STATE_DIRECTIVE_NAME;
 					ctx.state = STATE_BACKSLASH;
 					ctx.dn--;
 					break;
 				}
 				cho_log(&ctx, LOG_ERR, "Can't have a newline in a directive name.");
 				goto ERR;
 			}
 			if (c == ':' || c == ' ') {
 				directive_name[ctx.dn] = 0;
 				ctx.dn = 0;
 				ctx.state = STATE_DIRECTIVE_VALUE;
 				break;
 			}
 			directive_name[ctx.dn] = c;
 			ctx.dn++;
 			break;
 		}
 		case STATE_DIRECTIVE_VALUE: {
 			if (c == '}') {
 				directive_value[ctx.dv] = 0;
 				ctx.dv = 0;
 				stripped_directive_value = str_remove_leading_whitespace(directive_value);
 				directive = cho_directive_parse(&ctx, directive_name);
 				/* printf(
 					"directive: '%s'\ndtype: %s, stype: %s, position: %s\n",
 					directive_name, dtype(directive->dtype), the_stype(directive->stype), pos(directive->position)
 				); */
 				switch (directive->dtype) {
 				case DIRECTIVE_TYPE_ENVIRONMENT: {
 					if (strlen(stripped_directive_value) > 0) {
 						ctx.songs[ctx.so]->present_text_types[TEXT_TYPE_LABEL] = true;
 					}
 					ctx.current_ttype = directive->ttype;
 					switch (directive->position) {
 					case POSITION_START: {
 						if (!is_previous_section_closed(&ctx)) {
 							cho_log(&ctx, LOG_ERR, "Can't start a new section when the previous one is not yet closed.");
 							goto ERR;
 						}
 						if (directive->stype == SECTION_TYPE_CUSTOM) {
 							memset(custom_directive, 0, sizeof(custom_directive));
 							strcpy(custom_directive, &directive_name[9]);
 						}
 						cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 						free((*lines)[ctx.li]->items);
 						ctx.lii = 0;
 						free((*lines)[ctx.li]);
 						(*lines)[ctx.li] = NULL;
 						ctx.se++;
 						ctx.songs[ctx.so]->sections = erealloc(ctx.songs[ctx.so]->sections, (ctx.se+1) * sizeof(struct ChoSection *));
 						ctx.songs[ctx.so]->sections[ctx.se] = cho_section_new();
 						ctx.songs[ctx.so]->sections[ctx.se]->type = directive->stype;
 
 						if (strchr(stripped_directive_value, '=')) {
 							directive_attrs = cho_attrs_parse(&ctx, stripped_directive_value, directive_name);
 							if (!directive_attrs) {
 								DEBUG("cho_attrs_parse failed.");
 								goto ERR;
 							}
 							label = cho_attrs_get(directive_attrs, "label");
 							if (directive->stype == SECTION_TYPE_GRID) {
 								shape = cho_attrs_get(directive_attrs, "shape");
 								if (shape) {
 									if (!cho_grid_shape_parse_and_set(&ctx, shape)) {
 										DEBUG("cho_grid_parse_and_set_shape failed.");
 										goto ERR;
 									}
 								}
 							}
 						} else {
 							if (directive->stype == SECTION_TYPE_GRID) {
 								int index = str_index_of(stripped_directive_value, ' ');
 								if (index != -1) {
 									stripped_directive_value[index] = 0;
 									label = &stripped_directive_value[index+1];
 								}
 								if (!cho_grid_shape_parse_and_set(&ctx, stripped_directive_value)) {
 									DEBUG("cho_grid_parse_and_set_shape failed.");
 									goto ERR;
 								}
 							} else {
 								label = stripped_directive_value;
 							}
 						}
 						if (label) {
 							ctx.songs[ctx.so]->sections[ctx.se]->label = emalloc(sizeof(struct ChoText));
 							ctx.songs[ctx.so]->sections[ctx.se]->label->text = strdup(label);
 							ctx.prev_ttype = ctx.current_ttype;
 							ctx.current_ttype = TEXT_TYPE_LABEL;
 							ctx.songs[ctx.so]->sections[ctx.se]->label->style = cho_style_new_default(&ctx);
 							ctx.current_ttype = ctx.prev_ttype;
 							label = NULL;
 						}
 						cho_tag_attrs_free(directive_attrs);
 						directive_attrs = NULL;
 						if (ctx.directive_has_tag) {
 							cho_style_complement(ctx.songs[ctx.so]->sections[ctx.se]->label->style, ctx.tags[ctx.ta]->style, &ctx.tags[ctx.ta]->style_presence);
 							ctx.directive_has_tag = false;
 						}
 						ctx.li = 0;
 						lines = &ctx.songs[ctx.so]->sections[ctx.se]->lines;
 						*lines = emalloc(sizeof(struct ChoLine *));
 						(*lines)[ctx.li] = cho_line_new();
 						(*lines)[ctx.li]->items = emalloc(sizeof(struct ChoLineItem *));
 						(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 						ctx.songs[ctx.so]->present_text_types[directive->ttype] = true;
 						break;
 					}
 					case POSITION_END: {
 						cho_log(&ctx, LOG_ERR, "A directive that closes a section can't have arguments.");
 						goto ERR;
 					}
 					case POSITION_NO: {
 						/* INFO: {chorus: ...} */
 						label = strdup(stripped_directive_value);
 						chorus = cho_find_previous_chorus(ctx.songs[ctx.so]->sections, ctx.se);
 						if (chorus) {
 							if (config->output->chorus->quote) {
 								if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 									(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 									(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 								}
 								ctx.lii++;
 								(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 								(*lines)[ctx.li]->items[ctx.lii] = NULL;
 								ctx.lii = 0;
 								ctx.te = 0;
 								(*lines)[ctx.li]->text_above = erealloc((*lines)[ctx.li]->text_above, (ctx.lia+1) * sizeof(struct ChoLineItemAbove *));
 								(*lines)[ctx.li]->text_above[ctx.lia] = NULL;
 								ctx.lia = 0;
 								cho_line_free((*lines)[ctx.li]);
 								// songs[so]->sections[se]->lines = erealloc(songs[so]->sections[se]->lines, (li+1) * sizeof(struct ChoLine *));
 								(*lines)[ctx.li] = NULL;
 								ctx.li = 0;
 								ctx.se++;
 								ctx.songs[ctx.so]->sections = erealloc(ctx.songs[ctx.so]->sections, (ctx.se+1) * sizeof(struct ChoSection *));
 								ctx.songs[ctx.so]->sections[ctx.se] = cho_section_copy(chorus);
 								if (ctx.songs[ctx.so]->sections[ctx.se]->label) {
 									free(ctx.songs[ctx.so]->sections[ctx.se]->label->text);
 									ctx.songs[ctx.so]->sections[ctx.se]->label->text = label;
 								} else {
 									ctx.current_ttype = TEXT_TYPE_LABEL;
 									ctx.songs[ctx.so]->sections[ctx.se]->label = cho_text_new(&ctx);
 									ctx.songs[ctx.so]->sections[ctx.se]->label->text = label;
 								}
 								if (ctx.directive_has_tag) {
 									cho_style_complement(ctx.songs[ctx.so]->sections[ctx.se]->label->style, ctx.tags[ctx.ta]->style, &ctx.tags[ctx.ta]->style_presence);
 									ctx.directive_has_tag = false;
 								}
 								ctx.se++;
 								ctx.songs[ctx.so]->sections = erealloc(ctx.songs[ctx.so]->sections, (ctx.se+1) * sizeof(struct ChoSection *));
 								ctx.songs[ctx.so]->sections[ctx.se] = cho_section_new();
 								lines = &ctx.songs[ctx.so]->sections[ctx.se]->lines;
 								*lines = emalloc(sizeof(struct ChoLine *));
 								(*lines)[ctx.li] = cho_line_new();
 								(*lines)[ctx.li]->items = emalloc(sizeof(struct ChoLineItem *));
 								(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 							} else {
 								if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 									(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 									(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 									if (strlen((*lines)[ctx.li]->items[ctx.lii]->u.text->text) == 0) {
 										cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 									} else {
 										ctx.lii++;
 									}
 								} else {
 									ctx.lii++;
 								}
 								(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 								(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 								cho_style_free((*lines)[ctx.li]->items[ctx.lii]->u.text->style);
 								ctx.current_ttype = TEXT_TYPE_LABEL;
 								(*lines)[ctx.li]->items[ctx.lii]->u.text->style = cho_style_new_default(&ctx);
 								(*lines)[ctx.li]->items[ctx.lii]->u.text->text = label;
 								if (ctx.directive_has_tag) {
 									cho_style_complement((*lines)[ctx.li]->items[ctx.lii]->u.text->style, ctx.tags[ctx.ta]->style, &ctx.tags[ctx.ta]->style_presence);
 									ctx.directive_has_tag = false;
 								}
 								ctx.te += strlen(label);
 							}
 						} else {
 							if (config->output->chorus->quote) {
 								cho_log(&ctx, LOG_WARN, "Can't quote chorus because it's not defined previously.");
 							}
 							if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 								(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 								(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 								if (strlen((*lines)[ctx.li]->items[ctx.lii]->u.text->text) == 0) {
 									cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 								} else {
 									ctx.lii++;
 								}
 							} else {
 								ctx.lii++;
 							}
 							(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 							(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 							cho_style_free((*lines)[ctx.li]->items[ctx.lii]->u.text->style);
 							ctx.current_ttype = TEXT_TYPE_LABEL;
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->style = cho_style_new_default(&ctx);
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->text = label;
 							if (ctx.directive_has_tag) {
 								cho_style_complement((*lines)[ctx.li]->items[ctx.lii]->u.text->style, ctx.tags[ctx.ta]->style, &ctx.tags[ctx.ta]->style_presence);
 							}
 							ctx.te += strlen(label);
 						}
 						break;
 					}
 					}
 					break;
 				}
 				case DIRECTIVE_TYPE_METADATA: {
 					metadata_value = strdup(stripped_directive_value);
 					if (strlen(metadata_value) == 0) {
 						cho_log(&ctx, LOG_WARN, "Ignoring metadata directive '%s' because it has no value.", directive_name);
 						free(metadata_value);
 						break;
 					}
 					switch (directive->meta) {
 					case METADATA_DIRECTIVE_TITLE:
 						ctx.songs[ctx.so]->metadata = erealloc(ctx.songs[ctx.so]->metadata, (ctx.m+1) * sizeof(struct ChoMetadata *));
 						ctx.songs[ctx.so]->metadata[ctx.m] = cho_metadata_new(&ctx);
 						ctx.songs[ctx.so]->metadata[ctx.m]->name = strdup("title");
 						ctx.songs[ctx.so]->metadata[ctx.m]->value = metadata_value;
 						cho_style_free(ctx.songs[ctx.so]->metadata[ctx.m]->style);
 						ctx.songs[ctx.so]->metadata[ctx.m]->style = cho_style_copy(directive->style);
 						ctx.songs[ctx.so]->present_text_types[TEXT_TYPE_TITLE] = true;
 						break;
 					case METADATA_DIRECTIVE_SUBTITLE:
 						ctx.songs[ctx.so]->metadata = erealloc(ctx.songs[ctx.so]->metadata, (ctx.m+1) * sizeof(struct ChoMetadata *));
 						ctx.songs[ctx.so]->metadata[ctx.m] = cho_metadata_new(&ctx);
 						ctx.songs[ctx.so]->metadata[ctx.m]->name = strdup("subtitle");
 						ctx.songs[ctx.so]->metadata[ctx.m]->value = metadata_value;
 						cho_style_free(ctx.songs[ctx.so]->metadata[ctx.m]->style);
 						ctx.songs[ctx.so]->metadata[ctx.m]->style = cho_style_copy(directive->style);
 						ctx.songs[ctx.so]->present_text_types[TEXT_TYPE_SUBTITLE] = true;
 						break;
 					case METADATA_DIRECTIVE_OTHER: {
 						if (!strcmp(directive_name, "meta")) {
 							metadata = cho_metadata_split(&ctx, directive_value);
 							if (!metadata) {
 								DEBUG("cho_metadata_split failed.");
 								goto ERR;
 							}
 							ctx.songs[ctx.so]->metadata = erealloc(ctx.songs[ctx.so]->metadata, (ctx.m+1) * sizeof(struct ChoMetadata *));
 							ctx.songs[ctx.so]->metadata[ctx.m] = metadata;
 							free(metadata_value);
 						} else {
 							ctx.songs[ctx.so]->metadata = erealloc(ctx.songs[ctx.so]->metadata, (ctx.m+1) * sizeof(struct ChoMetadata *));
 							ctx.songs[ctx.so]->metadata[ctx.m] = cho_metadata_new(&ctx);
 							ctx.songs[ctx.so]->metadata[ctx.m]->name = strdup(directive_name);
 							ctx.songs[ctx.so]->metadata[ctx.m]->value = metadata_value;
 						}
 					}
 					}
 					if (ctx.directive_has_tag) {
 						cho_style_complement(ctx.songs[ctx.so]->metadata[ctx.m]->style, ctx.tags[ctx.ta]->style, &ctx.tags[ctx.ta]->style_presence);
 						ctx.directive_has_tag = false;
 					}
 					ctx.m++;
 					break;
 				}
 				case DIRECTIVE_TYPE_FORMATTING: {
 					if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 						if (strlen((*lines)[ctx.li]->items[ctx.lii]->u.text->text) == 0) {
 							cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 						} else {
 							ctx.lii++;
 						}
 					} else {
 						ctx.lii++;
 					}
 					(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 					(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 					cho_style_free((*lines)[ctx.li]->items[ctx.lii]->u.text->style);
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->style = cho_style_copy(directive->style);
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text = strdup(stripped_directive_value);
 					if (ctx.directive_has_tag) {
 						cho_style_complement((*lines)[ctx.li]->items[ctx.lii]->u.text->style, ctx.tags[ctx.ta]->style, &ctx.tags[ctx.ta]->style_presence);
 						ctx.directive_has_tag = false;
 					}
 					ctx.te += strlen(stripped_directive_value);
 					ctx.songs[ctx.so]->present_text_types[directive->ttype] = true;
 					break;
 				}
 				case DIRECTIVE_TYPE_IMAGE: {
 					if (strchr(directive_value, '=')) {
 						image = cho_image_directive_parse(&ctx, directive_value);
 						if (!image) {
 							DEBUG("cho_image_directive_parse failed.");
 							goto ERR;
 						}
 					} else {
 						image = cho_image_new();
 						image->src = strdup(stripped_directive_value);
 					}
 					if (image->is_asset) {
 						ctx.image_assets = erealloc(ctx.image_assets, (ctx.ia+1) * sizeof(struct ChoImage *));
 						ctx.image_assets[ctx.ia] = image;
 						ctx.ia++;
 					} else {
 						if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 							ctx.te = 0;
 						}
 						ctx.lii++;
 						(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 						(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 						cho_text_free((*lines)[ctx.li]->items[ctx.lii]->u.text);
 						(*lines)[ctx.li]->items[ctx.lii]->is_text = false;
 						(*lines)[ctx.li]->items[ctx.lii]->u.image = image;
 					}
 					break;
 				}
 				case DIRECTIVE_TYPE_PREAMBLE:
 					cho_log(&ctx, LOG_ERR, "Preamble directive '%s' can't have a value.", directive_name);
 					goto ERR;
 				case DIRECTIVE_TYPE_FONT: {
 					sprop.ttype = directive->ttype;
 					switch (directive->sprop) {
 					case STYLE_PROPERTY_TYPE_FONT:
 						sprop.u.font_name = emalloc((strlen(stripped_directive_value)+1) * sizeof(char));
 						strcpy(sprop.u.font_name, stripped_directive_value);
 						sprop.type = STYLE_PROPERTY_TYPE_FONT;
 						break;
 					case STYLE_PROPERTY_TYPE_SIZE:
 						sprop.u.font_size = strtod(stripped_directive_value, NULL);
 						if (sprop.u.font_size <= 0.0) {
 							cho_log(&ctx, LOG_ERR, "Font directive '%s' has to contain a positive number.", directive_name);
 							goto ERR;
 						}
 						sprop.type = STYLE_PROPERTY_TYPE_SIZE;
 						break;
 					case STYLE_PROPERTY_TYPE_COLOR:
 						sprop.u.foreground_color = cho_color_parse(stripped_directive_value);
 						if (sprop.u.foreground_color == NULL) {
 							cho_log(&ctx, LOG_ERR, "Font directive '%s' has an invalid value.", directive_name);
 							goto ERR;
 						}
 						sprop.type = STYLE_PROPERTY_TYPE_COLOR;
 						break;
 					}
 					if (!cho_style_change_default(sprop)) {
 						DEBUG("cho_style_change_default failed.");
 						goto ERR;
 					}
 					if (sprop.type == STYLE_PROPERTY_TYPE_FONT) {
 						free(sprop.u.font_name);
 					} else if (sprop.type == STYLE_PROPERTY_TYPE_COLOR) {
 						free(sprop.u.foreground_color);
 					}
 					break;
 				}
 				case DIRECTIVE_TYPE_CHORD: {
 					switch (directive->ctype) {
 					case CHORD_DIRECTIVE_TRANSPOSE:
 						if (!transposition_parse(directive_value, &transpose)) {
 							DEBUG("transposition_parse failed.");
 							cho_log(&ctx, LOG_ERR, "Directive 'transpose' has an invalid value.");
 							goto ERR;
 						}
 						ctx.transpose_history = erealloc(ctx.transpose_history, (ctx.th+1) * sizeof(int *));
 						ctx.transpose_history[ctx.th] = ctx.transpose_history[ctx.th-1] + transpose;
 						ctx.transpose = &ctx.transpose_history[ctx.th];
 						ctx.th++;
 						break;
 					case CHORD_DIRECTIVE_DEFINE:
 						diagram = cho_chord_diagram_parse(&ctx, directive_value, ctx.songs[ctx.so]->diagrams, ctx.dia);
 						if (!diagram) {
 							DEBUG("cho_chord_diagram_parse failed.");
 							goto ERR;
 						}
 						// debug_chord_diagram_print(diagram);
 						ctx.songs[ctx.so]->diagrams = erealloc(ctx.songs[ctx.so]->diagrams, (ctx.dia+1) * sizeof(struct ChordDiagram *));
 						ctx.songs[ctx.so]->diagrams[ctx.dia] = diagram;
 						ctx.dia++;
 						break;
 					}
 					break;
 				}
 				case DIRECTIVE_TYPE_OUTPUT:
 					cho_log(&ctx, LOG_ERR, "Directive '%s' can't have a value.", directive_name);
 					goto ERR;
 				case DIRECTIVE_TYPE_EXTENSION:
 					// INFO: Such a directive should not be logged.
 					break;
 				case DIRECTIVE_TYPE_CUSTOM:
 					cho_log(&ctx, LOG_INFO, "Ignoring custom directive '%s'.", directive_name);
 					break;
 				}
 				switch (directive->stype) {
 				case SECTION_TYPE_TAB:
 					ctx.state = STATE_TAB;
 					break;
 				case SECTION_TYPE_GRID:
 					ctx.state = STATE_GRID;
 					break;
 				default:
 					ctx.state = STATE_LYRICS;
 				}
 				memset(directive_value, 0, strlen(directive_value));
 				free(stripped_directive_value);
 				stripped_directive_value = NULL;
 				cho_directive_free(directive);
 				directive = NULL;
 				break;
 			}
 			if (c == '%') {
 				ctx.state_before_metadata_substitution = STATE_DIRECTIVE_VALUE;
 				ctx.state = STATE_MAYBE_METADATA_SUBSTITUTION;
 				break;
 			}
 			if (c == '<') {
 				ctx.state_before_tag = STATE_DIRECTIVE_VALUE;
 				ctx.state = STATE_MARKUP_TAG;
 				break;
 			}
 			if (c == '{') {
 				cho_log(&ctx, LOG_ERR, "Can't start a new directive if the previous one is not yet closed.");
 				goto ERR;
 			}
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c == '\\') {
 					ctx.state_before_backslash = STATE_DIRECTIVE_VALUE;
 					ctx.state = STATE_BACKSLASH;
 					ctx.dv--;
 					break;
 				}
 				cho_log(&ctx, LOG_ERR, "Newline character inside a directive value is invalid.");
 				goto ERR;
 			}
 			if (ctx.dv > 4094) {
 				cho_log(&ctx, LOG_ERR, "Directive value can't be greater than 4095 bytes.");
 				goto ERR;
 			}
 			directive_value[ctx.dv] = c;
 			ctx.dv++;
 			break;
 		}
 		case STATE_CHORD: {
 			if (c == ']') {
 				chord[ctx.ch] = 0;
 				ctx.ch = 0;
 				ctx.prev_ttype = ctx.current_ttype;
 				ctx.current_ttype = TEXT_TYPE_CHORD;
 				if (ctx.is_chord_already_initialized) {
 					ctx.text_above_pos = cho_line_compute_text_above_position(ctx.songs[ctx.so]->sections[ctx.se]->lines[ctx.li], ctx.lii, ctx.te);
 					(*lines)[ctx.li]->text_above[ctx.lia]->position = ctx.text_above_pos;
 					tmp_chord = cho_chord_parse(&ctx, chord);
 					cho_chord_complete((*lines)[ctx.li]->text_above[ctx.lia]->u.chord, tmp_chord);
 					if (!(*lines)[ctx.li]->text_above[ctx.lia]->u.chord->is_canonical) {
 						cho_log(&ctx, LOG_INFO, "Didn't recognize the chord '%s'.", (*lines)[ctx.li]->text_above[ctx.lia]->u.chord->name);
 					}
 					cho_chord_free(tmp_chord);
 					ctx.is_chord_already_initialized = false;
 				} else {
 					(*lines)[ctx.li]->text_above = erealloc((*lines)[ctx.li]->text_above, (ctx.lia+1) * sizeof(struct ChoLineItemAbove *));
 					(*lines)[ctx.li]->text_above[ctx.lia] = emalloc(sizeof(struct ChoLineItemAbove));
 					(*lines)[ctx.li]->text_above[ctx.lia]->is_chord = true;
 					ctx.text_above_pos = cho_line_compute_text_above_position((*lines)[ctx.li], ctx.lii, ctx.te);
 					(*lines)[ctx.li]->text_above[ctx.lia]->position = ctx.text_above_pos;
 					(*lines)[ctx.li]->text_above[ctx.lia]->u.chord = cho_chord_parse(&ctx, chord);
 					if (!(*lines)[ctx.li]->text_above[ctx.lia]->u.chord->is_canonical) {
 						cho_log(&ctx, LOG_INFO, "Didn't recognize the chord '%s'.", (*lines)[ctx.li]->text_above[ctx.lia]->u.chord->name);
 					}
 				}
 				ctx.songs[ctx.so]->present_text_types[TEXT_TYPE_CHORD] = true;
 				memset(chord, 0, strlen(chord));
 				ctx.lia++;
 				ctx.current_ttype = ctx.prev_ttype;
 				ctx.state = STATE_LYRICS;
 				break;
 			}
 			if (prev_c == '[' && c == '*') {
 				ctx.prev_ttype = ctx.current_ttype;
 				ctx.current_ttype = TEXT_TYPE_ANNOT;
 				(*lines)[ctx.li]->text_above = erealloc((*lines)[ctx.li]->text_above, (ctx.lia+1) * sizeof(struct ChoLineItemAbove *));
 				(*lines)[ctx.li]->text_above[ctx.lia] = emalloc(sizeof(struct ChoLineItemAbove));
 				(*lines)[ctx.li]->text_above[ctx.lia]->is_chord = false;
 				ctx.text_above_pos = cho_line_compute_text_above_position((*lines)[ctx.li], ctx.lii, ctx.te);
 				(*lines)[ctx.li]->text_above[ctx.lia]->position = ctx.text_above_pos;
 				(*lines)[ctx.li]->text_above[ctx.lia]->u.annot = cho_text_new(&ctx);
 				ctx.state = STATE_ANNOTATION;
 				break;
 			}
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c == '\\') {
 					ctx.state_before_backslash = STATE_CHORD;
 					ctx.state = STATE_BACKSLASH;
 					ctx.ch--;
 					break;
 				}
 				cho_log(&ctx, LOG_ERR, "Newline character inside a chord is invalid.");
 				goto ERR;
 			}
 			if (c == '[') {
 				cho_log(&ctx, LOG_ERR, "Can't start a new chord/annotation if the previous one is not yet closed.");
 				goto ERR;
 			}
 			if (c == '<') {
 				if (prev_c == '[') {
 					(*lines)[ctx.li]->text_above = erealloc((*lines)[ctx.li]->text_above, (ctx.lia+1) * sizeof(struct ChoLineItemAbove *));
 					(*lines)[ctx.li]->text_above[ctx.lia] = emalloc(sizeof(struct ChoLineItemAbove));
 					(*lines)[ctx.li]->text_above[ctx.lia]->is_chord = true;
 					(*lines)[ctx.li]->text_above[ctx.lia]->u.chord = cho_chord_new(&ctx);
 					ctx.is_chord_already_initialized = true;
 				}
 				ctx.state_before_tag = STATE_CHORD;
 				ctx.state = STATE_MARKUP_TAG;
 				break;
 			}
 			if (ctx.ch > CHORD_LEN-2) {
 				cho_log(&ctx, LOG_ERR, "Chord can't be greater than %d bytes.", CHORD_LEN-1);
 				goto ERR;
 			}
 			chord[ctx.ch] = c;
 			ctx.ch++;
 			break;
 		}
 		case STATE_ANNOTATION: {
 			if (c == ']') {
 				(*lines)[ctx.li]->text_above[ctx.lia]->u.annot->text = erealloc((*lines)[ctx.li]->text_above[ctx.lia]->u.annot->text, (ctx.ann+1) * sizeof(char));
 				(*lines)[ctx.li]->text_above[ctx.lia]->u.annot->text[ctx.ann] = 0;
 				ctx.songs[ctx.so]->present_text_types[TEXT_TYPE_ANNOT] = true;
 				ctx.ann = 0;
 				ctx.lia++;
 				ctx.current_ttype = ctx.prev_ttype;
 				ctx.state = STATE_LYRICS;
 				break;
 			}
 			if (c == '<') {
 				ctx.state_before_tag = STATE_ANNOTATION;
 				ctx.state = STATE_MARKUP_TAG;
 				break;
 			}
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c == '\\') {
 					ctx.state_before_backslash = STATE_ANNOTATION;
 					ctx.state = STATE_BACKSLASH;
 					ctx.ann--;
 					break;
 				}
 				cho_log(&ctx, LOG_ERR, "Newline character inside an annotation is invalid.");
 				ctx.lia++;
 				goto ERR;
 			}
 			(*lines)[ctx.li]->text_above[ctx.lia]->u.annot->text = erealloc((*lines)[ctx.li]->text_above[ctx.lia]->u.annot->text, (ctx.ann+1) * sizeof(char));
 			(*lines)[ctx.li]->text_above[ctx.lia]->u.annot->text[ctx.ann] = c;
 			ctx.ann++;
 			break;
 		}
 		case STATE_TAB: {
 			// INFO: similar to STATE_LYRICS but without markup and directives
 			if (prev_c == '\n' && c == '#') {
 				ctx.state_before_comment = STATE_TAB;
 				ctx.state = STATE_COMMENT;
 				break;
 			}
 			if (ctx.is_maybe_end_of_tab_directive) {
 				if (c == '}') {
 					directive_name[ctx.dn] = 0;
 					ctx.dn = 0;
 					ctx.is_maybe_end_of_tab_directive = false;
 					if (!strcmp(directive_name, "end_of_tab") || !strcmp(directive_name, "eot")) {
 						cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 						free((*lines)[ctx.li]->items);
 						ctx.lii = 0;
 						free((*lines)[ctx.li]);
 						(*lines)[ctx.li] = NULL;
 						ctx.se++;
 						ctx.songs[ctx.so]->sections = erealloc(ctx.songs[ctx.so]->sections, (ctx.se+1) * sizeof(struct ChoSection *));
 						ctx.songs[ctx.so]->sections[ctx.se] = cho_section_new();
 						ctx.li = 0;
 						lines = &ctx.songs[ctx.so]->sections[ctx.se]->lines;
 						*lines = emalloc(sizeof(struct ChoLine *));
 						(*lines)[ctx.li] = cho_line_new();
 						(*lines)[ctx.li]->items = emalloc(sizeof(struct ChoLineItem *));
 						(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 						ctx.current_ttype = TEXT_TYPE_TEXT;
 						ctx.state = STATE_LYRICS;
 						break;
 					} else {
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = '{';
 						ctx.te++;
 						char *k;
 						for (k = (char *)&directive_name; *k; k++, ctx.te++) {
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = *k;
 						}
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = '}';
 						ctx.te++;
 					}
 					break;
 				}
 				if (c == ' ' || c == ':') {
 					directive_name[ctx.dn] = 0;
 					ctx.dn = 0;
 					ctx.is_maybe_end_of_tab_directive = false;
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = '{';
 					ctx.te++;
 					char *k;
 					for (k = (char *)&directive_name; *k; k++, ctx.te++) {
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = *k;
 					}
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = c;
 					ctx.te++;
 					break;
 				}
 				directive_name[ctx.dn] = c;
 				ctx.dn++;
 				break;
 			}
 			if (prev_c == '\n' && c == '{') {
 				ctx.is_maybe_end_of_tab_directive = true;
 				break;
 			}
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c == '\\') {
 					ctx.state_before_backslash = STATE_TAB;
 					ctx.state = STATE_BACKSLASH;
 					// INFO: This will later overwrite the backslash
 					ctx.te--;
 					break;
 				}
 				if ((*lines)[ctx.li]->items[ctx.lii]->is_text) {
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = 0;
 					if (strlen((*lines)[ctx.li]->items[ctx.lii]->u.text->text) == 0) {
 						cho_line_item_free((*lines)[ctx.li]->items[ctx.lii]);
 						if (ctx.lii == 0) {
 							if (
 								!(*lines)[ctx.li]->text_above &&
 								(*lines)[ctx.li]->btype == BREAK_TYPE_LINE
 							) {
 								free((*lines)[ctx.li]->items);
 								free((*lines)[ctx.li]);
 								*lines = erealloc(*lines, (ctx.li+1) * sizeof(struct ChoLine *));
 								(*lines)[ctx.li] = cho_line_new();
 								(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 								(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 								break;
 							}
 						}
 					} else {
 						ctx.lii++;
 					}
 				} else {
 					ctx.lii++;
 				}
 				(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 				(*lines)[ctx.li]->items[ctx.lii] = NULL;
 				ctx.lii = 0;
 				ctx.te = 0;
 				(*lines)[ctx.li]->text_above = erealloc((*lines)[ctx.li]->text_above, (ctx.lia+1) * sizeof(struct ChoLineItemAbove *));
 				(*lines)[ctx.li]->text_above[ctx.lia] = NULL;
 				ctx.lia = 0;
 				ctx.li++;
 				*lines = erealloc(*lines, (ctx.li+1) * sizeof(struct ChoLine *));
 				(*lines)[ctx.li] = cho_line_new();
 				(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 				(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 				break;
 			}
 			(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 			(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = c;
 			ctx.te++;
 			break;
 		}
 		case STATE_GRID: {
 			if (prev_c == '\n' && c == '#') {
 				ctx.state_before_comment = STATE_GRID;
 				ctx.state = STATE_COMMENT;
 				break;
 			}
 			if (prev_c == '\n' && c == '{') {
 				ctx.state = STATE_DIRECTIVE_NAME;
 				break;
 			}
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c != '}') {
 					grid_token[ctx.gt] = 0;
 					ctx.gt = 0;
 					if (grid_token[0] == 0) {
 						break;
 					}
 					token = cho_grid_token_parse(&ctx, grid_token, &err);
 					if (err) {
 						cho_log(&ctx, LOG_ERR, "Invalid token '%s' in grid section.", grid_token);
 						goto ERR;
 					}
 					if (token == GRID_TOKEN_BAR_LINE_SYMBOL) {
 						ctx.grid.bar_line_symbol_count++;
 						ctx.grid.bar_line_symbol_in_line_count++;
 						if (ctx.grid.bar_line_symbol_count == 2) {
 							ctx.grid.expected_tokens_per_cell = ctx.grid.tokens_per_cell;
 						} else {
 							if (ctx.grid.bar_line_symbol_in_line_count > 1 && ctx.grid.expected_tokens_per_cell != ctx.grid.tokens_per_cell) {
 								cho_log(
 									&ctx,
 									LOG_ERR,
 									"Grid cell no. %d has %d tokens but should have %d tokens.",
 									ctx.grid.bar_line_symbol_in_line_count - 1,
 									ctx.grid.tokens_per_cell,
 									ctx.grid.expected_tokens_per_cell
 								);
 								goto ERR;
 							}
 						}
 						ctx.grid.tokens_per_cell = 0;
 					} else {
 						ctx.grid.tokens_per_cell++;
 					}
 					if (token == GRID_TOKEN_PLACEHOLDER) {
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->text = strdup(" ");
 					} else {
 						ctx.prev_ttype = ctx.current_ttype;
 						ctx.current_ttype = TEXT_TYPE_GRID;
 						cho_style_free((*lines)[ctx.li]->items[ctx.lii]->u.text->style);
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->style = cho_style_new_default(&ctx);
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->text = strdup(grid_token);
 						ctx.current_ttype = ctx.prev_ttype;
 					}
 					ctx.lii++;
 					(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 					(*lines)[ctx.li]->items[ctx.lii] = NULL;
 					ctx.lii = 0;
 					(*lines)[ctx.li]->text_above = erealloc((*lines)[ctx.li]->text_above, (ctx.lia+1) * sizeof(struct ChoLineItem *));
 					(*lines)[ctx.li]->text_above[ctx.lia] = NULL;
 					ctx.lia = 0;
 					ctx.li++;
 					*lines = erealloc(*lines, (ctx.li+1) * sizeof(struct ChoLine *));
 					(*lines)[ctx.li] = cho_line_new();
 					(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 					(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 					ctx.grid.bar_line_symbol_in_line_count = 0;
 				}
 				break;
 			}
 			if (c == ' ') {
 				grid_token[ctx.gt] = 0;
 				ctx.gt = 0;
 				if (grid_token[0] == 0) {
 					break;
 				}
 				token = cho_grid_token_parse(&ctx, grid_token, &err);
 				if (err) {
 					cho_log(&ctx, LOG_ERR, "Invalid token '%s' in grid section.", grid_token);
 					goto ERR;
 				}
 				if (token == GRID_TOKEN_BAR_LINE_SYMBOL) {
 					ctx.grid.bar_line_symbol_count++;
 					ctx.grid.bar_line_symbol_in_line_count++;
 					if (ctx.grid.bar_line_symbol_count == 2) {
 						ctx.grid.expected_tokens_per_cell = ctx.grid.tokens_per_cell;
 					} else {
 						if (ctx.grid.bar_line_symbol_in_line_count > 1 && ctx.grid.expected_tokens_per_cell != ctx.grid.tokens_per_cell) {
 							cho_log(
 								&ctx,
 								LOG_ERR,
 								"Grid cell no. %d has %d tokens but should have %d tokens.",
 								ctx.grid.bar_line_symbol_in_line_count - 1,
 								ctx.grid.tokens_per_cell,
 								ctx.grid.expected_tokens_per_cell
 							);
 							goto ERR;
 						}
 					}
 					ctx.grid.tokens_per_cell = 0;
 				} else {
 					ctx.grid.tokens_per_cell++;
 				}
 				if (token == GRID_TOKEN_PLACEHOLDER) {
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text = strdup(" ");
 				} else {
 					ctx.prev_ttype = ctx.current_ttype;
 					ctx.current_ttype = TEXT_TYPE_GRID;
 					cho_style_free((*lines)[ctx.li]->items[ctx.lii]->u.text->style);
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->style = cho_style_new_default(&ctx);
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->text = strdup(grid_token);
 					ctx.current_ttype = ctx.prev_ttype;
 				}
 				ctx.lii++;
 				(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 				(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 				break;
 			}
 			grid_token[ctx.gt] = c;
 			ctx.gt++;
 			break;
 		}
 		case STATE_MARKUP_TAG: {
 			if (c == '/') {
 				ctx.state = STATE_MARKUP_TAG_END;
 				break;
 			}
 			ctx.ta++;
 			ctx.tags = erealloc(ctx.tags, (ctx.ta+1) * sizeof(struct Tag *));
 			ctx.tags[ctx.ta] = cho_tag_new();
 			ctx.state = STATE_MARKUP_TAG_START;
 			str--;
 			break;
 		}
 		case STATE_MARKUP_TAG_START: {
 			if (c == '>') {
 				tag_start[ctx.t] = 0;
 				ctx.t = 0;
 				if (!strcmp(tag_start, "img")) {
 					cho_log(&ctx, LOG_ERR, "'img' tag has to have at least the 'src' attribute.");
 					goto ERR;
 				}
 				ctx.tags[ctx.ta]->name = strdup(tag_start);
 				tag_style = cho_style_parse(&ctx, tag_start, NULL, cho_tag_style_inherit(ctx.tags, ctx.ta-1), &ctx.tags[ctx.ta]->style_presence);
 				if (!tag_style) {
 					DEBUG("cho_style_parse failed.");
 					goto ERR;
 				}
 				ctx.tags[ctx.ta]->style = tag_style;
 				switch (ctx.state_before_tag) {
 				case STATE_LYRICS:
 					cho_style_free((*lines)[ctx.li]->items[ctx.lii]->u.text->style);
 					(*lines)[ctx.li]->items[ctx.lii]->u.text->style = cho_style_copy(tag_style);
 					break;
 				case STATE_CHORD:
 					cho_style_free((*lines)[ctx.li]->text_above[ctx.lia]->u.chord->style);
 					(*lines)[ctx.li]->text_above[ctx.lia]->u.chord->style = cho_style_copy(tag_style);
 					break;
 				case STATE_ANNOTATION:
 					if (ctx.ann > 0) {
 						(*lines)[ctx.li]->text_above[ctx.lia]->u.annot->text = erealloc((*lines)[ctx.li]->text_above[ctx.lia]->u.annot->text, (ctx.ann+1) * sizeof(char));
 						(*lines)[ctx.li]->text_above[ctx.lia]->u.annot->text[ctx.ann] = 0;
 						ctx.ann = 0;
 						ctx.lia++;
 						(*lines)[ctx.li]->text_above = erealloc((*lines)[ctx.li]->text_above, (ctx.lia+1) * sizeof(struct ChoLineItemAbove *));
 						(*lines)[ctx.li]->text_above[ctx.lia] = emalloc(sizeof(struct ChoLineItemAbove));
 						(*lines)[ctx.li]->text_above[ctx.lia]->is_chord = false;
 						(*lines)[ctx.li]->text_above[ctx.lia]->position = ctx.text_above_pos;
 						(*lines)[ctx.li]->text_above[ctx.lia]->u.annot = cho_text_new(&ctx);
 					}
 					cho_style_free((*lines)[ctx.li]->text_above[ctx.lia]->u.annot->style);
 					(*lines)[ctx.li]->text_above[ctx.lia]->u.annot->style = cho_style_copy(tag_style);
 					break;
 				case STATE_DIRECTIVE_VALUE:
 					ctx.directive_has_tag = true;
 					break;
 				default:
 					cho_log(&ctx, LOG_ERR, "Invalid state_before_tag '%s'.", state_enums[ctx.state_before_tag]);
 					goto ERR;
 				}
 				memset(tag_start, 0, strlen(tag_start));
 				ctx.state = ctx.state_before_tag;
 				break;
 			}
 			if (is_whitespace(c)) {
 				tag_start[ctx.t] = 0;
 				ctx.t = 0;
 				ctx.tags[ctx.ta]->name = strdup(tag_start);
 				ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 				ctx.tags[ctx.ta]->attrs[ctx.at] = cho_tag_attr_new();
 				ctx.state = STATE_MARKUP_ATTR_NAME;
 				break;
 			}
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c == '\\') {
 					ctx.state_before_backslash = STATE_MARKUP_TAG_START;
 					ctx.state = STATE_BACKSLASH;
 					ctx.t--;
 					break;
 				}
 				cho_log(&ctx, LOG_ERR, "Newline character inside a tag name is invalid.");
 				goto ERR;
 			}
 			if (ctx.t == 5) {
 				cho_log(&ctx, LOG_ERR, "Start tag name is too long.");
 				goto ERR;
 			}
 			tag_start[ctx.t] = c;
 			ctx.t++;
 			break;
 		}
 		case STATE_MARKUP_TAG_END: {
 			if (c == '>') {
 				tag_end[ctx.t] = 0;
 				ctx.t = 0;
 				if (!cho_tag_close_last_unclosed(&ctx, tag_end, ctx.tags, ctx.ta)) {
 					DEBUG("cho_tag_close_last_unclosed failed.");
 					goto ERR;
 				}
 				memset(tag_end, 0, strlen(tag_end));
 				ctx.state = ctx.state_before_tag;
 				break;
 			}
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c == '\\') {
 					ctx.state_before_backslash = STATE_MARKUP_TAG_END;
 					ctx.state = STATE_BACKSLASH;
 					ctx.t--;
 					break;
 				}
 				cho_log(&ctx, LOG_ERR, "Newline character inside a tag name is invalid.");
 				goto ERR;
 			}
 			if (ctx.t == 5) {
 				cho_log(&ctx, LOG_ERR, "End tag name is too long.");
 				goto ERR;
 			}
 			tag_end[ctx.t] = c;
 			ctx.t++;
 			break;
 		}
 		case STATE_MARKUP_ATTR_NAME: {
 			if (c == '=') {
 				ctx.tags[ctx.ta]->attrs[ctx.at]->name = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->name, (ctx.atn+1) * sizeof(char));
 				ctx.tags[ctx.ta]->attrs[ctx.at]->name[ctx.atn] = 0;
 				ctx.atn = 0;
 				ctx.state = STATE_MARKUP_ATTR_VALUE;
 				break;
 			}
 			if (is_whitespace(c)) {
 				if (ctx.at == 0) {
 					if (!ctx.tags[ctx.ta]->attrs[ctx.at]->name) {
 						break;
 					} else {
 						ctx.tags[ctx.ta]->attrs[ctx.at]->name = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->name, (ctx.atn+1) * sizeof(char));
 						ctx.tags[ctx.ta]->attrs[ctx.at]->name[ctx.atn] = 0;
 						cho_log(&ctx, LOG_ERR, "1 Attribute with name '%s' of tag '%s' has no value.", ctx.tags[ctx.ta]->attrs[ctx.at]->name, tag_start);
 						ctx.at++;
 						ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 						ctx.tags[ctx.ta]->attrs[ctx.at] = NULL;
 						goto ERR;
 					}
 				}
 				if (ctx.tags[ctx.ta]->attrs[ctx.at-1]->name && ctx.tags[ctx.ta]->attrs[ctx.at-1]->value) {
 					break;
 				}
 				if (!ctx.tags[ctx.ta]->attrs[ctx.at-1]->name && !ctx.tags[ctx.ta]->attrs[ctx.at-1]->value) {
 					break;
 				}
 				ctx.tags[ctx.ta]->attrs[ctx.at]->name = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->name, (ctx.atn+1) * sizeof(char));
 				ctx.tags[ctx.ta]->attrs[ctx.at]->name[ctx.atn] = 0;
 				cho_log(&ctx, LOG_ERR, "2 Attribute with name '%s' of tag '%s' has no value.", ctx.tags[ctx.ta]->attrs[ctx.at]->name, tag_start);
 				ctx.at++;
 				ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 				ctx.tags[ctx.ta]->attrs[ctx.at] = NULL;
 				goto ERR;
 			}
 			if (c == '>') {
 				if (ctx.tags[ctx.ta]->attrs[ctx.at]->name && !ctx.tags[ctx.ta]->attrs[ctx.at]->value) {
 					ctx.tags[ctx.ta]->attrs[ctx.at]->name = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->name, (ctx.atn+1) * sizeof(char));
 					ctx.tags[ctx.ta]->attrs[ctx.at]->name[ctx.atn] = 0;
 					cho_log(&ctx, LOG_ERR, "3 Attribute with name '%s' of tag '%s' has no value.", ctx.tags[ctx.ta]->attrs[ctx.at]->name, tag_start);
 					ctx.at++;
 					ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 					ctx.tags[ctx.ta]->attrs[ctx.at] = NULL;
 					goto ERR;
 				}
 				if (ctx.at > 0 && ctx.tags[ctx.ta]->attrs[ctx.at-1]->value) {
 					cho_tag_attr_free(ctx.tags[ctx.ta]->attrs[ctx.at]);
 					ctx.tags[ctx.ta]->attrs[ctx.at] = NULL;
 					ctx.atn = 0;
 					if (!strcmp(ctx.tags[ctx.ta]->name, "img")) {
 						cho_text_free((*lines)[ctx.li]->items[ctx.lii]->u.text);
 						(*lines)[ctx.li]->items[ctx.lii]->is_text = false;
 						image = cho_image_tag_parse(&ctx, ctx.tags[ctx.ta]->attrs);
 						if (!image) {
 							DEBUG("cho_image_tag_parse failed.");
 							goto ERR;
 						}
 						(*lines)[ctx.li]->items[ctx.lii]->u.image = image;
 						ctx.lii++;
 						(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 						(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 					} else {
 						tag_style = cho_style_parse(&ctx, tag_start, ctx.tags[ctx.ta]->attrs, cho_tag_style_inherit(ctx.tags, ctx.ta-1), &ctx.tags[ctx.ta]->style_presence);
 						if (!tag_style) {
 							DEBUG("cho_style_parse failed.");
 							goto ERR;
 						}
 						ctx.tags[ctx.ta]->style = tag_style;
 						switch (ctx.state_before_tag) {
 						case STATE_LYRICS:
 							cho_style_free((*lines)[ctx.li]->items[ctx.lii]->u.text->style);
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->style = cho_style_copy(tag_style);
 							break;
 						case STATE_CHORD:
 							cho_style_free((*lines)[ctx.li]->text_above[ctx.lia]->u.chord->style);
 							(*lines)[ctx.li]->text_above[ctx.lia]->u.chord->style = cho_style_copy(tag_style);
 							break;
 						case STATE_ANNOTATION:
 							cho_style_free((*lines)[ctx.li]->text_above[ctx.lia]->u.annot->style);
 							(*lines)[ctx.li]->text_above[ctx.lia]->u.annot->style = cho_style_copy(tag_style);
 							break;
 						case STATE_DIRECTIVE_VALUE:
 							ctx.directive_has_tag = true;
 							break;
 						default:
 							cho_log(&ctx, LOG_ERR, "Invalid state_before_tag '%s'.", state_enums[ctx.state_before_tag]);
 							goto ERR;
 						}
 					}
 					ctx.at = 0;
 					memset(tag_start, 0, strlen(tag_start));
 					ctx.state = ctx.state_before_tag;
 					break;
 				} else {
 					ctx.tags[ctx.ta]->attrs[ctx.at]->name = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->name, (ctx.atn+1) * sizeof(char));
 					ctx.tags[ctx.ta]->attrs[ctx.at]->name[ctx.atn] = 0;
 					ctx.atn = 0;
 					cho_log(&ctx, LOG_ERR, "4 Attribute with name '%s' of tag '%s' has no value.", ctx.tags[ctx.ta]->attrs[ctx.at]->name, tag_start);
 					ctx.at++;
 					ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 					ctx.tags[ctx.ta]->attrs[ctx.at] = NULL;
 					goto ERR;
 				}
 			}
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c == '\\') {
 					ctx.state_before_backslash = STATE_MARKUP_ATTR_NAME;
 					ctx.state = STATE_BACKSLASH;
 					ctx.atn--;
 					break;
 				}
 				cho_log(&ctx, LOG_ERR, "Newline character inside an tag attribute name is invalid.");
 				ctx.at++;
 				ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 				ctx.tags[ctx.ta]->attrs[ctx.at] = NULL;
 				goto ERR;
 			}
 			ctx.tags[ctx.ta]->attrs[ctx.at]->name = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->name, (ctx.atn+1) * sizeof(char));
 			ctx.tags[ctx.ta]->attrs[ctx.at]->name[ctx.atn] = c;
 			ctx.atn++;
 			break;
 		}
 		case STATE_MARKUP_ATTR_VALUE: {
 			if (c == '\n') {
 				ctx.line_no++;
 				if (prev_c == '\\') {
 					ctx.state_before_backslash = STATE_MARKUP_ATTR_VALUE;
 					ctx.state = STATE_BACKSLASH;
 					ctx.atv--;
 					break;
 				}
 				cho_log(&ctx, LOG_ERR, "Newline character inside an attribute value is invalid.");
 				ctx.at++;
 				ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 				ctx.tags[ctx.ta]->attrs[ctx.at] = NULL;
 				goto ERR;
 			}
 			if (avs == ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED) {
 				if (is_whitespace(c)) {
 					cho_log(&ctx, LOG_ERR, "Whitespace character after equals sign is invalid.");
 					ctx.at++;
 					ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 					ctx.tags[ctx.ta]->attrs[ctx.at] = NULL;
 					goto ERR;
 				}
 				if (c == '>') {
 					cho_log(&ctx, LOG_ERR, "5 Attribute with name '%s' of tag '%s' has no value.", ctx.tags[ctx.ta]->attrs[ctx.at]->name, tag_start);
 					ctx.at++;
 					ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 					ctx.tags[ctx.ta]->attrs[ctx.at] = NULL;
 					goto ERR;
 				}
 				if (c == '\'') {
 					avs = ATTRIBUTE_VALUE_SYNTAX_APOSTROPHE;
 				} else if (c == '"') {
 					avs = ATTRIBUTE_VALUE_SYNTAX_QUOTATION_MARK;
 				} else {
 					avs = ATTRIBUTE_VALUE_SYNTAX_UNQUOTED;
 					if (c == '%') {
 						ctx.state_before_metadata_substitution = STATE_MARKUP_ATTR_VALUE;
 						ctx.state = STATE_MAYBE_METADATA_SUBSTITUTION;
 						break;
 					}
 					ctx.tags[ctx.ta]->attrs[ctx.at]->value = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->value, (ctx.atv+1) * sizeof(char));
 					ctx.tags[ctx.ta]->attrs[ctx.at]->value[ctx.atv] = c;
 					ctx.atv++;
 				}
 				break;
 			}
 			if (avs == ATTRIBUTE_VALUE_SYNTAX_UNQUOTED && c == '>') {
 				ctx.tags[ctx.ta]->attrs[ctx.at]->value = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->value, (ctx.atv+1) * sizeof(char));
 				ctx.tags[ctx.ta]->attrs[ctx.at]->value[ctx.atv] = 0;
 				ctx.atv = 0;
 				ctx.at++;
 				ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 				ctx.tags[ctx.ta]->attrs[ctx.at] = NULL;
 				if (!strcmp(ctx.tags[ctx.ta]->name, "img")) {
 					cho_text_free((*lines)[ctx.li]->items[ctx.lii]->u.text);
 					(*lines)[ctx.li]->items[ctx.lii]->is_text = false;
 					image = cho_image_tag_parse(&ctx, ctx.tags[ctx.ta]->attrs);
 					if (!image) {
 						DEBUG("cho_image_tag_parse failed.");
 						goto ERR;
 					}
 					(*lines)[ctx.li]->items[ctx.lii]->u.image = image;
 					ctx.lii++;
 					(*lines)[ctx.li]->items = erealloc((*lines)[ctx.li]->items, (ctx.lii+1) * sizeof(struct ChoLineItem *));
 					(*lines)[ctx.li]->items[ctx.lii] = cho_line_item_new(&ctx);
 				} else {
 					tag_style = cho_style_parse(&ctx, tag_start, ctx.tags[ctx.ta]->attrs, cho_tag_style_inherit(ctx.tags, ctx.ta-1), &ctx.tags[ctx.ta]->style_presence);
 					if (!tag_style) {
 						DEBUG("cho_style_parse failed.");
 						goto ERR;
 					}
 					ctx.tags[ctx.ta]->style = tag_style;
 					switch (ctx.state_before_tag) {
 					case STATE_LYRICS:
 						cho_style_free((*lines)[ctx.li]->items[ctx.lii]->u.text->style);
 						(*lines)[ctx.li]->items[ctx.lii]->u.text->style = cho_style_copy(tag_style);
 						break;
 					case STATE_CHORD:
 						cho_style_free((*lines)[ctx.li]->text_above[ctx.lia]->u.chord->style);
 						(*lines)[ctx.li]->text_above[ctx.lia]->u.chord->style = cho_style_copy(tag_style);
 						break;
 					case STATE_ANNOTATION:
 						cho_style_free((*lines)[ctx.li]->text_above[ctx.lia]->u.annot->style);
 						(*lines)[ctx.li]->text_above[ctx.lia]->u.annot->style = cho_style_copy(tag_style);
 						break;
 					case STATE_DIRECTIVE_VALUE:
 						ctx.directive_has_tag = true;
 						break;
 					default:
 						cho_log(&ctx, LOG_ERR, "Invalid state_before_tag '%s'.", state_enums[ctx.state_before_tag]);
 						goto ERR;
 					}
 				}
 				ctx.at = 0;
 				avs = ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED;
 				memset(tag_start, 0, strlen(tag_start));
 				ctx.state = ctx.state_before_tag;
 				break;
 			}
 			if (
 				(avs == ATTRIBUTE_VALUE_SYNTAX_APOSTROPHE && c == '\'') ||
 				(avs == ATTRIBUTE_VALUE_SYNTAX_QUOTATION_MARK && c == '"') ||
 				(avs == ATTRIBUTE_VALUE_SYNTAX_UNQUOTED && (c == ' ' || c == '\t'))
 			) {
 				ctx.tags[ctx.ta]->attrs[ctx.at]->value = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->value, (ctx.atv+1) * sizeof(char));
 				ctx.tags[ctx.ta]->attrs[ctx.at]->value[ctx.atv] = 0;
 				ctx.atv = 0;
 				ctx.at++;
 				ctx.tags[ctx.ta]->attrs = erealloc(ctx.tags[ctx.ta]->attrs, (ctx.at+1) * sizeof(struct Attr *));
 				ctx.tags[ctx.ta]->attrs[ctx.at] = cho_tag_attr_new();
 				avs = ATTRIBUTE_VALUE_SYNTAX_UNINITIALIZED;
 				ctx.state = STATE_MARKUP_ATTR_NAME;
 				break;
 			}
 			if (c == '%') {
 				ctx.state_before_metadata_substitution = STATE_MARKUP_ATTR_VALUE;
 				ctx.state = STATE_MAYBE_METADATA_SUBSTITUTION;
 				break;
 			}
 			ctx.tags[ctx.ta]->attrs[ctx.at]->value = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->value, (ctx.atv+1) * sizeof(char));
 			ctx.tags[ctx.ta]->attrs[ctx.at]->value[ctx.atv] = c;
 			ctx.atv++;
 			break;
 		}
 		case STATE_COMMENT: {
 			if (c == '\n') {
 				ctx.line_no++;
 				ctx.state = ctx.state_before_comment;
 				break;
 			}
 			break;
 		}
 		case STATE_MAYBE_METADATA_SUBSTITUTION: {
 			if (c == '{') {
 				metadata_substitution[ctx.ms] = '%';
 				ctx.ms++;
 				metadata_substitution[ctx.ms] = '{';
 				ctx.ms++;
 				ctx.state = STATE_METADATA_SUBSTITUTION;
 				break;
 			}
 			switch (ctx.state_before_metadata_substitution) {
 			case STATE_LYRICS:
 				(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 				(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = '%';
 				ctx.te++;
 				break;
 			case STATE_DIRECTIVE_VALUE:
 				directive_value[ctx.dv] = '%';
 				ctx.dv++;
 				break;
 			case STATE_MARKUP_ATTR_VALUE:
 				ctx.tags[ctx.ta]->attrs[ctx.at]->value = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->value, (ctx.atv+1) * sizeof(char));
 				ctx.tags[ctx.ta]->attrs[ctx.at]->value[ctx.atv] = '%';
 				break;
 			default:
 			}
 			ctx.state = ctx.state_before_metadata_substitution;
 			str--;
 			break;
 		}
 		case STATE_METADATA_SUBSTITUTION: {
 			if (prev_c != '\\' && c == '}') {
 				if (ctx.nested_level == 0) {
 					metadata_substitution[ctx.ms] = '}';
 					ctx.ms++;
 					metadata_substitution[ctx.ms] = 0;
 					ctx.ms = 0;
 					char *substituted = cho_metadata_substitution_parse(
 						&ctx,
 						metadata_substitution,
 						NULL,
 						ctx.state_before_metadata_substitution
 					);
 					if (!substituted) {
 						DEBUG("cho_metadata_substitution_parse failed.");
 						goto ERR;
 					}
 					char *ch;
 					switch (ctx.state_before_metadata_substitution) {
 					case STATE_LYRICS:
 						for (ch = substituted; *ch; ch++) {
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->text = erealloc((*lines)[ctx.li]->items[ctx.lii]->u.text->text, (ctx.te+1) * sizeof(char));
 							(*lines)[ctx.li]->items[ctx.lii]->u.text->text[ctx.te] = *ch;
 							ctx.te++;
 						}
 						break;
 					case STATE_DIRECTIVE_VALUE:
 						for (ch = substituted; *ch; ch++) {
 							directive_value[ctx.dv] = *ch;
 							ctx.dv++;
 						}
 						break;
 					case STATE_MARKUP_ATTR_VALUE:
 						for (ch = substituted; *ch; ch++) {
 							ctx.tags[ctx.ta]->attrs[ctx.at]->value = erealloc(ctx.tags[ctx.ta]->attrs[ctx.at]->value, (ctx.atv+1) * sizeof(char));
 							ctx.tags[ctx.ta]->attrs[ctx.at]->value[ctx.atv] = *ch;
 							ctx.atv++;
 						}
 						break;
 					default:
 					}
 					free(substituted);
 					ctx.state = ctx.state_before_metadata_substitution;
 					break;
 				}
 				ctx.nested_level--;
 			}
 			if (prev_c == '%' && c == '{') {
 				ctx.nested_level++;
 			}
 			if (ctx.ms > 4094) {
 				cho_log(&ctx, LOG_ERR, "Metadata substitution can't be greater than 4095 bytes.");
 				goto ERR;
 			}
 			metadata_substitution[ctx.ms] = c;
 			ctx.ms++;
 			break;
 		}
 		}
 		prev_c = c;
 	}
 	if (!cho_style_reset_default()) {
 		DEBUG("cho_style_reset_default failed.");
 		goto ERR;
 	}
 	cho_songs_close(&ctx, lines);
 	bool exist_title = false;
 	for (ctx.so = 0; ctx.songs[ctx.so]; ctx.so++) {
 		for (ctx.m = 0; ctx.songs[ctx.so]->metadata[ctx.m]; ctx.m++) {
 			if (
 				!strcmp(ctx.songs[ctx.so]->metadata[ctx.m]->name, "title") &&
 				ctx.songs[ctx.so]->metadata[ctx.m]->value &&
 				strcmp(ctx.songs[ctx.so]->metadata[ctx.m]->value, "") != 0
 			) {
 				exist_title = true;
 			}
 		}
 		if (!exist_title) {
 			/* INFO: This cho_log() is not line specific. It's a workaround. */
 			ctx.line_no = 0;
 			cho_log(&ctx, LOG_ERR, "Song has no title.");
 			goto ERR;
 		}
 		exist_title = false;
 	}
 	cho_context_cleanup(&ctx);
 	return ctx.songs;
 	ERR:
 	cho_songs_close(&ctx, lines);
 	cho_context_cleanup(&ctx);
 	for (int e = 0; e<=ctx.so; e++) {
 		cho_song_free(ctx.songs[e]);
 	}
 	free(ctx.songs);
 	free(stripped_directive_value);
 	cho_directive_free(directive);
 	cho_tag_attrs_free(directive_attrs);
 	return NULL;
 }
 
 #ifdef ENABLE_DEBUG
 void
 cho_debug_songs_print(struct ChoSong **songs)
 {
 	struct ChoSong **s;
 	struct ChoSection **se;
 	struct ChoLine **li;
 	struct ChoLineItem **it;
 	struct ChoLineItemAbove **above;
 	char *name;
 	for (s = songs; *s; s++) {
 		for (se = (*s)->sections; *se; se++) {
 			printf("## Section");
 			if ((*se)->label) {
 				printf(": %s\n", (*se)->label->text);
 			} else {
 				printf("\n");
 			}
 			for (li = (*se)->lines; *li; li++) {
 				printf("## Line\n");
 				it = (*li)->items;
 				for (above = (*li)->text_above; *above; above++) {
 					if ((*above)->is_chord) {
 						name = cho_chord_name_generate((*above)->u.chord);
 						printf("chord: %s\n", name);
 						free(name);
 					} else {
 						printf("annotation: %s\n", (*above)->u.annot->text);
 					}
 				}
 				for (it = (*li)->items; *it; it++) {
 					if ((*it)->is_text) {
 						printf("text: %s\n", (*it)->u.text->text);
 					} else {
 						printf("image: %s\n", (*it)->u.image->src);
 					}
 				}
 			}
 		}
 	}
 }
 #endif /* ENABLE_DEBUG */