fc.c File Reference

#include "fc.h"
#include "conutils_noros.h"
#include <strsafe.h>
#include <shlwapi.h>

Include dependency graph for fc.c:

Go to the source code of this file.

Macros
#define	IS_DOTS(pch)    ((*(pch) == L'.') && (((pch)[1] == 0) || (((pch)[1] == L'.') && ((pch)[2] == 0))))
#define	HasWildcard(filename)    ((wcschr((filename), L'*') != NULL) || (wcschr((filename), L'?') != NULL))

Functions
FCRET	NoDifference (VOID)
FCRET	Different (LPCWSTR file0, LPCWSTR file1)
FCRET	LongerThan (LPCWSTR file0, LPCWSTR file1)
FCRET	OutOfMemory (VOID)
FCRET	CannotRead (LPCWSTR file)
FCRET	InvalidSwitch (VOID)
FCRET	ResyncFailed (VOID)
VOID	PrintCaption (LPCWSTR file)
VOID	PrintEndOfDiff (VOID)
VOID	PrintDots (VOID)
VOID	PrintLineW (const FILECOMPARE *pFC, DWORD lineno, LPCWSTR psz)
VOID	PrintLineA (const FILECOMPARE *pFC, DWORD lineno, LPCSTR psz)
HANDLE	DoOpenFileForInput (LPCWSTR file)
static FCRET	BinaryFileCompare (FILECOMPARE *pFC)
static FCRET	TextFileCompare (FILECOMPARE *pFC)
static BOOL	IsBinaryExt (LPCWSTR filename)
static FCRET	FileCompare (FILECOMPARE *pFC)
static BOOL	IsTitleWild (LPCWSTR filename)
static FCRET	FileCompareOneSideWild (const FILECOMPARE *pFC, BOOL bWildRight)
static FCRET	FileCompareWildTitle (const FILECOMPARE *pFC)
static FCRET	FileCompareBothWild (const FILECOMPARE *pFC)
static FCRET	WildcardFileCompare (FILECOMPARE *pFC)
int	wmain (int argc, WCHAR **argv)
main
Program entry point Parameters ArgCount Arguments Returns EXIT_SUCCESS on success, EXIT_FAILURE on failure
int	main (int argc, char **argv)

Macro Definition Documentation

HasWildcard

#define HasWildcard

(

filename

)

((wcschr((filename), L'*') != NULL) || (wcschr((filename), L'?') != NULL))

Definition at line 334 of file fc.c.

IS_DOTS

#define IS_DOTS

(

pch

)

((*(pch) == L'.') && (((pch)[1] == 0) || (((pch)[1] == L'.') && ((pch)[2] == 0))))

Definition at line 332 of file fc.c.

Function Documentation

BinaryFileCompare()

static FCRET BinaryFileCompare ( FILECOMPARE *  pFC )

static

Definition at line 100 of file fc.c.

