2 * Copyright (C) 2005 Junio C Hamano
12 static const char *diff_opts
= "-pu";
13 static unsigned char null_sha1
[20] = { 0, };
15 static int reverse_diff
;
16 static int use_size_cache
;
18 static const char *external_diff(void)
20 static const char *external_diff_cmd
= NULL
;
21 static int done_preparing
= 0;
22 const char *env_diff_opts
;
25 return external_diff_cmd
;
28 * Default values above are meant to match the
29 * Linux kernel development style. Examples of
30 * alternative styles you can specify via environment
35 external_diff_cmd
= getenv("GIT_EXTERNAL_DIFF");
37 /* In case external diff fails... */
38 env_diff_opts
= getenv("GIT_DIFF_OPTS");
39 if (env_diff_opts
) diff_opts
= env_diff_opts
;
42 return external_diff_cmd
;
45 #define TEMPFILE_PATH_LEN 50
47 static struct diff_tempfile
{
48 const char *name
; /* filename external diff should read from */
51 char tmp_path
[TEMPFILE_PATH_LEN
];
54 static int count_lines(const char *filename
)
57 int count
, ch
, completely_empty
= 1, nl_just_seen
= 0;
58 in
= fopen(filename
, "r");
60 while ((ch
= fgetc(in
)) != EOF
)
74 count
++; /* no trailing newline */
78 static void print_line_count(int count
)
88 printf("1,%d", count
);
93 static void copy_file(int prefix
, const char *filename
)
96 int ch
, nl_just_seen
= 1;
97 in
= fopen(filename
, "r");
98 while ((ch
= fgetc(in
)) != EOF
) {
109 printf("\n\\ No newline at end of file\n");
112 static void emit_rewrite_diff(const char *name_a
,
114 struct diff_tempfile
*temp
)
116 /* Use temp[i].name as input, name_a and name_b as labels */
118 lc_a
= count_lines(temp
[0].name
);
119 lc_b
= count_lines(temp
[1].name
);
120 printf("--- %s\n+++ %s\n@@ -", name_a
, name_b
);
121 print_line_count(lc_a
);
123 print_line_count(lc_b
);
126 copy_file('-', temp
[0].name
);
128 copy_file('+', temp
[1].name
);
131 static void builtin_diff(const char *name_a
,
133 struct diff_tempfile
*temp
,
134 const char *xfrm_msg
,
135 int complete_rewrite
)
137 int i
, next_at
, cmd_size
;
138 const char *const diff_cmd
= "diff -L%s%s -L%s%s";
139 const char *const diff_arg
= "%s %s||:"; /* "||:" is to return 0 */
140 const char *input_name_sq
[2];
141 const char *path0
[2];
142 const char *path1
[2];
143 const char *name_sq
[2];
146 name_sq
[0] = sq_quote(name_a
);
147 name_sq
[1] = sq_quote(name_b
);
149 /* diff_cmd and diff_arg have 6 %s in total which makes
150 * the sum of these strings 12 bytes larger than required.
151 * we use 2 spaces around diff-opts, and we need to count
152 * terminating NUL, so we subtract 9 here.
154 cmd_size
= (strlen(diff_cmd
) + strlen(diff_opts
) +
155 strlen(diff_arg
) - 9);
156 for (i
= 0; i
< 2; i
++) {
157 input_name_sq
[i
] = sq_quote(temp
[i
].name
);
158 if (!strcmp(temp
[i
].name
, "/dev/null")) {
159 path0
[i
] = "/dev/null";
162 path0
[i
] = i
? "b/" : "a/";
163 path1
[i
] = name_sq
[i
];
165 cmd_size
+= (strlen(path0
[i
]) + strlen(path1
[i
]) +
166 strlen(input_name_sq
[i
]));
169 cmd
= xmalloc(cmd_size
);
172 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
174 path0
[0], path1
[0], path0
[1], path1
[1]);
175 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
177 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
178 diff_arg
, input_name_sq
[0], input_name_sq
[1]);
180 printf("diff --git a/%s b/%s\n", name_a
, name_b
);
182 printf("new file mode %s\n", temp
[1].mode
);
183 if (xfrm_msg
&& xfrm_msg
[0])
186 else if (!path1
[1][0]) {
187 printf("deleted file mode %s\n", temp
[0].mode
);
188 if (xfrm_msg
&& xfrm_msg
[0])
192 if (strcmp(temp
[0].mode
, temp
[1].mode
)) {
193 printf("old mode %s\n", temp
[0].mode
);
194 printf("new mode %s\n", temp
[1].mode
);
196 if (xfrm_msg
&& xfrm_msg
[0])
198 if (strncmp(temp
[0].mode
, temp
[1].mode
, 3))
199 /* we do not run diff between different kind
203 if (complete_rewrite
) {
205 emit_rewrite_diff(name_a
, name_b
, temp
);
210 execlp("/bin/sh","sh", "-c", cmd
, NULL
);
213 struct diff_filespec
*alloc_filespec(const char *path
)
215 int namelen
= strlen(path
);
216 struct diff_filespec
*spec
= xmalloc(sizeof(*spec
) + namelen
+ 1);
218 memset(spec
, 0, sizeof(*spec
));
219 spec
->path
= (char *)(spec
+ 1);
220 memcpy(spec
->path
, path
, namelen
+1);
224 void fill_filespec(struct diff_filespec
*spec
, const unsigned char *sha1
,
228 spec
->mode
= DIFF_FILE_CANON_MODE(mode
);
229 memcpy(spec
->sha1
, sha1
, 20);
230 spec
->sha1_valid
= !!memcmp(sha1
, null_sha1
, 20);
235 * Given a name and sha1 pair, if the dircache tells us the file in
236 * the work tree has that object contents, return true, so that
237 * prepare_temp_file() does not have to inflate and extract.
239 static int work_tree_matches(const char *name
, const unsigned char *sha1
)
241 struct cache_entry
*ce
;
245 /* We do not read the cache ourselves here, because the
246 * benchmark with my previous version that always reads cache
247 * shows that it makes things worse for diff-tree comparing
248 * two linux-2.6 kernel trees in an already checked out work
249 * tree. This is because most diff-tree comparisons deal with
250 * only a small number of files, while reading the cache is
251 * expensive for a large project, and its cost outweighs the
252 * savings we get by not inflating the object to a temporary
253 * file. Practically, this code only helps when we are used
254 * by diff-cache --cached, which does read the cache before
261 pos
= cache_name_pos(name
, len
);
264 ce
= active_cache
[pos
];
265 if ((lstat(name
, &st
) < 0) ||
266 !S_ISREG(st
.st_mode
) || /* careful! */
267 ce_match_stat(ce
, &st
) ||
268 memcmp(sha1
, ce
->sha1
, 20))
270 /* we return 1 only when we can stat, it is a regular file,
271 * stat information matches, and sha1 recorded in the cache
272 * matches. I.e. we know the file in the work tree really is
273 * the same as the <name, sha1> pair.
278 static struct sha1_size_cache
{
279 unsigned char sha1
[20];
282 static int sha1_size_cache_nr
, sha1_size_cache_alloc
;
284 static struct sha1_size_cache
*locate_size_cache(unsigned char *sha1
,
289 struct sha1_size_cache
*e
;
292 last
= sha1_size_cache_nr
;
293 while (last
> first
) {
294 int cmp
, next
= (last
+ first
) >> 1;
295 e
= sha1_size_cache
[next
];
296 cmp
= memcmp(e
->sha1
, sha1
, 20);
308 /* insert to make it at "first" */
309 if (sha1_size_cache_alloc
<= sha1_size_cache_nr
) {
310 sha1_size_cache_alloc
= alloc_nr(sha1_size_cache_alloc
);
311 sha1_size_cache
= xrealloc(sha1_size_cache
,
312 sha1_size_cache_alloc
*
313 sizeof(*sha1_size_cache
));
315 sha1_size_cache_nr
++;
316 if (first
< sha1_size_cache_nr
)
317 memmove(sha1_size_cache
+ first
+ 1, sha1_size_cache
+ first
,
318 (sha1_size_cache_nr
- first
- 1) *
319 sizeof(*sha1_size_cache
));
320 e
= xmalloc(sizeof(struct sha1_size_cache
));
321 sha1_size_cache
[first
] = e
;
322 memcpy(e
->sha1
, sha1
, 20);
328 * While doing rename detection and pickaxe operation, we may need to
329 * grab the data for the blob (or file) for our own in-core comparison.
330 * diff_filespec has data and size fields for this purpose.
332 int diff_populate_filespec(struct diff_filespec
*s
, int size_only
)
335 if (!DIFF_FILE_VALID(s
))
336 die("internal error: asking to populate invalid file.");
337 if (S_ISDIR(s
->mode
))
345 if (!s
->sha1_valid
||
346 work_tree_matches(s
->path
, s
->sha1
)) {
349 if (lstat(s
->path
, &st
) < 0) {
350 if (errno
== ENOENT
) {
359 s
->size
= st
.st_size
;
364 if (S_ISLNK(st
.st_mode
)) {
366 s
->data
= xmalloc(s
->size
);
368 ret
= readlink(s
->path
, s
->data
, s
->size
);
375 fd
= open(s
->path
, O_RDONLY
);
378 s
->data
= mmap(NULL
, s
->size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
380 if (s
->data
== MAP_FAILED
)
382 s
->should_munmap
= 1;
386 struct sha1_size_cache
*e
;
389 e
= locate_size_cache(s
->sha1
, 1, 0);
394 if (!sha1_object_info(s
->sha1
, type
, &s
->size
))
395 locate_size_cache(s
->sha1
, 0, s
->size
);
398 s
->data
= read_sha1_file(s
->sha1
, type
, &s
->size
);
405 void diff_free_filespec(struct diff_filespec
*s
)
409 else if (s
->should_munmap
)
410 munmap(s
->data
, s
->size
);
414 static void prep_temp_blob(struct diff_tempfile
*temp
,
422 fd
= git_mkstemp(temp
->tmp_path
, TEMPFILE_PATH_LEN
, ".diff_XXXXXX");
424 die("unable to create temp-file");
425 if (write(fd
, blob
, size
) != size
)
426 die("unable to write temp-file");
428 temp
->name
= temp
->tmp_path
;
429 strcpy(temp
->hex
, sha1_to_hex(sha1
));
431 sprintf(temp
->mode
, "%06o", mode
);
434 static void prepare_temp_file(const char *name
,
435 struct diff_tempfile
*temp
,
436 struct diff_filespec
*one
)
438 if (!DIFF_FILE_VALID(one
)) {
440 /* A '-' entry produces this for file-2, and
441 * a '+' entry produces this for file-1.
443 temp
->name
= "/dev/null";
444 strcpy(temp
->hex
, ".");
445 strcpy(temp
->mode
, ".");
449 if (!one
->sha1_valid
||
450 work_tree_matches(name
, one
->sha1
)) {
452 if (lstat(name
, &st
) < 0) {
454 goto not_a_valid_file
;
455 die("stat(%s): %s", name
, strerror(errno
));
457 if (S_ISLNK(st
.st_mode
)) {
459 char *buf
, buf_
[1024];
460 buf
= ((sizeof(buf_
) < st
.st_size
) ?
461 xmalloc(st
.st_size
) : buf_
);
462 ret
= readlink(name
, buf
, st
.st_size
);
464 die("readlink(%s)", name
);
465 prep_temp_blob(temp
, buf
, st
.st_size
,
467 one
->sha1
: null_sha1
),
469 one
->mode
: S_IFLNK
));
472 /* we can borrow from the file in the work tree */
474 if (!one
->sha1_valid
)
475 strcpy(temp
->hex
, sha1_to_hex(null_sha1
));
477 strcpy(temp
->hex
, sha1_to_hex(one
->sha1
));
478 /* Even though we may sometimes borrow the
479 * contents from the work tree, we always want
480 * one->mode. mode is trustworthy even when
481 * !(one->sha1_valid), as long as
482 * DIFF_FILE_VALID(one).
484 sprintf(temp
->mode
, "%06o", one
->mode
);
489 if (diff_populate_filespec(one
, 0))
490 die("cannot read data blob for %s", one
->path
);
491 prep_temp_blob(temp
, one
->data
, one
->size
,
492 one
->sha1
, one
->mode
);
496 static void remove_tempfile(void)
500 for (i
= 0; i
< 2; i
++)
501 if (diff_temp
[i
].name
== diff_temp
[i
].tmp_path
) {
502 unlink(diff_temp
[i
].name
);
503 diff_temp
[i
].name
= NULL
;
507 static void remove_tempfile_on_signal(int signo
)
512 /* An external diff command takes:
514 * diff-cmd name infile1 infile1-sha1 infile1-mode \
515 * infile2 infile2-sha1 infile2-mode [ rename-to ]
518 static void run_external_diff(const char *pgm
,
521 struct diff_filespec
*one
,
522 struct diff_filespec
*two
,
523 const char *xfrm_msg
,
524 int complete_rewrite
)
526 struct diff_tempfile
*temp
= diff_temp
;
529 static int atexit_asked
= 0;
530 const char *othername
;
532 othername
= (other
? other
: name
);
534 prepare_temp_file(name
, &temp
[0], one
);
535 prepare_temp_file(othername
, &temp
[1], two
);
536 if (! atexit_asked
&&
537 (temp
[0].name
== temp
[0].tmp_path
||
538 temp
[1].name
== temp
[1].tmp_path
)) {
540 atexit(remove_tempfile
);
542 signal(SIGINT
, remove_tempfile_on_signal
);
548 die("unable to fork");
552 const char *exec_arg
[10];
553 const char **arg
= &exec_arg
[0];
556 *arg
++ = temp
[0].name
;
557 *arg
++ = temp
[0].hex
;
558 *arg
++ = temp
[0].mode
;
559 *arg
++ = temp
[1].name
;
560 *arg
++ = temp
[1].hex
;
561 *arg
++ = temp
[1].mode
;
567 execvp(pgm
, (char *const*) exec_arg
);
570 execlp(pgm
, pgm
, name
, NULL
);
573 * otherwise we use the built-in one.
576 builtin_diff(name
, othername
, temp
, xfrm_msg
,
579 printf("* Unmerged path %s\n", name
);
582 if (waitpid(pid
, &status
, 0) < 0 ||
583 !WIFEXITED(status
) || WEXITSTATUS(status
)) {
584 /* Earlier we did not check the exit status because
585 * diff exits non-zero if files are different, and
586 * we are not interested in knowing that. It was a
587 * mistake which made it harder to quit a diff-*
588 * session that uses the git-apply-patch-script as
589 * the GIT_EXTERNAL_DIFF. A custom GIT_EXTERNAL_DIFF
590 * should also exit non-zero only when it wants to
591 * abort the entire diff-* session.
594 fprintf(stderr
, "external diff died, stopping at %s.\n", name
);
600 static void run_diff(struct diff_filepair
*p
)
602 const char *pgm
= external_diff();
603 char msg_
[PATH_MAX
*2+200], *xfrm_msg
;
604 struct diff_filespec
*one
;
605 struct diff_filespec
*two
;
608 int complete_rewrite
= 0;
610 if (DIFF_PAIR_UNMERGED(p
)) {
612 run_external_diff(pgm
, p
->one
->path
, NULL
, NULL
, NULL
, NULL
,
618 other
= (strcmp(name
, p
->two
->path
) ? p
->two
->path
: NULL
);
619 one
= p
->one
; two
= p
->two
;
621 case DIFF_STATUS_COPIED
:
623 "similarity index %d%%\n"
626 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
),
630 case DIFF_STATUS_RENAMED
:
632 "similarity index %d%%\n"
635 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
),
639 case DIFF_STATUS_MODIFIED
:
642 "dissimilarity index %d%%",
643 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
));
645 complete_rewrite
= 1;
654 DIFF_FILE_VALID(one
) && DIFF_FILE_VALID(two
) &&
655 (S_IFMT
& one
->mode
) != (S_IFMT
& two
->mode
)) {
656 /* a filepair that changes between file and symlink
657 * needs to be split into deletion and creation.
659 struct diff_filespec
*null
= alloc_filespec(two
->path
);
660 run_external_diff(NULL
, name
, other
, one
, null
, xfrm_msg
, 0);
662 null
= alloc_filespec(one
->path
);
663 run_external_diff(NULL
, name
, other
, null
, two
, xfrm_msg
, 0);
667 run_external_diff(pgm
, name
, other
, one
, two
, xfrm_msg
,
671 void diff_setup(int flags
)
673 if (flags
& DIFF_SETUP_REVERSE
)
675 if (flags
& DIFF_SETUP_USE_CACHE
) {
677 /* read-cache does not die even when it fails
678 * so it is safe for us to do this here. Also
679 * it does not smudge active_cache or active_nr
680 * when it fails, so we do not have to worry about
681 * cleaning it up oufselves either.
685 if (flags
& DIFF_SETUP_USE_SIZE_CACHE
)
690 static int parse_num(const char **cp_p
)
692 int num
, scale
, ch
, cnt
;
693 const char *cp
= *cp_p
;
697 while ('0' <= (ch
= *cp
) && ch
<= '9') {
699 /* We simply ignore more than 5 digits precision. */
701 num
= num
* 10 + ch
- '0';
707 /* user says num divided by scale and we say internally that
708 * is MAX_SCORE * num / scale.
710 return (MAX_SCORE
* num
/ scale
);
713 int diff_scoreopt_parse(const char *opt
)
720 if (cmd
!= 'M' && cmd
!= 'C' && cmd
!= 'B')
721 return -1; /* that is not a -M, -C nor -B option */
723 opt1
= parse_num(&opt
);
729 else if (*opt
!= '/')
730 return -1; /* we expect -B80/99 or -B80 */
733 opt2
= parse_num(&opt
);
738 return opt1
| (opt2
<< 16);
741 struct diff_queue_struct diff_queued_diff
;
743 void diff_q(struct diff_queue_struct
*queue
, struct diff_filepair
*dp
)
745 if (queue
->alloc
<= queue
->nr
) {
746 queue
->alloc
= alloc_nr(queue
->alloc
);
747 queue
->queue
= xrealloc(queue
->queue
,
748 sizeof(dp
) * queue
->alloc
);
750 queue
->queue
[queue
->nr
++] = dp
;
753 struct diff_filepair
*diff_queue(struct diff_queue_struct
*queue
,
754 struct diff_filespec
*one
,
755 struct diff_filespec
*two
)
757 struct diff_filepair
*dp
= xmalloc(sizeof(*dp
));
762 dp
->source_stays
= 0;
768 void diff_free_filepair(struct diff_filepair
*p
)
770 diff_free_filespec(p
->one
);
771 diff_free_filespec(p
->two
);
775 static void diff_flush_raw(struct diff_filepair
*p
,
776 int line_termination
,
777 int inter_name_termination
)
782 if (line_termination
) {
783 const char *const err
=
784 "path %s cannot be expressed without -z";
785 if (strchr(p
->one
->path
, line_termination
) ||
786 strchr(p
->one
->path
, inter_name_termination
))
787 die(err
, p
->one
->path
);
788 if (strchr(p
->two
->path
, line_termination
) ||
789 strchr(p
->two
->path
, inter_name_termination
))
790 die(err
, p
->two
->path
);
794 sprintf(status
, "%c%03d", p
->status
,
795 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
));
797 status
[0] = p
->status
;
801 case DIFF_STATUS_COPIED
:
802 case DIFF_STATUS_RENAMED
:
805 case DIFF_STATUS_ADDED
:
806 case DIFF_STATUS_DELETED
:
813 printf(":%06o %06o %s ",
814 p
->one
->mode
, p
->two
->mode
, sha1_to_hex(p
->one
->sha1
));
816 sha1_to_hex(p
->two
->sha1
),
818 inter_name_termination
,
821 printf("%c%s", inter_name_termination
, p
->two
->path
);
822 putchar(line_termination
);
825 static void diff_flush_name(struct diff_filepair
*p
,
826 int line_termination
)
828 printf("%s%c", p
->two
->path
, line_termination
);
831 int diff_unmodified_pair(struct diff_filepair
*p
)
833 /* This function is written stricter than necessary to support
834 * the currently implemented transformers, but the idea is to
835 * let transformers to produce diff_filepairs any way they want,
836 * and filter and clean them up here before producing the output.
838 struct diff_filespec
*one
, *two
;
840 if (DIFF_PAIR_UNMERGED(p
))
841 return 0; /* unmerged is interesting */
846 /* deletion, addition, mode or type change
847 * and rename are all interesting.
849 if (DIFF_FILE_VALID(one
) != DIFF_FILE_VALID(two
) ||
850 DIFF_PAIR_MODE_CHANGED(p
) ||
851 strcmp(one
->path
, two
->path
))
854 /* both are valid and point at the same path. that is, we are
855 * dealing with a change.
857 if (one
->sha1_valid
&& two
->sha1_valid
&&
858 !memcmp(one
->sha1
, two
->sha1
, sizeof(one
->sha1
)))
859 return 1; /* no change */
860 if (!one
->sha1_valid
&& !two
->sha1_valid
)
861 return 1; /* both look at the same file on the filesystem. */
865 static void diff_flush_patch(struct diff_filepair
*p
)
867 if (diff_unmodified_pair(p
))
870 if ((DIFF_FILE_VALID(p
->one
) && S_ISDIR(p
->one
->mode
)) ||
871 (DIFF_FILE_VALID(p
->two
) && S_ISDIR(p
->two
->mode
)))
872 return; /* no tree diffs in patch format */
877 int diff_queue_is_empty(void)
879 struct diff_queue_struct
*q
= &diff_queued_diff
;
881 for (i
= 0; i
< q
->nr
; i
++)
882 if (!diff_unmodified_pair(q
->queue
[i
]))
888 void diff_debug_filespec(struct diff_filespec
*s
, int x
, const char *one
)
890 fprintf(stderr
, "queue[%d] %s (%s) %s %06o %s\n",
893 DIFF_FILE_VALID(s
) ? "valid" : "invalid",
895 s
->sha1_valid
? sha1_to_hex(s
->sha1
) : "");
896 fprintf(stderr
, "queue[%d] %s size %lu flags %d\n",
898 s
->size
, s
->xfrm_flags
);
901 void diff_debug_filepair(const struct diff_filepair
*p
, int i
)
903 diff_debug_filespec(p
->one
, i
, "one");
904 diff_debug_filespec(p
->two
, i
, "two");
905 fprintf(stderr
, "score %d, status %c stays %d broken %d\n",
906 p
->score
, p
->status
? p
->status
: '?',
907 p
->source_stays
, p
->broken_pair
);
910 void diff_debug_queue(const char *msg
, struct diff_queue_struct
*q
)
914 fprintf(stderr
, "%s\n", msg
);
915 fprintf(stderr
, "q->nr = %d\n", q
->nr
);
916 for (i
= 0; i
< q
->nr
; i
++) {
917 struct diff_filepair
*p
= q
->queue
[i
];
918 diff_debug_filepair(p
, i
);
923 static void diff_resolve_rename_copy(void)
926 struct diff_filepair
*p
, *pp
;
927 struct diff_queue_struct
*q
= &diff_queued_diff
;
929 diff_debug_queue("resolve-rename-copy", q
);
931 for (i
= 0; i
< q
->nr
; i
++) {
933 p
->status
= 0; /* undecided */
934 if (DIFF_PAIR_UNMERGED(p
))
935 p
->status
= DIFF_STATUS_UNMERGED
;
936 else if (!DIFF_FILE_VALID(p
->one
))
937 p
->status
= DIFF_STATUS_ADDED
;
938 else if (!DIFF_FILE_VALID(p
->two
))
939 p
->status
= DIFF_STATUS_DELETED
;
940 else if (DIFF_PAIR_TYPE_CHANGED(p
))
941 p
->status
= DIFF_STATUS_TYPE_CHANGED
;
943 /* from this point on, we are dealing with a pair
944 * whose both sides are valid and of the same type, i.e.
945 * either in-place edit or rename/copy edit.
947 else if (DIFF_PAIR_RENAME(p
)) {
948 if (p
->source_stays
) {
949 p
->status
= DIFF_STATUS_COPIED
;
952 /* See if there is some other filepair that
953 * copies from the same source as us. If so
954 * we are a copy. Otherwise we are either a
955 * copy if the path stays, or a rename if it
956 * does not, but we already handled "stays" case.
958 for (j
= i
+ 1; j
< q
->nr
; j
++) {
960 if (strcmp(pp
->one
->path
, p
->one
->path
))
961 continue; /* not us */
962 if (!DIFF_PAIR_RENAME(pp
))
963 continue; /* not a rename/copy */
964 /* pp is a rename/copy from the same source */
965 p
->status
= DIFF_STATUS_COPIED
;
969 p
->status
= DIFF_STATUS_RENAMED
;
971 else if (memcmp(p
->one
->sha1
, p
->two
->sha1
, 20) ||
972 p
->one
->mode
!= p
->two
->mode
)
973 p
->status
= DIFF_STATUS_MODIFIED
;
975 /* This is a "no-change" entry and should not
976 * happen anymore, but prepare for broken callers.
978 error("feeding unmodified %s to diffcore",
980 p
->status
= DIFF_STATUS_UNKNOWN
;
983 diff_debug_queue("resolve-rename-copy done", q
);
986 void diff_flush(int diff_output_style
, int line_termination
)
988 struct diff_queue_struct
*q
= &diff_queued_diff
;
990 int inter_name_termination
= '\t';
992 if (!line_termination
)
993 inter_name_termination
= 0;
995 for (i
= 0; i
< q
->nr
; i
++) {
996 struct diff_filepair
*p
= q
->queue
[i
];
997 if ((diff_output_style
== DIFF_FORMAT_NO_OUTPUT
) ||
998 (p
->status
== DIFF_STATUS_UNKNOWN
))
1001 die("internal error in diff-resolve-rename-copy");
1002 switch (diff_output_style
) {
1003 case DIFF_FORMAT_PATCH
:
1004 diff_flush_patch(p
);
1006 case DIFF_FORMAT_RAW
:
1007 diff_flush_raw(p
, line_termination
,
1008 inter_name_termination
);
1010 case DIFF_FORMAT_NAME
:
1011 diff_flush_name(p
, line_termination
);
1014 diff_free_filepair(q
->queue
[i
]);
1018 q
->nr
= q
->alloc
= 0;
1021 static void diffcore_apply_filter(const char *filter
)
1024 struct diff_queue_struct
*q
= &diff_queued_diff
;
1025 struct diff_queue_struct outq
;
1027 outq
.nr
= outq
.alloc
= 0;
1032 if (strchr(filter
, DIFF_STATUS_FILTER_AON
)) {
1034 for (i
= found
= 0; !found
&& i
< q
->nr
; i
++) {
1035 struct diff_filepair
*p
= q
->queue
[i
];
1036 if (((p
->status
== DIFF_STATUS_MODIFIED
) &&
1038 strchr(filter
, DIFF_STATUS_FILTER_BROKEN
)) ||
1040 strchr(filter
, DIFF_STATUS_MODIFIED
)))) ||
1041 ((p
->status
!= DIFF_STATUS_MODIFIED
) &&
1042 strchr(filter
, p
->status
)))
1048 /* otherwise we will clear the whole queue
1049 * by copying the empty outq at the end of this
1050 * function, but first clear the current entries
1053 for (i
= 0; i
< q
->nr
; i
++)
1054 diff_free_filepair(q
->queue
[i
]);
1057 /* Only the matching ones */
1058 for (i
= 0; i
< q
->nr
; i
++) {
1059 struct diff_filepair
*p
= q
->queue
[i
];
1061 if (((p
->status
== DIFF_STATUS_MODIFIED
) &&
1063 strchr(filter
, DIFF_STATUS_FILTER_BROKEN
)) ||
1065 strchr(filter
, DIFF_STATUS_MODIFIED
)))) ||
1066 ((p
->status
!= DIFF_STATUS_MODIFIED
) &&
1067 strchr(filter
, p
->status
)))
1070 diff_free_filepair(p
);
1077 void diffcore_std(const char **paths
,
1078 int detect_rename
, int rename_score
,
1079 const char *pickaxe
, int pickaxe_opts
,
1081 const char *orderfile
,
1084 if (paths
&& paths
[0])
1085 diffcore_pathspec(paths
);
1086 if (break_opt
!= -1)
1087 diffcore_break(break_opt
);
1089 diffcore_rename(detect_rename
, rename_score
);
1090 if (break_opt
!= -1)
1091 diffcore_merge_broken();
1093 diffcore_pickaxe(pickaxe
, pickaxe_opts
);
1095 diffcore_order(orderfile
);
1096 diff_resolve_rename_copy();
1097 diffcore_apply_filter(filter
);
1101 void diffcore_std_no_resolve(const char **paths
,
1102 const char *pickaxe
, int pickaxe_opts
,
1103 const char *orderfile
,
1106 if (paths
&& paths
[0])
1107 diffcore_pathspec(paths
);
1109 diffcore_pickaxe(pickaxe
, pickaxe_opts
);
1111 diffcore_order(orderfile
);
1112 diffcore_apply_filter(filter
);
1115 void diff_addremove(int addremove
, unsigned mode
,
1116 const unsigned char *sha1
,
1117 const char *base
, const char *path
)
1119 char concatpath
[PATH_MAX
];
1120 struct diff_filespec
*one
, *two
;
1122 /* This may look odd, but it is a preparation for
1123 * feeding "there are unchanged files which should
1124 * not produce diffs, but when you are doing copy
1125 * detection you would need them, so here they are"
1126 * entries to the diff-core. They will be prefixed
1127 * with something like '=' or '*' (I haven't decided
1128 * which but should not make any difference).
1129 * Feeding the same new and old to diff_change()
1130 * also has the same effect.
1131 * Before the final output happens, they are pruned after
1132 * merged into rename/copy pairs as appropriate.
1135 addremove
= (addremove
== '+' ? '-' :
1136 addremove
== '-' ? '+' : addremove
);
1138 if (!path
) path
= "";
1139 sprintf(concatpath
, "%s%s", base
, path
);
1140 one
= alloc_filespec(concatpath
);
1141 two
= alloc_filespec(concatpath
);
1143 if (addremove
!= '+')
1144 fill_filespec(one
, sha1
, mode
);
1145 if (addremove
!= '-')
1146 fill_filespec(two
, sha1
, mode
);
1148 diff_queue(&diff_queued_diff
, one
, two
);
1151 void diff_helper_input(unsigned old_mode
,
1153 const unsigned char *old_sha1
,
1154 const unsigned char *new_sha1
,
1155 const char *old_path
,
1158 const char *new_path
)
1160 struct diff_filespec
*one
, *two
;
1161 struct diff_filepair
*dp
;
1163 one
= alloc_filespec(old_path
);
1164 two
= alloc_filespec(new_path
);
1166 fill_filespec(one
, old_sha1
, old_mode
);
1168 fill_filespec(two
, new_sha1
, new_mode
);
1169 dp
= diff_queue(&diff_queued_diff
, one
, two
);
1170 dp
->score
= score
* MAX_SCORE
/ 100;
1171 dp
->status
= status
;
1174 void diff_change(unsigned old_mode
, unsigned new_mode
,
1175 const unsigned char *old_sha1
,
1176 const unsigned char *new_sha1
,
1177 const char *base
, const char *path
)
1179 char concatpath
[PATH_MAX
];
1180 struct diff_filespec
*one
, *two
;
1184 const unsigned char *tmp_c
;
1185 tmp
= old_mode
; old_mode
= new_mode
; new_mode
= tmp
;
1186 tmp_c
= old_sha1
; old_sha1
= new_sha1
; new_sha1
= tmp_c
;
1188 if (!path
) path
= "";
1189 sprintf(concatpath
, "%s%s", base
, path
);
1190 one
= alloc_filespec(concatpath
);
1191 two
= alloc_filespec(concatpath
);
1192 fill_filespec(one
, old_sha1
, old_mode
);
1193 fill_filespec(two
, new_sha1
, new_mode
);
1195 diff_queue(&diff_queued_diff
, one
, two
);
1198 void diff_unmerge(const char *path
)
1200 struct diff_filespec
*one
, *two
;
1201 one
= alloc_filespec(path
);
1202 two
= alloc_filespec(path
);
1203 diff_queue(&diff_queued_diff
, one
, two
);