#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ctype.h>
#include "diff.h"

struct line {
       int     serial;
       int     value;
};
extern struct line *file[2];
extern int len[2];
extern long *ixold, *ixnew;
extern int *J;

static Biobuf *input[2];
static char *file1, *file2;
static int firstchange;

#define MAXLINELEN      4096
#define MIN(x, y)       ((x) < (y) ? (x): (y))

static int
readline(Biobuf *bp, char *buf)
{
       int c;
       char *p, *e;

       p = buf;
       e = p + MAXLINELEN-1;
       do {
               c = Bgetc(bp);
               if (c < 0) {
                       if (p == buf)
                               return -1;
                       break;
               }
               if (c == '\n')
                       break;
               *p++ = c;
       } while (p < e);
       *p = 0;
       if (c != '\n' && c >= 0) {
               do c = Bgetc(bp);
               while (c >= 0 && c != '\n');
       }
       return p - buf;
}

#define HALFLONG 16
#define low(x)  (x&((1L<<HALFLONG)-1))
#define high(x) (x>>HALFLONG)

/*
* hashing has the effect of
* arranging line in 7-bit bytes and then
* summing 1-s complement in 16-bit hunks
*/
static int
readhash(Biobuf *bp, char *buf)
{
       long sum;
       unsigned shift;
       char *p;
       int len, space;

       sum = 1;
       shift = 0;
       if ((len = readline(bp, buf)) == -1)
               return 0;
       p = buf;
       switch(bflag)   /* various types of white space handling */
       {
       case 0:
               while (len--) {
                       sum += (long)*p++ << (shift &= (HALFLONG-1));
                       shift += 7;
               }
               break;
       case 1:
               /*
                * coalesce multiple white-space
                */
               for (space = 0; len--; p++) {
                       if (isspace(*p)) {
                               space++;
                               continue;
                       }
                       if (space) {
                               shift += 7;
                               space = 0;
                       }
                       sum += (long)*p << (shift &= (HALFLONG-1));
                       shift += 7;
               }
               break;
       default:
               /*
                * strip all white-space
                */
               while (len--) {
                       if (isspace(*p)) {
                               p++;
                               continue;
                       }
                       sum += (long)*p++ << (shift &= (HALFLONG-1));
                       shift += 7;
               }
               break;
       }
       sum = low(sum) + high(sum);
       return ((short)low(sum) + (short)high(sum));
}

Biobuf *
prepare(int i, char *arg)
{
       struct line *p;
       int j, h;
       Biobuf *bp;
       char *cp, buf[MAXLINELEN];
       int nbytes;
       Rune r;

       bp = Bopen(arg, OREAD);
       if (!bp) {
               panic(mflag ? 0: 2, "cannot open %s: %r\n", arg);
               return 0;
       }
       if (binary)
               return bp;
       nbytes = Bread(bp, buf, MIN(1024, MAXLINELEN));
       if (nbytes > 0) {
               cp = buf;
               while (cp < buf+nbytes-UTFmax) {
                       /*
                        * heuristic for a binary file in the
                        * brave new UNICODE world
                        */
                       cp += chartorune(&r, cp);
                       if (r == 0 || (r > 0x7f && r <= 0xa0)) {
                               binary++;
                               return bp;
                       }
               }
               Bseek(bp, 0, 0);
       }
       p = MALLOC(struct line, 3);
       for (j = 0; h = readhash(bp, buf); p[j].value = h)
               p = REALLOC(p, struct line, (++j+3));
       len[i] = j;
       file[i] = p;
       input[i] = bp;                  /*fix*/
       if (i == 0) {                   /*fix*/
               file1 = arg;
               firstchange = 0;
       }
       else
               file2 = arg;
       return bp;
}

static int
squishspace(char *buf)
{
       char *p, *q;
       int space;

       for (space = 0, q = p = buf; *q; q++) {
               if (isspace(*q)) {
                       space++;
                       continue;
               }
               if (space && bflag == 1) {
                       *p++ = ' ';
                       space = 0;
               }
               *p++ = *q;
       }
       *p = 0;
       return p - buf;
}

/*
* need to fix up for unexpected EOF's
*/
void
check(Biobuf *bf, Biobuf *bt)
{
       int f, t, flen, tlen;
       char fbuf[MAXLINELEN], tbuf[MAXLINELEN];

       ixold[0] = ixnew[0] = 0;
       for (f = t = 1; f < len[0]; f++) {
               flen = readline(bf, fbuf);
               ixold[f] = ixold[f-1] + flen + 1;               /* ftell(bf) */
               if (J[f] == 0)
                       continue;
               do {
                       tlen = readline(bt, tbuf);
                       ixnew[t] = ixnew[t-1] + tlen + 1;       /* ftell(bt) */
               } while (t++ < J[f]);
               if (bflag) {
                       flen = squishspace(fbuf);
                       tlen = squishspace(tbuf);
               }
               if (flen != tlen || strcmp(fbuf, tbuf))
                       J[f] = 0;
       }
       while (t < len[1]) {
               tlen = readline(bt, tbuf);
               ixnew[t] = ixnew[t-1] + tlen + 1;       /* fseek(bt) */
               t++;
       }
}

