/* fcom.c - file compare
*
* 4/30/86 daniel lipkie LineCompare, at end, if NOT Same then error
* 5/01/86 daniel lipkie SYM files treaded as binary
* if (quiet mode) then exit(1) on FIRST difference
* 27-May-1986 mz Make line arrays dynamically allocated at read
* time.
* Make default size be 300 lines.
* 05-Aug-1986 DANL MAX default line size 255
* 10-Feb-1987 mz Make /m imply /t
* 10-Jun-1987 danl fill -> fillbuf
* 09-Nov-1987 mz Fix 0D0D0A bug
* Fix different at line 2 bug
* 25-Nov-1987 mz All errors to stderr
* 30-Nov-1987 mz Resync fails dumps entire file
* 21-Jul-1988 bw Don't GP fault on empty test files
* 06-Aug-1990 davegi Changed Move to memmove (OS/2 2.0)
*
* Fcom compares two files in either a line-by-line mode or in a strict
* byte-by-byte mode.
*
* The byte-by-byte mode is simple; merely read both files and print the
* offsets where they differ and the contents.
*
* The line compare mode attempts to isolate differences in ranges of lines.
* Two buffers of lines are read and compared. No hashing of lines needs
* to be done; hashing only speedily tells you when things are different,
* not the same. Most files run through this are expected to be largely
* the same. Thus, hashing buys nothing.
*
* [0] Fill buffers
* [1] If both buffers are empty then
* [1.1] Done
* [2] Adjust buffers so 1st differing lines are at top.
* [3] If buffers are empty then
* [3.1] Goto [0]
*
* This is the difficult part. We assume that there is a sequence of inserts,
* deletes and replacements that will bring the buffers back into alignment.
*
* [4] xd = yd = FALSE
* [5] xc = yc = 1
* [6] xp = yp = 1
* [7] If buffer1[xc] and buffer2[yp] begin a "sync" range then
* [7.1] Output lines 1 through xc-1 in buffer 1
* [7.2] Output lines 1 through yp-1 in buffer 2
* [7.3] Adjust buffer 1 so line xc is at beginning
* [7.4] Adjust buffer 2 so line yp is at beginning
* [7.5] Goto [0]
* [8] If buffer1[xp] and buffer2[yc] begin a "sync" range then
* [8.1] Output lines 1 through xp-1 in buffer 1
* [8.2] Output lines 1 through yc-1 in buffer 2
* [8.3] Adjust buffer 1 so line xp is at beginning
* [8.4] Adjust buffer 2 so line yc is at beginning
* [8.5] Goto [0]
* [9] xp = xp + 1
* [10] if xp > xc then
* [10.1] xp = 1
* [10.2] xc = xc + 1
* [10.3] if xc > number of lines in buffer 1 then
* [10.4] xc = number of lines
* [10.5] xd = TRUE
* [11] if yp > yc then
* [11.1] yp = 1
* [11.2] yc = yc + 1
* [11.3] if yc > number of lines in buffer 2 then
* [11.4] yc = number of lines
* [11.5] yd = TRUE
* [12] if not xd or not yd then
* [12.1] goto [6]
*
* At this point there is no possible match between the buffers. For
* simplicity, we punt.
*
* [13] Display error message.
*
* Certain flags may be set to modify the behavior of the comparison:
*
* -a abbreviated output. Rather than displaying all of the modified
* ranges, just display the beginning, ... and the ending difference
* -b compare the files in binary (or byte-by-byte) mode. This mode is
* default on .EXE, .OBJ, .SYM, .LIB, .COM, .BIN, and .SYS files
* -c ignore case on compare (cmp = strcmpi instead of strcmp)
* -l compare files in line-by-line mode
* -lb n set the size of the internal line buffer to n lines from default
* of 300
* -m merge the input files into one for output. Use extention to
* indicate what kind of separators to use.
* -n output the line number also
* -NNNN set the number of lines to resynchronize to NNNN which defaults
* to 2
* -w ignore blank lines and white space (ignore len 0, use strcmps)
* -t do not untabify (use fgets instead of fgetl)
*/
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <process.h>
#include <ctype.h>
#include <math.h>
#include <stdlib.h>
#include <windows.h>
#include <tools.h>
int ctSync = -1; /* number of lines required to sync */
int cLine = -1; /* number of lines in internal buffs */
flagType fAbbrev = FALSE; /* abbreviated output */
flagType fBinary = FALSE; /* binary comparison */
flagType fLine = FALSE; /* line comparison */
flagType fNumb = FALSE; /* display line numbers */
flagType fCase = TRUE; /* case is significant */
flagType fIgnore = FALSE; /* ignore spaces and blank lines */
flagType fQuiet = FALSE; /* TRUE => no messages output */
flagType fMerge = FALSE; /* TRUE => merge files onto stdout */
int debug;
#define D_COMP 0x0001
#define D_CCALL 0x0002
#define D_RESYNC 0x0004
#define D_CALL 0x0008
#define D_SYNC 0x0010
struct lineType {
int line; /* line number */
char *text; /* body of line */
};
struct lineType *buffer1, *buffer2;
/*
* Forward Function Declarations
*/
void usage( char *, int );
int fillbuf( struct lineType *, FILE *, int, int * );
flagType compare( int, int, int, register int, register int);
int BinaryCompare( char *, char * );
void pline(struct lineType *);
void dump(struct lineType *, int, int);
int adjust (struct lineType *, int, int);
void LineCompare (char *, char *);
char * (__cdecl *funcRead) (char *, int, FILE *);
/* function to use to read lines */
int (__cdecl *fCmp)(const char *, const char *);
/* function to use to compare lines */
char line[MAXLINELEN]; /* single line buffer */
char *extBin[] = { ".EXE", ".OBJ", ".SYM", ".LIB", ".COM", ".BIN",
".SYS", NULL };
void
usage (p, erc)
char *p;
int erc;
{
if (!fQuiet) {
if (p)
fprintf (stderr, "fcom: %s\n", p);
else
fprintf (stderr, "usage: fcom [/a] [/b] [/c] [/l] [/lb n] [/m] [/n] [/NNNN] [/w] [/t] file1 file2\n");
}
exit(erc);
}
/* return number of lines read in
*
* pl line buffer to fill
* fh handle to read
* ct max number to read
* plnum line number counter to use
*
* returns number of lines read
*/
int fillbuf( struct lineType *pl, FILE *fh, int ct, int *plnum )
{
char *line;
int i, l;
if ((line = malloc (MAXLINELEN)) == NULL)
usage ("out of memory", 2);
if (TESTFLAG (debug, D_CALL))
printf ("fillbuf (%p, %p, %d)\n", pl, fh, ct);
i = 0;
while (ct-- && (*funcRead) (line, MAXLINELEN, fh) != NULL) {
if (pl->text != NULL)
free (pl->text);
l = strlen (line);
if ((pl->text = malloc (l+1)) == NULL)
usage ("out of memory", 2);
// djg Move ((char far *)line, (char far *) (pl->text), l+1);
memmove ((char *) (pl->text), (char *)line, l+1);
if (funcRead == fgets)
pl->text[l-2] = 0;
if (fIgnore && !strcmps (pl->text, ""))
pl->text[0] = 0;
if (l != 0 || !fIgnore) {
pl->line = ++*plnum;
pl++;
i++;
}
}
if (TESTFLAG (debug, D_CALL))
printf ("fillbuf returns %d\n", i);
free (line);
return i;
}
/* compare a range of lines
*
* l1, l2 number of lines in each line buffer
* s1, s2 beginning location in each buffer to begin compare
* ct number of contiguous lines to compare
*/
flagType compare (l1, s1, l2, s2, ct)
int l1, l2, ct;
register int s1, s2;
{
if (TESTFLAG (debug, D_CCALL))
printf ("compare (%d, %d, %d, %d, %d)\n", l1, s1, l2, s2, ct);
if (ct <= 0 || s1+ct > l1 || s2+ct > l2)
return FALSE;
while (ct--) {
if (TESTFLAG (debug, D_COMP))
printf ("'%s' == '%s'? ", buffer1[s1].text, buffer2[s2].text);
if ((*fCmp)(buffer1[s1++].text, buffer2[s2++].text)) {
if (TESTFLAG (debug, D_CCALL))
printf ("No\n");
return FALSE;
}
}
if (TESTFLAG (debug, D_CCALL))
printf ("Yes\n");
return TRUE;
}
BinaryCompare (f1, f2)
char *f1, *f2;
{
register int c1, c2;
long pos;
FILE *fh1, *fh2;
flagType fSame;
fSame = TRUE;
if ((fh1 = fopen (f1, "rb")) == NULL) {
sprintf (line, "cannot open %s - %s", f1, error ());
usage (line, 2);
}
if ((fh2 = fopen (f2, "rb")) == NULL) {
sprintf (line, "cannot open %s - %s", f2, error ());
usage (line, 2);
}
pos = 0L;
while (TRUE) {
if ((c1 = getc (fh1)) != EOF)
if ((c2 = getc (fh2)) != EOF)
if (c1 == c2)
;
else {
fSame = FALSE;
if (fQuiet)
exit(1);
else
printf ("%08lx: %02x %02x\n", pos, c1, c2);
}
else {
sprintf (line, "%s longer than %s", f1, f2);
usage (line, 1);
}
else
if ((c2 = getc (fh2)) == EOF)
if (fSame)
usage ("no differences encountered", 0);
else
exit (1);
else {
sprintf (line, "%s longer than %s", f2, f1);
usage (line, 1);
}
pos++;
}
return( 0 );
}
/* print out a single line */
void pline (pl)
struct lineType *pl;
{
if (fNumb)
printf ("%5d: ", pl->line);
printf ("%s\n", pl->text);
}
/* output a range of lines */
void dump( struct lineType *pl, int start, int end )
{
if (fAbbrev && end-start > 2) {
pline (pl+start);
printf ("...\n");
pline (pl+end);
}
else
while (start <= end)
pline (pl+start++);
}
/* adjust returns number of lines in buffer
*
* pl line buffer to be adjusted
* ml number of line in line buffer
* lt number of lines to scroll
*/
adjust( struct lineType *pl, int ml, int lt)
{
int i;
if (TESTFLAG (debug, D_CALL))
printf ("adjust (%p, %d, %d) = ", pl, ml, lt);
if (TESTFLAG (debug, D_CALL))
printf ("%d\n", ml-lt);
if (ml <= lt)
return 0;
if (TESTFLAG (debug, D_CALL))
printf ("move (%p, %p, %04x)\n", &pl[lt], &pl[0], sizeof (*pl)*(ml-lt));
/* buffer has 0..lt-1 lt..ml
* we free 0..lt-1
*/
for (i = 0; i < lt; i++)
if (pl[i].text != NULL)
free (pl[i].text);
/* buffer is 0..0 lt..ml
* compact to lt..ml ???
*/
// djg Move ((char far *)&pl[lt], (char far *)&pl[0], sizeof (*pl)*(ml-lt));
memmove ((char *)&pl[0], (char *)&pl[lt], sizeof (*pl)*(ml-lt));
/* buffer is lt..ml ??
* fill to be lt..ml 0..0
*/
for (i = ml-lt; i < ml; i++)
pl[i].text = NULL;
return ml-lt;
}
void LineCompare (f1, f2)
char *f1, *f2;
{
FILE *fh1, *fh2;
int l1, l2, i, xp, yp, xc, yc;
flagType xd, yd, fSame, fFirstLineDifferent;
int line1, line2;
fFirstLineDifferent = TRUE;
fSame = TRUE;
if ((fh1 = fopen (f1, "rb")) == NULL) {
sprintf (line, "cannot open %s - %s", f1, error ());
usage (line, 2);
}
if ((fh2 = fopen (f2, "rb")) == NULL) {
sprintf (line, "cannot open %s - %s", f2, error ());
usage (line, 2);
}
if ((buffer1 = (struct lineType *)calloc (cLine, sizeof *buffer1)) == NULL ||
(buffer2 = (struct lineType *)calloc (cLine, sizeof *buffer1)) == NULL)
usage ("out of memory\n", 2);
l1 = l2 = 0;
line1 = line2 = 0;
l0: if (TESTFLAG (debug, D_SYNC))
printf ("At scan beginning\n");
if (fQuiet && !fSame)
exit(1);
l1 += fillbuf (buffer1+l1, fh1, cLine-l1, &line1);
l2 += fillbuf (buffer2+l2, fh2, cLine-l2, &line2);
if (l1 == 0 && l2 == 0) {
if (fSame)
usage ("no differences encountered", 0);
else
usage ("differences encountered", 1);
}
/* find first line that differs in buffer
*/
xc = min (l1, l2);
for (i=0; i < xc; i++)
if (!compare (l1, i, l2, i, 1))
break;
if (fMerge)
dump (buffer2, 0, i-1);
/* If we are different at a place other than at the top then we know
* that there will be a matching line at the head of the buffer
*/
if (i != 0)
fFirstLineDifferent = FALSE;
/* if we found one at all, then adjust all buffers so last matching
* line is at top. Note that if we are doing this for the first buffers
* worth in the file then the top lines WON'T MATCH
*/
if (i != xc)
i = max (i-1, 0);
l1 = adjust (buffer1, l1, i);
l2 = adjust (buffer2, l2, i);
/* if we've matched the entire buffers-worth then go back and fill some
* more
*/
if (l1 == 0 && l2 == 0) {
fFirstLineDifferent = FALSE;
goto l0;
}
/* Fill up the buffers as much as possible; the next match may occur
* AFTER the current set of buffers
*/
l1 += fillbuf (buffer1+l1, fh1, cLine-l1, &line1);
l2 += fillbuf (buffer2+l2, fh2, cLine-l2, &line2);
if (TESTFLAG (debug, D_SYNC))
printf ("buffers are adjusted, %d, %d remain\n", l1, l2);
xd = yd = FALSE;
xc = yc = 1;
xp = yp = 1;
/* begin trying to match the buffers
*/
l6: if (TESTFLAG (debug, D_RESYNC))
printf ("Trying resync %d,%d %d,%d\n", xc, xp, yc, yp);
i = min (l1-xc,l2-yp);
i = min (i, ctSync);
if (compare (l1, xc, l2, yp, i)) {
fSame = FALSE;
if (fMerge) {
printf ("#if OLDVERSION\n");
dump (buffer1, fFirstLineDifferent ? 0 : 1, xc-1);
printf ("#else\n");
dump (buffer2, fFirstLineDifferent ? 0 : 1, yp-1);
printf ("#endif\n");
}
else
if (!fQuiet) {
printf ("***** %s\n", f1);
dump (buffer1, 0, xc);
printf ("***** %s\n", f2);
dump (buffer2, 0, yp);
printf ("*****\n\n");
}
if (TESTFLAG (debug, D_SYNC))
printf ("Sync at %d,%d\n", xc, yp);
l1 = adjust (buffer1, l1, xc);
l2 = adjust (buffer2, l2, yp);
fFirstLineDifferent = FALSE;
goto l0;
}
i = min (l1-xp, l2-yc);
i = min (i, ctSync);
if (compare (l1, xp, l2, yc, i)) {
fSame = FALSE;
if (fMerge) {
printf ("#if OLDVERSION\n");
dump (buffer1, fFirstLineDifferent ? 0 : 1, xp-1);
printf ("#else\n");
dump (buffer2, fFirstLineDifferent ? 0 : 1, yc-1);
printf ("#endif\n");
}
else
if (!fQuiet) {
printf ("***** %s\n", f1);
dump (buffer1, 0, xp);
printf ("***** %s\n", f2);
dump (buffer2, 0, yc);
printf ("*****\n\n");
}
if (TESTFLAG (debug, D_SYNC))
printf ("Sync at %d,%d\n", xp, yc);
l1 = adjust (buffer1, l1, xp);
l2 = adjust (buffer2, l2, yc);
fFirstLineDifferent = FALSE;
goto l0;
}
if (++xp > xc) {
xp = 1;
if (++xc >= l1) {
xc = l1;
xd = TRUE;
}
}
if (++yp > yc) {
yp = 1;
if (++yc >= l2) {
yc = l1;
yd = TRUE;
}
}
if (!xd || !yd)
goto l6;
fSame = FALSE;
if (fMerge) {
if (l1 >= cLine || l2 >= cLine)
fprintf (stderr, "resync failed. Files are too different\n");
printf ("#if OLDVERSION\n");
do {
dump (buffer1, 0, l1-1);
l1 = adjust (buffer1, l1, l1);
} while (l1 += fillbuf (buffer1+l1, fh1, cLine-l1, &line1));
printf ("#else\n");
do {
dump (buffer2, 0, l2-1);
l2 = adjust (buffer2, l2, l2);
} while (l2 += fillbuf (buffer2+l2, fh2, cLine-l2, &line2));
printf ("#endif\n");
}
else
if (!fQuiet) {
if (l1 >= cLine || l2 >= cLine)
fprintf (stderr, "resync failed. Files are too different\n");
printf ("***** %s\n", f1);
do {
dump (buffer1, 0, l1-1);
l1 = adjust (buffer1, l1, l1);
} while (l1 += fillbuf (buffer1+l1, fh1, cLine-l1, &line1));
printf ("***** %s\n", f2);
do {
dump (buffer2, 0, l2-1);
l2 = adjust (buffer2, l2, l2);
} while (l2 += fillbuf (buffer2+l2, fh2, cLine-l2, &line2));
printf ("*****\n\n");
}
exit (1);
}
__cdecl main (c, v)
int c;
char *v[];
{
int i;
funcRead = fgetl;
ConvertAppToOem( c, v );
if (c == 1)
usage (NULL, 2);
SHIFT(c,v);
while (fSwitChr (**v)) {
if (!strcmp (*v+1, "a"))
fAbbrev = TRUE;
else
if (!strcmp (*v+1, "b"))
fBinary = TRUE;
else
if (!strcmp (*v+1, "c"))
fCase = FALSE;
else
if (!strncmp (*v+1, "d", 1))
debug = atoi (*v+2);
else
if (!strcmp (*v+1, "l"))
fLine = TRUE;
else
if (!strcmp (*v+1, "lb")) {
SHIFT(c,v);
cLine = ntoi (*v, 10);
}
else
if (!strcmp (*v+1, "m")) {
fMerge = TRUE;
funcRead = fgets;
}
else
if (!strcmp (*v+1, "n"))
fNumb = TRUE;
else
if (!strcmp (*v+1, "q"))
fQuiet = TRUE;
else
if (*strbskip (*v+1, "0123456789") == '\0')
ctSync = ntoi (*v+1, 10);
else
if (!strcmp (*v+1, "t"))
funcRead = fgets;
else
if (!strcmp (*v+1, "w"))
fIgnore = TRUE;
else
usage (NULL, 2);
SHIFT(c,v);
}
if (c != 2)
usage (NULL, 2);
if (ctSync != -1)
fLine = TRUE;
else
ctSync = 2;
if (cLine == -1)
cLine = 300;
if (!fBinary && !fLine) {
extention (v[0], line);
for (i = 0; extBin[i]; i++)
if (!_strcmpi (extBin[i], line))
fBinary = TRUE;
if (!fBinary)
fLine = TRUE;
}
if (fBinary && (fLine || fNumb))
usage ("incompatable switches", 2);
if (fIgnore)
if (fCase)
fCmp = strcmps;
else
fCmp = strcmpis;
else
if (fCase)
fCmp = strcmp;
else
fCmp = _strcmpi;
if (fBinary)
BinaryCompare (v[0], v[1]);
else
LineCompare (v[0], v[1]);
return( 0 );
}