{
    FCRET ret;
    HANDLE hFile0, hFile1, hMapping0 = NULL, hMapping1 = NULL;
    LPBYTE pb0 = NULL, pb1 = NULL;
    LARGE_INTEGER ib, cb0, cb1, cbCommon;
    DWORD cbView, ibView;
    BOOL fDifferent = FALSE;
 
    hFile0 = DoOpenFileForInput(pFC->file[0]);
    if (hFile0 == INVALID_HANDLE_VALUE)
        return FCRET_CANT_FIND;
    hFile1 = DoOpenFileForInput(pFC->file[1]);
    if (hFile1 == INVALID_HANDLE_VALUE)
    {
        CloseHandle(hFile0);
        return FCRET_CANT_FIND;
    }
 
    do
    {
        if (_wcsicmp(pFC->file[0], pFC->file[1]) == 0)
        {
            ret = NoDifference();
            break;
        }
        if (!GetFileSizeEx(hFile0, &cb0))
        {
            ret = CannotRead(pFC->file[0]);
            break;
        }
        if (!GetFileSizeEx(hFile1, &cb1))
        {
            ret = CannotRead(pFC->file[1]);
            break;
        }
        cbCommon.QuadPart = min(cb0.QuadPart, cb1.QuadPart);
        if (cbCommon.QuadPart > 0)
        {
            hMapping0 = CreateFileMappingW(hFile0, NULL, PAGE_READONLY,
                                           cb0.HighPart, cb0.LowPart, NULL);
            if (hMapping0 == NULL)
            {
                ret = CannotRead(pFC->file[0]);
                break;
            }
            hMapping1 = CreateFileMappingW(hFile1, NULL, PAGE_READONLY,
                                           cb1.HighPart, cb1.LowPart, NULL);
            if (hMapping1 == NULL)
            {
                ret = CannotRead(pFC->file[1]);
                break;
            }
 
            ret = FCRET_IDENTICAL;
            for (ib.QuadPart = 0; ib.QuadPart < cbCommon.QuadPart; )
            {
                cbView = (DWORD)min(cbCommon.QuadPart - ib.QuadPart, MAX_VIEW_SIZE);
                pb0 = MapViewOfFile(hMapping0, FILE_MAP_READ, ib.HighPart, ib.LowPart, cbView);
                pb1 = MapViewOfFile(hMapping1, FILE_MAP_READ, ib.HighPart, ib.LowPart, cbView);
                if (!pb0 || !pb1)
                {
                    ret = OutOfMemory();
                    break;
                }
                for (ibView = 0; ibView < cbView; ++ib.QuadPart, ++ibView)
                {
                    if (pb0[ibView] == pb1[ibView])
                        continue;
 
                    fDifferent = TRUE;
                    if (cbCommon.QuadPart > MAXDWORD)
                    {
                        ConPrintf(StdOut, L"%016I64X: %02X %02X\n", ib.QuadPart,
                                  pb0[ibView], pb1[ibView]);
                    }
                    else
                    {
                        ConPrintf(StdOut, L"%08lX: %02X %02X\n", ib.LowPart,
                                  pb0[ibView], pb1[ibView]);
                    }
                }
                UnmapViewOfFile(pb0);
                UnmapViewOfFile(pb1);
                pb0 = pb1 = NULL;
            }
            if (ret != FCRET_IDENTICAL)
                break;
        }
 
        if (cb0.QuadPart < cb1.QuadPart)
            ret = LongerThan(pFC->file[1], pFC->file[0]);
        else if (cb0.QuadPart > cb1.QuadPart)
            ret = LongerThan(pFC->file[0], pFC->file[1]);
        else if (fDifferent)
            ret = Different(pFC->file[0], pFC->file[1]);
        else
            ret = NoDifference();
    } while (0);
 
    UnmapViewOfFile(pb0);
    UnmapViewOfFile(pb1);
    CloseHandle(hMapping0);
    CloseHandle(hMapping1);
    CloseHandle(hFile0);
    CloseHandle(hFile1);
    return ret;
}

Referenced by FileCompare().

CannotRead()

FCRET CannotRead

(

LPCWSTR

file

)

Definition at line 42 of file fc.c.

{
    ConResPrintf(StdErr, IDS_CANNOT_READ, file);
    return FCRET_INVALID;
}

Referenced by BinaryFileCompare(), and TextFileCompare().

Different()

FCRET Different	(	LPCWSTR	file0,
		LPCWSTR	file1
	)

Definition at line 24 of file fc.c.

{
    ConResPrintf(StdOut, IDS_DIFFERENT, file0, file1);
    return FCRET_DIFFERENT;
}

Referenced by BinaryFileCompare(), and Finalize().

DoOpenFileForInput()

HANDLE DoOpenFileForInput

(

LPCWSTR

file

)

Definition at line 90 of file fc.c.

{
    HANDLE hFile = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        ConResPrintf(StdErr, IDS_CANNOT_OPEN, file);
    }
    return hFile;
}

Referenced by BinaryFileCompare(), and TextFileCompare().

FileCompare()

static FCRET FileCompare ( FILECOMPARE *  pFC )

static

Definition at line 312 of file fc.c.

{
    FCRET ret;
    ConResPrintf(StdOut, IDS_COMPARING, pFC->file[0], pFC->file[1]);
 
    if (!(pFC->dwFlags & FLAG_L) &&
        ((pFC->dwFlags & FLAG_B) || IsBinaryExt(pFC->file[0]) || IsBinaryExt(pFC->file[1])))
    {
        ret = BinaryFileCompare(pFC);
    }
    else
    {
        ret = TextFileCompare(pFC);
    }
 
    ConPuts(StdOut, L"\n");
    return ret;
}

