← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/git-core/intrepid-updates

« back to all changes in this revision

Viewing changes to builtin-diff.c

  • Committer: Package Import Robot
  • Author(s): Gerrit Pape
  • Date: 2007-04-22 13:31:05 UTC
  • mfrom: (1.1.14)
  • Revision ID: package-import@ubuntu.com-20070422133105-tkmhz328g2p0epz1
Tags: 1:1.5.1.2-1
* new upstream point release.
* debian/changelog.upstream: upstream changes taken from mailing list
  announcement.

Show diffs side-by-side

added added

removed removed

Lines of Context:
builtin-diff.c
25
25
static const char builtin_diff_usage[] =
26
26
"git-diff <options> <rev>{0,2} -- <path>*";
27
27
 
28
 
static int builtin_diff_files(struct rev_info *revs,
29
 
                              int argc, const char **argv)
30
 
{
31
 
        int silent = 0;
32
 
        while (1 < argc) {
33
 
                const char *arg = argv[1];
34
 
                if (!strcmp(arg, "--base"))
35
 
                        revs->max_count = 1;
36
 
                else if (!strcmp(arg, "--ours"))
37
 
                        revs->max_count = 2;
38
 
                else if (!strcmp(arg, "--theirs"))
39
 
                        revs->max_count = 3;
40
 
                else if (!strcmp(arg, "-q"))
41
 
                        silent = 1;
42
 
                else
43
 
                        usage(builtin_diff_usage);
44
 
                argv++; argc--;
45
 
        }
46
 
        /*
47
 
         * Make sure there are NO revision (i.e. pending object) parameter,
48
 
         * specified rev.max_count is reasonable (0 <= n <= 3), and
49
 
         * there is no other revision filtering parameter.
50
 
         */
51
 
        if (revs->pending.nr ||
52
 
            revs->min_age != -1 ||
53
 
            revs->max_age != -1 ||
54
 
            3 < revs->max_count)
55
 
                usage(builtin_diff_usage);
56
 
        if (revs->max_count < 0 &&
57
 
            (revs->diffopt.output_format & DIFF_FORMAT_PATCH))
58
 
                revs->combine_merges = revs->dense_combined_merges = 1;
59
 
        return run_diff_files(revs, silent);
60
 
}
61
 
 
62
28
static void stuff_change(struct diff_options *opt,
63
29
                         unsigned old_mode, unsigned new_mode,
64
30
                         const unsigned char *old_sha1,
151
117
            revs->max_count != -1 || revs->min_age != -1 ||
152
118
            revs->max_age != -1)
153
119
                usage(builtin_diff_usage);
 
120
        if (read_cache() < 0) {
 
121
                perror("read_cache");
 
122
                return -1;
 
123
        }
154
124
        return run_diff_index(revs, cached);
155
125
}
156
126
 
192
162
        parent = xmalloc(ents * sizeof(*parent));
193
163
        /* Again, the revs are all reverse */
194
164
        for (i = 0; i < ents; i++)
195
 
                hashcpy((unsigned char*)parent + i, ent[ents - 1 - i].item->sha1);
 
165
                hashcpy((unsigned char *)(parent + i),
 
166
                        ent[ents - 1 - i].item->sha1);
196
167
        diff_tree_combined(parent[0], parent + 1, ents - 1,
197
168
                           revs->dense_combined_merges, revs);
198
169
        return 0;
218
189
        int ents = 0, blobs = 0, paths = 0;
219
190
        const char *path = NULL;
220
191
        struct blobinfo blob[2];
 
192
        int nongit = 0;
 
193
        int result = 0;
221
194
 
222
195
        /*
223
196
         * We could get N tree-ish in the rev.pending_objects list.
239
212
         * Other cases are errors.
240
213
         */
241
214
 
 
215
        prefix = setup_git_directory_gently(&nongit);
242
216
        git_config(git_diff_ui_config);
243
217
        init_revisions(&rev, prefix);
244
218
 
245
 
        argc = setup_revisions(argc, argv, &rev, NULL);
 
219
        if (!setup_diff_no_index(&rev, argc, argv, nongit, prefix))
 
220
                argc = 0;
 
221
        else
 
222
                argc = setup_revisions(argc, argv, &rev, NULL);
246
223
        if (!rev.diffopt.output_format) {
247
224
                rev.diffopt.output_format = DIFF_FORMAT_PATCH;
248
225
                if (diff_setup_done(&rev.diffopt) < 0)
260
237
                                break;
261
238
                        else if (!strcmp(arg, "--cached")) {
262
239
                                add_head(&rev);
 
240
                                if (!rev.pending.nr)
 
241
                                        die("No HEAD commit to compare with (yet)");
263
242
                                break;
264
243
                        }
265
244
                }
314
293
        if (!ents) {
315
294
                switch (blobs) {
316
295
                case 0:
317
 
                        return builtin_diff_files(&rev, argc, argv);
 
296
                        result = run_diff_files_cmd(&rev, argc, argv);
318
297
                        break;
319
298
                case 1:
320
299
                        if (paths != 1)
321
300
                                usage(builtin_diff_usage);
322
 
                        return builtin_diff_b_f(&rev, argc, argv, blob, path);
 
301
                        result = builtin_diff_b_f(&rev, argc, argv, blob, path);
323
302
                        break;
324
303
                case 2:
325
304
                        if (paths)
326
305
                                usage(builtin_diff_usage);
327
 
                        return builtin_diff_blobs(&rev, argc, argv, blob);
 
306
                        result = builtin_diff_blobs(&rev, argc, argv, blob);
328
307
                        break;
329
308
                default:
330
309
                        usage(builtin_diff_usage);
333
312
        else if (blobs)
334
313
                usage(builtin_diff_usage);
335
314
        else if (ents == 1)
336
 
                return builtin_diff_index(&rev, argc, argv);
 
315
                result = builtin_diff_index(&rev, argc, argv);
337
316
        else if (ents == 2)
338
 
                return builtin_diff_tree(&rev, argc, argv, ent);
 
317
                result = builtin_diff_tree(&rev, argc, argv, ent);
339
318
        else if ((ents == 3) && (ent[0].item->flags & UNINTERESTING)) {
340
319
                /* diff A...B where there is one sane merge base between
341
320
                 * A and B.  We have ent[0] == merge-base, ent[1] == A,
342
321
                 * and ent[2] == B.  Show diff between the base and B.
343
322
                 */
344
323
                ent[1] = ent[2];
345
 
                return builtin_diff_tree(&rev, argc, argv, ent);
 
324
                result = builtin_diff_tree(&rev, argc, argv, ent);
346
325
        }
347
326
        else
348
 
                return builtin_diff_combined(&rev, argc, argv,
 
327
                result = builtin_diff_combined(&rev, argc, argv,
349
328
                                             ent, ents);
350
 
        usage(builtin_diff_usage);
 
329
        if (rev.diffopt.exit_with_status)
 
330
                result = rev.diffopt.has_changes;
 
331
        return result;
351
332
}