mirror of
https://github.com/git/git
synced 2024-08-25 02:35:46 +00:00
Merge branch 'jc/diff-mark'
* jc/diff-mark: diff: honor binariness specified in attributes Fix configuration syntax to specify customized hunk header patterns. Per-path attribute based hunk header selection. Future-proof source for changes in xdemitconf_t Introduce diff_filespec_is_binary()
This commit is contained in:
Junio C Hamano
commit
e3c76dbd0f
|
|
@ -518,8 +518,8 @@ static struct patch *compare_buffer(mmfile_t *file_p, mmfile_t *file_o,
|
|||
xdemitcb_t ecb;
|
||||
|
||||
xpp.flags = xdl_opts;
|
||||
memset(&xecfg, 0, sizeof(xecfg));
|
||||
xecfg.ctxlen = context;
|
||||
xecfg.flags = 0;
|
||||
ecb.outf = xdiff_outf;
|
||||
ecb.priv = &state;
|
||||
memset(&state, 0, sizeof(state));
|
||||
|
|
|
|||
|
|
@ -285,8 +285,8 @@ static int diff_two(const char *file1, const char *label1,
|
|||
printf("--- a/%s\n+++ b/%s\n", label1, label2);
|
||||
fflush(stdout);
|
||||
xpp.flags = XDF_NEED_MINIMAL;
|
||||
memset(&xecfg, 0, sizeof(xecfg));
|
||||
xecfg.ctxlen = 3;
|
||||
xecfg.flags = 0;
|
||||
ecb.outf = outf;
|
||||
xdl_diff(&minus, &plus, &xpp, &xecfg, &ecb);
|
||||
|
||||
|
|
|
|||
|
|
@ -215,8 +215,7 @@ static void combine_diff(const unsigned char *parent, mmfile_t *result_file,
|
|||
parent_file.ptr = grab_blob(parent, &sz);
|
||||
parent_file.size = sz;
|
||||
xpp.flags = XDF_NEED_MINIMAL;
|
||||
xecfg.ctxlen = 0;
|
||||
xecfg.flags = 0;
|
||||
memset(&xecfg, 0, sizeof(xecfg));
|
||||
ecb.outf = xdiff_outf;
|
||||
ecb.priv = &state;
|
||||
memset(&state, 0, sizeof(state));
|
||||
|
|
|
|||
198
diff.c
198
diff.c
|
|
@ -56,6 +56,14 @@ static struct ll_diff_driver {
|
|||
char *cmd;
|
||||
} *user_diff, **user_diff_tail;
|
||||
|
||||
static void read_config_if_needed(void)
|
||||
{
|
||||
if (!user_diff_tail) {
|
||||
user_diff_tail = &user_diff;
|
||||
git_config(git_diff_ui_config);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Currently there is only "diff.<drivername>.command" variable;
|
||||
* because there are "diff.color.<slot>" variables, we are parsing
|
||||
|
|
@ -93,6 +101,45 @@ static int parse_lldiff_command(const char *var, const char *ep, const char *val
|
|||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* 'diff.<what>.funcname' attribute can be specified in the configuration
|
||||
* to define a customized regexp to find the beginning of a function to
|
||||
* be used for hunk header lines of "diff -p" style output.
|
||||
*/
|
||||
static struct funcname_pattern {
|
||||
char *name;
|
||||
char *pattern;
|
||||
struct funcname_pattern *next;
|
||||
} *funcname_pattern_list;
|
||||
|
||||
static int parse_funcname_pattern(const char *var, const char *ep, const char *value)
|
||||
{
|
||||
const char *name;
|
||||
int namelen;
|
||||
struct funcname_pattern *pp;
|
||||
|
||||
name = var + 5; /* "diff." */
|
||||
namelen = ep - name;
|
||||
|
||||
for (pp = funcname_pattern_list; pp; pp = pp->next)
|
||||
if (!strncmp(pp->name, name, namelen) && !pp->name[namelen])
|
||||
break;
|
||||
if (!pp) {
|
||||
char *namebuf;
|
||||
pp = xcalloc(1, sizeof(*pp));
|
||||
namebuf = xmalloc(namelen + 1);
|
||||
memcpy(namebuf, name, namelen);
|
||||
namebuf[namelen] = 0;
|
||||
pp->name = namebuf;
|
||||
pp->next = funcname_pattern_list;
|
||||
funcname_pattern_list = pp;
|
||||
}
|
||||
if (pp->pattern)
|
||||
free(pp->pattern);
|
||||
pp->pattern = xstrdup(value);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* These are to give UI layer defaults.
|
||||
* The core-level commands such as git-diff-files should
|
||||
|
|
@ -122,8 +169,12 @@ int git_diff_ui_config(const char *var, const char *value)
|
|||
if (!prefixcmp(var, "diff.")) {
|
||||
const char *ep = strrchr(var, '.');
|
||||
|
||||
if (ep != var + 4 && !strcmp(ep, ".command"))
|
||||
return parse_lldiff_command(var, ep, value);
|
||||
if (ep != var + 4) {
|
||||
if (!strcmp(ep, ".command"))
|
||||
return parse_lldiff_command(var, ep, value);
|
||||
if (!strcmp(ep, ".funcname"))
|
||||
return parse_funcname_pattern(var, ep, value);
|
||||
}
|
||||
}
|
||||
if (!prefixcmp(var, "diff.color.") || !prefixcmp(var, "color.diff.")) {
|
||||
int slot = parse_diff_color_slot(var, 11);
|
||||
|
|
@ -390,6 +441,7 @@ static void diff_words_show(struct diff_words_data *diff_words)
|
|||
mmfile_t minus, plus;
|
||||
int i;
|
||||
|
||||
memset(&xecfg, 0, sizeof(xecfg));
|
||||
minus.size = diff_words->minus.text.size;
|
||||
minus.ptr = xmalloc(minus.size);
|
||||
memcpy(minus.ptr, diff_words->minus.text.ptr, minus.size);
|
||||
|
|
@ -408,7 +460,6 @@ static void diff_words_show(struct diff_words_data *diff_words)
|
|||
|
||||
xpp.flags = XDF_NEED_MINIMAL;
|
||||
xecfg.ctxlen = diff_words->minus.alloc + diff_words->plus.alloc;
|
||||
xecfg.flags = 0;
|
||||
ecb.outf = xdiff_outf;
|
||||
ecb.priv = diff_words;
|
||||
diff_words->xm.consume = fn_out_diff_words_aux;
|
||||
|
|
@ -1102,30 +1153,101 @@ static void setup_diff_attr_check(struct git_attr_check *check)
|
|||
{
|
||||
static struct git_attr *attr_diff;
|
||||
|
||||
if (!attr_diff)
|
||||
if (!attr_diff) {
|
||||
attr_diff = git_attr("diff", 4);
|
||||
check->attr = attr_diff;
|
||||
}
|
||||
check[0].attr = attr_diff;
|
||||
}
|
||||
|
||||
static int file_is_binary(struct diff_filespec *one)
|
||||
static void diff_filespec_check_attr(struct diff_filespec *one)
|
||||
{
|
||||
struct git_attr_check attr_diff_check;
|
||||
int check_from_data = 0;
|
||||
|
||||
if (one->checked_attr)
|
||||
return;
|
||||
|
||||
setup_diff_attr_check(&attr_diff_check);
|
||||
one->is_binary = 0;
|
||||
one->funcname_pattern_ident = NULL;
|
||||
|
||||
if (!git_checkattr(one->path, 1, &attr_diff_check)) {
|
||||
const char *value = attr_diff_check.value;
|
||||
const char *value;
|
||||
|
||||
/* binaryness */
|
||||
value = attr_diff_check.value;
|
||||
if (ATTR_TRUE(value))
|
||||
return 0;
|
||||
;
|
||||
else if (ATTR_FALSE(value))
|
||||
return 1;
|
||||
one->is_binary = 1;
|
||||
else
|
||||
check_from_data = 1;
|
||||
|
||||
/* funcname pattern ident */
|
||||
if (ATTR_TRUE(value) || ATTR_FALSE(value) || ATTR_UNSET(value))
|
||||
;
|
||||
else
|
||||
one->funcname_pattern_ident = value;
|
||||
}
|
||||
|
||||
if (!one->data) {
|
||||
if (!DIFF_FILE_VALID(one))
|
||||
return 0;
|
||||
diff_populate_filespec(one, 0);
|
||||
if (check_from_data) {
|
||||
if (!one->data && DIFF_FILE_VALID(one))
|
||||
diff_populate_filespec(one, 0);
|
||||
|
||||
if (one->data)
|
||||
one->is_binary = buffer_is_binary(one->data, one->size);
|
||||
}
|
||||
return buffer_is_binary(one->data, one->size);
|
||||
}
|
||||
|
||||
int diff_filespec_is_binary(struct diff_filespec *one)
|
||||
{
|
||||
diff_filespec_check_attr(one);
|
||||
return one->is_binary;
|
||||
}
|
||||
|
||||
static const char *funcname_pattern(const char *ident)
|
||||
{
|
||||
struct funcname_pattern *pp;
|
||||
|
||||
read_config_if_needed();
|
||||
for (pp = funcname_pattern_list; pp; pp = pp->next)
|
||||
if (!strcmp(ident, pp->name))
|
||||
return pp->pattern;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static const char *diff_funcname_pattern(struct diff_filespec *one)
|
||||
{
|
||||
const char *ident, *pattern;
|
||||
|
||||
diff_filespec_check_attr(one);
|
||||
ident = one->funcname_pattern_ident;
|
||||
|
||||
if (!ident)
|
||||
/*
|
||||
* If the config file has "funcname.default" defined, that
|
||||
* regexp is used; otherwise NULL is returned and xemit uses
|
||||
* the built-in default.
|
||||
*/
|
||||
return funcname_pattern("default");
|
||||
|
||||
/* Look up custom "funcname.$ident" regexp from config. */
|
||||
pattern = funcname_pattern(ident);
|
||||
if (pattern)
|
||||
return pattern;
|
||||
|
||||
/*
|
||||
* And define built-in fallback patterns here. Note that
|
||||
* these can be overriden by the user's config settings.
|
||||
*/
|
||||
if (!strcmp(ident, "java"))
|
||||
return "!^[ ]*\\(catch\\|do\\|for\\|if\\|instanceof\\|"
|
||||
"new\\|return\\|switch\\|throw\\|while\\)\n"
|
||||
"^[ ]*\\(\\([ ]*"
|
||||
"[A-Za-z_][A-Za-z_0-9]*\\)\\{2,\\}"
|
||||
"[ ]*([^;]*$\\)";
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void builtin_diff(const char *name_a,
|
||||
|
|
@ -1182,7 +1304,8 @@ static void builtin_diff(const char *name_a,
|
|||
if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
|
||||
die("unable to read files to diff");
|
||||
|
||||
if (!o->text && (file_is_binary(one) || file_is_binary(two))) {
|
||||
if (!o->text &&
|
||||
(diff_filespec_is_binary(one) || diff_filespec_is_binary(two))) {
|
||||
/* Quite common confusing case */
|
||||
if (mf1.size == mf2.size &&
|
||||
!memcmp(mf1.ptr, mf2.ptr, mf1.size))
|
||||
|
|
@ -1201,7 +1324,13 @@ static void builtin_diff(const char *name_a,
|
|||
xdemitconf_t xecfg;
|
||||
xdemitcb_t ecb;
|
||||
struct emit_callback ecbdata;
|
||||
const char *funcname_pattern;
|
||||
|
||||
funcname_pattern = diff_funcname_pattern(one);
|
||||
if (!funcname_pattern)
|
||||
funcname_pattern = diff_funcname_pattern(two);
|
||||
|
||||
memset(&xecfg, 0, sizeof(xecfg));
|
||||
memset(&ecbdata, 0, sizeof(ecbdata));
|
||||
ecbdata.label_path = lbl;
|
||||
ecbdata.color_diff = o->color_diff;
|
||||
|
|
@ -1209,6 +1338,8 @@ static void builtin_diff(const char *name_a,
|
|||
xpp.flags = XDF_NEED_MINIMAL | o->xdl_opts;
|
||||
xecfg.ctxlen = o->context;
|
||||
xecfg.flags = XDL_EMIT_FUNCNAMES;
|
||||
if (funcname_pattern)
|
||||
xdiff_set_find_func(&xecfg, funcname_pattern);
|
||||
if (!diffopts)
|
||||
;
|
||||
else if (!prefixcmp(diffopts, "--unified="))
|
||||
|
|
@ -1260,7 +1391,7 @@ static void builtin_diffstat(const char *name_a, const char *name_b,
|
|||
if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
|
||||
die("unable to read files to diff");
|
||||
|
||||
if (file_is_binary(one) || file_is_binary(two)) {
|
||||
if (diff_filespec_is_binary(one) || diff_filespec_is_binary(two)) {
|
||||
data->is_binary = 1;
|
||||
data->added = mf2.size;
|
||||
data->deleted = mf1.size;
|
||||
|
|
@ -1270,9 +1401,8 @@ static void builtin_diffstat(const char *name_a, const char *name_b,
|
|||
xdemitconf_t xecfg;
|
||||
xdemitcb_t ecb;
|
||||
|
||||
memset(&xecfg, 0, sizeof(xecfg));
|
||||
xpp.flags = XDF_NEED_MINIMAL | o->xdl_opts;
|
||||
xecfg.ctxlen = 0;
|
||||
xecfg.flags = 0;
|
||||
ecb.outf = xdiff_outf;
|
||||
ecb.priv = diffstat;
|
||||
xdl_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
|
||||
|
|
@ -1302,7 +1432,7 @@ static void builtin_checkdiff(const char *name_a, const char *name_b,
|
|||
if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
|
||||
die("unable to read files to diff");
|
||||
|
||||
if (file_is_binary(two))
|
||||
if (diff_filespec_is_binary(two))
|
||||
goto free_and_return;
|
||||
else {
|
||||
/* Crazy xdl interfaces.. */
|
||||
|
|
@ -1310,9 +1440,8 @@ static void builtin_checkdiff(const char *name_a, const char *name_b,
|
|||
xdemitconf_t xecfg;
|
||||
xdemitcb_t ecb;
|
||||
|
||||
memset(&xecfg, 0, sizeof(xecfg));
|
||||
xpp.flags = XDF_NEED_MINIMAL;
|
||||
xecfg.ctxlen = 0;
|
||||
xecfg.flags = 0;
|
||||
ecb.outf = xdiff_outf;
|
||||
ecb.priv = &data;
|
||||
xdl_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
|
||||
|
|
@ -1753,10 +1882,7 @@ static const char *external_diff_attr(const char *name)
|
|||
!ATTR_UNSET(value)) {
|
||||
struct ll_diff_driver *drv;
|
||||
|
||||
if (!user_diff_tail) {
|
||||
user_diff_tail = &user_diff;
|
||||
git_config(git_diff_ui_config);
|
||||
}
|
||||
read_config_if_needed();
|
||||
for (drv = user_diff; drv; drv = drv->next)
|
||||
if (!strcmp(drv->name, value))
|
||||
return drv->cmd;
|
||||
|
|
@ -1880,8 +2006,8 @@ static void run_diff(struct diff_filepair *p, struct diff_options *o)
|
|||
|
||||
if (o->binary) {
|
||||
mmfile_t mf;
|
||||
if ((!fill_mmfile(&mf, one) && file_is_binary(one)) ||
|
||||
(!fill_mmfile(&mf, two) && file_is_binary(two)))
|
||||
if ((!fill_mmfile(&mf, one) && diff_filespec_is_binary(one)) ||
|
||||
(!fill_mmfile(&mf, two) && diff_filespec_is_binary(two)))
|
||||
abbrev = 40;
|
||||
}
|
||||
len += snprintf(msg + len, sizeof(msg) - len,
|
||||
|
|
@ -2764,6 +2890,7 @@ static int diff_get_patch_id(struct diff_options *options, unsigned char *sha1)
|
|||
struct diff_filepair *p = q->queue[i];
|
||||
int len1, len2;
|
||||
|
||||
memset(&xecfg, 0, sizeof(xecfg));
|
||||
if (p->status == 0)
|
||||
return error("internal diff status error");
|
||||
if (p->status == DIFF_STATUS_UNKNOWN)
|
||||
|
|
@ -2783,7 +2910,7 @@ static int diff_get_patch_id(struct diff_options *options, unsigned char *sha1)
|
|||
return error("unable to read files to diff");
|
||||
|
||||
/* Maybe hash p->two? into the patch id? */
|
||||
if (file_is_binary(p->two))
|
||||
if (diff_filespec_is_binary(p->two))
|
||||
continue;
|
||||
|
||||
len1 = remove_space(p->one->path, strlen(p->one->path));
|
||||
|
|
@ -3011,21 +3138,6 @@ void diffcore_std(struct diff_options *options)
|
|||
if (options->quiet)
|
||||
return;
|
||||
|
||||
/*
|
||||
* break/rename count similarity differently depending on
|
||||
* the binary-ness.
|
||||
*/
|
||||
if ((options->break_opt != -1) || (options->detect_rename)) {
|
||||
struct diff_queue_struct *q = &diff_queued_diff;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < q->nr; i++) {
|
||||
struct diff_filepair *p = q->queue[i];
|
||||
p->one->is_binary = file_is_binary(p->one);
|
||||
p->two->is_binary = file_is_binary(p->two);
|
||||
}
|
||||
}
|
||||
|
||||
if (options->break_opt != -1)
|
||||
diffcore_break(options->break_opt);
|
||||
if (options->detect_rename)
|
||||
|
|
|
|||
|
|
@ -129,7 +129,7 @@ static struct spanhash_top *hash_chars(struct diff_filespec *one)
|
|||
struct spanhash_top *hash;
|
||||
unsigned char *buf = one->data;
|
||||
unsigned int sz = one->size;
|
||||
int is_text = !one->is_binary;
|
||||
int is_text = !diff_filespec_is_binary(one);
|
||||
|
||||
i = INITIAL_HASH_SIZE;
|
||||
hash = xmalloc(sizeof(*hash) + sizeof(struct spanhash) * (1<<i));
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@ struct diff_filespec {
|
|||
char *path;
|
||||
void *data;
|
||||
void *cnt_data;
|
||||
const char *funcname_pattern_ident;
|
||||
unsigned long size;
|
||||
int xfrm_flags; /* for use by the xfrm */
|
||||
unsigned short mode; /* file mode */
|
||||
|
|
@ -37,6 +38,7 @@ struct diff_filespec {
|
|||
#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 */
|
||||
unsigned checked_attr : 1;
|
||||
unsigned is_binary : 1; /* data should be considered "binary" */
|
||||
};
|
||||
|
||||
|
|
@ -46,6 +48,7 @@ extern void fill_filespec(struct diff_filespec *, const unsigned char *,
|
|||
|
||||
extern int diff_populate_filespec(struct diff_filespec *, int);
|
||||
extern void diff_free_filespec_data(struct diff_filespec *);
|
||||
extern int diff_filespec_is_binary(struct diff_filespec *);
|
||||
|
||||
struct diff_filepair {
|
||||
struct diff_filespec *one;
|
||||
|
|
|
|||
|
|
@ -62,6 +62,7 @@ static int generate_common_file(mmfile_t *res, mmfile_t *f1, mmfile_t *f2)
|
|||
xdemitcb_t ecb;
|
||||
|
||||
xpp.flags = XDF_NEED_MINIMAL;
|
||||
memset(&xecfg, 0, sizeof(xecfg));
|
||||
xecfg.ctxlen = 3;
|
||||
xecfg.flags = XDL_EMIT_COMMON;
|
||||
ecb.outf = common_outf;
|
||||
|
|
|
|||
|
|
@ -106,8 +106,8 @@ static void show_diff(struct merge_list *entry)
|
|||
xdemitcb_t ecb;
|
||||
|
||||
xpp.flags = XDF_NEED_MINIMAL;
|
||||
memset(&xecfg, 0, sizeof(xecfg));
|
||||
xecfg.ctxlen = 3;
|
||||
xecfg.flags = 0;
|
||||
ecb.outf = show_outf;
|
||||
ecb.priv = NULL;
|
||||
|
||||
|
|
|
|||
60
t/t4018-diff-funcname.sh
Normal file
60
t/t4018-diff-funcname.sh
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
#!/bin/sh
|
||||
#
|
||||
# Copyright (c) 2007 Johannes E. Schindelin
|
||||
#
|
||||
|
||||
test_description='Test custom diff function name patterns'
|
||||
|
||||
. ./test-lib.sh
|
||||
|
||||
LF='
|
||||
'
|
||||
|
||||
cat > Beer.java << EOF
|
||||
public class Beer
|
||||
{
|
||||
int special;
|
||||
public static void main(String args[])
|
||||
{
|
||||
String s=" ";
|
||||
for(int x = 99; x > 0; x--)
|
||||
{
|
||||
System.out.print(x + " bottles of beer on the wall "
|
||||
+ x + " bottles of beer\n"
|
||||
+ "Take one down, pass it around, " + (x - 1)
|
||||
+ " bottles of beer on the wall.\n");
|
||||
}
|
||||
System.out.print("Go to the store, buy some more,\n"
|
||||
+ "99 bottles of beer on the wall.\n");
|
||||
}
|
||||
}
|
||||
EOF
|
||||
|
||||
sed 's/beer\\/beer,\\/' < Beer.java > Beer-correct.java
|
||||
|
||||
test_expect_success 'default behaviour' '
|
||||
git diff Beer.java Beer-correct.java |
|
||||
grep "^@@.*@@ public class Beer"
|
||||
'
|
||||
|
||||
test_expect_success 'preset java pattern' '
|
||||
echo "*.java diff=java" >.gitattributes &&
|
||||
git diff Beer.java Beer-correct.java |
|
||||
grep "^@@.*@@ public static void main("
|
||||
'
|
||||
|
||||
git config diff.java.funcname '!static
|
||||
!String
|
||||
[^ ].*s.*'
|
||||
|
||||
test_expect_success 'custom pattern' '
|
||||
git diff Beer.java Beer-correct.java |
|
||||
grep "^@@.*@@ int special;$"
|
||||
'
|
||||
|
||||
test_expect_success 'last regexp must not be negated' '
|
||||
git config diff.java.funcname "!static" &&
|
||||
! git diff Beer.java Beer-correct.java
|
||||
'
|
||||
|
||||
test_done
|
||||
|
|
@ -94,4 +94,16 @@ test_expect_success 'diff attribute should apply only to diff' '
|
|||
|
||||
'
|
||||
|
||||
test_expect_success 'no diff with -diff' '
|
||||
echo >.gitattributes "file -diff" &&
|
||||
git diff | grep Binary
|
||||
'
|
||||
|
||||
echo NULZbetweenZwords | tr Z '\0' > file
|
||||
|
||||
test_expect_success 'force diff with "diff"' '
|
||||
echo >.gitattributes "file diff" &&
|
||||
git diff | grep -a second
|
||||
'
|
||||
|
||||
test_done
|
||||
|
|
|
|||
|
|
@ -129,3 +129,74 @@ int buffer_is_binary(const char *ptr, unsigned long size)
|
|||
size = FIRST_FEW_BYTES;
|
||||
return !!memchr(ptr, 0, size);
|
||||
}
|
||||
|
||||
struct ff_regs {
|
||||
int nr;
|
||||
struct ff_reg {
|
||||
regex_t re;
|
||||
int negate;
|
||||
} *array;
|
||||
};
|
||||
|
||||
static long ff_regexp(const char *line, long len,
|
||||
char *buffer, long buffer_size, void *priv)
|
||||
{
|
||||
char *line_buffer = xstrndup(line, len); /* make NUL terminated */
|
||||
struct ff_regs *regs = priv;
|
||||
regmatch_t pmatch[2];
|
||||
int result = 0, i;
|
||||
|
||||
for (i = 0; i < regs->nr; i++) {
|
||||
struct ff_reg *reg = regs->array + i;
|
||||
if (reg->negate ^ !!regexec(®->re,
|
||||
line_buffer, 2, pmatch, 0)) {
|
||||
free(line_buffer);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
i = pmatch[1].rm_so >= 0 ? 1 : 0;
|
||||
line += pmatch[i].rm_so;
|
||||
result = pmatch[i].rm_eo - pmatch[i].rm_so;
|
||||
if (result > buffer_size)
|
||||
result = buffer_size;
|
||||
else
|
||||
while (result > 0 && (isspace(line[result - 1]) ||
|
||||
line[result - 1] == '\n'))
|
||||
result--;
|
||||
memcpy(buffer, line, result);
|
||||
free(line_buffer);
|
||||
return result;
|
||||
}
|
||||
|
||||
void xdiff_set_find_func(xdemitconf_t *xecfg, const char *value)
|
||||
{
|
||||
int i;
|
||||
struct ff_regs *regs;
|
||||
|
||||
xecfg->find_func = ff_regexp;
|
||||
regs = xecfg->find_func_priv = xmalloc(sizeof(struct ff_regs));
|
||||
for (i = 0, regs->nr = 1; value[i]; i++)
|
||||
if (value[i] == '\n')
|
||||
regs->nr++;
|
||||
regs->array = xmalloc(regs->nr * sizeof(struct ff_reg));
|
||||
for (i = 0; i < regs->nr; i++) {
|
||||
struct ff_reg *reg = regs->array + i;
|
||||
const char *ep = strchr(value, '\n'), *expression;
|
||||
char *buffer = NULL;
|
||||
|
||||
reg->negate = (*value == '!');
|
||||
if (reg->negate && i == regs->nr - 1)
|
||||
die("Last expression must not be negated: %s", value);
|
||||
if (*value == '!')
|
||||
value++;
|
||||
if (ep)
|
||||
expression = buffer = xstrndup(value, ep - value);
|
||||
else
|
||||
expression = value;
|
||||
if (regcomp(®->re, expression, 0))
|
||||
die("Invalid regexp to look for hunk header: %s", expression);
|
||||
if (buffer)
|
||||
free(buffer);
|
||||
value = ep + 1;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,4 +20,6 @@ int parse_hunk_header(char *line, int len,
|
|||
int read_mmfile(mmfile_t *ptr, const char *filename);
|
||||
int buffer_is_binary(const char *ptr, unsigned long size);
|
||||
|
||||
extern void xdiff_set_find_func(xdemitconf_t *xecfg, const char *line);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -73,9 +73,13 @@ typedef struct s_xdemitcb {
|
|||
int (*outf)(void *, mmbuffer_t *, int);
|
||||
} xdemitcb_t;
|
||||
|
||||
typedef long (*find_func_t)(const char *line, long line_len, char *buffer, long buffer_size, void *priv);
|
||||
|
||||
typedef struct s_xdemitconf {
|
||||
long ctxlen;
|
||||
unsigned long flags;
|
||||
find_func_t find_func;
|
||||
void *find_func_priv;
|
||||
} xdemitconf_t;
|
||||
|
||||
typedef struct s_bdiffparam {
|
||||
|
|
|
|||
|
|
@ -69,7 +69,24 @@ static xdchange_t *xdl_get_hunk(xdchange_t *xscr, xdemitconf_t const *xecfg) {
|
|||
}
|
||||
|
||||
|
||||
static void xdl_find_func(xdfile_t *xf, long i, char *buf, long sz, long *ll) {
|
||||
static long def_ff(const char *rec, long len, char *buf, long sz, void *priv)
|
||||
{
|
||||
if (len > 0 &&
|
||||
(isalpha((unsigned char)*rec) || /* identifier? */
|
||||
*rec == '_' || /* also identifier? */
|
||||
*rec == '$')) { /* identifiers from VMS and other esoterico */
|
||||
if (len > sz)
|
||||
len = sz;
|
||||
while (0 < len && isspace((unsigned char)rec[len - 1]))
|
||||
len--;
|
||||
memcpy(buf, rec, len);
|
||||
return len;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void xdl_find_func(xdfile_t *xf, long i, char *buf, long sz, long *ll,
|
||||
find_func_t ff, void *ff_priv) {
|
||||
|
||||
/*
|
||||
* Be quite stupid about this for now. Find a line in the old file
|
||||
|
|
@ -80,22 +97,12 @@ static void xdl_find_func(xdfile_t *xf, long i, char *buf, long sz, long *ll) {
|
|||
const char *rec;
|
||||
long len;
|
||||
|
||||
*ll = 0;
|
||||
while (i-- > 0) {
|
||||
len = xdl_get_rec(xf, i, &rec);
|
||||
if (len > 0 &&
|
||||
(isalpha((unsigned char)*rec) || /* identifier? */
|
||||
*rec == '_' || /* also identifier? */
|
||||
*rec == '$')) { /* mysterious GNU diff's invention */
|
||||
if (len > sz)
|
||||
len = sz;
|
||||
while (0 < len && isspace((unsigned char)rec[len - 1]))
|
||||
len--;
|
||||
memcpy(buf, rec, len);
|
||||
*ll = len;
|
||||
if ((*ll = ff(rec, len, buf, sz, ff_priv)) >= 0)
|
||||
return;
|
||||
}
|
||||
}
|
||||
*ll = 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -120,6 +127,7 @@ int xdl_emit_diff(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb,
|
|||
xdchange_t *xch, *xche;
|
||||
char funcbuf[80];
|
||||
long funclen = 0;
|
||||
find_func_t ff = xecfg->find_func ? xecfg->find_func : def_ff;
|
||||
|
||||
if (xecfg->flags & XDL_EMIT_COMMON)
|
||||
return xdl_emit_common(xe, xscr, ecb, xecfg);
|
||||
|
|
@ -143,7 +151,8 @@ int xdl_emit_diff(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb,
|
|||
|
||||
if (xecfg->flags & XDL_EMIT_FUNCNAMES) {
|
||||
xdl_find_func(&xe->xdf1, s1, funcbuf,
|
||||
sizeof(funcbuf), &funclen);
|
||||
sizeof(funcbuf), &funclen,
|
||||
ff, xecfg->find_func_priv);
|
||||
}
|
||||
if (xdl_emit_hunk_hdr(s1 + 1, e1 - s1, s2 + 1, e2 - s2,
|
||||
funcbuf, funclen, ecb) < 0)
|
||||
|
|
|
|||
Loading…
Reference in a new issue