Initial commit.

6 files changed, 1147 insertions, 0 deletions

diff --git a/src/common.c b/src/common.c
new file mode 100644
index 0000000..1c057a2
--- /dev/null
+++ b/src/common.c
@@ -0,0 +1,100 @@
+/*
+Copyright (C) 2016  Paweł Redman
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 3
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation,
+Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+#include "common.h"
+
+void vstr_init(vstr_t *vstr)
+{
+	memset(vstr, 0, sizeof(*vstr));
+}
+
+void vstr_free(vstr_t *vstr)
+{
+	free(vstr->data);
+}
+
+void vstr_clear(vstr_t *vstr)
+{
+	vstr->size = 0;
+}
+
+static int vstr_enlarge(vstr_t *vstr)
+{
+	size_t new_alloc;
+
+	new_alloc = (vstr->alloc + 4) * 3 / 2;
+	debug("%zu -> %zu\n", vstr->alloc, new_alloc);
+
+	vstr->data = realloc(vstr->data, new_alloc);
+	if (!vstr->data)
+		return 1;
+
+	vstr->alloc = new_alloc;
+	return 0;
+}
+
+int vstr_putc(vstr_t *vstr, char ch)
+{
+	// note: keep at least one character free at all times for vstr_termz
+	if (vstr->size + 2 > vstr->alloc)
+		if (vstr_enlarge(vstr))
+			return -ENOMEM;
+
+	vstr->data[vstr->size] = ch;
+	vstr->size++;
+	return 0;
+}
+
+int vstr_cmp(vstr_t *vstr, const char *str)
+{
+	size_t len;
+
+	len = strlen(str);
+	if (vstr->size < len)
+		len = vstr->size;
+
+	return memcmp(vstr->data, str, len);
+}
+
+char *vstr_strdup(vstr_t *vstr)
+{
+	char *str;
+
+	str = malloc(vstr->size + 1);
+	if (!str)
+		return NULL;
+
+	memcpy(str, vstr->data, vstr->size);
+	str[vstr->size] = 0;
+
+	return str;
+}
+
+void vstr_termz(vstr_t *vstr)
+{
+	vstr->data[vstr->size] = 0;
+}
+
+float vstr_atof(vstr_t *vstr)
+{
+	if (!vstr->size)
+		return 0;
+
+	vstr_termz(vstr);
+	return atof(vstr->data);
+}
diff --git a/src/common.h b/src/common.h
new file mode 100644
index 0000000..8c6f43f
--- /dev/null
+++ b/src/common.h
@@ -0,0 +1,86 @@
+/*
+Copyright (C) 2016  Paweł Redman
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 3
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation,
+Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include "elist.h"
+
+#ifdef DEBUG
+#define debug(fmt, ...) fprintf(stderr, "%s: " fmt, __func__, ##__VA_ARGS__)
+#else
+#define debug(fmt, ...)
+#endif
+
+#define PROGRAM_NAME "mapcat"
+#define PROGRAM_VERSION "0.1.0"
+
+// common.c
+
+typedef struct {
+	char *data;
+	size_t size, alloc;
+} vstr_t;
+
+void vstr_init(vstr_t *vstr);
+void vstr_free(vstr_t *vstr);
+void vstr_clear(vstr_t *vstr);
+int vstr_putc(vstr_t *vstr, char ch);
+int vstr_cmp(vstr_t *vstr, const char *str);
+char *vstr_strdup(vstr_t *vstr);
+void vstr_termz(vstr_t *vstr);
+float vstr_atof(vstr_t *vstr);
+
+// lexer.c
+
+#define LEXER_BUFFER 1024
+
+typedef struct {
+	int error;
+	const char *path;
+	FILE *fp;
+	bool eof;
+
+	vstr_t *token;
+	char buf[LEXER_BUFFER];
+	char *buf_c, *buf_e;
+
+	size_t cc, lc, Cc; // character, line, and column counters
+	char last;
+
+	bool in_token;
+	bool in_quote;
+	bool in_comment;
+} lexer_state_t;
+
+int lexer_open(lexer_state_t *ls, const char *path, vstr_t *token);
+int lexer_get_token(lexer_state_t *ls);
+int lexer_assert(lexer_state_t *ls, const char *match, const char *desc);
+int lexer_assert_or_eof(lexer_state_t *ls, const char *match, const char *desc);
+void lexer_perror(lexer_state_t *ls, const char *fmt, ...);
+void lexer_perror_eg(lexer_state_t *ls, const char *expected);
+int lexer_get_floats(lexer_state_t *ls, float *out, size_t count);
+
+// mapcat.c
+
+int mapcat_load(const char *path);
+int mapcat_save(const char *path);
+void mapcat_free(void);
diff --git a/src/elist.h b/src/elist.h
new file mode 100644
index 0000000..da6d172
--- /dev/null
+++ b/src/elist.h
@@ -0,0 +1,113 @@
+/*
+Copyright (C) 2016  Paweł Redman
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 3
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation,
+Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+#define offsetin(V, M) ((size_t)&(V)->M - (size_t)(V))
+
+typedef struct {
+	void *prev, *next;
+} elist_header_t;
+
+static inline elist_header_t *elist_header(void *entry, size_t offs)
+{
+	return (elist_header_t*)((char*)entry + offs);
+}
+
+static inline void elist_append_real(void **head, void *entry, size_t offs)
+{
+	elist_header_t *head_header, *entry_header;
+
+	entry_header = elist_header(entry, offs);
+
+	if (!*head) {
+		*head = entry;
+		entry_header->prev = entry;
+		entry_header->next = NULL;
+		return;
+	}
+
+	head_header = elist_header(*head, offs);
+
+	entry_header->prev = head_header->prev;
+	if (head_header->prev)
+		elist_header(head_header->prev, offs)->next = entry;
+	head_header->prev = entry;
+
+	entry_header->next = NULL;
+}
+
+#define elist_append(head, entry, member) \
+elist_append_real((void**)(head), (entry), offsetin((entry), member))
+
+#define elist_next(entry, member) \
+(elist_header((entry), offsetin((entry), member))->next)
+
+#define elist_for(iter, head, member) \
+for ((iter) = (head); (iter); (iter) = elist_next((iter), member))
+
+static inline void elist_unlink_real(void **head, void *entry, size_t offs)
+{
+	elist_header_t *entry_header;
+
+	entry_header = elist_header(entry, offs);
+
+	if (entry_header->prev && *head != entry) {
+		elist_header_t *prev_header;
+		prev_header = elist_header(entry_header->prev, offs);
+		prev_header->next = entry_header->next;
+	}
+
+	if (entry_header->next) {
+		elist_header_t *next_header;
+		next_header = elist_header(entry_header->next, offs);
+		next_header->prev = entry_header->prev;
+	} else {
+		elist_header_t *head_header;
+		head_header = elist_header(*head, offs);
+		head_header->prev = entry_header->prev;
+	}
+
+	if (*head == entry)
+		*head = entry_header->next;
+
+}
+
+#define elist_unlink(head, entry, member) \
+elist_unlink_real((void**)(head), (entry), offsetin((entry), member))
+
+static inline void elist_append_list_real(void **head1, void *head2, size_t offs)
+{
+	elist_header_t *head1_header, *head2_header, *last1_header;
+
+	if (!*head1) {
+		*head1 = head2;
+		return;
+	}
+
+	if (!head2)
+		return;
+
+	head1_header = elist_header(head1, offs);
+	head2_header = elist_header(head2, offs);
+	last1_header = elist_header(head1_header->prev, offs);
+	head1_header->prev = head2_header->prev;
+	last1_header->next = head2;
+	head2_header->prev = head1_header->prev;
+}
+
+#define elist_append_list(head1, head2, member) \
+elist_append_list_real((void**)(head1), (head2), offsetin((head2), member))
diff --git a/src/lexer.c b/src/lexer.c
new file mode 100644
index 0000000..41d6784
--- /dev/null
+++ b/src/lexer.c
@@ -0,0 +1,253 @@
+/*
+Copyright (C) 2016  Paweł Redman
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 3
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation,
+Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+#include "common.h"
+#include <ctype.h>
+
+int lexer_open(lexer_state_t *ls, const char *path, vstr_t *token)
+{
+	ls->error = 0;
+	ls->path = path;
+
+	ls->fp = fopen(path, "r");
+	if (!ls->fp)
+		return -errno;
+
+	ls->eof = false;
+
+	ls->token = token;
+	ls->buf_e = ls->buf_c = ls->buf;
+	ls->cc = ls->lc = ls->Cc = 0;
+
+	ls->in_token = false;
+	ls->in_quote = false;
+	ls->in_comment = false;
+
+	return 0;
+}
+
+//RETURN VALUES
+//	<0 on error
+//	0 on success
+//	note: sets ls->eof to true if there's no more data left
+static int fill_buffer(lexer_state_t *ls)
+{
+	size_t read;
+
+	read = fread(ls->buf, 1, sizeof(ls->buf), ls->fp);
+	debug("read = %zu\n", read);
+	if (read < sizeof(ls->buf)) {
+		if (ferror(ls->fp)) {
+			fclose(ls->fp);
+			return -errno;
+		}
+
+		ls->eof = true;
+		fclose(ls->fp);
+		debug("no data left, ls->fp closed\n");
+	}
+
+	ls->buf_c = ls->buf;
+	ls->buf_e = ls->buf + read;
+	return 0;
+}
+
+//RETURN VALUES
+//	-ENOMEM
+//	-EAGAIN when the buffer runs out
+//	0 on success
+//	1 when no data is left
+static int read_buffer(lexer_state_t *ls)
+{
+	while (ls->buf_c < ls->buf_e) {
+		bool ret_token = false;
+
+		debug("*ls->buf_c = %c, ls->last = %c\n", *ls->buf_c, ls->last);
+
+		if (*ls->buf_c == '\n') {
+			ls->lc++;
+			ls->Cc = 0;
+		}
+
+		if (ls->in_comment) {
+			if (*ls->buf_c == '\n')
+				ls->in_comment = false;
+		} else if (isspace(*ls->buf_c) && !ls->in_quote) {
+			if (ls->in_token) {
+				ls->in_token = false;
+				ret_token = true;
+			}
+		} else if (*ls->buf_c == '/' && ls->last == '/') {
+			ls->in_comment = true;
+			ls->in_token = false;
+
+			ls->token->size--; // remove the first slash
+			if (ls->token->size)
+				ret_token = true;
+		} else if (*ls->buf_c == '\"' &&
+		           (ls->cc && ls->last != '\\')) {
+			ls->in_quote = !ls->in_quote;
+
+			if (!ls->in_quote) {
+				ls->in_token = false;
+				ret_token = true;
+			}
+		} else {
+			if (!ls->in_token) {
+				ls->in_token = true;
+			}
+		}
+
+		if (ls->in_token)
+			if (vstr_putc(ls->token, *ls->buf_c)) {
+				ls->error = ENOMEM;
+				return -ENOMEM;
+			}
+
+		ls->last = *ls->buf_c;
+		ls->buf_c++;
+		ls->cc++;
+		ls->Cc++;
+
+		if (ret_token)
+			return 0;
+	}
+
+	if (ls->eof) {
+		if (ls->token->size > 0)
+			return 0;
+		return 1;
+	}
+
+	return -EAGAIN;
+}
+
+//RETURN VALUES
+//	<0 on error
+//	0 on success
+//	1 when no data is left
+int lexer_get_token(lexer_state_t *ls)
+{
+	int ret;
+
+	vstr_clear(ls->token);
+
+	while (1) {
+		ret = read_buffer(ls);
+		debug("read_buffer = %i\n", ret);
+		if (ret != -EAGAIN)
+			return ret;
+
+		ret = fill_buffer(ls);
+		debug("fill_buffer = %i\n", ret);
+		if (ret < 0)
+			return ret;
+	}
+}
+
+void lexer_perror(lexer_state_t *ls, const char *fmt, ...)
+{
+	va_list vl;
+
+	fprintf(stderr, "%s:%zu:%zu: ", ls->path, ls->lc + 1, ls->Cc + 1);
+
+	if (ls->error) {
+		perror(NULL);
+	} else {
+		va_start(vl, fmt);
+		vfprintf(stderr, fmt, vl);
+		va_end(vl);
+	}
+}
+
+void lexer_perror_eg(lexer_state_t *ls, const char *expected)
+{
+	if (ls->eof && ls->buf_c == ls->buf_e)
+		lexer_perror(ls, "expected %s, got EOF\n", expected);
+	else {
+		vstr_termz(ls->token);
+		lexer_perror(ls, "expected %s, got \"%s\"\n", expected,
+		             ls->token->data);
+	}
+}
+
+int lexer_assert(lexer_state_t *ls, const char *match, const char *desc)
+{
+	int ret;
+
+	ret = lexer_get_token(ls);
+	if (ret) {
+		lexer_perror(ls, "expected %s%s\"%s\", got EOF\n",
+		             (desc ? desc : ""), (desc ? " " : ""), match);
+		return 1;
+	}
+
+	if (vstr_cmp(ls->token, match)) {
+		vstr_termz(ls->token);
+		lexer_perror(ls, "expected %s%s\"%s\", got \"%s\"\n",
+		             (desc ? desc : ""), (desc ? " " : ""), match,
+		             ls->token->data);
+		return 1;
+	}
+
+	return 0;
+} 
+
+//RETURN VALUE
+//	-1 on eof (also success)
+//	0 on success
+//	1 on error
+int lexer_assert_or_eof(lexer_state_t *ls, const char *match, const char *desc)
+{
+	int ret;
+
+	ret = lexer_get_token(ls);
+	if (ret < 0) {
+		perror("lexer");
+		return 1;
+	}
+
+	if (ret == 1) {
+		return -1;
+	}
+
+	if (vstr_cmp(ls->token, match)) {
+		lexer_perror(ls, "expected %s%s\"%s\" or EOF, got \"%.*s\"\n",
+		             (desc ? desc : ""), (desc ? " " : ""), match,
+		             (int)ls->token->size, ls->token->data);
+		return 1;
+	}
+
+	return 0;
+} 
+
+int lexer_get_floats(lexer_state_t *ls, float *out, size_t count)
+{
+	size_t i;
+
+	for (i = 0; i < count; i++) {
+		if (lexer_get_token(ls)) {
+			lexer_perror_eg(ls, "a number");
+			return 1;
+		}
+
+		out[i] = vstr_atof(ls->token);
+	}
+
+	return 0;
+}
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..d34f00e
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,112 @@
+/*
+Copyright (C) 2016  Paweł Redman
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 3
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation,
+Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+#include "common.h"
+#include <unistd.h>
+
+#define error(fmt, ...) fprintf(stderr, PROGRAM_NAME ": " fmt, ##__VA_ARGS__)
+
+void print_version(void)
+{
+	puts(PROGRAM_NAME " " PROGRAM_VERSION ", Copyright (C) 2016  Paweł Redman\n"
+	     PROGRAM_NAME " comes with ABSOLUTELY NO WARRANTY.\n"
+	     "This is free software, and you are welcome to redistribute it\n"
+             "under certain conditions. See the file COPYING.");
+}
+
+void print_usage(void)
+{
+	puts(PROGRAM_NAME " " PROGRAM_VERSION "\n"
+	     "usage: " PROGRAM_NAME " -o outfile infile...\n"
+	     "    or " PROGRAM_NAME " -v\n"
+	     "    or " PROGRAM_NAME " -h");
+}
+
+typedef struct {
+	char *path;
+	elist_header_t list;
+} input_file_t;
+
+int main(int argc, char **argv)
+{
+	int rv = 1, i;
+	input_file_t *inputs = NULL, *input, *next;
+	char *output = NULL;
+
+	for (i = 1; i < argc; i++) {
+		if (!strcmp(argv[i], "-v")) {
+			print_version();
+			rv = 0;
+			goto out;
+		} else if (!strcmp(argv[i], "-h")) {
+			print_usage();
+			rv = 0;
+			goto out;
+		} else if (!strcmp(argv[i], "-o")) {
+			if (i + 1 >= argc) {
+				error("-o needs an argument\n");
+				goto out;
+			}
+
+			if (output) {
+				error("-o can be specified only once\n");
+				goto out;
+			}
+
+			output = argv[i + 1];
+			i++;
+		} else {
+			input = malloc(sizeof(input_file_t));
+			if (!input) {
+				error("out of memory\n");
+				goto out;
+			}
+
+			input->path = argv[i];
+			elist_append(&inputs, input, list);
+		}
+	}
+
+	if (!inputs) {
+		error("no input files specified, try '" PROGRAM_NAME " -h'\n");
+		goto out;
+	}
+
+	if (!output) {
+		error("no output file specified, try '" PROGRAM_NAME " -h'\n");
+		goto out;
+	}
+
+	elist_for (input, inputs, list)
+		if (mapcat_load(input->path))
+			goto out;
+
+	if (mapcat_save(output))
+		goto out;
+
+	rv = 0;
+out:
+	mapcat_free();
+
+	for (input = inputs; input; input = next) {
+		next = elist_next(input, list);
+		free(input);
+	}
+
+	return rv;
+}
diff --git a/src/mapcat.c b/src/mapcat.c
new file mode 100644
index 0000000..6420cf5
--- /dev/null
+++ b/src/mapcat.c
@@ -0,0 +1,483 @@
+/*
+Copyright (C) 2016  Paweł Redman
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 3
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software Foundation,
+Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+#define DEBUG
+#include "common.h"
+
+typedef struct {
+	float def[9];
+	char *shader;
+	float texmap[8];
+	elist_header_t list;
+} brush_face_t;
+
+typedef struct {
+	brush_face_t *faces;
+	elist_header_t list;
+} brush_t;
+
+typedef struct {
+	char *key;
+	char *value;
+	elist_header_t list;
+} entity_key_t;
+
+typedef struct {
+	char *classname;
+	brush_t *brushes;
+	entity_key_t *keys;
+
+	elist_header_t list;
+} entity_t;
+
+entity_t *worldspawn;
+entity_t *entities;
+
+static int read_entity_key(lexer_state_t *ls, entity_t *entity)
+{
+	entity_key_t *key;
+
+	// classnames are stored separately for easier access later
+	if (!vstr_cmp(ls->token, "classname")) {
+		if (entity->classname) {
+			lexer_perror(ls, "warning: duplicate classname\n");
+			free(entity->classname);
+			entity->classname = NULL;
+		}
+
+		if (lexer_get_token(ls)) {
+			lexer_perror_eg(ls, "the classname");
+			return 1;
+		}
+
+		entity->classname = vstr_strdup(ls->token);
+		if (!entity->classname) {
+			lexer_perror(ls, "out of memory\n");
+			return 1;
+		}
+
+		return 0;
+	}
+
+	key = malloc(sizeof(entity_key_t));
+	if (!key)
+		goto error_oom;
+
+	memset(key, 0, sizeof(*key));
+	elist_append(&entity->keys, key, list);
+
+	key->key = vstr_strdup(ls->token);
+	if (!key->key)
+		goto error_oom;
+
+	if (lexer_get_token(ls)) {
+		lexer_perror_eg(ls, "the key value");
+		return 1;
+	}
+
+	key->value = vstr_strdup(ls->token);
+	if (!key->value)
+		goto error_oom;
+
+	return 0;
+error_oom:
+	lexer_perror(ls, "out of memory\n");
+	return 1;
+}
+
+static int read_brush_face(lexer_state_t *ls, brush_t *brush)
+{
+	brush_face_t *face;
+
+	face = malloc(sizeof(brush_face_t));
+	if (!face) {
+		lexer_perror(ls, "out of memory\n");
+		return 1;
+	}
+
+	memset(face, 0, sizeof(*face));
+	elist_append(&brush->faces, face, list);
+
+	if (lexer_get_floats(ls, face->def, 3))
+		return 1;
+
+	if (lexer_assert(ls, ")", "the end of this face's 1st vector"))
+		return 1;
+
+	if (lexer_assert(ls, "(", "the beginning of this face's 2nd vector"))
+		return 1;
+
+	if (lexer_get_floats(ls, face->def + 3, 3))
+		return 1;
+
+	if (lexer_assert(ls, ")", "the end of this face's 2nd vector"))
+		return 1;
+
+	if (lexer_assert(ls, "(", "the beginning of this face's 3rd vector"))
+		return 1;
+
+	if (lexer_get_floats(ls, face->def + 6, 3))
+		return 1;
+
+	if (lexer_assert(ls, ")", "the end of this face's 3rd vector"))
+		return 1;
+
+	if (lexer_get_token(ls)) {
+		lexer_perror_eg(ls, "a shader name");
+		return 1;
+	}
+
+	face->shader = vstr_strdup(ls->token);
+	if (!face->shader) {
+		lexer_perror(ls, "out of memory\n");
+		return 1;
+	}
+
+	if (lexer_get_floats(ls, face->texmap, 8))
+		return 1;
+
+	return 0;
+}
+
+static int read_brush_faces(lexer_state_t *ls, brush_t *brush)
+{
+	while (1) {
+		if (lexer_get_token(ls)) {
+			lexer_perror_eg(ls, "the beginning of a brush face "
+			                    " ('(') or the end of this brush"
+			                    " ('}')");
+			return 1;
+		}
+
+		if (!vstr_cmp(ls->token, "(")) {
+			if (read_brush_face(ls, brush))
+				return 1;
+		} else if (!vstr_cmp(ls->token, "}"))
+			break;
+	}
+
+	return 0;
+}
+
+static void free_entity_keys(entity_t *entity)
+{
+	entity_key_t *key, *next;
+
+	for (key = entity->keys; key; key = next) {
+		next = elist_next(key, list);
+
+		free(key->key);
+		free(key->value);
+		free(key);
+	}
+}
+
+static void free_brush(brush_t *brush)
+{
+	brush_face_t *face, *face_next;
+
+	for (face = brush->faces; face; face = face_next) {
+		face_next = elist_next(face, list);
+
+		free(face->shader);
+		free(face);
+	}
+
+	free(brush);
+}
+
+// this frees an entity_t and its children
+// note: this function does NOT unlink the entity from the global list
+static void free_entity(entity_t *entity)
+{
+	brush_t *brush, *next;
+
+	free_entity_keys(entity);
+	free(entity->classname);
+
+	for (brush = entity->brushes; brush; brush = next) {
+		next = elist_next(brush, list);
+		free_brush(brush);
+	}
+
+	free(entity);
+}
+
+static void merge_into_worldspawn(entity_t *entity)
+{
+	// the first worldspawn becomes the output's worldspawn.
+	// other worldspawn's brushes are appended to it
+	if (!worldspawn) {
+		worldspawn = entity;
+		return;
+	}
+
+	// keep only the original key-value pairs
+	free_entity_keys(entity);
+
+	elist_append_list(worldspawn->brushes, entity->brushes, list);
+
+	free(entity);
+}
+
+static bool brush_discard(brush_t *brush)
+{
+	brush_face_t *face;
+
+	elist_for(face, brush->faces, list)
+		if (!strcmp(face->shader, "mapcat_discard"))
+			return true;
+
+	return false;
+}
+
+static int read_entity(lexer_state_t *ls)
+{
+	entity_t *entity;
+
+	entity = malloc(sizeof(entity_t));
+	if (!entity) {
+		lexer_perror(ls, "out of memory\n");
+		return 1;
+	}
+
+	memset(entity, 0, sizeof(*entity));
+
+	// read keys and values
+	while (1) {
+		if (lexer_get_token(ls)) {
+			lexer_perror_eg(ls, "a key or the beginning of a brush"
+			                    " \"{\" or the end of this entity"
+			                    " \"}\"");
+			goto error;
+		}
+
+		if (!vstr_cmp(ls->token, "{"))
+			break;
+
+		if (!vstr_cmp(ls->token, "}"))
+			goto no_brushes;
+
+		if (read_entity_key(ls, entity))
+			goto error;
+	}
+
+	// the opening brace of the first brush in this entity was already
+	// read in the loop above, so it has to be skipped in the loop below.
+	// the problem is solved by jumping in the middle of the loop
+	goto skip_first_brace;
+
+	while (1) {
+		brush_t *brush;
+
+		if (lexer_get_token(ls)) {
+		L1:
+			lexer_perror_eg(ls, "the beginning of a brush \"{\""
+			                    " or the end of this entity \"}\"");
+			goto error;
+		}
+
+		if (!vstr_cmp(ls->token, "}"))
+			break;
+		else if (vstr_cmp(ls->token, "{"))
+			goto L1;
+
+	skip_first_brace:
+		brush = malloc(sizeof(brush_t));
+		if (!brush) {
+			lexer_perror(ls, "out of memory\n");
+			goto error;
+		}
+
+		memset(brush, 0, sizeof(*brush));
+
+		if (read_brush_faces(ls, brush)) {
+			free_brush(brush);
+			goto error;
+		}
+
+		if (brush_discard(brush))
+			free_brush(brush);
+		else
+			elist_append(&entity->brushes, brush, list);
+	}
+
+no_brushes:
+
+	if (entity->classname && !strcmp(entity->classname, "worldspawn"))
+		merge_into_worldspawn(entity);
+	else
+		elist_append(&entities, entity, list);
+
+	return 0;
+error:
+	free_entity(entity);
+	return 1;
+}
+
+
+int mapcat_load(const char *path)
+{
+	int rv = 1;
+	lexer_state_t lexer;
+	vstr_t token;
+
+	vstr_init(&token);
+
+	if (lexer_open(&lexer, path, &token)) {
+		perror(path);
+		return 1;
+	}
+
+	while (1) {
+		int ret;
+
+		ret = lexer_assert_or_eof(&lexer, "{",
+		                          "the beginning of an entity");
+		if (ret == -1)
+			break;
+		if (ret > 0)
+			goto out;
+
+		if (read_entity(&lexer))
+			goto out;
+	}
+
+	rv = 0;
+out:
+	vstr_free(&token);
+	return rv;
+}
+
+static int write_brush(FILE *fp, brush_t *brush)
+{
+	brush_face_t *face;
+
+	elist_for(face, brush->faces, list) {
+		size_t i;
+
+		for (i = 0; i < 9; i += 3) {
+			if (i)
+				fprintf(fp, " ");
+
+			fprintf(fp, "( %f %f %f )", face->def[i],
+			        face->def[i + 1], face->def[i + 2]);
+		}
+
+		fprintf(fp, " %s", face->shader);
+
+		for (i = 0; i < 5; i++)
+			fprintf(fp, " %f", face->texmap[i]);
+
+		// the last three values are integers
+		for (i = 5; i < 8; i++)
+			fprintf(fp, " %.0f", face->texmap[i]);
+
+		fprintf(fp, "\n");
+	}
+
+	if (ferror(fp))
+		return -errno;
+
+	return 0;
+}
+
+static int write_entity(FILE *fp, entity_t *entity)
+{
+	entity_key_t *key;
+	brush_t *brush;
+	size_t brush_counter = 0;
+
+	fprintf(fp, "\"classname\" \"%s\"\n", entity->classname);
+
+	elist_for(key, entity->keys, list)
+		fprintf(fp, "\"%s\" \"%s\"\n", key->key, key->value);
+
+	elist_for(brush, entity->brushes, list) {
+		fprintf(fp, "// brush %zu\n{\n", brush_counter);
+		write_brush(fp, brush);
+		fprintf(fp, "}\n");
+		brush_counter++;
+	}
+
+	if (ferror(fp))
+		return -errno;
+
+	return 0;
+}
+
+int mapcat_save(const char *path)
+{
+	int rv = 1;
+	FILE *fp;
+	entity_t *entity;
+	size_t entity_counter = 1; // worldspawn is #0
+
+	fp = fopen(path, "w");
+	if (!fp) {
+		perror(path);
+		goto out;
+	}
+
+	if (!worldspawn) {
+		fprintf(stderr, "error: worldspawn is missing\n");
+		goto out;
+	}
+
+	fprintf(fp, "// entity 0\n{\n");
+	write_entity(fp, worldspawn);
+	fprintf(fp, "}\n");
+
+	elist_for(entity, entities, list) {
+		fprintf(fp, "// entity %zu\n{\n", entity_counter);
+
+		if (write_entity(fp, entity)) {
+			perror(path);
+			goto out;
+		}
+	 
+		fprintf(fp, "}\n");
+		entity_counter++;
+	}
+
+	if (ferror(fp) || fclose(fp)) {
+		perror(path);
+		goto out;
+	}
+
+	fp = NULL;
+	rv = 0;
+
+out:
+	if (fp)
+		fclose(fp);
+	return rv;
+}
+
+void mapcat_free(void)
+{
+	entity_t *entity, *next;
+
+	if (worldspawn)
+		free_entity(worldspawn);
+
+	for (entity = entities; entity; entity = next) {
+		next = elist_next(entity, list);
+		free_entity(entity);
+	}
+}