X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=diff.c;h=361d7c09ddfad2cb7e1589367ec74bad8f9ca67d;hb=c742b813971a415fea6e623de4d9e45286a0a976;hp=2762905b56a6a247f661a12d1573f1877d29a959;hpb=49d9e85d1103fe1d0fcb73956643b93acc5c1f4f;p=git.git

diff --git a/diff.c b/diff.c
index 2762905b..361d7c09 100644
--- a/diff.c
+++ b/diff.c
@@ -5,6 +5,7 @@
 #include <sys/wait.h>
 #include <signal.h>
 #include "cache.h"
+#include "quote.h"
 #include "diff.h"
 #include "diffcore.h"
 
@@ -40,42 +41,6 @@ static const char *external_diff(void)
 	return external_diff_cmd;
 }
 
-/* Help to copy the thing properly quoted for the shell safety.
- * any single quote is replaced with '\'', and the caller is
- * expected to enclose the result within a single quote pair.
- *
- * E.g.
- *  original     sq_expand     result
- *  name     ==> name      ==> 'name'
- *  a b      ==> a b       ==> 'a b'
- *  a'b      ==> a'\''b    ==> 'a'\''b'
- */
-static char *sq_expand(const char *src)
-{
-	static char *buf = NULL;
-	int cnt, c;
-	const char *cp;
-	char *bp;
-
-	/* count bytes needed to store the quoted string. */
-	for (cnt = 1, cp = src; *cp; cnt++, cp++)
-		if (*cp == '\'')
-			cnt += 3;
-
-	buf = xmalloc(cnt);
-	bp = buf;
-	while ((c = *src++)) {
-		if (c != '\'')
-			*bp++ = c;
-		else {
-			bp = strcpy(bp, "'\\''");
-			bp += 4;
-		}
-	}
-	*bp = 0;
-	return buf;
-}
-
 static struct diff_tempfile {
 	const char *name; /* filename external diff should read from */
 	char hex[41];
@@ -83,22 +48,100 @@ static struct diff_tempfile {
 	char tmp_path[50];
 } diff_temp[2];
 
+static int count_lines(const char *filename)
+{
+	FILE *in;
+	int count, ch, completely_empty = 1, nl_just_seen = 0;
+	in = fopen(filename, "r");
+	count = 0;
+	while ((ch = fgetc(in)) != EOF)
+		if (ch == '\n') {
+			count++;
+			nl_just_seen = 1;
+			completely_empty = 0;
+		}
+		else {
+			nl_just_seen = 0;
+			completely_empty = 0;
+		}
+	fclose(in);
+	if (completely_empty)
+		return 0;
+	if (!nl_just_seen)
+		count++; /* no trailing newline */
+	return count;
+}
+
+static void print_line_count(int count)
+{
+	switch (count) {
+	case 0:
+		printf("0,0");
+		break;
+	case 1:
+		printf("1");
+		break;
+	default:
+		printf("1,%d", count);
+		break;
+	}
+}
+
+static void copy_file(int prefix, const char *filename)
+{
+	FILE *in;
+	int ch, nl_just_seen = 1;
+	in = fopen(filename, "r");
+	while ((ch = fgetc(in)) != EOF) {
+		if (nl_just_seen)
+			putchar(prefix);
+		putchar(ch);
+		if (ch == '\n')
+			nl_just_seen = 1;
+		else
+			nl_just_seen = 0;
+	}
+	fclose(in);
+	if (!nl_just_seen)
+		printf("\n\\ No newline at end of file\n");
+}
+
+static void emit_rewrite_diff(const char *name_a,
+			      const char *name_b,
+			      struct diff_tempfile *temp)
+{
+	/* Use temp[i].name as input, name_a and name_b as labels */
+	int lc_a, lc_b;
+	lc_a = count_lines(temp[0].name);
+	lc_b = count_lines(temp[1].name);
+	printf("--- %s\n+++ %s\n@@ -", name_a, name_b);
+	print_line_count(lc_a);
+	printf(" +");
+	print_line_count(lc_b);
+	printf(" @@\n");
+	if (lc_a)
+		copy_file('-', temp[0].name);
+	if (lc_b)
+		copy_file('+', temp[1].name);
+}
+
 static void builtin_diff(const char *name_a,
 			 const char *name_b,
 			 struct diff_tempfile *temp,
-			 const char *xfrm_msg)
+			 const char *xfrm_msg,
+			 int complete_rewrite)
 {
 	int i, next_at, cmd_size;
-	const char *diff_cmd = "diff -L'%s%s' -L'%s%s'";
-	const char *diff_arg  = "'%s' '%s'||:"; /* "||:" is to return 0 */
+	const char *diff_cmd = "diff -L%s%s -L%s%s";
+	const char *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];
 	char *cmd;
 