Referenced by FileCompareBothWild(), FileCompareOneSideWild(), FileCompareWildTitle(), and WildcardFileCompare().

FileCompareBothWild()

static FCRET FileCompareBothWild ( const FILECOMPARE *  pFC )

static

Definition at line 446 of file fc.c.

{
    FCRET ret = FCRET_IDENTICAL;
    WIN32_FIND_DATAW find0, find1;
    HANDLE hFind0, hFind1;
    WCHAR szPath0[MAX_PATH], szPath1[MAX_PATH];
    FILECOMPARE fc;
 
    hFind0 = FindFirstFileW(pFC->file[0], &find0);
    if (hFind0 == INVALID_HANDLE_VALUE)
    {
        ConResPrintf(StdErr, IDS_CANNOT_OPEN, pFC->file[0]);
        ConPuts(StdOut, L"\n");
        return FCRET_CANT_FIND;
    }
    hFind1 = FindFirstFileW(pFC->file[1], &find1);
    if (hFind1 == INVALID_HANDLE_VALUE)
    {
        CloseHandle(hFind0);
        ConResPrintf(StdErr, IDS_CANNOT_OPEN, pFC->file[1]);
        ConPuts(StdOut, L"\n");
        return FCRET_CANT_FIND;
    }
    StringCbCopyW(szPath0, sizeof(szPath0), pFC->file[0]);
    StringCbCopyW(szPath1, sizeof(szPath1), pFC->file[1]);
 
    fc = *pFC;
    fc.file[0] = szPath0;
    fc.file[1] = szPath1;
    do
    {
        while (IS_DOTS(find0.cFileName))
        {
            if (!FindNextFileW(hFind0, &find0))
                goto quit;
        }
        while (IS_DOTS(find1.cFileName))
        {
            if (!FindNextFileW(hFind1, &find1))
                goto quit;
        }
 
        // replace file title
        PathRemoveFileSpecW(szPath0);
        PathRemoveFileSpecW(szPath1);
        PathAppendW(szPath0, find0.cFileName);
        PathAppendW(szPath1, find1.cFileName);
 
        switch (FileCompare(&fc))
        {
            case FCRET_IDENTICAL:
                break;
            case FCRET_DIFFERENT:
                if (ret != FCRET_INVALID)
                    ret = FCRET_DIFFERENT;
                break;
            default:
                ret = FCRET_INVALID;
                break;
        }
    } while (FindNextFileW(hFind0, &find0) && FindNextFileW(hFind1, &find1));
quit:
    CloseHandle(hFind0);
    CloseHandle(hFind1);
    return ret;
}

Referenced by WildcardFileCompare().

FileCompareOneSideWild()

static FCRET FileCompareOneSideWild ( const FILECOMPARE *  pFC, BOOL  bWildRight  )

static

Definition at line 343 of file fc.c.

{
    FCRET ret = FCRET_IDENTICAL;
    WIN32_FIND_DATAW find;
    HANDLE hFind;
    WCHAR szPath[MAX_PATH];
    FILECOMPARE fc;
 
    hFind = FindFirstFileW(pFC->file[bWildRight], &find);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        ConResPrintf(StdErr, IDS_CANNOT_OPEN, pFC->file[bWildRight]);
        ConPuts(StdOut, L"\n");
        return FCRET_CANT_FIND;
    }
    StringCbCopyW(szPath, sizeof(szPath), pFC->file[bWildRight]);
 
    fc = *pFC;
    fc.file[!bWildRight] = pFC->file[!bWildRight];
    fc.file[bWildRight] = szPath;
    do
    {
        if (IS_DOTS(find.cFileName))
            continue;
 
        // replace file title
        PathRemoveFileSpecW(szPath);
        PathAppendW(szPath, find.cFileName);
 
        switch (FileCompare(&fc))
        {
            case FCRET_IDENTICAL:
                break;
            case FCRET_DIFFERENT:
                if (ret != FCRET_INVALID)
                    ret = FCRET_DIFFERENT;
                break;
            default:
                ret = FCRET_INVALID;
                break;
        }
    } while (FindNextFileW(hFind, &find));
 
    FindClose(hFind);
    return ret;
}

Referenced by WildcardFileCompare().

