2 * Copyright (C) 2005 Junio C Hamano
11 static const char *diff_opts
= "-pu";
12 static unsigned char null_sha1
[20] = { 0, };
14 static int reverse_diff
;
15 static int generate_patch
;
16 static int line_termination
= '\n';
17 static int inter_name_termination
= '\t';
19 static const char *external_diff(void)
21 static const char *external_diff_cmd
= NULL
;
22 static int done_preparing
= 0;
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 if (gitenv("GIT_EXTERNAL_DIFF"))
36 external_diff_cmd
= gitenv("GIT_EXTERNAL_DIFF");
38 /* In case external diff fails... */
39 diff_opts
= gitenv("GIT_DIFF_OPTS") ? : diff_opts
;
42 return external_diff_cmd
;
45 /* Help to copy the thing properly quoted for the shell safety.
46 * any single quote is replaced with '\'', and the caller is
47 * expected to enclose the result within a single quote pair.
50 * original sq_expand result
51 * name ==> name ==> 'name'
52 * a b ==> a b ==> 'a b'
53 * a'b ==> a'\''b ==> 'a'\''b'
55 static char *sq_expand(const char *src
)
57 static char *buf
= NULL
;
62 /* count bytes needed to store the quoted string. */
63 for (cnt
= 1, cp
= src
; *cp
; cnt
++, cp
++)
69 while ((c
= *src
++)) {
73 bp
= strcpy(bp
, "'\\''");
81 static struct diff_tempfile
{
82 const char *name
; /* filename external diff should read from */
88 static void builtin_diff(const char *name_a
,
90 struct diff_tempfile
*temp
,
93 int i
, next_at
, cmd_size
;
94 const char *diff_cmd
= "diff -L'%s%s' -L'%s%s'";
95 const char *diff_arg
= "'%s' '%s'||:"; /* "||:" is to return 0 */
96 const char *input_name_sq
[2];
99 const char *name_sq
[2];
102 name_sq
[0] = sq_expand(name_a
);
103 name_sq
[1] = sq_expand(name_b
);
105 /* diff_cmd and diff_arg have 6 %s in total which makes
106 * the sum of these strings 12 bytes larger than required.
107 * we use 2 spaces around diff-opts, and we need to count
108 * terminating NUL, so we subtract 9 here.
110 cmd_size
= (strlen(diff_cmd
) + strlen(diff_opts
) +
111 strlen(diff_arg
) - 9);
112 for (i
= 0; i
< 2; i
++) {
113 input_name_sq
[i
] = sq_expand(temp
[i
].name
);
114 if (!strcmp(temp
[i
].name
, "/dev/null")) {
115 path0
[i
] = "/dev/null";
118 path0
[i
] = i
? "b/" : "a/";
119 path1
[i
] = name_sq
[i
];
121 cmd_size
+= (strlen(path0
[i
]) + strlen(path1
[i
]) +
122 strlen(input_name_sq
[i
]));
125 cmd
= xmalloc(cmd_size
);
128 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
130 path0
[0], path1
[0], path0
[1], path1
[1]);
131 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
133 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
134 diff_arg
, input_name_sq
[0], input_name_sq
[1]);
136 printf("diff --git a/%s b/%s\n", name_a
, name_b
);
138 printf("new file mode %s\n", temp
[1].mode
);
139 else if (!path1
[1][0])
140 printf("deleted file mode %s\n", temp
[0].mode
);
142 if (strcmp(temp
[0].mode
, temp
[1].mode
)) {
143 printf("old mode %s\n", temp
[0].mode
);
144 printf("new mode %s\n", temp
[1].mode
);
146 if (xfrm_msg
&& xfrm_msg
[0])
147 fputs(xfrm_msg
, stdout
);
149 if (strncmp(temp
[0].mode
, temp
[1].mode
, 3))
150 /* we do not run diff between different kind
156 execlp("/bin/sh","sh", "-c", cmd
, NULL
);
159 struct diff_filespec
*alloc_filespec(const char *path
)
161 int namelen
= strlen(path
);
162 struct diff_filespec
*spec
= xmalloc(sizeof(*spec
) + namelen
+ 1);
163 spec
->path
= (char *)(spec
+ 1);
164 strcpy(spec
->path
, path
);
165 spec
->should_free
= spec
->should_munmap
= 0;
166 spec
->xfrm_flags
= 0;
170 memset(spec
->sha1
, 0, 20);
174 void fill_filespec(struct diff_filespec
*spec
, const unsigned char *sha1
,
177 if (mode
) { /* just playing defensive */
179 memcpy(spec
->sha1
, sha1
, 20);
180 spec
->sha1_valid
= !!memcmp(sha1
, null_sha1
, 20);
185 * Given a name and sha1 pair, if the dircache tells us the file in
186 * the work tree has that object contents, return true, so that
187 * prepare_temp_file() does not have to inflate and extract.
189 static int work_tree_matches(const char *name
, const unsigned char *sha1
)
191 struct cache_entry
*ce
;
195 /* We do not read the cache ourselves here, because the
196 * benchmark with my previous version that always reads cache
197 * shows that it makes things worse for diff-tree comparing
198 * two linux-2.6 kernel trees in an already checked out work
199 * tree. This is because most diff-tree comparisons deal with
200 * only a small number of files, while reading the cache is
201 * expensive for a large project, and its cost outweighs the
202 * savings we get by not inflating the object to a temporary
203 * file. Practically, this code only helps when we are used
204 * by diff-cache --cached, which does read the cache before
211 pos
= cache_name_pos(name
, len
);
214 ce
= active_cache
[pos
];
215 if ((lstat(name
, &st
) < 0) ||
216 !S_ISREG(st
.st_mode
) || /* careful! */
217 ce_match_stat(ce
, &st
) ||
218 memcmp(sha1
, ce
->sha1
, 20))
220 /* we return 1 only when we can stat, it is a regular file,
221 * stat information matches, and sha1 recorded in the cache
222 * matches. I.e. we know the file in the work tree really is
223 * the same as the <name, sha1> pair.
229 * While doing rename detection and pickaxe operation, we may need to
230 * grab the data for the blob (or file) for our own in-core comparison.
231 * diff_filespec has data and size fields for this purpose.
233 int diff_populate_filespec(struct diff_filespec
*s
)
236 if (!DIFF_FILE_VALID(s
))
237 die("internal error: asking to populate invalid file.");
238 if (S_ISDIR(s
->mode
))
243 if (!s
->sha1_valid
||
244 work_tree_matches(s
->path
, s
->sha1
)) {
247 if (lstat(s
->path
, &st
) < 0) {
248 if (errno
== ENOENT
) {
257 s
->size
= st
.st_size
;
260 if (S_ISLNK(st
.st_mode
)) {
262 s
->data
= xmalloc(s
->size
);
264 ret
= readlink(s
->path
, s
->data
, s
->size
);
271 fd
= open(s
->path
, O_RDONLY
);
274 s
->data
= mmap(NULL
, s
->size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
275 s
->should_munmap
= 1;
280 s
->data
= read_sha1_file(s
->sha1
, type
, &s
->size
);
286 void diff_free_filespec_data(struct diff_filespec
*s
)
290 else if (s
->should_munmap
)
291 munmap(s
->data
, s
->size
);
292 s
->should_free
= s
->should_munmap
= 0;
296 static void prep_temp_blob(struct diff_tempfile
*temp
,
304 strcpy(temp
->tmp_path
, ".diff_XXXXXX");
305 fd
= mkstemp(temp
->tmp_path
);
307 die("unable to create temp-file");
308 if (write(fd
, blob
, size
) != size
)
309 die("unable to write temp-file");
311 temp
->name
= temp
->tmp_path
;
312 strcpy(temp
->hex
, sha1_to_hex(sha1
));
314 sprintf(temp
->mode
, "%06o", mode
);
317 static void prepare_temp_file(const char *name
,
318 struct diff_tempfile
*temp
,
319 struct diff_filespec
*one
)
321 if (!DIFF_FILE_VALID(one
)) {
323 /* A '-' entry produces this for file-2, and
324 * a '+' entry produces this for file-1.
326 temp
->name
= "/dev/null";
327 strcpy(temp
->hex
, ".");
328 strcpy(temp
->mode
, ".");
332 if (!one
->sha1_valid
||
333 work_tree_matches(name
, one
->sha1
)) {
335 if (lstat(name
, &st
) < 0) {
337 goto not_a_valid_file
;
338 die("stat(%s): %s", name
, strerror(errno
));
340 if (S_ISLNK(st
.st_mode
)) {
342 char *buf
, buf_
[1024];
343 buf
= ((sizeof(buf_
) < st
.st_size
) ?
344 xmalloc(st
.st_size
) : buf_
);
345 ret
= readlink(name
, buf
, st
.st_size
);
347 die("readlink(%s)", name
);
348 prep_temp_blob(temp
, buf
, st
.st_size
,
350 one
->sha1
: null_sha1
),
352 one
->mode
: S_IFLNK
));
355 /* we can borrow from the file in the work tree */
357 if (!one
->sha1_valid
)
358 strcpy(temp
->hex
, sha1_to_hex(null_sha1
));
360 strcpy(temp
->hex
, sha1_to_hex(one
->sha1
));
361 sprintf(temp
->mode
, "%06o",
362 S_IFREG
|ce_permissions(st
.st_mode
));
367 if (diff_populate_filespec(one
))
368 die("cannot read data blob for %s", one
->path
);
369 prep_temp_blob(temp
, one
->data
, one
->size
,
370 one
->sha1
, one
->mode
);
374 static void remove_tempfile(void)
378 for (i
= 0; i
< 2; i
++)
379 if (diff_temp
[i
].name
== diff_temp
[i
].tmp_path
) {
380 unlink(diff_temp
[i
].name
);
381 diff_temp
[i
].name
= NULL
;
385 static void remove_tempfile_on_signal(int signo
)
390 /* An external diff command takes:
392 * diff-cmd name infile1 infile1-sha1 infile1-mode \
393 * infile2 infile2-sha1 infile2-mode [ rename-to ]
396 static void run_external_diff(const char *name
,
398 struct diff_filespec
*one
,
399 struct diff_filespec
*two
,
400 const char *xfrm_msg
)
402 struct diff_tempfile
*temp
= diff_temp
;
405 static int atexit_asked
= 0;
408 prepare_temp_file(name
, &temp
[0], one
);
409 prepare_temp_file(other
? : name
, &temp
[1], two
);
410 if (! atexit_asked
&&
411 (temp
[0].name
== temp
[0].tmp_path
||
412 temp
[1].name
== temp
[1].tmp_path
)) {
414 atexit(remove_tempfile
);
416 signal(SIGINT
, remove_tempfile_on_signal
);
422 die("unable to fork");
424 const char *pgm
= external_diff();
427 const char *exec_arg
[10];
428 const char **arg
= &exec_arg
[0];
431 *arg
++ = temp
[0].name
;
432 *arg
++ = temp
[0].hex
;
433 *arg
++ = temp
[0].mode
;
434 *arg
++ = temp
[1].name
;
435 *arg
++ = temp
[1].hex
;
436 *arg
++ = temp
[1].mode
;
442 execvp(pgm
, (char *const*) exec_arg
);
445 execlp(pgm
, pgm
, name
, NULL
);
448 * otherwise we use the built-in one.
451 builtin_diff(name
, other
? : name
, temp
, xfrm_msg
);
453 printf("* Unmerged path %s\n", name
);
456 if (waitpid(pid
, &status
, 0) < 0 ||
457 !WIFEXITED(status
) || WEXITSTATUS(status
)) {
458 /* Earlier we did not check the exit status because
459 * diff exits non-zero if files are different, and
460 * we are not interested in knowing that. It was a
461 * mistake which made it harder to quit a diff-*
462 * session that uses the git-apply-patch-script as
463 * the GIT_EXTERNAL_DIFF. A custom GIT_EXTERNAL_DIFF
464 * should also exit non-zero only when it wants to
465 * abort the entire diff-* session.
468 fprintf(stderr
, "external diff died, stopping at %s.\n", name
);
474 void diff_setup(int reverse_diff_
)
476 reverse_diff
= reverse_diff_
;
479 struct diff_queue_struct diff_queued_diff
;
481 void diff_q(struct diff_queue_struct
*queue
, struct diff_filepair
*dp
)
483 if (queue
->alloc
<= queue
->nr
) {
484 queue
->alloc
= alloc_nr(queue
->alloc
);
485 queue
->queue
= xrealloc(queue
->queue
,
486 sizeof(dp
) * queue
->alloc
);
488 queue
->queue
[queue
->nr
++] = dp
;
491 struct diff_filepair
*diff_queue(struct diff_queue_struct
*queue
,
492 struct diff_filespec
*one
,
493 struct diff_filespec
*two
)
495 struct diff_filepair
*dp
= xmalloc(sizeof(*dp
));
499 dp
->orig_order
= queue
->nr
;
505 static void diff_flush_raw(struct diff_filepair
*p
)
507 if (DIFF_PAIR_UNMERGED(p
)) {
508 printf("U %s%c", p
->one
->path
, line_termination
);
511 printf(":%06o %06o %s ",
512 p
->one
->mode
, p
->two
->mode
, sha1_to_hex(p
->one
->sha1
));
513 printf("%s%c%s%c%s%c",
514 sha1_to_hex(p
->two
->sha1
), inter_name_termination
,
515 p
->one
->path
, inter_name_termination
,
516 p
->two
->path
, line_termination
);
519 int diff_unmodified_pair(struct diff_filepair
*p
)
521 /* This function is written stricter than necessary to support
522 * the currently implemented transformers, but the idea is to
523 * let transformers to produce diff_filepairs any way they want,
524 * and filter and clean them up here before producing the output.
526 struct diff_filespec
*one
, *two
;
528 if (DIFF_PAIR_UNMERGED(p
))
529 return 0; /* unmerged is interesting */
534 /* deletion, addition, mode change and renames are all interesting. */
535 if (DIFF_FILE_VALID(one
) != DIFF_FILE_VALID(two
) ||
536 (one
->mode
!= two
->mode
) ||
537 strcmp(one
->path
, two
->path
))
540 /* both are valid and point at the same path. that is, we are
541 * dealing with a change.
543 if (one
->sha1_valid
&& two
->sha1_valid
&&
544 !memcmp(one
->sha1
, two
->sha1
, sizeof(one
->sha1
)))
545 return 1; /* no change */
546 if (!one
->sha1_valid
&& !two
->sha1_valid
)
547 return 1; /* both look at the same file on the filesystem. */
551 static void diff_flush_patch(struct diff_filepair
*p
, const char *msg
)
553 const char *name
, *other
;
555 /* diffcore_prune() keeps "stay" entries for diff-raw
556 * copy/rename detection, but when we are generating
557 * patches we do not need them.
559 if (diff_unmodified_pair(p
))
563 other
= (strcmp(name
, p
->two
->path
) ? p
->two
->path
: NULL
);
564 if ((DIFF_FILE_VALID(p
->one
) && S_ISDIR(p
->one
->mode
)) ||
565 (DIFF_FILE_VALID(p
->two
) && S_ISDIR(p
->two
->mode
)))
566 return; /* no tree diffs in patch format */
568 if (DIFF_PAIR_UNMERGED(p
))
569 run_external_diff(name
, NULL
, NULL
, NULL
, NULL
);
571 run_external_diff(name
, other
, p
->one
, p
->two
, msg
);
574 int diff_needs_to_stay(struct diff_queue_struct
*q
, int i
,
575 struct diff_filespec
*it
)
577 /* If it will be used in later entry (either stay or used
578 * as the source of rename/copy), we need to copy, not rename.
581 struct diff_filepair
*p
= q
->queue
[i
++];
582 if (!DIFF_FILE_VALID(p
->two
))
583 continue; /* removed is fine */
584 if (strcmp(p
->one
->path
, it
->path
))
585 continue; /* not relevant */
587 /* p has its src set to *it and it is not a delete;
588 * it will be used for in-place change, rename/copy,
589 * or just stays there. We cannot rename it out.
596 static int diff_used_as_source(struct diff_queue_struct
*q
, int lim
,
597 struct diff_filespec
*it
)
600 for (i
= 0; i
< lim
; i
++) {
601 struct diff_filepair
*p
= q
->queue
[i
++];
602 if (!strcmp(p
->one
->path
, it
->path
))
608 void diffcore_prune(void)
611 * Although rename/copy detection wants to have "no-change"
612 * entries fed into them, the downstream do not need to see
613 * them, unless we had rename/copy for the same path earlier.
614 * This function removes such entries.
616 * The applications that use rename/copy should:
618 * (1) feed change and "no-change" entries via diff_queue().
619 * (2) call diffcore_rename, and any other future diffcore_xxx
620 * that would benefit by still having "no-change" entries.
621 * (3) call diffcore_prune
622 * (4) call other diffcore_xxx that do not need to see
623 * "no-change" entries.
624 * (5) call diff_flush().
626 struct diff_queue_struct
*q
= &diff_queued_diff
;
627 struct diff_queue_struct outq
;
631 outq
.nr
= outq
.alloc
= 0;
633 for (i
= 0; i
< q
->nr
; i
++) {
634 struct diff_filepair
*p
= q
->queue
[i
];
635 if (!diff_unmodified_pair(p
) ||
636 diff_used_as_source(q
, i
, p
->one
))
646 static void diff_flush_one(struct diff_filepair
*p
, const char *msg
)
649 diff_flush_patch(p
, msg
);
654 int diff_queue_is_empty(void)
656 struct diff_queue_struct
*q
= &diff_queued_diff
;
660 void diff_flush(int diff_output_style
)
662 struct diff_queue_struct
*q
= &diff_queued_diff
;
666 switch (diff_output_style
) {
667 case DIFF_FORMAT_HUMAN
:
668 line_termination
= '\n';
669 inter_name_termination
= '\t';
671 case DIFF_FORMAT_MACHINE
:
672 line_termination
= inter_name_termination
= 0;
674 case DIFF_FORMAT_PATCH
:
678 for (i
= 0; i
< q
->nr
; i
++) {
679 char msg_
[PATH_MAX
*2+200], *msg
= NULL
;
680 struct diff_filepair
*p
= q
->queue
[i
];
681 if (strcmp(p
->one
->path
, p
->two
->path
)) {
682 /* This is rename or copy. Which one is it? */
683 if (diff_needs_to_stay(q
, i
+1, p
->one
)) {
685 "similarity index %d%%\n"
688 (int)(0.5 + p
->score
* 100/MAX_SCORE
),
689 p
->one
->path
, p
->two
->path
);
693 "similarity index %d%%\n"
696 (int)(0.5 + p
->score
* 100/MAX_SCORE
),
697 p
->one
->path
, p
->two
->path
);
700 diff_flush_one(p
, msg
);
703 for (i
= 0; i
< q
->nr
; i
++) {
704 struct diff_filepair
*p
= q
->queue
[i
];
705 diff_free_filespec_data(p
->one
);
706 diff_free_filespec_data(p
->two
);
711 q
->nr
= q
->alloc
= 0;
714 void diff_addremove(int addremove
, unsigned mode
,
715 const unsigned char *sha1
,
716 const char *base
, const char *path
)
718 char concatpath
[PATH_MAX
];
719 struct diff_filespec
*one
, *two
;
721 /* This may look odd, but it is a preparation for
722 * feeding "there are unchanged files which should
723 * not produce diffs, but when you are doing copy
724 * detection you would need them, so here they are"
725 * entries to the diff-core. They will be prefixed
726 * with something like '=' or '*' (I haven't decided
727 * which but should not make any difference).
728 * Feeding the same new and old to diff_change()
729 * also has the same effect. diffcore_prune() should
730 * be used to filter uninteresting ones out before the
731 * final output happens.
734 addremove
= (addremove
== '+' ? '-' :
735 addremove
== '-' ? '+' : addremove
);
737 if (!path
) path
= "";
738 sprintf(concatpath
, "%s%s", base
, path
);
739 one
= alloc_filespec(concatpath
);
740 two
= alloc_filespec(concatpath
);
742 if (addremove
!= '+')
743 fill_filespec(one
, sha1
, mode
);
744 if (addremove
!= '-')
745 fill_filespec(two
, sha1
, mode
);
747 diff_queue(&diff_queued_diff
, one
, two
);
750 void diff_guif(unsigned old_mode
,
752 const unsigned char *old_sha1
,
753 const unsigned char *new_sha1
,
754 const char *old_path
,
755 const char *new_path
)
757 struct diff_filespec
*one
, *two
;
761 const unsigned char *tmp_c
;
762 tmp
= old_mode
; old_mode
= new_mode
; new_mode
= tmp
;
763 tmp_c
= old_sha1
; old_sha1
= new_sha1
; new_sha1
= tmp_c
;
765 one
= alloc_filespec(old_path
);
766 two
= alloc_filespec(new_path
);
768 fill_filespec(one
, old_sha1
, old_mode
);
770 fill_filespec(two
, new_sha1
, new_mode
);
771 diff_queue(&diff_queued_diff
, one
, two
);
774 void diff_change(unsigned old_mode
, unsigned new_mode
,
775 const unsigned char *old_sha1
,
776 const unsigned char *new_sha1
,
777 const char *base
, const char *path
)
779 char concatpath
[PATH_MAX
];
780 struct diff_filespec
*one
, *two
;
784 const unsigned char *tmp_c
;
785 tmp
= old_mode
; old_mode
= new_mode
; new_mode
= tmp
;
786 tmp_c
= old_sha1
; old_sha1
= new_sha1
; new_sha1
= tmp_c
;
788 if (!path
) path
= "";
789 sprintf(concatpath
, "%s%s", base
, path
);
790 one
= alloc_filespec(concatpath
);
791 two
= alloc_filespec(concatpath
);
792 fill_filespec(one
, old_sha1
, old_mode
);
793 fill_filespec(two
, new_sha1
, new_mode
);
795 diff_queue(&diff_queued_diff
, one
, two
);
798 void diff_unmerge(const char *path
)
800 struct diff_filespec
*one
, *two
;
801 one
= alloc_filespec(path
);
802 two
= alloc_filespec(path
);
803 diff_queue(&diff_queued_diff
, one
, two
);