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
];
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
))
115 * Does match sort strictly earlier than path with their
118 m
= strncmp(match
, path
,
119 (matchlen
< pathlen
) ? matchlen
: pathlen
);
124 * If we come here even once, that means there is at
125 * least one pathspec that would sort equal to or
126 * later than the path we are currently looking at.
127 * In other words, if we have never reached this point
128 * after iterating all pathspecs, it means all
129 * pathspecs are either outside of base, or inside the
130 * base but sorts strictly earlier than the current
131 * one. In either case, they will never match the
132 * subsequent entries. In such a case, we initialized
133 * the variable to -1 and that is what will be
134 * returned, allowing the caller to terminate early.
136 never_interesting
= 0;
138 if (pathlen
> matchlen
)
141 if (matchlen
> pathlen
) {
142 if (match
[pathlen
] != '/')
149 * If common part matched earlier then it is a hit,
150 * because we rejected the case where path is not a
151 * leading directory and is shorter than match.
156 return never_interesting
; /* No matches */
159 /* A whole sub-tree went away or appeared */
160 static void show_tree(struct diff_options
*opt
, const char *prefix
, struct tree_desc
*desc
, const char *base
, int baselen
)
163 int show
= tree_entry_interesting(desc
, base
, baselen
, opt
);
167 show_entry(opt
, prefix
, desc
, base
, baselen
);
168 update_tree_entry(desc
);
172 /* A file entry went away or appeared */
173 static void show_entry(struct diff_options
*opt
, const char *prefix
, struct tree_desc
*desc
,
174 const char *base
, int baselen
)
178 const unsigned char *sha1
= tree_entry_extract(desc
, &path
, &mode
);
180 if (opt
->recursive
&& S_ISDIR(mode
)) {
181 enum object_type type
;
182 int pathlen
= tree_entry_len(path
, sha1
);
183 char *newbase
= malloc_base(base
, baselen
, path
, pathlen
);
184 struct tree_desc inner
;
188 tree
= read_sha1_file(sha1
, &type
, &size
);
189 if (!tree
|| type
!= OBJ_TREE
)
190 die("corrupt tree sha %s", sha1_to_hex(sha1
));
192 init_tree_desc(&inner
, tree
, size
);
193 show_tree(opt
, prefix
, &inner
, newbase
, baselen
+ 1 + pathlen
);
198 opt
->add_remove(opt
, prefix
[0], mode
, sha1
, base
, path
);
202 static void skip_uninteresting(struct tree_desc
*t
, const char *base
, int baselen
, struct diff_options
*opt
)
205 int show
= tree_entry_interesting(t
, base
, baselen
, opt
);
207 update_tree_entry(t
);
217 int diff_tree(struct tree_desc
*t1
, struct tree_desc
*t2
, const char *base
, struct diff_options
*opt
)
219 int baselen
= strlen(base
);
222 if (opt
->quiet
&& opt
->has_changes
)
225 skip_uninteresting(t1
, base
, baselen
, opt
);
226 skip_uninteresting(t2
, base
, baselen
, opt
);
231 show_entry(opt
, "+", t2
, base
, baselen
);
232 update_tree_entry(t2
);
236 show_entry(opt
, "-", t1
, base
, baselen
);
237 update_tree_entry(t1
);
240 switch (compare_tree_entry(t1
, t2
, base
, baselen
, opt
)) {
242 update_tree_entry(t1
);
245 update_tree_entry(t1
);
248 update_tree_entry(t2
);
251 die("git-diff-tree: internal error");
256 int diff_tree_sha1(const unsigned char *old
, const unsigned char *new, const char *base
, struct diff_options
*opt
)
259 struct tree_desc t1
, t2
;
260 unsigned long size1
, size2
;
263 tree1
= read_object_with_reference(old
, tree_type
, &size1
, NULL
);
265 die("unable to read source tree (%s)", sha1_to_hex(old
));
266 tree2
= read_object_with_reference(new, tree_type
, &size2
, NULL
);
268 die("unable to read destination tree (%s)", sha1_to_hex(new));
269 init_tree_desc(&t1
, tree1
, size1
);
270 init_tree_desc(&t2
, tree2
, size2
);
271 retval
= diff_tree(&t1
, &t2
, base
, opt
);
277 int diff_root_tree_sha1(const unsigned char *new, const char *base
, struct diff_options
*opt
)
282 struct tree_desc empty
, real
;
284 tree
= read_object_with_reference(new, tree_type
, &size
, NULL
);
286 die("unable to read root tree (%s)", sha1_to_hex(new));
287 init_tree_desc(&real
, tree
, size
);
289 init_tree_desc(&empty
, "", 0);
290 retval
= diff_tree(&empty
, &real
, base
, opt
);
295 static int count_paths(const char **paths
)
303 void diff_tree_release_paths(struct diff_options
*opt
)
308 void diff_tree_setup_paths(const char **p
, struct diff_options
*opt
)
311 opt
->pathlens
= NULL
;
318 opt
->nr_paths
= count_paths(p
);
319 if (opt
->nr_paths
== 0) {
320 opt
->pathlens
= NULL
;
323 opt
->pathlens
= xmalloc(opt
->nr_paths
* sizeof(int));
324 for (i
=0; i
< opt
->nr_paths
; i
++)
325 opt
->pathlens
[i
] = strlen(p
[i
]);