FileCompareWildTitle()

static FCRET FileCompareWildTitle ( const FILECOMPARE *  pFC )

static

Definition at line 390 of file fc.c.

{
    FCRET ret = FCRET_IDENTICAL;
    WIN32_FIND_DATAW find;
    HANDLE hFind;
    WCHAR szPath0[MAX_PATH], szPath1[MAX_PATH];
    FILECOMPARE fc;
    LPWSTR pch;
 
    hFind = FindFirstFileW(pFC->file[0], &find);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        ConResPrintf(StdErr, IDS_CANNOT_OPEN, pFC->file[0]);
        ConPuts(StdOut, L"\n");
        return FCRET_CANT_FIND;
    }
    StringCbCopyW(szPath0, sizeof(szPath0), pFC->file[0]);
    StringCbCopyW(szPath1, sizeof(szPath1), pFC->file[1]);
    pch = PathFindExtensionW(pFC->file[1]);
 
    fc = *pFC;
    fc.file[0] = szPath0;
    fc.file[1] = szPath1;
    do
    {
        if (IS_DOTS(find.cFileName))
            continue;
 
        // replace file title
        PathRemoveFileSpecW(szPath0);
        PathRemoveFileSpecW(szPath1);
        PathAppendW(szPath0, find.cFileName);
        PathAppendW(szPath1, find.cFileName);
 
        // replace dot extension
        PathRemoveExtensionW(szPath1);
        PathAddExtensionW(szPath1, pch);
 
        switch (FileCompare(&fc))
        {
            case FCRET_IDENTICAL:
                break;
            case FCRET_DIFFERENT:
                if (ret != FCRET_INVALID)
                    ret = FCRET_DIFFERENT;
                break;
            default:
                ret = FCRET_INVALID;
                break;
        }
    } while (FindNextFileW(hFind, &find));
 
    FindClose(hFind);
    return ret;
}

Referenced by WildcardFileCompare().

InvalidSwitch()

FCRET InvalidSwitch

(

VOID

)

Definition at line 48 of file fc.c.

{
    ConResPuts(StdErr, IDS_INVALID_SWITCH);
    return FCRET_INVALID;
}

Referenced by wmain().

IsBinaryExt()

static BOOL IsBinaryExt ( LPCWSTR  filename )

static

Definition at line 281 of file fc.c.

{
    // Don't change this array. This is by design.
    // See also: https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/fc
    static const LPCWSTR s_exts[] = { L"EXE", L"COM", L"SYS", L"OBJ", L"LIB", L"BIN" };
    size_t iext;
    LPCWSTR pch, ext, pch0 = wcsrchr(filename, L'\\'), pch1 = wcsrchr(filename, L'/');
    if (!pch0 && !pch1)
        pch = filename;
    else if (!pch0 && pch1)
        pch = pch1;
    else if (pch0 && !pch1)
        pch = pch0;
    else if (pch0 < pch1)
        pch = pch1;
    else
        pch = pch0;
 
    ext = wcsrchr(pch, L'.');
    if (ext)
    {
        ++ext;
        for (iext = 0; iext < _countof(s_exts); ++iext)
        {
            if (_wcsicmp(ext, s_exts[iext]) == 0)
                return TRUE;
        }
    }
    return FALSE;
}

Referenced by FileCompare().

IsTitleWild()

static BOOL IsTitleWild ( LPCWSTR  filename )

inlinestatic

Definition at line 337 of file fc.c.

{
    LPCWSTR pch = PathFindFileNameW(filename);
    return (pch && *pch == L'*' && pch[1] == L'.' && !HasWildcard(&pch[2]));
}

Referenced by WildcardFileCompare().

LongerThan()

FCRET LongerThan	(	LPCWSTR	file0,
		LPCWSTR	file1
	)

Definition at line 30 of file fc.c.

{
    ConResPrintf(StdOut, IDS_LONGER_THAN, file0, file1);
    return FCRET_DIFFERENT;
}

Referenced by BinaryFileCompare().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 637 of file fc.c.

{
    INT my_argc;
    LPWSTR *my_argv = CommandLineToArgvW(GetCommandLineW(), &my_argc);
    INT ret = wmain(my_argc, my_argv);
    LocalFree(my_argv);
    return ret;
}

NoDifference()

FCRET NoDifference

