mirror of
https://github.com/git/git.git
synced 2024-11-24 10:26:17 +08:00
122aa6f9c0
The "diff" gitattribute is somewhat overloaded right now. It
can say one of three things:
1. this file is definitely binary, or definitely not
(i.e., diff or !diff)
2. this file should use an external diff engine (i.e.,
diff=foo, diff.foo.command = custom-script)
3. this file should use particular funcname patterns
(i.e., diff=foo, diff.foo.(x?)funcname = some-regex)
Most of the time, there is no conflict between these uses,
since using one implies that the other is irrelevant (e.g.,
an external diff engine will decide for itself whether the
file is binary).
However, there is at least one conflicting situation: there
is no way to say "use the regular rules to determine whether
this file is binary, but if we do diff it textually, use
this funcname pattern." That is, currently setting diff=foo
indicates that the file is definitely text.
This patch introduces a "binary" config option for a diff
driver, so that one can explicitly set diff.foo.binary. We
default this value to "don't know". That is, setting a diff
attribute to "foo" and using "diff.foo.funcname" will have
no effect on the binaryness of a file. To get the current
behavior, one can set diff.foo.binary to true.
This patch also has one additional advantage: it cleans up
the interface to the userdiff code a bit. Before, calling
code had to know more about whether attributes were false,
true, or unset to determine binaryness. Now that binaryness
is a property of a driver, we can represent these situations
just by passing back a driver struct.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
125 lines
4.0 KiB
C
125 lines
4.0 KiB
C
/*
|
|
* Copyright (C) 2005 Junio C Hamano
|
|
*/
|
|
#ifndef DIFFCORE_H
|
|
#define DIFFCORE_H
|
|
|
|
/* This header file is internal between diff.c and its diff transformers
|
|
* (e.g. diffcore-rename, diffcore-pickaxe). Never include this header
|
|
* in anything else.
|
|
*/
|
|
|
|
/* We internally use unsigned short as the score value,
|
|
* and rely on an int capable to hold 32-bits. -B can take
|
|
* -Bmerge_score/break_score format and the two scores are
|
|
* passed around in one int (high 16-bit for merge and low 16-bit
|
|
* for break).
|
|
*/
|
|
#define MAX_SCORE 60000.0
|
|
#define DEFAULT_RENAME_SCORE 30000 /* rename/copy similarity minimum (50%) */
|
|
#define DEFAULT_BREAK_SCORE 30000 /* minimum for break to happen (50%) */
|
|
#define DEFAULT_MERGE_SCORE 36000 /* maximum for break-merge to happen 60%) */
|
|
|
|
#define MINIMUM_BREAK_SIZE 400 /* do not break a file smaller than this */
|
|
|
|
struct userdiff_driver;
|
|
|
|
struct diff_filespec {
|
|
unsigned char sha1[20];
|
|
char *path;
|
|
void *data;
|
|
void *cnt_data;
|
|
const char *funcname_pattern_ident;
|
|
unsigned long size;
|
|
int count; /* Reference count */
|
|
int xfrm_flags; /* for use by the xfrm */
|
|
int rename_used; /* Count of rename users */
|
|
unsigned short mode; /* file mode */
|
|
unsigned sha1_valid : 1; /* if true, use sha1 and trust mode;
|
|
* if false, use the name and read from
|
|
* the filesystem.
|
|
*/
|
|
#define DIFF_FILE_VALID(spec) (((spec)->mode) != 0)
|
|
unsigned should_free : 1; /* data should be free()'ed */
|
|
unsigned should_munmap : 1; /* data should be munmap()'ed */
|
|
|
|
struct userdiff_driver *driver;
|
|
/* data should be considered "binary"; -1 means "don't know yet" */
|
|
int is_binary;
|
|
};
|
|
|
|
extern struct diff_filespec *alloc_filespec(const char *);
|
|
extern void free_filespec(struct diff_filespec *);
|
|
extern void fill_filespec(struct diff_filespec *, const unsigned char *,
|
|
unsigned short);
|
|
|
|
extern int diff_populate_filespec(struct diff_filespec *, int);
|
|
extern void diff_free_filespec_data(struct diff_filespec *);
|
|
extern void diff_free_filespec_blob(struct diff_filespec *);
|
|
extern int diff_filespec_is_binary(struct diff_filespec *);
|
|
|
|
struct diff_filepair {
|
|
struct diff_filespec *one;
|
|
struct diff_filespec *two;
|
|
unsigned short int score;
|
|
char status; /* M C R N D U (see Documentation/diff-format.txt) */
|
|
unsigned broken_pair : 1;
|
|
unsigned renamed_pair : 1;
|
|
unsigned is_unmerged : 1;
|
|
};
|
|
#define DIFF_PAIR_UNMERGED(p) ((p)->is_unmerged)
|
|
|
|
#define DIFF_PAIR_RENAME(p) ((p)->renamed_pair)
|
|
|
|
#define DIFF_PAIR_BROKEN(p) \
|
|
( (!DIFF_FILE_VALID((p)->one) != !DIFF_FILE_VALID((p)->two)) && \
|
|
((p)->broken_pair != 0) )
|
|
|
|
#define DIFF_PAIR_TYPE_CHANGED(p) \
|
|
((S_IFMT & (p)->one->mode) != (S_IFMT & (p)->two->mode))
|
|
|
|
#define DIFF_PAIR_MODE_CHANGED(p) ((p)->one->mode != (p)->two->mode)
|
|
|
|
extern void diff_free_filepair(struct diff_filepair *);
|
|
|
|
extern int diff_unmodified_pair(struct diff_filepair *);
|
|
|
|
struct diff_queue_struct {
|
|
struct diff_filepair **queue;
|
|
int alloc;
|
|
int nr;
|
|
};
|
|
|
|
extern struct diff_queue_struct diff_queued_diff;
|
|
extern struct diff_filepair *diff_queue(struct diff_queue_struct *,
|
|
struct diff_filespec *,
|
|
struct diff_filespec *);
|
|
extern void diff_q(struct diff_queue_struct *, struct diff_filepair *);
|
|
|
|
extern void diffcore_break(int);
|
|
extern void diffcore_rename(struct diff_options *);
|
|
extern void diffcore_merge_broken(void);
|
|
extern void diffcore_pickaxe(const char *needle, int opts);
|
|
extern void diffcore_order(const char *orderfile);
|
|
|
|
#define DIFF_DEBUG 0
|
|
#if DIFF_DEBUG
|
|
void diff_debug_filespec(struct diff_filespec *, int, const char *);
|
|
void diff_debug_filepair(const struct diff_filepair *, int);
|
|
void diff_debug_queue(const char *, struct diff_queue_struct *);
|
|
#else
|
|
#define diff_debug_filespec(a,b,c) do {} while(0)
|
|
#define diff_debug_filepair(a,b) do {} while(0)
|
|
#define diff_debug_queue(a,b) do {} while(0)
|
|
#endif
|
|
|
|
extern int diffcore_count_changes(struct diff_filespec *src,
|
|
struct diff_filespec *dst,
|
|
void **src_count_p,
|
|
void **dst_count_p,
|
|
unsigned long delta_limit,
|
|
unsigned long *src_copied,
|
|
unsigned long *literal_added);
|
|
|
|
#endif
|