add config parser

Signed-off-by: Bernhard Reutner-Fischer <rep.dot.nop@gmail.com>

4 files changed, 324 insertions, 3 deletions

diff --git a/Makefile.in b/Makefile.in
index 3767ea498..1c0e30571 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -202,6 +202,7 @@ $(top_builddir)extra/scripts/unifdef: $(top_srcdir)extra/scripts/unifdef.c
 # a "y" here means the feature is enabled and so we should *not* rm it.
 # if the option expands to nothing though, we can punt the headers.
 HEADERS_RM- := \
+	internal \
 	dl-osinfo.h \
 	_lfs_64.h \
 	bits/uClibc_arch_features.h \
diff --git a/include/internal/parse_config.h b/include/internal/parse_config.h
new file mode 100644
index 000000000..e5241105c
--- /dev/null
+++ b/include/internal/parse_config.h
@@ -0,0 +1,50 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * config file parser helper
+ *
+ * Copyright (C) 2008 by Vladimir Dronnikov <dronnikov@gmail.com>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Also for use in uClibc (http://uclibc.org/) licensed under LGPLv2.1 or later.
+ */
+
+#include <stdio.h>
+#ifndef FAST_FUNC
+# define FAST_FUNC
+#endif
+
+/*
+ * Config file parser
+ */
+enum {
+	PARSE_COLLAPSE  = 0x00010000, /* treat consecutive delimiters as one */
+	PARSE_TRIM      = 0x00020000, /* trim leading and trailing delimiters */
+/* TODO: COLLAPSE and TRIM seem to always go in pair */
+	PARSE_GREEDY    = 0x00040000, /* last token takes entire remainder of the line */
+	PARSE_MIN_DIE   = 0x00100000, /* die if < min tokens found */
+	/* keep a copy of current line */
+	PARSE_KEEP_COPY = 0x00200000 * 0, /*ENABLE_FEATURE_CROND_D, */
+/*	PARSE_ESCAPE    = 0x00400000,*/ /* process escape sequences in tokens */
+	/* NORMAL is:
+	   * remove leading and trailing delimiters and collapse
+	     multiple delimiters into one
+	   * warn and continue if less than mintokens delimiters found
+	   * grab everything into last token
+	 */
+	PARSE_NORMAL    = PARSE_COLLAPSE | PARSE_TRIM | PARSE_GREEDY,
+};
+
+typedef struct parser_t {
+	FILE *fp; /* input file */
+	char *data; /* pointer to data */
+	size_t data_len; /* offset into data of begin of line */
+	char *line; /* pointer to beginning of line */
+	size_t line_len; /* length of line */
+	smalluint allocated;
+} parser_t;
+parser_t* config_open(const char *filename) FAST_FUNC attribute_hidden;
+int config_read(parser_t *parser, char ***tokens, unsigned flags, const char *delims) FAST_FUNC attribute_hidden;
+#define config_read(parser, tokens, max, min, str, flags) \
+	config_read(parser, tokens, ((flags) | (((min) & 0xFF) << 8) | ((max) & 0xFF)), str)
+void config_close(parser_t *parser) FAST_FUNC attribute_hidden;
+
diff --git a/libc/misc/internals/Makefile.in b/libc/misc/internals/Makefile.in
index eb78e3698..354dfc980 100644
--- a/libc/misc/internals/Makefile.in
+++ b/libc/misc/internals/Makefile.in
@@ -7,9 +7,8 @@
 
 subdirs += libc/misc/internals
 
-CFLAGS-__uClibc_main.c := $(SSP_DISABLE_FLAGS)
-
-CSRC := tempname.c errno.c __errno_location.c __h_errno_location.c
+CSRC := tempname.c errno.c __errno_location.c __h_errno_location.c \
+	parse_config.c
 
 MISC_INTERNALS_DIR := $(top_srcdir)libc/misc/internals
 MISC_INTERNALS_OUT := $(top_builddir)libc/misc/internals
@@ -17,6 +16,9 @@ MISC_INTERNALS_OUT := $(top_builddir)libc/misc/internals
 MISC_INTERNALS_SRC := $(patsubst %.c,$(MISC_INTERNALS_DIR)/%.c,$(CSRC))
 MISC_INTERNALS_OBJ := $(patsubst %.c,$(MISC_INTERNALS_OUT)/%.o,$(CSRC))
 
+CFLAGS-__uClibc_main.c := $(SSP_DISABLE_FLAGS)
+
+
 libc-y += $(MISC_INTERNALS_OBJ)
 ifneq ($(UCLIBC_FORMAT_SHARED_FLAT),y)
 libc-shared-y += $(MISC_INTERNALS_OUT)/__uClibc_main.oS
diff --git a/libc/misc/internals/parse_config.c b/libc/misc/internals/parse_config.c
new file mode 100644
index 000000000..cbb6ef7f1
--- /dev/null
+++ b/libc/misc/internals/parse_config.c
@@ -0,0 +1,268 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * config file parser helper
+ *
+ * Copyright (C) 2008 by Vladimir Dronnikov <dronnikov@gmail.com>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Also for use in uClibc (http://uclibc.org/) licensed under LGPLv2.1 or later.
+ */
+
+#if !defined _LIBC
+#include "libbb.h"
+
+#if defined ENABLE_PARSE && ENABLE_PARSE
+int parse_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int parse_main(int argc UNUSED_PARAM, char **argv)
+{
+	const char *delims = "# \t";
+	unsigned flags = PARSE_NORMAL;
+	int mintokens = 0, ntokens = 128;
+
+	opt_complementary = "-1:n+:m+:f+";
+	getopt32(argv, "n:m:d:f:", &ntokens, &mintokens, &delims, &flags);
+	//argc -= optind;
+	argv += optind;
+	while (*argv) {
+		parser_t *p = config_open(*argv);
+		if (p) {
+			int n;
+			char **t = xmalloc(sizeof(char *) * ntokens);
+			while ((n = config_read(p, t, ntokens, mintokens, delims, flags)) != 0) {
+				for (int i = 0; i < n; ++i)
+					printf("[%s]", t[i]);
+				puts("");
+			}
+			config_close(p);
+		}
+		argv++;
+	}
+	return EXIT_SUCCESS;
+}
+#endif
+#else
+# include <unistd.h>
+# include <string.h>
+# include <malloc.h>
+# include "internal/parse_config.h"
+# ifndef FAST_FUNC
+#  define FAST_FUNC
+# endif
+# define fopen_or_warn_stdin fopen
+# define bb_error_msg(...)
+# define xstrdup strdup
+# define xfunc_die() return 0
+/* Read up to EOF or EOL, treat line-continuations as extending the line.
+   Return number of bytes read into .line, -1 otherwise  */
+static off_t bb_get_chunk_with_continuation(parser_t* parsr)
+{
+	off_t pos = 0;
+	char *chp;
+
+	while (1) {
+		if (fgets(parsr->line + pos, parsr->line_len, parsr->fp) == NULL) {
+			memset(parsr->line, 0, parsr->line_len);
+			pos = -1;
+			break;
+		}
+		pos += strlen(parsr->line + pos);
+		chp = strchr(parsr->line, '\n');
+		if (chp) {
+			--pos;
+			if (--*chp == '\\')
+				--pos;
+			else
+				break;
+		}
+	}
+	return pos;
+}
+#endif
+
+/*
+
+Typical usage:
+
+----- CUT -----
+	char *t[3];	// tokens placeholder
+	parser_t *p = config_open(filename);
+	if (p) {
+		// parse line-by-line
+		while (config_read(p, t, 3, 0, delimiters, flags)) { // 1..3 tokens
+			// use tokens
+			bb_error_msg("TOKENS: [%s][%s][%s]", t[0], t[1], t[2]);
+		}
+		...
+		// free parser
+		config_close(p);
+	}
+----- CUT -----
+
+*/
+
+static __always_inline parser_t * FAST_FUNC config_open2(const char *filename,
+	FILE* FAST_FUNC (*fopen_func)(const char *path, const char *mode))
+{
+	parser_t *parser;
+	FILE* fp;
+
+	fp = fopen_func(filename, "r");
+	if (!fp)
+		return NULL;
+	parser = malloc(sizeof(*parser));
+	if (parser) {
+		memset(parser, 0, sizeof(*parser));
+		parser->fp = fp;
+	}
+	return parser;
+}
+
+parser_t attribute_hidden * FAST_FUNC config_open(const char *filename)
+{
+	return config_open2(filename, fopen_or_warn_stdin);
+}
+
+#ifdef UNUSED
+static void config_free_data(parser_t *parser)
+{
+	free(parser->data);
+	parser->data = parser->line = NULL;
+}
+#endif
+
+void attribute_hidden FAST_FUNC config_close(parser_t *parser)
+{
+	if (parser) {
+		fclose(parser->fp);
+		if (parser->allocated)
+			free(parser->data);
+		free(parser);
+	}
+}
+
+/*
+0. If parser is NULL return 0.
+1. Read a line from config file. If nothing to read then return 0.
+   Handle continuation character. Advance lineno for each physical line.
+   Discard everything past comment character.
+2. if PARSE_TRIM is set (default), remove leading and trailing delimiters.
+3. If resulting line is empty goto 1.
+4. Look for first delimiter. If !PARSE_COLLAPSE or !PARSE_TRIM is set then
+   remember the token as empty.
+5. Else (default) if number of seen tokens is equal to max number of tokens
+   (token is the last one) and PARSE_GREEDY is set then the remainder
+   of the line is the last token.
+   Else (token is not last or PARSE_GREEDY is not set) just replace
+   first delimiter with '\0' thus delimiting the token.
+6. Advance line pointer past the end of token. If number of seen tokens
+   is less than required number of tokens then goto 4.
+7. Check the number of seen tokens is not less the min number of tokens.
+   Complain or die otherwise depending on PARSE_MIN_DIE.
+8. Return the number of seen tokens.
+
+mintokens > 0 make config_read() print error message if less than mintokens
+(but more than 0) are found. Empty lines are always skipped (not warned about).
+*/
+#undef config_read
+int attribute_hidden FAST_FUNC config_read(parser_t *parser, char ***tokens,
+											unsigned flags, const char *delims)
+{
+	char *line;
+	int ntokens, mintokens;
+	off_t len;
+	int t;
+
+	if (parser == NULL)
+		return 0;
+	ntokens = flags & 0xFF;
+	mintokens = (flags & 0xFF00) >> 8;
+again:
+	if (parser->data == NULL) {
+		if (parser->line_len == 0)
+			parser->line_len = 81;
+		if (parser->data_len == 0)
+			parser->data_len += 1 + ntokens * sizeof(char *);
+		parser->data = realloc(parser->data,
+								parser->data_len + parser->line_len);
+		if (parser->data == NULL)
+			return 0;
+		parser->allocated |= 1;
+	} /* else { assert(parser->data_len > 0); } */
+	if (parser->line == NULL)
+		parser->line = parser->data + parser->data_len;
+	if (*tokens == NULL)
+		*tokens = (char **) parser->data;
+	memset(*tokens, 0, sizeof(*tokens[0]) * ntokens);
+	/*config_free_data(parser);*/
+
+	/* Read one line (handling continuations with backslash) */
+	len = bb_get_chunk_with_continuation(parser);
+	if (len == -1)
+		return 0;
+	line = parser->line;
+
+	/* Skip token in the start of line? */
+	if (flags & PARSE_TRIM)
+		line += strspn(line, delims + 1);
+
+	if (line[0] == '\0' || line[0] == delims[0])
+		goto again;
+
+	/* Tokenize the line */
+	for (t = 0; *line && *line != delims[0] && t < ntokens; t++) {
+		/* Pin token */
+		*(*tokens + t) = line;
+
+		/* Combine remaining arguments? */
+		if ((t != ntokens-1) || !(flags & PARSE_GREEDY)) {
+			/* Vanilla token, find next delimiter */
+			line += strcspn(line, delims[0] ? delims : delims + 1);
+		} else {
+			/* Combining, find comment char if any */
+			line = strchrnul(line, delims[0]);
+
+			/* Trim any extra delimiters from the end */
+			if (flags & PARSE_TRIM) {
+				while (strchr(delims + 1, line[-1]) != NULL)
+					line--;
+			}
+		}
+
+		/* Token not terminated? */
+		if (line[0] == delims[0])
+			*line = '\0';
+		else if (line[0] != '\0')
+			*(line++) = '\0';
+
+#if 0 /* unused so far */
+		if (flags & PARSE_ESCAPE) {
+			const char *from;
+			char *to;
+
+			from = to = tokens[t];
+			while (*from) {
+				if (*from == '\\') {
+					from++;
+					*to++ = bb_process_escape_sequence(&from);
+				} else {
+					*to++ = *from++;
+				}
+			}
+			*to = '\0';
+		}
+#endif
+
+		/* Skip possible delimiters */
+		if (flags & PARSE_COLLAPSE)
+			line += strspn(line, delims + 1);
+	}
+
+	if (t < mintokens) {
+		bb_error_msg(/*"bad line %u: "*/"%d tokens found, %d needed",
+				/*parser->lineno, */t, mintokens);
+		if (flags & PARSE_MIN_DIE)
+			xfunc_die();
+		goto again;
+	}
+	return t;
+}