2.9BSD - /usr/src/cmd/diff/diffreg.c

   1: static  char sccsid[] = "@(#)diffreg.c 4.1 10/9/80";
   2: 
   3: #include "diff.h"
   4: /*
   5:  * diff - compare two files.
   6:  */
   7: 
   8: /*
   9:  *	Uses an algorithm due to Harold Stone, which finds
  10:  *	a pair of longest identical subsequences in the two
  11:  *	files.
  12:  *
  13:  *	The major goal is to generate the match vector J.
  14:  *	J[i] is the index of the line in file1 corresponding
  15:  *	to line i file0. J[i] = 0 if there is no
  16:  *	such line in file1.
  17:  *
  18:  *	Lines are hashed so as to work in core. All potential
  19:  *	matches are located by sorting the lines of each file
  20:  *	on the hash (called ``value''). In particular, this
  21:  *	collects the equivalence classes in file1 together.
  22:  *	Subroutine equiv replaces the value of each line in
  23:  *	file0 by the index of the first element of its
  24:  *	matching equivalence in (the reordered) file1.
  25:  *	To save space equiv squeezes file1 into a single
  26:  *	array member in which the equivalence classes
  27:  *	are simply concatenated, except that their first
  28:  *	members are flagged by changing sign.
  29:  *
  30:  *	Next the indices that point into member are unsorted into
  31:  *	array class according to the original order of file0.
  32:  *
  33:  *	The cleverness lies in routine stone. This marches
  34:  *	through the lines of file0, developing a vector klist
  35:  *	of "k-candidates". At step i a k-candidate is a matched
  36:  *	pair of lines x,y (x in file0 y in file1) such that
  37:  *	there is a common subsequence of length k
  38:  *	between the first i lines of file0 and the first y
  39:  *	lines of file1, but there is no such subsequence for
  40:  *	any smaller y. x is the earliest possible mate to y
  41:  *	that occurs in such a subsequence.
  42:  *
  43:  *	Whenever any of the members of the equivalence class of
  44:  *	lines in file1 matable to a line in file0 has serial number
  45:  *	less than the y of some k-candidate, that k-candidate
  46:  *	with the smallest such y is replaced. The new
  47:  *	k-candidate is chained (via pred) to the current
  48:  *	k-1 candidate so that the actual subsequence can
  49:  *	be recovered. When a member has serial number greater
  50:  *	that the y of all k-candidates, the klist is extended.
  51:  *	At the end, the longest subsequence is pulled out
  52:  *	and placed in the array J by unravel
  53:  *
  54:  *	With J in hand, the matches there recorded are
  55:  *	check'ed against reality to assure that no spurious
  56:  *	matches have crept in due to hashing. If they have,
  57:  *	they are broken, and "jackpot" is recorded--a harmless
  58:  *	matter except that a true match for a spuriously
  59:  *	mated line may now be unnecessarily reported as a change.
  60:  *
  61:  *	Much of the complexity of the program comes simply
  62:  *	from trying to minimize core utilization and
  63:  *	maximize the range of doable problems by dynamically
  64:  *	allocating what is needed and reusing what is not.
  65:  *	The core requirements for problems larger than somewhat
  66:  *	are (in words) 2*length(file0) + length(file1) +
  67:  *	3*(number of k-candidates installed),  typically about
  68:  *	6n words for files of length n.
  69:  */
  70: 
  71: #define prints(s)   fputs(s,stdout)
  72: 
  73: FILE    *input[2];
  74: FILE    *fopen();
  75: 
  76: struct cand {
  77:     int x;
  78:     int y;
  79:     int pred;
  80: } cand;
  81: struct line {
  82:     int serial;
  83:     int value;
  84: } *file[2], line;
  85: int len[2];
  86: struct  line *sfile[2]; /* shortened by pruning common prefix and suffix */
  87: int slen[2];
  88: int pref, suff; /* length of prefix and suffix */
  89: int *class;     /* will be overlaid on file[0] */
  90: int *member;    /* will be overlaid on file[1] */
  91: int *klist;     /* will be overlaid on file[0] after class */
  92: struct  cand *clist;    /* merely a free storage pot for candidates */
  93: int clen = 0;
  94: int *J;     /* will be overlaid on class */
  95: long    *ixold;     /* will be overlaid on klist */
  96: long    *ixnew;     /* will be overlaid on file[1] */
  97: 
  98: diffreg()
  99: {
 100:     register int k;
 101: 
 102:     if (hflag) {
 103:         diffargv[0] = "diffh";
 104:         execv(diffh, diffargv);
 105:         fprintf(stderr, "diff: ");
 106:         perror(diffh);
 107:         done();
 108:     }
 109:     dummy = malloc(1);
 110:     if ((stb1.st_mode & S_IFMT) == S_IFDIR)
 111:         file1 = splice(file1, file2);
 112:     else if ((stb2.st_mode & S_IFMT) == S_IFDIR)
 113:         file2 = splice(file2, file1);
 114:     else if (!strcmp(file1, "-")) {
 115:         if (!strcmp(file2, "-")) {
 116:             fprintf(stderr, "diff: can't specify - -\n");
 117:             done();
 118:         }
 119:         file1 = copytemp();
 120:     } else if (!strcmp(file2, "-"))
 121:         file2 = copytemp();
 122:     prepare(0, file1);
 123:     prepare(1, file2);
 124:     prune();
 125:     sort(sfile[0],slen[0]);
 126:     sort(sfile[1],slen[1]);
 127: 
 128:     member = (int *)file[1];
 129:     equiv(sfile[0], slen[0], sfile[1], slen[1], member);
 130:     member = (int *)ralloc((char *)member,(slen[1]+2)*sizeof(int));
 131: 
 132:     class = (int *)file[0];
 133:     unsort(sfile[0], slen[0], class);
 134:     class = (int *)ralloc((char *)class,(slen[0]+2)*sizeof(int));
 135: 
 136:     klist = (int *)talloc((slen[0]+2)*sizeof(int));
 137:     clist = (struct cand *)talloc(sizeof(cand));
 138:     k = stone(class, slen[0], member, klist);
 139:     free((char *)member);
 140:     free((char *)class);
 141: 
 142:     J = (int *)talloc((len[0]+2)*sizeof(int));
 143:     unravel(klist[k]);
 144:     free((char *)clist);
 145:     free((char *)klist);
 146: 
 147:     ixold = (long *)talloc((len[0]+2)*sizeof(long));
 148:     ixnew = (long *)talloc((len[1]+2)*sizeof(long));
 149:     check();
 150:     output();
 151:     status = anychange;
 152:     if (opt == D_CONTEXT && anychange == 0)
 153:         printf("No differences encountered\n");
 154:     done();
 155: }
 156: 
 157: char *
 158: copytemp()
 159: {
 160:     char buf[BUFSIZ];
 161:     register int i, f;
 162: 
 163:     signal(SIGHUP,done);
 164:     signal(SIGINT,done);
 165:     signal(SIGPIPE,done);
 166:     signal(SIGTERM,done);
 167:     tempfile = mktemp("/tmp/dXXXXX");
 168:     f = creat(tempfile,0600);
 169:     if (f < 0) {
 170:         fprintf(stderr, "diff: ");
 171:         perror(tempfile);
 172:         done();
 173:     }
 174:     while ((i = read(0,buf,BUFSIZ)) > 0)
 175:         if (write(f,buf,i) != i) {
 176:             fprintf(stderr, "diff: ");
 177:             perror(tempfile);
 178:             done();
 179:         }
 180:     close(f);
 181:     return (tempfile);
 182: }
 183: 
 184: char *
 185: splice(dir, file)
 186:     char *dir, *file;
 187: {
 188:     char *tail;
 189:     char buf[BUFSIZ];
 190: 
 191:     if (!strcmp(file, "-")) {
 192:         fprintf(stderr, "diff: can't specify - with other arg directory\n");
 193:         done();
 194:     }
 195:     tail = rindex(file, '/');
 196:     if (tail == 0)
 197:         tail = file;
 198:     else
 199:         tail++;
 200:     sprintf(buf, "%s/%s", dir, tail);
 201:     return (savestr(buf));
 202: }
 203: 
 204: prepare(i, arg)
 205: char *arg;
 206: {
 207:     register struct line *p;
 208:     register j,h;
 209:     if((input[i] = fopen(arg,"r")) == NULL){
 210:         fprintf(stderr, "diff: ");
 211:         perror(arg);
 212:         done();
 213:     }
 214:     p = (struct line *)talloc(3*sizeof(line));
 215:     for(j=0; h=readhash(input[i]);) {
 216:         p = (struct line *)ralloc((char *)p,(++j+3)*sizeof(line));
 217:         p[j].value = h;
 218:     }
 219:     len[i] = j;
 220:     file[i] = p;
 221:     fclose(input[i]);
 222: }
 223: 
 224: prune()
 225: {
 226:     register i,j;
 227:     for(pref=0;pref<len[0]&&pref<len[1]&&
 228:         file[0][pref+1].value==file[1][pref+1].value;
 229:         pref++ ) ;
 230:     for(suff=0;suff<len[0]-pref&&suff<len[1]-pref&&
 231:         file[0][len[0]-suff].value==file[1][len[1]-suff].value;
 232:         suff++) ;
 233:     for(j=0;j<2;j++) {
 234:         sfile[j] = file[j]+pref;
 235:         slen[j] = len[j]-pref-suff;
 236:         for(i=0;i<=slen[j];i++)
 237:             sfile[j][i].serial = i;
 238:     }
 239: }
 240: 
 241: equiv(a,n,b,m,c)
 242: struct line *a, *b;
 243: int *c;
 244: {
 245:     register int i, j;
 246:     i = j = 1;
 247:     while(i<=n && j<=m) {
 248:         if(a[i].value <b[j].value)
 249:             a[i++].value = 0;
 250:         else if(a[i].value == b[j].value)
 251:             a[i++].value = j;
 252:         else
 253:             j++;
 254:     }
 255:     while(i <= n)
 256:         a[i++].value = 0;
 257:     b[m+1].value = 0;
 258:     j = 0;
 259:     while(++j <= m) {
 260:         c[j] = -b[j].serial;
 261:         while(b[j+1].value == b[j].value) {
 262:             j++;
 263:             c[j] = b[j].serial;
 264:         }
 265:     }
 266:     c[j] = -1;
 267: }
 268: 
 269: stone(a,n,b,c)
 270: int *a;
 271: int *b;
 272: int *c;
 273: {
 274:     register int i, k,y;
 275:     int j, l;
 276:     int oldc, tc;
 277:     int oldl;
 278:     k = 0;
 279:     c[0] = newcand(0,0,0);
 280:     for(i=1; i<=n; i++) {
 281:         j = a[i];
 282:         if(j==0)
 283:             continue;
 284:         y = -b[j];
 285:         oldl = 0;
 286:         oldc = c[0];
 287:         do {
 288:             if(y <= clist[oldc].y)
 289:                 continue;
 290:             l = search(c, k, y);
 291:             if(l!=oldl+1)
 292:                 oldc = c[l-1];
 293:             if(l<=k) {
 294:                 if(clist[c[l]].y <= y)
 295:                     continue;
 296:                 tc = c[l];
 297:                 c[l] = newcand(i,y,oldc);
 298:                 oldc = tc;
 299:                 oldl = l;
 300:             } else {
 301:                 c[l] = newcand(i,y,oldc);
 302:                 k++;
 303:                 break;
 304:             }
 305:         } while((y=b[++j]) > 0);
 306:     }
 307:     return(k);
 308: }
 309: 
 310: newcand(x,y,pred)
 311: {
 312:     register struct cand *q;
 313:     clist = (struct cand *)ralloc((char *)clist,++clen*sizeof(cand));
 314:     q = clist + clen -1;
 315:     q->x = x;
 316:     q->y = y;
 317:     q->pred = pred;
 318:     return(clen-1);
 319: }
 320: 
 321: search(c, k, y)
 322: int *c;
 323: {
 324:     register int i, j, l;
 325:     int t;
 326:     if(clist[c[k]].y<y) /*quick look for typical case*/
 327:         return(k+1);
 328:     i = 0;
 329:     j = k+1;
 330:     while((l=(i+j)/2) > i) {
 331:         t = clist[c[l]].y;
 332:         if(t > y)
 333:             j = l;
 334:         else if(t < y)
 335:             i = l;
 336:         else
 337:             return(l);
 338:     }
 339:     return(l+1);
 340: }
 341: 
 342: unravel(p)
 343: {
 344:     register int i;
 345:     register struct cand *q;
 346:     for(i=0; i<=len[0]; i++)
 347:         J[i] =  i<=pref ? i:
 348:             i>len[0]-suff ? i+len[1]-len[0]:
 349:             0;
 350:     for(q=clist+p;q->y!=0;q=clist+q->pred)
 351:         J[q->x+pref] = q->y+pref;
 352: }
 353: 
 354: /* check does double duty:
 355: 1.  ferret out any fortuitous correspondences due
 356: to confounding by hashing (which result in "jackpot")
 357: 2.  collect random access indexes to the two files */
 358: 
 359: check()
 360: {
 361:     register int i, j;
 362:     int jackpot;
 363:     long ctold, ctnew;
 364:     char c,d;
 365:     input[0] = fopen(file1,"r");
 366:     input[1] = fopen(file2,"r");
 367:     j = 1;
 368:     ixold[0] = ixnew[0] = 0;
 369:     jackpot = 0;
 370:     ctold = ctnew = 0;
 371:     for(i=1;i<=len[0];i++) {
 372:         if(J[i]==0) {
 373:             ixold[i] = ctold += skipline(0);
 374:             continue;
 375:         }
 376:         while(j<J[i]) {
 377:             ixnew[j] = ctnew += skipline(1);
 378:             j++;
 379:         }
 380:         for(;;) {
 381:             c = getc(input[0]);
 382:             d = getc(input[1]);
 383:             ctold++;
 384:             ctnew++;
 385:             if(bflag && isspace(c) && isspace(d)) {
 386:                 do {
 387:                     if(c=='\n') break;
 388:                     ctold++;
 389:                 } while(isspace(c=getc(input[0])));
 390:                 do {
 391:                     if(d=='\n') break;
 392:                     ctnew++;
 393:                 } while(isspace(d=getc(input[1])));
 394:             }
 395:             if(c!=d) {
 396:                 jackpot++;
 397:                 J[i] = 0;
 398:                 if(c!='\n')
 399:                     ctold += skipline(0);
 400:                 if(d!='\n')
 401:                     ctnew += skipline(1);
 402:                 break;
 403:             }
 404:             if(c=='\n')
 405:                 break;
 406:         }
 407:         ixold[i] = ctold;
 408:         ixnew[j] = ctnew;
 409:         j++;
 410:     }
 411:     for(;j<=len[1];j++) {
 412:         ixnew[j] = ctnew += skipline(1);
 413:     }
 414:     fclose(input[0]);
 415:     fclose(input[1]);
 416: /*
 417: 	if(jackpot)
 418: 		fprintf(stderr, "jackpot\n");
 419: */
 420: }
 421: 
 422: sort(a,n)   /*shellsort CACM #201*/
 423: struct line *a;
 424: {
 425:     struct line w;
 426:     register int j,m;
 427:     struct line *ai;
 428:     register struct line *aim;
 429:     int k;
 430:     for(j=1;j<=n;j*= 2)
 431:         m = 2*j - 1;
 432:     for(m/=2;m!=0;m/=2) {
 433:         k = n-m;
 434:         for(j=1;j<=k;j++) {
 435:             for(ai = &a[j]; ai > a; ai -= m) {
 436:                 aim = &ai[m];
 437:                 if(aim < ai)
 438:                     break;  /*wraparound*/
 439:                 if(aim->value > ai[0].value ||
 440:                    aim->value == ai[0].value &&
 441:                    aim->serial > ai[0].serial)
 442:                     break;
 443:                 w.value = ai[0].value;
 444:                 ai[0].value = aim->value;
 445:                 aim->value = w.value;
 446:                 w.serial = ai[0].serial;
 447:                 ai[0].serial = aim->serial;
 448:                 aim->serial = w.serial;
 449:             }
 450:         }
 451:     }
 452: }
 453: 
 454: unsort(f, l, b)
 455: struct line *f;
 456: int *b;
 457: {
 458:     register int *a;
 459:     register int i;
 460:     a = (int *)talloc((l+1)*sizeof(int));
 461:     for(i=1;i<=l;i++)
 462:         a[f[i].serial] = f[i].value;
 463:     for(i=1;i<=l;i++)
 464:         b[i] = a[i];
 465:     free((char *)a);
 466: }
 467: 
 468: skipline(f)
 469: {
 470:     register i;
 471:     for(i=1;getc(input[f])!='\n';i++) ;
 472:     return(i);
 473: }
 474: 
 475: output()
 476: {
 477:     int m;
 478:     register int i0, i1, j1;
 479:     int j0;
 480:     input[0] = fopen(file1,"r");
 481:     input[1] = fopen(file2,"r");
 482:     m = len[0];
 483:     J[0] = 0;
 484:     J[m+1] = len[1]+1;
 485:     if(opt!=D_EDIT) for(i0=1;i0<=m;i0=i1+1) {
 486:         while(i0<=m&&J[i0]==J[i0-1]+1) i0++;
 487:         j0 = J[i0-1]+1;
 488:         i1 = i0-1;
 489:         while(i1<m&&J[i1+1]==0) i1++;
 490:         j1 = J[i1+1]-1;
 491:         J[i1] = j1;
 492:         change(i0,i1,j0,j1);
 493:     } else for(i0=m;i0>=1;i0=i1-1) {
 494:         while(i0>=1&&J[i0]==J[i0+1]-1&&J[i0]!=0) i0--;
 495:         j0 = J[i0+1]-1;
 496:         i1 = i0+1;
 497:         while(i1>1&&J[i1-1]==0) i1--;
 498:         j1 = J[i1-1]+1;
 499:         J[i1] = j1;
 500:         change(i1,i0,j1,j0);
 501:     }
 502:     if(m==0)
 503:         change(1,0,1,len[1]);
 504:     if (opt==D_IFDEF) {
 505:         for (;;) {
 506: #define c i0
 507:             c = getc(input[0]);
 508:             if (c < 0)
 509:                 return;
 510:             putchar(c);
 511:         }
 512: #undef c
 513:     }
 514: }
 515: 
 516: /* indicate that there is a difference between lines a and b of the from file
 517:    to get to lines c to d of the to file.
 518:    If a is greater then b then there are no lines in the from file involved
 519:    and this means that there were lines appended (beginning at b).
 520:    If c is greater than d then there are lines missing from the to file.
 521: */
 522: change(a,b,c,d)
 523: {
 524:     char ch;
 525:     int lowa,upb,lowc,upd;
 526:     struct stat stbuf;
 527: 
 528:     if (opt != D_IFDEF && a>b && c>d)
 529:         return;
 530:     if (anychange == 0) {
 531:         anychange = 1;
 532:         if(opt == D_CONTEXT) {
 533:             printf("*** %s	", file1);
 534:             stat(file1, &stbuf);
 535:             printf("%s--- %s	",
 536:                 ctime(&stbuf.st_mtime), file2);
 537:             stat(file2, &stbuf);
 538:             printf("%s", ctime(&stbuf.st_mtime));
 539:         }
 540:     }
 541:     if (a <= b && c <= d)
 542:         ch = 'c';
 543:     else
 544:         ch = (a <= b) ? 'd' : 'a';
 545:     if(opt == D_CONTEXT) {
 546:         lowa = max(1, a-context);
 547:         upb  = min(len[0], b+context);
 548:         lowc = max(1, c-context);
 549:         upd  = min(len[1], d+context);
 550: 
 551:         /* print out from file */
 552:         printf("***************\n*** ");
 553:         range(lowa,upb,",");
 554:         printf("\n");
 555:         if (ch == 'a')
 556:             fetch(ixold,lowa,upb,input[0],"  ");
 557:         else {
 558:             fetch(ixold,lowa,a-1,input[0],"  ");
 559:             fetch(ixold,a,b,input[0],ch == 'c' ? "! " : "- ");
 560:             fetch(ixold,b+1,upb,input[0],"  ");
 561:         }
 562:         putchar('\n');
 563:         printf("--- ");
 564:         range(lowc,upd,",");
 565:         printf(" -----\n");
 566:         if (ch == 'd')
 567:             fetch(ixnew,lowc,upd,input[1],"  ");
 568:         else {
 569:             fetch(ixnew,lowc,c-1,input[1],"  ");
 570:             fetch(ixnew,c,d,input[1],ch == 'c' ? "! " : "+ ");
 571:             fetch(ixnew,d+1,upd,input[1],"  ");
 572:         }
 573:         return;
 574:     }
 575:     switch (opt) {
 576: 
 577:     case D_NORMAL:
 578:     case D_EDIT:
 579:         range(a,b,",");
 580:         putchar(a>b?'a':c>d?'d':'c');
 581:         if(opt==D_NORMAL)
 582:             range(c,d,",");
 583:         putchar('\n');
 584:         break;
 585:     case D_REVERSE:
 586:         putchar(a>b?'a':c>d?'d':'c');
 587:         range(a,b," ");
 588:         putchar('\n');
 589:         break;
 590:     }
 591:     if(opt == D_NORMAL || opt == D_IFDEF) {
 592:         fetch(ixold,a,b,input[0],"< ", 1);
 593:         if(a<=b&&c<=d && opt == D_NORMAL)
 594:             prints("---\n");
 595:     }
 596:     fetch(ixnew,c,d,input[1],opt==D_NORMAL?"> ":"", 0);
 597:     if ((opt ==D_EDIT || opt == D_REVERSE) && c<=d)
 598:         prints(".\n");
 599:     if (inifdef) {
 600:         fprintf(stdout, "#endif %s\n", endifname);
 601:         inifdef = 0;
 602:     }
 603: }
 604: 
 605: range(a,b,separator)
 606: char *separator;
 607: {
 608:     printf("%d", a>b?b:a);
 609:     if(a<b) {
 610:         printf("%s%d", separator, b);
 611:     }
 612: }
 613: 
 614: fetch(f,a,b,lb,s,oldfile)
 615: long *f;
 616: FILE *lb;
 617: char *s;
 618: {
 619:     register int i, j;
 620:     register int nc;
 621:     int oneflag = (*ifdef1!='\0') != (*ifdef2!='\0');
 622: 
 623:     /*
 624: 	 * When doing #ifdef's, copy down to current line
 625: 	 * if this is the first file, so that stuff makes it to output.
 626: 	 */
 627:     if (opt == D_IFDEF && oldfile){
 628:         long curpos = ftell(lb);
 629:         /* print through if append (a>b), else to (nb: 0 vs 1 orig) */
 630:         nc = f[a>b? b : a-1 ] - curpos;
 631:         for (i = 0; i < nc; i++)
 632:             putchar(getc(lb));
 633:     }
 634:     if (a > b)
 635:         return;
 636:     if (opt == D_IFDEF) {
 637:         if (inifdef)
 638:             fprintf(stdout, "#else %s%s\n", oneflag && oldfile==1 ? "!" : "", ifdef2);
 639:         else {
 640:             if (oneflag) {
 641:                 /* There was only one ifdef given */
 642:                 endifname = ifdef2;
 643:                 if (oldfile)
 644:                     fprintf(stdout, "#ifndef %s\n", endifname);
 645:                 else
 646:                     fprintf(stdout, "#ifdef %s\n", endifname);
 647:             }
 648:             else {
 649:                 endifname = oldfile ? ifdef1 : ifdef2;
 650:                 fprintf(stdout, "#ifdef %s\n", endifname);
 651:             }
 652:         }
 653:         inifdef = 1+oldfile;
 654:     }
 655:     for(i=a;i<=b;i++) {
 656:         fseek(lb,f[i-1],0);
 657:         nc = f[i]-f[i-1];
 658:         if (opt != D_IFDEF)
 659:             prints(s);
 660:         for(j=0;j<nc;j++)
 661:             putchar(getc(lb));
 662:     }
 663:     if (inifdef && !wantelses) {
 664:         fprintf(stdout, "#endif %s\n", endifname);
 665:         inifdef = 0;
 666:     }
 667: }
 668: 
 669: #define HALFLONG 16
 670: #define low(x)  (x&((1L<<HALFLONG)-1))
 671: #define high(x) (x>>HALFLONG)
 672: 
 673: /*
 674:  * hashing has the effect of
 675:  * arranging line in 7-bit bytes and then
 676:  * summing 1-s complement in 16-bit hunks
 677:  */
 678: readhash(f)
 679: FILE *f;
 680: {
 681:     long sum;
 682:     register unsigned shift;
 683:     register space;
 684:     register t;
 685:     sum = 1;
 686:     space = 0;
 687:     if(!bflag) for(shift=0;(t=getc(f))!='\n';shift+=7) {
 688:         if(t==-1)
 689:             return(0);
 690:         sum += (long)t << (shift%=HALFLONG);
 691:     }
 692:     else for(shift=0;;) {
 693:         switch(t=getc(f)) {
 694:         case -1:
 695:             return(0);
 696:         case '\t':
 697:         case ' ':
 698:             space++;
 699:             continue;
 700:         default:
 701:             if(space) {
 702:                 shift += 7;
 703:                 space = 0;
 704:             }
 705:             sum += (long)t << (shift%=HALFLONG);
 706:             shift += 7;
 707:             continue;
 708:         case '\n':
 709:             break;
 710:         }
 711:         break;
 712:     }
 713:     sum = low(sum) + high(sum);
 714:     return((short)low(sum) + (short)high(sum));
 715: }

Defined functions

Defined variables

Defined struct's

Defined macros