2 * Helper functions for tree diff generation
8 static char *malloc_base(const char *base
, int baselen
, const char *path
, int pathlen
)
10 char *newbase
= xmalloc(baselen
+ pathlen
+ 2);
11 memcpy(newbase
, base
, baselen
);
12 memcpy(newbase
+ baselen
, path
, pathlen
);
13 memcpy(newbase
+ baselen
+ pathlen
, "/", 2);
17 static void show_entry(struct diff_options
*opt
, const char *prefix
, struct tree_desc
*desc
,
18 const char *base
, int baselen
);
20 static int compare_tree_entry(struct tree_desc
*t1
, struct tree_desc
*t2
, const char *base
, int baselen
, struct diff_options
*opt
)
22 unsigned mode1
, mode2
;
23 const char *path1
, *path2
;
24 const unsigned char *sha1
, *sha2
;
25 int cmp
, pathlen1
, pathlen2
;
27 sha1
= tree_entry_extract(t1
, &path1
, &mode1
);
28 sha2
= tree_entry_extract(t2
, &path2
, &mode2
);
30 pathlen1
= tree_entry_len(path1
, sha1
);
31 pathlen2
= tree_entry_len(path2
, sha2
);
32 cmp
= base_name_compare(path1
, pathlen1
, mode1
, path2
, pathlen2
, mode2
);
34 show_entry(opt
, "-", t1
, base
, baselen
);
38 show_entry(opt
, "+", t2
, base
, baselen
);
41 if (!opt
->find_copies_harder
&& !hashcmp(sha1
, sha2
) && mode1
== mode2
)
45 * If the filemode has changed to/from a directory from/to a regular
46 * file, we need to consider it a remove and an add.
48 if (S_ISDIR(mode1
) != S_ISDIR(mode2
)) {
49 show_entry(opt
, "-", t1
, base
, baselen
);
50 show_entry(opt
, "+", t2
, base
, baselen
);
54 if (opt
->recursive
&& S_ISDIR(mode1
)) {
56 char *newbase
= malloc_base(base
, baselen
, path1
, pathlen1
);
57 if (opt
->tree_in_recursive
)
58 opt
->change(opt
, mode1
, mode2
,
59 sha1
, sha2
, base
, path1
);
60 retval
= diff_tree_sha1(sha1
, sha2
, newbase
, opt
);
65 opt
->change(opt
, mode1
, mode2
, sha1
, sha2
, base
, path1
);
70 * Is a tree entry interesting given the pathspec we have?
75 * - negative for "no, and no subsequent entries will be either"
77 static int tree_entry_interesting(struct tree_desc
*desc
, const char *base
, int baselen
, struct diff_options
*opt
)
80 const unsigned char *sha1
;
84 int never_interesting
= -1;
89 sha1
= tree_entry_extract(desc
, &path
, &mode
);
91 pathlen
= tree_entry_len(path
, sha1
);
93 for (i
= 0; i
< opt
->nr_paths
; i
++) {
94 const char *match
= opt
->paths
[i
];
95 int matchlen
= opt
->pathlens
[i
];
96 int m
= -1; /* signals that we haven't called strncmp() */
98 if (baselen
>= matchlen
) {
99 /* If it doesn't match, move along... */
100 if (strncmp(base
, match
, matchlen
))
103 /* The base is a subdirectory of a path which was specified. */
107 /* Does the base match? */
108 if (strncmp(base
, match
, baselen
))
114 if (never_interesting
) {
116 * We have not seen any match that sorts later
117 * than the current path.
121 * Does match sort strictly earlier than path
122 * with their common parts?
124 m
= strncmp(match
, path
,
125 (matchlen
< pathlen
) ? matchlen
: pathlen
);
130 * If we come here even once, that means there is at
131 * least one pathspec that would sort equal to or
132 * later than the path we are currently looking at.
133 * In other words, if we have never reached this point
134 * after iterating all pathspecs, it means all
135 * pathspecs are either outside of base, or inside the
136 * base but sorts strictly earlier than the current
137 * one. In either case, they will never match the
138 * subsequent entries. In such a case, we initialized
139 * the variable to -1 and that is what will be
140 * returned, allowing the caller to terminate early.
142 never_interesting
= 0;
145 if (pathlen
> matchlen
)
148 if (matchlen
> pathlen
) {
149 if (match
[pathlen
] != '/')
157 * we cheated and did not do strncmp(), so we do
160 m
= strncmp(match
, path
, pathlen
);
163 * If common part matched earlier then it is a hit,
164 * because we rejected the case where path is not a
165 * leading directory and is shorter than match.
170 return never_interesting
; /* No matches */
173 /* A whole sub-tree went away or appeared */
174 static void show_tree(struct diff_options
*opt
, const char *prefix
, struct tree_desc
*desc
, const char *base
, int baselen
)
177 int show
= tree_entry_interesting(desc
, base
, baselen
, opt
);
181 show_entry(opt
, prefix
, desc
, base
, baselen
);
182 update_tree_entry(desc
);
186 /* A file entry went away or appeared */
187 static void show_entry(struct diff_options
*opt
, const char *prefix
, struct tree_desc
*desc
,
188 const char *base
, int baselen
)
192 const unsigned char *sha1
= tree_entry_extract(desc
, &path
, &mode
);
194 if (opt
->recursive
&& S_ISDIR(mode
)) {
195 enum object_type type
;
196 int pathlen
= tree_entry_len(path
, sha1
);
197 char *newbase
= malloc_base(base
, baselen
, path
, pathlen
);
198 struct tree_desc inner
;
202 tree
= read_sha1_file(sha1
, &type
, &size
);
203 if (!tree
|| type
!= OBJ_TREE
)
204 die("corrupt tree sha %s", sha1_to_hex(sha1
));
206 init_tree_desc(&inner
, tree
, size
);
207 show_tree(opt
, prefix
, &inner
, newbase
, baselen
+ 1 + pathlen
);
212 opt
->add_remove(opt
, prefix
[0], mode
, sha1
, base
, path
);
216 static void skip_uninteresting(struct tree_desc
*t
, const char *base
, int baselen
, struct diff_options
*opt
)
219 int show
= tree_entry_interesting(t
, base
, baselen
, opt
);
221 update_tree_entry(t
);
231 int diff_tree(struct tree_desc
*t1
, struct tree_desc
*t2
, const char *base
, struct diff_options
*opt
)
233 int baselen
= strlen(base
);
236 if (opt
->quiet
&& opt
->has_changes
)
239 skip_uninteresting(t1
, base
, baselen
, opt
);
240 skip_uninteresting(t2
, base
, baselen
, opt
);
245 show_entry(opt
, "+", t2
, base
, baselen
);
246 update_tree_entry(t2
);
250 show_entry(opt
, "-", t1
, base
, baselen
);
251 update_tree_entry(t1
);
254 switch (compare_tree_entry(t1
, t2
, base
, baselen
, opt
)) {
256 update_tree_entry(t1
);
259 update_tree_entry(t1
);
262 update_tree_entry(t2
);
265 die("git-diff-tree: internal error");
270 int diff_tree_sha1(const unsigned char *old
, const unsigned char *new, const char *base
, struct diff_options
*opt
)
273 struct tree_desc t1
, t2
;
274 unsigned long size1
, size2
;
277 tree1
= read_object_with_reference(old
, tree_type
, &size1
, NULL
);
279 die("unable to read source tree (%s)", sha1_to_hex(old
));
280 tree2
= read_object_with_reference(new, tree_type
, &size2
, NULL
);
282 die("unable to read destination tree (%s)", sha1_to_hex(new));
283 init_tree_desc(&t1
, tree1
, size1
);
284 init_tree_desc(&t2
, tree2
, size2
);
285 retval
= diff_tree(&t1
, &t2
, base
, opt
);
291 int diff_root_tree_sha1(const unsigned char *new, const char *base
, struct diff_options
*opt
)
296 struct tree_desc empty
, real
;
298 tree
= read_object_with_reference(new, tree_type
, &size
, NULL
);
300 die("unable to read root tree (%s)", sha1_to_hex(new));
301 init_tree_desc(&real
, tree
, size
);
303 init_tree_desc(&empty
, "", 0);
304 retval
= diff_tree(&empty
, &real
, base
, opt
);
309 static int count_paths(const char **paths
)
317 void diff_tree_release_paths(struct diff_options
*opt
)
322 void diff_tree_setup_paths(const char **p
, struct diff_options
*opt
)
325 opt
->pathlens
= NULL
;
332 opt
->nr_paths
= count_paths(p
);
333 if (opt
->nr_paths
== 0) {
334 opt
->pathlens
= NULL
;
337 opt
->pathlens
= xmalloc(opt
->nr_paths
* sizeof(int));
338 for (i
=0; i
< opt
->nr_paths
; i
++)
339 opt
->pathlens
[i
] = strlen(p
[i
]);