X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=diff.c;h=c8159183dac830bf7cba20edf480712f039d7135;hb=1e80e0449248edb77b0fb9853f4a3404a599e207;hp=cbb86320a6b98ea57712a78c558c7dc84613087b;hpb=b12bbd5986e1fae4120d7a415c1271c0273cad7e;p=git.git

diff --git a/diff.c b/diff.c
index cbb86320..c8159183 100644
--- a/diff.c
+++ b/diff.c
@@ -13,6 +13,58 @@ static const char *diff_opts = "-pu";
 
 static int use_size_cache;
 
+int diff_rename_limit_default = -1;
+
+int git_diff_config(const char *var, const char *value)
+{
+	if (!strcmp(var, "diff.renamelimit")) {
+		diff_rename_limit_default = git_config_int(var, value);
+		return 0;
+	}
+
+	return git_default_config(var, value);
+}
+
+static char *quote_one(const char *str)
+{
+	int needlen;
+	char *xp;
+
+	if (!str)
+		return NULL;
+	needlen = quote_c_style(str, NULL, NULL, 0);
+	if (!needlen)
+		return strdup(str);
+	xp = xmalloc(needlen + 1);
+	quote_c_style(str, xp, NULL, 0);
+	return xp;
+}
+
+static char *quote_two(const char *one, const char *two)
+{
+	int need_one = quote_c_style(one, NULL, NULL, 1);
+	int need_two = quote_c_style(two, NULL, NULL, 1);
+	char *xp;
+
+	if (need_one + need_two) {
+		if (!need_one) need_one = strlen(one);
+		if (!need_two) need_one = strlen(two);
+
+		xp = xmalloc(need_one + need_two + 3);
+		xp[0] = '"';
+		quote_c_style(one, xp + 1, NULL, 1);
+		quote_c_style(two, xp + need_one + 1, NULL, 1);
+		strcpy(xp + need_one + need_two + 1, "\"");
+		return xp;
+	}
+	need_one = strlen(one);
+	need_two = strlen(two);
+	xp = xmalloc(need_one + need_two + 1);
+	strcpy(xp, one);
+	strcpy(xp + need_one, two);
+	return xp;
+}
+
 static const char *external_diff(void)
 {
 	static const char *external_diff_cmd = NULL;
@@ -133,55 +185,52 @@ static void builtin_diff(const char *name_a,
 			 int complete_rewrite)
 {
 	int i, next_at, cmd_size;
-	const char *const diff_cmd = "diff -L%s%s -L%s%s";
-	const char *const diff_arg  = "%s %s||:"; /* "||:" is to return 0 */
+	const char *const diff_cmd = "diff -L%s -L%s";
+	const char *const diff_arg  = "-- %s %s||:"; /* "||:" is to return 0 */
 	const char *input_name_sq[2];
-	const char *path0[2];
-	const char *path1[2];
-	const char *name_sq[2];
+	const char *label_path[2];
 	char *cmd;
 
-	name_sq[0] = sq_quote(name_a);
-	name_sq[1] = sq_quote(name_b);
-
-	/* diff_cmd and diff_arg have 6 %s in total which makes
-	 * the sum of these strings 12 bytes larger than required.
+	/* diff_cmd and diff_arg have 4 %s in total which makes
+	 * the sum of these strings 8 bytes larger than required.
 	 * we use 2 spaces around diff-opts, and we need to count
-	 * terminating NUL, so we subtract 9 here.
+	 * terminating NUL; we used to subtract 5 here, but we do not
+	 * care about small leaks in this subprocess that is about
+	 * to exec "diff" anymore.
 	 */
-	cmd_size = (strlen(diff_cmd) + strlen(diff_opts) +
-			strlen(diff_arg) - 9);
+	cmd_size = (strlen(diff_cmd) + strlen(diff_opts) + strlen(diff_arg)
+		    + 128);
+
 	for (i = 0; i < 2; i++) {
 		input_name_sq[i] = sq_quote(temp[i].name);
-		if (!strcmp(temp[i].name, "/dev/null")) {
-			path0[i] = "/dev/null";
-			path1[i] = "";
-		} else {
-			path0[i] = i ? "b/" : "a/";
-			path1[i] = name_sq[i];
-		}
-		cmd_size += (strlen(path0[i]) + strlen(path1[i]) +
-			     strlen(input_name_sq[i]));
+		if (!strcmp(temp[i].name, "/dev/null"))
+			label_path[i] = "/dev/null";
+		else if (!i)
+			label_path[i] = sq_quote(quote_two("a/", name_a));
+		else
+			label_path[i] = sq_quote(quote_two("b/", name_b));
+		cmd_size += (strlen(label_path[i]) + strlen(input_name_sq[i]));
 	}
 
 	cmd = xmalloc(cmd_size);
 
 	next_at = 0;
 	next_at += snprintf(cmd+next_at, cmd_size-next_at,
-			    diff_cmd,
-			    path0[0], path1[0], path0[1], path1[1]);
+			    diff_cmd, label_path[0], label_path[1]);
 	next_at += snprintf(cmd+next_at, cmd_size-next_at,
 			    " %s ", diff_opts);
 	next_at += snprintf(cmd+next_at, cmd_size-next_at,
 			    diff_arg, input_name_sq[0], input_name_sq[1]);
 
-	printf("diff --git a/%s b/%s\n", name_a, name_b);
-	if (!path1[0][0]) {
+	printf("diff --git %s %s\n",
+	       quote_two("a/", name_a), quote_two("b/", name_b));
+	if (label_path[0][0] == '/') {
+		/* dev/null */
 		printf("new file mode %s\n", temp[1].mode);
 		if (xfrm_msg && xfrm_msg[0])
 			puts(xfrm_msg);
 	}
-	else if (!path1[1][0]) {
+	else if (label_path[1][0] == '/') {
 		printf("deleted file mode %s\n", temp[0].mode);
 		if (xfrm_msg && xfrm_msg[0])
 			puts(xfrm_msg);
@@ -611,7 +660,7 @@ static void diff_fill_sha1_info(struct diff_filespec *one)
 		memset(one->sha1, 0, 20);
 }
 
-static void run_diff(struct diff_filepair *p)
+static void run_diff(struct diff_filepair *p, struct diff_options *o)
 {
 	const char *pgm = external_diff();
 	char msg[PATH_MAX*2+300], *xfrm_msg;
@@ -619,6 +668,7 @@ static void run_diff(struct diff_filepair *p)
 	struct diff_filespec *two;
 	const char *name;
 	const char *other;
+	char *name_munged, *other_munged;
 	int complete_rewrite = 0;
 	int len;
 
@@ -631,6 +681,8 @@ static void run_diff(struct diff_filepair *p)
 
 	name = p->one->path;
 	other = (strcmp(name, p->two->path) ? p->two->path : NULL);
+	name_munged = quote_one(name);
+	other_munged = quote_one(other);
 	one = p->one; two = p->two;
 
 	diff_fill_sha1_info(one);
@@ -644,7 +696,7 @@ static void run_diff(struct diff_filepair *p)
 				"copy from %s\n"
 				"copy to %s\n",
 				(int)(0.5 + p->score * 100.0/MAX_SCORE),
-				name, other);
+				name_munged, other_munged);
 		break;
 	case DIFF_STATUS_RENAMED:
 		len += snprintf(msg + len, sizeof(msg) - len,
@@ -652,7 +704,7 @@ static void run_diff(struct diff_filepair *p)
 				"rename from %s\n"
 				"rename to %s\n",
 				(int)(0.5 + p->score * 100.0/MAX_SCORE),
-				name, other);
+				name_munged, other_munged);
 		break;
 	case DIFF_STATUS_MODIFIED:
 		if (p->score) {
@@ -671,10 +723,12 @@ static void run_diff(struct diff_filepair *p)
 
 	if (memcmp(one->sha1, two->sha1, 20)) {
 		char one_sha1[41];
+		int abbrev = o->full_index ? 40 : DIFF_DEFAULT_INDEX_ABBREV;
 		memcpy(one_sha1, sha1_to_hex(one->sha1), 41);
 
 		len += snprintf(msg + len, sizeof(msg) - len,
-				"index %.7s..%.7s", one_sha1,
+				"index %.*s..%.*s",
+				abbrev, one_sha1, abbrev,
 				sha1_to_hex(two->sha1));
 		if (one->mode == two->mode)
 			len += snprintf(msg + len, sizeof(msg) - len,
@@ -702,6 +756,9 @@ static void run_diff(struct diff_filepair *p)
 	else
 		run_external_diff(pgm, name, other, one, two, xfrm_msg,
 				  complete_rewrite);
+
+	free(name_munged);
+	free(other_munged);
 }
 
 void diff_setup(struct diff_options *options)
@@ -711,13 +768,19 @@ void diff_setup(struct diff_options *options)
 	options->line_termination = '\n';
 	options->break_opt = -1;
 	options->rename_limit = -1;
+
+	options->change = diff_change;
+	options->add_remove = diff_addremove;
 }
 
 int diff_setup_done(struct diff_options *options)
 {
-	if ((options->find_copies_harder || 0 <= options->rename_limit) &&
-	    options->detect_rename != DIFF_DETECT_COPY)
+	if ((options->find_copies_harder &&
+	     options->detect_rename != DIFF_DETECT_COPY) ||
+	    (0 <= options->rename_limit && !options->detect_rename))
 		return -1;
+	if (options->detect_rename && options->rename_limit < 0)
+		options->rename_limit = diff_rename_limit_default;
 	if (options->setup & DIFF_SETUP_USE_CACHE) {
 		if (!active_cache)
 			/* read-cache does not die even when it fails
@@ -730,6 +793,8 @@ int diff_setup_done(struct diff_options *options)
 	}
 	if (options->setup & DIFF_SETUP_USE_SIZE_CACHE)
 		use_size_cache = 1;
+	if (options->abbrev <= 0 || 40 < options->abbrev)
+		options->abbrev = 40; /* full */
 
 	return 0;
 }
@@ -743,6 +808,8 @@ int diff_opt_parse(struct diff_options *options, const char **av, int ac)
 		options->line_termination = 0;
 	else if (!strncmp(arg, "-l", 2))
 		options->rename_limit = strtoul(arg+2, NULL, 10);
+	else if (!strcmp(arg, "--full-index"))
+		options->full_index = 1;
 	else if (!strcmp(arg, "--name-only"))
 		options->output_format = DIFF_FORMAT_NAME;
 	else if (!strcmp(arg, "--name-status"))
@@ -778,6 +845,10 @@ int diff_opt_parse(struct diff_options *options, const char **av, int ac)
 	}
 	else if (!strcmp(arg, "--find-copies-harder"))
 		options->find_copies_harder = 1;
+	else if (!strcmp(arg, "--abbrev"))
+		options->abbrev = DIFF_DEFAULT_ABBREV;
+	else if (!strncmp(arg, "--abbrev=", 9))
+		options->abbrev = strtoul(arg + 9, NULL, 10);
 	else
 		return 0;
 	return 1;
@@ -785,16 +856,29 @@ int diff_opt_parse(struct diff_options *options, const char **av, int ac)
 
 static int parse_num(const char **cp_p)
 {
-	int num, scale, ch, cnt;
+	unsigned long num, scale;
+	int ch, dot;
 	const char *cp = *cp_p;
 
-	cnt = num = 0;
+	num = 0;
 	scale = 1;
-	while ('0' <= (ch = *cp) && ch <= '9') {
-		if (cnt++ < 5) {
-			/* We simply ignore more than 5 digits precision. */
-			scale *= 10;
-			num = num * 10 + ch - '0';
+	dot = 0;
+	for(;;) {
+		ch = *cp;
+		if ( !dot && ch == '.' ) {
+			scale = 1;
+			dot = 1;
+		} else if ( ch == '%' ) {
+			scale = dot ? scale*100 : 100;
+			cp++;	/* % is always at the end */
+			break;
+		} else if ( ch >= '0' && ch <= '9' ) {
+			if ( scale < 100000 ) {
+				scale *= 10;
+				num = (num*10) + (ch-'0');
+			}
+		} else {
+			break;
 		}
 		cp++;
 	}
@@ -803,7 +887,7 @@ static int parse_num(const char **cp_p)
 	/* user says num divided by scale and we say internally that
 	 * is MAX_SCORE * num / scale.
 	 */
-	return (MAX_SCORE * num / scale);
+	return (num >= scale) ? MAX_SCORE : (MAX_SCORE * num / scale);
 }
 
 int diff_scoreopt_parse(const char *opt)
@@ -871,23 +955,55 @@ void diff_free_filepair(struct diff_filepair *p)
 	free(p);
 }
 
+/* This is different from find_unique_abbrev() in that
+ * it needs to deal with 0{40} SHA1.
+ */
+const char *diff_unique_abbrev(const unsigned char *sha1, int len)
+{
+	int abblen;
+	const char *abbrev;
+	if (len == 40)
+		return sha1_to_hex(sha1);
+
+	abbrev = find_unique_abbrev(sha1, len);
+	if (!abbrev) {
+		if (!memcmp(sha1, null_sha1, 20)) {
+			char *buf = sha1_to_hex(null_sha1);
+			if (len < 37)
+				strcpy(buf + len, "...");
+			return buf;
+		}
+		else 
+			return sha1_to_hex(sha1);
+	}
+	abblen = strlen(abbrev);
+	if (abblen < 37) {
+		static char hex[41];
+		if (len < abblen && abblen <= len + 2)
+			sprintf(hex, "%s%.*s", abbrev, len+3-abblen, "..");
+		else
+			sprintf(hex, "%s...", abbrev);
+		return hex;
+	}
+	return sha1_to_hex(sha1);
+}
+
 static void diff_flush_raw(struct diff_filepair *p,
 			   int line_termination,
 			   int inter_name_termination,
-			   int output_format)
+			   struct diff_options *options)
 {
 	int two_paths;
 	char status[10];
+	int abbrev = options->abbrev;
+	const char *path_one, *path_two;
+	int output_format = options->output_format;
 
+	path_one = p->one->path;
+	path_two = p->two->path;
 	if (line_termination) {
-		const char *const err =
-			"path %s cannot be expressed without -z";
-		if (strchr(p->one->path, line_termination) ||
-		    strchr(p->one->path, inter_name_termination))
-			die(err, p->one->path);
-		if (strchr(p->two->path, line_termination) ||
-		    strchr(p->two->path, inter_name_termination))
-			die(err, p->two->path);
+		path_one = quote_one(path_one);
+		path_two = quote_one(path_two);
 	}
 
 	if (p->score)
@@ -912,19 +1028,34 @@ static void diff_flush_raw(struct diff_filepair *p,
 	}
 	if (output_format != DIFF_FORMAT_NAME_STATUS) {
 		printf(":%06o %06o %s ",
-		       p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1));
-		printf("%s ", sha1_to_hex(p->two->sha1));
+		       p->one->mode, p->two->mode,
+		       diff_unique_abbrev(p->one->sha1, abbrev));
+		printf("%s ",
+		       diff_unique_abbrev(p->two->sha1, abbrev));
 	}
-	printf("%s%c%s",status, inter_name_termination, p->one->path);
+	printf("%s%c%s", status, inter_name_termination, path_one);
 	if (two_paths)
-		printf("%c%s", inter_name_termination, p->two->path);
+		printf("%c%s", inter_name_termination, path_two);
 	putchar(line_termination);
+	if (path_one != p->one->path)
+		free((void*)path_one);
+	if (path_two != p->two->path)
+		free((void*)path_two);
 }
 
 static void diff_flush_name(struct diff_filepair *p,
+			    int inter_name_termination,
 			    int line_termination)
 {
-	printf("%s%c", p->two->path, line_termination);
+	char *path = p->two->path;
+
+	if (line_termination)
+		path = quote_one(p->two->path);
+	else
+		path = p->two->path;
+	printf("%s%c", path, line_termination);
+	if (p->two->path != path)
+		free(path);
 }
 
 int diff_unmodified_pair(struct diff_filepair *p)