-	name_sq[0] = sq_expand(name_a);
-	name_sq[1] = sq_expand(name_b);
+	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.
@@ -108,7 +151,7 @@ static void builtin_diff(const char *name_a,
 	cmd_size = (strlen(diff_cmd) + strlen(diff_opts) +
 			strlen(diff_arg) - 9);
 	for (i = 0; i < 2; i++) {
-		input_name_sq[i] = sq_expand(temp[i].name);
+		input_name_sq[i] = sq_quote(temp[i].name);
 		if (!strcmp(temp[i].name, "/dev/null")) {
 			path0[i] = "/dev/null";
 			path1[i] = "";
@@ -149,12 +192,16 @@ static void builtin_diff(const char *name_a,
 		}
 		if (xfrm_msg && xfrm_msg[0])
 			puts(xfrm_msg);
-
 		if (strncmp(temp[0].mode, temp[1].mode, 3))
 			/* we do not run diff between different kind
 			 * of objects.
 			 */
 			exit(0);
+		if (complete_rewrite) {
+			fflush(NULL);
+			emit_rewrite_diff(name_a, name_b, temp);
+			exit(0);
+		}
 	}
 	fflush(NULL);
 	execlp("/bin/sh","sh", "-c", cmd, NULL);
@@ -330,8 +377,10 @@ int diff_populate_filespec(struct diff_filespec *s, int size_only)
 		if (fd < 0)
 			goto err_empty;
 		s->data = mmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0);
-		s->should_munmap = 1;
 		close(fd);
+		if (s->data == MAP_FAILED)
+			goto err_empty;
+		s->should_munmap = 1;
 	}
 	else {
 		char type[20];
@@ -343,7 +392,7 @@ 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))
+			if (!sha1_object_info(s->sha1, type, &s->size))
 				locate_size_cache(s->sha1, 0, s->size);
 		}
 		else {
@@ -474,7 +523,8 @@ static void run_external_diff(const char *pgm,
 			      const char *other,
 			      struct diff_filespec *one,
 			      struct diff_filespec *two,
-			      const char *xfrm_msg)
+			      const char *xfrm_msg,
+			      int complete_rewrite)
 {
 	struct diff_tempfile *temp = diff_temp;
 	pid_t pid;
@@ -524,7 +574,8 @@ static void run_external_diff(const char *pgm,
 		 * otherwise we use the built-in one.
 		 */
 		if (one && two)
-			builtin_diff(name, other ? : name, temp, xfrm_msg);
+			builtin_diff(name, other ? : name, temp, xfrm_msg,
+				     complete_rewrite);
 		else
 			printf("* Unmerged path %s\n", name);
 		exit(0);
@@ -547,13 +598,59 @@ static void run_external_diff(const char *pgm,
 	remove_tempfile();
 }
 
-static void run_diff(const char *name,
-		     const char *other,
-		     struct diff_filespec *one,
-		     struct diff_filespec *two,
-		     const char *xfrm_msg)
+static void run_diff(struct diff_filepair *p)
 {
 	const char *pgm = external_diff();
+	char msg_[PATH_MAX*2+200], *xfrm_msg;
+	struct diff_filespec *one;
+	struct diff_filespec *two;
+	const char *name;
+	const char *other;
+	int complete_rewrite = 0;
+
+	if (DIFF_PAIR_UNMERGED(p)) {
+		/* unmerged */
+		run_external_diff(pgm, p->one->path, NULL, NULL, NULL, NULL,
+				  0);
+		return;
+	}
+
+	name = p->one->path;
+	other = (strcmp(name, p->two->path) ? p->two->path : NULL);
+	one = p->one; two = p->two;
+	switch (p->status) {
+	case DIFF_STATUS_COPIED:
+		sprintf(msg_,
+			"similarity index %d%%\n"
+			"copy from %s\n"
+			"copy to %s",
+			(int)(0.5 + p->score * 100.0/MAX_SCORE),
+			name, other);
+		xfrm_msg = msg_;
+		break;
+	case DIFF_STATUS_RENAMED:
+		sprintf(msg_,
+			"similarity index %d%%\n"
+			"rename from %s\n"
+			"rename to %s",
+			(int)(0.5 + p->score * 100.0/MAX_SCORE),
+			name, other);
+		xfrm_msg = msg_;
+		break;
+	case DIFF_STATUS_MODIFIED:
+		if (p->score) {
+			sprintf(msg_,
+				"dissimilarity index %d%%",
+				(int)(0.5 + p->score * 100.0/MAX_SCORE));
+			xfrm_msg = msg_;
+			complete_rewrite = 1;
+			break;
+		}
+		/* fallthru */
+	default:
+		xfrm_msg = NULL;
+	}
+
 	if (!pgm &&
 	    DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
 	    (S_IFMT & one->mode) != (S_IFMT & two->mode)) {
@@ -561,14 +658,15 @@ static void run_diff(const char *name,
 		 * needs to be split into deletion and creation.
 		 */
 		struct diff_filespec *null = alloc_filespec(two->path);
-		run_external_diff(NULL, name, other, one, null, xfrm_msg);
+		run_external_diff(NULL, name, other, one, null, xfrm_msg, 0);
 		free(null);
 		null = alloc_filespec(one->path);
-		run_external_diff(NULL, name, other, null, two, xfrm_msg);
+		run_external_diff(NULL, name, other, null, two, xfrm_msg, 0);
 		free(null);
 	}
 	else
-		run_external_diff(pgm, name, other, one, two, xfrm_msg);
+		run_external_diff(pgm, name, other, one, two, xfrm_msg,
+				  complete_rewrite);
 }
 
 void diff_setup(int flags)
@@ -661,6 +759,7 @@ struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
 	dp->one = one;
 	dp->two = two;
 	dp->score = 0;
+	dp->status = 0;
 	dp->source_stays = 0;
 	dp->broken_pair = 0;
 	diff_q(queue, dp);
@@ -691,26 +790,24 @@ static void diff_flush_raw(struct diff_filepair *p,
 			die(err, p->two->path);
 	}
 
-	switch (p->status) {
-	case 'C': case 'R':
-		two_paths = 1;
+	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;
+	}
+	switch (p->status) {
+	case DIFF_STATUS_COPIED:
+	case DIFF_STATUS_RENAMED:
+		two_paths = 1;
 		break;
-	case 'N': case 'D':
+	case DIFF_STATUS_ADDED:
+	case DIFF_STATUS_DELETED:
 		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;
-		status[1] = 0;
 		break;
 	}
 	printf(":%06o %06o %s ",
@@ -725,6 +822,12 @@ static void diff_flush_raw(struct diff_filepair *p,
 	putchar(line_termination);
 }
 
+static void diff_flush_name(struct diff_filepair *p,
+			    int line_termination)
+{
+	printf("%s%c", p->two->path, line_termination);
+}
+
 int diff_unmodified_pair(struct diff_filepair *p)
 {
 	/* This function is written stricter than necessary to support
@@ -761,55 +864,14 @@ int diff_unmodified_pair(struct diff_filepair *p)
 
 static void diff_flush_patch(struct diff_filepair *p)
 {
-	const char *name, *other;
-	char msg_[PATH_MAX*2+200], *msg;
-
 	if (diff_unmodified_pair(p))
 		return;
 
-	name = p->one->path;
-	other = (strcmp(name, p->two->path) ? p->two->path : NULL);
 	if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
 	    (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
 		return; /* no tree diffs in patch format */ 
 
-	switch (p->status) {
-	case 'C':
-		sprintf(msg_,
-			"similarity index %d%%\n"
-			"copy from %s\n"
-			"copy to %s",
-			(int)(0.5 + p->score * 100.0/MAX_SCORE),
-			p->one->path, p->two->path);
-		msg = msg_;
-		break;
-	case 'R':
-		sprintf(msg_,
-			"similarity index %d%%\n"
-			"rename old %s\n"
-			"rename new %s",
-			(int)(0.5 + p->score * 100.0/MAX_SCORE),
-			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;
-	}
-
-	if (DIFF_PAIR_UNMERGED(p))
-		run_diff(name, NULL, NULL, NULL, NULL);
-	else
-		run_diff(name, other, p->one, p->two, msg);
+	run_diff(p);
 }
 
 int diff_queue_is_empty(void)
@@ -870,13 +932,13 @@ static void diff_resolve_rename_copy(void)
 		p = q->queue[i];
 		p->status = 0; /* undecided */
 		if (DIFF_PAIR_UNMERGED(p))
-			p->status = 'U';
+			p->status = DIFF_STATUS_UNMERGED;
 		else if (!DIFF_FILE_VALID(p->one))
-			p->status = 'N';
+			p->status = DIFF_STATUS_ADDED;
 		else if (!DIFF_FILE_VALID(p->two))
-			p->status = 'D';
+			p->status = DIFF_STATUS_DELETED;
 		else if (DIFF_PAIR_TYPE_CHANGED(p))
-			p->status = 'T';
+			p->status = DIFF_STATUS_TYPE_CHANGED;
 
 		/* from this point on, we are dealing with a pair
 		 * whose both sides are valid and of the same type, i.e.
@@ -884,7 +946,7 @@ static void diff_resolve_rename_copy(void)
 		 */
 		else if (DIFF_PAIR_RENAME(p)) {
 			if (p->source_stays) {
-				p->status = 'C';
+				p->status = DIFF_STATUS_COPIED;
 				continue;
 			}
 			/* See if there is some other filepair that
@@ -898,43 +960,40 @@ static void diff_resolve_rename_copy(void)
 				if (!DIFF_PAIR_RENAME(pp))
 					continue; /* not a rename/copy */
 				/* pp is a rename/copy from the same source */
-				p->status = 'C';
+				p->status = DIFF_STATUS_COPIED;
 				break;
 			}
 			if (!p->status)
-				p->status = 'R';
+				p->status = DIFF_STATUS_RENAMED;
 		}
 		else if (memcmp(p->one->sha1, p->two->sha1, 20) ||
 			 p->one->mode != p->two->mode)
-			p->status = 'M';
+			p->status = DIFF_STATUS_MODIFIED;
 		else {
 			/* This is a "no-change" entry and should not
 			 * happen anymore, but prepare for broken callers.
 			 */
 			error("feeding unmodified %s to diffcore",
 			      p->one->path);
-			p->status = 'X';
+			p->status = DIFF_STATUS_UNKNOWN;
 		}
 	}
 	diff_debug_queue("resolve-rename-copy done", q);
 }
 
-void diff_flush(int diff_output_style, int resolve_rename_copy)
+void diff_flush(int diff_output_style, int line_termination)
 {
 	struct diff_queue_struct *q = &diff_queued_diff;
 	int i;
-	int line_termination = '\n';
 	int inter_name_termination = '\t';
 
-	if (diff_output_style == DIFF_FORMAT_MACHINE)
-		line_termination = inter_name_termination = 0;
-	if (resolve_rename_copy)
-		diff_resolve_rename_copy();
+	if (!line_termination)
+		inter_name_termination = 0;
 
 	for (i = 0; i < q->nr; i++) {
 		struct diff_filepair *p = q->queue[i];
 		if ((diff_output_style == DIFF_FORMAT_NO_OUTPUT) ||
-		    (p->status == 'X'))
+		    (p->status == DIFF_STATUS_UNKNOWN))
 			continue;
 		if (p->status == 0)
 			die("internal error in diff-resolve-rename-copy");
@@ -942,11 +1001,13 @@ void diff_flush(int diff_output_style, int resolve_rename_copy)
 		case DIFF_FORMAT_PATCH:
 			diff_flush_patch(p);
 			break;
-		case DIFF_FORMAT_HUMAN:
-		case DIFF_FORMAT_MACHINE:
+		case DIFF_FORMAT_RAW:
 			diff_flush_raw(p, line_termination,
 				       inter_name_termination);
 			break;
+		case DIFF_FORMAT_NAME:
+			diff_flush_name(p, line_termination);
+			break;
 		}
 	}
 	for (i = 0; i < q->nr; i++)
@@ -956,11 +1017,68 @@ void diff_flush(int diff_output_style, int resolve_rename_copy)
 	q->nr = q->alloc = 0;
 }
 
