2005-04-26 16:25:05 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2005 Junio C Hamano
|
|
|
|
|
*/
|
2005-04-26 01:22:47 +00:00
|
|
|
#ifndef DIFF_H
|
|
|
|
|
#define DIFF_H
|
|
|
|
|
|
2006-03-30 06:55:43 +00:00
|
|
|
#include "tree-walk.h"
|
2006-01-31 22:10:56 +00:00
|
|
|
|
Log message printout cleanups
On Sun, 16 Apr 2006, Junio C Hamano wrote:
>
> In the mid-term, I am hoping we can drop the generate_header()
> callchain _and_ the custom code that formats commit log in-core,
> found in cmd_log_wc().
Ok, this was nastier than expected, just because the dependencies between
the different log-printing stuff were absolutely _everywhere_, but here's
a patch that does exactly that.
The patch is not very easy to read, and the "--patch-with-stat" thing is
still broken (it does not call the "show_log()" thing properly for
merges). That's not a new bug. In the new world order it _should_ do
something like
if (rev->logopt)
show_log(rev, rev->logopt, "---\n");
but it doesn't. I haven't looked at the --with-stat logic, so I left it
alone.
That said, this patch removes more lines than it adds, and in particular,
the "cmd_log_wc()" loop is now a very clean:
while ((commit = get_revision(rev)) != NULL) {
log_tree_commit(rev, commit);
free(commit->buffer);
commit->buffer = NULL;
}
so it doesn't get much prettier than this. All the complexity is entirely
hidden in log-tree.c, and any code that needs to flush the log literally
just needs to do the "if (rev->logopt) show_log(...)" incantation.
I had to make the combined_diff() logic take a "struct rev_info" instead
of just a "struct diff_options", but that part is pretty clean.
This does change "git whatchanged" from using "diff-tree" as the commit
descriptor to "commit", and I changed one of the tests to reflect that new
reality. Otherwise everything still passes, and my other tests look fine
too.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-17 18:59:32 +00:00
|
|
|
struct rev_info;
|
2005-10-21 04:05:05 +00:00
|
|
|
struct diff_options;
|
2006-09-07 06:35:42 +00:00
|
|
|
struct diff_queue_struct;
|
2005-10-21 04:05:05 +00:00
|
|
|
|
|
|
|
|
typedef void (*change_fn_t)(struct diff_options *options,
|
|
|
|
|
unsigned old_mode, unsigned new_mode,
|
|
|
|
|
const unsigned char *old_sha1,
|
|
|
|
|
const unsigned char *new_sha1,
|
|
|
|
|
const char *base, const char *path);
|
|
|
|
|
|
|
|
|
|
typedef void (*add_remove_fn_t)(struct diff_options *options,
|
|
|
|
|
int addremove, unsigned mode,
|
|
|
|
|
const unsigned char *sha1,
|
|
|
|
|
const char *base, const char *path);
|
|
|
|
|
|
2006-09-07 06:35:42 +00:00
|
|
|
typedef void (*diff_format_fn_t)(struct diff_queue_struct *q,
|
|
|
|
|
struct diff_options *options, void *data);
|
|
|
|
|
|
2006-06-24 17:21:53 +00:00
|
|
|
#define DIFF_FORMAT_RAW 0x0001
|
|
|
|
|
#define DIFF_FORMAT_DIFFSTAT 0x0002
|
2006-10-12 10:01:00 +00:00
|
|
|
#define DIFF_FORMAT_NUMSTAT 0x0004
|
|
|
|
|
#define DIFF_FORMAT_SUMMARY 0x0008
|
|
|
|
|
#define DIFF_FORMAT_PATCH 0x0010
|
2006-12-15 04:15:44 +00:00
|
|
|
#define DIFF_FORMAT_SHORTSTAT 0x0020
|
2006-06-24 17:21:53 +00:00
|
|
|
|
|
|
|
|
/* These override all above */
|
2006-10-12 10:01:00 +00:00
|
|
|
#define DIFF_FORMAT_NAME 0x0100
|
|
|
|
|
#define DIFF_FORMAT_NAME_STATUS 0x0200
|
|
|
|
|
#define DIFF_FORMAT_CHECKDIFF 0x0400
|
2006-06-24 17:21:53 +00:00
|
|
|
|
|
|
|
|
/* Same as output_format = 0 but we know that -s flag was given
|
|
|
|
|
* and we should not give default value to output_format.
|
|
|
|
|
*/
|
2006-10-12 10:01:00 +00:00
|
|
|
#define DIFF_FORMAT_NO_OUTPUT 0x0800
|
2006-06-24 17:21:53 +00:00
|
|
|
|
2006-10-12 10:01:00 +00:00
|
|
|
#define DIFF_FORMAT_CALLBACK 0x1000
|
2006-09-07 06:35:42 +00:00
|
|
|
|
2007-11-10 19:05:14 +00:00
|
|
|
#define DIFF_OPT_RECURSIVE (1 << 0)
|
|
|
|
|
#define DIFF_OPT_TREE_IN_RECURSIVE (1 << 1)
|
|
|
|
|
#define DIFF_OPT_BINARY (1 << 2)
|
|
|
|
|
#define DIFF_OPT_TEXT (1 << 3)
|
|
|
|
|
#define DIFF_OPT_FULL_INDEX (1 << 4)
|
|
|
|
|
#define DIFF_OPT_SILENT_ON_REMOVE (1 << 5)
|
|
|
|
|
#define DIFF_OPT_FIND_COPIES_HARDER (1 << 6)
|
|
|
|
|
#define DIFF_OPT_FOLLOW_RENAMES (1 << 7)
|
|
|
|
|
#define DIFF_OPT_COLOR_DIFF (1 << 8)
|
|
|
|
|
#define DIFF_OPT_COLOR_DIFF_WORDS (1 << 9)
|
|
|
|
|
#define DIFF_OPT_HAS_CHANGES (1 << 10)
|
|
|
|
|
#define DIFF_OPT_QUIET (1 << 11)
|
|
|
|
|
#define DIFF_OPT_NO_INDEX (1 << 12)
|
|
|
|
|
#define DIFF_OPT_ALLOW_EXTERNAL (1 << 13)
|
|
|
|
|
#define DIFF_OPT_EXIT_WITH_STATUS (1 << 14)
|
|
|
|
|
#define DIFF_OPT_REVERSE_DIFF (1 << 15)
|
|
|
|
|
#define DIFF_OPT_TST(opts, flag) ((opts)->flags & DIFF_OPT_##flag)
|
|
|
|
|
#define DIFF_OPT_SET(opts, flag) ((opts)->flags |= DIFF_OPT_##flag)
|
|
|
|
|
#define DIFF_OPT_CLR(opts, flag) ((opts)->flags &= ~DIFF_OPT_##flag)
|
|
|
|
|
|
2005-09-21 07:00:47 +00:00
|
|
|
struct diff_options {
|
|
|
|
|
const char *filter;
|
|
|
|
|
const char *orderfile;
|
|
|
|
|
const char *pickaxe;
|
2006-11-02 08:02:11 +00:00
|
|
|
const char *single_follow;
|
2007-11-10 19:05:14 +00:00
|
|
|
unsigned flags;
|
2006-05-13 20:23:48 +00:00
|
|
|
int context;
|
2005-09-21 07:00:47 +00:00
|
|
|
int break_opt;
|
|
|
|
|
int detect_rename;
|
git-diff: squelch "empty" diffs
After starting to edit a working tree file but later when your edit ends
up identical to the original (this can also happen when you ran a
wholesale regexp replace with something like "perl -i" that does not
actually modify many of the paths), "git diff" between the index and the
working tree outputs many "empty" diffs that show "diff --git" headers
and nothing else, because these paths are stat-dirty. While it was a
way to warn the user that the earlier action of the user made the index
ineffective as an optimization mechanism, it was felt too loud for the
purpose of warning even to experienced users, and also resulted in
confusing people new to git.
This replaces the "empty" diffs with a single warning message at the
end. Having many such paths hurts performance, and you can run
"git-update-index --refresh" to update the lstat(2) information recorded
in the index in such a case. "git-status" does so as a side effect, and
that is more familiar to the end-user, so we recommend it to them.
The change affects only "git diff" that outputs patch text, because that
is where the annoyance of too many "empty" diff is most strongly felt,
and because the warning message can be safely ignored by downstream
tools without getting mistaken as part of the patch. For the low-level
"git diff-files" and "git diff-index", the traditional behaviour is
retained.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-03 20:33:31 +00:00
|
|
|
int skip_stat_unmatch;
|
2005-09-21 07:00:47 +00:00
|
|
|
int line_termination;
|
|
|
|
|
int output_format;
|
|
|
|
|
int pickaxe_opts;
|
|
|
|
|
int rename_score;
|
2005-09-21 07:18:27 +00:00
|
|
|
int rename_limit;
|
2005-09-21 07:00:47 +00:00
|
|
|
int setup;
|
2005-12-14 01:21:41 +00:00
|
|
|
int abbrev;
|
2006-06-25 10:54:14 +00:00
|
|
|
const char *msg_sep;
|
2006-05-20 13:40:29 +00:00
|
|
|
const char *stat_sep;
|
2006-06-14 15:40:23 +00:00
|
|
|
long xdl_opts;
|
2005-10-21 04:05:05 +00:00
|
|
|
|
2006-09-27 01:53:02 +00:00
|
|
|
int stat_width;
|
|
|
|
|
int stat_name_width;
|
|
|
|
|
|
2007-02-25 22:34:54 +00:00
|
|
|
/* this is set by diffcore for DIFF_FORMAT_PATCH */
|
|
|
|
|
int found_changes;
|
|
|
|
|
|
2006-04-10 23:39:11 +00:00
|
|
|
int nr_paths;
|
|
|
|
|
const char **paths;
|
|
|
|
|
int *pathlens;
|
2005-10-21 04:05:05 +00:00
|
|
|
change_fn_t change;
|
|
|
|
|
add_remove_fn_t add_remove;
|
2006-09-07 06:35:42 +00:00
|
|
|
diff_format_fn_t format_callback;
|
|
|
|
|
void *format_callback_data;
|
2005-09-21 07:00:47 +00:00
|
|
|
};
|
|
|
|
|
|
2006-07-23 09:24:18 +00:00
|
|
|
enum color_diff {
|
|
|
|
|
DIFF_RESET = 0,
|
|
|
|
|
DIFF_PLAIN = 1,
|
|
|
|
|
DIFF_METAINFO = 2,
|
|
|
|
|
DIFF_FRAGINFO = 3,
|
|
|
|
|
DIFF_FILE_OLD = 4,
|
|
|
|
|
DIFF_FILE_NEW = 5,
|
|
|
|
|
DIFF_COMMIT = 6,
|
2006-09-23 05:48:39 +00:00
|
|
|
DIFF_WHITESPACE = 7,
|
2006-07-23 09:24:18 +00:00
|
|
|
};
|
|
|
|
|
const char *diff_get_color(int diff_use_color, enum color_diff ix);
|
2007-11-10 19:05:14 +00:00
|
|
|
#define diff_get_color_opt(o, ix) \
|
|
|
|
|
diff_get_color(DIFF_OPT_TST((o), COLOR_DIFF), ix)
|
|
|
|
|
|
2006-07-23 09:24:18 +00:00
|
|
|
|
2006-05-20 13:40:29 +00:00
|
|
|
extern const char mime_boundary_leader[];
|
|
|
|
|
|
2006-04-10 23:39:11 +00:00
|
|
|
extern void diff_tree_setup_paths(const char **paths, struct diff_options *);
|
|
|
|
|
extern void diff_tree_release_paths(struct diff_options *);
|
2005-10-21 04:05:05 +00:00
|
|
|
extern int diff_tree(struct tree_desc *t1, struct tree_desc *t2,
|
|
|
|
|
const char *base, struct diff_options *opt);
|
|
|
|
|
extern int diff_tree_sha1(const unsigned char *old, const unsigned char *new,
|
|
|
|
|
const char *base, struct diff_options *opt);
|
2006-10-26 16:52:39 +00:00
|
|
|
extern int diff_root_tree_sha1(const unsigned char *new, const char *base,
|
|
|
|
|
struct diff_options *opt);
|
2005-10-21 04:05:05 +00:00
|
|
|
|
2006-01-28 08:03:38 +00:00
|
|
|
struct combine_diff_path {
|
|
|
|
|
struct combine_diff_path *next;
|
|
|
|
|
int len;
|
|
|
|
|
char *path;
|
2006-02-06 20:53:07 +00:00
|
|
|
unsigned int mode;
|
2006-01-28 08:03:38 +00:00
|
|
|
unsigned char sha1[20];
|
2006-02-06 20:53:07 +00:00
|
|
|
struct combine_diff_parent {
|
2006-02-10 10:30:52 +00:00
|
|
|
char status;
|
2006-02-06 20:53:07 +00:00
|
|
|
unsigned int mode;
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
} parent[FLEX_ARRAY];
|
2006-01-28 08:03:38 +00:00
|
|
|
};
|
2006-02-06 20:53:07 +00:00
|
|
|
#define combine_diff_path_size(n, l) \
|
|
|
|
|
(sizeof(struct combine_diff_path) + \
|
|
|
|
|
sizeof(struct combine_diff_parent) * (n) + (l) + 1)
|
2006-01-28 08:03:38 +00:00
|
|
|
|
Log message printout cleanups
On Sun, 16 Apr 2006, Junio C Hamano wrote:
>
> In the mid-term, I am hoping we can drop the generate_header()
> callchain _and_ the custom code that formats commit log in-core,
> found in cmd_log_wc().
Ok, this was nastier than expected, just because the dependencies between
the different log-printing stuff were absolutely _everywhere_, but here's
a patch that does exactly that.
The patch is not very easy to read, and the "--patch-with-stat" thing is
still broken (it does not call the "show_log()" thing properly for
merges). That's not a new bug. In the new world order it _should_ do
something like
if (rev->logopt)
show_log(rev, rev->logopt, "---\n");
but it doesn't. I haven't looked at the --with-stat logic, so I left it
alone.
That said, this patch removes more lines than it adds, and in particular,
the "cmd_log_wc()" loop is now a very clean:
while ((commit = get_revision(rev)) != NULL) {
log_tree_commit(rev, commit);
free(commit->buffer);
commit->buffer = NULL;
}
so it doesn't get much prettier than this. All the complexity is entirely
hidden in log-tree.c, and any code that needs to flush the log literally
just needs to do the "if (rev->logopt) show_log(...)" incantation.
I had to make the combined_diff() logic take a "struct rev_info" instead
of just a "struct diff_options", but that part is pretty clean.
This does change "git whatchanged" from using "diff-tree" as the commit
descriptor to "commit", and I changed one of the tests to reflect that new
reality. Otherwise everything still passes, and my other tests look fine
too.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-17 18:59:32 +00:00
|
|
|
extern void show_combined_diff(struct combine_diff_path *elem, int num_parent,
|
|
|
|
|
int dense, struct rev_info *);
|
2006-01-28 08:03:38 +00:00
|
|
|
|
2006-04-29 08:24:49 +00:00
|
|
|
extern void diff_tree_combined(const unsigned char *sha1, const unsigned char parent[][20], int num_parent, int dense, struct rev_info *rev);
|
|
|
|
|
|
Log message printout cleanups
On Sun, 16 Apr 2006, Junio C Hamano wrote:
>
> In the mid-term, I am hoping we can drop the generate_header()
> callchain _and_ the custom code that formats commit log in-core,
> found in cmd_log_wc().
Ok, this was nastier than expected, just because the dependencies between
the different log-printing stuff were absolutely _everywhere_, but here's
a patch that does exactly that.
The patch is not very easy to read, and the "--patch-with-stat" thing is
still broken (it does not call the "show_log()" thing properly for
merges). That's not a new bug. In the new world order it _should_ do
something like
if (rev->logopt)
show_log(rev, rev->logopt, "---\n");
but it doesn't. I haven't looked at the --with-stat logic, so I left it
alone.
That said, this patch removes more lines than it adds, and in particular,
the "cmd_log_wc()" loop is now a very clean:
while ((commit = get_revision(rev)) != NULL) {
log_tree_commit(rev, commit);
free(commit->buffer);
commit->buffer = NULL;
}
so it doesn't get much prettier than this. All the complexity is entirely
hidden in log-tree.c, and any code that needs to flush the log literally
just needs to do the "if (rev->logopt) show_log(...)" incantation.
I had to make the combined_diff() logic take a "struct rev_info" instead
of just a "struct diff_options", but that part is pretty clean.
This does change "git whatchanged" from using "diff-tree" as the commit
descriptor to "commit", and I changed one of the tests to reflect that new
reality. Otherwise everything still passes, and my other tests look fine
too.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-17 18:59:32 +00:00
|
|
|
extern void diff_tree_combined_merge(const unsigned char *sha1, int, struct rev_info *);
|
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-09-21 07:00:47 +00:00
|
|
|
extern void diff_addremove(struct diff_options *,
|
|
|
|
|
int addremove,
|
2005-04-27 16:21:00 +00:00
|
|
|
unsigned mode,
|
|
|
|
|
const unsigned char *sha1,
|
|
|
|
|
const char *base,
|
|
|
|
|
const char *path);
|
|
|
|
|
|
2005-09-21 07:00:47 +00:00
|
|
|
extern void diff_change(struct diff_options *,
|
|
|
|
|
unsigned mode1, unsigned mode2,
|
|
|
|
|
const unsigned char *sha1,
|
|
|
|
|
const unsigned char *sha2,
|
|
|
|
|
const char *base, const char *path);
|
2005-04-27 16:21:00 +00:00
|
|
|
|
2005-09-21 07:00:47 +00:00
|
|
|
extern void diff_unmerge(struct diff_options *,
|
2007-01-05 09:25:18 +00:00
|
|
|
const char *path,
|
|
|
|
|
unsigned mode,
|
|
|
|
|
const unsigned char *sha1);
|
2005-04-27 16:21:00 +00:00
|
|
|
|
2005-05-27 22:54:37 +00:00
|
|
|
#define DIFF_SETUP_REVERSE 1
|
2005-05-27 22:56:38 +00:00
|
|
|
#define DIFF_SETUP_USE_CACHE 2
|
|
|
|
|
#define DIFF_SETUP_USE_SIZE_CACHE 4
|
2005-06-03 08:36:43 +00:00
|
|
|
|
2006-07-08 08:05:16 +00:00
|
|
|
extern int git_diff_ui_config(const char *var, const char *value);
|
2005-09-21 07:00:47 +00:00
|
|
|
extern void diff_setup(struct diff_options *);
|
|
|
|
|
extern int diff_opt_parse(struct diff_options *, const char **, int);
|
|
|
|
|
extern int diff_setup_done(struct diff_options *);
|
2005-04-26 01:22:47 +00:00
|
|
|
|
2005-05-22 17:04:37 +00:00
|
|
|
#define DIFF_DETECT_RENAME 1
|
|
|
|
|
#define DIFF_DETECT_COPY 2
|
|
|
|
|
|
2005-05-27 22:55:28 +00:00
|
|
|
#define DIFF_PICKAXE_ALL 1
|
2006-03-29 00:16:33 +00:00
|
|
|
#define DIFF_PICKAXE_REGEX 2
|
[PATCH] Add -B flag to diff-* brothers.
A new diffcore transformation, diffcore-break.c, is introduced.
When the -B flag is given, a patch that represents a complete
rewrite is broken into a deletion followed by a creation. This
makes it easier to review such a complete rewrite patch.
The -B flag takes the same syntax as the -M and -C flags to
specify the minimum amount of non-source material the resulting
file needs to have to be considered a complete rewrite, and
defaults to 99% if not specified.
As the new test t4008-diff-break-rewrite.sh demonstrates, if a
file is a complete rewrite, it is broken into a delete/create
pair, which can further be subjected to the usual rename
detection if -M or -C is used. For example, if file0 gets
completely rewritten to make it as if it were rather based on
file1 which itself disappeared, the following happens:
The original change looks like this:
file0 --> file0' (quite different from file0)
file1 --> /dev/null
After diffcore-break runs, it would become this:
file0 --> /dev/null
/dev/null --> file0'
file1 --> /dev/null
Then diffcore-rename matches them up:
file1 --> file0'
The internal score values are finer grained now. Earlier
maximum of 10000 has been raised to 60000; there is no user
visible changes but there is no reason to waste available bits.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-05-30 07:08:37 +00:00
|
|
|
|
2005-09-21 07:00:47 +00:00
|
|
|
extern void diffcore_std(struct diff_options *);
|
2005-06-12 03:57:13 +00:00
|
|
|
|
2005-07-13 19:52:35 +00:00
|
|
|
#define COMMON_DIFF_OPTIONS_HELP \
|
|
|
|
|
"\ncommon diff options:\n" \
|
2005-09-21 07:18:27 +00:00
|
|
|
" -z output diff-raw with lines terminated with NUL.\n" \
|
|
|
|
|
" -p output patch format.\n" \
|
|
|
|
|
" -u synonym for -p.\n" \
|
2006-04-11 11:22:17 +00:00
|
|
|
" --patch-with-raw\n" \
|
|
|
|
|
" output both a patch and the diff-raw format.\n" \
|
2006-04-13 22:15:30 +00:00
|
|
|
" --stat show diffstat instead of patch.\n" \
|
2006-10-12 10:01:00 +00:00
|
|
|
" --numstat show numeric diffstat instead of patch.\n" \
|
2006-04-15 11:41:18 +00:00
|
|
|
" --patch-with-stat\n" \
|
|
|
|
|
" output a patch and prepend its diffstat.\n" \
|
2005-09-21 07:18:27 +00:00
|
|
|
" --name-only show only names of changed files.\n" \
|
2005-09-21 07:20:06 +00:00
|
|
|
" --name-status show names and status of changed files.\n" \
|
2005-12-14 01:21:41 +00:00
|
|
|
" --full-index show full object name on index lines.\n" \
|
2005-12-18 10:03:15 +00:00
|
|
|
" --abbrev=<n> abbreviate object names in diff-tree header and diff-raw.\n" \
|
2005-09-21 07:18:27 +00:00
|
|
|
" -R swap input file pairs.\n" \
|
|
|
|
|
" -B detect complete rewrites.\n" \
|
|
|
|
|
" -M detect renames.\n" \
|
|
|
|
|
" -C detect copies.\n" \
|
2005-07-13 19:52:35 +00:00
|
|
|
" --find-copies-harder\n" \
|
2005-09-21 07:18:27 +00:00
|
|
|
" try unchanged files as candidate for copy detection.\n" \
|
|
|
|
|
" -l<n> limit rename attempts up to <n> paths.\n" \
|
|
|
|
|
" -O<file> reorder diffs according to the <file>.\n" \
|
|
|
|
|
" -S<string> find filepair whose only one side contains the string.\n" \
|
2005-07-13 19:52:35 +00:00
|
|
|
" --pickaxe-all\n" \
|
2006-07-07 13:57:08 +00:00
|
|
|
" show all files diff when -S is used and hit is found.\n" \
|
|
|
|
|
" -a --text treat all files as text.\n"
|
2005-07-13 19:52:35 +00:00
|
|
|
|
2005-05-22 02:40:36 +00:00
|
|
|
extern int diff_queue_is_empty(void);
|
2005-09-21 07:00:47 +00:00
|
|
|
extern void diff_flush(struct diff_options*);
|
2005-04-26 01:22:47 +00:00
|
|
|
|
2005-07-25 20:05:44 +00:00
|
|
|
/* diff-raw status letters */
|
2005-07-25 21:31:19 +00:00
|
|
|
#define DIFF_STATUS_ADDED 'A'
|
2005-07-25 20:05:44 +00:00
|
|
|
#define DIFF_STATUS_COPIED 'C'
|
|
|
|
|
#define DIFF_STATUS_DELETED 'D'
|
|
|
|
|
#define DIFF_STATUS_MODIFIED 'M'
|
|
|
|
|
#define DIFF_STATUS_RENAMED 'R'
|
|
|
|
|
#define DIFF_STATUS_TYPE_CHANGED 'T'
|
|
|
|
|
#define DIFF_STATUS_UNKNOWN 'X'
|
|
|
|
|
#define DIFF_STATUS_UNMERGED 'U'
|
|
|
|
|
|
|
|
|
|
/* these are not diff-raw status letters proper, but used by
|
|
|
|
|
* diffcore-filter insn to specify additional restrictions.
|
|
|
|
|
*/
|
2005-10-05 00:44:17 +00:00
|
|
|
#define DIFF_STATUS_FILTER_AON '*'
|
2005-07-25 20:05:44 +00:00
|
|
|
#define DIFF_STATUS_FILTER_BROKEN 'B'
|
|
|
|
|
|
2005-12-14 01:21:41 +00:00
|
|
|
extern const char *diff_unique_abbrev(const unsigned char *, int);
|
|
|
|
|
|
2007-11-10 08:15:03 +00:00
|
|
|
/* do not report anything on removed paths */
|
|
|
|
|
#define DIFF_SILENT_ON_REMOVED 01
|
git-add: make the entry stat-clean after re-adding the same contents
Earlier in commit 0781b8a9b2fe760fc4ed519a3a26e4b9bd6ccffe
(add_file_to_index: skip rehashing if the cached stat already
matches), add_file_to_index() were taught not to re-add the path
if it already matches the index.
The change meant well, but was not executed quite right. It
used ie_modified() to see if the file on the work tree is really
different from the index, and skipped adding the contents if the
function says "not modified".
This was wrong. There are three possible comparison results
between the index and the file in the work tree:
- with lstat(2) we _know_ they are different. E.g. if the
length or the owner in the cached stat information is
different from the length we just obtained from lstat(2), we
can tell the file is modified without looking at the actual
contents.
- with lstat(2) we _know_ they are the same. The same length,
the same owner, the same everything (but this has a twist, as
described below).
- we cannot tell from lstat(2) information alone and need to go
to the filesystem to actually compare.
The last case arises from what we call 'racy git' situation,
that can be caused with this sequence:
$ echo hello >file
$ git add file
$ echo aeiou >file ;# the same length
If the second "echo" is done within the same filesystem
timestamp granularity as the first "echo", then the timestamp
recorded by "git add" and the timestamp we get from lstat(2)
will be the same, and we can mistakenly say the file is not
modified. The path is called 'racily clean'. We need to
reliably detect racily clean paths are in fact modified.
To solve this problem, when we write out the index, we mark the
index entry that has the same timestamp as the index file itself
(that is the time from the point of view of the filesystem) to
tell any later code that does the lstat(2) comparison not to
trust the cached stat info, and ie_modified() then actually goes
to the filesystem to compare the contents for such a path.
That's all good, but it should not be used for this "git add"
optimization, as the goal of "git add" is to actually update the
path in the index and make it stat-clean. With the false
optimization, we did _not_ cause any data loss (after all, what
we failed to do was only to update the cached stat information),
but it made the following sequence leave the file stat dirty:
$ echo hello >file
$ git add file
$ echo hello >file ;# the same contents
$ git add file
The solution is not to use ie_modified() which goes to the
filesystem to see if it is really clean, but instead use
ie_match_stat() with "assume racily clean paths are dirty"
option, to force re-adding of such a path.
There was another problem with "git add -u". The codepath
shares the same issue when adding the paths that are found to be
modified, but in addition, it asked "git diff-files" machinery
run_diff_files() function (which is "git diff-files") to list
the paths that are modified. But "git diff-files" machinery
uses the same ie_modified() call so that it does not report
racily clean _and_ actually clean paths as modified, which is
not what we want.
The patch allows the callers of run_diff_files() to pass the
same "assume racily clean paths are dirty" option, and makes
"git-add -u" codepath to use that option, to discover and re-add
racily clean _and_ actually clean paths.
We could further optimize on top of this patch to differentiate
the case where the path really needs re-adding (i.e. the content
of the racily clean entry was indeed different) and the case
where only the cached stat information needs to be refreshed
(i.e. the racily clean entry was actually clean), but I do not
think it is worth it.
This patch applies to maint and all the way up.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-10 02:22:52 +00:00
|
|
|
/* report racily-clean paths as modified */
|
|
|
|
|
#define DIFF_RACY_IS_MODIFIED 02
|
2007-11-10 08:15:03 +00:00
|
|
|
extern int run_diff_files(struct rev_info *revs, unsigned int option);
|
2007-02-25 22:35:27 +00:00
|
|
|
extern int setup_diff_no_index(struct rev_info *revs,
|
|
|
|
|
int argc, const char ** argv, int nongit, const char *prefix);
|
2007-02-22 20:50:10 +00:00
|
|
|
extern int run_diff_files_cmd(struct rev_info *revs, int argc, const char **argv);
|
2006-04-22 06:57:45 +00:00
|
|
|
|
2006-04-22 10:58:04 +00:00
|
|
|
extern int run_diff_index(struct rev_info *revs, int cached);
|
2006-04-22 09:43:00 +00:00
|
|
|
|
2007-01-30 09:11:08 +00:00
|
|
|
extern int do_diff_cache(const unsigned char *, struct diff_options *);
|
2006-06-25 01:51:08 +00:00
|
|
|
extern int diff_flush_patch_id(struct diff_options *, unsigned char *);
|
|
|
|
|
|
2005-04-26 01:22:47 +00:00
|
|
|
#endif /* DIFF_H */
|