diff options
| -rw-r--r-- | Makefile.in | 1 | ||||
| -rw-r--r-- | include/internal/parse_config.h | 50 | ||||
| -rw-r--r-- | libc/misc/internals/Makefile.in | 8 | ||||
| -rw-r--r-- | libc/misc/internals/parse_config.c | 268 |
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; +} |