2 * Helper functions for tree diff generation
10 * Compare two tree entries, taking into account only path/S_ISDIR(mode),
11 * but not their sha1's.
13 * NOTE files and directories *always* compare differently, even when having
14 * the same name - thanks to base_name_compare().
16 * NOTE empty (=invalid) descriptor(s) take part in comparison as +infty,
17 * so that they sort *after* valid tree entries.
19 * Due to this convention, if trees are scanned in sorted order, all
20 * non-empty descriptors will be processed first.
22 static int tree_entry_pathcmp(struct tree_desc
*t1
, struct tree_desc
*t2
)
24 struct name_entry
*e1
, *e2
;
27 /* empty descriptors sort after valid tree entries */
29 return t2
->size
? 1 : 0;
35 cmp
= base_name_compare(e1
->path
, tree_entry_len(e1
), e1
->mode
,
36 e2
->path
, tree_entry_len(e2
), e2
->mode
);
41 /* convert path, t1/t2 -> opt->diff_*() callbacks */
42 static void emit_diff(struct diff_options
*opt
, struct strbuf
*path
,
43 struct tree_desc
*t1
, struct tree_desc
*t2
)
45 unsigned int mode1
= t1
? t1
->entry
.mode
: 0;
46 unsigned int mode2
= t2
? t2
->entry
.mode
: 0;
49 opt
->change(opt
, mode1
, mode2
, t1
->entry
.sha1
, t2
->entry
.sha1
,
50 1, 1, path
->buf
, 0, 0);
53 const unsigned char *sha1
;
59 sha1
= t2
->entry
.sha1
;
63 sha1
= t1
->entry
.sha1
;
67 opt
->add_remove(opt
, addremove
, mode
, sha1
, 1, path
->buf
, 0);
72 /* new path should be added to diff
74 * 3 cases on how/when it should be called and behaves:
76 * !t1, t2 -> path added, parent lacks it
77 * t1, !t2 -> path removed from parent
78 * t1, t2 -> path modified
80 static void show_path(struct strbuf
*base
, struct diff_options
*opt
,
81 struct tree_desc
*t1
, struct tree_desc
*t2
)
86 int old_baselen
= base
->len
;
87 int isdir
, recurse
= 0, emitthis
= 1;
89 /* at least something has to be valid */
93 /* path present in resulting tree */
94 tree_entry_extract(t2
, &path
, &mode
);
95 pathlen
= tree_entry_len(&t2
->entry
);
96 isdir
= S_ISDIR(mode
);
99 * a path was removed - take path from parent. Also take
100 * mode from parent, to decide on recursion.
102 tree_entry_extract(t1
, &path
, &mode
);
103 pathlen
= tree_entry_len(&t1
->entry
);
105 isdir
= S_ISDIR(mode
);
109 if (DIFF_OPT_TST(opt
, RECURSIVE
) && isdir
) {
111 emitthis
= DIFF_OPT_TST(opt
, TREE_IN_RECURSIVE
);
114 strbuf_add(base
, path
, pathlen
);
117 emit_diff(opt
, base
, t1
, t2
);
120 strbuf_addch(base
, '/');
121 diff_tree_sha1(t1
? t1
->entry
.sha1
: NULL
,
122 t2
? t2
->entry
.sha1
: NULL
, base
->buf
, opt
);
125 strbuf_setlen(base
, old_baselen
);
128 static void skip_uninteresting(struct tree_desc
*t
, struct strbuf
*base
,
129 struct diff_options
*opt
)
131 enum interesting match
;
134 match
= tree_entry_interesting(&t
->entry
, base
, 0, &opt
->pathspec
);
136 if (match
== all_entries_not_interesting
)
140 update_tree_entry(t
);
144 static int diff_tree(struct tree_desc
*t1
, struct tree_desc
*t2
,
145 const char *base_str
, struct diff_options
*opt
)
148 int baselen
= strlen(base_str
);
150 /* Enable recursion indefinitely */
151 opt
->pathspec
.recursive
= DIFF_OPT_TST(opt
, RECURSIVE
);
153 strbuf_init(&base
, PATH_MAX
);
154 strbuf_add(&base
, base_str
, baselen
);
159 if (diff_can_quit_early(opt
))
161 if (opt
->pathspec
.nr
) {
162 skip_uninteresting(t1
, &base
, opt
);
163 skip_uninteresting(t2
, &base
, opt
);
165 if (!t1
->size
&& !t2
->size
)
168 cmp
= tree_entry_pathcmp(t1
, t2
);
172 if (DIFF_OPT_TST(opt
, FIND_COPIES_HARDER
) ||
173 hashcmp(t1
->entry
.sha1
, t2
->entry
.sha1
) ||
174 (t1
->entry
.mode
!= t2
->entry
.mode
))
175 show_path(&base
, opt
, t1
, t2
);
177 update_tree_entry(t1
);
178 update_tree_entry(t2
);
183 show_path(&base
, opt
, t1
, /*t2=*/NULL
);
184 update_tree_entry(t1
);
189 show_path(&base
, opt
, /*t1=*/NULL
, t2
);
190 update_tree_entry(t2
);
194 strbuf_release(&base
);
199 * Does it look like the resulting diff might be due to a rename?
201 * - not a valid previous file
203 static inline int diff_might_be_rename(void)
205 return diff_queued_diff
.nr
== 1 &&
206 !DIFF_FILE_VALID(diff_queued_diff
.queue
[0]->one
);
209 static void try_to_follow_renames(struct tree_desc
*t1
, struct tree_desc
*t2
, const char *base
, struct diff_options
*opt
)
211 struct diff_options diff_opts
;
212 struct diff_queue_struct
*q
= &diff_queued_diff
;
213 struct diff_filepair
*choice
;
217 * follow-rename code is very specific, we need exactly one
218 * path. Magic that matches more than one path is not
221 GUARD_PATHSPEC(&opt
->pathspec
, PATHSPEC_FROMTOP
| PATHSPEC_LITERAL
);
224 * We should reject wildcards as well. Unfortunately we
225 * haven't got a reliable way to detect that 'foo\*bar' in
226 * fact has no wildcards. nowildcard_len is merely a hint for
227 * optimization. Let it slip for now until wildmatch is taught
228 * about dry-run mode and returns wildcard info.
230 if (opt
->pathspec
.has_wildcard
)
231 die("BUG:%s:%d: wildcards are not supported",
235 /* Remove the file creation entry from the diff queue, and remember it */
236 choice
= q
->queue
[0];
239 diff_setup(&diff_opts
);
240 DIFF_OPT_SET(&diff_opts
, RECURSIVE
);
241 DIFF_OPT_SET(&diff_opts
, FIND_COPIES_HARDER
);
242 diff_opts
.output_format
= DIFF_FORMAT_NO_OUTPUT
;
243 diff_opts
.single_follow
= opt
->pathspec
.items
[0].match
;
244 diff_opts
.break_opt
= opt
->break_opt
;
245 diff_opts
.rename_score
= opt
->rename_score
;
246 diff_setup_done(&diff_opts
);
247 diff_tree(t1
, t2
, base
, &diff_opts
);
248 diffcore_std(&diff_opts
);
249 free_pathspec(&diff_opts
.pathspec
);
251 /* Go through the new set of filepairing, and see if we find a more interesting one */
252 opt
->found_follow
= 0;
253 for (i
= 0; i
< q
->nr
; i
++) {
254 struct diff_filepair
*p
= q
->queue
[i
];
257 * Found a source? Not only do we use that for the new
258 * diff_queued_diff, we will also use that as the path in
261 if ((p
->status
== 'R' || p
->status
== 'C') &&
262 !strcmp(p
->two
->path
, opt
->pathspec
.items
[0].match
)) {
265 /* Switch the file-pairs around */
266 q
->queue
[i
] = choice
;
269 /* Update the path we use from now on.. */
270 path
[0] = p
->one
->path
;
272 free_pathspec(&opt
->pathspec
);
273 parse_pathspec(&opt
->pathspec
,
274 PATHSPEC_ALL_MAGIC
& ~PATHSPEC_LITERAL
,
275 PATHSPEC_LITERAL_PATH
, "", path
);
278 * The caller expects us to return a set of vanilla
279 * filepairs to let a later call to diffcore_std()
280 * it makes to sort the renames out (among other
281 * things), but we already have found renames
282 * ourselves; signal diffcore_std() not to muck with
283 * rename information.
285 opt
->found_follow
= 1;
291 * Then, discard all the non-relevant file pairs...
293 for (i
= 0; i
< q
->nr
; i
++) {
294 struct diff_filepair
*p
= q
->queue
[i
];
295 diff_free_filepair(p
);
299 * .. and re-instate the one we want (which might be either the
300 * original one, or the rename/copy we found)
302 q
->queue
[0] = choice
;
306 int diff_tree_sha1(const unsigned char *old
, const unsigned char *new, const char *base
, struct diff_options
*opt
)
309 struct tree_desc t1
, t2
;
310 unsigned long size1
, size2
;
313 tree1
= fill_tree_descriptor(&t1
, old
);
314 tree2
= fill_tree_descriptor(&t2
, new);
317 retval
= diff_tree(&t1
, &t2
, base
, opt
);
318 if (!*base
&& DIFF_OPT_TST(opt
, FOLLOW_RENAMES
) && diff_might_be_rename()) {
319 init_tree_desc(&t1
, tree1
, size1
);
320 init_tree_desc(&t2
, tree2
, size2
);
321 try_to_follow_renames(&t1
, &t2
, base
, opt
);
328 int diff_root_tree_sha1(const unsigned char *new, const char *base
, struct diff_options
*opt
)
330 return diff_tree_sha1(NULL
, new, base
, opt
);