Import a slightly modified Bayou version into svn. This is based

on the last snapshot posted by Jordan Crouse. This commit is long
overdue.

Changes by me include:

 - Rename 'utils' to 'util' for consistency with our other projects.

 - Move the main code out of src/* into the top-level directory.

 - Add missing license headers to the following files:
   Makefile, pbuilder/liblar/Makefile, util/pbuilder/Makefile.

 - Dropped the util/pbuilder/lzma completely. I'm working on reusing
   the lzma/ dir from v3 via svn:externals. Alas, this also means
   that Bayou won't yet compile out of the box.

 - Coding-style and white-space fixes (indent) for all files.

Signed-off-by: Uwe Hermann <uwe@hermann-uwe.de>
Acked-by: Uwe Hermann <uwe@hermann-uwe.de>



git-svn-id: svn://svn.coreboot.org/coreboot/trunk@3719 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1

1 files changed, 265 insertions, 0 deletions

diff --git a/payloads/bayou/util/pbuilder/config.c b/payloads/bayou/util/pbuilder/config.c
new file mode 100644
index 0000000000..7b517335e3
--- /dev/null
+++ b/payloads/bayou/util/pbuilder/config.c
@@ -0,0 +1,265 @@
+/*
+ * This file is part of the bayou project.
+ *
+ * Copyright (C) 2008 Advanced Micro Devices, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * 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 St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+
+#define _GNU_SOURCE
+
+#include <stdlib.h>
+#include <string.h>
+#include <expat.h>
+#include <ctype.h>
+#include "pbuilder.h"
+
+#define STATE_NONE                   0x00
+#define STATE_BAYOUCONFIG            0x01
+#define STATE_GLOBAL                 0x02
+#define STATE_GLOBAL_TIMEOUT         0x03
+#define STATE_PAYLOADS               0x04
+#define STATE_PAYLOAD                0x05
+#define STATE_PAYLOAD_TITLE          0x06
+#define STATE_PAYLOAD_FILE           0x07
+#define STATE_PAYLOAD_LARNAME        0x08
+#define STATE_PAYLOAD_CHAIN          0x09
+#define STATE_PAYLOAD_CHAIN_FILE     0x0A
+#define STATE_PAYLOAD_CHAIN_LARNAME  0x0B
+
+static struct userdata {
+	struct config *config;
+	struct pentry *payload;
+	struct pentry *chain;
+	int state;
+} userdata;
+
+static char buffer[8192];
+
+static struct {
+	char *element;
+	int pstate;
+	int state;
+} states[] = {
+	{"BayouConfig", STATE_NONE, STATE_BAYOUCONFIG},
+	{"global", STATE_BAYOUCONFIG, STATE_GLOBAL},
+	{"timeout", STATE_GLOBAL, STATE_GLOBAL_TIMEOUT},
+	{"payloads", STATE_BAYOUCONFIG, STATE_PAYLOADS},
+	{"payload", STATE_PAYLOADS, STATE_PAYLOAD},
+	{"title", STATE_PAYLOAD, STATE_PAYLOAD_TITLE},
+	{"lar", STATE_PAYLOAD, STATE_PAYLOAD_LARNAME},
+	{"file", STATE_PAYLOAD, STATE_PAYLOAD_FILE},
+	{"chain", STATE_PAYLOAD, STATE_PAYLOAD_CHAIN},
+	{"file", STATE_PAYLOAD_CHAIN, STATE_PAYLOAD_CHAIN_FILE},
+	{"lar", STATE_PAYLOAD_CHAIN, STATE_PAYLOAD_CHAIN_LARNAME},
+	{NULL},
+};
+
+static struct pentry *newPayload(struct config *config)
+{
+	struct pentry **tmp, *ret;
+
+	tmp = realloc(config->entries,
+		      (config->n_entries + 1) * sizeof(struct pentry *));
+
+	if (tmp == NULL)
+		return NULL;
+
+	config->entries = tmp;
+
+	ret = config->entries[config->n_entries] = calloc(sizeof(*ret), 1);
+
+	if (ret == NULL)
+		return NULL;
+
+	/* Yes, I want this to be ++config->n_entries (the index is 1 based). */
+	ret->index = ++config->n_entries;
+
+	return ret;
+}
+
+static void parseFlags(struct pentry *entry, const char *flags)
+{
+	char *p = (char *)flags;
+	char *n;
+
+	while (*p) {
+		n = strchr(p, ',');
+
+		if (n)
+			*(n++) = 0;
+
+		if (!strcmp(p, "default"))
+			entry->flags |= BPT_FLAG_DEFAULT;
+		else if (!strcmp(p, "nolist"))
+			entry->flags |= BPT_FLAG_NOSHOW;
+		else
+			warn("W: Unknown payload flag %s\n", p);
+
+		if (!n)
+			break;
+
+		for (p = n; *p && isspace(*p); p++) ;
+	}
+}
+
+static struct pentry *addPayload(struct config *config, const char **attr)
+{
+	struct pentry *ret = newPayload(config);
+	int i = 0;
+
+	if (ret == NULL)
+		die("E: Could not allocate memory for a new payload\n");
+
+	while (attr[i] != NULL) {
+		if (!strcmp(attr[i], "type")) {
+			if (!strcmp(attr[i + 1], "chain"))
+				ret->type = BPT_TYPE_CHAIN;
+			else if (!strcmp(attr[i + 1], "chooser"))
+				ret->type = BPT_TYPE_CHOOSER;
+			else
+				die("E: Invalid payload type %s\n",
+				    attr[i + 1]);
+		} else if (!strcmp(attr[i], "flags"))
+			parseFlags(ret, attr[i + 1]);
+
+		i += 2;
+	}
+
+	return ret;
+}
+
+static struct pentry *addChain(struct config *config, struct pentry *parent)
+{
+	struct pentry *ret = newPayload(config);
+
+	if (ret == NULL)
+		die("E: Could not allocate memory for a new payload\n");
+
+	ret->parent = parent->index;
+	ret->type = BPT_TYPE_SUBCHAIN;
+
+	return ret;
+}
+
+static void start(void *data, const char *el, const char **attr)
+{
+	int i;
+	struct userdata *d = (struct userdata *)data;
+
+	for (i = 0; states[i].element != NULL; i++) {
+		if (d->state != states[i].pstate)
+			continue;
+
+		if (!strcmp(el, states[i].element)) {
+			d->state = states[i].state;
+			break;
+		}
+	}
+
+	if (states[i].element == NULL)
+		die("E: Unknown element %s\n", el);
+
+	if (d->state == STATE_PAYLOAD)
+		d->payload = addPayload(d->config, attr);
+
+	if (d->state == STATE_PAYLOAD_CHAIN)
+		d->chain = addChain(d->config, d->payload);
+}
+
+static void data(void *data, const char *val, int len)
+{
+	struct userdata *d = (struct userdata *)data;
+	int l;
+
+	switch (d->state) {
+	case STATE_GLOBAL_TIMEOUT:
+		d->config->timeout = atoi(val);
+		break;
+	case STATE_PAYLOAD_TITLE:
+		l = sizeof(d->payload->title) - 1 > len ?
+		    len : sizeof(d->payload->title) - 1;
+
+		strncpy((char *)d->payload->title, (char *)val, l);
+		d->payload->title[l] = '\0';
+		break;
+	case STATE_PAYLOAD_FILE:
+		d->payload->file = strndup(val, len);
+		break;
+	case STATE_PAYLOAD_LARNAME:
+		d->payload->larname = strndup(val, len);
+		break;
+	case STATE_PAYLOAD_CHAIN_FILE:
+		d->chain->file = strndup(val, len);
+		break;
+	case STATE_PAYLOAD_CHAIN_LARNAME:
+		d->chain->larname = strndup(val, len);
+		break;
+	default:
+		break;
+	}
+}
+
+static void end(void *data, const char *el)
+{
+	struct userdata *d = (struct userdata *)data;
+	int i;
+
+	if (d->state == STATE_PAYLOAD_CHAIN)
+		d->chain = NULL;
+
+	if (d->state == STATE_PAYLOAD)
+		d->payload = NULL;
+
+	for (i = 0; states[i].element != NULL; i++) {
+		if (d->state != states[i].state)
+			continue;
+
+		if (!strcmp(el, states[i].element)) {
+			d->state = states[i].pstate;
+			break;
+		}
+	}
+
+	if (states[i].element == NULL)
+		die("E:  Unable to find the reverse state for %s\n", el);
+}
+
+void parseconfig(FILE *stream, struct config *config)
+{
+	XML_Parser p = XML_ParserCreate(NULL);
+	int eof = 0;
+
+	if (p == NULL)
+		die("E: Could not create the parser\n");
+
+	XML_SetElementHandler(p, start, end);
+	XML_SetCharacterDataHandler(p, data);
+
+	userdata.config = config;
+
+	XML_SetUserData(p, &userdata);
+
+	while (!eof) {
+		int len = fread(buffer, 1, 8192, stream);
+
+		eof = feof(stream);
+
+		if (ferror(stream))
+			die("E: Error reading the stream\n");
+
+		if (!XML_Parse(p, buffer, len, eof))
+			die("E: Error parsing the XML data\n");
+	}
+}