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

/*      diff - differential file comparison
*
*       Uses an algorithm due to Harold Stone, which finds
*       a pair of longest identical subsequences in the two
*       files.
*
*       The major goal is to generate the match vector J.
*       J[i] is the index of the line in file1 corresponding
*       to line i file0. J[i] = 0 if there is no
*       such line in file1.
*
*       Lines are hashed so as to work in core. All potential
*       matches are located by sorting the lines of each file
*       on the hash (called value). In particular, this
*       collects the equivalence classes in file1 together.
*       Subroutine equiv replaces the value of each line in
*       file0 by the index of the first element of its
*       matching equivalence in (the reordered) file1.
*       To save space equiv squeezes file1 into a single
*       array member in which the equivalence classes
*       are simply concatenated, except that their first
*       members are flagged by changing sign.
*
*       Next the indices that point into member are unsorted into
*       array class according to the original order of file0.
*
*       The cleverness lies in routine stone. This marches
*       through the lines of file0, developing a vector klist
*       of "k-candidates". At step i a k-candidate is a matched
*       pair of lines x,y (x in file0 y in file1) such that
*       there is a common subsequence of lenght k
*       between the first i lines of file0 and the first y
*       lines of file1, but there is no such subsequence for
*       any smaller y. x is the earliest possible mate to y
*       that occurs in such a subsequence.
*
*       Whenever any of the members of the equivalence class of
*       lines in file1 matable to a line in file0 has serial number
*       less than the y of some k-candidate, that k-candidate
*       with the smallest such y is replaced. The new
*       k-candidate is chained (via pred) to the current
*       k-1 candidate so that the actual subsequence can
*       be recovered. When a member has serial number greater
*       that the y of all k-candidates, the klist is extended.
*       At the end, the longest subsequence is pulled out
*       and placed in the array J by unravel.
*
*       With J in hand, the matches there recorded are
*       check'ed against reality to assure that no spurious
*       matches have crept in due to hashing. If they have,
*       they are broken, and "jackpot " is recorded--a harmless
*       matter except that a true match for a spuriously
*       mated line may now be unnecessarily reported as a change.
*
*       Much of the complexity of the program comes simply
*       from trying to minimize core utilization and
*       maximize the range of doable problems by dynamically
*       allocating what is needed and reusing what is not.
*       The core requirements for problems larger than somewhat
*       are (in words) 2*length(file0) + length(file1) +
*       3*(number of k-candidates installed),  typically about
*       6n words for files of length n.
*/
/* TIDY THIS UP */
struct cand {
       int x;
       int y;
       int pred;
} cand;
struct line {
       int serial;
       int value;
} *file[2], line;
int len[2];
int binary;
struct line *sfile[2];  /*shortened by pruning common prefix and suffix*/
int slen[2];
int pref, suff; /*length of prefix and suffix*/
int *class;     /*will be overlaid on file[0]*/
int *member;    /*will be overlaid on file[1]*/
int *klist;             /*will be overlaid on file[0] after class*/
struct cand *clist;     /* merely a free storage pot for candidates */
int clen;
int *J;         /*will be overlaid on class*/
long *ixold;    /*will be overlaid on klist*/
long *ixnew;    /*will be overlaid on file[1]*/
/* END OF SOME TIDYING */

static void
sort(struct line *a, int n)     /*shellsort CACM #201*/
{
       int m;
       struct line *ai, *aim, *j, *k;
       struct line w;
       int i;

       m = 0;
       for (i = 1; i <= n; i *= 2)
               m = 2*i - 1;
       for (m /= 2; m != 0; m /= 2) {
               k = a+(n-m);
               for (j = a+1; j <= k; j++) {
                       ai = j;
                       aim = ai+m;
                       do {
                               if (aim->value > ai->value ||
                                  aim->value == ai->value &&
                                  aim->serial > ai->serial)
                                       break;
                               w = *ai;
                               *ai = *aim;
                               *aim = w;

                               aim = ai;
                               ai -= m;
                       } while (ai > a && aim >= ai);
               }
       }
}

