src/usr.bin/cvs/diff_internals.c - diff

Return to diff_internals.c CVS log

Up to [local] / src / usr.bin / cvs

Diff for /src/usr.bin/cvs/diff_internals.c between version 1.13 and 1.14

version 1.13, 2007/05/30 03:30:21

version 1.14, 2007/06/29 05:04:40

Line 63

* @(#)diffreg.c 8.1 (Berkeley) 6/6/93

#include <sys/param.h>

#include <sys/stat.h>

#include <ctype.h>

#include <errno.h>

#include <regex.h>

#include <stddef.h>

#include <string.h>

#include <unistd.h>

#include "cvs.h"

#include "diff.h"

* diff - compare two files.

* Uses an algorithm due to Harold Stone, which finds

* a pair of longest identical subsequences in the two

* files.

Line 126

Line 144

* 6n words for files of length n.

#include <sys/param.h>

#include <sys/stat.h>

#include <ctype.h>

#include <errno.h>

#include <regex.h>

#include <stddef.h>

#include <string.h>

#include <unistd.h>

#include "cvs.h"

#include "diff.h"

struct cand {

int x;

int y;

Line 168

Line 173

static void uni_range(int, int);

static void dump_context_vec(FILE *, FILE *);

static void dump_unified_vec(FILE *, FILE *);

static int prepare(int, FILE *, off_t);

static void prepare(int, FILE *, off_t);

static void prune(void);

static void equiv(struct line *, int, struct line *, int, int *);

static void unravel(int);

Line 206

Line 211

static int *member; /* will be overlaid on file[1] */

static int clen;

static int inifdef; /* whether or not we are in a #ifdef block */

static int diff_len[2];

static int len[2];

static int pref, suff; /* length of prefix and suffix */

static int slen[2];

static int anychange;

Line 226

Line 231

static int lastmatchline;

BUF *diffbuf = NULL;

* chrtran points to one of 2 translation tables: cup2low if folding upper to

* lower case clow2low if not folding case

Line 320

Line 326

cvs_log(LP_ERR, "%s", file2);

goto closem;

}

switch (files_differ(f1, f2)) {

case 0:

goto closem;

Line 334

Line 341

rval = D_BINARY;

goto closem;

}

if (prepare(0, f1, stb1.st_size) < 0 ||

prepare(1, f2, stb2.st_size) < 0) {

prepare(0, f1, stb1.st_size);

goto closem;

prepare(1, f2, stb2.st_size);

}

prune();

sort(sfile[0], slen[0]);

sort(sfile[1], slen[1]);

Line 354

Line 361

clen = 0;

clistlen = 100;

clist = xcalloc(clistlen, sizeof(*clist));

i = stone(class, slen[0], member, klist);

if ((i = stone(class, slen[0], member, klist)) < 0)

goto closem;

xfree(member);

xfree(class);

J = xrealloc(J, diff_len[0] + 2, sizeof(*J));

J = xrealloc(J, len[0] + 2, sizeof(*J));

unravel(klist[i]);

xfree(clist);

xfree(klist);

ixold = xrealloc(ixold, diff_len[0] + 2, sizeof(*ixold));

ixold = xrealloc(ixold, len[0] + 2, sizeof(*ixold));

ixnew = xrealloc(ixnew, len[1] + 2, sizeof(*ixnew));

ixnew = xrealloc(ixnew, diff_len[1] + 2, sizeof(*ixnew));

check(f1, f2);

output(f1, f2);

closem:

if (anychange == 1) {

if (anychange) {

if (rval == D_SAME)

rval = D_DIFFER;

}

Line 413

Line 416

}

static int

static void

prepare(int i, FILE *fd, off_t filesize)

{

struct line *p;

Line 428

Line 431

p = xcalloc(sz + 3, sizeof(*p));

for (j = 0; (h = readhash(fd));) {

if (j == (int)sz) {

if (j == sz) {

sz = sz * 3 / 2;

p = xrealloc(p, sz + 3, sizeof(*p));

}

p[++j].value = h;

}

diff_len[i] = j;

len[i] = j;

file[i] = p;

return (0);

}

static void

Line 445

Line 446

{

int i, j;

for (pref = 0; pref < diff_len[0] && pref < diff_len[1] &&

for (pref = 0; pref < len[0] && pref < len[1] &&

file[0][pref + 1].value == file[1][pref + 1].value;

pref++)

;

for (suff = 0;

for (suff = 0; suff < len[0] - pref && suff < len[1] - pref &&

(suff < diff_len[0] - pref) && (suff < diff_len[1] - pref) &&

file[0][len[0] - suff].value == file[1][len[1] - suff].value;

(file[0][diff_len[0] - suff].value ==

file[1][diff_len[1] - suff].value);

suff++)

;

for (j = 0; j < 2; j++) {

sfile[j] = file[j] + pref;

slen[j] = diff_len[j] - pref - suff;

slen[j] = len[j] - pref - suff;

for (i = 0; i <= slen[j]; i++)

sfile[j][i].serial = i;

}

Line 505

Line 504

x = n / x;

x += y;

x /= 2;

} while (x - y > 1 || x - y < -1);

} while ((x - y) > 1 || (x - y) < -1);

return (x);

}

Line 513

Line 512

static int

stone(int *a, int n, int *b, int *c)

{

int ret;

int i, k, y, j, l;

int oldc, tc, oldl;

u_int numtries;

Line 522

Line 520

const u_int bound = dflag ? UINT_MAX : MAX(256, (u_int)isqrt(n));

k = 0;

if ((ret = newcand(0, 0, 0)) < 0)

c[0] = newcand(0, 0, 0);

return (-1);

c[0] = ret;

for (i = 1; i <= n; i++) {

j = a[i];

if (j == 0)

Line 543

Line 539

if (clist[c[l]].y <= y)

continue;

tc = c[l];

if ((ret = newcand(i, y, oldc)) < 0)

c[l] = newcand(i, y, oldc);

return (-1);

c[l] = ret;

oldc = tc;

oldl = l;

numtries++;

} else {

if ((ret = newcand(i, y, oldc)) < 0)

c[l] = newcand(i, y, oldc);

return (-1);

c[l] = ret;

k++;

break;

}

Line 607

Line 599

struct cand *q;

int i;

for (i = 0; i <= diff_len[0]; i++)

for (i = 0; i <= len[0]; i++)

J[i] = i <= pref ? i :

i > diff_len[0] - suff ? i + diff_len[1] - diff_len[0] : 0;

i > len[0] - suff ? i + len[1] - len[0] : 0;

for (q = clist + p; q->y != 0; q = clist + q->pred)

J[q->x + pref] = q->y + pref;

}

Line 632

Line 624

ixold[0] = ixnew[0] = 0;

jackpot = 0;

ctold = ctnew = 0;

for (i = 1; i <= diff_len[0]; i++) {

for (i = 1; i <= len[0]; i++) {

if (J[i] == 0) {

ixold[i] = ctold += skipline(f1);

continue;

Line 647

Line 639

d = getc(f2);

* GNU diff ignores a missing newline

* in one file if bflag || wflag.

* in one file for -b or -w.

if ((bflag == 1 || wflag == 1) &&

((c == EOF && d == '\n') ||

Line 710

Line 702

ixnew[j] = ctnew;

j++;

}

for (; j <= diff_len[1]; j++)

for (; j <= len[1]; j++)

ixnew[j] = ctnew += skipline(f2);

* if (jackpot != 0)

* if (jackpot)

* cvs_printf("jackpot\n");

* fprintf(stderr, "jackpot\n");

}

Line 781

Line 773

rewind(f1);

rewind(f2);

m = diff_len[0];

m = len[0];

J[0] = 0;

J[m + 1] = diff_len[1] + 1;

J[m + 1] = len[1] + 1;

for (i0 = 1; i0 <= m; i0 = i1 + 1) {

while (i0 <= m && J[i0] == J[i0 - 1] + 1)

i0++;

Line 796

Line 788

change(f1, f2, i0, i1, j0, j1);

}

if (m == 0)

change(f1, f2, 1, 0, 1, diff_len[1]);

change(f1, f2, 1, 0, 1, len[1]);

if (diff_format == D_IFDEF) {

for (;;) {

#define c i0

Line 869

Line 861

static void

change(FILE *f1, FILE *f2, int a, int b, int c, int d)

{

int i;

static size_t max_context = 64;

char buf[64];

struct tm *t;

int i;

if (diff_format != D_IFDEF && a > b && c > d)

return;

Line 1101

Line 1093

for (i = 0;;) {

switch (t = getc(f)) {

case '\t':

case '\r':

case '\v':

case '\f':

case ' ':

space++;

continue;

Line 1132

Line 1127

static int

asciifile(FILE *f)

{

char buf[BUFSIZ];

unsigned char buf[BUFSIZ];

size_t i, cnt;

if (aflag == 1 || f == NULL)

Line 1148

Line 1143

#define begins_with(s, pre) (strncmp(s, pre, sizeof(pre)-1) == 0)

static char*

static char *

match_function(const long *f, int pos, FILE *fp)

{

unsigned char buf[FUNCTION_CONTEXT_SIZE];

Line 1180

Line 1175

if (!state)

state = " (public)";

} else {

strlcpy(lastbuf, (const char *)buf,

strlcpy(lastbuf, buf,

sizeof lastbuf);

if (state)

strlcat(lastbuf, state,

Line 1192

Line 1187

}

pos--;

}

return (lastmatchline > 0) ? lastbuf : NULL;

return lastmatchline > 0 ? lastbuf : NULL;

}

/* dump accumulated "context" diff changes */

static void

dump_context_vec(FILE *f1, FILE *f2)

Line 1210

Line 1204

b = d = 0; /* gcc */

lowa = MAX(1, cvp->a - context);

upb = MIN(diff_len[0], context_vec_ptr->b + context);

upb = MIN(len[0], context_vec_ptr->b + context);

lowc = MAX(1, cvp->c - context);

upd = MIN(diff_len[1], context_vec_ptr->d + context);

upd = MIN(len[1], context_vec_ptr->d + context);

diff_output("***************");

if (diff_pflag == 1) {

f = match_function(ixold, lowa - 1, f1);

f = match_function(ixold, lowa-1, f1);

if (f != NULL) {

diff_output(" ");

diff_output("%s", f);

Line 1238

Line 1232

do_output++;

break;

}

if (do_output != 0) {

if (do_output) {

while (cvp <= context_vec_ptr) {

a = cvp->a;

b = cvp->b;

Line 1274

Line 1268

do_output++;

break;

}

if (do_output != 0) {

if (do_output) {

while (cvp <= context_vec_ptr) {

a = cvp->a;

b = cvp->b;

Line 1315

Line 1309

b = d = 0; /* gcc */

lowa = MAX(1, cvp->a - context);

upb = MIN(diff_len[0], context_vec_ptr->b + context);

upb = MIN(len[0], context_vec_ptr->b + context);

lowc = MAX(1, cvp->c - context);

upd = MIN(diff_len[1], context_vec_ptr->d + context);

upd = MIN(len[1], context_vec_ptr->d + context);

diff_output("@@ -");

uni_range(lowa, upb);

Line 1325

Line 1319

uni_range(lowc, upd);

diff_output(" @@");

if (diff_pflag == 1) {

f = match_function(ixold, lowa - 1, f1);

f = match_function(ixold, lowa-1, f1);

if (f != NULL) {

diff_output(" ");

diff_output("%s", f);