summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--exec.c50
-rw-r--r--parse.c446
-rw-r--r--printf.c66
-rw-r--r--printf.h9
4 files changed, 380 insertions, 191 deletions
diff --git a/exec.c b/exec.c
index c9302c2..0130317 100644
--- a/exec.c
+++ b/exec.c
@@ -116,6 +116,27 @@ static size_t bfs_exec_arg_max(const struct bfs_exec *execbuf) {
return arg_max;
}
+/** Highlight part of the command line as an error. */
+static void bfs_exec_parse_error(const struct bfs_ctx *ctx, const struct bfs_exec *execbuf) {
+ char **argv = execbuf->tmpl_argv - 1;
+ size_t argc = execbuf->tmpl_argc + 1;
+ if (argv[argc]) {
+ ++argc;
+ }
+
+ bool args[ctx->argc];
+ for (size_t i = 0; i < ctx->argc; ++i) {
+ args[i] = false;
+ }
+
+ size_t i = argv - ctx->argv;
+ for (size_t j = 0; j < argc; ++j) {
+ args[i + j] = true;
+ }
+
+ bfs_argv_error(ctx, args);
+}
+
struct bfs_exec *bfs_exec_parse(const struct bfs_ctx *ctx, char **argv, enum bfs_exec_flags flags) {
struct bfs_exec *execbuf = malloc(sizeof(*execbuf));
if (!execbuf) {
@@ -125,6 +146,8 @@ struct bfs_exec *bfs_exec_parse(const struct bfs_ctx *ctx, char **argv, enum bfs
execbuf->flags = flags;
execbuf->ctx = ctx;
+ execbuf->tmpl_argv = argv + 1;
+ execbuf->tmpl_argc = 0;
execbuf->argv = NULL;
execbuf->argc = 0;
execbuf->argv_cap = 0;
@@ -136,31 +159,33 @@ struct bfs_exec *bfs_exec_parse(const struct bfs_ctx *ctx, char **argv, enum bfs
execbuf->wd_len = 0;
execbuf->ret = 0;
- size_t i;
- for (i = 1; ; ++i) {
- const char *arg = argv[i];
+ while (true) {
+ const char *arg = execbuf->tmpl_argv[execbuf->tmpl_argc];
if (!arg) {
if (execbuf->flags & BFS_EXEC_CONFIRM) {
- bfs_error(ctx, "%s: Expected '... ;'.\n", argv[0]);
+ bfs_exec_parse_error(ctx, execbuf);
+ bfs_error(ctx, "Expected '... ;'.\n");
} else {
- bfs_error(ctx, "%s: Expected '... ;' or '... {} +'.\n", argv[0]);
+ bfs_exec_parse_error(ctx, execbuf);
+ bfs_error(ctx, "Expected '... ;' or '... {} +'.\n");
}
goto fail;
} else if (strcmp(arg, ";") == 0) {
break;
} else if (strcmp(arg, "+") == 0) {
- if (!(execbuf->flags & BFS_EXEC_CONFIRM) && strcmp(argv[i - 1], "{}") == 0) {
+ const char *prev = execbuf->tmpl_argv[execbuf->tmpl_argc - 1];
+ if (!(execbuf->flags & BFS_EXEC_CONFIRM) && strcmp(prev, "{}") == 0) {
execbuf->flags |= BFS_EXEC_MULTI;
break;
}
}
- }
- execbuf->tmpl_argv = argv + 1;
- execbuf->tmpl_argc = i - 1;
+ ++execbuf->tmpl_argc;
+ }
if (execbuf->tmpl_argc == 0) {
- bfs_error(ctx, "%s: Missing command.\n", argv[0]);
+ bfs_exec_parse_error(ctx, execbuf);
+ bfs_error(ctx, "Missing command.\n");
goto fail;
}
@@ -172,10 +197,11 @@ struct bfs_exec *bfs_exec_parse(const struct bfs_ctx *ctx, char **argv, enum bfs
}
if (execbuf->flags & BFS_EXEC_MULTI) {
- for (i = 0; i < execbuf->tmpl_argc - 1; ++i) {
+ for (size_t i = 0; i < execbuf->tmpl_argc - 1; ++i) {
char *arg = execbuf->tmpl_argv[i];
if (strstr(arg, "{}")) {
- bfs_error(ctx, "%s ... +: Only one '{}' is supported.\n", argv[0]);
+ bfs_exec_parse_error(ctx, execbuf);
+ bfs_error(ctx, "Only one '{}' is supported.\n");
goto fail;
}
execbuf->argv[i] = arg;
diff --git a/parse.c b/parse.c
index 25a4ed8..493b321 100644
--- a/parse.c
+++ b/parse.c
@@ -241,8 +241,6 @@ struct parser_state {
bool stdout_tty;
/** Whether this session is interactive (stdin and stderr are each a terminal). */
bool interactive;
- /** Whether stdin has been consumed by -files0-from -. */
- bool stdin_consumed;
/** Whether -color or -nocolor has been passed. */
enum use_color use_color;
/** Whether a -print action is implied. */
@@ -257,17 +255,21 @@ struct parser_state {
bool excluding;
/** The last non-path argument. */
- const char *last_arg;
- /** A "-depth"-type argument if any. */
- const char *depth_arg;
- /** A "-prune"-type argument if any. */
- const char *prune_arg;
- /** A "-mount"-type argument if any. */
- const char *mount_arg;
- /** An "-xdev"-type argument if any. */
- const char *xdev_arg;
- /** An "-ok"-type argument if any. */
- const char *ok_arg;
+ char **last_arg;
+ /** A "-depth"-type argument, if any. */
+ char **depth_arg;
+ /** A "-prune" argument, if any. */
+ char **prune_arg;
+ /** A "-mount" argument, if any. */
+ char **mount_arg;
+ /** An "-xdev" argument, if any. */
+ char **xdev_arg;
+ /** A "-files0-from" argument, if any. */
+ char **files0_arg;
+ /** A "-files0-from -" argument, if any. */
+ char **files0_stdin_arg;
+ /** An "-ok"-type expression, if any. */
+ const struct bfs_expr *ok_expr;
/** The current time. */
struct timespec now;
@@ -292,21 +294,110 @@ enum token_type {
};
/**
+ * Print a low-level error message during parsing.
+ */
+static void parse_perror(const struct parser_state *state, const char *str) {
+ bfs_perror(state->ctx, str);
+}
+
+/** Initialize an empty highlighted range. */
+static void init_highlight(const struct bfs_ctx *ctx, bool *args) {
+ for (size_t i = 0; i < ctx->argc; ++i) {
+ args[i] = false;
+ }
+}
+
+/** Highlight a range of command line arguments. */
+static void highlight_args(const struct bfs_ctx *ctx, char **argv, size_t argc, bool *args) {
+ size_t i = argv - ctx->argv;
+ for (size_t j = 0; j < argc; ++j) {
+ assert(i + j < ctx->argc);
+ args[i + j] = true;
+ }
+}
+
+/**
* Print an error message during parsing.
*/
BFS_FORMATTER(2, 3)
static void parse_error(const struct parser_state *state, const char *format, ...) {
+ int error = errno;
+ const struct bfs_ctx *ctx = state->ctx;
+
+ // If we're at the end of the command line, highlight the last argument
+ char **argv = state->argv;
+ if (!*argv) {
+ --argv;
+ }
+
+ bool highlight[ctx->argc];
+ init_highlight(ctx, highlight);
+ highlight_args(ctx, argv, 1, highlight);
+ bfs_argv_error(ctx, highlight);
+
va_list args;
va_start(args, format);
+ errno = error;
bfs_verror(state->ctx, format, args);
va_end(args);
}
/**
- * Print a low-level error message during parsing.
+ * Print an error about some command line arguments.
*/
-static void parse_perror(const struct parser_state *state, const char *str) {
- bfs_perror(state->ctx, str);
+BFS_FORMATTER(4, 5)
+static void parse_argv_error(const struct parser_state *state, char **argv, size_t argc, const char *format, ...) {
+ int error = errno;
+ const struct bfs_ctx *ctx = state->ctx;
+
+ bool highlight[ctx->argc];
+ init_highlight(ctx, highlight);
+ highlight_args(ctx, argv, argc, highlight);
+ bfs_argv_error(ctx, highlight);
+
+ va_list args;
+ va_start(args, format);
+ errno = error;
+ bfs_verror(ctx, format, args);
+ va_end(args);
+}
+
+/**
+ * Print an error about conflicting command line arguments.
+ */
+BFS_FORMATTER(6, 7)
+static void parse_conflict_error(const struct parser_state *state, char **argv1, size_t argc1, char **argv2, size_t argc2, const char *format, ...) {
+ int error = errno;
+ const struct bfs_ctx *ctx = state->ctx;
+
+ bool highlight[ctx->argc];
+ init_highlight(ctx, highlight);
+ highlight_args(ctx, argv1, argc1, highlight);
+ highlight_args(ctx, argv2, argc2, highlight);
+ bfs_argv_error(ctx, highlight);
+
+ va_list args;
+ va_start(args, format);
+ errno = error;
+ bfs_verror(ctx, format, args);
+ va_end(args);
+}
+
+/**
+ * Print an error about an expression.
+ */
+BFS_FORMATTER(3, 4)
+static void parse_expr_error(const struct parser_state *state, const struct bfs_expr *expr, const char *format, ...) {
+ int error = errno;
+ const struct bfs_ctx *ctx = state->ctx;
+
+ bfs_expr_error(ctx, expr);
+
+ va_list args;
+ va_start(args, format);
+ errno = error;
+ bfs_verror(ctx, format, args);
+ va_end(args);
}
/**
@@ -314,14 +405,75 @@ static void parse_perror(const struct parser_state *state, const char *str) {
*/
BFS_FORMATTER(2, 3)
static bool parse_warning(const struct parser_state *state, const char *format, ...) {
+ int error = errno;
+ const struct bfs_ctx *ctx = state->ctx;
+
+ // If we're at the end of the command line, highlight the last argument
+ char **argv = state->argv;
+ if (!*argv) {
+ --argv;
+ }
+
+ bool highlight[ctx->argc];
+ init_highlight(ctx, highlight);
+ highlight_args(ctx, argv, 1, highlight);
+ if (!bfs_argv_warning(ctx, highlight)) {
+ return false;
+ }
+
va_list args;
va_start(args, format);
+ errno = error;
bool ret = bfs_vwarning(state->ctx, format, args);
va_end(args);
return ret;
}
/**
+ * Print a warning about conflicting command line arguments.
+ */
+BFS_FORMATTER(6, 7)
+static bool parse_conflict_warning(const struct parser_state *state, char **argv1, size_t argc1, char **argv2, size_t argc2, const char *format, ...) {
+ int error = errno;
+ const struct bfs_ctx *ctx = state->ctx;
+
+ bool highlight[ctx->argc];
+ init_highlight(ctx, highlight);
+ highlight_args(ctx, argv1, argc1, highlight);
+ highlight_args(ctx, argv2, argc2, highlight);
+ if (!bfs_argv_warning(ctx, highlight)) {
+ return false;
+ }
+
+ va_list args;
+ va_start(args, format);
+ errno = error;
+ bool ret = bfs_vwarning(ctx, format, args);
+ va_end(args);
+ return ret;
+}
+
+/**
+ * Print a warning about an expression.
+ */
+BFS_FORMATTER(3, 4)
+static bool parse_expr_warning(const struct parser_state *state, const struct bfs_expr *expr, const char *format, ...) {
+ int error = errno;
+ const struct bfs_ctx *ctx = state->ctx;
+
+ if (!bfs_expr_warning(ctx, expr)) {
+ return false;
+ }
+
+ va_list args;
+ va_start(args, format);
+ errno = error;
+ bool ret = bfs_vwarning(ctx, format, args);
+ va_end(args);
+ return ret;
+}
+
+/**
* Fill in a "-print"-type expression.
*/
static void init_print_expr(struct parser_state *state, struct bfs_expr *expr) {
@@ -362,7 +514,7 @@ static int expr_open(struct parser_state *state, struct bfs_expr *expr, const ch
return 0;
fail:
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %m.\n", expr->argv[0], path);
+ parse_expr_error(state, expr, "%m.\n");
if (cfile) {
cfclose(cfile);
} else if (file) {
@@ -374,15 +526,15 @@ fail:
/**
* Invoke bfs_stat() on an argument.
*/
-static int stat_arg(const struct parser_state *state, struct bfs_expr *expr, const char *path, struct bfs_stat *sb) {
+static int stat_arg(const struct parser_state *state, char **arg, struct bfs_stat *sb) {
const struct bfs_ctx *ctx = state->ctx;
bool follow = ctx->flags & (BFTW_FOLLOW_ROOTS | BFTW_FOLLOW_ALL);
enum bfs_stat_flags flags = follow ? BFS_STAT_TRYFOLLOW : BFS_STAT_NOFOLLOW;
- int ret = bfs_stat(AT_FDCWD, path, flags, sb);
+ int ret = bfs_stat(AT_FDCWD, *arg, flags, sb);
if (ret != 0) {
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %m.\n", expr->argv[0], path);
+ parse_argv_error(state, arg, 1, "%m.\n");
}
return ret;
}
@@ -401,7 +553,7 @@ static char **parser_advance(struct parser_state *state, enum token_type type, s
}
if (type != T_PATH) {
- state->last_arg = *state->argv;
+ state->last_arg = state->argv;
}
char **argv = state->argv;
@@ -491,7 +643,7 @@ enum int_flags {
/**
* Parse an integer.
*/
-static const char *parse_int(const struct parser_state *state, const char *str, void *result, enum int_flags flags) {
+static const char *parse_int(const struct parser_state *state, char **arg, const char *str, void *result, enum int_flags flags) {
char *endptr;
int base = flags & IF_BASE_MASK;
@@ -549,19 +701,19 @@ static const char *parse_int(const struct parser_state *state, const char *str,
bad:
if (!(flags & IF_QUIET)) {
- parse_error(state, "${bld}%s${rs} is not a valid integer.\n", str);
+ parse_argv_error(state, arg, 1, "${bld}%s${rs} is not a valid integer.\n", str);
}
return NULL;
negative:
if (!(flags & IF_QUIET)) {
- parse_error(state, "Negative integer ${bld}%s${rs} is not allowed here.\n", str);
+ parse_argv_error(state, arg, 1, "Negative integer ${bld}%s${rs} is not allowed here.\n", str);
}
return NULL;
range:
if (!(flags & IF_QUIET)) {
- parse_error(state, "${bld}%s${rs} is too large an integer.\n", str);
+ parse_argv_error(state, arg, 1, "${bld}%s${rs} is too large an integer.\n", str);
}
return NULL;
}
@@ -569,7 +721,9 @@ range:
/**
* Parse an integer and a comparison flag.
*/
-static const char *parse_icmp(const struct parser_state *state, const char *str, struct bfs_expr *expr, enum int_flags flags) {
+static const char *parse_icmp(const struct parser_state *state, struct bfs_expr *expr, enum int_flags flags) {
+ char **arg = &expr->argv[1];
+ const char *str = *arg;
switch (str[0]) {
case '-':
expr->int_cmp = BFS_INT_LESS;
@@ -584,7 +738,7 @@ static const char *parse_icmp(const struct parser_state *state, const char *str,
break;
}
- return parse_int(state, str, &expr->num, flags | IF_LONG_LONG | IF_UNSIGNED);
+ return parse_int(state, arg, str, &expr->num, flags | IF_LONG_LONG | IF_UNSIGNED);
}
/**
@@ -619,13 +773,6 @@ static struct bfs_expr *parse_nullary_flag(struct parser_state *state) {
}
/**
- * Parse a flag that takes a single value.
- */
-static struct bfs_expr *parse_unary_flag(struct parser_state *state) {
- return parse_flag(state, 2);
-}
-
-/**
* Parse a single option.
*/
static struct bfs_expr *parse_option(struct parser_state *state, size_t argc) {
@@ -684,10 +831,10 @@ static struct bfs_expr *parse_unary_test(struct parser_state *state, bfs_eval_fn
* Parse a single action.
*/
static struct bfs_expr *parse_action(struct parser_state *state, bfs_eval_fn *eval_fn, size_t argc) {
- char **argv = state->argv;
+ char **argv = parser_advance(state, T_ACTION, argc);
if (state->excluding) {
- parse_error(state, "The ${blu}%s${rs} action is not supported within ${red}-exclude${rs}.\n", argv[0]);
+ parse_argv_error(state, argv, argc, "This action is not supported within ${red}-exclude${rs}.\n");
return NULL;
}
@@ -695,7 +842,6 @@ static struct bfs_expr *parse_action(struct parser_state *state, bfs_eval_fn *ev
state->implicit_print = false;
}
- parser_advance(state, T_ACTION, argc);
return bfs_expr_new(eval_fn, argc, argv);
}
@@ -742,7 +888,7 @@ static struct bfs_expr *parse_test_icmp(struct parser_state *state, bfs_eval_fn
return NULL;
}
- if (!parse_icmp(state, expr->argv[1], expr, 0)) {
+ if (!parse_icmp(state, expr, 0)) {
bfs_expr_free(expr);
return NULL;
}
@@ -790,6 +936,8 @@ static struct bfs_expr *parse_debug(struct parser_state *state, int arg1, int ar
return NULL;
}
+ parser_advance(state, T_FLAG, 1);
+
bool unrecognized = false;
for (const char *flag = flags, *next; flag; flag = next) {
@@ -833,7 +981,8 @@ static struct bfs_expr *parse_debug(struct parser_state *state, int arg1, int ar
cfprintf(ctx->cerr, "\n");
}
- return parse_unary_flag(state);
+ parser_advance(state, T_FLAG, 1);
+ return &bfs_true;
}
/**
@@ -844,7 +993,7 @@ static struct bfs_expr *parse_optlevel(struct parser_state *state, int arg1, int
if (strcmp(state->argv[0], "-Ofast") == 0) {
*optlevel = 4;
- } else if (!parse_int(state, state->argv[0] + 2, optlevel, IF_INT | IF_UNSIGNED)) {
+ } else if (!parse_int(state, state->argv, state->argv[0] + 2, optlevel, IF_INT | IF_UNSIGNED)) {
return NULL;
}
@@ -916,7 +1065,7 @@ static struct bfs_expr *parse_acl(struct parser_state *state, int flag, int arg2
}
return expr;
#else
- parse_error(state, "${blu}%s${rs} is missing platform support.\n", state->argv[0]);
+ parse_error(state, "Missing platform support.\n");
return NULL;
#endif
}
@@ -931,7 +1080,7 @@ static struct bfs_expr *parse_newer(struct parser_state *state, int field, int a
}
struct bfs_stat sb;
- if (stat_arg(state, expr, expr->argv[1], &sb) != 0) {
+ if (stat_arg(state, &expr->argv[1], &sb) != 0) {
goto fail;
}
@@ -974,7 +1123,7 @@ static struct bfs_expr *parse_time(struct parser_state *state, int field, int ar
expr->reftime = state->now;
expr->stat_field = field;
- const char *tail = parse_icmp(state, expr->argv[1], expr, IF_PARTIAL_OK);
+ const char *tail = parse_icmp(state, expr, IF_PARTIAL_OK);
if (!tail) {
goto fail;
}
@@ -1004,8 +1153,7 @@ static struct bfs_expr *parse_time(struct parser_state *state, int field, int ar
case 's':
break;
default:
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Unknown time unit ${bld}%c${rs}.\n",
- expr->argv[0], expr->argv[1], *tail);
+ parse_expr_error(state, expr, "Unknown time unit ${bld}%c${rs}.\n", *tail);
goto fail;
}
@@ -1015,13 +1163,12 @@ static struct bfs_expr *parse_time(struct parser_state *state, int field, int ar
break;
}
- tail = parse_int(state, tail, &time, IF_PARTIAL_OK | IF_LONG_LONG | IF_UNSIGNED);
+ tail = parse_int(state, &expr->argv[1], tail, &time, IF_PARTIAL_OK | IF_LONG_LONG | IF_UNSIGNED);
if (!tail) {
goto fail;
}
if (!*tail) {
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Missing time unit.\n",
- expr->argv[0], expr->argv[1]);
+ parse_expr_error(state, expr, "Missing time unit.\n");
goto fail;
}
}
@@ -1046,7 +1193,7 @@ static struct bfs_expr *parse_capable(struct parser_state *state, int flag, int
}
return expr;
#else
- parse_error(state, "${blu}%s${rs} is missing platform support.\n", state->argv[0]);
+ parse_error(state, "Missing platform support.\n");
return NULL;
#endif
}
@@ -1060,7 +1207,7 @@ static struct bfs_expr *parse_color(struct parser_state *state, int color, int a
if (color) {
if (!colors) {
- parse_error(state, "${blu}%s${rs}: %s.\n", state->argv[0], strerror(ctx->colors_error));
+ parse_error(state, "%s.\n", strerror(ctx->colors_error));
return NULL;
}
@@ -1118,7 +1265,7 @@ static struct bfs_expr *parse_daystart(struct parser_state *state, int arg1, int
*/
static struct bfs_expr *parse_delete(struct parser_state *state, int arg1, int arg2) {
state->ctx->flags |= BFTW_POST_ORDER;
- state->depth_arg = state->argv[0];
+ state->depth_arg = state->argv;
return parse_nullary_action(state, eval_delete);
}
@@ -1127,7 +1274,7 @@ static struct bfs_expr *parse_delete(struct parser_state *state, int arg1, int a
*/
static struct bfs_expr *parse_depth(struct parser_state *state, int arg1, int arg2) {
state->ctx->flags |= BFTW_POST_ORDER;
- state->depth_arg = state->argv[0];
+ state->depth_arg = state->argv;
return parse_nullary_flag(state);
}
@@ -1156,7 +1303,7 @@ static struct bfs_expr *parse_depth_limit(struct parser_state *state, int is_min
}
int *depth = is_min ? &ctx->mindepth : &ctx->maxdepth;
- if (!parse_int(state, value, depth, IF_INT | IF_UNSIGNED)) {
+ if (!parse_int(state, &state->argv[1], value, depth, IF_INT | IF_UNSIGNED)) {
return NULL;
}
@@ -1220,7 +1367,7 @@ static struct bfs_expr *parse_exec(struct parser_state *state, int flags, int ar
}
if (execbuf->flags & BFS_EXEC_CONFIRM) {
- state->ok_arg = expr->argv[0];
+ state->ok_expr = expr;
}
return expr;
@@ -1234,7 +1381,7 @@ static struct bfs_expr *parse_exit(struct parser_state *state, int arg1, int arg
const char *value = state->argv[1];
int status = EXIT_SUCCESS;
- if (value && parse_int(state, value, &status, IF_INT | IF_UNSIGNED | IF_QUIET)) {
+ if (value && parse_int(state, NULL, value, &status, IF_INT | IF_UNSIGNED | IF_QUIET)) {
argc = 2;
}
@@ -1250,9 +1397,7 @@ static struct bfs_expr *parse_exit(struct parser_state *state, int arg1, int arg
* Parse -f PATH.
*/
static struct bfs_expr *parse_f(struct parser_state *state, int arg1, int arg2) {
- parser_advance(state, T_FLAG, 1);
-
- const char *path = state->argv[0];
+ const char *path = state->argv[1];
if (!path) {
parse_error(state, "${cyn}-f${rs} requires a path.\n");
return NULL;
@@ -1262,6 +1407,7 @@ static struct bfs_expr *parse_f(struct parser_state *state, int arg1, int arg2)
return NULL;
}
+ parser_advance(state, T_FLAG, 1);
parser_advance(state, T_PATH, 1);
return &bfs_true;
}
@@ -1277,6 +1423,8 @@ static struct bfs_expr *parse_files0_from(struct parser_state *state, int arg1,
return NULL;
}
+ state->files0_arg = parser_advance(state, T_OPTION, 1);
+
FILE *file;
if (strcmp(from, "-") == 0) {
file = stdin;
@@ -1284,17 +1432,17 @@ static struct bfs_expr *parse_files0_from(struct parser_state *state, int arg1,
file = xfopen(from, O_RDONLY | O_CLOEXEC);
}
if (!file) {
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %m.\n", arg, from);
+ parse_error(state, "%m.\n");
return NULL;
}
- struct bfs_expr *expr = parse_unary_option(state);
+ struct bfs_expr *expr = &bfs_true;
while (true) {
char *path = xgetdelim(file, '\0');
if (!path) {
if (errno) {
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %m.\n", arg, from);
+ parse_error(state, "%m.\n");
expr = NULL;
}
break;
@@ -1309,12 +1457,13 @@ static struct bfs_expr *parse_files0_from(struct parser_state *state, int arg1,
}
if (file == stdin) {
- state->stdin_consumed = true;
+ state->files0_stdin_arg = state->files0_arg;
} else {
fclose(file);
}
state->implicit_root = false;
+ parser_advance(state, T_OPTION, 1);
return expr;
}
@@ -1344,9 +1493,9 @@ static struct bfs_expr *parse_flags(struct parser_state *state, int arg1, int ar
if (xstrtofflags(&flags, &expr->set_flags, &expr->clear_flags) != 0) {
if (errno == ENOTSUP) {
- parse_error(state, "${blu}%s${rs} is missing platform support.\n", expr->argv[0]);
+ parse_expr_error(state, expr, "Missing platform support.\n");
} else {
- parse_error(state, "${blu}%s${rs}: Invalid flags ${bld}%s${rs}.\n", expr->argv[0], flags);
+ parse_expr_error(state, expr, "Invalid flags.\n");
}
bfs_expr_free(expr);
return NULL;
@@ -1453,8 +1602,7 @@ static struct bfs_expr *parse_fprintf(struct parser_state *state, int arg1, int
goto fail;
}
- expr->printf = bfs_printf_parse(state->ctx, format);
- if (!expr->printf) {
+ if (bfs_printf_parse(state->ctx, expr, format) != 0) {
goto fail;
}
@@ -1469,15 +1617,18 @@ fail:
* Parse -fstype TYPE.
*/
static struct bfs_expr *parse_fstype(struct parser_state *state, int arg1, int arg2) {
- if (!bfs_ctx_mtab(state->ctx)) {
- parse_error(state, "Couldn't parse the mount table: %m.\n");
+ struct bfs_expr *expr = parse_unary_test(state, eval_fstype);
+ if (!expr) {
return NULL;
}
- struct bfs_expr *expr = parse_unary_test(state, eval_fstype);
- if (expr) {
- expr->cost = STAT_COST;
+ if (!bfs_ctx_mtab(state->ctx)) {
+ parse_expr_error(state, expr, "Couldn't parse the mount table: %m.\n");
+ bfs_expr_free(expr);
+ return NULL;
}
+
+ expr->cost = STAT_COST;
return expr;
}
@@ -1485,29 +1636,27 @@ static struct bfs_expr *parse_fstype(struct parser_state *state, int arg1, int a
* Parse -gid/-group.
*/
static struct bfs_expr *parse_group(struct parser_state *state, int arg1, int arg2) {
- const struct bfs_groups *groups = bfs_ctx_groups(state->ctx);
- if (!groups) {
- parse_error(state, "Couldn't parse the group table: %m.\n");
- return NULL;
- }
-
- const char *arg = state->argv[0];
-
struct bfs_expr *expr = parse_unary_test(state, eval_gid);
if (!expr) {
return NULL;
}
+ const struct bfs_groups *groups = bfs_ctx_groups(state->ctx);
+ if (!groups) {
+ parse_expr_error(state, expr, "Couldn't parse the group table: %m.\n");
+ goto fail;
+ }
+
const struct group *grp = bfs_getgrnam(groups, expr->argv[1]);
if (grp) {
expr->num = grp->gr_gid;
expr->int_cmp = BFS_INT_EQUAL;
} else if (looks_like_icmp(expr->argv[1])) {
- if (!parse_icmp(state, expr->argv[1], expr, 0)) {
+ if (!parse_icmp(state, expr, 0)) {
goto fail;
}
} else {
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: No such group.\n", arg, expr->argv[1]);
+ parse_expr_error(state, expr, "No such group.\n");
goto fail;
}
@@ -1543,29 +1692,27 @@ static struct bfs_expr *parse_used(struct parser_state *state, int arg1, int arg
* Parse -uid/-user.
*/
static struct bfs_expr *parse_user(struct parser_state *state, int arg1, int arg2) {
- const struct bfs_users *users = bfs_ctx_users(state->ctx);
- if (!users) {
- parse_error(state, "Couldn't parse the user table: %m.\n");
- return NULL;
- }
-
- const char *arg = state->argv[0];
-
struct bfs_expr *expr = parse_unary_test(state, eval_uid);
if (!expr) {
return NULL;
}
+ const struct bfs_users *users = bfs_ctx_users(state->ctx);
+ if (!users) {
+ parse_expr_error(state, expr, "Couldn't parse the user table: %m.\n");
+ goto fail;
+ }
+
const struct passwd *pwd = bfs_getpwnam(users, expr->argv[1]);
if (pwd) {
expr->num = pwd->pw_uid;
expr->int_cmp = BFS_INT_EQUAL;
} else if (looks_like_icmp(expr->argv[1])) {
- if (!parse_icmp(state, expr->argv[1], expr, 0)) {
+ if (!parse_icmp(state, expr, 0)) {
goto fail;
}
} else {
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: No such user.\n", arg, expr->argv[1]);
+ parse_expr_error(state, expr, "No such user.\n");
goto fail;
}
@@ -1645,13 +1792,11 @@ static struct bfs_expr *parse_ls(struct parser_state *state, int arg1, int arg2)
* Parse -mount.
*/
static struct bfs_expr *parse_mount(struct parser_state *state, int arg1, int arg2) {
- parse_warning(state,
- "In the future, ${blu}%s${rs} will skip mount points entirely, unlike\n"
- "${blu}-xdev${rs}, due to http://austingroupbugs.net/view.php?id=1133.\n\n",
- state->argv[0]);
+ parse_warning(state, "In the future, ${blu}%s${rs} will skip mount points entirely, unlike\n", state->argv[0]);
+ bfs_warning(state->ctx, "${blu}-xdev${rs}, due to http://austingroupbugs.net/view.php?id=1133.\n\n");
state->ctx->flags |= BFTW_PRUNE_MOUNTS;
- state->mount_arg = state->argv[0];
+ state->mount_arg = state->argv;
return parse_nullary_option(state);
}
@@ -1663,14 +1808,11 @@ static struct bfs_expr *parse_fnmatch(const struct parser_state *state, struct b
return NULL;
}
- const char *arg = expr->argv[0];
- const char *pattern = expr->argv[1];
-
if (casefold) {
#ifdef FNM_CASEFOLD
expr->num = FNM_CASEFOLD;
#else
- parse_error(state, "${blu}%s${rs} is missing platform support.\n", arg);
+ parse_expr_error(state, expr, "Missing platform support.\n");
bfs_expr_free(expr);
return NULL;
#endif
@@ -1684,6 +1826,7 @@ static struct bfs_expr *parse_fnmatch(const struct parser_state *state, struct b
// return a non-zero value (indicating either no match or an error).
//
// But not all implementations obey this, so check for it ourselves.
+ const char *pattern = expr->argv[1];
size_t i, len = strlen(pattern);
for (i = 0; i < len; ++i) {
if (pattern[len - i - 1] != '\\') {
@@ -1691,7 +1834,7 @@ static struct bfs_expr *parse_fnmatch(const struct parser_state *state, struct b
}
}
if (i % 2 != 0) {
- parse_warning(state, "${blu}%s${rs} ${bld}%s${rs}: Unescaped trailing backslash.\n\n", arg, pattern);
+ parse_expr_warning(state, expr, "Unescaped trailing backslash.\n\n");
bfs_expr_free(expr);
return &bfs_false;
}
@@ -1752,11 +1895,11 @@ static int parse_reftime(const struct parser_state *state, struct bfs_expr *expr
if (parse_timestamp(expr->argv[1], &expr->reftime) == 0) {
return 0;
} else if (errno != EINVAL) {
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %m.\n", expr->argv[0], expr->argv[1]);
+ parse_expr_error(state, expr, "%m.\n");
return -1;
}
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Invalid timestamp.\n\n", expr->argv[0], expr->argv[1]);
+ parse_expr_error(state, expr, "Invalid timestamp.\n\n");
fprintf(stderr, "Supported timestamp formats are ISO 8601-like, e.g.\n\n");
struct tm tm;
@@ -1809,9 +1952,9 @@ static struct bfs_expr *parse_newerxy(struct parser_state *state, int arg1, int
expr->stat_field = parse_newerxy_field(arg[6]);
if (!expr->stat_field) {
- parse_error(state,
- "${blu}%s${rs}: For ${blu}-newer${bld}XY${rs}, ${bld}X${rs} should be ${bld}a${rs}, ${bld}c${rs}, ${bld}m${rs}, or ${bld}B${rs}, not ${er}%c${rs}.\n",
- arg, arg[6]);
+ parse_expr_error(state, expr,
+ "For ${blu}-newer${bld}XY${rs}, ${bld}X${rs} should be ${bld}a${rs}, ${bld}c${rs}, ${bld}m${rs}, or ${bld}B${rs}, not ${er}%c${rs}.\n",
+ arg[6]);
goto fail;
}
@@ -1822,21 +1965,21 @@ static struct bfs_expr *parse_newerxy(struct parser_state *state, int arg1, int
} else {
enum bfs_stat_field field = parse_newerxy_field(arg[7]);
if (!field) {
- parse_error(state,
- "${blu}%s${rs}: For ${blu}-newer${bld}XY${rs}, ${bld}Y${rs} should be ${bld}a${rs}, ${bld}c${rs}, ${bld}m${rs}, ${bld}B${rs}, or ${bld}t${rs}, not ${er}%c${rs}.\n",
- arg, arg[7]);
+ parse_expr_error(state, expr,
+ "For ${blu}-newer${bld}XY${rs}, ${bld}Y${rs} should be ${bld}a${rs}, ${bld}c${rs}, ${bld}m${rs}, ${bld}B${rs}, or ${bld}t${rs}, not ${er}%c${rs}.\n",
+ arg[7]);
goto fail;
}
struct bfs_stat sb;
- if (stat_arg(state, expr, expr->argv[1], &sb) != 0) {
+ if (stat_arg(state, &expr->argv[1], &sb) != 0) {
goto fail;
}
const struct timespec *reftime = bfs_stat_time(&sb, field);
if (!reftime) {
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Couldn't get file %s.\n", arg, expr->argv[1], bfs_stat_field_name(field));
+ parse_expr_error(state, expr, "Couldn't get file %s.\n", bfs_stat_field_name(field));
goto fail;
}
@@ -1921,7 +2064,7 @@ static struct bfs_expr *parse_nouser(struct parser_state *state, int arg1, int a
static int parse_mode(const struct parser_state *state, const char *mode, struct bfs_expr *expr) {
if (mode[0] >= '0' && mode[0] <= '9') {
unsigned int parsed;
- if (!parse_int(state, mode, &parsed, 8 | IF_INT | IF_UNSIGNED | IF_QUIET)) {
+ if (!parse_int(state, NULL, mode, &parsed, 8 | IF_INT | IF_UNSIGNED | IF_QUIET)) {
goto fail;
}
if (parsed > 07777) {
@@ -2132,7 +2275,7 @@ done:
return 0;
fail:
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Invalid mode.\n", expr->argv[0], mode);
+ parse_expr_error(state, expr, "Invalid mode.\n");
return -1;
}
@@ -2213,8 +2356,7 @@ static struct bfs_expr *parse_printf(struct parser_state *state, int arg1, int a
init_print_expr(state, expr);
- expr->printf = bfs_printf_parse(state->ctx, expr->argv[1]);
- if (!expr->printf) {
+ if (bfs_printf_parse(state->ctx, expr, expr->argv[1]) != 0) {
bfs_expr_free(expr);
return NULL;
}
@@ -2237,7 +2379,7 @@ static struct bfs_expr *parse_printx(struct parser_state *state, int arg1, int a
* Parse -prune.
*/
static struct bfs_expr *parse_prune(struct parser_state *state, int arg1, int arg2) {
- state->prune_arg = state->argv[0];
+ state->prune_arg = state->argv;
struct bfs_expr *expr = parse_nullary_action(state, eval_prune);
if (expr) {
@@ -2278,7 +2420,7 @@ static struct bfs_expr *parse_regex(struct parser_state *state, int flags, int a
goto fail;
}
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: %s.\n", expr->argv[0], expr->argv[1], str);
+ parse_expr_error(state, expr, "%s.\n", str);
free(str);
goto fail;
}
@@ -2312,6 +2454,8 @@ static struct bfs_expr *parse_regextype(struct parser_state *state, int arg1, in
goto list_types;
}
+ parser_advance(state, T_OPTION, 1);
+
// See https://www.gnu.org/software/gnulib/manual/html_node/Predefined-Syntaxes.html
if (strcmp(type, "posix-basic") == 0
|| strcmp(type, "ed") == 0
@@ -2330,11 +2474,12 @@ static struct bfs_expr *parse_regextype(struct parser_state *state, int arg1, in
cfile = ctx->cout;
goto list_types;
} else {
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Unsupported regex type.\n\n", arg, type);
+ parse_error(state, "Unsupported regex type.\n\n");
goto list_types;
}
- return parse_unary_option(state);
+ parser_advance(state, T_OPTION, 1);
+ return &bfs_true;
list_types:
cfprintf(cfile, "Supported types are:\n\n");
@@ -2367,7 +2512,7 @@ static struct bfs_expr *parse_samefile(struct parser_state *state, int arg1, int
}
struct bfs_stat sb;
- if (stat_arg(state, expr, expr->argv[1], &sb) != 0) {
+ if (stat_arg(state, &expr->argv[1], &sb) != 0) {
bfs_expr_free(expr);
return NULL;
}
@@ -2395,6 +2540,7 @@ static struct bfs_expr *parse_search_strategy(struct parser_state *state, int ar
goto list_strategies;
}
+ parser_advance(state, T_FLAG, 1);
if (strcmp(arg, "bfs") == 0) {
ctx->strategy = BFTW_BFS;
@@ -2409,11 +2555,12 @@ static struct bfs_expr *parse_search_strategy(struct parser_state *state, int ar
cfile = ctx->cout;
goto list_strategies;
} else {
- parse_error(state, "${cyn}%s${rs} ${bld}%s${rs}: Unrecognized search strategy.\n\n", flag, arg);
+ parse_error(state, "Unrecognized search strategy.\n\n");
goto list_strategies;
}
- return parse_unary_flag(state);
+ parser_advance(state, T_FLAG, 1);
+ return &bfs_true;
list_strategies:
cfprintf(cfile, "Supported search strategies:\n\n");
@@ -2455,7 +2602,7 @@ static struct bfs_expr *parse_size(struct parser_state *state, int arg1, int arg
return NULL;
}
- const char *unit = parse_icmp(state, expr->argv[1], expr, IF_PARTIAL_OK);
+ const char *unit = parse_icmp(state, expr, IF_PARTIAL_OK);
if (!unit) {
goto fail;
}
@@ -2501,8 +2648,7 @@ static struct bfs_expr *parse_size(struct parser_state *state, int arg1, int arg
return expr;
bad_unit:
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Expected a size unit (one of ${bld}cwbkMGTP${rs}); found ${er}%s${rs}.\n",
- expr->argv[0], expr->argv[1], unit);
+ parse_expr_error(state, expr, "Expected a size unit (one of ${bld}cwbkMGTP${rs}); found ${er}%s${rs}.\n", unit);
fail:
bfs_expr_free(expr);
return NULL;
@@ -2584,12 +2730,11 @@ static struct bfs_expr *parse_type(struct parser_state *state, int x, int arg2)
break;
case '\0':
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Expected a type flag.\n", expr->argv[0], expr->argv[1]);
+ parse_expr_error(state, expr, "Expected a type flag.\n");
goto fail;
default:
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Unknown type flag ${er}%c${rs} (expected one of [${bld}bcdpflsD${rs}]).\n",
- expr->argv[0], expr->argv[1], *c);
+ parse_expr_error(state, expr, "Unknown type flag ${er}%c${rs}; expected one of [${bld}bcdpflsD${rs}].\n", *c);
goto fail;
}
@@ -2606,7 +2751,7 @@ static struct bfs_expr *parse_type(struct parser_state *state, int x, int arg2)
++c;
continue;
} else {
- parse_error(state, "${blu}%s${rs} ${bld}%s${rs}: Types must be comma-separated.\n", expr->argv[0], expr->argv[1]);
+ parse_expr_error(state, expr, "Types must be comma-separated.\n");
goto fail;
}
}
@@ -2648,7 +2793,7 @@ static struct bfs_expr *parse_xattr(struct parser_state *state, int arg1, int ar
}
return expr;
#else
- parse_error(state, "${blu}%s${rs} is missing platform support.\n", state->argv[0]);
+ parse_error(state, "Missing platform support.\n");
return NULL;
#endif
}
@@ -2665,7 +2810,7 @@ static struct bfs_expr *parse_xattrname(struct parser_state *state, int arg1, in
}
return expr;
#else
- parse_error(state, "${blu}%s${rs} is missing platform support.\n", state->argv[0]);
+ parse_error(state, "Missing platform support.\n");
return NULL;
#endif
}
@@ -2675,7 +2820,7 @@ static struct bfs_expr *parse_xattrname(struct parser_state *state, int arg1, in
*/
static struct bfs_expr *parse_xdev(struct parser_state *state, int arg1, int arg2) {
state->ctx->flags |= BFTW_PRUNE_MOUNTS;
- state->xdev_arg = state->argv[0];
+ state->xdev_arg = state->argv;
return parse_nullary_option(state);
}
@@ -3244,7 +3389,7 @@ static struct bfs_expr *parse_literal(struct parser_state *state) {
match = table_lookup_fuzzy(arg);
CFILE *cerr = state->ctx->cerr;
- parse_error(state, "Unknown argument ${er}%s${rs}; did you mean ", arg);
+ parse_error(state, "Unknown argument; did you mean ");
switch (match->type) {
case T_FLAG:
cfprintf(cerr, "${cyn}%s${rs}?", match->arg);
@@ -3277,7 +3422,7 @@ unmatched:
return NULL;
unexpected:
- parse_error(state, "Expected a predicate; found ${er}%s${rs}.\n", arg);
+ parse_error(state, "Expected a predicate.\n");
return NULL;
}
@@ -3294,7 +3439,7 @@ static struct bfs_expr *parse_factor(struct parser_state *state) {
const char *arg = state->argv[0];
if (!arg) {
- parse_error(state, "Expression terminated prematurely after ${red}%s${rs}.\n", state->last_arg);
+ parse_argv_error(state, state->last_arg, 1, "Expression terminated prematurely here.\n");
return NULL;
}
@@ -3313,7 +3458,7 @@ static struct bfs_expr *parse_factor(struct parser_state *state) {
arg = state->argv[0];
if (!arg || strcmp(arg, ")") != 0) {
- parse_error(state, "Expected a ${red})${rs} after ${blu}%s${rs}.\n", state->argv[-1]);
+ parse_error(state, "Expected a ${red})${rs}.\n");
bfs_expr_free(expr);
return NULL;
}
@@ -3321,12 +3466,12 @@ static struct bfs_expr *parse_factor(struct parser_state *state) {
return expr;
} else if (strcmp(arg, "-exclude") == 0) {
- parser_advance(state, T_OPERATOR, 1);
-
if (state->excluding) {
parse_error(state, "${er}%s${rs} is not supported within ${red}-exclude${rs}.\n", arg);
return NULL;
}
+
+ parser_advance(state, T_OPERATOR, 1);
state->excluding = true;
struct bfs_expr *factor = parse_factor(state);
@@ -3491,7 +3636,7 @@ static struct bfs_expr *parse_whole_expr(struct parser_state *state) {
}
if (state->argv[0]) {
- parse_error(state, "Unexpected argument ${er}%s${rs}.\n", state->argv[0]);
+ parse_error(state, "Unexpected argument.\n");
goto fail;
}
@@ -3510,14 +3655,18 @@ static struct bfs_expr *parse_whole_expr(struct parser_state *state) {
}
if (state->mount_arg && state->xdev_arg) {
- parse_warning(state, "${blu}%s${rs} is redundant in the presence of ${blu}%s${rs}.\n\n", state->xdev_arg, state->mount_arg);
+ parse_conflict_warning(state, state->mount_arg, 1, state->xdev_arg, 1,
+ "${blu}%s${rs} is redundant in the presence of ${blu}%s${rs}.\n\n",
+ state->xdev_arg[0], state->mount_arg[0]);
}
if (state->ctx->warn && state->depth_arg && state->prune_arg) {
- parse_warning(state, "${blu}%s${rs} does not work in the presence of ${blu}%s${rs}.\n", state->prune_arg, state->depth_arg);
+ parse_conflict_warning(state, state->depth_arg, 1, state->prune_arg, 1,
+ "${blu}%s${rs} does not work in the presence of ${blu}%s${rs}.\n",
+ state->prune_arg[0], state->depth_arg[0]);
if (state->interactive) {
- fprintf(stderr, "Do you want to continue? ");
+ bfs_warning(state->ctx, "Do you want to continue? ");
if (ynprompt() == 0) {
goto fail;
}
@@ -3526,8 +3675,10 @@ static struct bfs_expr *parse_whole_expr(struct parser_state *state) {
fprintf(stderr, "\n");
}
- if (state->ok_arg && state->stdin_consumed) {
- parse_error(state, "${blu}%s${rs} conflicts with ${blu}-files0-from${rs} ${bld}-${rs}.\n", state->ok_arg);
+ if (state->ok_expr && state->files0_stdin_arg) {
+ parse_conflict_error(state, state->ok_expr->argv, state->ok_expr->argc, state->files0_stdin_arg, 2,
+ "${blu}%s${rs} conflicts with ${blu}%s${rs} ${bld}%s${rs}.\n",
+ state->ok_expr->argv[0], state->files0_stdin_arg[0], state->files0_stdin_arg[1]);
goto fail;
}
@@ -3756,7 +3907,6 @@ struct bfs_ctx *bfs_parse_cmdline(int argc, char *argv[]) {
.regex_type = BFS_REGEX_POSIX_BASIC,
.stdout_tty = stdout_tty,
.interactive = stdin_tty && stderr_tty,
- .stdin_consumed = false,
.use_color = use_color,
.implicit_print = true,
.implicit_root = true,
@@ -3767,7 +3917,9 @@ struct bfs_ctx *bfs_parse_cmdline(int argc, char *argv[]) {
.prune_arg = NULL,
.mount_arg = NULL,
.xdev_arg = NULL,
- .ok_arg = NULL,
+ .files0_arg = NULL,
+ .files0_stdin_arg = NULL,
+ .ok_expr = NULL,
};
if (strcmp(xbasename(state.command), "find") == 0) {
@@ -3795,7 +3947,7 @@ struct bfs_ctx *bfs_parse_cmdline(int argc, char *argv[]) {
if (darray_length(ctx->paths) == 0) {
if (!state.implicit_root) {
- parse_error(&state, "No root paths specified.\n");
+ parse_argv_error(&state, state.files0_arg, 2, "No root paths specified.\n");
goto fail;
} else if (parse_root(&state, ".") != 0) {
goto fail;
diff --git a/printf.c b/printf.c
index ffc6e4e..8fdde41 100644
--- a/printf.c
+++ b/printf.c
@@ -22,6 +22,7 @@
#include "diag.h"
#include "dir.h"
#include "dstring.h"
+#include "expr.h"
#include "mtab.h"
#include "pwcache.h"
#include "stat.h"
@@ -585,8 +586,8 @@ static int append_directive(const struct bfs_ctx *ctx, struct bfs_printf **forma
return 0;
}
-struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *format) {
- struct bfs_printf *ret = NULL;
+int bfs_printf_parse(const struct bfs_ctx *ctx, struct bfs_expr *expr, const char *format) {
+ expr->printf = NULL;
char *literal = dstralloc(0);
if (!literal) {
@@ -625,18 +626,20 @@ struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *forma
struct bfs_printf directive = {
.fn = bfs_printf_flush,
};
- if (append_directive(ctx, &ret, &literal, &directive) != 0) {
+ if (append_directive(ctx, &expr->printf, &literal, &directive) != 0) {
goto error;
}
goto done;
}
case '\0':
- bfs_error(ctx, "'%s': Incomplete escape sequence '\\'.\n", format);
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Incomplete escape sequence '\\'.\n");
goto error;
default:
- bfs_error(ctx, "'%s': Unrecognized escape sequence '\\%c'.\n", format, c);
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Unrecognized escape sequence '\\%c'.\n", c);
goto error;
}
} else if (c == '%') {
@@ -672,7 +675,8 @@ struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *forma
case ' ':
case '-':
if (strchr(directive.str, c)) {
- bfs_error(ctx, "'%s': Duplicate flag '%c'.\n", format, c);
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Duplicate flag '%c'.\n", c);
goto directive_error;
}
if (dstrapp(&directive.str, c) != 0) {
@@ -730,7 +734,9 @@ struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *forma
case 'F':
directive.ptr = bfs_ctx_mtab(ctx);
if (!directive.ptr) {
- bfs_error(ctx, "Couldn't parse the mount table: %m.\n");
+ int error = errno;
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Couldn't parse the mount table: %s.\n", strerror(error));
goto directive_error;
}
directive.fn = bfs_printf_F;
@@ -738,7 +744,9 @@ struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *forma
case 'g':
directive.ptr = bfs_ctx_groups(ctx);
if (!directive.ptr) {
- bfs_error(ctx, "Couldn't parse the group table: %m.\n");
+ int error = errno;
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Couldn't parse the group table: %s.\n", strerror(error));
goto directive_error;
}
directive.fn = bfs_printf_g;
@@ -791,7 +799,9 @@ struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *forma
case 'u':
directive.ptr = bfs_ctx_users(ctx);
if (!directive.ptr) {
- bfs_error(ctx, "Couldn't parse the user table: %m.\n");
+ int error = errno;
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Couldn't parse the user table: %s.\n", strerror(error));
goto directive_error;
}
directive.fn = bfs_printf_u;
@@ -828,27 +838,32 @@ struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *forma
directive.fn = bfs_printf_strftime;
c = *++i;
if (!c) {
- bfs_error(ctx, "'%s': Incomplete time specifier '%s%c'.\n", format, directive.str, i[-1]);
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Incomplete time specifier '%s%c'.\n", directive.str, i[-1]);
goto directive_error;
} else if (strchr("%+@aAbBcCdDeFgGhHIjklmMnprRsStTuUVwWxXyYzZ", c)) {
directive.c = c;
} else {
- bfs_error(ctx, "'%s': Unrecognized time specifier '%%%c%c'.\n", format, i[-1], c);
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Unrecognized time specifier '%%%c%c'.\n", i[-1], c);
goto directive_error;
}
break;
case '\0':
- bfs_error(ctx, "'%s': Incomplete format specifier '%s'.\n", format, directive.str);
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Incomplete format specifier '%s'.\n", directive.str);
goto directive_error;
default:
- bfs_error(ctx, "'%s': Unrecognized format specifier '%%%c'.\n", format, c);
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Unrecognized format specifier '%%%c'.\n", c);
goto directive_error;
}
if (must_be_numeric && strcmp(specifier, "s") == 0) {
- bfs_error(ctx, "'%s': Invalid flags '%s' for string format '%%%c'.\n", format, directive.str + 1, c);
+ bfs_expr_error(ctx, expr);
+ bfs_error(ctx, "Invalid flags '%s' for string format '%%%c'.\n", directive.str + 1, c);
goto directive_error;
}
@@ -857,7 +872,7 @@ struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *forma
goto directive_error;
}
- if (append_directive(ctx, &ret, &literal, &directive) != 0) {
+ if (append_directive(ctx, &expr->printf, &literal, &directive) != 0) {
goto directive_error;
}
@@ -876,24 +891,17 @@ struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *forma
}
done:
- if (!ret || dstrlen(literal) > 0) {
- struct bfs_printf directive = {
- .fn = bfs_printf_literal,
- .str = literal,
- };
- if (DARRAY_PUSH(&ret, &directive) != 0) {
- bfs_perror(ctx, "DARRAY_PUSH()");
- goto error;
- }
- } else {
- dstrfree(literal);
+ if (append_literal(ctx, &expr->printf, &literal) != 0) {
+ goto error;
}
- return ret;
+ dstrfree(literal);
+ return 0;
error:
dstrfree(literal);
- bfs_printf_free(ret);
- return NULL;
+ bfs_printf_free(expr->printf);
+ expr->printf = NULL;
+ return -1;
}
int bfs_printf(CFILE *cfile, const struct bfs_printf *format, const struct BFTW *ftwbuf) {
diff --git a/printf.h b/printf.h
index eac97e6..a8c5f2a 100644
--- a/printf.h
+++ b/printf.h
@@ -1,6 +1,6 @@
/****************************************************************************
* bfs *
- * Copyright (C) 2017-2020 Tavian Barnes <tavianator@tavianator.com> *
+ * Copyright (C) 2017-2022 Tavian Barnes <tavianator@tavianator.com> *
* *
* Permission to use, copy, modify, and/or distribute this software for any *
* purpose with or without fee is hereby granted. *
@@ -25,6 +25,7 @@
struct BFTW;
struct bfs_ctx;
+struct bfs_expr;
/**
* A printf command, the result of parsing a single format string.
@@ -36,12 +37,14 @@ struct bfs_printf;
*
* @param ctx
* The bfs context.
+ * @param expr
+ * The expression to fill in.
* @param format
* The format string to parse.
* @return
- * The parsed printf command, or NULL on failure.
+ * 0 on success, -1 on failure.
*/
-struct bfs_printf *bfs_printf_parse(const struct bfs_ctx *ctx, const char *format);
+int bfs_printf_parse(const struct bfs_ctx *ctx, struct bfs_expr *expr, const char *format);
/**
* Evaluate a parsed format string.