expr: Remove the singleton bfs_{true,false} expressions

4 files changed, 209 insertions, 174 deletions

diff --git a/src/color.c b/src/color.c
index 98fe9f2..94fcac8 100644
--- a/src/color.c
+++ b/src/color.c
@@ -877,6 +877,10 @@ static int cbuff(CFILE *cfile, const char *format, ...);
 
 /** Dump a parsed expression tree, for debugging. */
 static int print_expr(CFILE *cfile, const struct bfs_expr *expr, bool verbose) {
+	if (!expr) {
+		return dstrcat(&cfile->buffer, "(null)");
+	}
+
 	if (dstrcat(&cfile->buffer, "(") != 0) {
 		return -1;
 	}
diff --git a/src/expr.h b/src/expr.h
index 2de8958..e541d8e 100644
--- a/src/expr.h
+++ b/src/expr.h
@@ -202,11 +202,6 @@ struct bfs_expr {
 	};
 };
 
-/** Singleton true expression instance. */
-extern struct bfs_expr bfs_true;
-/** Singleton false expression instance. */
-extern struct bfs_expr bfs_false;
-
 /**
  * Create a new expression.
  */
diff --git a/src/opt.c b/src/opt.c
index f7f80d7..441c611 100644
--- a/src/opt.c
+++ b/src/opt.c
@@ -344,6 +344,13 @@ static void opt_warning(const struct opt_state *state, const struct bfs_expr *ex
 	}
 }
 