(

VOID

)

Definition at line 18 of file fc.c.

{
    ConResPuts(StdOut, IDS_NO_DIFFERENCE);
    return FCRET_IDENTICAL;
}

Referenced by BinaryFileCompare(), Finalize(), and TextFileCompare().

OutOfMemory()

FCRET OutOfMemory

(

VOID

)

Definition at line 36 of file fc.c.

{
    ConResPuts(StdErr, IDS_OUT_OF_MEMORY);
    return FCRET_INVALID;
}

PrintCaption()

VOID PrintCaption

(

LPCWSTR

file

)

Definition at line 60 of file fc.c.

{
    ConPrintf(StdOut, L"***** %ls\n", file);
}

Referenced by ShowDiff().

PrintDots()

VOID PrintDots

(

VOID

)

Definition at line 70 of file fc.c.

{
    ConPuts(StdOut, L"...\n");
}

Referenced by ShowDiff().

PrintEndOfDiff()

VOID PrintEndOfDiff

(

VOID

)

Definition at line 65 of file fc.c.

{
    ConPuts(StdOut, L"*****\n\n");
}

Referenced by Finalize(), and TextCompare().

PrintLineA()

VOID PrintLineA	(	const FILECOMPARE *	pFC,
		DWORD	lineno,
		LPCSTR	psz
	)

Definition at line 82 of file fc.c.

{
    if (pFC->dwFlags & FLAG_N)
        ConPrintf(StdOut, L"%5d:  %hs\n", lineno, psz);
    else
        ConPrintf(StdOut, L"%hs\n", psz);
}

PrintLineW()

VOID PrintLineW	(	const FILECOMPARE *	pFC,
		DWORD	lineno,
		LPCWSTR	psz
	)

Definition at line 75 of file fc.c.

{
    if (pFC->dwFlags & FLAG_N)
        ConPrintf(StdOut, L"%5d:  %ls\n", lineno, psz);
    else
        ConPrintf(StdOut, L"%ls\n", psz);
}

ResyncFailed()

FCRET ResyncFailed

(

VOID

)

Definition at line 54 of file fc.c.

{
    ConResPuts(StdOut, IDS_RESYNC_FAILED);
    return FCRET_DIFFERENT;
}

Referenced by TextCompare().

TextFileCompare()

static FCRET TextFileCompare ( FILECOMPARE *  pFC )

static

Definition at line 209 of file fc.c.

{
    FCRET ret;
    HANDLE hFile0, hFile1, hMapping0 = NULL, hMapping1 = NULL;
    LARGE_INTEGER cb0, cb1;
    BOOL fUnicode = !!(pFC->dwFlags & FLAG_U);
 
    hFile0 = DoOpenFileForInput(pFC->file[0]);
    if (hFile0 == INVALID_HANDLE_VALUE)
        return FCRET_CANT_FIND;
    hFile1 = DoOpenFileForInput(pFC->file[1]);
    if (hFile1 == INVALID_HANDLE_VALUE)
    {
        CloseHandle(hFile0);
        return FCRET_CANT_FIND;
    }
 
    do
    {
        if (_wcsicmp(pFC->file[0], pFC->file[1]) == 0)
        {
            ret = NoDifference();
            break;
        }
        if (!GetFileSizeEx(hFile0, &cb0))
        {
            ret = CannotRead(pFC->file[0]);
            break;
        }
        if (!GetFileSizeEx(hFile1, &cb1))
        {
            ret = CannotRead(pFC->file[1]);
            break;
        }
        if (cb0.QuadPart == 0 && cb1.QuadPart == 0)
        {
            ret = NoDifference();
            break;
        }
        if (cb0.QuadPart > 0)
        {
            hMapping0 = CreateFileMappingW(hFile0, NULL, PAGE_READONLY,
                                           cb0.HighPart, cb0.LowPart, NULL);
            if (hMapping0 == NULL)
            {
                ret = CannotRead(pFC->file[0]);
                break;
            }
        }
        if (cb1.QuadPart > 0)
        {
            hMapping1 = CreateFileMappingW(hFile1, NULL, PAGE_READONLY,
                                           cb1.HighPart, cb1.LowPart, NULL);
            if (hMapping1 == NULL)
            {
                ret = CannotRead(pFC->file[1]);
                break;
            }
        }
        if (fUnicode)
            ret = TextCompareW(pFC, &hMapping0, &cb0, &hMapping1, &cb1);
        else
            ret = TextCompareA(pFC, &hMapping0, &cb0, &hMapping1, &cb1);
    } while (0);
 
    CloseHandle(hMapping0);
    CloseHandle(hMapping1);
    CloseHandle(hFile0);
    CloseHandle(hFile1);
    return ret;
}

