home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_100 / 133_01 / textcom < prev    next >
Text File  |  1985-03-10  |  12KB  |  496 lines
  1. /*
  2. CUG-HEADER:
  3.    TITLE: "Text comparison utility"
  4.    VER: 1.7
  5.    AUTHOR: G.N. GILBERT
  6.    O.S.: CP/M 2.2
  7.    FNAME: TEXTCOM
  8.    DESC: compares two text files, printing differences
  9.         attempts to re-synchronise after finding differences
  10.    KEYWORDS: text, differences
  11. */
  12.  
  13. /*
  14.     TEXTCOM
  15.  
  16.     compares two text files, printing differences
  17.         attempts to synchronise after finding differences.
  18.  
  19.     G. Nigel Gilbert / MICROLOGY  (tel 04868-22521)  16.10.81
  20.  
  21.     vers 1.3:  tabs expanded on list output      30.8.82
  22.     vers 1.4:  control chars suppressed on output (except ^I,cr/lf)
  23.     vers 1.5:  option to ignore parity bit
  24.     vers 1.6:  findline() substituted for fgets(), which got screwed
  25.             up when \n had its parity bit set
  26.     vers 1.7:  option to match white space in comparison
  27.  
  28.     compile with -e3300 -o
  29. */
  30. #define VERSION 17
  31.  
  32. #include <bdscio.h>
  33.  
  34. #define MAXINT 65535
  35. #define MAXSYNC 100    /*max distance to attempt to restore synchronism*/
  36. #define DEFLSYNC 3    /*default no. of bytes which must match to
  37. establish synchronity*/
  38. #define MAXLEN 512    /*max length of input line*/
  39.  
  40. #define NO 0
  41. #define YES 1
  42.  
  43. #define bool char
  44.  
  45. bool putboth;        /*print diffs on both screen and printer*/
  46. bool pause;        /*stop at the end of each screen of output*/
  47. bool nosync;        /*don't attempt to synchronise*/
  48. int sync;        /*distance over which files must be matched */
  49. int line;        /*output line count*/
  50. int col;        /*output column no for printer tabs*/
  51. bool report;        /*write differences to file*/
  52. bool parity;        /*ignore parity bit*/
  53. bool white;        /*match white space*/
  54. char repbuf[BUFSIZ];    /*file buffer for report*/
  55. char name1[15], name2[15];    /*names of files to compare*/
  56. unsigned line1, line2;    /*line counts for input files*/
  57. unsigned start, stop;    /*start and stop comparing at lines..*/
  58. bool different, listing;/*found a difference; list diffs.*/
  59. char *c1,*c2;        /*pointers to current lines being compared*/
  60. char fbuf1[BUFSIZ], fbuf2[BUFSIZ];    /*input file buffers*/
  61. char repname[15];    /*report file name*/
  62.  
  63. struct aring {
  64.     char *buf[MAXSYNC];
  65.     int ringp;
  66.     bool eof;
  67. } 
  68. ring1, ring2;        /*file input ring buffer*/
  69.  
  70. char *findline(line,iobuf)    /*read a line from an  input file, stripping
  71.                  '\n', and returning NULL if at Eof */
  72. char *line, *iobuf;
  73. {
  74.     int cint;
  75.     char i, cnopar;
  76.  
  77.     for (i=0; i < (MAXLEN-1) && (cint=getc(iobuf)) != ERROR; i++) {
  78.         if ((cnopar=cint & 0x7f) == CPMEOF) return NULL;
  79.         if (cnopar == '\n') break;
  80.         if (cnopar == '\r') continue;
  81.         *line++= (parity ? cnopar : cint);
  82.         }
  83.     *line='\0';
  84.     return line;
  85. }
  86.  
  87. char *readline(iobuf)    /*read a line and store it away, returning pointer
  88.                 to it, or NULL if end of file*/
  89. char *iobuf;
  90. {
  91.     char temp[MAXLEN], *t, *p, *alloc(), *findline(), *strcpy();
  92.  
  93.     if (findline(temp,iobuf) == NULL) return NULL;
  94.     if ((p=alloc(strlen(temp)+1)) == NULL) {
  95.         puts("Out of memory\n"); 
  96.         exit();
  97.         }
  98.     return strcpy(p,temp);
  99. }
  100.  
  101. char *getline(ring,iobuf)    /*get a line of text from ring buffer
  102.                     returning pointer to it;
  103.                     replace with one from input file*/
  104. struct aring *ring;
  105. char *iobuf;
  106. {
  107.     char *c, **p, *readline();
  108.  
  109.     if (ring -> ringp == MAXSYNC) ring -> ringp = 0;
  110.     c = *( p=&(ring -> buf[ring -> ringp++]) );
  111.     if (ring -> eof || (*p=readline(iobuf)) == NULL) {
  112.         *p=EOF; 
  113.         ring -> eof=YES;
  114.         }
  115.     return c;
  116. }
  117.  
  118. initring(ring,iobuf)    /*initialise by filling ring buffer*/
  119. struct aring *ring;
  120. char *iobuf;
  121. {
  122.     int i;
  123.     char *c, *readline();
  124.  
  125.     ring -> eof=NO;
  126.     for (i=0; i<MAXSYNC; i++) {
  127.         if (ring -> eof || (c=readline(iobuf)) == NULL)
  128.         {
  129.             c=EOF; 
  130.             ring -> eof=YES;
  131.             }
  132.         ring -> buf[i]=c;
  133.         }
  134.     ring -> ringp=MAXSYNC;
  135. }
  136.  
  137. char *peep(ring,p)        /*return pointer to p'th next line*/
  138. struct aring *ring;
  139. int p;
  140. {
  141.     return ring -> buf[ (p - 1 + ring -> ringp) % MAXSYNC];
  142. }
  143.  
  144. pline(c)        /*print a line and free its storage space*/
  145. char *c;
  146. {
  147.     lineincr();
  148.     if (c != EOF) {
  149.         puts(c);
  150.         free(c);
  151.         }
  152.     else puts("--End Of File--");
  153.     putchar('\n');
  154. }
  155.  
  156. putchar(c)        /*print a printable character,
  157.               on printer too if putboth
  158.               or into report file if reporting*/
  159. int c;
  160. {
  161.     if (c < ' ' && (c != '\n' && c != '\r' && c != '\t')) return c;
  162.     if (c == '\n')putchar('\r');
  163.     if (putboth) {
  164.         if (c == '\t') while (++col%8) bdos(5,' ');
  165.         else {
  166.             if (c == '\n') col=0;
  167.             else col++;
  168.             bdos(5,c);
  169.             }
  170.         }
  171.     if (report) {
  172.         if (putc(c,repbuf) == ERROR) {
  173.             report=NO; 
  174.             puts("Error on writing report file\n");
  175.             exit();
  176.             }
  177.         }
  178.     else bdos(2,c);
  179.     return c;
  180. }
  181. lineincr()    /*increment line count; pause, print header
  182.                 if at end of screen*/
  183. {
  184.     if (line >= 22 && pause) {
  185.         puts("\t\t\t\t\t[Return]/Quit > ");
  186.         if (tolower(getchar()) == 'q') exit();
  187.         putchar('\n');
  188.         line=0;
  189.         }
  190.     if (!line++)printf("\t<<<<< Comparison of %s with %s >>>>>\n",
  191.     name1,name2);
  192. }
  193.  
  194. scompare(s1,s2)        /*compare strings for equality (0=same)*/
  195. char *s1,*s2;
  196. {
  197.     if (s1 == s2) return 0; /*both EOF*/
  198.     if (s1 == EOF || s2 == EOF) return 1;
  199.     return (white ? txtcmp(s1,s2) : strcmp(s1,s2));
  200. }
  201.  
  202. txtcmp(s1,s2)        /*compare strings, matching white space with
  203.             any white space chars*/
  204. char *s1,*s2;
  205. {
  206.     while (*s1 && *s2) {
  207.         if ((*s1 == ' ' || *s1 == '\t') && (*s2 == ' ' || *s2 == '\t')) {
  208.             while (*s1 == ' ' || *s1 == '\t') s1++;
  209.             while (*s2 == ' ' || *s2 == '\t') s2++;
  210.             if (!*s1 && !*s2) return 0;
  211.             }
  212.         if (*s1++ != *s2++) return 1;
  213.         }
  214.     while (*s1 == ' ' || *s1 == '\t') *s1++;
  215.     while (*s2 == ' ' || *s2 == '\t') *s2++;
  216.     return *s1-*s2;
  217. }
  218.         
  219. search(ringa,ringb,c)    /*try to get files back into sync. when mismatch
  220.                 has been found.  If successful, returns
  221.                 number of lines to skip to get back to
  222.                 synchronity, else 0*/
  223. struct aring *ringa, *ringb;
  224. char *c;
  225. {
  226.     int outofsync, match, i;
  227.  
  228.     if (nosync) return 0;
  229.     for (outofsync=1; outofsync < MAXSYNC; outofsync++)
  230.         /*look forward for a match*/
  231.         if (!scompare(peep(ringb,outofsync),c)) break;
  232.     /*break when found*/
  233.  
  234.     if (outofsync == MAXSYNC) return 0;
  235.     else   /* match found, look for sync more */
  236.     for (match=1; match < sync; match++)
  237.         if ( (i=outofsync+match) >= MAXSYNC ||
  238.         scompare(peep(ringa,match),peep(ringb,i)))
  239.             break;    /*break if no match*/
  240.  
  241.     if (match == sync) return outofsync;
  242.     /*return pos of start of sync matches*/
  243.     else return 0;
  244. }
  245.  
  246. blksrch(ringa,ringb,n)    /*try to get files back into sync. when mismatch
  247.                 at n'th character after current
  248.                 has been found.  If successful, returns
  249.                 number of lines to skip to get back to
  250.                 synchronity, else 0*/
  251. struct aring *ringa, *ringb;
  252. int n;
  253. {
  254.     int outofsync, match, i;
  255.  
  256.     if (nosync) return 0;
  257.     for (outofsync=1; outofsync+n < MAXSYNC; outofsync++)
  258.         /*look forward for a match*/
  259.         if (!scompare(peep(ringb,outofsync+n),peep(ringa,n)))
  260.             break; /*break when found*/
  261.  
  262.     if (outofsync == MAXSYNC) return 0;
  263.     else   /* match found, look for sync more */
  264.     for (match=1; match < sync; match++)
  265.         if ( (i=outofsync+match+n) >= MAXSYNC ||
  266.         scompare(peep(ringa,match+n),peep(ringb,i)))
  267.             break;    /*break if no match*/
  268.     if (match == sync) return outofsync;
  269.     /*return pos of start of sync matches*/
  270.     else return 0;
  271. }
  272.  
  273. addr(p)        /*gets a line number from a command line parameter;
  274.             returns it*/
  275. char **p;
  276. {
  277.     int n;
  278.  
  279.     n=0;
  280.     while (*(++*p))    n=10*n+**p-'0';
  281.     return n;
  282. }
  283.  
  284. args(argc,argv)        /*read args from command line*/
  285.  
  286. int argc;
  287. char *argv[];
  288. {
  289.     int i;
  290.     char *p;
  291.  
  292.     putboth=listing=nosync=report=NO;
  293.     pause=parity=white=YES;
  294.     start=sync=0; 
  295.     stop=MAXINT;
  296.     printf("[Textcom v%d.%d]\n",VERSION/10,VERSION%10);
  297.     if (argc < 3) {
  298.         puts("Usage: TEXTCOM  oldfile  newfile [options]\n");
  299.         puts("\t(compares an old version of a text file with a new)\n");
  300.         puts("\n   Options:\n");
  301.         puts("       -Sdd  to syncronise up to dd lines\n");
  302.         printf("           (use -S for strict compare). Default = %d\n",
  303.         DEFLSYNC);
  304.         puts("       -L  to list differences on printer and screen\n");
  305.         puts("       -Rname to create a file, 'name', reporting differences\n");
  306.         puts("       -C  to continue without pauses at the end of each screen\n");
  307.         puts("       -Fxxxx to display differences only from ");
  308.         puts("line xxxx\n");
  309.         puts("       -Txxxx to stop comparison at line xxxx\n");
  310.         puts("       -P  to include parity bit in comparison\n");
  311.         puts("       -W  to match a white space char only with the same one\n");
  312.         exit();
  313.         }
  314.  
  315.     for (i=3; i < argc; i++) {
  316.         switch( *(p=++argv[i]) ) {
  317.         case 'L': 
  318.             listing=YES; 
  319.             break;
  320.         case 'C': 
  321.             pause=NO; 
  322.             break;
  323.         case 'S': 
  324.             sync=addr(&p); 
  325.             nosync=!sync;
  326.             if (sync >= MAXSYNC) {
  327.                 printf("Max. sync is %u",MAXSYNC); 
  328.                 exit();
  329.                 }
  330.             break;
  331.         case 'R': 
  332.             report=YES; 
  333.             strcpy(repname,++p); 
  334.             break;
  335.         case 'F': 
  336.             start=addr(&p); 
  337.             break;
  338.         case 'T': 
  339.             stop=addr(&p); 
  340.             break;
  341.         case 'P': 
  342.             parity=NO; 
  343.             break;
  344.         case 'W':
  345.             white=NO;
  346.             break;
  347.         default : 
  348.             puts("Unknown option -"); 
  349.             puts(p); 
  350.             exit();
  351.             }
  352.         }
  353.     if (stop < start) {
  354.         printf("-From (%d) is not less than -To (%d)\n",start,stop);
  355.         exit();
  356.         }
  357.     if(listing || report) pause=NO;
  358.     if(sync == 0) sync=DEFLSYNC;
  359.  
  360.     strcpy(name1,argv[1]);
  361.     if (fopen(name1,fbuf1) == ERROR) {
  362.         puts("Can't find "); 
  363.         puts(name1); 
  364.         exit();
  365.         }
  366.     initring(&ring1,fbuf1);
  367.  
  368.     strcpy(name2,argv[2]);
  369.     if (fopen(name2,fbuf2) == ERROR) {
  370.         puts("Can't find "); 
  371.         puts(name2); 
  372.         exit();
  373.         }
  374.     initring(&ring2,fbuf2);
  375.  
  376.     if (report) {
  377.         if (fcreat(repname,repbuf) == ERROR) {
  378.             puts("Can't open "); 
  379.             puts(repname); 
  380.             exit();
  381.             }
  382.         }
  383.     putboth=listing;
  384. }
  385.  
  386. printdif()    /*resynchronise and print differences */
  387. {
  388.     int unsync, i;
  389.  
  390.     if ( (unsync=search(&ring2,&ring1,c2))) { /*note deletion*/
  391.         lineincr();
  392.         puts(">>>>>> ");
  393.         if (unsync == 1) printf("Line %u",line1+1);
  394.         else printf("Lines %u to %u",line1,line1+unsync);
  395.         printf(" of %s deleted from %s\n",name1,name2);
  396.         for (i=0; i<unsync; i++) {
  397.             pline(c1);
  398.             c1=getline(&ring1,fbuf1);
  399.             }
  400.         line1+=unsync;
  401.         }
  402.     else {
  403.         if ((unsync=search(&ring1,&ring2,c1))) {
  404.             /*note insertion*/
  405.             lineincr();
  406.             puts(">>>>>> ");
  407.             if (unsync == 1) printf("Line %u",line2+1);
  408.             else printf("Lines %u to %u",line2,
  409.                 line2+unsync);
  410.             printf(" of %s inserted\n",name2);
  411.             for (i=0; i<unsync; i++) {
  412.                 pline(c2);
  413.                 c2=getline(&ring2,fbuf2);
  414.                 }
  415.             line2+=unsync;
  416.             }
  417.         else { /*look for a block of changed lines*/
  418.  
  419.             for (unsync=1; unsync < MAXSYNC &&
  420.         scompare(peep(&ring1,unsync),peep(&ring2,unsync)) &&
  421.         !blksrch(&ring1,&ring2,unsync) &&
  422.         !blksrch(&ring2,&ring1,unsync);
  423.         unsync++);
  424.                 if (unsync == 1) {
  425.                 lineincr();
  426.                 printf(">>>>>> Line %u of %s changed to line %u of %s\n",
  427.                 line1,name1,line2,name2);
  428.                 pline(c1,line1);
  429.                 pline(c2,line2);
  430.                 }
  431.             else {
  432.                 lineincr();
  433.                 printf(">>>>>> Lines %u to %u of %s ....\n",
  434.                 line1,line1+unsync-1,name1);
  435.                 for (i=1; i<=unsync; i++) {
  436.                     pline(c1);
  437.                     if (i < unsync)c1=getline(&ring1,fbuf1);
  438.                     }
  439.                 lineincr();
  440.                 printf(">>>>>> .... changed to lines %u to %u of %s\n",
  441.                 line2,line2+unsync-1,name2);
  442.                 for (i=1; i<=unsync; i++) {
  443.                     pline(c2);
  444.                     if(i < unsync)c2=getline(&ring2,fbuf2);
  445.                     }
  446.                 line1+=--unsync; 
  447.                 line2+=unsync;
  448.                 }
  449.             }
  450.         }
  451. }
  452.  
  453. main(argc,argv)
  454.  
  455. int argc;
  456. char *argv[];
  457.  
  458. {
  459.     _allocp=NULL;
  460.     args(argc,argv);
  461.  
  462.     line1=line2=1;
  463.     line=col=0;
  464.     different=NO;
  465.  
  466.     do {
  467.         c1=getline(&ring1,fbuf1);
  468.         c2=getline(&ring2,fbuf2);
  469.  
  470.         if (scompare(c1,c2)) { /*lines are different*/
  471.             different=YES;
  472.             if (line1 >= start && line2 >= start) printdif();
  473.             }
  474.         else {
  475.             if (c1 != EOF) free(c1);
  476.             if (c2 != EOF) free(c2);
  477.             }
  478.         line1++; 
  479.         line2++;
  480.         } 
  481.     while ((c1 != EOF || c2 != EOF) && (line1 < stop || line2 < stop));
  482.  
  483.     if (different) puts("Files differ");
  484.     else printf("Files %s and %s are identical",name1,name2);
  485.     if (start != 0 || stop != MAXINT)
  486.         printf(" between lines %u and %u\n",start,min(line1,line2));
  487.     else putchar('\n');
  488.  
  489.     if (report) { /*flush and close report file*/
  490.         putc(CPMEOF,repbuf); 
  491.         fflush(repbuf); 
  492.         fclose(repbuf);
  493.         }
  494. }
  495.     puts(">>>>>> ");
  496.             if (unsync == 1) printf("Line %u",line2+1);