2 * Helper functions for tree diff generation
9 static void show_entry(struct diff_options
*opt
, const char *prefix
,
10 struct tree_desc
*desc
, struct strbuf
*base
);
12 static int compare_tree_entry(struct tree_desc
*t1
, struct tree_desc
*t2
,
13 struct strbuf
*base
, struct diff_options
*opt
)
15 unsigned mode1
, mode2
;
16 const char *path1
, *path2
;
17 const unsigned char *sha1
, *sha2
;
18 int cmp
, pathlen1
, pathlen2
;
19 int old_baselen
= base
->len
;
21 sha1
= tree_entry_extract(t1
, &path1
, &mode1
);
22 sha2
= tree_entry_extract(t2
, &path2
, &mode2
);
24 pathlen1
= tree_entry_len(path1
, sha1
);
25 pathlen2
= tree_entry_len(path2
, sha2
);
26 cmp
= base_name_compare(path1
, pathlen1
, mode1
, path2
, pathlen2
, mode2
);
28 show_entry(opt
, "-", t1
, base
);
32 show_entry(opt
, "+", t2
, base
);
35 if (!DIFF_OPT_TST(opt
, FIND_COPIES_HARDER
) && !hashcmp(sha1
, sha2
) && mode1
== mode2
)
39 * If the filemode has changed to/from a directory from/to a regular
40 * file, we need to consider it a remove and an add.
42 if (S_ISDIR(mode1
) != S_ISDIR(mode2
)) {
43 show_entry(opt
, "-", t1
, base
);
44 show_entry(opt
, "+", t2
, base
);
48 strbuf_add(base
, path1
, pathlen1
);
49 if (DIFF_OPT_TST(opt
, RECURSIVE
) && S_ISDIR(mode1
)) {
50 if (DIFF_OPT_TST(opt
, TREE_IN_RECURSIVE
)) {
51 opt
->change(opt
, mode1
, mode2
,
52 sha1
, sha2
, base
->buf
, 0, 0);
54 strbuf_addch(base
, '/');
55 diff_tree_sha1(sha1
, sha2
, base
->buf
, opt
);
57 opt
->change(opt
, mode1
, mode2
, sha1
, sha2
, base
->buf
, 0, 0);
59 strbuf_setlen(base
, old_baselen
);
63 /* A whole sub-tree went away or appeared */
64 static void show_tree(struct diff_options
*opt
, const char *prefix
,
65 struct tree_desc
*desc
, struct strbuf
*base
)
67 int all_interesting
= 0;
74 show
= tree_entry_interesting(&desc
->entry
, base
, 0,
82 show_entry(opt
, prefix
, desc
, base
);
83 update_tree_entry(desc
);
87 /* A file entry went away or appeared */
88 static void show_entry(struct diff_options
*opt
, const char *prefix
,
89 struct tree_desc
*desc
, struct strbuf
*base
)
93 const unsigned char *sha1
= tree_entry_extract(desc
, &path
, &mode
);
94 int pathlen
= tree_entry_len(path
, sha1
);
95 int old_baselen
= base
->len
;
97 strbuf_add(base
, path
, pathlen
);
98 if (DIFF_OPT_TST(opt
, RECURSIVE
) && S_ISDIR(mode
)) {
99 enum object_type type
;
100 struct tree_desc inner
;
104 tree
= read_sha1_file(sha1
, &type
, &size
);
105 if (!tree
|| type
!= OBJ_TREE
)
106 die("corrupt tree sha %s", sha1_to_hex(sha1
));
108 if (DIFF_OPT_TST(opt
, TREE_IN_RECURSIVE
))
109 opt
->add_remove(opt
, *prefix
, mode
, sha1
, base
->buf
, 0);
111 strbuf_addch(base
, '/');
113 init_tree_desc(&inner
, tree
, size
);
114 show_tree(opt
, prefix
, &inner
, base
);
117 opt
->add_remove(opt
, prefix
[0], mode
, sha1
, base
->buf
, 0);
119 strbuf_setlen(base
, old_baselen
);
122 static void skip_uninteresting(struct tree_desc
*t
, struct strbuf
*base
,
123 struct diff_options
*opt
, int *all_interesting
)
126 int show
= tree_entry_interesting(&t
->entry
, base
, 0, &opt
->pathspec
);
128 *all_interesting
= 1;
130 update_tree_entry(t
);
140 int diff_tree(struct tree_desc
*t1
, struct tree_desc
*t2
,
141 const char *base_str
, struct diff_options
*opt
)
144 int baselen
= strlen(base_str
);
145 int all_t1_interesting
= 0;
146 int all_t2_interesting
= 0;
148 /* Enable recursion indefinitely */
149 opt
->pathspec
.recursive
= DIFF_OPT_TST(opt
, RECURSIVE
);
150 opt
->pathspec
.max_depth
= -1;
152 strbuf_init(&base
, PATH_MAX
);
153 strbuf_add(&base
, base_str
, baselen
);
156 if (diff_can_quit_early(opt
))
158 if (opt
->pathspec
.nr
) {
159 if (!all_t1_interesting
)
160 skip_uninteresting(t1
, &base
, opt
, &all_t1_interesting
);
161 if (!all_t2_interesting
)
162 skip_uninteresting(t2
, &base
, opt
, &all_t2_interesting
);
167 show_entry(opt
, "+", t2
, &base
);
168 update_tree_entry(t2
);
172 show_entry(opt
, "-", t1
, &base
);
173 update_tree_entry(t1
);
176 switch (compare_tree_entry(t1
, t2
, &base
, opt
)) {
178 update_tree_entry(t1
);
181 update_tree_entry(t1
);
184 update_tree_entry(t2
);
187 die("git diff-tree: internal error");
190 strbuf_release(&base
);
195 * Does it look like the resulting diff might be due to a rename?
197 * - not a valid previous file
199 static inline int diff_might_be_rename(void)
201 return diff_queued_diff
.nr
== 1 &&
202 !DIFF_FILE_VALID(diff_queued_diff
.queue
[0]->one
);
205 static void try_to_follow_renames(struct tree_desc
*t1
, struct tree_desc
*t2
, const char *base
, struct diff_options
*opt
)
207 struct diff_options diff_opts
;
208 struct diff_queue_struct
*q
= &diff_queued_diff
;
209 struct diff_filepair
*choice
;
210 const char *paths
[1];
213 /* Remove the file creation entry from the diff queue, and remember it */
214 choice
= q
->queue
[0];
217 diff_setup(&diff_opts
);
218 DIFF_OPT_SET(&diff_opts
, RECURSIVE
);
219 DIFF_OPT_SET(&diff_opts
, FIND_COPIES_HARDER
);
220 diff_opts
.output_format
= DIFF_FORMAT_NO_OUTPUT
;
221 diff_opts
.single_follow
= opt
->pathspec
.raw
[0];
222 diff_opts
.break_opt
= opt
->break_opt
;
224 diff_tree_setup_paths(paths
, &diff_opts
);
225 if (diff_setup_done(&diff_opts
) < 0)
226 die("unable to set up diff options to follow renames");
227 diff_tree(t1
, t2
, base
, &diff_opts
);
228 diffcore_std(&diff_opts
);
229 diff_tree_release_paths(&diff_opts
);
231 /* Go through the new set of filepairing, and see if we find a more interesting one */
232 opt
->found_follow
= 0;
233 for (i
= 0; i
< q
->nr
; i
++) {
234 struct diff_filepair
*p
= q
->queue
[i
];
237 * Found a source? Not only do we use that for the new
238 * diff_queued_diff, we will also use that as the path in
241 if ((p
->status
== 'R' || p
->status
== 'C') &&
242 !strcmp(p
->two
->path
, opt
->pathspec
.raw
[0])) {
243 /* Switch the file-pairs around */
244 q
->queue
[i
] = choice
;
247 /* Update the path we use from now on.. */
248 diff_tree_release_paths(opt
);
249 opt
->pathspec
.raw
[0] = xstrdup(p
->one
->path
);
250 diff_tree_setup_paths(opt
->pathspec
.raw
, opt
);
253 * The caller expects us to return a set of vanilla
254 * filepairs to let a later call to diffcore_std()
255 * it makes to sort the renames out (among other
256 * things), but we already have found renames
257 * ourselves; signal diffcore_std() not to muck with
258 * rename information.
260 opt
->found_follow
= 1;
266 * Then, discard all the non-relevant file pairs...
268 for (i
= 0; i
< q
->nr
; i
++) {
269 struct diff_filepair
*p
= q
->queue
[i
];
270 diff_free_filepair(p
);
274 * .. and re-instate the one we want (which might be either the
275 * original one, or the rename/copy we found)
277 q
->queue
[0] = choice
;
281 int diff_tree_sha1(const unsigned char *old
, const unsigned char *new, const char *base
, struct diff_options
*opt
)
284 struct tree_desc t1
, t2
;
285 unsigned long size1
, size2
;
288 tree1
= read_object_with_reference(old
, tree_type
, &size1
, NULL
);
290 die("unable to read source tree (%s)", sha1_to_hex(old
));
291 tree2
= read_object_with_reference(new, tree_type
, &size2
, NULL
);
293 die("unable to read destination tree (%s)", sha1_to_hex(new));
294 init_tree_desc(&t1
, tree1
, size1
);
295 init_tree_desc(&t2
, tree2
, size2
);
296 retval
= diff_tree(&t1
, &t2
, base
, opt
);
297 if (!*base
&& DIFF_OPT_TST(opt
, FOLLOW_RENAMES
) && diff_might_be_rename()) {
298 init_tree_desc(&t1
, tree1
, size1
);
299 init_tree_desc(&t2
, tree2
, size2
);
300 try_to_follow_renames(&t1
, &t2
, base
, opt
);
307 int diff_root_tree_sha1(const unsigned char *new, const char *base
, struct diff_options
*opt
)
312 struct tree_desc empty
, real
;
314 tree
= read_object_with_reference(new, tree_type
, &size
, NULL
);
316 die("unable to read root tree (%s)", sha1_to_hex(new));
317 init_tree_desc(&real
, tree
, size
);
319 init_tree_desc(&empty
, "", 0);
320 retval
= diff_tree(&empty
, &real
, base
, opt
);
325 void diff_tree_release_paths(struct diff_options
*opt
)
327 free_pathspec(&opt
->pathspec
);
330 void diff_tree_setup_paths(const char **p
, struct diff_options
*opt
)
332 init_pathspec(&opt
->pathspec
, p
);