static void
unsort(struct line *f, int l, int *b)
{
       int *a;
       int i;

       a = MALLOC(int, (l+1));
       for(i=1;i<=l;i++)
               a[f[i].serial] = f[i].value;
       for(i=1;i<=l;i++)
               b[i] = a[i];
       FREE(a);
}

static void
prune(void)
{
       int i,j;

       for(pref=0;pref<len[0]&&pref<len[1]&&
               file[0][pref+1].value==file[1][pref+1].value;
               pref++ ) ;
       for(suff=0;suff<len[0]-pref&&suff<len[1]-pref&&
               file[0][len[0]-suff].value==file[1][len[1]-suff].value;
               suff++) ;
       for(j=0;j<2;j++) {
               sfile[j] = file[j]+pref;
               slen[j] = len[j]-pref-suff;
               for(i=0;i<=slen[j];i++)
                       sfile[j][i].serial = i;
       }
}

static void
equiv(struct line *a, int n, struct line *b, int m, int *c)
{
       int i, j;

       i = j = 1;
       while(i<=n && j<=m) {
               if(a[i].value < b[j].value)
                       a[i++].value = 0;
               else if(a[i].value == b[j].value)
                       a[i++].value = j;
               else
                       j++;
       }
       while(i <= n)
               a[i++].value = 0;
       b[m+1].value = 0;
       j = 0;
       while(++j <= m) {
               c[j] = -b[j].serial;
               while(b[j+1].value == b[j].value) {
                       j++;
                       c[j] = b[j].serial;
               }
       }
       c[j] = -1;
}

static int
newcand(int x, int  y, int pred)
{
       struct cand *q;

       clist = REALLOC(clist, struct cand, (clen+1));
       q = clist + clen;
       q->x = x;
       q->y = y;
       q->pred = pred;
       return clen++;
}

static int
search(int *c, int k, int y)
{
       int i, j, l;
       int t;

       if(clist[c[k]].y < y)   /*quick look for typical case*/
               return k+1;
       i = 0;
       j = k+1;
       while((l=(i+j)/2) > i) {
               t = clist[c[l]].y;
               if(t > y)
                       j = l;
               else if(t < y)
                       i = l;
               else
                       return l;
       }
       return l+1;
}

static int
stone(int *a, int n, int *b, int *c)
{
       int i, k,y;
       int j, l;
       int oldc, tc;
       int oldl;

       k = 0;
       c[0] = newcand(0,0,0);
       for(i=1; i<=n; i++) {
               j = a[i];
               if(j==0)
                       continue;
               y = -b[j];
               oldl = 0;
               oldc = c[0];
               do {
                       if(y <= clist[oldc].y)
                               continue;
                       l = search(c, k, y);
                       if(l!=oldl+1)
                               oldc = c[l-1];
                       if(l<=k) {
                               if(clist[c[l]].y <= y)
                                       continue;
                               tc = c[l];
                               c[l] = newcand(i,y,oldc);
                               oldc = tc;
                               oldl = l;
                       } else {
                               c[l] = newcand(i,y,oldc);
                               k++;
                               break;
                       }
               } while((y=b[++j]) > 0);
       }
       return k;
}

static void
unravel(int p)
{
       int i;
       struct cand *q;

       for(i=0; i<=len[0]; i++) {
               if (i <= pref)
                       J[i] = i;
               else if (i > len[0]-suff)
                       J[i] = i+len[1]-len[0];
               else
                       J[i] = 0;
       }
       for(q=clist+p;q->y!=0;q=clist+q->pred)
               J[q->x+pref] = q->y+pref;
}

