2006-04-05 09:03:58 +00:00
|
|
|
#include "cache.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2018-05-15 23:42:15 +00:00
|
|
|
#include "object-store.h"
|
2006-04-05 09:03:58 +00:00
|
|
|
#include "xdiff-interface.h"
|
2008-10-25 13:31:15 +00:00
|
|
|
#include "xdiff/xtypes.h"
|
|
|
|
#include "xdiff/xdiffi.h"
|
|
|
|
#include "xdiff/xemit.h"
|
|
|
|
#include "xdiff/xmacros.h"
|
2017-10-25 18:49:11 +00:00
|
|
|
#include "xdiff/xutils.h"
|
2008-08-14 06:18:22 +00:00
|
|
|
|
|
|
|
struct xdiff_emit_state {
|
2018-11-02 06:35:45 +00:00
|
|
|
xdiff_emit_hunk_fn hunk_fn;
|
|
|
|
xdiff_emit_line_fn line_fn;
|
2008-08-14 06:18:22 +00:00
|
|
|
void *consume_callback_data;
|
|
|
|
struct strbuf remainder;
|
|
|
|
};
|
2006-04-05 09:03:58 +00:00
|
|
|
|
2018-11-02 06:35:45 +00:00
|
|
|
static int xdiff_out_hunk(void *priv_,
|
|
|
|
long old_begin, long old_nr,
|
|
|
|
long new_begin, long new_nr,
|
|
|
|
const char *func, long funclen)
|
2006-04-05 19:22:35 +00:00
|
|
|
{
|
2018-11-02 06:35:45 +00:00
|
|
|
struct xdiff_emit_state *priv = priv_;
|
2006-04-05 19:22:35 +00:00
|
|
|
|
2018-11-02 06:35:45 +00:00
|
|
|
if (priv->remainder.len)
|
|
|
|
BUG("xdiff emitted hunk in the middle of a line");
|
2006-04-05 19:22:35 +00:00
|
|
|
|
2018-11-02 06:35:45 +00:00
|
|
|
priv->hunk_fn(priv->consume_callback_data,
|
|
|
|
old_begin, old_nr, new_begin, new_nr,
|
|
|
|
func, funclen);
|
|
|
|
return 0;
|
2006-04-05 19:22:35 +00:00
|
|
|
}
|
|
|
|
|
2006-04-05 09:03:58 +00:00
|
|
|
static void consume_one(void *priv_, char *s, unsigned long size)
|
|
|
|
{
|
|
|
|
struct xdiff_emit_state *priv = priv_;
|
|
|
|
char *ep;
|
|
|
|
while (size) {
|
|
|
|
unsigned long this_size;
|
|
|
|
ep = memchr(s, '\n', size);
|
|
|
|
this_size = (ep == NULL) ? size : (ep - s + 1);
|
2018-11-02 06:35:45 +00:00
|
|
|
priv->line_fn(priv->consume_callback_data, s, this_size);
|
2006-04-05 09:03:58 +00:00
|
|
|
size -= this_size;
|
|
|
|
s += this_size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Make xdi_diff_outf interface for running xdiff_outf diffs
To prepare for the need to initialize and release resources for an
xdi_diff with the xdiff_outf output function, make a new function to
wrap this usage.
Old:
ecb.outf = xdiff_outf;
ecb.priv = &state;
...
xdi_diff(file_p, file_o, &xpp, &xecfg, &ecb);
New:
xdi_diff_outf(file_p, file_o, &state.xm, &xpp, &xecfg, &ecb);
Signed-off-by: Brian Downing <bdowning@lavos.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-14 05:36:50 +00:00
|
|
|
static int xdiff_outf(void *priv_, mmbuffer_t *mb, int nbuf)
|
2006-04-05 09:03:58 +00:00
|
|
|
{
|
|
|
|
struct xdiff_emit_state *priv = priv_;
|
|
|
|
int i;
|
|
|
|
|
2018-11-02 06:37:18 +00:00
|
|
|
if (!priv->line_fn)
|
|
|
|
return 0;
|
|
|
|
|
2006-04-05 09:03:58 +00:00
|
|
|
for (i = 0; i < nbuf; i++) {
|
|
|
|
if (mb[i].ptr[mb[i].size-1] != '\n') {
|
|
|
|
/* Incomplete line */
|
2008-08-14 05:36:51 +00:00
|
|
|
strbuf_add(&priv->remainder, mb[i].ptr, mb[i].size);
|
2006-04-05 09:03:58 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we have a complete line */
|
2008-08-14 05:36:51 +00:00
|
|
|
if (!priv->remainder.len) {
|
2006-04-05 09:03:58 +00:00
|
|
|
consume_one(priv, mb[i].ptr, mb[i].size);
|
|
|
|
continue;
|
|
|
|
}
|
2008-08-14 05:36:51 +00:00
|
|
|
strbuf_add(&priv->remainder, mb[i].ptr, mb[i].size);
|
|
|
|
consume_one(priv, priv->remainder.buf, priv->remainder.len);
|
|
|
|
strbuf_reset(&priv->remainder);
|
2006-04-05 09:03:58 +00:00
|
|
|
}
|
2008-08-14 05:36:51 +00:00
|
|
|
if (priv->remainder.len) {
|
|
|
|
consume_one(priv, priv->remainder.buf, priv->remainder.len);
|
|
|
|
strbuf_reset(&priv->remainder);
|
2006-04-05 09:03:58 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2006-12-20 16:37:07 +00:00
|
|
|
|
2007-12-13 22:24:18 +00:00
|
|
|
/*
|
|
|
|
* Trim down common substring at the end of the buffers,
|
2016-05-28 15:04:31 +00:00
|
|
|
* but end on a complete line.
|
2007-12-13 22:24:18 +00:00
|
|
|
*/
|
2016-05-28 15:04:31 +00:00
|
|
|
static void trim_common_tail(mmfile_t *a, mmfile_t *b)
|
2007-12-13 22:24:18 +00:00
|
|
|
{
|
|
|
|
const int blk = 1024;
|
2007-12-16 07:06:14 +00:00
|
|
|
long trimmed = 0, recovered = 0;
|
avoid computing zero offsets from NULL pointer
The Undefined Behavior Sanitizer in clang-11 seems to have learned a new
trick: it complains about computing offsets from a NULL pointer, even if
that offset is 0. This causes numerous test failures. For example, from
t1090:
unpack-trees.c:1355:41: runtime error: applying zero offset to null pointer
...
not ok 6 - in partial clone, sparse checkout only fetches needed blobs
The code in question looks like this:
struct cache_entry **cache_end = cache + nr;
...
while (cache != cache_end)
and we sometimes pass in a NULL and 0 for "cache" and "nr". This is
conceptually fine, as "cache_end" would be equal to "cache" in this
case, and we wouldn't enter the loop at all. But computing even a zero
offset violates the C standard. And given the fact that UBSan is
noticing this behavior, this might be a potential problem spot if the
compiler starts making unexpected assumptions based on undefined
behavior.
So let's just avoid it, which is pretty easy. In some cases we can just
switch to iterating with a numeric index (as we do in sequencer.c here).
In other cases (like the cache_end one) the use of an end pointer is
more natural; we can keep that by just explicitly checking for the
NULL/0 case when assigning the end pointer.
Note that there are two ways you can write this latter case, checking
for the pointer:
cache_end = cache ? cache + nr : cache;
or the size:
cache_end = nr ? cache + nr : cache;
For the case of a NULL/0 ptr/len combo, they are equivalent. But writing
it the second way (as this patch does) has the property that if somebody
were to incorrectly pass a NULL pointer with a non-zero length, we'd
continue to notice and segfault, rather than silently pretending the
length was zero.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-29 05:46:47 +00:00
|
|
|
char *ap = a->size ? a->ptr + a->size : a->ptr;
|
|
|
|
char *bp = b->size ? b->ptr + b->size : b->ptr;
|
2007-12-13 22:24:18 +00:00
|
|
|
long smaller = (a->size < b->size) ? a->size : b->size;
|
|
|
|
|
|
|
|
while (blk + trimmed <= smaller && !memcmp(ap - blk, bp - blk, blk)) {
|
|
|
|
trimmed += blk;
|
|
|
|
ap -= blk;
|
|
|
|
bp -= blk;
|
|
|
|
}
|
|
|
|
|
2007-12-21 04:22:46 +00:00
|
|
|
while (recovered < trimmed)
|
2007-12-16 07:06:14 +00:00
|
|
|
if (ap[recovered++] == '\n')
|
2007-12-21 04:22:46 +00:00
|
|
|
break;
|
|
|
|
a->size -= trimmed - recovered;
|
|
|
|
b->size -= trimmed - recovered;
|
2007-12-13 22:24:18 +00:00
|
|
|
}
|
|
|
|
|
2007-12-13 21:25:07 +00:00
|
|
|
int xdi_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, xdemitconf_t const *xecfg, xdemitcb_t *xecb)
|
|
|
|
{
|
2007-12-13 22:24:18 +00:00
|
|
|
mmfile_t a = *mf1;
|
|
|
|
mmfile_t b = *mf2;
|
|
|
|
|
xdiff: reject files larger than ~1GB
The xdiff code is not prepared to handle extremely large
files. It uses "int" in many places, which can overflow if
we have a very large number of lines or even bytes in our
input files. This can cause us to produce incorrect diffs,
with no indication that the output is wrong. Or worse, we
may even underallocate a buffer whose size is the result of
an overflowing addition.
We're much better off to tell the user that we cannot diff
or merge such a large file. This patch covers both cases,
but in slightly different ways:
1. For merging, we notice the large file and cleanly fall
back to a binary merge (which is effectively "we cannot
merge this").
2. For diffing, we make the binary/text distinction much
earlier, and in many different places. For this case,
we'll use the xdi_diff as our choke point, and reject
any diff there before it hits the xdiff code.
This means in most cases we'll die() immediately after.
That's not ideal, but in practice we shouldn't
generally hit this code path unless the user is trying
to do something tricky. We already consider files
larger than core.bigfilethreshold to be binary, so this
code would only kick in when that is circumvented
(either by bumping that value, or by using a
.gitattribute to mark a file as diffable).
In other words, we can avoid being "nice" here, because
there is already nice code that tries to do the right
thing. We are adding the suspenders to the nice code's
belt, so notice when it has been worked around (both to
protect the user from malicious inputs, and because it
is better to die() than generate bogus output).
The maximum size was chosen after experimenting with feeding
large files to the xdiff code. It's just under a gigabyte,
which leaves room for two obvious cases:
- a diff3 merge conflict result on files of maximum size X
could be 3*X plus the size of the markers, which would
still be only about 3G, which fits in a 32-bit int.
- some of the diff code allocates arrays of one int per
record. Even if each file consists only of blank lines,
then a file smaller than 1G will have fewer than 1G
records, and therefore the int array will fit in 4G.
Since the limit is arbitrary anyway, I chose to go under a
gigabyte, to leave a safety margin (e.g., we would not want
to overflow by allocating "(records + 1) * sizeof(int)" or
similar.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-09-24 23:12:45 +00:00
|
|
|
if (mf1->size > MAX_XDIFF_SIZE || mf2->size > MAX_XDIFF_SIZE)
|
|
|
|
return -1;
|
|
|
|
|
2016-05-28 15:04:31 +00:00
|
|
|
if (!xecfg->ctxlen && !(xecfg->flags & XDL_EMIT_FUNCCONTEXT))
|
|
|
|
trim_common_tail(&a, &b);
|
2007-12-13 22:24:18 +00:00
|
|
|
|
|
|
|
return xdl_diff(&a, &b, xpp, xecfg, xecb);
|
2007-12-13 21:25:07 +00:00
|
|
|
}
|
|
|
|
|
2018-11-02 06:36:06 +00:00
|
|
|
void discard_hunk_line(void *priv,
|
|
|
|
long ob, long on, long nb, long nn,
|
|
|
|
const char *func, long funclen)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
Make xdi_diff_outf interface for running xdiff_outf diffs
To prepare for the need to initialize and release resources for an
xdi_diff with the xdiff_outf output function, make a new function to
wrap this usage.
Old:
ecb.outf = xdiff_outf;
ecb.priv = &state;
...
xdi_diff(file_p, file_o, &xpp, &xecfg, &ecb);
New:
xdi_diff_outf(file_p, file_o, &state.xm, &xpp, &xecfg, &ecb);
Signed-off-by: Brian Downing <bdowning@lavos.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-14 05:36:50 +00:00
|
|
|
int xdi_diff_outf(mmfile_t *mf1, mmfile_t *mf2,
|
2018-11-02 06:35:45 +00:00
|
|
|
xdiff_emit_hunk_fn hunk_fn,
|
|
|
|
xdiff_emit_line_fn line_fn,
|
|
|
|
void *consume_callback_data,
|
2010-05-04 20:41:34 +00:00
|
|
|
xpparam_t const *xpp, xdemitconf_t const *xecfg)
|
Make xdi_diff_outf interface for running xdiff_outf diffs
To prepare for the need to initialize and release resources for an
xdi_diff with the xdiff_outf output function, make a new function to
wrap this usage.
Old:
ecb.outf = xdiff_outf;
ecb.priv = &state;
...
xdi_diff(file_p, file_o, &xpp, &xecfg, &ecb);
New:
xdi_diff_outf(file_p, file_o, &state.xm, &xpp, &xecfg, &ecb);
Signed-off-by: Brian Downing <bdowning@lavos.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-14 05:36:50 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2008-08-14 06:18:22 +00:00
|
|
|
struct xdiff_emit_state state;
|
2010-05-04 20:41:34 +00:00
|
|
|
xdemitcb_t ecb;
|
2008-08-14 06:18:22 +00:00
|
|
|
|
|
|
|
memset(&state, 0, sizeof(state));
|
2018-11-02 06:35:45 +00:00
|
|
|
state.hunk_fn = hunk_fn;
|
|
|
|
state.line_fn = line_fn;
|
2008-08-14 06:18:22 +00:00
|
|
|
state.consume_callback_data = consume_callback_data;
|
2010-05-04 20:41:34 +00:00
|
|
|
memset(&ecb, 0, sizeof(ecb));
|
2018-11-02 06:35:45 +00:00
|
|
|
if (hunk_fn)
|
|
|
|
ecb.out_hunk = xdiff_out_hunk;
|
xdiff: provide a separate emit callback for hunks
The xdiff library always emits hunk header lines to our callbacks as
formatted strings like "@@ -a,b +c,d @@\n". This is convenient if we're
going to output a diff, but less so if we actually need to compute using
those numbers, which requires re-parsing the line.
In preparation for moving away from this, let's teach xdiff a new
callback function which gets the broken-out hunk information. To help
callers that don't want to use this new callback, if it's NULL we'll
continue to format the hunk header into a string.
Note that this function renames the "outf" callback to "out_line", as
well. This isn't strictly necessary, but helps in two ways:
1. Now that there are two callbacks, it's nice to use more descriptive
names.
2. Many callers did not zero the emit_callback_data struct, and needed
to be modified to set ecb.out_hunk to NULL. By changing the name of
the existing struct member, that guarantees that any new callers
from in-flight topics will break the build and be examined
manually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-02 06:35:01 +00:00
|
|
|
ecb.out_line = xdiff_outf;
|
2010-05-04 20:41:34 +00:00
|
|
|
ecb.priv = &state;
|
2008-08-14 06:18:22 +00:00
|
|
|
strbuf_init(&state.remainder, 0);
|
2010-05-04 20:41:34 +00:00
|
|
|
ret = xdi_diff(mf1, mf2, xpp, xecfg, &ecb);
|
2008-08-14 06:18:22 +00:00
|
|
|
strbuf_release(&state.remainder);
|
Make xdi_diff_outf interface for running xdiff_outf diffs
To prepare for the need to initialize and release resources for an
xdi_diff with the xdiff_outf output function, make a new function to
wrap this usage.
Old:
ecb.outf = xdiff_outf;
ecb.priv = &state;
...
xdi_diff(file_p, file_o, &xpp, &xecfg, &ecb);
New:
xdi_diff_outf(file_p, file_o, &state.xm, &xpp, &xecfg, &ecb);
Signed-off-by: Brian Downing <bdowning@lavos.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-14 05:36:50 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-12-20 16:37:07 +00:00
|
|
|
int read_mmfile(mmfile_t *ptr, const char *filename)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
FILE *f;
|
2007-03-07 01:44:37 +00:00
|
|
|
size_t sz;
|
2006-12-20 16:37:07 +00:00
|
|
|
|
|
|
|
if (stat(filename, &st))
|
2017-05-03 10:16:55 +00:00
|
|
|
return error_errno("Could not stat %s", filename);
|
2006-12-20 16:37:07 +00:00
|
|
|
if ((f = fopen(filename, "rb")) == NULL)
|
2017-05-03 10:16:55 +00:00
|
|
|
return error_errno("Could not open %s", filename);
|
2007-03-07 01:44:37 +00:00
|
|
|
sz = xsize_t(st.st_size);
|
2008-03-13 15:19:35 +00:00
|
|
|
ptr->ptr = xmalloc(sz ? sz : 1);
|
2010-12-25 12:38:46 +00:00
|
|
|
if (sz && fread(ptr->ptr, sz, 1, f) != 1) {
|
|
|
|
fclose(f);
|
2006-12-20 16:37:07 +00:00
|
|
|
return error("Could not read %s", filename);
|
2010-12-25 12:38:46 +00:00
|
|
|
}
|
2006-12-20 16:37:07 +00:00
|
|
|
fclose(f);
|
2007-03-07 01:44:37 +00:00
|
|
|
ptr->size = sz;
|
2006-12-20 16:37:07 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-05 20:08:02 +00:00
|
|
|
void read_mmblob(mmfile_t *ptr, const struct object_id *oid)
|
2010-02-16 23:42:55 +00:00
|
|
|
{
|
|
|
|
unsigned long size;
|
|
|
|
enum object_type type;
|
|
|
|
|
convert "oidcmp() == 0" to oideq()
Using the more restrictive oideq() should, in the long run,
give the compiler more opportunities to optimize these
callsites. For now, this conversion should be a complete
noop with respect to the generated code.
The result is also perhaps a little more readable, as it
avoids the "zero is equal" idiom. Since it's so prevalent in
C, I think seasoned programmers tend not to even notice it
anymore, but it can sometimes make for awkward double
negations (e.g., we can drop a few !!oidcmp() instances
here).
This patch was generated almost entirely by the included
coccinelle patch. This mechanical conversion should be
completely safe, because we check explicitly for cases where
oidcmp() is compared to 0, which is what oideq() is doing
under the hood. Note that we don't have to catch "!oidcmp()"
separately; coccinelle's standard isomorphisms make sure the
two are treated equivalently.
I say "almost" because I did hand-edit the coccinelle output
to fix up a few style violations (it mostly keeps the
original formatting, but sometimes unwraps long lines).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-28 21:22:40 +00:00
|
|
|
if (oideq(oid, &null_oid)) {
|
2010-02-16 23:42:55 +00:00
|
|
|
ptr->ptr = xstrdup("");
|
|
|
|
ptr->size = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
sha1_file: convert read_sha1_file to struct object_id
Convert read_sha1_file to take a pointer to struct object_id and rename
it read_object_file. Do the same for read_sha1_file_extended.
Convert one use in grep.c to use the new function without any other code
change, since the pointer being passed is a void pointer that is already
initialized with a pointer to struct object_id. Update the declaration
and definitions of the modified functions, and apply the following
semantic patch to convert the remaining callers:
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1.hash, E2, E3)
+ read_object_file(&E1, E2, E3)
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1->hash, E2, E3)
+ read_object_file(E1, E2, E3)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1.hash, E2, E3, E4)
+ read_object_file_extended(&E1, E2, E3, E4)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1->hash, E2, E3, E4)
+ read_object_file_extended(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:53 +00:00
|
|
|
ptr->ptr = read_object_file(oid, &type, &size);
|
2010-02-16 23:42:55 +00:00
|
|
|
if (!ptr->ptr || type != OBJ_BLOB)
|
2016-09-05 20:08:02 +00:00
|
|
|
die("unable to read blob object %s", oid_to_hex(oid));
|
2010-02-16 23:42:55 +00:00
|
|
|
ptr->size = size;
|
|
|
|
}
|
|
|
|
|
2007-06-05 02:36:11 +00:00
|
|
|
#define FIRST_FEW_BYTES 8000
|
|
|
|
int buffer_is_binary(const char *ptr, unsigned long size)
|
|
|
|
{
|
|
|
|
if (FIRST_FEW_BYTES < size)
|
|
|
|
size = FIRST_FEW_BYTES;
|
|
|
|
return !!memchr(ptr, 0, size);
|
|
|
|
}
|
2007-07-06 07:45:10 +00:00
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
struct ff_regs *regs = priv;
|
|
|
|
regmatch_t pmatch[2];
|
2008-09-20 07:52:11 +00:00
|
|
|
int i;
|
2016-09-21 18:24:14 +00:00
|
|
|
int result;
|
2007-07-06 07:45:10 +00:00
|
|
|
|
2008-10-01 19:28:26 +00:00
|
|
|
/* Exclude terminating newline (and cr) from matching */
|
|
|
|
if (len > 0 && line[len-1] == '\n') {
|
2008-10-17 08:52:32 +00:00
|
|
|
if (len > 1 && line[len-2] == '\r')
|
|
|
|
len -= 2;
|
|
|
|
else
|
|
|
|
len--;
|
|
|
|
}
|
|
|
|
|
2007-07-06 07:45:10 +00:00
|
|
|
for (i = 0; i < regs->nr; i++) {
|
|
|
|
struct ff_reg *reg = regs->array + i;
|
2016-09-21 18:24:14 +00:00
|
|
|
if (!regexec_buf(®->re, line, len, 2, pmatch, 0)) {
|
2008-09-20 07:52:11 +00:00
|
|
|
if (reg->negate)
|
2016-09-21 18:24:14 +00:00
|
|
|
return -1;
|
2008-09-20 07:52:11 +00:00
|
|
|
break;
|
2007-07-06 07:45:10 +00:00
|
|
|
}
|
|
|
|
}
|
2008-09-20 07:52:11 +00:00
|
|
|
if (regs->nr <= i)
|
2016-09-21 18:24:14 +00:00
|
|
|
return -1;
|
2007-07-06 07:45:10 +00:00
|
|
|
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;
|
2010-09-09 19:02:46 +00:00
|
|
|
while (result > 0 && (isspace(line[result - 1])))
|
|
|
|
result--;
|
2007-07-06 07:45:10 +00:00
|
|
|
memcpy(buffer, line, result);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2008-09-18 22:42:48 +00:00
|
|
|
void xdiff_set_find_func(xdemitconf_t *xecfg, const char *value, int cflags)
|
2007-07-06 07:45:10 +00:00
|
|
|
{
|
|
|
|
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++;
|
2016-02-22 22:44:25 +00:00
|
|
|
ALLOC_ARRAY(regs->array, regs->nr);
|
2007-07-06 07:45:10 +00:00
|
|
|
for (i = 0; i < regs->nr; i++) {
|
|
|
|
struct ff_reg *reg = regs->array + i;
|
xdiff: avoid computing non-zero offset from NULL pointer
As with the previous commit, clang-11's UBSan complains about computing
offsets from a NULL pointer, causing some tests to fail. In this case,
though, we're actually computing a non-zero offset, which is even more
dubious. From t7810:
xdiff-interface.c:268:14: runtime error: applying non-zero offset 1 to null pointer
...
not ok 131 - grep -p with userdiff
The problem is our parsing of the funcname config. We count the number
of lines in the string, allocate an array, and then loop over our
allocated entries, parsing each line and moving our cursor to one past
the trailing newline for the next iteration.
But the final line will not generally have a trailing newline (since
it's a config value), and hence we go to one past NULL. In practice this
is OK, since our loop should terminate before we look at the value. But
even computing such an invalid pointer technically violates the
standard.
We can fix it by leaving the pointer at NULL if we're at the end, rather
than one-past. And while we're thinking about it, we can also document
the variant by asserting that our initial line-count matches the
second-pass of parsing.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-25 05:39:29 +00:00
|
|
|
const char *ep, *expression;
|
2007-07-06 07:45:10 +00:00
|
|
|
char *buffer = NULL;
|
|
|
|
|
xdiff: avoid computing non-zero offset from NULL pointer
As with the previous commit, clang-11's UBSan complains about computing
offsets from a NULL pointer, causing some tests to fail. In this case,
though, we're actually computing a non-zero offset, which is even more
dubious. From t7810:
xdiff-interface.c:268:14: runtime error: applying non-zero offset 1 to null pointer
...
not ok 131 - grep -p with userdiff
The problem is our parsing of the funcname config. We count the number
of lines in the string, allocate an array, and then loop over our
allocated entries, parsing each line and moving our cursor to one past
the trailing newline for the next iteration.
But the final line will not generally have a trailing newline (since
it's a config value), and hence we go to one past NULL. In practice this
is OK, since our loop should terminate before we look at the value. But
even computing such an invalid pointer technically violates the
standard.
We can fix it by leaving the pointer at NULL if we're at the end, rather
than one-past. And while we're thinking about it, we can also document
the variant by asserting that our initial line-count matches the
second-pass of parsing.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-25 05:39:29 +00:00
|
|
|
if (!value)
|
|
|
|
BUG("mismatch between line count and parsing");
|
|
|
|
ep = strchr(value, '\n');
|
|
|
|
|
2007-07-06 07:45:10 +00:00
|
|
|
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;
|
2008-09-18 22:42:48 +00:00
|
|
|
if (regcomp(®->re, expression, cflags))
|
2007-07-06 07:45:10 +00:00
|
|
|
die("Invalid regexp to look for hunk header: %s", expression);
|
Avoid unnecessary "if-before-free" tests.
This change removes all obvious useless if-before-free tests.
E.g., it replaces code like this:
if (some_expression)
free (some_expression);
with the now-equivalent:
free (some_expression);
It is equivalent not just because POSIX has required free(NULL)
to work for a long time, but simply because it has worked for
so long that no reasonable porting target fails the test.
Here's some evidence from nearly 1.5 years ago:
http://www.winehq.org/pipermail/wine-patches/2006-October/031544.html
FYI, the change below was prepared by running the following:
git ls-files -z | xargs -0 \
perl -0x3b -pi -e \
's/\bif\s*\(\s*(\S+?)(?:\s*!=\s*NULL)?\s*\)\s+(free\s*\(\s*\1\s*\))/$2/s'
Note however, that it doesn't handle brace-enclosed blocks like
"if (x) { free (x); }". But that's ok, since there were none like
that in git sources.
Beware: if you do use the above snippet, note that it can
produce syntactically invalid C code. That happens when the
affected "if"-statement has a matching "else".
E.g., it would transform this
if (x)
free (x);
else
foo ();
into this:
free (x);
else
foo ();
There were none of those here, either.
If you're interested in automating detection of the useless
tests, you might like the useless-if-before-free script in gnulib:
[it *does* detect brace-enclosed free statements, and has a --name=S
option to make it detect free-like functions with different names]
http://git.sv.gnu.org/gitweb/?p=gnulib.git;a=blob;f=build-aux/useless-if-before-free
Addendum:
Remove one more (in imap-send.c), spotted by Jean-Luc Herren <jlh@gmx.ch>.
Signed-off-by: Jim Meyering <meyering@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-31 17:26:32 +00:00
|
|
|
free(buffer);
|
xdiff: avoid computing non-zero offset from NULL pointer
As with the previous commit, clang-11's UBSan complains about computing
offsets from a NULL pointer, causing some tests to fail. In this case,
though, we're actually computing a non-zero offset, which is even more
dubious. From t7810:
xdiff-interface.c:268:14: runtime error: applying non-zero offset 1 to null pointer
...
not ok 131 - grep -p with userdiff
The problem is our parsing of the funcname config. We count the number
of lines in the string, allocate an array, and then loop over our
allocated entries, parsing each line and moving our cursor to one past
the trailing newline for the next iteration.
But the final line will not generally have a trailing newline (since
it's a config value), and hence we go to one past NULL. In practice this
is OK, since our loop should terminate before we look at the value. But
even computing such an invalid pointer technically violates the
standard.
We can fix it by leaving the pointer at NULL if we're at the end, rather
than one-past. And while we're thinking about it, we can also document
the variant by asserting that our initial line-count matches the
second-pass of parsing.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-01-25 05:39:29 +00:00
|
|
|
value = ep ? ep + 1 : NULL;
|
2007-07-06 07:45:10 +00:00
|
|
|
}
|
|
|
|
}
|
2008-08-29 17:49:56 +00:00
|
|
|
|
2009-07-01 22:01:43 +00:00
|
|
|
void xdiff_clear_find_func(xdemitconf_t *xecfg)
|
|
|
|
{
|
|
|
|
if (xecfg->find_func) {
|
|
|
|
int i;
|
|
|
|
struct ff_regs *regs = xecfg->find_func_priv;
|
|
|
|
|
|
|
|
for (i = 0; i < regs->nr; i++)
|
|
|
|
regfree(®s->array[i].re);
|
|
|
|
free(regs->array);
|
|
|
|
free(regs);
|
|
|
|
xecfg->find_func = NULL;
|
|
|
|
xecfg->find_func_priv = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-25 18:49:11 +00:00
|
|
|
unsigned long xdiff_hash_string(const char *s, size_t len, long flags)
|
|
|
|
{
|
|
|
|
return xdl_hash_record(&s, s + len, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
int xdiff_compare_lines(const char *l1, long s1,
|
|
|
|
const char *l2, long s2, long flags)
|
|
|
|
{
|
|
|
|
return xdl_recmatch(l1, s1, l2, s2, flags);
|
|
|
|
}
|
|
|
|
|
2008-08-29 17:49:56 +00:00
|
|
|
int git_xmerge_style = -1;
|
|
|
|
|
|
|
|
int git_xmerge_config(const char *var, const char *value, void *cb)
|
|
|
|
{
|
2011-05-14 20:19:21 +00:00
|
|
|
if (!strcmp(var, "merge.conflictstyle")) {
|
2008-08-29 17:49:56 +00:00
|
|
|
if (!value)
|
|
|
|
die("'%s' is not a boolean", var);
|
|
|
|
if (!strcmp(value, "diff3"))
|
|
|
|
git_xmerge_style = XDL_MERGE_DIFF3;
|
|
|
|
else if (!strcmp(value, "merge"))
|
|
|
|
git_xmerge_style = 0;
|
2019-02-16 11:24:41 +00:00
|
|
|
/*
|
|
|
|
* Please update _git_checkout() in
|
|
|
|
* git-completion.bash when you add new merge config
|
|
|
|
*/
|
2008-08-29 17:49:56 +00:00
|
|
|
else
|
|
|
|
die("unknown style '%s' given for '%s'",
|
|
|
|
value, var);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return git_default_config(var, value, cb);
|
|
|
|
}
|