+/** Create a constant expression. */
+static struct bfs_expr *opt_const(bool value) {
+	static bfs_eval_fn *fns[] = {eval_false, eval_true};
+	static char *fake_args[] = {"-false", "-true"};
+	return bfs_expr_new(fns[value], 1, &fake_args[value]);
+}
+
 /** Extract a child expression, freeing the outer expression. */
 static struct bfs_expr *extract_child_expr(struct bfs_expr *expr, struct bfs_expr **child) {
 	struct bfs_expr *ret = *child;
@@ -457,14 +464,11 @@ static struct bfs_expr *optimize_not_expr(const struct opt_state *state, struct
 
 	int optlevel = state->ctx->optlevel;
 	if (optlevel >= 1) {
-		if (rhs == &bfs_true) {
-			opt_debug(state, 1, "constant propagation: %pe <==> %pe\n", expr, &bfs_false);
+		if (rhs->eval_fn == eval_true || rhs->eval_fn == eval_false) {
+			struct bfs_expr *ret = opt_const(rhs->eval_fn == eval_false);
+			opt_debug(state, 1, "constant propagation: %pe <==> %pe\n", expr, ret);
 			bfs_expr_free(expr);
-			return &bfs_false;
-		} else if (rhs == &bfs_false) {
-			opt_debug(state, 1, "constant propagation: %pe <==> %pe\n", expr, &bfs_true);
-			bfs_expr_free(expr);
-			return &bfs_true;
+			return ret;
 		} else if (rhs->eval_fn == eval_not) {
 			opt_debug(state, 1, "double negation: %pe <==> %pe\n", expr, rhs->rhs);
 			return extract_child_expr(expr, &rhs->rhs);
@@ -514,17 +518,17 @@ static struct bfs_expr *optimize_and_expr(const struct opt_state *state, struct
 	const struct bfs_ctx *ctx = state->ctx;
 	int optlevel = ctx->optlevel;
 	if (optlevel >= 1) {
-		if (lhs == &bfs_true) {
+		if (lhs->eval_fn == eval_true) {
 			opt_debug(state, 1, "conjunction elimination: %pe <==> %pe\n", expr, rhs);
 			return extract_child_expr(expr, &expr->rhs);
-		} else if (rhs == &bfs_true) {
+		} else if (rhs->eval_fn == eval_true) {
 			opt_debug(state, 1, "conjunction elimination: %pe <==> %pe\n", expr, lhs);
 			return extract_child_expr(expr, &expr->lhs);
 		} else if (lhs->always_false) {
 			opt_debug(state, 1, "short-circuit: %pe <==> %pe\n", expr, lhs);
 			opt_warning(state, expr->rhs, "This expression is unreachable.\n\n");
 			return extract_child_expr(expr, &expr->lhs);
-		} else if (lhs->always_true && rhs == &bfs_false) {
+		} else if (lhs->always_true && rhs->eval_fn == eval_false) {
 			bool debug = opt_debug(state, 1, "strength reduction: %pe <==> ", expr);
 			struct bfs_expr *ret = extract_child_expr(expr, &expr->lhs);
 			ret = negate_expr(ret, &fake_not_arg);
@@ -532,7 +536,7 @@ static struct bfs_expr *optimize_and_expr(const struct opt_state *state, struct
 				cfprintf(ctx->cerr, "%pe\n", ret);
 			}
 			return ret;
-		} else if (optlevel >= 2 && lhs->pure && rhs == &bfs_false) {
+		} else if (optlevel >= 2 && lhs->pure && rhs->eval_fn == eval_false) {
 			opt_debug(state, 2, "purity: %pe <==> %pe\n", expr, rhs);
 			opt_warning(state, expr->lhs, "The result of this expression is ignored.\n\n");
 			return extract_child_expr(expr, &expr->rhs);
@@ -589,13 +593,13 @@ static struct bfs_expr *optimize_or_expr(const struct opt_state *state, struct b
 			opt_debug(state, 1, "short-circuit: %pe <==> %pe\n", expr, lhs);
 			opt_warning(state, expr->rhs, "This expression is unreachable.\n\n");
 			return extract_child_expr(expr, &expr->lhs);
-		} else if (lhs == &bfs_false) {
+		} else if (lhs->eval_fn == eval_false) {
 			opt_debug(state, 1, "disjunctive syllogism: %pe <==> %pe\n", expr, rhs);
 			return extract_child_expr(expr, &expr->rhs);
-		} else if (rhs == &bfs_false) {
+		} else if (rhs->eval_fn == eval_false) {
 			opt_debug(state, 1, "disjunctive syllogism: %pe <==> %pe\n", expr, lhs);
 			return extract_child_expr(expr, &expr->lhs);
-		} else if (lhs->always_false && rhs == &bfs_true) {
+		} else if (lhs->always_false && rhs->eval_fn == eval_true) {
 			bool debug = opt_debug(state, 1, "strength reduction: %pe <==> ", expr);
 			struct bfs_expr *ret = extract_child_expr(expr, &expr->lhs);
 			ret = negate_expr(ret, &fake_not_arg);
@@ -603,7 +607,7 @@ static struct bfs_expr *optimize_or_expr(const struct opt_state *state, struct b
 				cfprintf(ctx->cerr, "%pe\n", ret);
 			}
 			return ret;
-		} else if (optlevel >= 2 && lhs->pure && rhs == &bfs_true) {
+		} else if (optlevel >= 2 && lhs->pure && rhs->eval_fn == eval_true) {
 			opt_debug(state, 2, "purity: %pe <==> %pe\n", expr, rhs);
 			opt_warning(state, expr->lhs, "The result of this expression is ignored.\n\n");
 			return extract_child_expr(expr, &expr->rhs);
@@ -667,11 +671,12 @@ static struct bfs_expr *ignore_result(const struct opt_state *state, struct bfs_
 			}
 		}
 
-		if (optlevel >= 2 && expr->pure && expr != &bfs_false) {
-			opt_debug(state, 2, "ignored result: %pe --> %pe\n", expr, &bfs_false);
+		if (optlevel >= 2 && expr->pure && expr->eval_fn != eval_false) {
+			struct bfs_expr *ret = opt_const(false);
+			opt_debug(state, 2, "ignored result: %pe --> %pe\n", expr, ret);
 			opt_warning(state, expr, "The result of this expression is ignored.\n\n");
 			bfs_expr_free(expr);
-			expr = &bfs_false;
+			return ret;
 		}
 	}
 
@@ -693,8 +698,8 @@ static struct bfs_expr *optimize_comma_expr(const struct opt_state *state, struc
 			opt_debug(state, 1, "reachability: %pe <==> %pe\n", expr, lhs);
 			opt_warning(state, expr->rhs, "This expression is unreachable.\n\n");
 			return extract_child_expr(expr, &expr->lhs);
-		} else if ((lhs->always_true && rhs == &bfs_true)
-			   || (lhs->always_false && rhs == &bfs_false)) {
+		} else if ((lhs->always_true && rhs->eval_fn == eval_true)
+			   || (lhs->always_false && rhs->eval_fn == eval_false)) {
 			opt_debug(state, 1, "redundancy elimination: %pe <==> %pe\n", expr, lhs);
 			return extract_child_expr(expr, &expr->lhs);
 		} else if (optlevel >= 2 && lhs->pure) {
@@ -835,11 +840,11 @@ static struct bfs_expr *optimize_expr_recursive(struct opt_state *state, struct
 	state->facts_when_false = state->facts;
 
 	if (optlevel >= 2 && facts_are_impossible(&state->facts)) {
-		opt_debug(state, 2, "reachability: %pe --> %pe\n", expr, &bfs_false);
+		struct bfs_expr *ret = opt_const(false);
+		opt_debug(state, 2, "reachability: %pe --> %pe\n", expr, ret);
 		opt_warning(state, expr, "This expression is unreachable.\n\n");
 		bfs_expr_free(expr);
-		expr = &bfs_false;
-		goto done;
+		return ret;
 	}
 
 	if (!bfs_expr_has_children(expr) && !expr->pure) {
@@ -893,7 +898,7 @@ static struct bfs_expr *optimize_expr_recursive(struct opt_state *state, struct
 	}
 
 	if (!expr) {
-		goto done;
+		return NULL;
 	}
 
 	if (bfs_expr_has_children(expr)) {
@@ -918,33 +923,34 @@ static struct bfs_expr *optimize_expr_recursive(struct opt_state *state, struct
 		set_facts_impossible(&state->facts_when_true);
 	}
 
-	if (optlevel < 2 || expr == &bfs_true || expr == &bfs_false) {
-		goto done;
+	if (optlevel < 2 || expr->eval_fn == eval_true || expr->eval_fn == eval_false) {
+		return expr;
 	}
 
 	if (facts_are_impossible(&state->facts_when_true)) {
 		if (expr->pure) {
-			opt_debug(state, 2, "data flow: %pe --> %pe\n", expr, &bfs_false);
+			struct bfs_expr *ret = opt_const(false);
 			opt_warning(state, expr, "This expression is always false.\n\n");
+			opt_debug(state, 2, "data flow: %pe --> %pe\n", expr, ret);
 			bfs_expr_free(expr);
-			expr = &bfs_false;
+			return ret;
 		} else {
 			expr->always_false = true;
 			expr->probability = 0.0;
 		}
 	} else if (facts_are_impossible(&state->facts_when_false)) {
 		if (expr->pure) {
-			opt_debug(state, 2, "data flow: %pe --> %pe\n", expr, &bfs_true);
+			struct bfs_expr *ret = opt_const(true);
+			opt_debug(state, 2, "data flow: %pe --> %pe\n", expr, ret);
 			opt_warning(state, expr, "This expression is always true.\n\n");
 			bfs_expr_free(expr);
-			expr = &bfs_true;
+			return ret;
 		} else {
 			expr->always_true = true;
 			expr->probability = 1.0;
 		}
 	}
 
-done:
 	return expr;
 }
 
diff --git a/src/parse.c b/src/parse.c
index 2136bb5..16132f3 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -73,45 +73,6 @@ static char *fake_true_arg = "-true";
 #define STAT_COST   1000.0
 #define PRINT_COST 20000.0
 
-struct bfs_expr bfs_true = {
-	.eval_fn = eval_true,
-	.argc = 1,
-	.argv = &fake_true_arg,
-	.pure = true,
-	.always_true = true,
-	.cost = FAST_COST,
-	.probability = 1.0,
-};
-
-struct bfs_expr bfs_false = {
-	.eval_fn = eval_false,
-	.argc = 1,
-	.argv = &fake_false_arg,
-	.pure = true,
-	.always_false = true,
-	.cost = FAST_COST,
-	.probability = 0.0,
-};
-
-void bfs_expr_free(struct bfs_expr *expr) {
-	if (!expr || expr == &bfs_true || expr == &bfs_false) {
-		return;
-	}
-
-	if (bfs_expr_has_children(expr)) {
-		bfs_expr_free(expr->rhs);
-		bfs_expr_free(expr->lhs);
-	} else if (expr->eval_fn == eval_exec) {
-		bfs_exec_free(expr->exec);
-	} else if (expr->eval_fn == eval_fprintf) {
-		bfs_printf_free(expr->printf);
-	} else if (expr->eval_fn == eval_regex) {
-		bfs_regfree(expr->regex);
-	}
-
-	free(expr);
-}
-
 struct bfs_expr *bfs_expr_new(bfs_eval_fn *eval_fn, size_t argc, char **argv) {
 	struct bfs_expr *expr = malloc(sizeof(*expr));
 	if (!expr) {
@@ -124,16 +85,29 @@ struct bfs_expr *bfs_expr_new(bfs_eval_fn *eval_fn, size_t argc, char **argv) {
 	expr->argv = argv;
 	expr->persistent_fds = 0;
 	expr->ephemeral_fds = 0;
-	expr->pure = false;
-	expr->always_true = false;
-	expr->always_false = false;
 	expr->cost = FAST_COST;
-	expr->probability = 0.5;
 	expr->evaluations = 0;
 	expr->successes = 0;
 	expr->elapsed.tv_sec = 0;
 	expr->elapsed.tv_nsec = 0;
 
+	if (eval_fn == eval_true) {
+		expr->pure = true;
+		expr->always_true = true;
+		expr->always_false = false;
+		expr->probability = 1.0;
+	} else if (eval_fn == eval_false) {
+		expr->pure = true;
+		expr->always_true = false;
+		expr->always_false = true;
+		expr->probability = 0.0;
+	} else {
+		expr->pure = false;
+		expr->always_true = false;
+		expr->always_false = false;
+		expr->probability = 0.5;
+	}
+
 	// Prevent bfs_expr_free() from freeing uninitialized pointers on error paths
 	if (bfs_expr_has_children(expr)) {
 		expr->lhs = NULL;
@@ -149,6 +123,37 @@ struct bfs_expr *bfs_expr_new(bfs_eval_fn *eval_fn, size_t argc, char **argv) {
 	return expr;
 }
 
+bool bfs_expr_has_children(const struct bfs_expr *expr) {
+	return expr->eval_fn == eval_and
+		|| expr->eval_fn == eval_or
+		|| expr->eval_fn == eval_not
+		|| expr->eval_fn == eval_comma;
+}
+
+bool bfs_expr_never_returns(const struct bfs_expr *expr) {
+	// Expressions that never return are vacuously both always true and always false
+	return expr->always_true && expr->always_false;
+}
+
+void bfs_expr_free(struct bfs_expr *expr) {
+	if (!expr) {
+		return;
+	}
+
+	if (bfs_expr_has_children(expr)) {
+		bfs_expr_free(expr->rhs);
+		bfs_expr_free(expr->lhs);
+	} else if (expr->eval_fn == eval_exec) {
+		bfs_exec_free(expr->exec);
+	} else if (expr->eval_fn == eval_fprintf) {
+		bfs_printf_free(expr->printf);
+	} else if (expr->eval_fn == eval_regex) {
+		bfs_regfree(expr->regex);
+	}
+
+	free(expr);
+}
+
 /**
  * Create a new unary expression.
  */
@@ -193,18 +198,6 @@ static struct bfs_expr *new_binary_expr(bfs_eval_fn *eval_fn, struct bfs_expr *l
 	return expr;
 }
 
-bool bfs_expr_has_children(const struct bfs_expr *expr) {
-	return expr->eval_fn == eval_and
-		|| expr->eval_fn == eval_or
-		|| expr->eval_fn == eval_not
-		|| expr->eval_fn == eval_comma;
-}
-
-bool bfs_expr_never_returns(const struct bfs_expr *expr) {
-	// Expressions that never return are vacuously both always true and always false
-	return expr->always_true && expr->always_false;
-}
-
 /**
  * Set an expression to always return true.
  */
@@ -762,8 +755,8 @@ static bool looks_like_icmp(const char *str) {
  * Parse a single flag.
  */
 static struct bfs_expr *parse_flag(struct parser_state *state, size_t argc) {
-	parser_advance(state, T_FLAG, argc);
-	return &bfs_true;
+	char **argv = parser_advance(state, T_FLAG, argc);
+	return bfs_expr_new(eval_true, argc, argv);
 }
 
 /**
@@ -774,11 +767,25 @@ static struct bfs_expr *parse_nullary_flag(struct parser_state *state) {
 }
 
 /**
+ * Parse a flag that takes a value.
+ */
+static struct bfs_expr *parse_unary_flag(struct parser_state *state) {
+	const char *arg = state->argv[0];
+	const char *value = state->argv[1];
+	if (!value) {
+		parse_error(state, "${cyn}%s${rs} needs a value.\n", arg);
+		return NULL;
+	}
+
+	return parse_flag(state, 2);
+}
+
+/**
  * Parse a single option.
  */
 static struct bfs_expr *parse_option(struct parser_state *state, size_t argc) {
-	parser_advance(state, T_OPTION, argc);
-	return &bfs_true;
+	char **argv = parser_advance(state, T_OPTION, argc);
+	return bfs_expr_new(eval_true, argc, argv);
 }
 
 /**
@@ -792,6 +799,13 @@ static struct bfs_expr *parse_nullary_option(struct parser_state *state) {
  * Parse an option that takes a value.
  */
 static struct bfs_expr *parse_unary_option(struct parser_state *state) {
+	const char *arg = state->argv[0];
+	const char *value = state->argv[1];
+	if (!value) {
+		parse_error(state, "${blu}%s${rs} needs a value.\n", arg);
+		return NULL;
+	}
+
 	return parse_option(state, 2);
 }
 
@@ -929,19 +943,16 @@ static bool parse_debug_flag(const char *flag, size_t len, const char *expected)
 static struct bfs_expr *parse_debug(struct parser_state *state, int arg1, int arg2) {
 	struct bfs_ctx *ctx = state->ctx;
 
-	const char *arg = state->argv[0];
-	const char *flags = state->argv[1];
-	if (!flags) {
-		parse_error(state, "${cyn}%s${rs} needs a flag.\n\n", arg);
+	struct bfs_expr *expr = parse_unary_flag(state);
+	if (!expr) {
+		cfprintf(ctx->cerr, "\n");
 		debug_help(ctx->cerr);
 		return NULL;
 	}
 
-	parser_advance(state, T_FLAG, 1);
-
 	bool unrecognized = false;
 
-	for (const char *flag = flags, *next; flag; flag = next) {
+	for (const char *flag = expr->argv[1], *next; flag; flag = next) {
 		size_t len = strcspn(flag, ",");
 		if (flag[len]) {
 			next = flag + len + 1;
@@ -952,6 +963,7 @@ static struct bfs_expr *parse_debug(struct parser_state *state, int arg1, int ar
 		if (parse_debug_flag(flag, len, "help")) {
 			debug_help(ctx->cout);
 			state->just_info = true;
+			bfs_expr_free(expr);
 			return NULL;
 		} else if (parse_debug_flag(flag, len, "all")) {
 			ctx->debug = DEBUG_ALL;
@@ -969,7 +981,7 @@ static struct bfs_expr *parse_debug(struct parser_state *state, int arg1, int ar
 		if (DEBUG_ALL & i) {
 			ctx->debug |= i;
 		} else {
-			if (parse_warning(state, "Unrecognized debug flag ${bld}")) {
+			if (parse_expr_warning(state, expr, "Unrecognized debug flag ${bld}")) {
 				fwrite(flag, 1, len, stderr);
 				cfprintf(ctx->cerr, "${rs}.\n\n");
 				unrecognized = true;
@@ -982,27 +994,32 @@ static struct bfs_expr *parse_debug(struct parser_state *state, int arg1, int ar
 		cfprintf(ctx->cerr, "\n");
 	}
 
-	parser_advance(state, T_FLAG, 1);
-	return &bfs_true;
+	return expr;
 }
 
 /**
  * Parse -On.
  */
 static struct bfs_expr *parse_optlevel(struct parser_state *state, int arg1, int arg2) {
+	struct bfs_expr *expr = parse_nullary_flag(state);
+	if (!expr) {
+		return NULL;
+	}
+
 	int *optlevel = &state->ctx->optlevel;
 
-	if (strcmp(state->argv[0], "-Ofast") == 0) {
+	if (strcmp(expr->argv[0], "-Ofast") == 0) {
 		*optlevel = 4;
-	} else if (!parse_int(state, state->argv, state->argv[0] + 2, optlevel, IF_INT | IF_UNSIGNED)) {
+	} else if (!parse_int(state, expr->argv, expr->argv[0] + 2, optlevel, IF_INT | IF_UNSIGNED)) {
+		bfs_expr_free(expr);
 		return NULL;
 	}
 
 	if (*optlevel > 4) {
-		parse_warning(state, "${cyn}-O${bld}%s${rs} is the same as ${cyn}-O${bld}4${rs}.\n\n", state->argv[0] + 2);
+		parse_expr_warning(state, expr, "${cyn}-O${bld}%s${rs} is the same as ${cyn}-O${bld}4${rs}.\n\n", state->argv[0] + 2);
 	}
 
-	return parse_nullary_flag(state);
+	return expr;
 }
 
 /**
@@ -1203,12 +1220,18 @@ static struct bfs_expr *parse_capable(struct parser_state *state, int flag, int
  * Parse -(no)?color.
  */
 static struct bfs_expr *parse_color(struct parser_state *state, int color, int arg2) {
+	struct bfs_expr *expr = parse_nullary_option(state);
+	if (!expr) {
+		return NULL;
+	}
+
 	struct bfs_ctx *ctx = state->ctx;
 	struct colors *colors = ctx->colors;
 
 	if (color) {
 		if (!colors) {
-			parse_error(state, "%s.\n", strerror(ctx->colors_error));
+			parse_expr_error(state, expr, "%s.\n", strerror(ctx->colors_error));
+			bfs_expr_free(expr);
 			return NULL;
 		}
 
@@ -1221,15 +1244,14 @@ static struct bfs_expr *parse_color(struct parser_state *state, int color, int a
 		ctx->cerr->colors = NULL;
 	}
 
-	return parse_nullary_option(state);
+	return expr;
 }
 
 /**
  * Parse -{false,true}.
  */
 static struct bfs_expr *parse_const(struct parser_state *state, int value, int arg2) {
-	parser_advance(state, T_TEST, 1);
-	return value ? &bfs_true : &bfs_false;
+	return parse_nullary_test(state, value ? eval_true : eval_false);
 }
 
 /**
@@ -1295,20 +1317,20 @@ static struct bfs_expr *parse_depth_n(struct parser_state *state, int arg1, int
  * Parse -{min,max}depth N.
  */
 static struct bfs_expr *parse_depth_limit(struct parser_state *state, int is_min, int arg2) {
-	struct bfs_ctx *ctx = state->ctx;
-	const char *arg = state->argv[0];
-	const char *value = state->argv[1];
-	if (!value) {
-		parse_error(state, "${blu}%s${rs} needs a value.\n", arg);
+	struct bfs_expr *expr = parse_unary_option(state);
+	if (!expr) {
 		return NULL;
 	}
 
+	struct bfs_ctx *ctx = state->ctx;
 	int *depth = is_min ? &ctx->mindepth : &ctx->maxdepth;
-	if (!parse_int(state, &state->argv[1], value, depth, IF_INT | IF_UNSIGNED)) {
+	char **arg = &expr->argv[1];
+	if (!parse_int(state, arg, *arg, depth, IF_INT | IF_UNSIGNED)) {
+		bfs_expr_free(expr);
 		return NULL;
 	}
 
-	return parse_unary_option(state);
+	return expr;
 }
 
 /**
@@ -1398,33 +1420,30 @@ 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) {
-	const char *path = state->argv[1];
-	if (!path) {
-		parse_error(state, "${cyn}-f${rs} requires a path.\n");
+	struct bfs_expr *expr = parse_unary_flag(state);
+	if (!expr) {
 		return NULL;
 	}
 
-	if (parse_root(state, path) != 0) {
+	if (parse_root(state, expr->argv[1]) != 0) {
+		bfs_expr_free(expr);
 		return NULL;
 	}
 
-	parser_advance(state, T_FLAG, 1);
-	parser_advance(state, T_PATH, 1);
-	return &bfs_true;
+	return expr;
 }
 
 /**
  * Parse -files0-from PATH.
  */
 static struct bfs_expr *parse_files0_from(struct parser_state *state, int arg1, int arg2) {
-	const char *arg = state->argv[0];
-	const char *from = state->argv[1];
-	if (!from) {
-		parse_error(state, "${blu}%s${rs} requires a path.\n", arg);
+	struct bfs_expr *expr = parse_unary_option(state);
+	if (!expr) {
 		return NULL;
 	}
 
-	state->files0_arg = parser_advance(state, T_OPTION, 1);
+	state->files0_arg = expr->argv;
+	const char *from = expr->argv[1];
 
 	FILE *file;
 	if (strcmp(from, "-") == 0) {
@@ -1433,27 +1452,24 @@ 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, "%m.\n");
-		return NULL;
+		parse_expr_error(state, expr, "%m.\n");
+		goto fail;
 	}
 
-	struct bfs_expr *expr = &bfs_true;
-
 	while (true) {
 		char *path = xgetdelim(file, '\0');
 		if (!path) {
 			if (errno) {
-				parse_error(state, "%m.\n");
-				expr = NULL;
+				goto fail;
+			} else {
+				break;
 			}
-			break;
 		}
 
 		int ret = parse_root(state, path);
 		free(path);
 		if (ret != 0) {
-			expr = NULL;
-			break;
+			goto fail;
 		}
 	}
 
@@ -1464,8 +1480,14 @@ static struct bfs_expr *parse_files0_from(struct parser_state *state, int arg1,
 	}
 
 	state->implicit_root = false;
-	parser_advance(state, T_OPTION, 1);
 	return expr;
+
+fail:
+	if (file && file != stdin) {
+		fclose(file);
+	}
+	bfs_expr_free(expr);
+	return NULL;
 }
 
 /**
@@ -1771,12 +1793,17 @@ 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", state->argv[0]);
+	struct bfs_expr *expr = parse_nullary_option(state);
+	if (!expr) {
+		return NULL;
+	}
+
+	parse_expr_warning(state, expr, "In the future, ${blu}%s${rs} will skip mount points entirely, unlike\n", expr->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;
-	return parse_nullary_option(state);
+	return expr;
 }
 
 /**
@@ -1814,8 +1841,8 @@ static struct bfs_expr *parse_fnmatch(const struct parser_state *state, struct b
 	}
 	if (i % 2 != 0) {
 		parse_expr_warning(state, expr, "Unescaped trailing backslash.\n\n");
-		bfs_expr_free(expr);
-		return &bfs_false;
+		expr->eval_fn = eval_false;
+		return expr;
 	}
 
 	expr->cost = 400.0;
@@ -2009,8 +2036,7 @@ static struct bfs_expr *parse_nohidden(struct parser_state *state, int arg1, int
 		return NULL;
 	}
 
-	parser_advance(state, T_OPTION, 1);
-	return &bfs_true;
+	return parse_nullary_option(state);
 }
 
 /**
@@ -2430,16 +2456,14 @@ static struct bfs_expr *parse_regextype(struct parser_state *state, int arg1, in
 	struct bfs_ctx *ctx = state->ctx;
 	CFILE *cfile = ctx->cerr;
 
-	const char *arg = state->argv[0];
-	const char *type = state->argv[1];
-	if (!type) {
-		parse_error(state, "${blu}%s${rs} needs a value.\n\n", arg);
+	struct bfs_expr *expr = parse_unary_option(state);
+	if (!expr) {
+		cfprintf(cfile, "\n");
 		goto list_types;
 	}
 
-	parser_advance(state, T_OPTION, 1);
-
 	// See https://www.gnu.org/software/gnulib/manual/html_node/Predefined-Syntaxes.html
+	const char *type = expr->argv[1];
 	if (strcmp(type, "posix-basic") == 0
 	    || strcmp(type, "ed") == 0
 	    || strcmp(type, "sed") == 0) {
@@ -2457,12 +2481,11 @@ static struct bfs_expr *parse_regextype(struct parser_state *state, int arg1, in
 		cfile = ctx->cout;
 		goto list_types;
 	} else {
-		parse_error(state, "Unsupported regex type.\n\n");
+		parse_expr_error(state, expr, "Unsupported regex type.\n\n");
 		goto list_types;
 	}
 
-	parser_advance(state, T_OPTION, 1);
-	return &bfs_true;
+	return expr;
 
 list_types:
 	cfprintf(cfile, "Supported types are:\n\n");
@@ -2474,6 +2497,8 @@ list_types:
 	cfprintf(cfile, "  ${bld}grep${rs}:           Like ${grn}grep${rs}\n");
 #endif
 	cfprintf(cfile, "  ${bld}sed${rs}:            Like ${grn}sed${rs} (same as ${bld}posix-basic${rs})\n");
+
+	bfs_expr_free(expr);
 	return NULL;
 }
 
@@ -2516,15 +2541,13 @@ static struct bfs_expr *parse_search_strategy(struct parser_state *state, int ar
 	struct bfs_ctx *ctx = state->ctx;
 	CFILE *cfile = ctx->cerr;
 
-	const char *flag = state->argv[0];
-	const char *arg = state->argv[1];
-	if (!arg) {
-		parse_error(state, "${cyn}%s${rs} needs an argument.\n\n", flag);
+	struct bfs_expr *expr = parse_unary_flag(state);
+	if (!expr) {
+		cfprintf(cfile, "\n");
 		goto list_strategies;
 	}
 
-	parser_advance(state, T_FLAG, 1);
-
+	const char *arg = expr->argv[1];
 	if (strcmp(arg, "bfs") == 0) {
 		ctx->strategy = BFTW_BFS;
 	} else if (strcmp(arg, "dfs") == 0) {
@@ -2538,12 +2561,11 @@ static struct bfs_expr *parse_search_strategy(struct parser_state *state, int ar
 		cfile = ctx->cout;
 		goto list_strategies;
 	} else {
-		parse_error(state, "Unrecognized search strategy.\n\n");
+		parse_expr_error(state, expr, "Unrecognized search strategy.\n\n");
 		goto list_strategies;
 	}
 
-	parser_advance(state, T_FLAG, 1);
-	return &bfs_true;
+	return expr;
 
 list_strategies:
 	cfprintf(cfile, "Supported search strategies:\n\n");
@@ -2551,6 +2573,8 @@ list_strategies:
 	cfprintf(cfile, "  ${bld}dfs${rs}: depth-first search\n");
 	cfprintf(cfile, "  ${bld}ids${rs}: iterative deepening search\n");
 	cfprintf(cfile, "  ${bld}eds${rs}: exponential deepening search\n");
+
+	bfs_expr_free(expr);
 	return NULL;
 }
 
@@ -3456,7 +3480,7 @@ static struct bfs_expr *parse_factor(struct parser_state *state) {
 			return NULL;
 		}
 
-		parser_advance(state, T_OPERATOR, 1);
+		char **argv = parser_advance(state, T_OPERATOR, 1);
 		state->excluding = true;
 
 		struct bfs_expr *factor = parse_factor(state);
@@ -3470,7 +3494,7 @@ static struct bfs_expr *parse_factor(struct parser_state *state) {
 			return NULL;
 		}
 
-		return &bfs_true;
+		return bfs_expr_new(eval_true, state->argv - argv, argv);
 	} else if (strcmp(arg, "!") == 0 || strcmp(arg, "-not") == 0) {
 		char **argv = parser_advance(state, T_OPERATOR, 1);
 
@@ -3612,12 +3636,14 @@ static struct bfs_expr *parse_whole_expr(struct parser_state *state) {
 		return NULL;
 	}
 
-	struct bfs_expr *expr = &bfs_true;
+	struct bfs_expr *expr;
 	if (state->argv[0]) {
 		expr = parse_expr(state);
-		if (!expr) {
-			return NULL;
-		}
+	} else {
+		expr = bfs_expr_new(eval_true, 1, &fake_true_arg);
+	}
+	if (!expr) {
+		return NULL;
 	}
 
 	if (state->argv[0]) {
@@ -3804,7 +3830,7 @@ void bfs_ctx_dump(const struct bfs_ctx *ctx, enum debug_flags flag) {
 
 	fputs("\n", stderr);
 
-	if (ctx->exclude != &bfs_false) {
+	if (ctx->exclude->eval_fn != eval_false) {
 		bfs_debug(ctx, flag, "(${red}-exclude${rs}\n");
 		dump_expr_multiline(ctx, flag, ctx->exclude, 1, 1);
 	}
@@ -3910,7 +3936,11 @@ struct bfs_ctx *bfs_parse_cmdline(int argc, char *argv[]) {
 		ctx->strategy = BFTW_DFS;
 	}
 
-	ctx->exclude = &bfs_false;
+	ctx->exclude = bfs_expr_new(eval_false, 1, &fake_false_arg);
+	if (!ctx->exclude) {
+		goto fail;
+	}
+
 	ctx->expr = parse_whole_expr(&state);
 	if (!ctx->expr) {
 		if (state.just_info) {