static void
output(void)
{
       int m, i0, i1, j0, j1;

       m = len[0];
       J[0] = 0;
       J[m+1] = len[1]+1;
       if (mode != 'e') {
               for (i0 = 1; i0 <= m; i0 = i1+1) {
                       while (i0 <= m && J[i0] == J[i0-1]+1)
                               i0++;
                       j0 = J[i0-1]+1;
                       i1 = i0-1;
                       while (i1 < m && J[i1+1] == 0)
                               i1++;
                       j1 = J[i1+1]-1;
                       J[i1] = j1;
                       change(i0, i1, j0, j1);
               }
       }
       else {
               for (i0 = m; i0 >= 1; i0 = i1-1) {
                       while (i0 >= 1 && J[i0] == J[i0+1]-1 && J[i0])
                               i0--;
                       j0 = J[i0+1]-1;
                       i1 = i0+1;
                       while (i1 > 1 && J[i1-1] == 0)
                               i1--;
                       j1 = J[i1-1]+1;
                       J[i1] = j1;
                       change(i1 , i0, j1, j0);
               }
       }
       if (m == 0)
               change(1, 0, 1, len[1]);
       flushchanges();
}

#define BUF 4096
static int
cmp(Biobuf* b1, Biobuf* b2)
{
       int n;
       uchar buf1[BUF], buf2[BUF];
       int f1, f2;
       vlong nc = 1;
       uchar *b1s, *b1e, *b2s, *b2e;

       f1 = Bfildes(b1);
       f2 = Bfildes(b2);
       seek(f1, 0, 0);
       seek(f2, 0, 0);
       b1s = b1e = buf1;
       b2s = b2e = buf2;
       for(;;){
               if(b1s >= b1e){
                       if(b1s >= &buf1[BUF])
                               b1s = buf1;
                       n = read(f1, b1s,  &buf1[BUF] - b1s);
                       b1e = b1s + n;
               }
               if(b2s >= b2e){
                       if(b2s >= &buf2[BUF])
                               b2s = buf2;
                       n = read(f2, b2s,  &buf2[BUF] - b2s);
                       b2e = b2s + n;
               }
               n = b2e - b2s;
               if(n > b1e - b1s)
                       n = b1e - b1s;
               if(n <= 0)
                       break;
               if(memcmp((void *)b1s, (void *)b2s, n) != 0){
                       return 1;
               }
               nc += n;
               b1s += n;
               b2s += n;
       }
       if(b1e - b1s == b2e - b2s)
               return 0;
       return 1;
}

void
diffreg(char *f, char *t)
{
       Biobuf *b0, *b1;
       int k;

       binary = 0;
       b0 = prepare(0, f);
       if (!b0)
               return;
       b1 = prepare(1, t);
       if (!b1) {
               Bterm(b0);
               return;
       }
       if (binary){
               // could use b0 and b1 but this is simpler.
               if (cmp(b0, b1))
                       print("binary files %s %s differ\n", f, t);
               Bterm(b0);
               Bterm(b1);
               return;
       }
       clen = 0;
       prune();
       sort(sfile[0], slen[0]);
       sort(sfile[1], slen[1]);

       member = (int *)file[1];
       equiv(sfile[0], slen[0], sfile[1], slen[1], member);
       member = REALLOC(member, int, slen[1]+2);

       class = (int *)file[0];
       unsort(sfile[0], slen[0], class);
       class = REALLOC(class, int, slen[0]+2);

       klist = MALLOC(int, slen[0]+2);
       clist = MALLOC(struct cand, 1);
       k = stone(class, slen[0], member, klist);
       FREE(member);
       FREE(class);

       J = MALLOC(int, len[0]+2);
       unravel(klist[k]);
       FREE(clist);
       FREE(klist);

       ixold = MALLOC(long, len[0]+2);
       ixnew = MALLOC(long, len[1]+2);
       Bseek(b0, 0, 0); Bseek(b1, 0, 0);
       check(b0, b1);
       output();
       FREE(J); FREE(ixold); FREE(ixnew);
       Bterm(b0); Bterm(b1);                   /* ++++ */
}

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.