Diff clean-up.

This is a long overdue clean-up to the code for parsing and passing
diff options.  It also tightens some constness issues.

Signed-off-by: Junio C Hamano <junkio@cox.net>

1 files changed, 25 insertions, 57 deletions

diff --git a/diff-stages.c b/diff-stages.c
index 2e9c0bce6e..85170b21d6 100644
--- a/diff-stages.c
+++ b/diff-stages.c
@@ -5,17 +5,7 @@
 #include "cache.h"
 #include "diff.h"
 
-static int diff_output_format = DIFF_FORMAT_RAW;
-static int diff_line_termination = '\n';
-static int detect_rename = 0;
-static int find_copies_harder = 0;
-static int diff_setup_opt = 0;
-static int diff_score_opt = 0;
-static const char *pickaxe = NULL;
-static int pickaxe_opts = 0;
-static int diff_break_opt = -1;
-static const char *orderfile = NULL;
-static const char *diff_filter = NULL;
+static struct diff_options diff_options;
 
 static const char diff_stages_usage[] =
 "git-diff-stages [<common diff options>] <stage1> <stage2> [<path>...]"
@@ -47,15 +37,16 @@ static void diff_stages(int stage1, int stage2)
 		if (!one && !two)
 			continue;
 		if (!one)
-			diff_addremove('+', ntohl(two->ce_mode),
+			diff_addremove(&diff_options, '+', ntohl(two->ce_mode),
 				       two->sha1, name, NULL);
 		else if (!two)
-			diff_addremove('-', ntohl(one->ce_mode),
+			diff_addremove(&diff_options, '-', ntohl(one->ce_mode),
 				       one->sha1, name, NULL);
 		else if (memcmp(one->sha1, two->sha1, 20) ||
 			 (one->ce_mode != two->ce_mode) ||
-			 find_copies_harder)
-			diff_change(ntohl(one->ce_mode), ntohl(two->ce_mode),
+			 diff_options.find_copies_harder)
+			diff_change(&diff_options,
+				    ntohl(one->ce_mode), ntohl(two->ce_mode),
 				    one->sha1, two->sha1, name, NULL);
 	}
 }
@@ -65,44 +56,25 @@ int main(int ac, const char **av)
 	int stage1, stage2;
 
 	read_cache();
+	diff_setup(&diff_options);
 	while (1 < ac && av[1][0] == '-') {
 		const char *arg = av[1];
 		if (!strcmp(arg, "-r"))
 			; /* as usual */
-		else if (!strcmp(arg, "-p") || !strcmp(arg, "-u"))
-			diff_output_format = DIFF_FORMAT_PATCH;
-		else if (!strncmp(arg, "-B", 2)) {
-			if ((diff_break_opt = diff_scoreopt_parse(arg)) == -1)
+		else {
+			int diff_opt_cnt;
+			diff_opt_cnt = diff_opt_parse(&diff_options,
+						      av+1, ac-1);
+			if (diff_opt_cnt < 0)
 				usage(diff_stages_usage);
-		}
-		else if (!strncmp(arg, "-M", 2)) {
-			detect_rename = DIFF_DETECT_RENAME;
-			if ((diff_score_opt = diff_scoreopt_parse(arg)) == -1)
-				usage(diff_stages_usage);
-		}
-		else if (!strncmp(arg, "-C", 2)) {
-			detect_rename = DIFF_DETECT_COPY;
-			if ((diff_score_opt = diff_scoreopt_parse(arg)) == -1)
+			else if (diff_opt_cnt) {
+				av += diff_opt_cnt;
+				ac -= diff_opt_cnt;
+				continue;
+			}
+			else
 				usage(diff_stages_usage);
 		}
-		else if (!strcmp(arg, "--find-copies-harder"))
-			find_copies_harder = 1;
-		else if (!strcmp(arg, "-z"))
-			diff_line_termination = 0;
-		else if (!strcmp(arg, "--name-only"))
-			diff_output_format = DIFF_FORMAT_NAME;
-		else if (!strcmp(arg, "-R"))
-			diff_setup_opt |= DIFF_SETUP_REVERSE;
-		else if (!strncmp(arg, "-S", 2))
-			pickaxe = arg + 2;
-		else if (!strncmp(arg, "-O", 2))
-			orderfile = arg + 2;
-		else if (!strncmp(arg, "--diff-filter=", 14))
-			diff_filter = arg + 14;
-		else if (!strcmp(arg, "--pickaxe-all"))
-			pickaxe_opts = DIFF_PICKAXE_ALL;
-		else
-			usage(diff_stages_usage);
 		ac--; av++;
 	}
 
@@ -110,21 +82,17 @@ int main(int ac, const char **av)
 	    sscanf(av[1], "%d", &stage1) != 1 ||
 	    ! (0 <= stage1 && stage1 <= 3) ||
 	    sscanf(av[2], "%d", &stage2) != 1 ||
-	    ! (0 <= stage2 && stage2 <= 3) ||
-	    (find_copies_harder && detect_rename != DIFF_DETECT_COPY))
+	    ! (0 <= stage2 && stage2 <= 3))
 		usage(diff_stages_usage);
 
 	av += 3; /* The rest from av[0] are for paths restriction. */
-	diff_setup(diff_setup_opt);
+	diff_options.paths = av;
 
-	diff_stages(stage1, stage2);
+	if (diff_setup_done(&diff_options) < 0)
+		usage(diff_stages_usage);
 
-	diffcore_std(av,
-		     detect_rename, diff_score_opt,
-		     pickaxe, pickaxe_opts,
-		     diff_break_opt,
-		     orderfile,
-		     diff_filter);
-	diff_flush(diff_output_format, diff_line_termination);
+	diff_stages(stage1, stage2);
+	diffcore_std(&diff_options);
+	diff_flush(&diff_options);
 	return 0;
 }