2 * Copyright (C) 2005 Junio C Hamano
12 static const char *diff_opts
= "-pu";
14 static int use_size_cache
;
16 int diff_rename_limit_default
= -1;
18 static char *quote_one(const char *str
)
25 needlen
= quote_c_style(str
, NULL
, NULL
, 0);
28 xp
= xmalloc(needlen
+ 1);
29 quote_c_style(str
, xp
, NULL
, 0);
33 static char *quote_two(const char *one
, const char *two
)
35 int need_one
= quote_c_style(one
, NULL
, NULL
, 1);
36 int need_two
= quote_c_style(two
, NULL
, NULL
, 1);
39 if (need_one
+ need_two
) {
40 if (!need_one
) need_one
= strlen(one
);
41 if (!need_two
) need_one
= strlen(two
);
43 xp
= xmalloc(need_one
+ need_two
+ 3);
45 quote_c_style(one
, xp
+ 1, NULL
, 1);
46 quote_c_style(two
, xp
+ need_one
+ 1, NULL
, 1);
47 strcpy(xp
+ need_one
+ need_two
+ 1, "\"");
50 need_one
= strlen(one
);
51 need_two
= strlen(two
);
52 xp
= xmalloc(need_one
+ need_two
+ 1);
54 strcpy(xp
+ need_one
, two
);
58 static const char *external_diff(void)
60 static const char *external_diff_cmd
= NULL
;
61 static int done_preparing
= 0;
62 const char *env_diff_opts
;
65 return external_diff_cmd
;
68 * Default values above are meant to match the
69 * Linux kernel development style. Examples of
70 * alternative styles you can specify via environment
75 external_diff_cmd
= getenv("GIT_EXTERNAL_DIFF");
77 /* In case external diff fails... */
78 env_diff_opts
= getenv("GIT_DIFF_OPTS");
79 if (env_diff_opts
) diff_opts
= env_diff_opts
;
82 return external_diff_cmd
;
85 #define TEMPFILE_PATH_LEN 50
87 static struct diff_tempfile
{
88 const char *name
; /* filename external diff should read from */
91 char tmp_path
[TEMPFILE_PATH_LEN
];
94 static int count_lines(const char *filename
)
97 int count
, ch
, completely_empty
= 1, nl_just_seen
= 0;
98 in
= fopen(filename
, "r");
100 while ((ch
= fgetc(in
)) != EOF
)
104 completely_empty
= 0;
108 completely_empty
= 0;
111 if (completely_empty
)
114 count
++; /* no trailing newline */
118 static void print_line_count(int count
)
128 printf("1,%d", count
);
133 static void copy_file(int prefix
, const char *filename
)
136 int ch
, nl_just_seen
= 1;
137 in
= fopen(filename
, "r");
138 while ((ch
= fgetc(in
)) != EOF
) {
149 printf("\n\\ No newline at end of file\n");
152 static void emit_rewrite_diff(const char *name_a
,
154 struct diff_tempfile
*temp
)
156 /* Use temp[i].name as input, name_a and name_b as labels */
158 lc_a
= count_lines(temp
[0].name
);
159 lc_b
= count_lines(temp
[1].name
);
160 printf("--- %s\n+++ %s\n@@ -", name_a
, name_b
);
161 print_line_count(lc_a
);
163 print_line_count(lc_b
);
166 copy_file('-', temp
[0].name
);
168 copy_file('+', temp
[1].name
);
171 static void builtin_diff(const char *name_a
,
173 struct diff_tempfile
*temp
,
174 const char *xfrm_msg
,
175 int complete_rewrite
)
177 int i
, next_at
, cmd_size
;
178 const char *const diff_cmd
= "diff -L%s -L%s";
179 const char *const diff_arg
= "-- %s %s||:"; /* "||:" is to return 0 */
180 const char *input_name_sq
[2];
181 const char *label_path
[2];
184 /* diff_cmd and diff_arg have 4 %s in total which makes
185 * the sum of these strings 8 bytes larger than required.
186 * we use 2 spaces around diff-opts, and we need to count
187 * terminating NUL; we used to subtract 5 here, but we do not
188 * care about small leaks in this subprocess that is about
189 * to exec "diff" anymore.
191 cmd_size
= (strlen(diff_cmd
) + strlen(diff_opts
) + strlen(diff_arg
)
194 for (i
= 0; i
< 2; i
++) {
195 input_name_sq
[i
] = sq_quote(temp
[i
].name
);
196 if (!strcmp(temp
[i
].name
, "/dev/null"))
197 label_path
[i
] = "/dev/null";
199 label_path
[i
] = sq_quote(quote_two("a/", name_a
));
201 label_path
[i
] = sq_quote(quote_two("b/", name_b
));
202 cmd_size
+= (strlen(label_path
[i
]) + strlen(input_name_sq
[i
]));
205 cmd
= xmalloc(cmd_size
);
208 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
209 diff_cmd
, label_path
[0], label_path
[1]);
210 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
212 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
213 diff_arg
, input_name_sq
[0], input_name_sq
[1]);
215 printf("diff --git %s %s\n",
216 quote_two("a/", name_a
), quote_two("b/", name_b
));
217 if (label_path
[0][0] == '/') {
219 printf("new file mode %s\n", temp
[1].mode
);
220 if (xfrm_msg
&& xfrm_msg
[0])
223 else if (label_path
[1][0] == '/') {
224 printf("deleted file mode %s\n", temp
[0].mode
);
225 if (xfrm_msg
&& xfrm_msg
[0])
229 if (strcmp(temp
[0].mode
, temp
[1].mode
)) {
230 printf("old mode %s\n", temp
[0].mode
);
231 printf("new mode %s\n", temp
[1].mode
);
233 if (xfrm_msg
&& xfrm_msg
[0])
235 if (strncmp(temp
[0].mode
, temp
[1].mode
, 3))
236 /* we do not run diff between different kind
240 if (complete_rewrite
) {
242 emit_rewrite_diff(name_a
, name_b
, temp
);
247 execlp("/bin/sh","sh", "-c", cmd
, NULL
);
250 struct diff_filespec
*alloc_filespec(const char *path
)
252 int namelen
= strlen(path
);
253 struct diff_filespec
*spec
= xmalloc(sizeof(*spec
) + namelen
+ 1);
255 memset(spec
, 0, sizeof(*spec
));
256 spec
->path
= (char *)(spec
+ 1);
257 memcpy(spec
->path
, path
, namelen
+1);
261 void fill_filespec(struct diff_filespec
*spec
, const unsigned char *sha1
,
265 spec
->mode
= DIFF_FILE_CANON_MODE(mode
);
266 memcpy(spec
->sha1
, sha1
, 20);
267 spec
->sha1_valid
= !!memcmp(sha1
, null_sha1
, 20);
272 * Given a name and sha1 pair, if the dircache tells us the file in
273 * the work tree has that object contents, return true, so that
274 * prepare_temp_file() does not have to inflate and extract.
276 static int work_tree_matches(const char *name
, const unsigned char *sha1
)
278 struct cache_entry
*ce
;
282 /* We do not read the cache ourselves here, because the
283 * benchmark with my previous version that always reads cache
284 * shows that it makes things worse for diff-tree comparing
285 * two linux-2.6 kernel trees in an already checked out work
286 * tree. This is because most diff-tree comparisons deal with
287 * only a small number of files, while reading the cache is
288 * expensive for a large project, and its cost outweighs the
289 * savings we get by not inflating the object to a temporary
290 * file. Practically, this code only helps when we are used
291 * by diff-cache --cached, which does read the cache before
298 pos
= cache_name_pos(name
, len
);
301 ce
= active_cache
[pos
];
302 if ((lstat(name
, &st
) < 0) ||
303 !S_ISREG(st
.st_mode
) || /* careful! */
304 ce_match_stat(ce
, &st
) ||
305 memcmp(sha1
, ce
->sha1
, 20))
307 /* we return 1 only when we can stat, it is a regular file,
308 * stat information matches, and sha1 recorded in the cache
309 * matches. I.e. we know the file in the work tree really is
310 * the same as the <name, sha1> pair.
315 static struct sha1_size_cache
{
316 unsigned char sha1
[20];
319 static int sha1_size_cache_nr
, sha1_size_cache_alloc
;
321 static struct sha1_size_cache
*locate_size_cache(unsigned char *sha1
,
326 struct sha1_size_cache
*e
;
329 last
= sha1_size_cache_nr
;
330 while (last
> first
) {
331 int cmp
, next
= (last
+ first
) >> 1;
332 e
= sha1_size_cache
[next
];
333 cmp
= memcmp(e
->sha1
, sha1
, 20);
345 /* insert to make it at "first" */
346 if (sha1_size_cache_alloc
<= sha1_size_cache_nr
) {
347 sha1_size_cache_alloc
= alloc_nr(sha1_size_cache_alloc
);
348 sha1_size_cache
= xrealloc(sha1_size_cache
,
349 sha1_size_cache_alloc
*
350 sizeof(*sha1_size_cache
));
352 sha1_size_cache_nr
++;
353 if (first
< sha1_size_cache_nr
)
354 memmove(sha1_size_cache
+ first
+ 1, sha1_size_cache
+ first
,
355 (sha1_size_cache_nr
- first
- 1) *
356 sizeof(*sha1_size_cache
));
357 e
= xmalloc(sizeof(struct sha1_size_cache
));
358 sha1_size_cache
[first
] = e
;
359 memcpy(e
->sha1
, sha1
, 20);
365 * While doing rename detection and pickaxe operation, we may need to
366 * grab the data for the blob (or file) for our own in-core comparison.
367 * diff_filespec has data and size fields for this purpose.
369 int diff_populate_filespec(struct diff_filespec
*s
, int size_only
)
372 if (!DIFF_FILE_VALID(s
))
373 die("internal error: asking to populate invalid file.");
374 if (S_ISDIR(s
->mode
))
382 if (!s
->sha1_valid
||
383 work_tree_matches(s
->path
, s
->sha1
)) {
386 if (lstat(s
->path
, &st
) < 0) {
387 if (errno
== ENOENT
) {
396 s
->size
= st
.st_size
;
401 if (S_ISLNK(st
.st_mode
)) {
403 s
->data
= xmalloc(s
->size
);
405 ret
= readlink(s
->path
, s
->data
, s
->size
);
412 fd
= open(s
->path
, O_RDONLY
);
415 s
->data
= mmap(NULL
, s
->size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
417 if (s
->data
== MAP_FAILED
)
419 s
->should_munmap
= 1;
423 struct sha1_size_cache
*e
;
426 e
= locate_size_cache(s
->sha1
, 1, 0);
431 if (!sha1_object_info(s
->sha1
, type
, &s
->size
))
432 locate_size_cache(s
->sha1
, 0, s
->size
);
435 s
->data
= read_sha1_file(s
->sha1
, type
, &s
->size
);
442 void diff_free_filespec_data(struct diff_filespec
*s
)
446 else if (s
->should_munmap
)
447 munmap(s
->data
, s
->size
);
448 s
->should_free
= s
->should_munmap
= 0;
452 static void prep_temp_blob(struct diff_tempfile
*temp
,
455 const unsigned char *sha1
,
460 fd
= git_mkstemp(temp
->tmp_path
, TEMPFILE_PATH_LEN
, ".diff_XXXXXX");
462 die("unable to create temp-file");
463 if (write(fd
, blob
, size
) != size
)
464 die("unable to write temp-file");
466 temp
->name
= temp
->tmp_path
;
467 strcpy(temp
->hex
, sha1_to_hex(sha1
));
469 sprintf(temp
->mode
, "%06o", mode
);
472 static void prepare_temp_file(const char *name
,
473 struct diff_tempfile
*temp
,
474 struct diff_filespec
*one
)
476 if (!DIFF_FILE_VALID(one
)) {
478 /* A '-' entry produces this for file-2, and
479 * a '+' entry produces this for file-1.
481 temp
->name
= "/dev/null";
482 strcpy(temp
->hex
, ".");
483 strcpy(temp
->mode
, ".");
487 if (!one
->sha1_valid
||
488 work_tree_matches(name
, one
->sha1
)) {
490 if (lstat(name
, &st
) < 0) {
492 goto not_a_valid_file
;
493 die("stat(%s): %s", name
, strerror(errno
));
495 if (S_ISLNK(st
.st_mode
)) {
497 char *buf
, buf_
[1024];
498 buf
= ((sizeof(buf_
) < st
.st_size
) ?
499 xmalloc(st
.st_size
) : buf_
);
500 ret
= readlink(name
, buf
, st
.st_size
);
502 die("readlink(%s)", name
);
503 prep_temp_blob(temp
, buf
, st
.st_size
,
505 one
->sha1
: null_sha1
),
507 one
->mode
: S_IFLNK
));
510 /* we can borrow from the file in the work tree */
512 if (!one
->sha1_valid
)
513 strcpy(temp
->hex
, sha1_to_hex(null_sha1
));
515 strcpy(temp
->hex
, sha1_to_hex(one
->sha1
));
516 /* Even though we may sometimes borrow the
517 * contents from the work tree, we always want
518 * one->mode. mode is trustworthy even when
519 * !(one->sha1_valid), as long as
520 * DIFF_FILE_VALID(one).
522 sprintf(temp
->mode
, "%06o", one
->mode
);
527 if (diff_populate_filespec(one
, 0))
528 die("cannot read data blob for %s", one
->path
);
529 prep_temp_blob(temp
, one
->data
, one
->size
,
530 one
->sha1
, one
->mode
);
534 static void remove_tempfile(void)
538 for (i
= 0; i
< 2; i
++)
539 if (diff_temp
[i
].name
== diff_temp
[i
].tmp_path
) {
540 unlink(diff_temp
[i
].name
);
541 diff_temp
[i
].name
= NULL
;
545 static void remove_tempfile_on_signal(int signo
)
550 /* An external diff command takes:
552 * diff-cmd name infile1 infile1-sha1 infile1-mode \
553 * infile2 infile2-sha1 infile2-mode [ rename-to ]
556 static void run_external_diff(const char *pgm
,
559 struct diff_filespec
*one
,
560 struct diff_filespec
*two
,
561 const char *xfrm_msg
,
562 int complete_rewrite
)
564 struct diff_tempfile
*temp
= diff_temp
;
567 static int atexit_asked
= 0;
568 const char *othername
;
570 othername
= (other
? other
: name
);
572 prepare_temp_file(name
, &temp
[0], one
);
573 prepare_temp_file(othername
, &temp
[1], two
);
574 if (! atexit_asked
&&
575 (temp
[0].name
== temp
[0].tmp_path
||
576 temp
[1].name
== temp
[1].tmp_path
)) {
578 atexit(remove_tempfile
);
580 signal(SIGINT
, remove_tempfile_on_signal
);
586 die("unable to fork");
590 const char *exec_arg
[10];
591 const char **arg
= &exec_arg
[0];
594 *arg
++ = temp
[0].name
;
595 *arg
++ = temp
[0].hex
;
596 *arg
++ = temp
[0].mode
;
597 *arg
++ = temp
[1].name
;
598 *arg
++ = temp
[1].hex
;
599 *arg
++ = temp
[1].mode
;
605 execvp(pgm
, (char *const*) exec_arg
);
608 execlp(pgm
, pgm
, name
, NULL
);
611 * otherwise we use the built-in one.
614 builtin_diff(name
, othername
, temp
, xfrm_msg
,
617 printf("* Unmerged path %s\n", name
);
620 if (waitpid(pid
, &status
, 0) < 0 ||
621 !WIFEXITED(status
) || WEXITSTATUS(status
)) {
622 /* Earlier we did not check the exit status because
623 * diff exits non-zero if files are different, and
624 * we are not interested in knowing that. It was a
625 * mistake which made it harder to quit a diff-*
626 * session that uses the git-apply-patch-script as
627 * the GIT_EXTERNAL_DIFF. A custom GIT_EXTERNAL_DIFF
628 * should also exit non-zero only when it wants to
629 * abort the entire diff-* session.
632 fprintf(stderr
, "external diff died, stopping at %s.\n", name
);
638 static void diff_fill_sha1_info(struct diff_filespec
*one
)
640 if (DIFF_FILE_VALID(one
)) {
641 if (!one
->sha1_valid
) {
643 if (stat(one
->path
, &st
) < 0)
644 die("stat %s", one
->path
);
645 if (index_path(one
->sha1
, one
->path
, &st
, 0))
646 die("cannot hash %s\n", one
->path
);
650 memset(one
->sha1
, 0, 20);
653 static void run_diff(struct diff_filepair
*p
, struct diff_options
*o
)
655 const char *pgm
= external_diff();
656 char msg
[PATH_MAX
*2+300], *xfrm_msg
;
657 struct diff_filespec
*one
;
658 struct diff_filespec
*two
;
661 char *name_munged
, *other_munged
;
662 int complete_rewrite
= 0;
665 if (DIFF_PAIR_UNMERGED(p
)) {
667 run_external_diff(pgm
, p
->one
->path
, NULL
, NULL
, NULL
, NULL
,
673 other
= (strcmp(name
, p
->two
->path
) ? p
->two
->path
: NULL
);
674 name_munged
= quote_one(name
);
675 other_munged
= quote_one(other
);
676 one
= p
->one
; two
= p
->two
;
678 diff_fill_sha1_info(one
);
679 diff_fill_sha1_info(two
);
683 case DIFF_STATUS_COPIED
:
684 len
+= snprintf(msg
+ len
, sizeof(msg
) - len
,
685 "similarity index %d%%\n"
688 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
),
689 name_munged
, other_munged
);
691 case DIFF_STATUS_RENAMED
:
692 len
+= snprintf(msg
+ len
, sizeof(msg
) - len
,
693 "similarity index %d%%\n"
696 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
),
697 name_munged
, other_munged
);
699 case DIFF_STATUS_MODIFIED
:
701 len
+= snprintf(msg
+ len
, sizeof(msg
) - len
,
702 "dissimilarity index %d%%\n",
703 (int)(0.5 + p
->score
*
705 complete_rewrite
= 1;
714 if (memcmp(one
->sha1
, two
->sha1
, 20)) {
716 const char *index_fmt
= o
->full_index
? "index %s..%s" : "index %.7s..%.7s";
717 memcpy(one_sha1
, sha1_to_hex(one
->sha1
), 41);
719 len
+= snprintf(msg
+ len
, sizeof(msg
) - len
,
720 index_fmt
, one_sha1
, sha1_to_hex(two
->sha1
));
721 if (one
->mode
== two
->mode
)
722 len
+= snprintf(msg
+ len
, sizeof(msg
) - len
,
724 len
+= snprintf(msg
+ len
, sizeof(msg
) - len
, "\n");
729 xfrm_msg
= len
? msg
: NULL
;
732 DIFF_FILE_VALID(one
) && DIFF_FILE_VALID(two
) &&
733 (S_IFMT
& one
->mode
) != (S_IFMT
& two
->mode
)) {
734 /* a filepair that changes between file and symlink
735 * needs to be split into deletion and creation.
737 struct diff_filespec
*null
= alloc_filespec(two
->path
);
738 run_external_diff(NULL
, name
, other
, one
, null
, xfrm_msg
, 0);
740 null
= alloc_filespec(one
->path
);
741 run_external_diff(NULL
, name
, other
, null
, two
, xfrm_msg
, 0);
745 run_external_diff(pgm
, name
, other
, one
, two
, xfrm_msg
,
752 void diff_setup(struct diff_options
*options
)
754 memset(options
, 0, sizeof(*options
));
755 options
->output_format
= DIFF_FORMAT_RAW
;
756 options
->line_termination
= '\n';
757 options
->break_opt
= -1;
758 options
->rename_limit
= -1;
760 options
->change
= diff_change
;
761 options
->add_remove
= diff_addremove
;
764 int diff_setup_done(struct diff_options
*options
)
766 if ((options
->find_copies_harder
&&
767 options
->detect_rename
!= DIFF_DETECT_COPY
) ||
768 (0 <= options
->rename_limit
&& !options
->detect_rename
))
770 if (options
->detect_rename
&& options
->rename_limit
< 0)
771 options
->rename_limit
= diff_rename_limit_default
;
772 if (options
->setup
& DIFF_SETUP_USE_CACHE
) {
774 /* read-cache does not die even when it fails
775 * so it is safe for us to do this here. Also
776 * it does not smudge active_cache or active_nr
777 * when it fails, so we do not have to worry about
778 * cleaning it up oufselves either.
782 if (options
->setup
& DIFF_SETUP_USE_SIZE_CACHE
)
788 int diff_opt_parse(struct diff_options
*options
, const char **av
, int ac
)
790 const char *arg
= av
[0];
791 if (!strcmp(arg
, "-p") || !strcmp(arg
, "-u"))
792 options
->output_format
= DIFF_FORMAT_PATCH
;
793 else if (!strcmp(arg
, "-z"))
794 options
->line_termination
= 0;
795 else if (!strncmp(arg
, "-l", 2))
796 options
->rename_limit
= strtoul(arg
+2, NULL
, 10);
797 else if (!strcmp(arg
, "--full-index"))
798 options
->full_index
= 1;
799 else if (!strcmp(arg
, "--name-only"))
800 options
->output_format
= DIFF_FORMAT_NAME
;
801 else if (!strcmp(arg
, "--name-status"))
802 options
->output_format
= DIFF_FORMAT_NAME_STATUS
;
803 else if (!strcmp(arg
, "-R"))
804 options
->reverse_diff
= 1;
805 else if (!strncmp(arg
, "-S", 2))
806 options
->pickaxe
= arg
+ 2;
807 else if (!strcmp(arg
, "-s"))
808 options
->output_format
= DIFF_FORMAT_NO_OUTPUT
;
809 else if (!strncmp(arg
, "-O", 2))
810 options
->orderfile
= arg
+ 2;
811 else if (!strncmp(arg
, "--diff-filter=", 14))
812 options
->filter
= arg
+ 14;
813 else if (!strcmp(arg
, "--pickaxe-all"))
814 options
->pickaxe_opts
= DIFF_PICKAXE_ALL
;
815 else if (!strncmp(arg
, "-B", 2)) {
816 if ((options
->break_opt
=
817 diff_scoreopt_parse(arg
)) == -1)
820 else if (!strncmp(arg
, "-M", 2)) {
821 if ((options
->rename_score
=
822 diff_scoreopt_parse(arg
)) == -1)
824 options
->detect_rename
= DIFF_DETECT_RENAME
;
826 else if (!strncmp(arg
, "-C", 2)) {
827 if ((options
->rename_score
=
828 diff_scoreopt_parse(arg
)) == -1)
830 options
->detect_rename
= DIFF_DETECT_COPY
;
832 else if (!strcmp(arg
, "--find-copies-harder"))
833 options
->find_copies_harder
= 1;
839 static int parse_num(const char **cp_p
)
841 int num
, scale
, ch
, cnt
;
842 const char *cp
= *cp_p
;
846 while ('0' <= (ch
= *cp
) && ch
<= '9') {
848 /* We simply ignore more than 5 digits precision. */
850 num
= num
* 10 + ch
- '0';
856 /* special case: -M100 would mean 1.0 not 0.1 */
857 if (num
== 100 && scale
== 1000)
860 /* user says num divided by scale and we say internally that
861 * is MAX_SCORE * num / scale.
863 return (MAX_SCORE
* num
/ scale
);
866 int diff_scoreopt_parse(const char *opt
)
873 if (cmd
!= 'M' && cmd
!= 'C' && cmd
!= 'B')
874 return -1; /* that is not a -M, -C nor -B option */
876 opt1
= parse_num(&opt
);
882 else if (*opt
!= '/')
883 return -1; /* we expect -B80/99 or -B80 */
886 opt2
= parse_num(&opt
);
891 return opt1
| (opt2
<< 16);
894 struct diff_queue_struct diff_queued_diff
;
896 void diff_q(struct diff_queue_struct
*queue
, struct diff_filepair
*dp
)
898 if (queue
->alloc
<= queue
->nr
) {
899 queue
->alloc
= alloc_nr(queue
->alloc
);
900 queue
->queue
= xrealloc(queue
->queue
,
901 sizeof(dp
) * queue
->alloc
);
903 queue
->queue
[queue
->nr
++] = dp
;
906 struct diff_filepair
*diff_queue(struct diff_queue_struct
*queue
,
907 struct diff_filespec
*one
,
908 struct diff_filespec
*two
)
910 struct diff_filepair
*dp
= xmalloc(sizeof(*dp
));
915 dp
->source_stays
= 0;
922 void diff_free_filepair(struct diff_filepair
*p
)
924 diff_free_filespec_data(p
->one
);
925 diff_free_filespec_data(p
->two
);
931 static void diff_flush_raw(struct diff_filepair
*p
,
932 int line_termination
,
933 int inter_name_termination
,
938 const char *path_one
, *path_two
;
940 path_one
= p
->one
->path
;
941 path_two
= p
->two
->path
;
942 if (line_termination
) {
943 path_one
= quote_one(path_one
);
944 path_two
= quote_one(path_two
);
948 sprintf(status
, "%c%03d", p
->status
,
949 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
));
951 status
[0] = p
->status
;
955 case DIFF_STATUS_COPIED
:
956 case DIFF_STATUS_RENAMED
:
959 case DIFF_STATUS_ADDED
:
960 case DIFF_STATUS_DELETED
:
967 if (output_format
!= DIFF_FORMAT_NAME_STATUS
) {
968 printf(":%06o %06o %s ",
969 p
->one
->mode
, p
->two
->mode
, sha1_to_hex(p
->one
->sha1
));
970 printf("%s ", sha1_to_hex(p
->two
->sha1
));
972 printf("%s%c%s", status
, inter_name_termination
, path_one
);
974 printf("%c%s", inter_name_termination
, path_two
);
975 putchar(line_termination
);
976 if (path_one
!= p
->one
->path
)
977 free((void*)path_one
);
978 if (path_two
!= p
->two
->path
)
979 free((void*)path_two
);
982 static void diff_flush_name(struct diff_filepair
*p
,
983 int inter_name_termination
,
984 int line_termination
)
986 char *path
= p
->two
->path
;
988 if (line_termination
)
989 path
= quote_one(p
->two
->path
);
992 printf("%s%c", path
, line_termination
);
993 if (p
->two
->path
!= path
)
997 int diff_unmodified_pair(struct diff_filepair
*p
)
999 /* This function is written stricter than necessary to support
1000 * the currently implemented transformers, but the idea is to
1001 * let transformers to produce diff_filepairs any way they want,
1002 * and filter and clean them up here before producing the output.
1004 struct diff_filespec
*one
, *two
;
1006 if (DIFF_PAIR_UNMERGED(p
))
1007 return 0; /* unmerged is interesting */
1012 /* deletion, addition, mode or type change
1013 * and rename are all interesting.
1015 if (DIFF_FILE_VALID(one
) != DIFF_FILE_VALID(two
) ||
1016 DIFF_PAIR_MODE_CHANGED(p
) ||
1017 strcmp(one
->path
, two
->path
))
1020 /* both are valid and point at the same path. that is, we are
1021 * dealing with a change.
1023 if (one
->sha1_valid
&& two
->sha1_valid
&&
1024 !memcmp(one
->sha1
, two
->sha1
, sizeof(one
->sha1
)))
1025 return 1; /* no change */
1026 if (!one
->sha1_valid
&& !two
->sha1_valid
)
1027 return 1; /* both look at the same file on the filesystem. */
1031 static void diff_flush_patch(struct diff_filepair
*p
, struct diff_options
*o
)
1033 if (diff_unmodified_pair(p
))
1036 if ((DIFF_FILE_VALID(p
->one
) && S_ISDIR(p
->one
->mode
)) ||
1037 (DIFF_FILE_VALID(p
->two
) && S_ISDIR(p
->two
->mode
)))
1038 return; /* no tree diffs in patch format */
1043 int diff_queue_is_empty(void)
1045 struct diff_queue_struct
*q
= &diff_queued_diff
;
1047 for (i
= 0; i
< q
->nr
; i
++)
1048 if (!diff_unmodified_pair(q
->queue
[i
]))
1054 void diff_debug_filespec(struct diff_filespec
*s
, int x
, const char *one
)
1056 fprintf(stderr
, "queue[%d] %s (%s) %s %06o %s\n",
1059 DIFF_FILE_VALID(s
) ? "valid" : "invalid",
1061 s
->sha1_valid
? sha1_to_hex(s
->sha1
) : "");
1062 fprintf(stderr
, "queue[%d] %s size %lu flags %d\n",
1064 s
->size
, s
->xfrm_flags
);
1067 void diff_debug_filepair(const struct diff_filepair
*p
, int i
)
1069 diff_debug_filespec(p
->one
, i
, "one");
1070 diff_debug_filespec(p
->two
, i
, "two");
1071 fprintf(stderr
, "score %d, status %c stays %d broken %d\n",
1072 p
->score
, p
->status
? p
->status
: '?',
1073 p
->source_stays
, p
->broken_pair
);
1076 void diff_debug_queue(const char *msg
, struct diff_queue_struct
*q
)
1080 fprintf(stderr
, "%s\n", msg
);
1081 fprintf(stderr
, "q->nr = %d\n", q
->nr
);
1082 for (i
= 0; i
< q
->nr
; i
++) {
1083 struct diff_filepair
*p
= q
->queue
[i
];
1084 diff_debug_filepair(p
, i
);
1089 static void diff_resolve_rename_copy(void)
1092 struct diff_filepair
*p
, *pp
;
1093 struct diff_queue_struct
*q
= &diff_queued_diff
;
1095 diff_debug_queue("resolve-rename-copy", q
);
1097 for (i
= 0; i
< q
->nr
; i
++) {
1099 p
->status
= 0; /* undecided */
1100 if (DIFF_PAIR_UNMERGED(p
))
1101 p
->status
= DIFF_STATUS_UNMERGED
;
1102 else if (!DIFF_FILE_VALID(p
->one
))
1103 p
->status
= DIFF_STATUS_ADDED
;
1104 else if (!DIFF_FILE_VALID(p
->two
))
1105 p
->status
= DIFF_STATUS_DELETED
;
1106 else if (DIFF_PAIR_TYPE_CHANGED(p
))
1107 p
->status
= DIFF_STATUS_TYPE_CHANGED
;
1109 /* from this point on, we are dealing with a pair
1110 * whose both sides are valid and of the same type, i.e.
1111 * either in-place edit or rename/copy edit.
1113 else if (DIFF_PAIR_RENAME(p
)) {
1114 if (p
->source_stays
) {
1115 p
->status
= DIFF_STATUS_COPIED
;
1118 /* See if there is some other filepair that
1119 * copies from the same source as us. If so
1120 * we are a copy. Otherwise we are either a
1121 * copy if the path stays, or a rename if it
1122 * does not, but we already handled "stays" case.
1124 for (j
= i
+ 1; j
< q
->nr
; j
++) {
1126 if (strcmp(pp
->one
->path
, p
->one
->path
))
1127 continue; /* not us */
1128 if (!DIFF_PAIR_RENAME(pp
))
1129 continue; /* not a rename/copy */
1130 /* pp is a rename/copy from the same source */
1131 p
->status
= DIFF_STATUS_COPIED
;
1135 p
->status
= DIFF_STATUS_RENAMED
;
1137 else if (memcmp(p
->one
->sha1
, p
->two
->sha1
, 20) ||
1138 p
->one
->mode
!= p
->two
->mode
)
1139 p
->status
= DIFF_STATUS_MODIFIED
;
1141 /* This is a "no-change" entry and should not
1142 * happen anymore, but prepare for broken callers.
1144 error("feeding unmodified %s to diffcore",
1146 p
->status
= DIFF_STATUS_UNKNOWN
;
1149 diff_debug_queue("resolve-rename-copy done", q
);
1152 void diff_flush(struct diff_options
*options
)
1154 struct diff_queue_struct
*q
= &diff_queued_diff
;
1156 int inter_name_termination
= '\t';
1157 int diff_output_format
= options
->output_format
;
1158 int line_termination
= options
->line_termination
;
1160 if (!line_termination
)
1161 inter_name_termination
= 0;
1163 for (i
= 0; i
< q
->nr
; i
++) {
1164 struct diff_filepair
*p
= q
->queue
[i
];
1165 if ((diff_output_format
== DIFF_FORMAT_NO_OUTPUT
) ||
1166 (p
->status
== DIFF_STATUS_UNKNOWN
))
1169 die("internal error in diff-resolve-rename-copy");
1170 switch (diff_output_format
) {
1171 case DIFF_FORMAT_PATCH
:
1172 diff_flush_patch(p
, options
);
1174 case DIFF_FORMAT_RAW
:
1175 case DIFF_FORMAT_NAME_STATUS
:
1176 diff_flush_raw(p
, line_termination
,
1177 inter_name_termination
,
1178 diff_output_format
);
1180 case DIFF_FORMAT_NAME
:
1182 inter_name_termination
,
1186 diff_free_filepair(q
->queue
[i
]);
1190 q
->nr
= q
->alloc
= 0;
1193 static void diffcore_apply_filter(const char *filter
)
1196 struct diff_queue_struct
*q
= &diff_queued_diff
;
1197 struct diff_queue_struct outq
;
1199 outq
.nr
= outq
.alloc
= 0;
1204 if (strchr(filter
, DIFF_STATUS_FILTER_AON
)) {
1206 for (i
= found
= 0; !found
&& i
< q
->nr
; i
++) {
1207 struct diff_filepair
*p
= q
->queue
[i
];
1208 if (((p
->status
== DIFF_STATUS_MODIFIED
) &&
1210 strchr(filter
, DIFF_STATUS_FILTER_BROKEN
)) ||
1212 strchr(filter
, DIFF_STATUS_MODIFIED
)))) ||
1213 ((p
->status
!= DIFF_STATUS_MODIFIED
) &&
1214 strchr(filter
, p
->status
)))
1220 /* otherwise we will clear the whole queue
1221 * by copying the empty outq at the end of this
1222 * function, but first clear the current entries
1225 for (i
= 0; i
< q
->nr
; i
++)
1226 diff_free_filepair(q
->queue
[i
]);
1229 /* Only the matching ones */
1230 for (i
= 0; i
< q
->nr
; i
++) {
1231 struct diff_filepair
*p
= q
->queue
[i
];
1233 if (((p
->status
== DIFF_STATUS_MODIFIED
) &&
1235 strchr(filter
, DIFF_STATUS_FILTER_BROKEN
)) ||
1237 strchr(filter
, DIFF_STATUS_MODIFIED
)))) ||
1238 ((p
->status
!= DIFF_STATUS_MODIFIED
) &&
1239 strchr(filter
, p
->status
)))
1242 diff_free_filepair(p
);
1249 void diffcore_std(struct diff_options
*options
)
1251 if (options
->paths
&& options
->paths
[0])
1252 diffcore_pathspec(options
->paths
);
1253 if (options
->break_opt
!= -1)
1254 diffcore_break(options
->break_opt
);
1255 if (options
->detect_rename
)
1256 diffcore_rename(options
);
1257 if (options
->break_opt
!= -1)
1258 diffcore_merge_broken();
1259 if (options
->pickaxe
)
1260 diffcore_pickaxe(options
->pickaxe
, options
->pickaxe_opts
);
1261 if (options
->orderfile
)
1262 diffcore_order(options
->orderfile
);
1263 diff_resolve_rename_copy();
1264 diffcore_apply_filter(options
->filter
);
1268 void diffcore_std_no_resolve(struct diff_options
*options
)
1270 if (options
->pickaxe
)
1271 diffcore_pickaxe(options
->pickaxe
, options
->pickaxe_opts
);
1272 if (options
->orderfile
)
1273 diffcore_order(options
->orderfile
);
1274 diffcore_apply_filter(options
->filter
);
1277 void diff_addremove(struct diff_options
*options
,
1278 int addremove
, unsigned mode
,
1279 const unsigned char *sha1
,
1280 const char *base
, const char *path
)
1282 char concatpath
[PATH_MAX
];
1283 struct diff_filespec
*one
, *two
;
1285 /* This may look odd, but it is a preparation for
1286 * feeding "there are unchanged files which should
1287 * not produce diffs, but when you are doing copy
1288 * detection you would need them, so here they are"
1289 * entries to the diff-core. They will be prefixed
1290 * with something like '=' or '*' (I haven't decided
1291 * which but should not make any difference).
1292 * Feeding the same new and old to diff_change()
1293 * also has the same effect.
1294 * Before the final output happens, they are pruned after
1295 * merged into rename/copy pairs as appropriate.
1297 if (options
->reverse_diff
)
1298 addremove
= (addremove
== '+' ? '-' :
1299 addremove
== '-' ? '+' : addremove
);
1301 if (!path
) path
= "";
1302 sprintf(concatpath
, "%s%s", base
, path
);
1303 one
= alloc_filespec(concatpath
);
1304 two
= alloc_filespec(concatpath
);
1306 if (addremove
!= '+')
1307 fill_filespec(one
, sha1
, mode
);
1308 if (addremove
!= '-')
1309 fill_filespec(two
, sha1
, mode
);
1311 diff_queue(&diff_queued_diff
, one
, two
);
1314 void diff_change(struct diff_options
*options
,
1315 unsigned old_mode
, unsigned new_mode
,
1316 const unsigned char *old_sha1
,
1317 const unsigned char *new_sha1
,
1318 const char *base
, const char *path
)
1320 char concatpath
[PATH_MAX
];
1321 struct diff_filespec
*one
, *two
;
1323 if (options
->reverse_diff
) {
1325 const unsigned char *tmp_c
;
1326 tmp
= old_mode
; old_mode
= new_mode
; new_mode
= tmp
;
1327 tmp_c
= old_sha1
; old_sha1
= new_sha1
; new_sha1
= tmp_c
;
1329 if (!path
) path
= "";
1330 sprintf(concatpath
, "%s%s", base
, path
);
1331 one
= alloc_filespec(concatpath
);
1332 two
= alloc_filespec(concatpath
);
1333 fill_filespec(one
, old_sha1
, old_mode
);
1334 fill_filespec(two
, new_sha1
, new_mode
);
1336 diff_queue(&diff_queued_diff
, one
, two
);
1339 void diff_unmerge(struct diff_options
*options
,
1342 struct diff_filespec
*one
, *two
;
1343 one
= alloc_filespec(path
);
1344 two
= alloc_filespec(path
);
1345 diff_queue(&diff_queued_diff
, one
, two
);