+static void diffcore_apply_filter(const char *filter)
+{
+	int i;
+	struct diff_queue_struct *q = &diff_queued_diff;
+	struct diff_queue_struct outq;
+	outq.queue = NULL;
+	outq.nr = outq.alloc = 0;
+
+	if (!filter)
+		return;
+
+	if (strchr(filter, DIFF_STATUS_FILTER_AON)) {
+		int found;
+		for (i = found = 0; !found && i < q->nr; i++) {
+			struct diff_filepair *p = q->queue[i];
+			if (((p->status == DIFF_STATUS_MODIFIED) &&
+			     ((p->score &&
+			       strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
+			      (!p->score &&
+			       strchr(filter, DIFF_STATUS_MODIFIED)))) ||
+			    ((p->status != DIFF_STATUS_MODIFIED) &&
+			     strchr(filter, p->status)))
+				found++;
+		}
+		if (found)
+			return;
+
+		/* otherwise we will clear the whole queue
+		 * by copying the empty outq at the end of this
+		 * function, but first clear the current entries
+		 * in the queue.
+		 */
+		for (i = 0; i < q->nr; i++)
+			diff_free_filepair(q->queue[i]);
+	}
+	else {
+		/* Only the matching ones */
+		for (i = 0; i < q->nr; i++) {
+			struct diff_filepair *p = q->queue[i];
+
+			if (((p->status == DIFF_STATUS_MODIFIED) &&
+			     ((p->score &&
+			       strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
+			      (!p->score &&
+			       strchr(filter, DIFF_STATUS_MODIFIED)))) ||
+			    ((p->status != DIFF_STATUS_MODIFIED) &&
+			     strchr(filter, p->status)))
+				diff_q(&outq, p);
+			else
+				diff_free_filepair(p);
+		}
+	}
+	free(q->queue);
+	*q = outq;
+}
+
 void diffcore_std(const char **paths,
 		  int detect_rename, int rename_score,
 		  const char *pickaxe, int pickaxe_opts,
 		  int break_opt,
-		  const char *orderfile)
+		  const char *orderfile,
+		  const char *filter)
 {
 	if (paths && paths[0])
 		diffcore_pathspec(paths);
@@ -974,6 +1092,23 @@ void diffcore_std(const char **paths,
 		diffcore_pickaxe(pickaxe, pickaxe_opts);
 	if (orderfile)
 		diffcore_order(orderfile);
+	diff_resolve_rename_copy();
+	diffcore_apply_filter(filter);
+}
+
+
+void diffcore_std_no_resolve(const char **paths,
+			     const char *pickaxe, int pickaxe_opts,
+			     const char *orderfile,
+			     const char *filter)
+{
+	if (paths && paths[0])
+		diffcore_pathspec(paths);
+	if (pickaxe)
+		diffcore_pickaxe(pickaxe, pickaxe_opts);
+	if (orderfile)
+		diffcore_order(orderfile);
+	diffcore_apply_filter(filter);
 }
 
 void diff_addremove(int addremove, unsigned mode,