1393 lines
38 KiB
C++
1393 lines
38 KiB
C++
/*++
|
||
|
||
Copyright (c) 1990-2000 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
FC
|
||
|
||
Abstract:
|
||
|
||
FC is a DOS-5 compatible file comparison utility
|
||
|
||
Author:
|
||
|
||
Ramon Juan San Andres (ramonsa) 01-May-1991
|
||
|
||
Notes:
|
||
|
||
This FC is a port of the DOS5 FC code. It has been slightly modified
|
||
to use some of the ULIB functionality (e.g. argument parsing), however
|
||
it does not make full use of the ULIB functionality (e.g. it uses
|
||
stdio.h functions for file handling).
|
||
|
||
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
|
||
/****************************************************************************
|
||
File Compare
|
||
|
||
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.
|
||
|
||
|
||
***********************************************************************
|
||
The algorithm that immediately follows does not work. There is an error
|
||
somewhere in the range of lines 11 on. An alternative explanation follows.
|
||
KGS
|
||
************************************************************************
|
||
|
||
[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.
|
||
|
||
EXPLANATION 2
|
||
|
||
This is a variation of the Largest Common Subsequence problem. A
|
||
detailed explanation of this can be found on p 189 of Data Structures
|
||
and Algorithms by Aho Hopcroft and Ulman.
|
||
|
||
FC maintains two buffers within which it tries to find the Largest Common
|
||
Subsequence (The largest common subsequence is simply the pattern in
|
||
buffer1 that yields the most matches with the pattern in buffer2, or the
|
||
pattern in buffer2 that yields the most matches with the pattern in buffer1)
|
||
|
||
FC makes a simplifying assumption that the contents of one buffer can be
|
||
converted to the contents of the other buffer by deleting the lines that are
|
||
different between the two buffers.
|
||
|
||
Two indices into each buffer are maintained:
|
||
|
||
xc, yc == point to the last line that has been scanned up to now
|
||
|
||
xp, yp == point to the first line that has not been exhaustively
|
||
compared to lines 0 - #c in the other buffer.
|
||
|
||
FC now makes a second simplifying assumption:
|
||
It is unnecessary to do any calculations on lines that are equal.
|
||
|
||
Hence FC scans File1 and File two line by line until a difference is
|
||
encountered.
|
||
|
||
When a difference is encountered the two buffers are filled such that
|
||
the line containing the first difference heads the buffer. The following
|
||
exhaustive search algorithm is applied to find the first "sync" occurance.
|
||
(The below is simplified to use == for comparison. In practice more than
|
||
one line needs to match for a "sync" to be established).
|
||
|
||
FOR xc,yc = 1; xc,yx <= sizeof( BUFFERS ); xc++, yc++
|
||
|
||
FOR xp,yp = 1; xp,yp <= xc,yc; xp++, yp++
|
||
|
||
IF ( BUFFER1[xp] == BUFFER2[yc] )
|
||
|
||
Then the range of lines BUFFER1[ 1 ... xp ] and
|
||
BUFFER2[ 1 ... yc ] need to be deleted for the
|
||
two files to be equal. Therefore DISPLAY these
|
||
ranges, and begin scanning both files starting at
|
||
the matching lines.
|
||
FI
|
||
|
||
IF ( BUFFER1[yp] == BUFFER2[xc] )
|
||
|
||
Then the range of lines BUFFER2[ 1 ... yp ] and
|
||
BUFFER1[ 1 ... xc ] need to be deleted for the
|
||
two files to be equal. Therefore DISPLAY these
|
||
ranges, and begin scanning both files starting at
|
||
the matching lines.
|
||
FI
|
||
FOREND
|
||
FOREND
|
||
|
||
If a match is not found within the buffers, the message "RESYNC FAILED"
|
||
is issued and further comparison is aborted since there is no valid way
|
||
to find further matching lines.
|
||
|
||
END EXPLANATION 2
|
||
|
||
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, .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 100
|
||
-u Files to be compared are UNICODE text files
|
||
-w ignore blank lines and white space (ignore len 0, use strcmps)
|
||
-t do not untabify (use fgets instead of fgetl)
|
||
-n output the line number also
|
||
-NNNN set the number of lines to resynchronize to n which defaults
|
||
to 2. Failure to have this value set correctly can result in
|
||
odd output:
|
||
file1: file2:
|
||
abcdefg abcdefg
|
||
aaaaaaa aaaaaab
|
||
aaaaaaa aaaaaaa
|
||
aaaaaaa aaaaaaa
|
||
abcdefg abcdefg
|
||
|
||
with default sync of 2 yields: with sync => 3 yields:
|
||
|
||
*****f1 *****f1
|
||
abcdefg abcdefg
|
||
aaaaaaa aaaaaaa
|
||
*****f2 aaaaaaa
|
||
abcdefg *****f2
|
||
aaaaaab abcdefg
|
||
aaaaaaa aaaaaab
|
||
aaaaaaa
|
||
*****f1
|
||
aaaaaaa
|
||
aaaaaaa
|
||
abcdefg
|
||
*****f2
|
||
aaaaaaa
|
||
abcdefg
|
||
|
||
WARNING:
|
||
This program makes use of GOTO's and hence is not as straightforward
|
||
as it could be! CAVEAT PROGRAMMER.
|
||
****************************************************************************/
|
||
|
||
|
||
#include "ulib.hxx"
|
||
#include "fc.hxx"
|
||
#include "arg.hxx"
|
||
#include "array.hxx"
|
||
#include "arrayit.hxx"
|
||
#include "bytestrm.hxx"
|
||
#include "dir.hxx"
|
||
#include "file.hxx"
|
||
#include "filestrm.hxx"
|
||
#include "filter.hxx"
|
||
#include "mbstr.hxx"
|
||
#include "system.hxx"
|
||
#include "wstring.hxx"
|
||
|
||
#include <malloc.h>
|
||
#include <process.h>
|
||
#include <stdlib.h>
|
||
#include <math.h>
|
||
#include <locale.h>
|
||
|
||
/**************************************************************************/
|
||
/* main */
|
||
/**************************************************************************/
|
||
|
||
INT __cdecl
|
||
main (
|
||
)
|
||
{
|
||
DEFINE_CLASS_DESCRIPTOR( FC );
|
||
|
||
{
|
||
FC Fc;
|
||
|
||
if ( Fc.Initialize() ) {
|
||
|
||
return Fc.Fcmain();
|
||
}
|
||
}
|
||
|
||
return FAILURE;
|
||
}
|
||
|
||
|
||
|
||
|
||
CHAR *ExtBin[] = { "EXE", "OBJ", "LIB",
|
||
"COM", "BIN", "SYS", NULL };
|
||
|
||
|
||
|
||
|
||
DEFINE_CONSTRUCTOR( FC, PROGRAM );
|
||
|
||
|
||
FC::~FC () {
|
||
}
|
||
|
||
|
||
|
||
BOOLEAN FC::Initialize() {
|
||
|
||
|
||
if ( PROGRAM::Initialize() ) {
|
||
|
||
ValidateVersion();
|
||
|
||
ctSync = -1; // number of lines required to sync
|
||
cLine = -1; // number of lines in internal buffs
|
||
|
||
fAbbrev = FALSE; // abbreviated output
|
||
fBinary = FALSE; // binary comparison
|
||
fLine = FALSE; // line comparison
|
||
fNumb = FALSE; // display line numbers
|
||
fCase = TRUE; // case is significant
|
||
fIgnore = FALSE; // ignore spaces and blank lines
|
||
fSkipOffline = TRUE; // skip offline files
|
||
|
||
fOfflineSkipped = FALSE; // no files are skipped
|
||
|
||
#ifdef DEBUG
|
||
fDebug = FALSE;
|
||
#endif
|
||
|
||
fExpandTabs = TRUE;
|
||
// funcRead = (int (*)(char *,int,FILE *))fgetl;
|
||
|
||
extBin = (CHAR **)ExtBin;
|
||
|
||
return ParseArguments();
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
BOOLEAN
|
||
FC::ParseArguments(
|
||
)
|
||
{
|
||
|
||
ARGUMENT_LEXEMIZER ArgLex;
|
||
ARRAY LexArray;
|
||
ARRAY ArrayOfArg;
|
||
|
||
PATH_ARGUMENT ProgramName;
|
||
FLAG_ARGUMENT FlagAbbreviate;
|
||
FLAG_ARGUMENT FlagAsciiCompare;
|
||
FLAG_ARGUMENT FlagBinaryCompare;
|
||
FLAG_ARGUMENT FlagCaseInsensitive;
|
||
FLAG_ARGUMENT FlagCompression;
|
||
FLAG_ARGUMENT FlagExpansion;
|
||
FLAG_ARGUMENT FlagLineNumber;
|
||
FLAG_ARGUMENT FlagRequestHelp;
|
||
FLAG_ARGUMENT FlagUnicode;
|
||
FLAG_ARGUMENT FlagIncludeOffline;
|
||
FLAG_ARGUMENT FlagIncludeOffline2;
|
||
LONG_ARGUMENT LongBufferSize;
|
||
#ifdef DEBUG
|
||
FLAG_ARGUMENT FlagDebug;
|
||
#endif
|
||
STRING_ARGUMENT LongMatch;
|
||
PATH_ARGUMENT InFile1;
|
||
PATH_ARGUMENT InFile2;
|
||
|
||
LONG Long;
|
||
INT i;
|
||
|
||
|
||
if( !LexArray.Initialize() ) {
|
||
DebugAbort( "LexArray.Initialize() Failed!\n" );
|
||
return( FALSE );
|
||
}
|
||
if( !ArgLex.Initialize(&LexArray) ) {
|
||
DebugAbort( "ArgLex.Initialize() Failed!\n" );
|
||
return( FALSE );
|
||
}
|
||
|
||
// Allow only the '/' as a valid switch
|
||
ArgLex.PutSwitches("/");
|
||
ArgLex.SetCaseSensitive( FALSE );
|
||
|
||
ArgLex.PutStartQuotes("\"");
|
||
ArgLex.PutEndQuotes("\"");
|
||
ArgLex.PutSeparators(" \t");
|
||
|
||
if( !ArgLex.PrepareToParse() ) {
|
||
DebugAbort( "ArgLex.PrepareToParse() Failed!\n" );
|
||
return( FALSE );
|
||
}
|
||
|
||
if( !ProgramName.Initialize("*") ||
|
||
!FlagAbbreviate.Initialize("/A") ||
|
||
!FlagAsciiCompare.Initialize("/L") ||
|
||
!FlagBinaryCompare.Initialize("/B") ||
|
||
!FlagCaseInsensitive.Initialize("/C") ||
|
||
!FlagCompression.Initialize("/W") ||
|
||
!FlagExpansion.Initialize("/T") ||
|
||
!FlagLineNumber.Initialize("/N") ||
|
||
!FlagRequestHelp.Initialize("/?") ||
|
||
!FlagUnicode.Initialize("/U") ||
|
||
!FlagIncludeOffline.Initialize("/OFFLINE") ||
|
||
!FlagIncludeOffline2.Initialize("/OFF") ||
|
||
#ifdef DEBUG
|
||
!FlagDebug.Initialize("/D") ||
|
||
#endif
|
||
!LongBufferSize.Initialize("/LB#") ||
|
||
!LongMatch.Initialize("/*") ||
|
||
!InFile1.Initialize("*") ||
|
||
!InFile2.Initialize("*") ) {
|
||
|
||
DebugAbort( "Unable to Initialize some or all of the Arguments!\n" );
|
||
return( FALSE );
|
||
}
|
||
|
||
|
||
if( !ArrayOfArg.Initialize() ) {
|
||
DebugAbort( "ArrayOfArg.Initialize() Failed\n" );
|
||
return( FALSE );
|
||
}
|
||
|
||
if( !ArrayOfArg.Put(&ProgramName) ||
|
||
!ArrayOfArg.Put(&FlagAbbreviate) ||
|
||
!ArrayOfArg.Put(&FlagAsciiCompare) ||
|
||
!ArrayOfArg.Put(&FlagBinaryCompare) ||
|
||
!ArrayOfArg.Put(&FlagCaseInsensitive) ||
|
||
!ArrayOfArg.Put(&FlagCompression) ||
|
||
!ArrayOfArg.Put(&FlagExpansion) ||
|
||
!ArrayOfArg.Put(&FlagLineNumber) ||
|
||
!ArrayOfArg.Put(&FlagRequestHelp) ||
|
||
!ArrayOfArg.Put(&FlagUnicode) ||
|
||
!ArrayOfArg.Put(&FlagIncludeOffline) ||
|
||
!ArrayOfArg.Put(&FlagIncludeOffline2) ||
|
||
#ifdef DEBUG
|
||
!ArrayOfArg.Put(&FlagDebug) ||
|
||
#endif
|
||
!ArrayOfArg.Put(&LongBufferSize) ||
|
||
!ArrayOfArg.Put(&LongMatch) ||
|
||
!ArrayOfArg.Put(&InFile1) ||
|
||
!ArrayOfArg.Put(&InFile2) ) {
|
||
|
||
DebugAbort( "ArrayOfArg.Put() Failed!\n" );
|
||
return( FALSE );
|
||
}
|
||
|
||
|
||
if( !( ArgLex.DoParsing( &ArrayOfArg ) ) ) {
|
||
// For each incorrect command line parameter, FC displays the
|
||
// following message:
|
||
//
|
||
// FC: Invalid Switch
|
||
//
|
||
// It does *not* die if a parameter is unrecognized...(Dos does...)
|
||
//
|
||
DisplayMessage( MSG_FC_INVALID_SWITCH, ERROR_MESSAGE, "" );
|
||
// return( FALSE );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// It should now be safe to test the arguments for their values...
|
||
//
|
||
if( FlagRequestHelp.QueryFlag() ) {
|
||
DisplayMessage( MSG_FC_HELP_MESSAGE, NORMAL_MESSAGE, "" );
|
||
return( FALSE );
|
||
}
|
||
|
||
if( FlagBinaryCompare.QueryFlag() &&
|
||
( FlagAsciiCompare.QueryFlag() || FlagLineNumber.QueryFlag() ) ) {
|
||
|
||
DisplayMessage( MSG_FC_INCOMPATIBLE_SWITCHES, ERROR_MESSAGE, "" );
|
||
return( FALSE );
|
||
}
|
||
|
||
if( !InFile1.IsValueSet() ||
|
||
!InFile2.IsValueSet() ) {
|
||
DisplayMessage( MSG_FC_INSUFFICIENT_FILES, ERROR_MESSAGE, "" );
|
||
return( FALSE );
|
||
}
|
||
|
||
|
||
//
|
||
// Convert filenames to upper case
|
||
//
|
||
_File1.Initialize( InFile1.GetPath() );
|
||
_File2.Initialize( InFile2.GetPath() );
|
||
|
||
((PWSTRING)_File1.GetPathString())->Strupr();
|
||
((PWSTRING)_File2.GetPathString())->Strupr();
|
||
|
||
|
||
fUnicode = FlagUnicode.QueryFlag();
|
||
fAbbrev = FlagAbbreviate.QueryFlag();
|
||
fCase = !FlagCaseInsensitive.QueryFlag();
|
||
fIgnore = FlagCompression.QueryFlag();
|
||
fNumb = FlagLineNumber.QueryFlag();
|
||
fBinary = FlagBinaryCompare.QueryFlag();
|
||
fSkipOffline = ( !FlagIncludeOffline.QueryFlag() ) &&
|
||
( !FlagIncludeOffline2.QueryFlag() );
|
||
|
||
if ( FlagExpansion.QueryFlag() ) {
|
||
fExpandTabs = FALSE;
|
||
//funcRead = (int (*)(char *,int,FILE *))fgets;
|
||
}
|
||
|
||
#ifdef DEBUG
|
||
fDebug = FlagDebug.QueryFlag();
|
||
#endif
|
||
|
||
|
||
if ( LongBufferSize.IsValueSet() ) {
|
||
cLine = (INT)LongBufferSize.QueryLong();
|
||
fLine = TRUE;
|
||
} else {
|
||
cLine = 100;
|
||
}
|
||
|
||
if ( LongMatch.IsValueSet() ) {
|
||
if ( LongMatch.GetString()->QueryNumber( &Long ) ) {
|
||
ctSync = (INT)Long;
|
||
fLine = TRUE;
|
||
} else {
|
||
|
||
DisplayMessage( MSG_FC_INVALID_SWITCH, ERROR_MESSAGE, "" );
|
||
ctSync = 2;
|
||
}
|
||
} else {
|
||
ctSync = 2;
|
||
}
|
||
|
||
if (!fBinary && !fLine) {
|
||
|
||
DSTRING ExtBin;
|
||
PWSTRING Ext = _File1.QueryExt();
|
||
|
||
if ( Ext ) {
|
||
for (i=0; extBin[i]; i++) {
|
||
ExtBin.Initialize( extBin[i] );
|
||
if ( !ExtBin.Stricmp( Ext ) ) {
|
||
fBinary = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
DELETE( Ext );
|
||
}
|
||
|
||
if (!fBinary) {
|
||
fLine = TRUE;
|
||
}
|
||
}
|
||
|
||
if (!fUnicode) {
|
||
if (fIgnore) {
|
||
if (fCase) {
|
||
fCmp = MBSTR::Strcmps;
|
||
} else {
|
||
fCmp = MBSTR::Strcmpis;
|
||
}
|
||
} else {
|
||
|
||
if (fCase) {
|
||
fCmp = MBSTR::Strcmp;
|
||
} else {
|
||
fCmp = MBSTR::Stricmp;
|
||
}
|
||
}
|
||
} else {
|
||
if (fIgnore) {
|
||
if (fCase) {
|
||
fCmp_U = WSTRING::Strcmps;
|
||
} else {
|
||
fCmp_U = WSTRING::Strcmpis;
|
||
}
|
||
} else {
|
||
|
||
if (fCase) {
|
||
fCmp_U = WSTRING::Strcmp;
|
||
} else {
|
||
fCmp_U = WSTRING::Stricmp;
|
||
}
|
||
}
|
||
}
|
||
|
||
return( TRUE );
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
INT
|
||
FC::Fcmain
|
||
(
|
||
)
|
||
{
|
||
return ParseFileNames();
|
||
}
|
||
|
||
|
||
|
||
|
||
/**************************************************************************/
|
||
/* BinaryCompare */
|
||
/**************************************************************************/
|
||
|
||
int
|
||
FC::BinaryCompare (
|
||
PCWSTRING f1,
|
||
PCWSTRING f2
|
||
)
|
||
{
|
||
|
||
PATH FileName;
|
||
PFSN_FILE File1 = NULL;
|
||
PFSN_FILE File2 = NULL;
|
||
PFILE_STREAM Stream1 = NULL;
|
||
PFILE_STREAM Stream2 = NULL;;
|
||
BYTE_STREAM Bs1;
|
||
BYTE_STREAM Bs2;
|
||
BYTE c1, c2;
|
||
ULONG64 pos;
|
||
BOOLEAN fSame;
|
||
char buffer[128];
|
||
BOOLEAN fFileSkipped;
|
||
|
||
|
||
if ( !FileName.Initialize( f1 ) ||
|
||
!(File1 = SYSTEM::QueryFile( &FileName, fSkipOffline, &fFileSkipped )) ||
|
||
!(Stream1 = File1->QueryStream( READ_ACCESS, FILE_FLAG_OPEN_NO_RECALL )) ||
|
||
!Bs1.Initialize( Stream1 )
|
||
) {
|
||
|
||
DELETE( Stream2 );
|
||
DELETE( File2 );
|
||
DELETE( Stream1 );
|
||
DELETE( File1 );
|
||
if (fFileSkipped) {
|
||
// Skipping offline files is not an error, just track this happened
|
||
fOfflineSkipped = TRUE;
|
||
return FILES_OFFLINE;
|
||
|
||
} else {
|
||
DisplayMessage( MSG_FC_UNABLE_TO_OPEN, ERROR_MESSAGE, "%W", f1 );
|
||
return FILES_NOT_FOUND;
|
||
}
|
||
}
|
||
|
||
if ( !FileName.Initialize( f2 ) ||
|
||
!(File2 = SYSTEM::QueryFile( &FileName, fSkipOffline, &fFileSkipped )) ||
|
||
!(Stream2 = File2->QueryStream( READ_ACCESS, FILE_FLAG_OPEN_NO_RECALL )) ||
|
||
!Bs2.Initialize( Stream2 )
|
||
) {
|
||
|
||
DELETE( Stream2 );
|
||
DELETE( File2 );
|
||
DELETE( Stream1 );
|
||
DELETE( File1 );
|
||
if (fFileSkipped) {
|
||
// Skipping offline files is not an error, just track this happened
|
||
fOfflineSkipped = TRUE;
|
||
return FILES_OFFLINE;
|
||
|
||
} else {
|
||
DisplayMessage( MSG_FC_UNABLE_TO_OPEN, ERROR_MESSAGE, "%W", f2 );
|
||
return FILES_NOT_FOUND;
|
||
}
|
||
}
|
||
|
||
fSame = TRUE;
|
||
pos = 0;
|
||
|
||
while ( TRUE ) {
|
||
|
||
if ( Bs1.ReadByte( &c1 ) ) {
|
||
|
||
if ( Bs2.ReadByte( &c2 ) ) {
|
||
|
||
if (c1 != c2) {
|
||
|
||
if (pos > MAXULONG) {
|
||
sprintf( buffer, "%016I64X: %02X %02X", pos, c1, c2 );
|
||
} else {
|
||
sprintf( buffer, "%08I64X: %02X %02X", pos, c1, c2 );
|
||
}
|
||
DisplayMessage( MSG_FC_DATA, NORMAL_MESSAGE, "%s", buffer );
|
||
fSame = FALSE;
|
||
|
||
}
|
||
|
||
} else {
|
||
|
||
DisplayMessage( MSG_FC_FILES_DIFFERENT_LENGTH, NORMAL_MESSAGE, "%W%W", f1, f2 );
|
||
fSame = FALSE;
|
||
break;
|
||
|
||
}
|
||
|
||
} else {
|
||
|
||
if ( Bs2.ReadByte( &c2 ) ) {
|
||
|
||
DisplayMessage( MSG_FC_FILES_DIFFERENT_LENGTH, NORMAL_MESSAGE, "%W%W", f2, f1 );
|
||
fSame = FALSE;
|
||
break;
|
||
|
||
} else {
|
||
|
||
if (fSame) {
|
||
DisplayMessage( MSG_FC_NO_DIFFERENCES, NORMAL_MESSAGE );
|
||
}
|
||
|
||
break;
|
||
|
||
}
|
||
}
|
||
|
||
pos++;
|
||
}
|
||
|
||
DELETE( Stream2 );
|
||
DELETE( File2 );
|
||
DELETE( Stream1 );
|
||
DELETE( File1 );
|
||
|
||
return fSame ? SUCCESS : FILES_ARE_DIFFERENT;
|
||
}
|
||
|
||
|
||
/**************************************************************************/
|
||
/* Compare a range of lines. */
|
||
/**************************************************************************/
|
||
|
||
BOOLEAN FC::compare (int l1, register int s1, int l2, register int s2, int ct)
|
||
{
|
||
#ifdef DEBUG
|
||
if (fDebug)
|
||
DebugPrintTrace(("compare (%d, %d, %d, %d, %d)\n", l1, s1, l2, s2, ct));
|
||
#endif
|
||
|
||
if (ct <= 0 || s1+ct > l1 || s2+ct > l2)
|
||
return (FALSE);
|
||
|
||
while (ct--)
|
||
{
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug)
|
||
DebugPrintTrace(("'%s' == '%s'? ", buffer1[s1].text, buffer2[s2].text));
|
||
#endif
|
||
if(!fUnicode) {
|
||
if ((*fCmp)(buffer1[s1++].text, buffer2[s2++].text)) {
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug)
|
||
DebugPrintTrace(("No\n"));
|
||
#endif
|
||
return (FALSE);
|
||
}
|
||
} else {
|
||
if ((*fCmp_U)(buffer1[s1++].wtext, buffer2[s2++].wtext)) {
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug)
|
||
DebugPrintTrace(("No\n"));
|
||
#endif
|
||
return (FALSE);
|
||
}
|
||
}
|
||
}
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug)
|
||
DebugPrintTrace(("Yes\n"));
|
||
#endif
|
||
|
||
return (TRUE);
|
||
}
|
||
|
||
|
||
/**************************************************************************/
|
||
/* LineCompare */
|
||
/**************************************************************************/
|
||
|
||
|
||
INT
|
||
FC::LineCompare(
|
||
PCWSTRING f1,
|
||
PCWSTRING f2
|
||
)
|
||
{
|
||
|
||
PATH FileName;
|
||
PFSN_FILE File1 = NULL;
|
||
PFSN_FILE File2 = NULL;
|
||
PFILE_STREAM Stream1 = NULL;
|
||
PFILE_STREAM Stream2 = NULL;
|
||
int result;
|
||
BOOLEAN fFileSkipped;
|
||
|
||
|
||
buffer1 = buffer2 = NULL;
|
||
|
||
if ( !FileName.Initialize( f1 ) ||
|
||
!(File1 = SYSTEM::QueryFile( &FileName, fSkipOffline, &fFileSkipped )) ||
|
||
!(Stream1 = File1->QueryStream( READ_ACCESS, FILE_FLAG_OPEN_NO_RECALL ))
|
||
) {
|
||
|
||
FREE(buffer1);
|
||
FREE(buffer2);
|
||
DELETE(Stream2);
|
||
DELETE(File2);
|
||
DELETE(Stream1);
|
||
DELETE(File1);
|
||
if (fFileSkipped) {
|
||
// Skipping offline files is not an error, just track this happened
|
||
fOfflineSkipped = TRUE;
|
||
return FILES_OFFLINE;
|
||
|
||
} else {
|
||
DisplayMessage( MSG_FC_UNABLE_TO_OPEN, ERROR_MESSAGE, "%W", f1 );
|
||
return FILES_NOT_FOUND;
|
||
}
|
||
}
|
||
|
||
if ( !FileName.Initialize( f2 ) ||
|
||
!(File2 = SYSTEM::QueryFile( &FileName, fSkipOffline, &fFileSkipped )) ||
|
||
!(Stream2 = File2->QueryStream( READ_ACCESS, FILE_FLAG_OPEN_NO_RECALL ))
|
||
) {
|
||
|
||
FREE(buffer1);
|
||
FREE(buffer2);
|
||
DELETE(Stream2);
|
||
DELETE(File2);
|
||
DELETE(Stream1);
|
||
DELETE(File1);
|
||
if (fFileSkipped) {
|
||
// Skipping offline files is not an error, just track this happened
|
||
fOfflineSkipped = TRUE;
|
||
return FILES_OFFLINE;
|
||
|
||
} else {
|
||
DisplayMessage( MSG_FC_UNABLE_TO_OPEN, ERROR_MESSAGE, "%W", f2 );
|
||
return FILES_NOT_FOUND;
|
||
}
|
||
}
|
||
|
||
|
||
if ( (buffer1 = (struct lineType *)MALLOC(cLine * (sizeof *buffer1))) == NULL ||
|
||
(buffer2 = (struct lineType *)MALLOC(cLine * (sizeof *buffer1))) == NULL) {
|
||
|
||
DisplayMessage( MSG_FC_OUT_OF_MEMORY, ERROR_MESSAGE );
|
||
FREE(buffer1);
|
||
FREE(buffer2);
|
||
DELETE(Stream2);
|
||
DELETE(File2);
|
||
DELETE(Stream1);
|
||
DELETE(File1);
|
||
return FAILURE;
|
||
}
|
||
|
||
result = RealLineCompare( f1, f2, Stream1, Stream2 );
|
||
|
||
FREE(buffer1);
|
||
FREE(buffer2);
|
||
DELETE(Stream2);
|
||
DELETE(File2);
|
||
DELETE(Stream1);
|
||
DELETE(File1);
|
||
|
||
return result;
|
||
}
|
||
|
||
int
|
||
FC::RealLineCompare (
|
||
PCWSTRING f1,
|
||
PCWSTRING f2,
|
||
PSTREAM Stream1,
|
||
PSTREAM Stream2
|
||
)
|
||
{
|
||
|
||
int l1, l2, i, xp, yp, xc, yc;
|
||
BOOLEAN xd, yd, fSame;
|
||
int line1, line2;
|
||
|
||
|
||
fSame = TRUE;
|
||
l1 = l2 = 0;
|
||
line1 = line2 = 0;
|
||
|
||
l0:
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug) {
|
||
DebugPrintTrace(("At scan beginning\n"));
|
||
}
|
||
#endif
|
||
|
||
l1 += xfill (buffer1+l1, Stream1, cLine-l1, &line1);
|
||
l2 += xfill (buffer2+l2, Stream2, cLine-l2, &line2);
|
||
|
||
if (l1 == 0 && l2 == 0) {
|
||
|
||
if (fSame) {
|
||
DisplayMessage( MSG_FC_NO_DIFFERENCES, NORMAL_MESSAGE );
|
||
}
|
||
return fSame ? SUCCESS : FILES_ARE_DIFFERENT;
|
||
}
|
||
|
||
xc = min (l1, l2);
|
||
|
||
for (i=0; i < xc; i++) {
|
||
|
||
if (!compare (l1, i, l2, i, 1)) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (i != xc) {
|
||
i = ( i-1 > 0 )? ( i-1 ) : 0;
|
||
}
|
||
|
||
l1 = adjust (buffer1, l1, i);
|
||
l2 = adjust (buffer2, l2, i);
|
||
|
||
if (l1 == 0 && l2 == 0) {
|
||
goto l0;
|
||
}
|
||
|
||
l1 += xfill (buffer1+l1, Stream1, cLine-l1, &line1);
|
||
l2 += xfill (buffer2+l2, Stream2, cLine-l2, &line2);
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug) {
|
||
DebugPrintTrace(("buffers are adjusted, %d, %d remain\n", l1, l2));
|
||
}
|
||
#endif
|
||
|
||
xd = yd = FALSE;
|
||
xc = yc = 1;
|
||
xp = yp = 1;
|
||
|
||
l6:
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug) {
|
||
DebugPrintTrace(("Trying resync %d,%d %d,%d\n", xc, xp, yc, yp));
|
||
}
|
||
#endif
|
||
|
||
i = min (l1-xc,l2-yp);
|
||
i = min (i, ctSync);
|
||
|
||
if (compare (l1, xc, l2, yp, i)) {
|
||
|
||
fSame = FALSE;
|
||
DisplayMessage( MSG_FC_OUTPUT_FILENAME, NORMAL_MESSAGE, "%W", f1 );
|
||
dump (buffer1, 0, xc);
|
||
DisplayMessage( MSG_FC_OUTPUT_FILENAME, NORMAL_MESSAGE, "%W", f2 );
|
||
dump (buffer2, 0, yp);
|
||
DisplayMessage( MSG_FC_DUMP_END, NORMAL_MESSAGE );
|
||
|
||
l1 = adjust (buffer1, l1, xc);
|
||
l2 = adjust (buffer2, l2, yp);
|
||
|
||
goto l0;
|
||
}
|
||
|
||
i = min (l1-xp, l2-yc);
|
||
i = min (i, ctSync);
|
||
|
||
if (compare (l1, xp, l2, yc, i)) {
|
||
|
||
fSame = FALSE;
|
||
DisplayMessage( MSG_FC_OUTPUT_FILENAME, NORMAL_MESSAGE, "%W", f1 );
|
||
dump (buffer1, 0, xp);
|
||
DisplayMessage( MSG_FC_OUTPUT_FILENAME, NORMAL_MESSAGE, "%W", f2 );
|
||
dump (buffer2, 0, yc);
|
||
DisplayMessage( MSG_FC_DUMP_END, NORMAL_MESSAGE );
|
||
|
||
l1 = adjust (buffer1, l1, xp);
|
||
l2 = adjust (buffer2, l2, yc);
|
||
|
||
goto l0;
|
||
}
|
||
|
||
if (++xp > xc) {
|
||
|
||
xp = 1;
|
||
if (++xc >= l1) {
|
||
|
||
xc = l1;
|
||
xd = TRUE;
|
||
}
|
||
}
|
||
|
||
if (++yp > yc) {
|
||
|
||
yp = 1;
|
||
if (++yc >= l2) {
|
||
|
||
yc = l2;
|
||
yd = TRUE;
|
||
}
|
||
}
|
||
|
||
if (!xd || !yd) {
|
||
goto l6;
|
||
}
|
||
|
||
fSame = FALSE;
|
||
|
||
if (l1 >= cLine || l2 >= cLine) {
|
||
DisplayMessage( MSG_FC_RESYNC_FAILED, NORMAL_MESSAGE );
|
||
}
|
||
|
||
DisplayMessage( MSG_FC_OUTPUT_FILENAME, NORMAL_MESSAGE, "%W", f1 );
|
||
dump (buffer1, 0, l1-1);
|
||
DisplayMessage( MSG_FC_OUTPUT_FILENAME, NORMAL_MESSAGE, "%W", f2 );
|
||
dump (buffer2, 0, l2-1);
|
||
DisplayMessage( MSG_FC_DUMP_END, NORMAL_MESSAGE );
|
||
|
||
return fSame ? SUCCESS : FILES_ARE_DIFFERENT;
|
||
}
|
||
|
||
|
||
/**************************************************************************/
|
||
/* Return number of lines read in. */
|
||
/**************************************************************************/
|
||
|
||
FC::xfill (struct lineType *pl, PSTREAM Stream, int ct, int *plnum)
|
||
{
|
||
int i;
|
||
DWORD StrSize;
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug)
|
||
DebugPrintTrace(("xfill (%04x, %04x)\n", pl, fh));
|
||
#endif
|
||
|
||
i = 0;
|
||
|
||
if (!fUnicode) {
|
||
while ( ct-- && !Stream->IsAtEnd() && Stream->ReadMbLine( pl->text, MAXLINESIZE, &StrSize, fExpandTabs, 8 ) ) {
|
||
|
||
if (fIgnore && !MBSTR::Strcmps(pl->text, "")) {
|
||
|
||
pl->text[0] = 0;
|
||
++*plnum;
|
||
}
|
||
|
||
if (strlen (pl->text) != 0 || !fIgnore)
|
||
{
|
||
pl->line = ++*plnum;
|
||
pl++;
|
||
i++;
|
||
}
|
||
}
|
||
} else {
|
||
while( ct-- && !Stream->IsAtEnd() && Stream->ReadWLine( pl->wtext,MAXLINESIZE, &StrSize, fExpandTabs, 8 ) ) {
|
||
//while( ct-- && !Stream->IsAtEnd() && Stream->ReadLine( &_String , TRUE )) {
|
||
|
||
//_String.QueryWSTR(0,TO_END,pl->wtext,MAXLINESIZE,TRUE);
|
||
|
||
if (fIgnore && !WSTRING::Strcmps((PWSTR)pl->wtext, (PWSTR)L"")) {
|
||
|
||
pl->wtext[0] = 0;
|
||
++*plnum;
|
||
}
|
||
|
||
if (wcslen (pl->wtext) != 0 || !fIgnore)
|
||
{
|
||
pl->line = ++*plnum;
|
||
pl++;
|
||
i++;
|
||
}
|
||
}
|
||
}
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug)
|
||
DebugPrintTrace(("xfill returns %d\n", i));
|
||
#endif
|
||
|
||
return (i);
|
||
|
||
#if 0
|
||
|
||
while (ct-- && (*funcRead) (pl->text, MAXLINESIZE, fh) != NULL)
|
||
{
|
||
if (funcRead == ( int (*) (char *,int, FILE *))fgets)
|
||
pl->text[strlen(pl->text)-1] = 0;
|
||
if (fIgnore && !MBSTR::Strcmps(pl->text, ""))
|
||
{
|
||
pl->text[0] = 0;
|
||
++*plnum;
|
||
}
|
||
if (strlen (pl->text) != 0 || !fIgnore)
|
||
{
|
||
pl->line = ++*plnum;
|
||
pl++;
|
||
i++;
|
||
}
|
||
}
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug)
|
||
DebugPrintTrace(("xfill returns %d\n", i));
|
||
#endif
|
||
|
||
return (i);
|
||
|
||
# endif
|
||
|
||
}
|
||
|
||
|
||
/**************************************************************************/
|
||
/* Adjust returns number of lines in buffer. */
|
||
/**************************************************************************/
|
||
|
||
FC::adjust (struct lineType *pl, int ml, int lt)
|
||
{
|
||
#ifdef DEBUG
|
||
if (fDebug)
|
||
DebugPrintTrace(("adjust (%04x, %d, %d) = ", pl, ml, lt));
|
||
if (fDebug)
|
||
DebugPrintTrace(("%d\n", ml-lt));
|
||
#endif
|
||
|
||
if (ml <= lt)
|
||
return (0);
|
||
|
||
#ifdef DEBUG
|
||
if (fDebug)
|
||
DebugPrintTrace(("move (%04x, %04x, %04x)\n", &pl[lt], &pl[0], sizeof (*pl)*(ml-lt)));
|
||
#endif
|
||
|
||
// Move((char *)&pl[lt], (char *)&pl[0], sizeof (*pl)*(ml-lt));
|
||
memmove( (char *)&pl[0], (char *)&pl[lt], sizeof (*pl)*(ml-lt) );
|
||
return ml-lt;
|
||
}
|
||
|
||
|
||
/**************************************************************************/
|
||
/* dump */
|
||
/* dump outputs a range of lines. */
|
||
/* */
|
||
/* INPUTS */
|
||
/* pl pointer to current lineType structure */
|
||
/* start starting line number */
|
||
/* end ending line number */
|
||
/* */
|
||
/* CALLS */
|
||
/* pline, printf */
|
||
/**************************************************************************/
|
||
|
||
void FC::dump (struct lineType *pl, int start, int end)
|
||
{
|
||
if (fAbbrev && end-start > 2)
|
||
{
|
||
pline (pl+start);
|
||
DisplayMessage( MSG_FC_ABBREVIATE_SYMBOL, NORMAL_MESSAGE );
|
||
pline (pl+end);
|
||
}
|
||
else
|
||
{
|
||
while (start <= end)
|
||
pline (pl+start++);
|
||
}
|
||
}
|
||
|
||
|
||
/**************************************************************************/
|
||
/* PrintLINE */
|
||
/* pline prints a single line of output. If the /n flag */
|
||
/* has been specified, the line number of the printed text is added. */
|
||
/* */
|
||
/* Inputs */
|
||
/* pl pointer to current lineType structure */
|
||
/* fNumb TRUE if /n specified */
|
||
/**************************************************************************/
|
||
|
||
void FC::pline (struct lineType *pl)
|
||
{
|
||
if (!fUnicode) {
|
||
if (fNumb)
|
||
DisplayMessage( MSG_FC_NUMBERED_DATA, NORMAL_MESSAGE, "%5d%s",
|
||
pl->line, pl->text );
|
||
else
|
||
DisplayMessage( MSG_FC_DATA, NORMAL_MESSAGE, "%s", pl->text );
|
||
} else {
|
||
FSTRING f;
|
||
if (fNumb)
|
||
DisplayMessage( MSG_FC_NUMBERED_DATA, NORMAL_MESSAGE, "%5d%W",
|
||
pl->line, f.Initialize(pl->wtext) );
|
||
else
|
||
DisplayMessage( MSG_FC_DATA, NORMAL_MESSAGE, "%W",
|
||
f.Initialize(pl->wtext) );
|
||
}
|
||
}
|
||
|
||
|
||
/*********************************************************************/
|
||
/* Routine: ParseFileNames */
|
||
/* */
|
||
/* Function: Parses the two given filenames and then compares the */
|
||
/* appropriate filenames. This routine handles wildcard */
|
||
/* characters in both filenames. */
|
||
/*********************************************************************/
|
||
|
||
INT
|
||
FC::ParseFileNames()
|
||
{
|
||
PATH File1;
|
||
PATH File2;
|
||
FSN_FILTER Filter;
|
||
PWSTRING Name;
|
||
PARRAY NodeArray;
|
||
PITERATOR Iterator;
|
||
PFSN_DIRECTORY Dir;
|
||
PFSNODE File;
|
||
PPATH ExpandedPath;
|
||
PATH TmpPath;
|
||
int result = SUCCESS;
|
||
char *locale;
|
||
|
||
if (!File1.Initialize( &_File1 ) ||
|
||
!File2.Initialize( &_File2 ) ||
|
||
!Filter.Initialize()) {
|
||
DisplayMessage( MSG_FC_OUT_OF_MEMORY, ERROR_MESSAGE );
|
||
return FAILURE;
|
||
}
|
||
|
||
if (!(Name = File1.QueryName())) {
|
||
DisplayMessage( MSG_FC_UNABLE_TO_OPEN, ERROR_MESSAGE, "%W", File1.GetPathString() );
|
||
return FILES_NOT_FOUND;
|
||
}
|
||
|
||
if (!Filter.SetFileName( Name ) ||
|
||
!Filter.SetAttributes( (FSN_ATTRIBUTE)0, // ALL
|
||
FSN_ATTRIBUTE_FILES, // ANY
|
||
FSN_ATTRIBUTE_DIRECTORY )) { // NONE
|
||
DELETE( Name );
|
||
DisplayMessage( MSG_FC_OUT_OF_MEMORY, ERROR_MESSAGE );
|
||
return FAILURE;
|
||
}
|
||
|
||
DELETE( Name );
|
||
|
||
if (!TmpPath.Initialize( &File1, TRUE ) ||
|
||
!TmpPath.TruncateBase()) {
|
||
DisplayMessage( MSG_FC_OUT_OF_MEMORY, ERROR_MESSAGE );
|
||
return FAILURE;
|
||
}
|
||
|
||
if ( !(Dir = SYSTEM::QueryDirectory( &TmpPath )) ||
|
||
!(NodeArray = Dir->QueryFsnodeArray( &Filter )) ||
|
||
!(Iterator = NodeArray->QueryIterator()) ||
|
||
!(File = (PFSNODE)Iterator->GetNext())
|
||
) {
|
||
DisplayMessage( MSG_FC_UNABLE_TO_OPEN, ERROR_MESSAGE, "%W", File1.GetPathString() );
|
||
return FILES_NOT_FOUND;
|
||
}
|
||
|
||
Iterator->Reset();
|
||
|
||
while ( File = (PFSNODE)Iterator->GetNext() ) {
|
||
|
||
PWSTRING Name1;
|
||
PWSTRING Name2;
|
||
|
||
if (!(Name1 = File->QueryName())) {
|
||
DisplayMessage( MSG_FC_UNABLE_TO_OPEN, ERROR_MESSAGE, "%W", File->GetPath()->GetPathString() );
|
||
return FILES_NOT_FOUND;
|
||
}
|
||
|
||
if ( _File2.HasWildCard() ) {
|
||
|
||
if ( !(ExpandedPath = _File2.QueryWCExpansion( (PPATH)File->GetPath() ))) {
|
||
|
||
if (!(Name2 = _File2.QueryName())) {
|
||
DisplayMessage( MSG_FC_UNABLE_TO_OPEN, ERROR_MESSAGE, "%W", _File2.GetPathString() );
|
||
return FILES_NOT_FOUND;
|
||
}
|
||
|
||
DisplayMessage( MSG_FC_CANT_EXPAND_TO_MATCH, ERROR_MESSAGE, "%W%W", Name1, Name2 );
|
||
DELETE( Name2 );
|
||
DELETE( Name1 );
|
||
DELETE( Iterator );
|
||
DELETE( NodeArray );
|
||
DELETE( Dir );
|
||
return FAILURE;
|
||
}
|
||
|
||
} else {
|
||
|
||
if ( !(ExpandedPath = NEW PATH) ||
|
||
!ExpandedPath->Initialize( &_File2 ) ) {
|
||
|
||
DisplayMessage( MSG_FC_OUT_OF_MEMORY, ERROR_MESSAGE );
|
||
DELETE( Name1 );
|
||
DELETE( Iterator );
|
||
DELETE( NodeArray );
|
||
DELETE( Dir );
|
||
return FAILURE;
|
||
|
||
}
|
||
}
|
||
|
||
if (!(Name2 = ExpandedPath->QueryName())) {
|
||
DisplayMessage( MSG_FC_UNABLE_TO_OPEN, ERROR_MESSAGE, "%W", ExpandedPath->GetPathString() );
|
||
return FILES_NOT_FOUND;
|
||
}
|
||
|
||
if (!File1.SetName( Name1 ) ||
|
||
!File2.SetName( Name2 )) {
|
||
DisplayMessage( MSG_FC_OUT_OF_MEMORY, ERROR_MESSAGE );
|
||
return FAILURE;
|
||
}
|
||
|
||
switch (comp( File1.GetPathString(), File2.GetPathString() )) {
|
||
case FAILURE:
|
||
return FAILURE;
|
||
|
||
case SUCCESS:
|
||
break;
|
||
|
||
case FILES_ARE_DIFFERENT:
|
||
result |= FILES_ARE_DIFFERENT;
|
||
break;
|
||
|
||
case FILES_NOT_FOUND:
|
||
result |= FILES_NOT_FOUND;
|
||
break;
|
||
|
||
case FILES_OFFLINE:
|
||
result |= FILES_OFFLINE;
|
||
break;
|
||
|
||
default:
|
||
DebugAssert(FALSE);
|
||
}
|
||
|
||
DELETE( Name2 );
|
||
DELETE( Name1 );
|
||
DELETE( ExpandedPath );
|
||
|
||
}
|
||
|
||
// Print a warning in case that offline files were skipped
|
||
if (fOfflineSkipped) {
|
||
DisplayMessage(MSG_FC_OFFLINE_FILES_SKIPPED, ERROR_MESSAGE);
|
||
}
|
||
|
||
DELETE( Iterator );
|
||
NodeArray->DeleteAllMembers();
|
||
DELETE( NodeArray );
|
||
DELETE( Dir );
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
|
||
|
||
/*********************************************************************/
|
||
/* Routine: comp */
|
||
/* */
|
||
/* Function: Compares the two files. */
|
||
/*********************************************************************/
|
||
|
||
INT
|
||
FC::comp(PCWSTRING file1, PCWSTRING file2)
|
||
{
|
||
DisplayMessage( MSG_FC_COMPARING_FILES, NORMAL_MESSAGE, "%W%W", file1, file2 );
|
||
if (fBinary) {
|
||
return BinaryCompare (file1, file2);
|
||
} else {
|
||
return LineCompare (file1, file2);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
#if 0
|
||
/* returns line from file (no CRLFs); returns NULL if EOF */
|
||
FC::fgetl ( char *buf, int len, FILE *fh)
|
||
{
|
||
register int c;
|
||
register char *p;
|
||
|
||
/* remember NUL at end */
|
||
len--;
|
||
p = buf;
|
||
while (len) {
|
||
c = getc (fh);
|
||
if (c == EOF || c == '\n')
|
||
break;
|
||
#if MSDOS
|
||
if (c != '\r')
|
||
#endif
|
||
if (c != '\t') {
|
||
*p++ = (char)c;
|
||
len--;
|
||
}
|
||
else {
|
||
c = min (8 - ((int)(p-buf) & 0x0007), len);
|
||
memset(p, ' ', c);
|
||
p += c;
|
||
len -= c;
|
||
}
|
||
}
|
||
*p = 0;
|
||
return ! ( (c == EOF) && (p == buf) );
|
||
}
|
||
#endif
|