Merge branch 'pe/cleanup'
[git] / diff-tree.c
1 #include "cache.h"
2 #include "diff.h"
3 #include "commit.h"
4
5 static int show_root_diff = 0;
6 static int no_commit_id = 0;
7 static int verbose_header = 0;
8 static int ignore_merges = 1;
9 static int combine_merges = 0;
10 static int dense_combined_merges = 0;
11 static int read_stdin = 0;
12 static int always_show_header = 0;
13
14 static const char *header = NULL;
15 static const char *header_prefix = "";
16 static enum cmit_fmt commit_format = CMIT_FMT_RAW;
17
18 static struct diff_options diff_options;
19
20 static int call_diff_flush(void)
21 {
22         diffcore_std(&diff_options);
23         if (diff_queue_is_empty()) {
24                 int saved_fmt = diff_options.output_format;
25                 diff_options.output_format = DIFF_FORMAT_NO_OUTPUT;
26                 diff_flush(&diff_options);
27                 diff_options.output_format = saved_fmt;
28                 return 0;
29         }
30         if (header) {
31                 if (!no_commit_id)
32                         printf("%s%c", header, diff_options.line_termination);
33                 header = NULL;
34         }
35         diff_flush(&diff_options);
36         return 1;
37 }
38
39 static int diff_tree_sha1_top(const unsigned char *old,
40                               const unsigned char *new, const char *base)
41 {
42         int ret;
43
44         ret = diff_tree_sha1(old, new, base, &diff_options);
45         call_diff_flush();
46         return ret;
47 }
48
49 static int diff_root_tree(const unsigned char *new, const char *base)
50 {
51         int retval;
52         void *tree;
53         struct tree_desc empty, real;
54
55         tree = read_object_with_reference(new, tree_type, &real.size, NULL);
56         if (!tree)
57                 die("unable to read root tree (%s)", sha1_to_hex(new));
58         real.buf = tree;
59
60         empty.buf = "";
61         empty.size = 0;
62         retval = diff_tree(&empty, &real, base, &diff_options);
63         free(tree);
64         call_diff_flush();
65         return retval;
66 }
67
68 static const char *generate_header(const unsigned char *commit_sha1,
69                                    const unsigned char *parent_sha1,
70                                    const struct commit *commit)
71 {
72         static char this_header[16384];
73         int offset;
74         unsigned long len;
75         int abbrev = diff_options.abbrev;
76         const char *msg = commit->buffer;
77
78         if (!verbose_header)
79                 return sha1_to_hex(commit_sha1);
80
81         len = strlen(msg);
82
83         offset = sprintf(this_header, "%s%s ",
84                          header_prefix,
85                          diff_unique_abbrev(commit_sha1, abbrev));
86         if (commit_sha1 != parent_sha1)
87                 offset += sprintf(this_header + offset, "(from %s)\n",
88                                   parent_sha1
89                                   ? diff_unique_abbrev(parent_sha1, abbrev)
90                                   : "root");
91         else
92                 offset += sprintf(this_header + offset, "(from parents)\n");
93         offset += pretty_print_commit(commit_format, commit, len,
94                                       this_header + offset,
95                                       sizeof(this_header) - offset, abbrev);
96         if (always_show_header) {
97                 puts(this_header);
98                 return NULL;
99         }
100         return this_header;
101 }
102
103 static int diff_tree_commit(struct commit *commit)
104 {
105         struct commit_list *parents;
106         unsigned const char *sha1 = commit->object.sha1;
107
108         /* Root commit? */
109         if (show_root_diff && !commit->parents) {
110                 header = generate_header(sha1, NULL, commit);
111                 diff_root_tree(sha1, "");
112         }
113
114         /* More than one parent? */
115         if (commit->parents && commit->parents->next) {
116                 if (ignore_merges)
117                         return 0;
118                 else if (combine_merges) {
119                         header = generate_header(sha1, sha1, commit);
120                         header = diff_tree_combined_merge(sha1, header,
121                                                         dense_combined_merges,
122                                                         &diff_options);
123                         if (!header && verbose_header)
124                                 header_prefix = "\ndiff-tree ";
125                         return 0;
126                 }
127         }
128
129         for (parents = commit->parents; parents; parents = parents->next) {
130                 struct commit *parent = parents->item;
131                 header = generate_header(sha1, parent->object.sha1, commit);
132                 diff_tree_sha1_top(parent->object.sha1, sha1, "");
133                 if (!header && verbose_header) {
134                         header_prefix = "\ndiff-tree ";
135                         /*
136                          * Don't print multiple merge entries if we
137                          * don't print the diffs.
138                          */
139                 }
140         }
141         return 0;
142 }
143
144 static int diff_tree_commit_sha1(const unsigned char *sha1)
145 {
146         struct commit *commit = lookup_commit_reference(sha1);
147         if (!commit)
148                 return -1;
149         return diff_tree_commit(commit);
150 }
151
152 static int diff_tree_stdin(char *line)
153 {
154         int len = strlen(line);
155         unsigned char sha1[20];
156         struct commit *commit;
157
158         if (!len || line[len-1] != '\n')
159                 return -1;
160         line[len-1] = 0;
161         if (get_sha1_hex(line, sha1))
162                 return -1;
163         commit = lookup_commit(sha1);
164         if (!commit || parse_commit(commit))
165                 return -1;
166         if (isspace(line[40]) && !get_sha1_hex(line+41, sha1)) {
167                 /* Graft the fake parents locally to the commit */
168                 int pos = 41;
169                 struct commit_list **pptr, *parents;
170
171                 /* Free the real parent list */
172                 for (parents = commit->parents; parents; ) {
173                         struct commit_list *tmp = parents->next;
174                         free(parents);
175                         parents = tmp;
176                 }
177                 commit->parents = NULL;
178                 pptr = &(commit->parents);
179                 while (line[pos] && !get_sha1_hex(line + pos, sha1)) {
180                         struct commit *parent = lookup_commit(sha1);
181                         if (parent) {
182                                 pptr = &commit_list_insert(parent, pptr)->next;
183                         }
184                         pos += 41;
185                 }
186         }
187         return diff_tree_commit(commit);
188 }
189
190 static const char diff_tree_usage[] =
191 "git-diff-tree [--stdin] [-m] [-c] [--cc] [-s] [-v] [--pretty] [-t] [-r] [--root] "
192 "[<common diff options>] <tree-ish> [<tree-ish>] [<path>...]\n"
193 "  -r            diff recursively\n"
194 "  --root        include the initial commit as diff against /dev/null\n"
195 COMMON_DIFF_OPTIONS_HELP;
196
197 int main(int argc, const char **argv)
198 {
199         int nr_sha1;
200         char line[1000];
201         unsigned char sha1[2][20];
202         const char *prefix = setup_git_directory();
203
204         git_config(git_diff_config);
205         nr_sha1 = 0;
206         diff_setup(&diff_options);
207
208         for (;;) {
209                 int diff_opt_cnt;
210                 const char *arg;
211
212                 argv++;
213                 argc--;
214                 arg = *argv;
215                 if (!arg)
216                         break;
217
218                 if (*arg != '-') {
219                         if (nr_sha1 < 2 && !get_sha1(arg, sha1[nr_sha1])) {
220                                 nr_sha1++;
221                                 continue;
222                         }
223                         break;
224                 }
225
226                 diff_opt_cnt = diff_opt_parse(&diff_options, argv, argc);
227                 if (diff_opt_cnt < 0)
228                         usage(diff_tree_usage);
229                 else if (diff_opt_cnt) {
230                         argv += diff_opt_cnt - 1;
231                         argc -= diff_opt_cnt - 1;
232                         continue;
233                 }
234
235
236                 if (!strcmp(arg, "--")) {
237                         argv++;
238                         argc--;
239                         break;
240                 }
241                 if (!strcmp(arg, "-r")) {
242                         diff_options.recursive = 1;
243                         continue;
244                 }
245                 if (!strcmp(arg, "-t")) {
246                         diff_options.recursive = 1;
247                         diff_options.tree_in_recursive = 1;
248                         continue;
249                 }
250                 if (!strcmp(arg, "-m")) {
251                         ignore_merges = 0;
252                         continue;
253                 }
254                 if (!strcmp(arg, "-c")) {
255                         combine_merges = 1;
256                         continue;
257                 }
258                 if (!strcmp(arg, "--cc")) {
259                         dense_combined_merges = combine_merges = 1;
260                         continue;
261                 }
262                 if (!strcmp(arg, "-v")) {
263                         verbose_header = 1;
264                         header_prefix = "diff-tree ";
265                         continue;
266                 }
267                 if (!strncmp(arg, "--pretty", 8)) {
268                         verbose_header = 1;
269                         header_prefix = "diff-tree ";
270                         commit_format = get_commit_format(arg+8);
271                         continue;
272                 }
273                 if (!strcmp(arg, "--stdin")) {
274                         read_stdin = 1;
275                         continue;
276                 }
277                 if (!strcmp(arg, "--root")) {
278                         show_root_diff = 1;
279                         continue;
280                 }
281                 if (!strcmp(arg, "--no-commit-id")) {
282                         no_commit_id = 1;
283                         continue;
284                 }
285                 if (!strcmp(arg, "--always")) {
286                         always_show_header = 1;
287                         continue;
288                 }
289                 usage(diff_tree_usage);
290         }
291
292         if (combine_merges)
293                 ignore_merges = 0;
294
295         /* We can only do dense combined merges with diff output */
296         if (dense_combined_merges)
297                 diff_options.output_format = DIFF_FORMAT_PATCH;
298
299         if (diff_options.output_format == DIFF_FORMAT_PATCH)
300                 diff_options.recursive = 1;
301
302         diff_tree_setup_paths(get_pathspec(prefix, argv));
303         diff_setup_done(&diff_options);
304
305         switch (nr_sha1) {
306         case 0:
307                 if (!read_stdin)
308                         usage(diff_tree_usage);
309                 break;
310         case 1:
311                 diff_tree_commit_sha1(sha1[0]);
312                 break;
313         case 2:
314                 diff_tree_sha1_top(sha1[0], sha1[1], "");
315                 break;
316         }
317
318         if (!read_stdin)
319                 return 0;
320
321         if (diff_options.detect_rename)
322                 diff_options.setup |= (DIFF_SETUP_USE_SIZE_CACHE |
323                                        DIFF_SETUP_USE_CACHE);
324         while (fgets(line, sizeof(line), stdin))
325                 diff_tree_stdin(line);
326
327         return 0;
328 }