static void
range(int a, int b, char *separator)
{
       Bprint(&stdout, "%d", a > b ? b: a);
       if (a < b)
               Bprint(&stdout, "%s%d", separator, b);
}

static void
fetch(long *f, int a, int b, Biobuf *bp, char *s)
{
       char buf[MAXLINELEN];
       int maxb;

       if(a <= 1)
               a = 1;
       if(bp == input[0])
               maxb = len[0];
       else
               maxb = len[1];
       if(b > maxb)
               b = maxb;
       if(a > maxb)
               return;
       Bseek(bp, f[a-1], 0);
       while (a++ <= b) {
               readline(bp, buf);
               Bprint(&stdout, "%s%s\n", s, buf);
       }
}

typedef struct Change Change;
struct Change
{
       int a;
       int b;
       int c;
       int d;
};

Change *changes;
int nchanges;

void
change(int a, int b, int c, int d)
{
       char verb;
       char buf[4];
       Change *ch;

       if (a > b && c > d)
               return;
       anychange = 1;
       if (mflag && firstchange == 0) {
               if(mode) {
                       buf[0] = '-';
                       buf[1] = mode;
                       buf[2] = ' ';
                       buf[3] = '\0';
               } else {
                       buf[0] = '\0';
               }
               Bprint(&stdout, "diff %s%s %s\n", buf, file1, file2);
               firstchange = 1;
       }
       verb = a > b ? 'a': c > d ? 'd': 'c';
       switch(mode) {
       case 'e':
               range(a, b, ",");
               Bputc(&stdout, verb);
               break;
       case 0:
               range(a, b, ",");
               Bputc(&stdout, verb);
               range(c, d, ",");
               break;
       case 'n':
               Bprint(&stdout, "%s:", file1);
               range(a, b, ",");
               Bprint(&stdout, " %c ", verb);
               Bprint(&stdout, "%s:", file2);
               range(c, d, ",");
               break;
       case 'f':
               Bputc(&stdout, verb);
               range(a, b, " ");
               break;
       case 'c':
       case 'a':
               if(nchanges%1024 == 0)
                       changes = erealloc(changes, (nchanges+1024)*sizeof(changes[0]));
               ch = &changes[nchanges++];
               ch->a = a;
               ch->b = b;
               ch->c = c;
               ch->d = d;
               return;
       }
       Bputc(&stdout, '\n');
       if (mode == 0 || mode == 'n') {
               fetch(ixold, a, b, input[0], "< ");
               if (a <= b && c <= d)
                       Bprint(&stdout, "---\n");
       }
       fetch(ixnew, c, d, input[1], mode == 0 || mode == 'n' ? "> ": "");
       if (mode != 0 && mode != 'n' && c <= d)
               Bprint(&stdout, ".\n");
}

enum
{
       Lines = 3,      /* number of lines of context shown */
};

int
changeset(int i)
{
       while(i<nchanges && changes[i].b+1+2*Lines > changes[i+1].a)
               i++;
       if(i<nchanges)
               return i+1;
       return nchanges;
}

void
flushchanges(void)
{
       int a, b, c, d, at;
       int i, j;

       if(nchanges == 0)
               return;

       for(i=0; i<nchanges; ){
               j = changeset(i);
               a = changes[i].a-Lines;
               b = changes[j-1].b+Lines;
               c = changes[i].c-Lines;
               d = changes[j-1].d+Lines;
               if(a < 1)
                       a = 1;
               if(c < 1)
                       c = 1;
               if(b > len[0])
                       b = len[0];
               if(d > len[1])
                       d = len[1];
               if(mode == 'a'){
                       a = 1;
                       b = len[0];
                       c = 1;
                       d = len[1];
                       j = nchanges;
               }
               Bprint(&stdout, "%s:", file1);
               range(a, b, ",");
               Bprint(&stdout, " - ");
               Bprint(&stdout, "%s:", file2);
               range(c, d, ",");
               Bputc(&stdout, '\n');
               at = a;
               for(; i<j; i++){
                       fetch(ixold, at, changes[i].a-1, input[0], "  ");
                       fetch(ixold, changes[i].a, changes[i].b, input[0], "- ");
                       fetch(ixnew, changes[i].c, changes[i].d, input[1], "+ ");
                       at = changes[i].b+1;
               }
               fetch(ixold, at, b, input[0], "  ");
       }
       nchanges = 0;
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.