#include <stdio.h>
#include <ctype.h>
-#define LINEBUF 128
+#define LINEBUF 32
#define LINEBUF_MAX 4096
/*
* Fetch a new line from the input stream and resize buffer if necessary
*/
-static void uci_getln(struct uci_context *ctx)
+static void uci_getln(struct uci_context *ctx, int offset)
{
struct uci_parse_context *pctx = ctx->pctx;
char *p;
pctx->bufsz = LINEBUF;
}
- ofs = 0;
+ ofs = offset;
do {
p = &pctx->buf[ofs];
p[ofs] = 0;
p = fgets(p, pctx->bufsz - ofs, pctx->file);
- if (!p || !p[ofs])
+ if (!p || !*p)
return;
ofs += strlen(p);
}
/*
- * Clean up all extra memory used by the parser
+ * Clean up all extra memory used by the parser and exporter
*/
-static void uci_parse_cleanup(struct uci_context *ctx)
+static void uci_file_cleanup(struct uci_context *ctx)
{
struct uci_parse_context *pctx;
+ if (ctx->buf) {
+ free(ctx->buf);
+ ctx->buf = NULL;
+ ctx->bufsz = 0;
+ }
+
pctx = ctx->pctx;
if (!pctx)
return;
ctx->pctx = NULL;
- if (pctx->cfg) {
- uci_list_del(&pctx->cfg->list);
- uci_drop_config(pctx->cfg);
+ if (pctx->package) {
+ uci_list_del(&pctx->package->list);
+ uci_drop_config(pctx->package);
}
if (pctx->buf)
free(pctx->buf);
free(pctx);
}
+/*
+ * parse a character escaped by '\'
+ * returns true if the escaped character is to be parsed
+ * returns false if the escaped character is to be ignored
+ */
+static inline bool parse_backslash(struct uci_context *ctx, char **str)
+{
+ /* skip backslash */
+ *str += 1;
+
+ /* undecoded backslash at the end of line, fetch the next line */
+ if (!**str) {
+ *str += 1;
+ uci_getln(ctx, *str - ctx->pctx->buf);
+ return false;
+ }
+
+ /* FIXME: decode escaped char, necessary? */
+ return true;
+}
+
/*
* move the string pointer forward until a non-whitespace character or
* EOL is reached
*/
-static void skip_whitespace(char **str)
+static void skip_whitespace(struct uci_context *ctx, char **str)
{
+restart:
while (**str && isspace(**str))
*str += 1;
+
+ if (**str == '\\') {
+ if (!parse_backslash(ctx, str))
+ goto restart;
+ }
}
static inline void addc(char **dest, char **src)
*src += 1;
}
-static inline void parse_backslash(char **str, char **target)
-{
- /* skip backslash */
- *str += 1;
- /* FIXME: decode escaped characters? */
- addc(target, str);
-}
-
/*
* parse a double quoted string argument from the command line
*/
while ((c = **str)) {
switch(c) {
- case '\\':
- parse_backslash(str, target);
- continue;
case '"':
**target = 0;
*str += 1;
return;
+ case '\\':
+ if (!parse_backslash(ctx, str))
+ continue;
+ /* fall through */
default:
addc(target, str);
break;
{
do {
switch(**str) {
- case '\\':
- parse_backslash(str, target);
- continue;
case '\'':
parse_single_quote(ctx, str, target);
break;
break;
case 0:
goto done;
+ case '\\':
+ if (!parse_backslash(ctx, str))
+ continue;
+ /* fall through */
default:
addc(target, str);
break;
char *ptr;
val = ptr = *str;
- skip_whitespace(str);
+ skip_whitespace(ctx, str);
parse_str(ctx, str, &ptr);
if (required && !*val) {
ctx->pctx->reason = "insufficient arguments";
name = pctx->name;
/* add the last config to main config file list */
- if (pctx->cfg) {
- uci_list_add(&ctx->root, &pctx->cfg->list);
+ if (pctx->package) {
+ uci_list_add(&ctx->root, &pctx->package->list);
- pctx->cfg = NULL;
+ pctx->package = NULL;
pctx->section = NULL;
}
ignore:
ctx->errno = 0;
- pctx->cfg = uci_alloc_config(ctx, name);
+ pctx->package = uci_alloc_config(ctx, name);
+}
+
+/*
+ * parse the 'package' uci command (next config package)
+ */
+static void uci_parse_package(struct uci_context *ctx, char **str)
+{
+ char *name = NULL;
+
+ /* command string null-terminated by strtok */
+ *str += strlen(*str) + 1;
+
+ UCI_TRAP_SAVE(ctx, error);
+ name = next_arg(ctx, str, true);
+ assert_eol(ctx, str);
+ ctx->pctx->name = name;
+ uci_switch_config(ctx);
+ UCI_TRAP_RESTORE(ctx);
+ return;
+
+error:
+ if (name)
+ free(name);
+ UCI_THROW(ctx, ctx->errno);
}
/*
char *name = NULL;
char *type = NULL;
- if (!ctx->pctx->cfg) {
+ if (!ctx->pctx->package) {
if (!ctx->pctx->name) {
ctx->pctx->byte = *str - ctx->pctx->buf;
ctx->pctx->reason = "attempting to import a file without a package name";
type = next_arg(ctx, str, true);
name = next_arg(ctx, str, false);
assert_eol(ctx, str);
- ctx->pctx->section = uci_add_section(ctx->pctx->cfg, type, name);
+ ctx->pctx->section = uci_add_section(ctx->pctx->package, type, name);
UCI_TRAP_RESTORE(ctx);
return;
word = strtok_r(word, " \t", &pbrk);
switch(word[0]) {
+ case 'p':
+ if ((word[1] == 0) || !strcmp(word + 1, "ackage"))
+ uci_parse_package(ctx, &word);
+ break;
case 'c':
if ((word[1] == 0) || !strcmp(word + 1, "onfig"))
uci_parse_config(ctx, &word);
}
}
-int uci_import(struct uci_context *ctx, FILE *stream, const char *name, struct uci_config **cfg)
+/* max number of characters that escaping adds to the string */
+#define UCI_QUOTE_ESCAPE "'\\'"
+
+/*
+ * escape an uci string for export
+ */
+static char *uci_escape(struct uci_context *ctx, char *str)
+{
+ char *s, *p, *t;
+ int pos = 0;
+
+ if (!ctx->buf) {
+ ctx->bufsz = LINEBUF;
+ ctx->buf = malloc(LINEBUF);
+ }
+
+ s = str;
+ p = strchr(str, '\'');
+ if (!p)
+ return str;
+
+ do {
+ int len = p - s;
+ if (len > 0) {
+ if (p + sizeof(UCI_QUOTE_ESCAPE) - str >= ctx->bufsz) {
+ ctx->bufsz *= 2;
+ ctx->buf = realloc(ctx->buf, ctx->bufsz);
+ if (!ctx->buf)
+ UCI_THROW(ctx, UCI_ERR_MEM);
+ }
+ memcpy(&ctx->buf[pos], s, len);
+ pos += len;
+ }
+ strcpy(&ctx->buf[pos], UCI_QUOTE_ESCAPE);
+ pos += sizeof(UCI_QUOTE_ESCAPE);
+ s = p + 1;
+ } while ((p = strchr(s, '\'')));
+
+ return ctx->buf;
+}
+
+
+/*
+ * export a single config package to a file stream
+ */
+static void uci_export_config(struct uci_package *package, FILE *stream)
+{
+ struct uci_context *ctx = package->ctx;
+ struct uci_section *s;
+ struct uci_option *o;
+
+ fprintf(stream, "package '%s'\n", uci_escape(ctx, package->name));
+ uci_foreach_entry(section, &package->sections, s) {
+ fprintf(stream, "\nconfig '%s'", uci_escape(ctx, s->type));
+ fprintf(stream, " '%s'\n", uci_escape(ctx, s->name));
+ uci_foreach_entry(option, &s->options, o) {
+ fprintf(stream, "\toption '%s'", uci_escape(ctx, o->name));
+ fprintf(stream, " '%s'\n", uci_escape(ctx, o->value));
+ }
+ }
+ fprintf(stream, "\n");
+}
+
+int uci_export(struct uci_context *ctx, FILE *stream, struct uci_package *package)
+{
+ UCI_HANDLE_ERR(ctx);
+ UCI_ASSERT(ctx, stream != NULL);
+
+ if (package) {
+ uci_export_config(package, stream);
+ goto done;
+ }
+
+ uci_foreach_entry(package, &ctx->root, package) {
+ uci_export_config(package, stream);
+ }
+done:
+ return 0;
+}
+
+int uci_import(struct uci_context *ctx, FILE *stream, const char *name, struct uci_package **package)
{
struct uci_parse_context *pctx;
/* make sure no memory from previous parse attempts is leaked */
- uci_parse_cleanup(ctx);
+ uci_file_cleanup(ctx);
pctx = (struct uci_parse_context *) uci_malloc(ctx, sizeof(struct uci_parse_context));
ctx->pctx = pctx;
pctx->name = name;
while (!feof(pctx->file)) {
- uci_getln(ctx);
+ uci_getln(ctx, 0);
if (pctx->buf[0])
uci_parse_line(ctx);
}
- if (cfg)
- *cfg = pctx->cfg;
+ if (package)
+ *package = pctx->package;
pctx->name = NULL;
uci_switch_config(ctx);
/* no error happened, we can get rid of the parser context now */
- uci_parse_cleanup(ctx);
+ uci_file_cleanup(ctx);
return 0;
}
-int uci_load(struct uci_context *ctx, const char *name, struct uci_config **cfg)
+int uci_load(struct uci_context *ctx, const char *name, struct uci_package **package)
{
struct stat statbuf;
char *filename;
if (!file)
UCI_THROW(ctx, UCI_ERR_IO);
- return uci_import(ctx, file, name, cfg);
+ return uci_import(ctx, file, name, package);
}
projects / project / uci.git / blobdiff