mirror of
https://github.com/git/git
synced 2024-08-27 19:49:21 +00:00
![Johannes Schindelin](/assets/img/avatar_default.png)
When comparing two lines, ignoring any whitespace at the end, we first try to match as many bytes as possible and break out of the loop only upon mismatch, to let the remainder be handled by the code shared with the other whitespace-ignoring code paths. When comparing the bytes, however, we incremented the counters always, even if the bytes did not match. And because we fall through to the space-at-eol handling at that point, it is as if that mismatch never happened. Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de> Signed-off-by: Junio C Hamano <gitster@pobox.com>
498 lines
11 KiB
C
498 lines
11 KiB
C
/*
|
|
* LibXDiff by Davide Libenzi ( File Differential Library )
|
|
* Copyright (C) 2003 Davide Libenzi
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
* Davide Libenzi <davidel@xmailserver.org>
|
|
*
|
|
*/
|
|
|
|
#include <limits.h>
|
|
#include <assert.h>
|
|
#include "xinclude.h"
|
|
|
|
|
|
|
|
|
|
long xdl_bogosqrt(long n) {
|
|
long i;
|
|
|
|
/*
|
|
* Classical integer square root approximation using shifts.
|
|
*/
|
|
for (i = 1; n > 0; n >>= 2)
|
|
i <<= 1;
|
|
|
|
return i;
|
|
}
|
|
|
|
|
|
int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize,
|
|
xdemitcb_t *ecb) {
|
|
int i = 2;
|
|
mmbuffer_t mb[3];
|
|
|
|
mb[0].ptr = (char *) pre;
|
|
mb[0].size = psize;
|
|
mb[1].ptr = (char *) rec;
|
|
mb[1].size = size;
|
|
if (size > 0 && rec[size - 1] != '\n') {
|
|
mb[2].ptr = (char *) "\n\\ No newline at end of file\n";
|
|
mb[2].size = strlen(mb[2].ptr);
|
|
i++;
|
|
}
|
|
if (ecb->outf(ecb->priv, mb, i) < 0) {
|
|
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void *xdl_mmfile_first(mmfile_t *mmf, long *size)
|
|
{
|
|
*size = mmf->size;
|
|
return mmf->ptr;
|
|
}
|
|
|
|
|
|
long xdl_mmfile_size(mmfile_t *mmf)
|
|
{
|
|
return mmf->size;
|
|
}
|
|
|
|
|
|
int xdl_cha_init(chastore_t *cha, long isize, long icount) {
|
|
|
|
cha->head = cha->tail = NULL;
|
|
cha->isize = isize;
|
|
cha->nsize = icount * isize;
|
|
cha->ancur = cha->sncur = NULL;
|
|
cha->scurr = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void xdl_cha_free(chastore_t *cha) {
|
|
chanode_t *cur, *tmp;
|
|
|
|
for (cur = cha->head; (tmp = cur) != NULL;) {
|
|
cur = cur->next;
|
|
xdl_free(tmp);
|
|
}
|
|
}
|
|
|
|
|
|
void *xdl_cha_alloc(chastore_t *cha) {
|
|
chanode_t *ancur;
|
|
void *data;
|
|
|
|
if (!(ancur = cha->ancur) || ancur->icurr == cha->nsize) {
|
|
if (!(ancur = (chanode_t *) xdl_malloc(sizeof(chanode_t) + cha->nsize))) {
|
|
|
|
return NULL;
|
|
}
|
|
ancur->icurr = 0;
|
|
ancur->next = NULL;
|
|
if (cha->tail)
|
|
cha->tail->next = ancur;
|
|
if (!cha->head)
|
|
cha->head = ancur;
|
|
cha->tail = ancur;
|
|
cha->ancur = ancur;
|
|
}
|
|
|
|
data = (char *) ancur + sizeof(chanode_t) + ancur->icurr;
|
|
ancur->icurr += cha->isize;
|
|
|
|
return data;
|
|
}
|
|
|
|
long xdl_guess_lines(mmfile_t *mf, long sample) {
|
|
long nl = 0, size, tsize = 0;
|
|
char const *data, *cur, *top;
|
|
|
|
if ((cur = data = xdl_mmfile_first(mf, &size)) != NULL) {
|
|
for (top = data + size; nl < sample && cur < top; ) {
|
|
nl++;
|
|
if (!(cur = memchr(cur, '\n', top - cur)))
|
|
cur = top;
|
|
else
|
|
cur++;
|
|
}
|
|
tsize += (long) (cur - data);
|
|
}
|
|
|
|
if (nl && tsize)
|
|
nl = xdl_mmfile_size(mf) / (tsize / nl);
|
|
|
|
return nl + 1;
|
|
}
|
|
|
|
int xdl_blankline(const char *line, long size, long flags)
|
|
{
|
|
long i;
|
|
|
|
if (!(flags & XDF_WHITESPACE_FLAGS))
|
|
return (size <= 1);
|
|
|
|
for (i = 0; i < size && XDL_ISSPACE(line[i]); i++)
|
|
;
|
|
|
|
return (i == size);
|
|
}
|
|
|
|
int xdl_recmatch(const char *l1, long s1, const char *l2, long s2, long flags)
|
|
{
|
|
int i1, i2;
|
|
|
|
if (s1 == s2 && !memcmp(l1, l2, s1))
|
|
return 1;
|
|
if (!(flags & XDF_WHITESPACE_FLAGS))
|
|
return 0;
|
|
|
|
i1 = 0;
|
|
i2 = 0;
|
|
|
|
/*
|
|
* -w matches everything that matches with -b, and -b in turn
|
|
* matches everything that matches with --ignore-space-at-eol.
|
|
*
|
|
* Each flavor of ignoring needs different logic to skip whitespaces
|
|
* while we have both sides to compare.
|
|
*/
|
|
if (flags & XDF_IGNORE_WHITESPACE) {
|
|
goto skip_ws;
|
|
while (i1 < s1 && i2 < s2) {
|
|
if (l1[i1++] != l2[i2++])
|
|
return 0;
|
|
skip_ws:
|
|
while (i1 < s1 && XDL_ISSPACE(l1[i1]))
|
|
i1++;
|
|
while (i2 < s2 && XDL_ISSPACE(l2[i2]))
|
|
i2++;
|
|
}
|
|
} else if (flags & XDF_IGNORE_WHITESPACE_CHANGE) {
|
|
while (i1 < s1 && i2 < s2) {
|
|
if (XDL_ISSPACE(l1[i1]) && XDL_ISSPACE(l2[i2])) {
|
|
/* Skip matching spaces and try again */
|
|
while (i1 < s1 && XDL_ISSPACE(l1[i1]))
|
|
i1++;
|
|
while (i2 < s2 && XDL_ISSPACE(l2[i2]))
|
|
i2++;
|
|
continue;
|
|
}
|
|
if (l1[i1++] != l2[i2++])
|
|
return 0;
|
|
}
|
|
} else if (flags & XDF_IGNORE_WHITESPACE_AT_EOL) {
|
|
while (i1 < s1 && i2 < s2 && l1[i1] == l2[i2]) {
|
|
i1++;
|
|
i2++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* After running out of one side, the remaining side must have
|
|
* nothing but whitespace for the lines to match. Note that
|
|
* ignore-whitespace-at-eol case may break out of the loop
|
|
* while there still are characters remaining on both lines.
|
|
*/
|
|
if (i1 < s1) {
|
|
while (i1 < s1 && XDL_ISSPACE(l1[i1]))
|
|
i1++;
|
|
if (s1 != i1)
|
|
return 0;
|
|
}
|
|
if (i2 < s2) {
|
|
while (i2 < s2 && XDL_ISSPACE(l2[i2]))
|
|
i2++;
|
|
return (s2 == i2);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static unsigned long xdl_hash_record_with_whitespace(char const **data,
|
|
char const *top, long flags) {
|
|
unsigned long ha = 5381;
|
|
char const *ptr = *data;
|
|
|
|
for (; ptr < top && *ptr != '\n'; ptr++) {
|
|
if (XDL_ISSPACE(*ptr)) {
|
|
const char *ptr2 = ptr;
|
|
int at_eol;
|
|
while (ptr + 1 < top && XDL_ISSPACE(ptr[1])
|
|
&& ptr[1] != '\n')
|
|
ptr++;
|
|
at_eol = (top <= ptr + 1 || ptr[1] == '\n');
|
|
if (flags & XDF_IGNORE_WHITESPACE)
|
|
; /* already handled */
|
|
else if (flags & XDF_IGNORE_WHITESPACE_CHANGE
|
|
&& !at_eol) {
|
|
ha += (ha << 5);
|
|
ha ^= (unsigned long) ' ';
|
|
}
|
|
else if (flags & XDF_IGNORE_WHITESPACE_AT_EOL
|
|
&& !at_eol) {
|
|
while (ptr2 != ptr + 1) {
|
|
ha += (ha << 5);
|
|
ha ^= (unsigned long) *ptr2;
|
|
ptr2++;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
ha += (ha << 5);
|
|
ha ^= (unsigned long) *ptr;
|
|
}
|
|
*data = ptr < top ? ptr + 1: ptr;
|
|
|
|
return ha;
|
|
}
|
|
|
|
#ifdef XDL_FAST_HASH
|
|
|
|
#define REPEAT_BYTE(x) ((~0ul / 0xff) * (x))
|
|
|
|
#define ONEBYTES REPEAT_BYTE(0x01)
|
|
#define NEWLINEBYTES REPEAT_BYTE(0x0a)
|
|
#define HIGHBITS REPEAT_BYTE(0x80)
|
|
|
|
/* Return the high bit set in the first byte that is a zero */
|
|
static inline unsigned long has_zero(unsigned long a)
|
|
{
|
|
return ((a - ONEBYTES) & ~a) & HIGHBITS;
|
|
}
|
|
|
|
static inline long count_masked_bytes(unsigned long mask)
|
|
{
|
|
if (sizeof(long) == 8) {
|
|
/*
|
|
* Jan Achrenius on G+: microoptimized version of
|
|
* the simpler "(mask & ONEBYTES) * ONEBYTES >> 56"
|
|
* that works for the bytemasks without having to
|
|
* mask them first.
|
|
*/
|
|
/*
|
|
* return mask * 0x0001020304050608 >> 56;
|
|
*
|
|
* Doing it like this avoids warnings on 32-bit machines.
|
|
*/
|
|
long a = (REPEAT_BYTE(0x01) / 0xff + 1);
|
|
return mask * a >> (sizeof(long) * 7);
|
|
} else {
|
|
/* Carl Chatfield / Jan Achrenius G+ version for 32-bit */
|
|
/* (000000 0000ff 00ffff ffffff) -> ( 1 1 2 3 ) */
|
|
long a = (0x0ff0001 + mask) >> 23;
|
|
/* Fix the 1 for 00 case */
|
|
return a & mask;
|
|
}
|
|
}
|
|
|
|
unsigned long xdl_hash_record(char const **data, char const *top, long flags)
|
|
{
|
|
unsigned long hash = 5381;
|
|
unsigned long a = 0, mask = 0;
|
|
char const *ptr = *data;
|
|
char const *end = top - sizeof(unsigned long) + 1;
|
|
|
|
if (flags & XDF_WHITESPACE_FLAGS)
|
|
return xdl_hash_record_with_whitespace(data, top, flags);
|
|
|
|
ptr -= sizeof(unsigned long);
|
|
do {
|
|
hash += hash << 5;
|
|
hash ^= a;
|
|
ptr += sizeof(unsigned long);
|
|
if (ptr >= end)
|
|
break;
|
|
a = *(unsigned long *)ptr;
|
|
/* Do we have any '\n' bytes in this word? */
|
|
mask = has_zero(a ^ NEWLINEBYTES);
|
|
} while (!mask);
|
|
|
|
if (ptr >= end) {
|
|
/*
|
|
* There is only a partial word left at the end of the
|
|
* buffer. Because we may work with a memory mapping,
|
|
* we have to grab the rest byte by byte instead of
|
|
* blindly reading it.
|
|
*
|
|
* To avoid problems with masking in a signed value,
|
|
* we use an unsigned char here.
|
|
*/
|
|
const char *p;
|
|
for (p = top - 1; p >= ptr; p--)
|
|
a = (a << 8) + *((const unsigned char *)p);
|
|
mask = has_zero(a ^ NEWLINEBYTES);
|
|
if (!mask)
|
|
/*
|
|
* No '\n' found in the partial word. Make a
|
|
* mask that matches what we read.
|
|
*/
|
|
mask = 1UL << (8 * (top - ptr) + 7);
|
|
}
|
|
|
|
/* The mask *below* the first high bit set */
|
|
mask = (mask - 1) & ~mask;
|
|
mask >>= 7;
|
|
hash += hash << 5;
|
|
hash ^= a & mask;
|
|
|
|
/* Advance past the last (possibly partial) word */
|
|
ptr += count_masked_bytes(mask);
|
|
|
|
if (ptr < top) {
|
|
assert(*ptr == '\n');
|
|
ptr++;
|
|
}
|
|
|
|
*data = ptr;
|
|
|
|
return hash;
|
|
}
|
|
|
|
#else /* XDL_FAST_HASH */
|
|
|
|
unsigned long xdl_hash_record(char const **data, char const *top, long flags) {
|
|
unsigned long ha = 5381;
|
|
char const *ptr = *data;
|
|
|
|
if (flags & XDF_WHITESPACE_FLAGS)
|
|
return xdl_hash_record_with_whitespace(data, top, flags);
|
|
|
|
for (; ptr < top && *ptr != '\n'; ptr++) {
|
|
ha += (ha << 5);
|
|
ha ^= (unsigned long) *ptr;
|
|
}
|
|
*data = ptr < top ? ptr + 1: ptr;
|
|
|
|
return ha;
|
|
}
|
|
|
|
#endif /* XDL_FAST_HASH */
|
|
|
|
unsigned int xdl_hashbits(unsigned int size) {
|
|
unsigned int val = 1, bits = 0;
|
|
|
|
for (; val < size && bits < CHAR_BIT * sizeof(unsigned int); val <<= 1, bits++);
|
|
return bits ? bits: 1;
|
|
}
|
|
|
|
|
|
int xdl_num_out(char *out, long val) {
|
|
char *ptr, *str = out;
|
|
char buf[32];
|
|
|
|
ptr = buf + sizeof(buf) - 1;
|
|
*ptr = '\0';
|
|
if (val < 0) {
|
|
*--ptr = '-';
|
|
val = -val;
|
|
}
|
|
for (; val && ptr > buf; val /= 10)
|
|
*--ptr = "0123456789"[val % 10];
|
|
if (*ptr)
|
|
for (; *ptr; ptr++, str++)
|
|
*str = *ptr;
|
|
else
|
|
*str++ = '0';
|
|
*str = '\0';
|
|
|
|
return str - out;
|
|
}
|
|
|
|
int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2,
|
|
const char *func, long funclen, xdemitcb_t *ecb) {
|
|
int nb = 0;
|
|
mmbuffer_t mb;
|
|
char buf[128];
|
|
|
|
memcpy(buf, "@@ -", 4);
|
|
nb += 4;
|
|
|
|
nb += xdl_num_out(buf + nb, c1 ? s1: s1 - 1);
|
|
|
|
if (c1 != 1) {
|
|
memcpy(buf + nb, ",", 1);
|
|
nb += 1;
|
|
|
|
nb += xdl_num_out(buf + nb, c1);
|
|
}
|
|
|
|
memcpy(buf + nb, " +", 2);
|
|
nb += 2;
|
|
|
|
nb += xdl_num_out(buf + nb, c2 ? s2: s2 - 1);
|
|
|
|
if (c2 != 1) {
|
|
memcpy(buf + nb, ",", 1);
|
|
nb += 1;
|
|
|
|
nb += xdl_num_out(buf + nb, c2);
|
|
}
|
|
|
|
memcpy(buf + nb, " @@", 3);
|
|
nb += 3;
|
|
if (func && funclen) {
|
|
buf[nb++] = ' ';
|
|
if (funclen > sizeof(buf) - nb - 1)
|
|
funclen = sizeof(buf) - nb - 1;
|
|
memcpy(buf + nb, func, funclen);
|
|
nb += funclen;
|
|
}
|
|
buf[nb++] = '\n';
|
|
|
|
mb.ptr = buf;
|
|
mb.size = nb;
|
|
if (ecb->outf(ecb->priv, &mb, 1) < 0)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp,
|
|
int line1, int count1, int line2, int count2)
|
|
{
|
|
/*
|
|
* This probably does not work outside Git, since
|
|
* we have a very simple mmfile structure.
|
|
*
|
|
* Note: ideally, we would reuse the prepared environment, but
|
|
* the libxdiff interface does not (yet) allow for diffing only
|
|
* ranges of lines instead of the whole files.
|
|
*/
|
|
mmfile_t subfile1, subfile2;
|
|
xdfenv_t env;
|
|
|
|
subfile1.ptr = (char *)diff_env->xdf1.recs[line1 - 1]->ptr;
|
|
subfile1.size = diff_env->xdf1.recs[line1 + count1 - 2]->ptr +
|
|
diff_env->xdf1.recs[line1 + count1 - 2]->size - subfile1.ptr;
|
|
subfile2.ptr = (char *)diff_env->xdf2.recs[line2 - 1]->ptr;
|
|
subfile2.size = diff_env->xdf2.recs[line2 + count2 - 2]->ptr +
|
|
diff_env->xdf2.recs[line2 + count2 - 2]->size - subfile2.ptr;
|
|
if (xdl_do_diff(&subfile1, &subfile2, xpp, &env) < 0)
|
|
return -1;
|
|
|
|
memcpy(diff_env->xdf1.rchg + line1 - 1, env.xdf1.rchg, count1);
|
|
memcpy(diff_env->xdf2.rchg + line2 - 1, env.xdf2.rchg, count2);
|
|
|
|
xdl_free_env(&env);
|
|
|
|
return 0;
|
|
}
|