@@ -961,7 +1092,7 @@ int diff_unmodified_pair(struct diff_filepair *p)
 	return 0;
 }
 
-static void diff_flush_patch(struct diff_filepair *p)
+static void diff_flush_patch(struct diff_filepair *p, struct diff_options *o)
 {
 	if (diff_unmodified_pair(p))
 		return;
@@ -970,7 +1101,7 @@ static void diff_flush_patch(struct diff_filepair *p)
 	    (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
 		return; /* no tree diffs in patch format */ 
 
-	run_diff(p);
+	run_diff(p, o);
 }
 
 int diff_queue_is_empty(void)
@@ -1102,16 +1233,18 @@ void diff_flush(struct diff_options *options)
 			die("internal error in diff-resolve-rename-copy");
 		switch (diff_output_format) {
 		case DIFF_FORMAT_PATCH:
-			diff_flush_patch(p);
+			diff_flush_patch(p, options);
 			break;
 		case DIFF_FORMAT_RAW:
 		case DIFF_FORMAT_NAME_STATUS:
 			diff_flush_raw(p, line_termination,
 				       inter_name_termination,
-				       diff_output_format);
+				       options);
 			break;
 		case DIFF_FORMAT_NAME:
-			diff_flush_name(p, line_termination);
+			diff_flush_name(p,
+					inter_name_termination,
+					line_termination);
 			break;
 		}
 		diff_free_filepair(q->queue[i]);