X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=diff.c;h=315eb5c26ac347a54ff0a4013ad40844ecf2812e;hb=000182eacf99cde27d5916aa415921924b82972c;hp=a080d94c37c8a99cdbc3b8ed510c4a52cea508e8;hpb=2cd68882ee8629f9782be017007fff4c78e45e45;p=git.git

diff --git a/diff.c b/diff.c
index a080d94c..315eb5c2 100644
--- a/diff.c
+++ b/diff.c
@@ -132,10 +132,16 @@ static void builtin_diff(const char *name_a,
 			    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])
+	if (!path1[0][0]) {
 		printf("new file mode %s\n", temp[1].mode);
-	else if (!path1[1][0])
+		if (xfrm_msg && xfrm_msg[0])
+			puts(xfrm_msg);
+	}
+	else if (!path1[1][0]) {
 		printf("deleted file mode %s\n", temp[0].mode);
+		if (xfrm_msg && xfrm_msg[0])
+			puts(xfrm_msg);
+	}
 	else {
 		if (strcmp(temp[0].mode, temp[1].mode)) {
 			printf("old mode %s\n", temp[0].mode);
@@ -327,7 +333,6 @@ int diff_populate_filespec(struct diff_filespec *s, int size_only)
 		close(fd);
 	}
 	else {
-		/* We cannot do size only for SHA1 blobs */
 		char type[20];
 		struct sha1_size_cache *e;
 
@@ -337,11 +342,13 @@ int diff_populate_filespec(struct diff_filespec *s, int size_only)
 				s->size = e->size;
 				return 0;
 			}
+			if (!sha1_file_size(s->sha1, &s->size))
+				locate_size_cache(s->sha1, s->size);
+		}
+		else {
+			s->data = read_sha1_file(s->sha1, type, &s->size);
+			s->should_free = 1;
 		}
-		s->data = read_sha1_file(s->sha1, type, &s->size);
-		s->should_free = 1;
-		if (s->data && size_only)
-			locate_size_cache(s->sha1, s->size);
 	}
 	return 0;
 }
@@ -582,6 +589,57 @@ void diff_setup(int flags)
 	
 }
 
+static int parse_num(const char **cp_p)
+{
+	int num, scale, ch, cnt;
+	const char *cp = *cp_p;
+
+	cnt = 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';
+		}
+		*cp++;
+	}
+	*cp_p = cp;
+
+	/* user says num divided by scale and we say internally that
+	 * is MAX_SCORE * num / scale.
+	 */
+	return (MAX_SCORE * num / scale);
+}
+
+int diff_scoreopt_parse(const char *opt)
+{
+	int opt1, opt2, cmd;
+
+	if (*opt++ != '-')
+		return -1;
+	cmd = *opt++;
+	if (cmd != 'M' && cmd != 'C' && cmd != 'B')
+		return -1; /* that is not a -M, -C nor -B option */
+
+	opt1 = parse_num(&opt);
+	if (cmd != 'B')
+		opt2 = 0;
+	else {
+		if (*opt == 0)
+			opt2 = 0;
+		else if (*opt != '/')
+			return -1; /* we expect -B80/99 or -B80 */
+		else {
+			opt++;
+			opt2 = parse_num(&opt);
+		}
+	}
+	if (*opt != 0)
+		return -1;
+	return opt1 | (opt2 << 16);
+}
+
 struct diff_queue_struct diff_queued_diff;
 
 void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
@@ -603,6 +661,7 @@ struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
 	dp->two = two;
 	dp->score = 0;
 	dp->source_stays = 0;
+	dp->broken_pair = 0;
 	diff_q(queue, dp);
 	return dp;
 }
@@ -637,6 +696,16 @@ static void diff_flush_raw(struct diff_filepair *p,
 		sprintf(status, "%c%03d", p->status,
 			(int)(0.5 + p->score * 100.0/MAX_SCORE));
 		break;
+	case 'N': case 'D':
+		two_paths = 0;
+		if (p->score)
+			sprintf(status, "%c%03d", p->status,
+				(int)(0.5 + p->score * 100.0/MAX_SCORE));
+		else {
+			status[0] = p->status;
+			status[1] = 0;
+		}
+		break;
 	default:
 		two_paths = 0;
 		status[0] = p->status;
@@ -722,6 +791,16 @@ static void diff_flush_patch(struct diff_filepair *p)
 			p->one->path, p->two->path);
 		msg = msg_;
 		break;
+	case 'D': case 'N':
+		if (DIFF_PAIR_BROKEN(p)) {
+			sprintf(msg_,
+				"dissimilarity index %d%%",
+				(int)(0.5 + p->score * 100.0/MAX_SCORE));
+			msg = msg_;
+		}
+		else
+			msg = NULL;
+		break;
 	default:
 		msg = NULL;
 	}
@@ -760,8 +839,9 @@ void diff_debug_filepair(const struct diff_filepair *p, int i)
 {
 	diff_debug_filespec(p->one, i, "one");
 	diff_debug_filespec(p->two, i, "two");
-	fprintf(stderr, "score %d, status %c source_stays %d\n",
-		p->score, p->status ? : '?', p->source_stays);
+	fprintf(stderr, "score %d, status %c stays %d broken %d\n",
+		p->score, p->status ? : '?',
+		p->source_stays, p->broken_pair);
 }
 
 void diff_debug_queue(const char *msg, struct diff_queue_struct *q)
@@ -826,12 +906,14 @@ static void diff_resolve_rename_copy(void)
 		else if (memcmp(p->one->sha1, p->two->sha1, 20) ||
 			 p->one->mode != p->two->mode)
 			p->status = 'M';
-		else
-			/* this is a "no-change" entry.
-			 * should not happen anymore.
-			 * p->status = 'X';
+		else {
+			/* This is a "no-change" entry and should not
+			 * happen anymore, but prepare for broken callers.
 			 */
-			die("internal error in diffcore: unmodified entry remains");
+			error("feeding unmodified %s to diffcore",
+			      p->one->path);
+			p->status = 'X';
+		}
 	}
 	diff_debug_queue("resolve-rename-copy done", q);
 }
@@ -875,14 +957,22 @@ void diff_flush(int diff_output_style, int resolve_rename_copy)
 
 void diffcore_std(const char **paths,
 		  int detect_rename, int rename_score,
-		  const char *pickaxe, int pickaxe_opts)
+		  const char *pickaxe, int pickaxe_opts,
+		  int break_opt,
+		  const char *orderfile)
 {
 	if (paths && paths[0])
 		diffcore_pathspec(paths);
+	if (0 <= break_opt)
+		diffcore_break(break_opt);
 	if (detect_rename)
 		diffcore_rename(detect_rename, rename_score);
+	if (0 <= break_opt)
+		diffcore_merge_broken();
 	if (pickaxe)
 		diffcore_pickaxe(pickaxe, pickaxe_opts);
+	if (orderfile)
+		diffcore_order(orderfile);
 }
 
 void diff_addremove(int addremove, unsigned mode,