2005-04-09 20:00:54 +00:00
|
|
|
#include "cache.h"
|
2005-04-27 16:21:00 +00:00
|
|
|
#include "diff.h"
|
2005-06-01 15:34:23 +00:00
|
|
|
#include "commit.h"
|
2005-04-09 20:00:54 +00:00
|
|
|
|
2005-05-19 20:44:29 +00:00
|
|
|
static int show_root_diff = 0;
|
2005-11-10 05:30:12 +00:00
|
|
|
static int no_commit_id = 0;
|
2005-05-06 18:42:47 +00:00
|
|
|
static int verbose_header = 0;
|
2005-05-06 17:03:17 +00:00
|
|
|
static int ignore_merges = 1;
|
diff-tree -c: show a merge commit a bit more sensibly.
A new option '-c' to diff-tree changes the way a merge commit is
displayed when generating a patch output. It shows a "combined
diff" (hence the option letter 'c'), which looks like this:
$ git-diff-tree --pretty -c -p fec9ebf1 | head -n 18
diff-tree fec9ebf... (from parents)
Merge: 0620db3... 8a263ae...
Author: Junio C Hamano <junkio@cox.net>
Date: Sun Jan 15 22:25:35 2006 -0800
Merge fixes up to GIT 1.1.3
diff --combined describe.c
@@@ +98,7 @@@
return (a_date > b_date) ? -1 : (a_date == b_date) ? 0 : 1;
}
- static void describe(char *arg)
- static void describe(struct commit *cmit, int last_one)
++ static void describe(char *arg, int last_one)
{
+ unsigned char sha1[20];
+ struct commit *cmit;
There are a few things to note about this feature:
- The '-c' option implies '-p'. It also implies '-m' halfway
in the sense that "interesting" merges are shown, but not all
merges.
- When a blob matches one of the parents, we do not show a diff
for that path at all. For a merge commit, this option shows
paths with real file-level merge (aka "interesting things").
- As a concequence of the above, an "uninteresting" merge is
not shown at all. You can use '-m' in addition to '-c' to
show the commit log for such a merge, but there will be no
combined diff output.
- Unlike "gitk", the output is monochrome.
A '-' character in the nth column means the line is from the nth
parent and does not appear in the merge result (i.e. removed
from that parent's version).
A '+' character in the nth column means the line appears in the
merge result, and the nth parent does not have that line
(i.e. added by the merge itself or inherited from another
parent).
The above example output shows that the function signature was
changed from either parents (hence two "-" lines and a "++"
line), and "unsigned char sha1[20]", prefixed by a " +", was
inherited from the first parent.
The code as sent to the list was buggy in few corner cases,
which I have fixed since then.
It does not bother to keep track of and show the line numbers
from parent commits, which it probably should.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-01-24 09:22:04 +00:00
|
|
|
static int combine_merges = 0;
|
2006-01-24 09:22:04 +00:00
|
|
|
static int dense_combined_merges = 0;
|
2005-05-06 17:03:17 +00:00
|
|
|
static int read_stdin = 0;
|
2006-02-05 19:42:09 +00:00
|
|
|
static int always_show_header = 0;
|
2005-09-21 07:00:47 +00:00
|
|
|
|
2005-05-06 17:56:35 +00:00
|
|
|
static const char *header = NULL;
|
2005-05-06 18:42:47 +00:00
|
|
|
static const char *header_prefix = "";
|
2005-06-05 16:02:03 +00:00
|
|
|
static enum cmit_fmt commit_format = CMIT_FMT_RAW;
|
2005-04-09 20:00:54 +00:00
|
|
|
|
2005-10-21 04:05:05 +00:00
|
|
|
static struct diff_options diff_options;
|
2005-04-10 21:03:58 +00:00
|
|
|
|
2005-05-22 21:33:43 +00:00
|
|
|
static int call_diff_flush(void)
|
2005-05-22 02:40:36 +00:00
|
|
|
{
|
2005-09-21 07:00:47 +00:00
|
|
|
diffcore_std(&diff_options);
|
2005-05-23 23:37:47 +00:00
|
|
|
if (diff_queue_is_empty()) {
|
2005-09-21 07:00:47 +00:00
|
|
|
int saved_fmt = diff_options.output_format;
|
|
|
|
diff_options.output_format = DIFF_FORMAT_NO_OUTPUT;
|
|
|
|
diff_flush(&diff_options);
|
|
|
|
diff_options.output_format = saved_fmt;
|
2005-05-23 23:37:47 +00:00
|
|
|
return 0;
|
2005-05-22 17:04:37 +00:00
|
|
|
}
|
|
|
|
if (header) {
|
2005-11-10 05:30:12 +00:00
|
|
|
if (!no_commit_id)
|
|
|
|
printf("%s%c", header, diff_options.line_termination);
|
2005-05-22 17:04:37 +00:00
|
|
|
header = NULL;
|
|
|
|
}
|
2005-09-21 07:00:47 +00:00
|
|
|
diff_flush(&diff_options);
|
2005-05-22 17:04:37 +00:00
|
|
|
return 1;
|
2005-05-22 02:40:36 +00:00
|
|
|
}
|
|
|
|
|
2005-05-19 10:32:35 +00:00
|
|
|
static int diff_tree_sha1_top(const unsigned char *old,
|
|
|
|
const unsigned char *new, const char *base)
|
|
|
|
{
|
|
|
|
int ret;
|
2005-05-20 02:00:36 +00:00
|
|
|
|
2005-10-21 04:05:05 +00:00
|
|
|
ret = diff_tree_sha1(old, new, base, &diff_options);
|
2005-05-22 02:40:36 +00:00
|
|
|
call_diff_flush();
|
2005-05-19 10:32:35 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-05-19 20:44:29 +00:00
|
|
|
static int diff_root_tree(const unsigned char *new, const char *base)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
void *tree;
|
2005-10-21 04:05:05 +00:00
|
|
|
struct tree_desc empty, real;
|
2005-05-19 20:44:29 +00:00
|
|
|
|
2005-10-21 04:05:05 +00:00
|
|
|
tree = read_object_with_reference(new, "tree", &real.size, NULL);
|
2005-05-19 20:44:29 +00:00
|
|
|
if (!tree)
|
|
|
|
die("unable to read root tree (%s)", sha1_to_hex(new));
|
2005-10-21 04:05:05 +00:00
|
|
|
real.buf = tree;
|
|
|
|
|
|
|
|
empty.buf = "";
|
|
|
|
empty.size = 0;
|
|
|
|
retval = diff_tree(&empty, &real, base, &diff_options);
|
2005-05-19 20:44:29 +00:00
|
|
|
free(tree);
|
2005-05-22 02:40:36 +00:00
|
|
|
call_diff_flush();
|
2005-05-19 20:44:29 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2005-12-14 01:21:41 +00:00
|
|
|
static const char *generate_header(const unsigned char *commit_sha1,
|
|
|
|
const unsigned char *parent_sha1,
|
2006-01-27 09:54:59 +00:00
|
|
|
const struct commit *commit)
|
2005-05-06 18:42:47 +00:00
|
|
|
{
|
2005-05-21 18:04:19 +00:00
|
|
|
static char this_header[16384];
|
2005-05-06 18:42:47 +00:00
|
|
|
int offset;
|
2005-11-22 05:49:06 +00:00
|
|
|
unsigned long len;
|
2005-12-14 01:21:41 +00:00
|
|
|
int abbrev = diff_options.abbrev;
|
2006-01-27 09:54:59 +00:00
|
|
|
const char *msg = commit->buffer;
|
2005-05-06 18:42:47 +00:00
|
|
|
|
2005-06-23 20:56:55 +00:00
|
|
|
if (!verbose_header)
|
2005-12-14 01:21:41 +00:00
|
|
|
return sha1_to_hex(commit_sha1);
|
2005-05-06 18:42:47 +00:00
|
|
|
|
2005-11-22 05:49:06 +00:00
|
|
|
len = strlen(msg);
|
2005-12-14 01:21:41 +00:00
|
|
|
|
|
|
|
offset = sprintf(this_header, "%s%s ",
|
|
|
|
header_prefix,
|
|
|
|
diff_unique_abbrev(commit_sha1, abbrev));
|
diff-tree -c: show a merge commit a bit more sensibly.
A new option '-c' to diff-tree changes the way a merge commit is
displayed when generating a patch output. It shows a "combined
diff" (hence the option letter 'c'), which looks like this:
$ git-diff-tree --pretty -c -p fec9ebf1 | head -n 18
diff-tree fec9ebf... (from parents)
Merge: 0620db3... 8a263ae...
Author: Junio C Hamano <junkio@cox.net>
Date: Sun Jan 15 22:25:35 2006 -0800
Merge fixes up to GIT 1.1.3
diff --combined describe.c
@@@ +98,7 @@@
return (a_date > b_date) ? -1 : (a_date == b_date) ? 0 : 1;
}
- static void describe(char *arg)
- static void describe(struct commit *cmit, int last_one)
++ static void describe(char *arg, int last_one)
{
+ unsigned char sha1[20];
+ struct commit *cmit;
There are a few things to note about this feature:
- The '-c' option implies '-p'. It also implies '-m' halfway
in the sense that "interesting" merges are shown, but not all
merges.
- When a blob matches one of the parents, we do not show a diff
for that path at all. For a merge commit, this option shows
paths with real file-level merge (aka "interesting things").
- As a concequence of the above, an "uninteresting" merge is
not shown at all. You can use '-m' in addition to '-c' to
show the commit log for such a merge, but there will be no
combined diff output.
- Unlike "gitk", the output is monochrome.
A '-' character in the nth column means the line is from the nth
parent and does not appear in the merge result (i.e. removed
from that parent's version).
A '+' character in the nth column means the line appears in the
merge result, and the nth parent does not have that line
(i.e. added by the merge itself or inherited from another
parent).
The above example output shows that the function signature was
changed from either parents (hence two "-" lines and a "++"
line), and "unsigned char sha1[20]", prefixed by a " +", was
inherited from the first parent.
The code as sent to the list was buggy in few corner cases,
which I have fixed since then.
It does not bother to keep track of and show the line numbers
from parent commits, which it probably should.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-01-24 09:22:04 +00:00
|
|
|
if (commit_sha1 != parent_sha1)
|
|
|
|
offset += sprintf(this_header + offset, "(from %s)\n",
|
|
|
|
parent_sha1
|
|
|
|
? diff_unique_abbrev(parent_sha1, abbrev)
|
|
|
|
: "root");
|
|
|
|
else
|
|
|
|
offset += sprintf(this_header + offset, "(from parents)\n");
|
2006-01-27 09:54:59 +00:00
|
|
|
offset += pretty_print_commit(commit_format, commit, len,
|
2005-12-14 01:21:41 +00:00
|
|
|
this_header + offset,
|
2006-01-25 10:37:40 +00:00
|
|
|
sizeof(this_header) - offset, abbrev);
|
2006-02-05 19:42:09 +00:00
|
|
|
if (always_show_header) {
|
|
|
|
puts(this_header);
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-05-06 18:42:47 +00:00
|
|
|
return this_header;
|
|
|
|
}
|
|
|
|
|
2005-11-22 05:49:06 +00:00
|
|
|
static int diff_tree_commit(const unsigned char *commit_sha1)
|
2005-05-06 17:03:17 +00:00
|
|
|
{
|
2005-11-22 05:49:06 +00:00
|
|
|
struct commit *commit;
|
|
|
|
struct commit_list *parents;
|
|
|
|
char name[50];
|
|
|
|
unsigned char sha1[20];
|
2005-05-06 17:03:17 +00:00
|
|
|
|
2005-11-22 05:49:06 +00:00
|
|
|
sprintf(name, "%s^0", sha1_to_hex(commit_sha1));
|
|
|
|
if (get_sha1(name, sha1))
|
2005-05-06 17:03:17 +00:00
|
|
|
return -1;
|
2005-11-22 05:49:06 +00:00
|
|
|
name[40] = 0;
|
|
|
|
commit = lookup_commit(sha1);
|
|
|
|
|
2005-05-19 20:44:29 +00:00
|
|
|
/* Root commit? */
|
2005-11-22 05:49:06 +00:00
|
|
|
if (show_root_diff && !commit->parents) {
|
2006-01-27 09:54:59 +00:00
|
|
|
header = generate_header(sha1, NULL, commit);
|
2005-11-22 05:49:06 +00:00
|
|
|
diff_root_tree(commit_sha1, "");
|
2005-05-19 20:44:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* More than one parent? */
|
diff-tree -c: show a merge commit a bit more sensibly.
A new option '-c' to diff-tree changes the way a merge commit is
displayed when generating a patch output. It shows a "combined
diff" (hence the option letter 'c'), which looks like this:
$ git-diff-tree --pretty -c -p fec9ebf1 | head -n 18
diff-tree fec9ebf... (from parents)
Merge: 0620db3... 8a263ae...
Author: Junio C Hamano <junkio@cox.net>
Date: Sun Jan 15 22:25:35 2006 -0800
Merge fixes up to GIT 1.1.3
diff --combined describe.c
@@@ +98,7 @@@
return (a_date > b_date) ? -1 : (a_date == b_date) ? 0 : 1;
}
- static void describe(char *arg)
- static void describe(struct commit *cmit, int last_one)
++ static void describe(char *arg, int last_one)
{
+ unsigned char sha1[20];
+ struct commit *cmit;
There are a few things to note about this feature:
- The '-c' option implies '-p'. It also implies '-m' halfway
in the sense that "interesting" merges are shown, but not all
merges.
- When a blob matches one of the parents, we do not show a diff
for that path at all. For a merge commit, this option shows
paths with real file-level merge (aka "interesting things").
- As a concequence of the above, an "uninteresting" merge is
not shown at all. You can use '-m' in addition to '-c' to
show the commit log for such a merge, but there will be no
combined diff output.
- Unlike "gitk", the output is monochrome.
A '-' character in the nth column means the line is from the nth
parent and does not appear in the merge result (i.e. removed
from that parent's version).
A '+' character in the nth column means the line appears in the
merge result, and the nth parent does not have that line
(i.e. added by the merge itself or inherited from another
parent).
The above example output shows that the function signature was
changed from either parents (hence two "-" lines and a "++"
line), and "unsigned char sha1[20]", prefixed by a " +", was
inherited from the first parent.
The code as sent to the list was buggy in few corner cases,
which I have fixed since then.
It does not bother to keep track of and show the line numbers
from parent commits, which it probably should.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-01-24 09:22:04 +00:00
|
|
|
if (commit->parents && commit->parents->next) {
|
|
|
|
if (ignore_merges)
|
|
|
|
return 0;
|
|
|
|
else if (combine_merges) {
|
2006-01-28 08:16:09 +00:00
|
|
|
header = generate_header(sha1, sha1, commit);
|
diff-tree -c: show a merge commit a bit more sensibly.
A new option '-c' to diff-tree changes the way a merge commit is
displayed when generating a patch output. It shows a "combined
diff" (hence the option letter 'c'), which looks like this:
$ git-diff-tree --pretty -c -p fec9ebf1 | head -n 18
diff-tree fec9ebf... (from parents)
Merge: 0620db3... 8a263ae...
Author: Junio C Hamano <junkio@cox.net>
Date: Sun Jan 15 22:25:35 2006 -0800
Merge fixes up to GIT 1.1.3
diff --combined describe.c
@@@ +98,7 @@@
return (a_date > b_date) ? -1 : (a_date == b_date) ? 0 : 1;
}
- static void describe(char *arg)
- static void describe(struct commit *cmit, int last_one)
++ static void describe(char *arg, int last_one)
{
+ unsigned char sha1[20];
+ struct commit *cmit;
There are a few things to note about this feature:
- The '-c' option implies '-p'. It also implies '-m' halfway
in the sense that "interesting" merges are shown, but not all
merges.
- When a blob matches one of the parents, we do not show a diff
for that path at all. For a merge commit, this option shows
paths with real file-level merge (aka "interesting things").
- As a concequence of the above, an "uninteresting" merge is
not shown at all. You can use '-m' in addition to '-c' to
show the commit log for such a merge, but there will be no
combined diff output.
- Unlike "gitk", the output is monochrome.
A '-' character in the nth column means the line is from the nth
parent and does not appear in the merge result (i.e. removed
from that parent's version).
A '+' character in the nth column means the line appears in the
merge result, and the nth parent does not have that line
(i.e. added by the merge itself or inherited from another
parent).
The above example output shows that the function signature was
changed from either parents (hence two "-" lines and a "++"
line), and "unsigned char sha1[20]", prefixed by a " +", was
inherited from the first parent.
The code as sent to the list was buggy in few corner cases,
which I have fixed since then.
It does not bother to keep track of and show the line numbers
from parent commits, which it probably should.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-01-24 09:22:04 +00:00
|
|
|
return diff_tree_combined_merge(sha1, header,
|
2006-01-24 09:22:04 +00:00
|
|
|
dense_combined_merges);
|
diff-tree -c: show a merge commit a bit more sensibly.
A new option '-c' to diff-tree changes the way a merge commit is
displayed when generating a patch output. It shows a "combined
diff" (hence the option letter 'c'), which looks like this:
$ git-diff-tree --pretty -c -p fec9ebf1 | head -n 18
diff-tree fec9ebf... (from parents)
Merge: 0620db3... 8a263ae...
Author: Junio C Hamano <junkio@cox.net>
Date: Sun Jan 15 22:25:35 2006 -0800
Merge fixes up to GIT 1.1.3
diff --combined describe.c
@@@ +98,7 @@@
return (a_date > b_date) ? -1 : (a_date == b_date) ? 0 : 1;
}
- static void describe(char *arg)
- static void describe(struct commit *cmit, int last_one)
++ static void describe(char *arg, int last_one)
{
+ unsigned char sha1[20];
+ struct commit *cmit;
There are a few things to note about this feature:
- The '-c' option implies '-p'. It also implies '-m' halfway
in the sense that "interesting" merges are shown, but not all
merges.
- When a blob matches one of the parents, we do not show a diff
for that path at all. For a merge commit, this option shows
paths with real file-level merge (aka "interesting things").
- As a concequence of the above, an "uninteresting" merge is
not shown at all. You can use '-m' in addition to '-c' to
show the commit log for such a merge, but there will be no
combined diff output.
- Unlike "gitk", the output is monochrome.
A '-' character in the nth column means the line is from the nth
parent and does not appear in the merge result (i.e. removed
from that parent's version).
A '+' character in the nth column means the line appears in the
merge result, and the nth parent does not have that line
(i.e. added by the merge itself or inherited from another
parent).
The above example output shows that the function signature was
changed from either parents (hence two "-" lines and a "++"
line), and "unsigned char sha1[20]", prefixed by a " +", was
inherited from the first parent.
The code as sent to the list was buggy in few corner cases,
which I have fixed since then.
It does not bother to keep track of and show the line numbers
from parent commits, which it probably should.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-01-24 09:22:04 +00:00
|
|
|
}
|
|
|
|
}
|
2005-05-19 20:44:29 +00:00
|
|
|
|
2005-11-22 05:49:06 +00:00
|
|
|
for (parents = commit->parents; parents; parents = parents->next) {
|
|
|
|
struct commit *parent = parents->item;
|
2006-01-27 09:54:59 +00:00
|
|
|
header = generate_header(sha1, parent->object.sha1, commit);
|
2005-11-22 05:49:06 +00:00
|
|
|
diff_tree_sha1_top(parent->object.sha1, commit_sha1, "");
|
2005-05-21 22:42:53 +00:00
|
|
|
if (!header && verbose_header) {
|
2005-05-06 18:42:47 +00:00
|
|
|
header_prefix = "\ndiff-tree ";
|
2005-05-21 22:42:53 +00:00
|
|
|
/*
|
|
|
|
* Don't print multiple merge entries if we
|
|
|
|
* don't print the diffs.
|
|
|
|
*/
|
|
|
|
}
|
2005-05-06 17:03:17 +00:00
|
|
|
}
|
2005-05-18 20:06:47 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int diff_tree_stdin(char *line)
|
|
|
|
{
|
|
|
|
int len = strlen(line);
|
|
|
|
unsigned char commit[20], parent[20];
|
|
|
|
static char this_header[1000];
|
2005-12-14 01:21:41 +00:00
|
|
|
int abbrev = diff_options.abbrev;
|
2005-05-18 20:06:47 +00:00
|
|
|
|
|
|
|
if (!len || line[len-1] != '\n')
|
|
|
|
return -1;
|
|
|
|
line[len-1] = 0;
|
|
|
|
if (get_sha1_hex(line, commit))
|
|
|
|
return -1;
|
|
|
|
if (isspace(line[40]) && !get_sha1_hex(line+41, parent)) {
|
|
|
|
line[40] = 0;
|
|
|
|
line[81] = 0;
|
2005-12-14 01:21:41 +00:00
|
|
|
sprintf(this_header, "%s (from %s)\n",
|
|
|
|
diff_unique_abbrev(commit, abbrev),
|
|
|
|
diff_unique_abbrev(parent, abbrev));
|
2005-05-18 20:06:47 +00:00
|
|
|
header = this_header;
|
2005-05-19 10:32:35 +00:00
|
|
|
return diff_tree_sha1_top(parent, commit, "");
|
2005-05-18 20:06:47 +00:00
|
|
|
}
|
|
|
|
line[40] = 0;
|
2005-11-22 05:49:06 +00:00
|
|
|
return diff_tree_commit(commit);
|
2005-05-06 17:03:17 +00:00
|
|
|
}
|
|
|
|
|
2005-07-29 09:01:26 +00:00
|
|
|
static const char diff_tree_usage[] =
|
2006-01-24 09:22:04 +00:00
|
|
|
"git-diff-tree [--stdin] [-m] [-c] [--cc] [-s] [-v] [--pretty] [-t] [-r] [--root] "
|
2005-10-28 17:04:49 +00:00
|
|
|
"[<common diff options>] <tree-ish> [<tree-ish>] [<path>...]\n"
|
|
|
|
" -r diff recursively\n"
|
|
|
|
" --root include the initial commit as diff against /dev/null\n"
|
2005-07-13 19:52:35 +00:00
|
|
|
COMMON_DIFF_OPTIONS_HELP;
|
2005-06-13 00:44:21 +00:00
|
|
|
|
2005-09-21 07:00:47 +00:00
|
|
|
int main(int argc, const char **argv)
|
2005-04-10 21:03:58 +00:00
|
|
|
{
|
2005-05-18 20:10:17 +00:00
|
|
|
int nr_sha1;
|
2005-05-06 17:03:17 +00:00
|
|
|
char line[1000];
|
2005-05-18 20:10:17 +00:00
|
|
|
unsigned char sha1[2][20];
|
2005-08-17 01:06:34 +00:00
|
|
|
const char *prefix = setup_git_directory();
|
2005-04-10 21:03:58 +00:00
|
|
|
|
2005-11-22 06:52:37 +00:00
|
|
|
git_config(git_diff_config);
|
2005-05-18 20:10:17 +00:00
|
|
|
nr_sha1 = 0;
|
2005-09-21 07:00:47 +00:00
|
|
|
diff_setup(&diff_options);
|
|
|
|
|
2005-04-24 05:08:00 +00:00
|
|
|
for (;;) {
|
2005-09-21 07:00:47 +00:00
|
|
|
int diff_opt_cnt;
|
2005-05-22 17:04:37 +00:00
|
|
|
const char *arg;
|
2005-04-24 05:08:00 +00:00
|
|
|
|
2005-05-06 17:03:17 +00:00
|
|
|
argv++;
|
|
|
|
argc--;
|
|
|
|
arg = *argv;
|
2005-05-18 20:10:17 +00:00
|
|
|
if (!arg)
|
2005-04-24 05:08:00 +00:00
|
|
|
break;
|
|
|
|
|
2005-05-18 20:10:17 +00:00
|
|
|
if (*arg != '-') {
|
|
|
|
if (nr_sha1 < 2 && !get_sha1(arg, sha1[nr_sha1])) {
|
|
|
|
nr_sha1++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-09-21 07:00:47 +00:00
|
|
|
diff_opt_cnt = diff_opt_parse(&diff_options, argv, argc);
|
|
|
|
if (diff_opt_cnt < 0)
|
|
|
|
usage(diff_tree_usage);
|
|
|
|
else if (diff_opt_cnt) {
|
|
|
|
argv += diff_opt_cnt - 1;
|
|
|
|
argc -= diff_opt_cnt - 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-05-18 20:10:17 +00:00
|
|
|
if (!strcmp(arg, "--")) {
|
2005-05-06 17:03:17 +00:00
|
|
|
argv++;
|
|
|
|
argc--;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-11 15:37:17 +00:00
|
|
|
if (!strcmp(arg, "-r")) {
|
2005-10-21 04:05:05 +00:00
|
|
|
diff_options.recursive = 1;
|
2005-04-10 21:03:58 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-05-25 06:24:22 +00:00
|
|
|
if (!strcmp(arg, "-t")) {
|
2005-10-21 04:05:05 +00:00
|
|
|
diff_options.recursive = 1;
|
|
|
|
diff_options.tree_in_recursive = 1;
|
2005-05-25 06:24:22 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-05-06 17:03:17 +00:00
|
|
|
if (!strcmp(arg, "-m")) {
|
|
|
|
ignore_merges = 0;
|
|
|
|
continue;
|
|
|
|
}
|
diff-tree -c: show a merge commit a bit more sensibly.
A new option '-c' to diff-tree changes the way a merge commit is
displayed when generating a patch output. It shows a "combined
diff" (hence the option letter 'c'), which looks like this:
$ git-diff-tree --pretty -c -p fec9ebf1 | head -n 18
diff-tree fec9ebf... (from parents)
Merge: 0620db3... 8a263ae...
Author: Junio C Hamano <junkio@cox.net>
Date: Sun Jan 15 22:25:35 2006 -0800
Merge fixes up to GIT 1.1.3
diff --combined describe.c
@@@ +98,7 @@@
return (a_date > b_date) ? -1 : (a_date == b_date) ? 0 : 1;
}
- static void describe(char *arg)
- static void describe(struct commit *cmit, int last_one)
++ static void describe(char *arg, int last_one)
{
+ unsigned char sha1[20];
+ struct commit *cmit;
There are a few things to note about this feature:
- The '-c' option implies '-p'. It also implies '-m' halfway
in the sense that "interesting" merges are shown, but not all
merges.
- When a blob matches one of the parents, we do not show a diff
for that path at all. For a merge commit, this option shows
paths with real file-level merge (aka "interesting things").
- As a concequence of the above, an "uninteresting" merge is
not shown at all. You can use '-m' in addition to '-c' to
show the commit log for such a merge, but there will be no
combined diff output.
- Unlike "gitk", the output is monochrome.
A '-' character in the nth column means the line is from the nth
parent and does not appear in the merge result (i.e. removed
from that parent's version).
A '+' character in the nth column means the line appears in the
merge result, and the nth parent does not have that line
(i.e. added by the merge itself or inherited from another
parent).
The above example output shows that the function signature was
changed from either parents (hence two "-" lines and a "++"
line), and "unsigned char sha1[20]", prefixed by a " +", was
inherited from the first parent.
The code as sent to the list was buggy in few corner cases,
which I have fixed since then.
It does not bother to keep track of and show the line numbers
from parent commits, which it probably should.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-01-24 09:22:04 +00:00
|
|
|
if (!strcmp(arg, "-c")) {
|
|
|
|
combine_merges = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-01-24 09:22:04 +00:00
|
|
|
if (!strcmp(arg, "--cc")) {
|
|
|
|
dense_combined_merges = combine_merges = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-05-06 18:42:47 +00:00
|
|
|
if (!strcmp(arg, "-v")) {
|
|
|
|
verbose_header = 1;
|
|
|
|
header_prefix = "diff-tree ";
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-13 00:44:21 +00:00
|
|
|
if (!strncmp(arg, "--pretty", 8)) {
|
|
|
|
verbose_header = 1;
|
2005-06-13 03:34:09 +00:00
|
|
|
header_prefix = "diff-tree ";
|
2005-06-13 00:44:21 +00:00
|
|
|
commit_format = get_commit_format(arg+8);
|
|
|
|
continue;
|
|
|
|
}
|
2005-05-06 17:03:17 +00:00
|
|
|
if (!strcmp(arg, "--stdin")) {
|
|
|
|
read_stdin = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-05-19 20:44:29 +00:00
|
|
|
if (!strcmp(arg, "--root")) {
|
|
|
|
show_root_diff = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-11-10 05:30:12 +00:00
|
|
|
if (!strcmp(arg, "--no-commit-id")) {
|
|
|
|
no_commit_id = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2006-02-05 19:42:09 +00:00
|
|
|
if (!strcmp(arg, "--always")) {
|
|
|
|
always_show_header = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-21 02:49:16 +00:00
|
|
|
usage(diff_tree_usage);
|
2005-04-10 21:03:58 +00:00
|
|
|
}
|
2005-09-21 07:00:47 +00:00
|
|
|
if (diff_options.output_format == DIFF_FORMAT_PATCH)
|
2005-10-21 04:05:05 +00:00
|
|
|
diff_options.recursive = 1;
|
2005-04-10 21:03:58 +00:00
|
|
|
|
diff-tree -c: show a merge commit a bit more sensibly.
A new option '-c' to diff-tree changes the way a merge commit is
displayed when generating a patch output. It shows a "combined
diff" (hence the option letter 'c'), which looks like this:
$ git-diff-tree --pretty -c -p fec9ebf1 | head -n 18
diff-tree fec9ebf... (from parents)
Merge: 0620db3... 8a263ae...
Author: Junio C Hamano <junkio@cox.net>
Date: Sun Jan 15 22:25:35 2006 -0800
Merge fixes up to GIT 1.1.3
diff --combined describe.c
@@@ +98,7 @@@
return (a_date > b_date) ? -1 : (a_date == b_date) ? 0 : 1;
}
- static void describe(char *arg)
- static void describe(struct commit *cmit, int last_one)
++ static void describe(char *arg, int last_one)
{
+ unsigned char sha1[20];
+ struct commit *cmit;
There are a few things to note about this feature:
- The '-c' option implies '-p'. It also implies '-m' halfway
in the sense that "interesting" merges are shown, but not all
merges.
- When a blob matches one of the parents, we do not show a diff
for that path at all. For a merge commit, this option shows
paths with real file-level merge (aka "interesting things").
- As a concequence of the above, an "uninteresting" merge is
not shown at all. You can use '-m' in addition to '-c' to
show the commit log for such a merge, but there will be no
combined diff output.
- Unlike "gitk", the output is monochrome.
A '-' character in the nth column means the line is from the nth
parent and does not appear in the merge result (i.e. removed
from that parent's version).
A '+' character in the nth column means the line appears in the
merge result, and the nth parent does not have that line
(i.e. added by the merge itself or inherited from another
parent).
The above example output shows that the function signature was
changed from either parents (hence two "-" lines and a "++"
line), and "unsigned char sha1[20]", prefixed by a " +", was
inherited from the first parent.
The code as sent to the list was buggy in few corner cases,
which I have fixed since then.
It does not bother to keep track of and show the line numbers
from parent commits, which it probably should.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-01-24 09:22:04 +00:00
|
|
|
if (combine_merges) {
|
|
|
|
diff_options.output_format = DIFF_FORMAT_PATCH;
|
|
|
|
ignore_merges = 0;
|
|
|
|
}
|
|
|
|
|
2005-10-21 04:05:05 +00:00
|
|
|
diff_tree_setup_paths(get_pathspec(prefix, argv));
|
2005-12-14 01:21:41 +00:00
|
|
|
diff_setup_done(&diff_options);
|
2005-04-24 05:08:00 +00:00
|
|
|
|
2005-05-18 20:10:17 +00:00
|
|
|
switch (nr_sha1) {
|
|
|
|
case 0:
|
|
|
|
if (!read_stdin)
|
|
|
|
usage(diff_tree_usage);
|
|
|
|
break;
|
|
|
|
case 1:
|
2005-11-22 05:49:06 +00:00
|
|
|
diff_tree_commit(sha1[0]);
|
2005-05-18 20:10:17 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2005-05-19 10:32:35 +00:00
|
|
|
diff_tree_sha1_top(sha1[0], sha1[1], "");
|
2005-05-18 20:10:17 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-05-06 17:03:17 +00:00
|
|
|
if (!read_stdin)
|
2005-05-18 20:10:17 +00:00
|
|
|
return 0;
|
2005-05-06 17:03:17 +00:00
|
|
|
|
2005-09-21 07:00:47 +00:00
|
|
|
if (diff_options.detect_rename)
|
|
|
|
diff_options.setup |= (DIFF_SETUP_USE_SIZE_CACHE |
|
|
|
|
DIFF_SETUP_USE_CACHE);
|
2005-05-06 17:03:17 +00:00
|
|
|
while (fgets(line, sizeof(line), stdin))
|
|
|
|
diff_tree_stdin(line);
|
|
|
|
|
|
|
|
return 0;
|
2005-04-09 20:00:54 +00:00
|
|
|
}
|