Referenced by FileCompare().

WildcardFileCompare()

static FCRET WildcardFileCompare ( FILECOMPARE *  pFC )

static

Definition at line 513 of file fc.c.

{
    BOOL fWild0, fWild1;
 
    if (pFC->dwFlags & FLAG_HELP)
    {
        ConResPuts(StdOut, IDS_USAGE);
        return FCRET_INVALID;
    }
 
    if (!pFC->file[0] || !pFC->file[1])
    {
        ConResPuts(StdErr, IDS_NEEDS_FILES);
        return FCRET_INVALID;
    }
 
    fWild0 = HasWildcard(pFC->file[0]);
    fWild1 = HasWildcard(pFC->file[1]);
    if (fWild0 && fWild1)
    {
        if (IsTitleWild(pFC->file[0]) && IsTitleWild(pFC->file[1]))
            return FileCompareWildTitle(pFC);
        else
            return FileCompareBothWild(pFC);
    }
    else if (fWild0)
    {
        return FileCompareOneSideWild(pFC, FALSE);
    }
    else if (fWild1)
    {
        return FileCompareOneSideWild(pFC, TRUE);
    }
    return FileCompare(pFC);
}

Referenced by wmain().

wmain()

int wmain	(	int	argc,
		WCHAR **	argv
	)

Definition at line 549 of file fc.c.

{
    FILECOMPARE fc = { .dwFlags = 0, .n = 100, .nnnn = 2 };
    PWCHAR endptr;
    INT i;
 
    /* Initialize the Console Standard Streams */
    ConInitStdStreams();
 
    for (i = 1; i < argc; ++i)
    {
        if (argv[i][0] != L'/')
        {
            if (!fc.file[0])
                fc.file[0] = argv[i];
            else if (!fc.file[1])
                fc.file[1] = argv[i];
            else
                return InvalidSwitch();
            continue;
        }
        switch (towupper(argv[i][1]))
        {
            case L'A':
                fc.dwFlags |= FLAG_A;
                break;
            case L'B':
                fc.dwFlags |= FLAG_B;
                break;
            case L'C':
                fc.dwFlags |= FLAG_C;
                break;
            case L'L':
                if (_wcsicmp(argv[i], L"/L") == 0)
                {
                    fc.dwFlags |= FLAG_L;
                }
                else if (towupper(argv[i][2]) == L'B')
                {
                    if (iswdigit(argv[i][3]))
                    {
                        fc.dwFlags |= FLAG_LBn;
                        fc.n = wcstoul(&argv[i][3], &endptr, 10);
                        if (endptr == NULL || *endptr != 0)
                            return InvalidSwitch();
                    }
                    else
                    {
                        return InvalidSwitch();
                    }
                }
                break;
            case L'N':
                fc.dwFlags |= FLAG_N;
                break;
            case L'O':
                if (_wcsicmp(argv[i], L"/OFF") == 0 || _wcsicmp(argv[i], L"/OFFLINE") == 0)
                {
                    fc.dwFlags |= FLAG_OFFLINE;
                }
                break;
            case L'T':
                fc.dwFlags |= FLAG_T;
                break;
            case L'U':
                fc.dwFlags |= FLAG_U;
                break;
            case L'W':
                fc.dwFlags |= FLAG_W;
                break;
            case L'0': case L'1': case L'2': case L'3': case L'4':
            case L'5': case L'6': case L'7': case L'8': case L'9':
                fc.nnnn = wcstoul(&argv[i][1], &endptr, 10);
                if (endptr == NULL || *endptr != 0)
                    return InvalidSwitch();
                fc.dwFlags |= FLAG_nnnn;
                break;
            case L'?':
                fc.dwFlags |= FLAG_HELP;
                break;
            default:
                return InvalidSwitch();
        }
    }
    return WildcardFileCompare(&fc);
}