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 use_size_cache
;
17 static const char *external_diff(void)
19 static const char *external_diff_cmd
= NULL
;
20 static int done_preparing
= 0;
23 return external_diff_cmd
;
26 * Default values above are meant to match the
27 * Linux kernel development style. Examples of
28 * alternative styles you can specify via environment
33 if (gitenv("GIT_EXTERNAL_DIFF"))
34 external_diff_cmd
= gitenv("GIT_EXTERNAL_DIFF");
36 /* In case external diff fails... */
37 diff_opts
= gitenv("GIT_DIFF_OPTS") ? : diff_opts
;
40 return external_diff_cmd
;
43 /* Help to copy the thing properly quoted for the shell safety.
44 * any single quote is replaced with '\'', and the caller is
45 * expected to enclose the result within a single quote pair.
48 * original sq_expand result
49 * name ==> name ==> 'name'
50 * a b ==> a b ==> 'a b'
51 * a'b ==> a'\''b ==> 'a'\''b'
53 static char *sq_expand(const char *src
)
55 static char *buf
= NULL
;
60 /* count bytes needed to store the quoted string. */
61 for (cnt
= 1, cp
= src
; *cp
; cnt
++, cp
++)
67 while ((c
= *src
++)) {
71 bp
= strcpy(bp
, "'\\''");
79 static struct diff_tempfile
{
80 const char *name
; /* filename external diff should read from */
86 static void builtin_diff(const char *name_a
,
88 struct diff_tempfile
*temp
,
91 int i
, next_at
, cmd_size
;
92 const char *diff_cmd
= "diff -L'%s%s' -L'%s%s'";
93 const char *diff_arg
= "'%s' '%s'||:"; /* "||:" is to return 0 */
94 const char *input_name_sq
[2];
97 const char *name_sq
[2];
100 name_sq
[0] = sq_expand(name_a
);
101 name_sq
[1] = sq_expand(name_b
);
103 /* diff_cmd and diff_arg have 6 %s in total which makes
104 * the sum of these strings 12 bytes larger than required.
105 * we use 2 spaces around diff-opts, and we need to count
106 * terminating NUL, so we subtract 9 here.
108 cmd_size
= (strlen(diff_cmd
) + strlen(diff_opts
) +
109 strlen(diff_arg
) - 9);
110 for (i
= 0; i
< 2; i
++) {
111 input_name_sq
[i
] = sq_expand(temp
[i
].name
);
112 if (!strcmp(temp
[i
].name
, "/dev/null")) {
113 path0
[i
] = "/dev/null";
116 path0
[i
] = i
? "b/" : "a/";
117 path1
[i
] = name_sq
[i
];
119 cmd_size
+= (strlen(path0
[i
]) + strlen(path1
[i
]) +
120 strlen(input_name_sq
[i
]));
123 cmd
= xmalloc(cmd_size
);
126 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
128 path0
[0], path1
[0], path0
[1], path1
[1]);
129 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
131 next_at
+= snprintf(cmd
+next_at
, cmd_size
-next_at
,
132 diff_arg
, input_name_sq
[0], input_name_sq
[1]);
134 printf("diff --git a/%s b/%s\n", name_a
, name_b
);
136 printf("new file mode %s\n", temp
[1].mode
);
137 if (xfrm_msg
&& xfrm_msg
[0])
140 else if (!path1
[1][0]) {
141 printf("deleted file mode %s\n", temp
[0].mode
);
142 if (xfrm_msg
&& xfrm_msg
[0])
146 if (strcmp(temp
[0].mode
, temp
[1].mode
)) {
147 printf("old mode %s\n", temp
[0].mode
);
148 printf("new mode %s\n", temp
[1].mode
);
150 if (xfrm_msg
&& xfrm_msg
[0])
153 if (strncmp(temp
[0].mode
, temp
[1].mode
, 3))
154 /* we do not run diff between different kind
160 execlp("/bin/sh","sh", "-c", cmd
, NULL
);
163 struct diff_filespec
*alloc_filespec(const char *path
)
165 int namelen
= strlen(path
);
166 struct diff_filespec
*spec
= xmalloc(sizeof(*spec
) + namelen
+ 1);
167 spec
->path
= (char *)(spec
+ 1);
168 strcpy(spec
->path
, path
);
169 spec
->should_free
= spec
->should_munmap
= 0;
170 spec
->xfrm_flags
= 0;
174 memset(spec
->sha1
, 0, 20);
178 void fill_filespec(struct diff_filespec
*spec
, const unsigned char *sha1
,
182 spec
->mode
= DIFF_FILE_CANON_MODE(mode
);
183 memcpy(spec
->sha1
, sha1
, 20);
184 spec
->sha1_valid
= !!memcmp(sha1
, null_sha1
, 20);
189 * Given a name and sha1 pair, if the dircache tells us the file in
190 * the work tree has that object contents, return true, so that
191 * prepare_temp_file() does not have to inflate and extract.
193 static int work_tree_matches(const char *name
, const unsigned char *sha1
)
195 struct cache_entry
*ce
;
199 /* We do not read the cache ourselves here, because the
200 * benchmark with my previous version that always reads cache
201 * shows that it makes things worse for diff-tree comparing
202 * two linux-2.6 kernel trees in an already checked out work
203 * tree. This is because most diff-tree comparisons deal with
204 * only a small number of files, while reading the cache is
205 * expensive for a large project, and its cost outweighs the
206 * savings we get by not inflating the object to a temporary
207 * file. Practically, this code only helps when we are used
208 * by diff-cache --cached, which does read the cache before
215 pos
= cache_name_pos(name
, len
);
218 ce
= active_cache
[pos
];
219 if ((lstat(name
, &st
) < 0) ||
220 !S_ISREG(st
.st_mode
) || /* careful! */
221 ce_match_stat(ce
, &st
) ||
222 memcmp(sha1
, ce
->sha1
, 20))
224 /* we return 1 only when we can stat, it is a regular file,
225 * stat information matches, and sha1 recorded in the cache
226 * matches. I.e. we know the file in the work tree really is
227 * the same as the <name, sha1> pair.
232 static struct sha1_size_cache
{
233 unsigned char sha1
[20];
236 static int sha1_size_cache_nr
, sha1_size_cache_alloc
;
238 static struct sha1_size_cache
*locate_size_cache(unsigned char *sha1
,
242 struct sha1_size_cache
*e
;
245 last
= sha1_size_cache_nr
;
246 while (last
> first
) {
247 int next
= (last
+ first
) >> 1;
248 e
= sha1_size_cache
[next
];
249 int cmp
= memcmp(e
->sha1
, sha1
, 20);
259 if (size
== UINT_MAX
)
261 /* insert to make it at "first" */
262 if (sha1_size_cache_alloc
<= sha1_size_cache_nr
) {
263 sha1_size_cache_alloc
= alloc_nr(sha1_size_cache_alloc
);
264 sha1_size_cache
= xrealloc(sha1_size_cache
,
265 sha1_size_cache_alloc
*
266 sizeof(*sha1_size_cache
));
268 sha1_size_cache_nr
++;
269 if (first
< sha1_size_cache_nr
)
270 memmove(sha1_size_cache
+ first
+ 1, sha1_size_cache
+ first
,
271 (sha1_size_cache_nr
- first
- 1) *
272 sizeof(*sha1_size_cache
));
273 e
= xmalloc(sizeof(struct sha1_size_cache
));
274 sha1_size_cache
[first
] = e
;
275 memcpy(e
->sha1
, sha1
, 20);
281 * While doing rename detection and pickaxe operation, we may need to
282 * grab the data for the blob (or file) for our own in-core comparison.
283 * diff_filespec has data and size fields for this purpose.
285 int diff_populate_filespec(struct diff_filespec
*s
, int size_only
)
288 if (!DIFF_FILE_VALID(s
))
289 die("internal error: asking to populate invalid file.");
290 if (S_ISDIR(s
->mode
))
298 if (!s
->sha1_valid
||
299 work_tree_matches(s
->path
, s
->sha1
)) {
302 if (lstat(s
->path
, &st
) < 0) {
303 if (errno
== ENOENT
) {
312 s
->size
= st
.st_size
;
317 if (S_ISLNK(st
.st_mode
)) {
319 s
->data
= xmalloc(s
->size
);
321 ret
= readlink(s
->path
, s
->data
, s
->size
);
328 fd
= open(s
->path
, O_RDONLY
);
331 s
->data
= mmap(NULL
, s
->size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
332 s
->should_munmap
= 1;
337 struct sha1_size_cache
*e
;
340 e
= locate_size_cache(s
->sha1
, UINT_MAX
);
345 if (!sha1_file_size(s
->sha1
, &s
->size
))
346 locate_size_cache(s
->sha1
, s
->size
);
349 s
->data
= read_sha1_file(s
->sha1
, type
, &s
->size
);
356 void diff_free_filespec_data(struct diff_filespec
*s
)
360 else if (s
->should_munmap
)
361 munmap(s
->data
, s
->size
);
362 s
->should_free
= s
->should_munmap
= 0;
366 static void prep_temp_blob(struct diff_tempfile
*temp
,
374 strcpy(temp
->tmp_path
, ".diff_XXXXXX");
375 fd
= mkstemp(temp
->tmp_path
);
377 die("unable to create temp-file");
378 if (write(fd
, blob
, size
) != size
)
379 die("unable to write temp-file");
381 temp
->name
= temp
->tmp_path
;
382 strcpy(temp
->hex
, sha1_to_hex(sha1
));
384 sprintf(temp
->mode
, "%06o", mode
);
387 static void prepare_temp_file(const char *name
,
388 struct diff_tempfile
*temp
,
389 struct diff_filespec
*one
)
391 if (!DIFF_FILE_VALID(one
)) {
393 /* A '-' entry produces this for file-2, and
394 * a '+' entry produces this for file-1.
396 temp
->name
= "/dev/null";
397 strcpy(temp
->hex
, ".");
398 strcpy(temp
->mode
, ".");
402 if (!one
->sha1_valid
||
403 work_tree_matches(name
, one
->sha1
)) {
405 if (lstat(name
, &st
) < 0) {
407 goto not_a_valid_file
;
408 die("stat(%s): %s", name
, strerror(errno
));
410 if (S_ISLNK(st
.st_mode
)) {
412 char *buf
, buf_
[1024];
413 buf
= ((sizeof(buf_
) < st
.st_size
) ?
414 xmalloc(st
.st_size
) : buf_
);
415 ret
= readlink(name
, buf
, st
.st_size
);
417 die("readlink(%s)", name
);
418 prep_temp_blob(temp
, buf
, st
.st_size
,
420 one
->sha1
: null_sha1
),
422 one
->mode
: S_IFLNK
));
425 /* we can borrow from the file in the work tree */
427 if (!one
->sha1_valid
)
428 strcpy(temp
->hex
, sha1_to_hex(null_sha1
));
430 strcpy(temp
->hex
, sha1_to_hex(one
->sha1
));
431 /* Even though we may sometimes borrow the
432 * contents from the work tree, we always want
433 * one->mode. mode is trustworthy even when
434 * !(one->sha1_valid), as long as
435 * DIFF_FILE_VALID(one).
437 sprintf(temp
->mode
, "%06o", one
->mode
);
442 if (diff_populate_filespec(one
, 0))
443 die("cannot read data blob for %s", one
->path
);
444 prep_temp_blob(temp
, one
->data
, one
->size
,
445 one
->sha1
, one
->mode
);
449 static void remove_tempfile(void)
453 for (i
= 0; i
< 2; i
++)
454 if (diff_temp
[i
].name
== diff_temp
[i
].tmp_path
) {
455 unlink(diff_temp
[i
].name
);
456 diff_temp
[i
].name
= NULL
;
460 static void remove_tempfile_on_signal(int signo
)
465 /* An external diff command takes:
467 * diff-cmd name infile1 infile1-sha1 infile1-mode \
468 * infile2 infile2-sha1 infile2-mode [ rename-to ]
471 static void run_external_diff(const char *pgm
,
474 struct diff_filespec
*one
,
475 struct diff_filespec
*two
,
476 const char *xfrm_msg
)
478 struct diff_tempfile
*temp
= diff_temp
;
481 static int atexit_asked
= 0;
484 prepare_temp_file(name
, &temp
[0], one
);
485 prepare_temp_file(other
? : name
, &temp
[1], two
);
486 if (! atexit_asked
&&
487 (temp
[0].name
== temp
[0].tmp_path
||
488 temp
[1].name
== temp
[1].tmp_path
)) {
490 atexit(remove_tempfile
);
492 signal(SIGINT
, remove_tempfile_on_signal
);
498 die("unable to fork");
502 const char *exec_arg
[10];
503 const char **arg
= &exec_arg
[0];
506 *arg
++ = temp
[0].name
;
507 *arg
++ = temp
[0].hex
;
508 *arg
++ = temp
[0].mode
;
509 *arg
++ = temp
[1].name
;
510 *arg
++ = temp
[1].hex
;
511 *arg
++ = temp
[1].mode
;
517 execvp(pgm
, (char *const*) exec_arg
);
520 execlp(pgm
, pgm
, name
, NULL
);
523 * otherwise we use the built-in one.
526 builtin_diff(name
, other
? : name
, temp
, xfrm_msg
);
528 printf("* Unmerged path %s\n", name
);
531 if (waitpid(pid
, &status
, 0) < 0 ||
532 !WIFEXITED(status
) || WEXITSTATUS(status
)) {
533 /* Earlier we did not check the exit status because
534 * diff exits non-zero if files are different, and
535 * we are not interested in knowing that. It was a
536 * mistake which made it harder to quit a diff-*
537 * session that uses the git-apply-patch-script as
538 * the GIT_EXTERNAL_DIFF. A custom GIT_EXTERNAL_DIFF
539 * should also exit non-zero only when it wants to
540 * abort the entire diff-* session.
543 fprintf(stderr
, "external diff died, stopping at %s.\n", name
);
549 static void run_diff(const char *name
,
551 struct diff_filespec
*one
,
552 struct diff_filespec
*two
,
553 const char *xfrm_msg
)
555 const char *pgm
= external_diff();
557 DIFF_FILE_VALID(one
) && DIFF_FILE_VALID(two
) &&
558 (S_IFMT
& one
->mode
) != (S_IFMT
& two
->mode
)) {
559 /* a filepair that changes between file and symlink
560 * needs to be split into deletion and creation.
562 struct diff_filespec
*null
= alloc_filespec(two
->path
);
563 run_external_diff(NULL
, name
, other
, one
, null
, xfrm_msg
);
565 null
= alloc_filespec(one
->path
);
566 run_external_diff(NULL
, name
, other
, null
, two
, xfrm_msg
);
570 run_external_diff(pgm
, name
, other
, one
, two
, xfrm_msg
);
573 void diff_setup(int flags
)
575 if (flags
& DIFF_SETUP_REVERSE
)
577 if (flags
& DIFF_SETUP_USE_CACHE
) {
579 /* read-cache does not die even when it fails
580 * so it is safe for us to do this here. Also
581 * it does not smudge active_cache or active_nr
582 * when it fails, so we do not have to worry about
583 * cleaning it up oufselves either.
587 if (flags
& DIFF_SETUP_USE_SIZE_CACHE
)
592 static int parse_num(const char **cp_p
)
594 int num
, scale
, ch
, cnt
;
595 const char *cp
= *cp_p
;
599 while ('0' <= (ch
= *cp
) && ch
<= '9') {
601 /* We simply ignore more than 5 digits precision. */
603 num
= num
* 10 + ch
- '0';
609 /* user says num divided by scale and we say internally that
610 * is MAX_SCORE * num / scale.
612 return (MAX_SCORE
* num
/ scale
);
615 int diff_scoreopt_parse(const char *opt
)
622 if (cmd
!= 'M' && cmd
!= 'C' && cmd
!= 'B')
623 return -1; /* that is not a -M, -C nor -B option */
625 opt1
= parse_num(&opt
);
631 struct diff_queue_struct diff_queued_diff
;
633 void diff_q(struct diff_queue_struct
*queue
, struct diff_filepair
*dp
)
635 if (queue
->alloc
<= queue
->nr
) {
636 queue
->alloc
= alloc_nr(queue
->alloc
);
637 queue
->queue
= xrealloc(queue
->queue
,
638 sizeof(dp
) * queue
->alloc
);
640 queue
->queue
[queue
->nr
++] = dp
;
643 struct diff_filepair
*diff_queue(struct diff_queue_struct
*queue
,
644 struct diff_filespec
*one
,
645 struct diff_filespec
*two
)
647 struct diff_filepair
*dp
= xmalloc(sizeof(*dp
));
651 dp
->source_stays
= 0;
657 void diff_free_filepair(struct diff_filepair
*p
)
659 diff_free_filespec_data(p
->one
);
660 diff_free_filespec_data(p
->two
);
664 static void diff_flush_raw(struct diff_filepair
*p
,
665 int line_termination
,
666 int inter_name_termination
)
671 if (line_termination
) {
672 const char *err
= "path %s cannot be expressed without -z";
673 if (strchr(p
->one
->path
, line_termination
) ||
674 strchr(p
->one
->path
, inter_name_termination
))
675 die(err
, p
->one
->path
);
676 if (strchr(p
->two
->path
, line_termination
) ||
677 strchr(p
->two
->path
, inter_name_termination
))
678 die(err
, p
->two
->path
);
684 sprintf(status
, "%c%03d", p
->status
,
685 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
));
690 sprintf(status
, "%c%03d", p
->status
,
691 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
));
693 status
[0] = p
->status
;
699 status
[0] = p
->status
;
703 printf(":%06o %06o %s ",
704 p
->one
->mode
, p
->two
->mode
, sha1_to_hex(p
->one
->sha1
));
706 sha1_to_hex(p
->two
->sha1
),
708 inter_name_termination
,
711 printf("%c%s", inter_name_termination
, p
->two
->path
);
712 putchar(line_termination
);
715 int diff_unmodified_pair(struct diff_filepair
*p
)
717 /* This function is written stricter than necessary to support
718 * the currently implemented transformers, but the idea is to
719 * let transformers to produce diff_filepairs any way they want,
720 * and filter and clean them up here before producing the output.
722 struct diff_filespec
*one
, *two
;
724 if (DIFF_PAIR_UNMERGED(p
))
725 return 0; /* unmerged is interesting */
730 /* deletion, addition, mode or type change
731 * and rename are all interesting.
733 if (DIFF_FILE_VALID(one
) != DIFF_FILE_VALID(two
) ||
734 DIFF_PAIR_MODE_CHANGED(p
) ||
735 strcmp(one
->path
, two
->path
))
738 /* both are valid and point at the same path. that is, we are
739 * dealing with a change.
741 if (one
->sha1_valid
&& two
->sha1_valid
&&
742 !memcmp(one
->sha1
, two
->sha1
, sizeof(one
->sha1
)))
743 return 1; /* no change */
744 if (!one
->sha1_valid
&& !two
->sha1_valid
)
745 return 1; /* both look at the same file on the filesystem. */
749 static void diff_flush_patch(struct diff_filepair
*p
)
751 const char *name
, *other
;
752 char msg_
[PATH_MAX
*2+200], *msg
;
754 if (diff_unmodified_pair(p
))
758 other
= (strcmp(name
, p
->two
->path
) ? p
->two
->path
: NULL
);
759 if ((DIFF_FILE_VALID(p
->one
) && S_ISDIR(p
->one
->mode
)) ||
760 (DIFF_FILE_VALID(p
->two
) && S_ISDIR(p
->two
->mode
)))
761 return; /* no tree diffs in patch format */
766 "similarity index %d%%\n"
769 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
),
770 p
->one
->path
, p
->two
->path
);
775 "similarity index %d%%\n"
778 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
),
779 p
->one
->path
, p
->two
->path
);
783 if (DIFF_PAIR_BROKEN(p
)) {
785 "dissimilarity index %d%%",
786 (int)(0.5 + p
->score
* 100.0/MAX_SCORE
));
796 if (DIFF_PAIR_UNMERGED(p
))
797 run_diff(name
, NULL
, NULL
, NULL
, NULL
);
799 run_diff(name
, other
, p
->one
, p
->two
, msg
);
802 int diff_queue_is_empty(void)
804 struct diff_queue_struct
*q
= &diff_queued_diff
;
806 for (i
= 0; i
< q
->nr
; i
++)
807 if (!diff_unmodified_pair(q
->queue
[i
]))
813 void diff_debug_filespec(struct diff_filespec
*s
, int x
, const char *one
)
815 fprintf(stderr
, "queue[%d] %s (%s) %s %06o %s\n",
818 DIFF_FILE_VALID(s
) ? "valid" : "invalid",
820 s
->sha1_valid
? sha1_to_hex(s
->sha1
) : "");
821 fprintf(stderr
, "queue[%d] %s size %lu flags %d\n",
823 s
->size
, s
->xfrm_flags
);
826 void diff_debug_filepair(const struct diff_filepair
*p
, int i
)
828 diff_debug_filespec(p
->one
, i
, "one");
829 diff_debug_filespec(p
->two
, i
, "two");
830 fprintf(stderr
, "score %d, status %c stays %d broken %d\n",
831 p
->score
, p
->status
? : '?',
832 p
->source_stays
, p
->broken_pair
);
835 void diff_debug_queue(const char *msg
, struct diff_queue_struct
*q
)
839 fprintf(stderr
, "%s\n", msg
);
840 fprintf(stderr
, "q->nr = %d\n", q
->nr
);
841 for (i
= 0; i
< q
->nr
; i
++) {
842 struct diff_filepair
*p
= q
->queue
[i
];
843 diff_debug_filepair(p
, i
);
848 static void diff_resolve_rename_copy(void)
851 struct diff_filepair
*p
, *pp
;
852 struct diff_queue_struct
*q
= &diff_queued_diff
;
854 diff_debug_queue("resolve-rename-copy", q
);
856 for (i
= 0; i
< q
->nr
; i
++) {
858 p
->status
= 0; /* undecided */
859 if (DIFF_PAIR_UNMERGED(p
))
861 else if (!DIFF_FILE_VALID(p
->one
))
863 else if (!DIFF_FILE_VALID(p
->two
))
865 else if (DIFF_PAIR_TYPE_CHANGED(p
))
868 /* from this point on, we are dealing with a pair
869 * whose both sides are valid and of the same type, i.e.
870 * either in-place edit or rename/copy edit.
872 else if (DIFF_PAIR_RENAME(p
)) {
873 if (p
->source_stays
) {
877 /* See if there is some other filepair that
878 * copies from the same source as us. If so
879 * we are a copy. Otherwise we are a rename.
881 for (j
= i
+ 1; j
< q
->nr
; j
++) {
883 if (strcmp(pp
->one
->path
, p
->one
->path
))
884 continue; /* not us */
885 if (!DIFF_PAIR_RENAME(pp
))
886 continue; /* not a rename/copy */
887 /* pp is a rename/copy from the same source */
894 else if (memcmp(p
->one
->sha1
, p
->two
->sha1
, 20) ||
895 p
->one
->mode
!= p
->two
->mode
)
898 /* This is a "no-change" entry and should not
899 * happen anymore, but prepare for broken callers.
901 error("feeding unmodified %s to diffcore",
906 diff_debug_queue("resolve-rename-copy done", q
);
909 void diff_flush(int diff_output_style
, int resolve_rename_copy
)
911 struct diff_queue_struct
*q
= &diff_queued_diff
;
913 int line_termination
= '\n';
914 int inter_name_termination
= '\t';
916 if (diff_output_style
== DIFF_FORMAT_MACHINE
)
917 line_termination
= inter_name_termination
= 0;
918 if (resolve_rename_copy
)
919 diff_resolve_rename_copy();
921 for (i
= 0; i
< q
->nr
; i
++) {
922 struct diff_filepair
*p
= q
->queue
[i
];
923 if ((diff_output_style
== DIFF_FORMAT_NO_OUTPUT
) ||
927 die("internal error in diff-resolve-rename-copy");
928 switch (diff_output_style
) {
929 case DIFF_FORMAT_PATCH
:
932 case DIFF_FORMAT_HUMAN
:
933 case DIFF_FORMAT_MACHINE
:
934 diff_flush_raw(p
, line_termination
,
935 inter_name_termination
);
939 for (i
= 0; i
< q
->nr
; i
++)
940 diff_free_filepair(q
->queue
[i
]);
943 q
->nr
= q
->alloc
= 0;
946 void diffcore_std(const char **paths
,
947 int detect_rename
, int rename_score
,
948 const char *pickaxe
, int pickaxe_opts
,
950 const char *orderfile
)
952 if (paths
&& paths
[0])
953 diffcore_pathspec(paths
);
955 diffcore_break(break_opt
);
957 diffcore_rename(detect_rename
, rename_score
);
959 diffcore_pickaxe(pickaxe
, pickaxe_opts
);
961 diffcore_order(orderfile
);
964 void diff_addremove(int addremove
, unsigned mode
,
965 const unsigned char *sha1
,
966 const char *base
, const char *path
)
968 char concatpath
[PATH_MAX
];
969 struct diff_filespec
*one
, *two
;
971 /* This may look odd, but it is a preparation for
972 * feeding "there are unchanged files which should
973 * not produce diffs, but when you are doing copy
974 * detection you would need them, so here they are"
975 * entries to the diff-core. They will be prefixed
976 * with something like '=' or '*' (I haven't decided
977 * which but should not make any difference).
978 * Feeding the same new and old to diff_change()
979 * also has the same effect.
980 * Before the final output happens, they are pruned after
981 * merged into rename/copy pairs as appropriate.
984 addremove
= (addremove
== '+' ? '-' :
985 addremove
== '-' ? '+' : addremove
);
987 if (!path
) path
= "";
988 sprintf(concatpath
, "%s%s", base
, path
);
989 one
= alloc_filespec(concatpath
);
990 two
= alloc_filespec(concatpath
);
992 if (addremove
!= '+')
993 fill_filespec(one
, sha1
, mode
);
994 if (addremove
!= '-')
995 fill_filespec(two
, sha1
, mode
);
997 diff_queue(&diff_queued_diff
, one
, two
);
1000 void diff_helper_input(unsigned old_mode
,
1002 const unsigned char *old_sha1
,
1003 const unsigned char *new_sha1
,
1004 const char *old_path
,
1007 const char *new_path
)
1009 struct diff_filespec
*one
, *two
;
1010 struct diff_filepair
*dp
;
1012 one
= alloc_filespec(old_path
);
1013 two
= alloc_filespec(new_path
);
1015 fill_filespec(one
, old_sha1
, old_mode
);
1017 fill_filespec(two
, new_sha1
, new_mode
);
1018 dp
= diff_queue(&diff_queued_diff
, one
, two
);
1019 dp
->score
= score
* MAX_SCORE
/ 100;
1020 dp
->status
= status
;
1023 void diff_change(unsigned old_mode
, unsigned new_mode
,
1024 const unsigned char *old_sha1
,
1025 const unsigned char *new_sha1
,
1026 const char *base
, const char *path
)
1028 char concatpath
[PATH_MAX
];
1029 struct diff_filespec
*one
, *two
;
1033 const unsigned char *tmp_c
;
1034 tmp
= old_mode
; old_mode
= new_mode
; new_mode
= tmp
;
1035 tmp_c
= old_sha1
; old_sha1
= new_sha1
; new_sha1
= tmp_c
;
1037 if (!path
) path
= "";
1038 sprintf(concatpath
, "%s%s", base
, path
);
1039 one
= alloc_filespec(concatpath
);
1040 two
= alloc_filespec(concatpath
);
1041 fill_filespec(one
, old_sha1
, old_mode
);
1042 fill_filespec(two
, new_sha1
, new_mode
);
1044 diff_queue(&diff_queued_diff
, one
, two
);
1047 void diff_unmerge(const char *path
)
1049 struct diff_filespec
*one
, *two
;
1050 one
= alloc_filespec(path
);
1051 two
= alloc_filespec(path
);
1052 diff_queue(&diff_queued_diff
, one
, two
);