#include "precomp.h"
#pragma hdrstop
/* File: search.c */
/**************************************************************************/
/*  file search functions
/**************************************************************************/


extern PSTR LOCAL_SOURCE_DIRECTORY;

//*******************************************************************
//
//                          Exe Info
//
//*******************************************************************


typedef enum _EXETYPE {
    EXE_WIN16,
    EXE_WIN32,
    EXE_DOS,
    EXE_DUNNO
} EXETYPE;

#define EXE_WIN16_SZ    "WIN16"
#define EXE_WIN32_SZ    "WIN32"
#define EXE_DOS_SZ      "DOS"
#define EXE_DUNNO_SZ    NULL

typedef struct _EXEINFO *PEXEINFO;
typedef struct _EXEINFO {
    EXETYPE     ExeType;
    SZ          szExeType;
    SZ          szDescr;
} EXEINFO;

PEXEINFO
ExeInfoAlloc(
    SZ  szPath,
    SZ  szFile
    );

BOOL
FExeInfoInit(
    PEXEINFO    pExeInfo,
    SZ          szPath,
    SZ          szFile
    );

BOOL
FIsExeOrCom(
    SZ          szFile
    );

BOOL
FIsCom(
    SZ          szFile
    );

BOOL
FIsWin16(
    HANDLE              Handle,
    PIMAGE_DOS_HEADER   pDosHeader,
    PIMAGE_OS2_HEADER   pOs2Header
    );

BOOL
FFapi(
    HANDLE              Handle,
    PIMAGE_OS2_HEADER   pOs2Header,
    DWORD               dwOffset
    );

SZ
GetBaseName(
    SZ  szFile
    );

SZ
ReadWin16Descr(
    SZ                  szFile,
    HANDLE              Handle,
    PIMAGE_DOS_HEADER   pDosHeader,
    PIMAGE_OS2_HEADER   pOs2Header
    );

SZ
ReadWin32Descr(
    SZ                  szFile,
    HANDLE              Handle,
    PIMAGE_DOS_HEADER   pDosHeader,
    PIMAGE_NT_HEADERS   pNtHeader
    );

SZ
ReadDescr(
    HANDLE      Handle,
    DWORD       Offset,
    DWORD       Size
    );


VOID
ExeInfoFree(
    PEXEINFO    pInfo
    );


#define ExeInfoGetType(p)   ((p)->ExeType)
#define ExeInfoGetTypeSz(p) ((p)->szExeType)
#define ExeInfoGetDescr(p)  ((p)->szDescr)


//
//  Allocates an ExeInfo
//
PEXEINFO
ExeInfoAlloc(
    SZ  szPath,
    SZ  szFile
    )
{
    PEXEINFO    pExeInfo;

    if (pExeInfo = (PEXEINFO)SAlloc( sizeof(EXEINFO) )) {


        if ( !FExeInfoInit( pExeInfo, szPath, szFile ) ) {
            ExeInfoFree( pExeInfo );
            pExeInfo = NULL;
        }
    }

    return pExeInfo;
}

//
//  Initialize an ExeInfo
//
BOOL
FExeInfoInit(
    PEXEINFO    pExeInfo,
    SZ          szPath,
    SZ          szFile
    )

{

    HANDLE              Handle;
    BOOL                fOkay = fFalse;
    IMAGE_DOS_HEADER    DosHeader;
    IMAGE_OS2_HEADER    Os2Header;
    IMAGE_NT_HEADERS    NtHeader;
    DWORD               BytesRead;


    if ( !FIsExeOrCom(szFile) ) {
        pExeInfo->ExeType   = EXE_DOS;
        pExeInfo->szExeType = EXE_DOS_SZ;
        pExeInfo->szDescr   = GetBaseName( szFile );
        return fTrue;
    }


    //
    //  Initialize the pExeInfo so that it can be Freed up if something
    //  wrong happens.
    //
    pExeInfo->szDescr = NULL;


    //
    //  Open file
    //
    Handle = CreateFile( szPath,
                         GENERIC_READ,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         0,
                         NULL );

    if ( Handle != INVALID_HANDLE_VALUE ) {

        //
        //  Read DOS header
        //
        if ( ReadFile( Handle, &DosHeader, sizeof(IMAGE_DOS_HEADER), &BytesRead, NULL ) &&
             (BytesRead == sizeof(IMAGE_DOS_HEADER)) &&
             (DosHeader.e_magic == IMAGE_DOS_SIGNATURE) ) {


            //
            // Read OS/2 header
            //
            if ( (SetFilePointer( Handle, DosHeader.e_lfanew, 0, FILE_BEGIN ) != -1)        &&
                 ReadFile( Handle, &Os2Header, sizeof(IMAGE_OS2_HEADER), &BytesRead, NULL ) &&
                 (BytesRead == sizeof(IMAGE_OS2_HEADER))                                    &&
                 FIsWin16( Handle, &DosHeader, &Os2Header )
               ) {

                //
                //  WIN16 EXE
                //
                pExeInfo->ExeType   = EXE_WIN16;
                pExeInfo->szExeType = EXE_WIN16_SZ;
                pExeInfo->szDescr   = ReadWin16Descr( szFile, Handle, &DosHeader, &Os2Header );
                fOkay = fTrue;


            } else if ( (SetFilePointer( Handle, DosHeader.e_lfanew, 0, FILE_BEGIN ) != -1)   &&
                         ReadFile( Handle, &NtHeader, sizeof(IMAGE_NT_HEADERS), &BytesRead, NULL ) &&
                         (BytesRead == sizeof(IMAGE_NT_HEADERS)) &&
                         (NtHeader.Signature == IMAGE_NT_SIGNATURE) ) {

                //
                //  Make sure that it is a WIN32 subsystem exe
                //

                if ( (NtHeader.FileHeader.SizeOfOptionalHeader >= IMAGE_SIZEOF_NT_OPTIONAL_HEADER) &&
                     ((NtHeader.OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) ||
                      (NtHeader.OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_CUI)) ) {


                    //
                    //  WIN32
                    //
                    pExeInfo->ExeType   = EXE_WIN32;
                    pExeInfo->szExeType = EXE_WIN32_SZ;
//                    pExeInfo->szDescr   = ReadWin32Descr( szFile, Handle, &DosHeader, &NtHeader );
                    pExeInfo->szDescr   = GetBaseName( szFile );
                    fOkay = fTrue;
                }

            } else {

                //
                //  Assume DOS
                //
                pExeInfo->ExeType   = EXE_DOS;
                pExeInfo->szExeType = EXE_DOS_SZ;
                pExeInfo->szDescr   = GetBaseName( szFile );
                fOkay = fTrue;
            }
        } else {
            //
            // Might be a DOS .com file, which wouldn't have an exe header on it.
            //
            if ( FIsCom(szFile) ) {
                pExeInfo->ExeType   = EXE_DOS;
                pExeInfo->szExeType = EXE_DOS_SZ;
                pExeInfo->szDescr   = GetBaseName( szFile );
                fOkay = fTrue;
            }
        }


        CloseHandle( Handle );

        if ( !fOkay ) {

            pExeInfo->ExeType   = EXE_DUNNO;
            pExeInfo->szExeType = EXE_DUNNO_SZ;
            pExeInfo->szDescr   = NULL;
            fOkay = fTrue;
        }
    }


    return fOkay;
}

//
//  Determines if the file is a Win16 app
//
BOOL
FIsWin16(
    HANDLE              Handle,
    PIMAGE_DOS_HEADER   pDosHeader,
    PIMAGE_OS2_HEADER   pOs2Header
    )
{

#define NE_TYPE(ne) (((BYTE *)(ne))[0x36])

    BOOL    fW16 = fFalse;

    if ( pOs2Header->ne_magic == IMAGE_OS2_SIGNATURE ) {

        switch ( NE_TYPE( pOs2Header ) ) {

        case 0:             // Unknown EXE type, may be a windows exe

              //
              // Assume this file is a Windows App iff:
              //     it has a "expected windows version" value or
              //     it test's FALSE as a FAPI app
              //
              if (pOs2Header->ne_expver != 0) {

                 fW16 = fTrue;

              } else {

                 fW16 = !FFapi( Handle, pOs2Header, pDosHeader->e_lfanew );
              }
              break;

        case 2:             // Windows EXE type
              fW16 = fTrue;
              break;

        default:            // Definitly NOT a windows EXE (DOS4 or OS/2)
              break;
        }
    }

    return fW16;
}

//
//  Determine if the app is FAPI
//
BOOL
FFapi(
    HANDLE              Handle,
    PIMAGE_OS2_HEADER   pOs2Header,
    DWORD               dwOffset
    )
{

#define szDOSCALLS  "DOSCALLS"
#define lenDOSCALLS 8

    char    buf[256];
    char   *pch;
    WORD   UNALIGNED *pw;
    int     n;
    int     i;
    BOOL    f = FALSE;
    DWORD   BytesRead;

    /*
     *	look through the imported module table for the name "DOSCALLS" if
     *	found the EXE is a FAPI app.
     *
     *  NOTE! assumes module table will fit in a 256 byte buffer
     */

    // make sure this doesn't point off the end of the buffer we will use

    if (pOs2Header->ne_modtab > sizeof(buf)) {
        return fFalse;
    }

    SetFilePointer( Handle, dwOffset, 0, FILE_BEGIN );
    ReadFile( Handle, buf, sizeof(buf), &BytesRead, NULL );

    pw = (WORD UNALIGNED *)(buf + pOs2Header->ne_modtab);

    for (i = 0; (unsigned)i < pOs2Header->ne_cmod; i++)
    {
        pch = buf + pOs2Header->ne_imptab + *pw++;

	if (pch > (buf + sizeof(buf)))	// be sure we don't go off the end
	    break;

        n = (int)*pch++;

	if (n == 0)
	    break;

    if ( (n == lenDOSCALLS) && !_strnicmp(szDOSCALLS,pch,lenDOSCALLS) )
	{
	    f = TRUE;
	    break;
	}
    }

    return f;
}


//
//  Obtains the base portion of a file name (i.e. no extension)
//
SZ
GetBaseName(
    SZ  szFile
    )
{
    SZ  szEnd;
    SZ  szLast;
    SZ  sz;
    CB  cbSize;

    szEnd = szLast = szFile + strlen( szFile ) - 1;

    //
    //  Look for last '.'
    //
    while ( (szEnd >= szFile) && (*szEnd != '.')) {
        szEnd--;
    }


    if ( szEnd < szFile ) {
        cbSize = (CB)(szLast - szFile);
    } else {
        cbSize = (CB)(szEnd - szFile);
    }


    if (sz = (SZ)SAlloc( cbSize+1 )) {

        memcpy( sz, szFile, cbSize );
        sz[cbSize] = '\0';
    }

    return sz;
}


//
//  Determines if a filename is COM
//
BOOL
FIsCom(
    SZ          szFile
    )
{
    SZ  szEnd;

    szEnd = szFile + strlen( szFile ) - 1;

    //
    //  Look for last '.'
    //
    while ( (szEnd >= szFile) && (*szEnd != '.')) {
        szEnd--;
    }


    if ( szEnd >= szFile ) {
        return (BOOL)( (CrcStringCompare( szEnd, ".COM" ) == crcEqual) );

    }

    return fFalse;
}

//
//  Determines if a filename is EXE or COM
//
BOOL
FIsExeOrCom(
    SZ          szFile
    )
{
    SZ  szEnd;

    szEnd = szFile + strlen( szFile ) - 1;

    //
    //  Look for last '.'
    //
    while ( (szEnd >= szFile) && (*szEnd != '.')) {
        szEnd--;
    }


    if ( szEnd >= szFile ) {
        return (BOOL)( (CrcStringCompare( szEnd, ".EXE" ) == crcEqual) ||
                       (CrcStringCompare( szEnd, ".COM" ) == crcEqual) );

    }

    return fFalse;
}


//
//  Gets a Win16 Description
//
SZ
ReadWin16Descr(
    SZ                  szFile,
    HANDLE              Handle,
    PIMAGE_DOS_HEADER   pDosHeader,
    PIMAGE_OS2_HEADER   pOs2Header
    )
{
    DWORD   DescrOff;
    BYTE    DescrSize;
    SZ      szDescr = NULL;
    DWORD   BytesRead;

    UNREFERENCED_PARAMETER( pDosHeader );

    //
    //  Try to get description (first entry in nonresident table).
    //
    DescrOff = pOs2Header->ne_nrestab;

    if ( !(SetFilePointer( Handle, DescrOff, 0, FILE_BEGIN) != -1)                  ||
         !ReadFile( Handle, &DescrSize, sizeof(BYTE), &BytesRead, NULL )            ||
         !(BytesRead == sizeof(BYTE))                                               ||
         !(szDescr = ReadDescr( Handle, DescrOff+1, (DWORD)DescrSize ))
       ) {

        //
        //  Could not get description, try to get module name
        //  (first entry in resident table).
        //
        DescrOff = pOs2Header->ne_restab;

        if ( !(SetFilePointer( Handle, DescrOff, 0, FILE_BEGIN) != -1)                   ||
             !ReadFile( Handle, &DescrSize, sizeof(BYTE), &BytesRead, NULL )             ||
             !(BytesRead == sizeof(BYTE))                                                ||
             !(szDescr = ReadDescr( Handle, DescrOff+1, (DWORD)DescrSize ))
           ) {

            //
            //  Could not get module name, use file base name.
            //
            szDescr = GetBaseName( szFile );
        }
    }

    return szDescr;
}


#if 0
//
//  Get Win32 Description
//
SZ
ReadWin32Descr(
    SZ                  szFile,
    HANDLE              Handle,
    PIMAGE_DOS_HEADER   pDosHeader,
    PIMAGE_NT_HEADERS   pNtHeader
    )
{
    DWORD   DescrOff;
    DWORD   DescrSize;
    SZ      szDescr = NULL;

    UNREFERENCED_PARAMETER( pDosHeader );
    //
    //  Try to get the description
    //
    DescrOff  = pNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COPYRIGHT].VirtualAddress;
    DescrSize = pNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COPYRIGHT].Size;

    if ( !(szDescr = ReadDescr( Handle, DescrOff, DescrSize ) ) ) {

        //
        //  Could not get description, try to get module name.
        //
        //  BUGBUG: Where do we find the module name?
        //

        //
        //  Could not get module name, use file base name.
        //
        szDescr = GetBaseName( szFile );
    }

    return szDescr;
}
#endif


//
//  Reads a module description
//
SZ
ReadDescr(
    HANDLE      Handle,
    DWORD       Offset,
    DWORD       Size
    )

{
    SZ      szDescr = NULL;
    DWORD   BytesRead;
    size_t  SizeUsed;
    SZ      sz;


    if ( Size > 0 ) {

        if (szDescr = (SZ)SAlloc( Size+1 )) {

            //
            //  Read description
            //
            if ( (SetFilePointer( Handle, Offset, 0, FILE_BEGIN) != -1) &&
                 ReadFile( Handle, szDescr, Size, &BytesRead, NULL)     &&
                (BytesRead == Size) ) {

                //
                //  Get rid of padding blanks
                //
                sz = szDescr+Size-1;

                while ( (sz >= szDescr) &&
                        ( (*sz == ' ') || (*sz == '\t') ) ) {
                    sz--;
                }

                sz++;
                sz = '\0';
                SizeUsed = (size_t)(sz-szDescr);

                //
                //  If description has quotes or commas, or if it is longer
                //  than 26 characters, we don't want it.
                //
                if ( (SizeUsed > 25) ||
                     (strcspn( szDescr, """," ) >= SizeUsed)
                   ) {

                    SFree(szDescr);
                    szDescr = NULL;

                } else {

                    if ( (SizeUsed < Size) &&
                         (szDescr = SRealloc( szDescr, SizeUsed))) {

                        *(szDescr+SizeUsed) = '\0';
                    }
                }

            } else {

                SFree(szDescr);
                szDescr = NULL;
            }
        }
    }

    return szDescr;
}




//
//  Frees an Exe info
//
VOID
ExeInfoFree(
    PEXEINFO    pInfo
    )
{
    if ( pInfo->szDescr ) {
        SFree(pInfo->szDescr);
    }
    SFree(pInfo);
}





//*******************************************************************
//
//                         File List
//
//*******************************************************************

typedef struct _FILELIST *PFILELIST;
typedef struct _FILELIST {
    SYMTAB  SymTab;
} FILELIST;


PFILELIST
FileListAlloc(
    SZ  szFiles
    );

BOOL
FFileListInit(
    PFILELIST   pFileList
    );

VOID
FileListFree(
    PFILELIST   pFileList
    );

VOID
FileListDealloc(
    PFILELIST   pFileList
    );

BOOL
FFileInFileList(
    SZ          szFileName,
    PFILELIST   pFileList
    );

BOOL
FFileListAdd(
    SZ          szFileName,
    PFILELIST   pFileList
    );


//
//  Allocates a file list
//
PFILELIST
FileListAlloc(
    SZ  szFiles
    )
{
    BOOL        fOkay = fFalse;
    RGSZ        rgszFile;
    PFILELIST   pFileList = NULL;
    INT         iFile;

    if (rgszFile = RgszFromSzListValue( szFiles )) {

        if (pFileList = (PFILELIST)SAlloc( sizeof(FILELIST) )) {

            FFileListInit( pFileList );

            fOkay = fTrue;

            if ( rgszFile[0] ) {

                //
                //  Add files to FileList.
                //
                for ( iFile = 0; fOkay && rgszFile[iFile]; iFile++ ) {

                    if ( !(fOkay = FFileListAdd( rgszFile[iFile], pFileList ))) {

                        FileListFree( pFileList );
                        pFileList = NULL;
                    }
                }
            }
        }

        FFreeRgsz( rgszFile );
    }

    return pFileList;
}



//
//  Initializes a File list
//
BOOL
FFileListInit(
    PFILELIST   pFileList
    )
{
    USHORT      iHashBucket;

    for (iHashBucket = 0; iHashBucket < cHashBuckets; iHashBucket++) {
        pFileList->SymTab.HashBucket[iHashBucket] = NULL;
    }

    return fTrue;
}


//
//  Frees a file list
//
VOID
FileListFree(
    PFILELIST   pFileList
    )
{
    FileListDealloc( pFileList );
    SFree(pFileList);
}


//
//  Deallocates a file list
//
VOID
FileListDealloc (
    PFILELIST   pFileList
    )
{
    USHORT  iHashBucket;

    for (iHashBucket = 0; iHashBucket < cHashBuckets; iHashBucket++) {

        PSTE pste = pFileList->SymTab.HashBucket[iHashBucket];

        while (pste != (PSTE)NULL) {

            PSTE psteSav = pste->psteNext;

            FFreePste(pste);
            pste = psteSav;
        }
    }
}

//
//  Finds a file in a file list
//
BOOL
FFileInFileList(
    SZ          szFileName,
    PFILELIST   pFileList
)
{
    PPSTE       ppste;
    PSYMTAB     pSymTab = &(pFileList->SymTab);

    if ( szFileName && (szFileName[0] != '\0') ) {

        ppste = PpsteFindSymbol( pSymTab, szFileName );

        AssertRet(ppste != (PPSTE)NULL, fFalse);

        if (*ppste == (PSTE)NULL) {
            return fFalse;
        }

        AssertRet( (*ppste)->szSymbol != (SZ)NULL &&
                   *((*ppste)->szSymbol) != '\0' &&
                  (*ppste)->szValue != (SZ)NULL, fFalse);

        if (CrcStringCompare(szFileName, (*ppste)->szSymbol) != crcEqual) {
            return fFalse;
        }

        return fTrue;
    }

    return fFalse;
}




//
//  Adds a file to the file list
//
BOOL
FFileListAdd(
    SZ          szFileData,
    PFILELIST   pFileList
    )
{

    BOOL    fOkay = fFalse;
    PPSTE   ppste;
    SZ      szFile;
    SZ      szValue;
    PSYMTAB pSymTab = &(pFileList->SymTab);


    if ( szFileData ) {

        if ( (szFile = SzDupl(szFileData)) != NULL ) {

            SzStrUpper( szFile );

            if ( (szValue = SzDupl("")) != NULL ) {

                fOkay = fTrue;

            } else {

                SFree(szFile);
            }
        }
    }


    if ( fOkay ) {

        ppste = PpsteFindSymbol( pSymTab, szFile );

        if ( *ppste != NULL &&
             CrcStringCompare( (*ppste)->szSymbol, szFile) == crcEqual) {

            if ((*ppste)->szValue == NULL) {

                SFree(szFile);
                SFree(szValue);
                fOkay = fFalse;
                goto AddExit;
            }

            SFree((*ppste)->szValue);
            SFree(szFile);

            (*ppste)->szValue = NULL;

        } else {

            PSTE    pste;

            if ( (pste = PsteAlloc()) == NULL ) {

                SFree(szFile);
                SFree(szValue);
                fOkay = fFalse;
                goto AddExit;
            }

            pste->szSymbol = szFile;

#ifdef SYMTAB_STATS
            pSymTab->BucketCount[UsHashFunction(szFile)]++;
#endif

            pste->szValue  = NULL;
            pste->psteNext = *ppste;
            *ppste = pste;
        }

        (*ppste)->szValue = szValue;

    }

AddExit:

    return fOkay;
}





//*******************************************************************
//
//                         Search List
//
//*******************************************************************

typedef struct _SEARCHLIST *PSEARCHLIST;
typedef struct _SEARCHLIST {
    DWORD       dwPatterns;
    RGSZ        rgszPattern;
    FILELIST    FileList;
} SEARCHLIST;


PSEARCHLIST
SearchListAlloc(
    SZ  szFiles
    );

VOID
SearchListFree(
    PSEARCHLIST pList
    );

BOOL
FSearchListAddPattern(
    SZ          szPattern,
    PSEARCHLIST pSearchList
    );

BOOL
FFileInSearchList(
    SZ          szFileName,
    PSEARCHLIST pSearchList
    );


BOOL
FHasWildCard(
    SZ      szFile
    );


BOOL
FPatternMatch(
    SZ      szFile,
    SZ      szPattern
    );

//
//  Allocates a search list
//
PSEARCHLIST
SearchListAlloc(
    SZ  szFiles
    )
{
    BOOL        fOkay = fTrue;
    RGSZ        rgszFile;
    PSEARCHLIST pSearchList = NULL;
    INT         iFile;


    if (rgszFile = RgszFromSzListValue( szFiles )) {

        if ( rgszFile[0] != NULL ) {

            if (pSearchList = (PSEARCHLIST)SAlloc( sizeof(SEARCHLIST) )) {

                FFileListInit( &(pSearchList->FileList) );

                if ( pSearchList->rgszPattern = (RGSZ)SAlloc( sizeof(SZ) ) ) {

                    pSearchList->rgszPattern[0] = NULL;
                    pSearchList->dwPatterns     = 0;

                    //
                    //  Add files to FileList.
                    //
                    for ( iFile = 0; fOkay && rgszFile[iFile]; iFile++ ) {


                        //
                        //  If the file has wildcards, add it to the pattern list,
                        //  otherwise add it to the file list
                        //
                        if ( FHasWildCard( rgszFile[iFile] ) ) {

                            fOkay = FSearchListAddPattern( rgszFile[iFile], pSearchList );

                        } else {

                            fOkay = FFileListAdd( rgszFile[iFile], &(pSearchList->FileList) );

                        }

                        if (!fOkay) {

                            SearchListFree( pSearchList );
                            pSearchList = NULL;
                        }
                    }

                } else {

                    SFree(pSearchList);
                    pSearchList = NULL;
                }
            }
        }

        FFreeRgsz( rgszFile );
    }

    return pSearchList;
}


//
//  Frees a search list
//
VOID
SearchListFree(
    PSEARCHLIST pSearchList
    )
{
    FileListDealloc( &(pSearchList->FileList) );
    FFreeRgsz( pSearchList->rgszPattern );
    SFree(pSearchList);
}


//
//  Adds a pattern to the search list
//
BOOL
FSearchListAddPattern(
    SZ          szPattern,
    PSEARCHLIST pSearchList
    )
{
    SZ      sz;
    RGSZ    rgsz;
    BOOL    fOkay = fFalse;

    if (sz = SzDupl( szPattern )) {

        rgsz = (RGSZ)SRealloc( pSearchList->rgszPattern,
                                ((pSearchList->dwPatterns+2)*sizeof(SZ)));

        if ( rgsz ) {

            rgsz[pSearchList->dwPatterns]      = sz;
            rgsz[pSearchList->dwPatterns+1]    = NULL;

            pSearchList->rgszPattern = rgsz;
            pSearchList->dwPatterns++;

            fOkay = fTrue;

        } else {

            SFree(sz);
        }
    }

    return fOkay;
}



//
//  Determines if a file name is in the search list
//
BOOL
FFileInSearchList(
    SZ          szFileName,
    PSEARCHLIST pSearchList
    )
{
    INT i;

    if ( FFileInFileList( szFileName, &(pSearchList->FileList) ) ) {
        return fTrue;
    } else {

        for (i=0; pSearchList->rgszPattern[i]; i++ ) {

            if ( FPatternMatch( szFileName, pSearchList->rgszPattern[i] ) ) {
                return fTrue;
            }
        }
    }

    return fFalse;
}



//
//  Determines if a file name has a wildcard
//
BOOL
FHasWildCard(
    SZ      szFile
    )
{
    return (strcspn( szFile, "*?" ) < strlen( szFile ) );
}


BOOL
FPatternMatch(
    SZ      szFile,
    SZ      szPattern
    )
{
    switch (*szPattern) {
    case '\0':
        return ( *szFile == '\0' );
    case '?':
        return ( *szFile != '\0' && FPatternMatch (szPattern + 1, szFile + 1) );
    case '*':
        do {
        if (FPatternMatch (szPattern + 1, szFile))
                return fTrue;
        } while (*szFile++);
        return fFalse;
    default:
        return ( toupper (*szFile) == toupper (*szPattern) && FPatternMatch (szPattern + 1, szFile + 1) );
    }
}


//*******************************************************************
//
//                         Found List
//
//*******************************************************************


#define FOUNDLIST_INCR      32

typedef struct _FOUNDLIST *PFOUNDLIST;
typedef struct _FOUNDLIST {
    DWORD   Index;
    DWORD   Size;
    RGSZ    rgszList;
} FOUNDLIST;


PFOUNDLIST
FoundListAlloc(
    );

VOID
FoundListFree(
    PFOUNDLIST  pList
    );

BOOL
FoundListAdd(
    SZ          szFile,
    SZ          szDirectory,
    PEXEINFO    pExeInfo,
    PFOUNDLIST  pFoundList
    );

SZ
SzFromFoundList(
    PFOUNDLIST  pFoundList
    );


//
//  Initialize a Found List
//
PFOUNDLIST
FoundListAlloc(
    )
{
    PFOUNDLIST  pFoundList;

    if ( (pFoundList = (PFOUNDLIST)SAlloc( sizeof(FOUNDLIST) )) != NULL ) {

        if ( (pFoundList->rgszList = (RGSZ)SAlloc( FOUNDLIST_INCR * sizeof(SZ) )) != NULL ) {

            pFoundList->Index       = 0;
            pFoundList->Size        = FOUNDLIST_INCR;
            pFoundList->rgszList[0] = NULL;

        } else {

            SFree(pFoundList);
            pFoundList = (PFOUNDLIST)NULL;
        }
    }

    return pFoundList;
}


//
//  Free a found list
//
VOID
FoundListFree(
    PFOUNDLIST  pFoundList
    )
{
    RGSZ    rgszList;

    rgszList = (RGSZ)SRealloc( pFoundList->rgszList,
                                ((pFoundList->Index+1)*sizeof(SZ)));

    FFreeRgsz( rgszList );
    SFree(pFoundList);
}



//
//  Add and entry to the found list
//
BOOL
FoundListAdd (
    SZ          szFile,
    SZ          szDirectory,
    PEXEINFO    pExeInfo,
    PFOUNDLIST  pFoundList
    )
{
    BOOL    fOkay = fFalse;
    RGSZ    rgszEntry;
    RGSZ    rgszList;
    SZ      szEntry;

    if (rgszEntry = (RGSZ)SAlloc( 5 * sizeof(SZ) )) {

        rgszEntry[0] = szFile;
        rgszEntry[1] = szDirectory;
        rgszEntry[2] = ExeInfoGetTypeSz( pExeInfo );
        rgszEntry[3] = ExeInfoGetDescr( pExeInfo );
        rgszEntry[4] = NULL;

        if (szEntry = SzListValueFromRgsz( rgszEntry )) {

            if ( pFoundList->Index >= (pFoundList->Size - 1) ) {

                rgszList = (RGSZ)SRealloc( pFoundList->rgszList,
                                            ((pFoundList->Size+FOUNDLIST_INCR)*sizeof(SZ)));

                if ( rgszList ) {

                    pFoundList->Size    += FOUNDLIST_INCR;
                    pFoundList->rgszList = rgszList;
                    fOkay                = fTrue;
                }

            } else {

                fOkay = fTrue;
            }

            if ( fOkay ) {

                pFoundList->rgszList[pFoundList->Index++] = szEntry;
                pFoundList->rgszList[pFoundList->Index]   = NULL;

            } else {

                SFree(szEntry);
            }
        }

        SFree(rgszEntry);

    }

    return fOkay;
}


//
//  Get SZ from found list
//
SZ
SzFromFoundList(
    PFOUNDLIST  pFoundList
    )
{
    return SzListValueFromRgsz( pFoundList->rgszList );
}


//*******************************************************************
//
//                     Application Search
//
//*******************************************************************



extern  HWND    hwndFrame;

CHAR            GaugeText1[50];
CHAR            GaugeText2[50];
CHAR            GaugeText3[50];

WIN32_FIND_DATA FindData;
#define BARRANGE       30000



//
//  Local Prototypes
//
BOOL APIENTRY FSearchDirectoryList(
    RGSZ        rgszDirs,
    BOOL        fRecurse,
    BOOL        fSilent,
    PSEARCHLIST pSearchList,
    PFILELIST   pWin16Restr,
    PFILELIST   pWin32Restr,
    PFILELIST   pDosRestr,
    PFOUNDLIST  pFoundList
    );


BOOL APIENTRY FSearchDirectory(
    SZ          szDirectory,
    BOOL        fRecurse,
    BOOL        fSilent,
    PSEARCHLIST pSearchList,
    PFILELIST   pWin16Restr,
    PFILELIST   pWin32Restr,
    PFILELIST   pDosRestr,
    PFOUNDLIST  pFoundList,
    INT         Position,
    INT         Range,
    SZ          szDisplayBuffer
    );




//
//  Purpose:
//
//      Prepares for application search.
//
//  Arguments:
//
//      szInfVar        -   Where to put the result
//      szDirList       -   List of directories to search
//      fRecurse        -   Recursive flag
//      fSilent         -   Silent mode flag
//      szSearchList    -   List of files to search, can have wildcards
//      szWin16Restr    -   Win16 restriction list
//      szWin32Restr    -   Win32 restriction list
//      szDosRestr      -   Dos restriction list
//
//  Returns:
//
//      fTrue if success.
//
BOOL APIENTRY FSearchDirList(
    SZ      szInfVar,
    SZ      szDirList,
    BOOL    fRecurse,
    BOOL    fSilent,
    SZ      szSearchList,
    SZ      szWin16Restr,
    SZ      szWin32Restr,
    SZ      szDosRestr
    )
{
    BOOL        fOkay = fFalse;
    RGSZ        rgszDirs;
    PSEARCHLIST pSearchList;
    PFILELIST   pWin16Restr;
    PFILELIST   pWin32Restr;
    PFILELIST   pDosRestr;
    PFOUNDLIST  pFoundList;
    SZ          szResult;

    SetCursor(CurrentCursor = LoadCursor(NULL,IDC_WAIT));
    fSilent = (fSilent || fSilentSystem);

    if ( rgszDirs = RgszFromSzListValue( szDirList ) ) {

        if ( pSearchList = SearchListAlloc( szSearchList )) {

            if ( pWin16Restr = FileListAlloc( szWin16Restr ) ) {

                if ( pWin32Restr = FileListAlloc( szWin32Restr ) ) {

                    if ( pDosRestr = FileListAlloc( szDosRestr ) ) {

                        if ( pFoundList = FoundListAlloc() ) {


                            SetCursor(CurrentCursor = LoadCursor(NULL,IDC_ARROW));
                            fOkay = FSearchDirectoryList( rgszDirs,
                                                          fRecurse,
                                                          fSilent,
                                                          pSearchList,
                                                          pWin16Restr,
                                                          pWin32Restr,
                                                          pDosRestr,
                                                          pFoundList );

                            if ( fOkay ) {

                                if ( szResult = SzFromFoundList( pFoundList ) ) {

                                    while (!FAddSymbolValueToSymTab( szInfVar, szResult)) {

                                        if (!FHandleOOM(hwndFrame)) {

                                            fOkay = fFalse;
                                            break;

                                        }
                                    }

                                    SFree(szResult);

                                } else {

                                    fOkay = fFalse;
                                }
                            }

                            FoundListFree( pFoundList );
                        }

                        FileListFree( pDosRestr );
                    }

                    FileListFree( pWin32Restr );
                }

                FileListFree( pWin16Restr );
            }

            SearchListFree( pSearchList );
        }

        FFreeRgsz( rgszDirs );
    }

    return fOkay;
}





//
//  Purpose:
//
//      Performs the application search.
//
//  Arguments:
//
//      rgszDirs        -   List of directories to traverse
//      fRecurse        -   Recursive flag
//      fSilent         -   Silent mode flag
//      pSearchList     -   The list of files to search
//      pWin16Restr     -   List of Win16 restrictions
//      pWin32Restr     -   List of Win32 restrictions
//      pDosRestr       -   List of DOS restrictions
//      pFoundList      -   Found list
//
//  Returns:
//
//      fTrue if success.
//
BOOL APIENTRY FSearchDirectoryList(
    RGSZ        rgszDirs,
    BOOL        fRecurse,
    BOOL        fSilent,
    PSEARCHLIST pSearchList,
    PFILELIST   pWin16Restr,
    PFILELIST   pWin32Restr,
    PFILELIST   pDosRestr,
    PFOUNDLIST  pFoundList
    )
{

    DWORD   iDir;
    DWORD   cDirs;
    INT     SubRange;
    INT     Pos;
    CHAR    szDirectory[ cchlFullPathMax ];
    CHAR    szDisplayBuffer[cchlFullPathMax ];
    BOOL    fOkay = fTrue;

    //
    //  Figure out how many directories we have to traverse
    //
    for ( cDirs = 0, iDir = 0; rgszDirs[iDir] != NULL; iDir++ ) {
        if ( *rgszDirs[iDir] != '\0' ) {
            cDirs++;
        }
    }

    //
    //  Traverse the directories
    //
    if ( cDirs > 0 ) {

        if (!fSilent) {

            SZ  szText;

            ProOpen(hwndFrame, 0);
            ProSetBarRange(BARRANGE);
            ProSetBarPos(0);

            szText = SzFindSymbolValueInSymTab("ProText1");
            if (szText) {
               strcpy(GaugeText1, szText);
            }

            szText = SzFindSymbolValueInSymTab("ProText2");
            if (szText) {
               strcpy(GaugeText2, szText);
            }

            szText = SzFindSymbolValueInSymTab("ProText3");
            if (szText) {
               strcpy(GaugeText3, szText);
            }

            ProSetText(ID_STATUS1, GaugeText1);
            ProSetText(ID_STATUS4, "");
        }

        SubRange = BARRANGE/cDirs;
        Pos      = 0;


        //
        //  Do one directory at a time
        //
        for ( iDir = 0;
              fOkay && FYield() && !fUserQuit && (iDir < cDirs);
              iDir++ ) {

            SZ      szEnd;
            BOOL    fRecursive;

            strcpy( szDirectory, rgszDirs[iDir] );
            szEnd = szDirectory + strlen( szDirectory ) - 1;

            if ( ( (szEnd - szDirectory) >= 1)   &&
                 ( szDirectory[1] == ':'  ) &&
                 ( szDirectory[2] == '\0' ) ) {

                    fRecursive = fTrue;

            } else {

                fRecursive = fRecurse;
            }

            if ( *szEnd == '\\' ) {
                *szEnd = '\0';
            }


            fOkay = FSearchDirectory( szDirectory,
                                      fRecursive,
                                      fSilent,
                                      pSearchList,
                                      pWin16Restr,
                                      pWin32Restr,
                                      pDosRestr,
                                      pFoundList,
                                      Pos,
                                      SubRange,
                                      szDisplayBuffer );

            Pos += SubRange;
        }

        if (!fSilent) {
            ProSetBarPos(BARRANGE - 1);
            ProClose(hwndFrame);
        }
    }

    return fOkay;
}





//
//  Purpose:
//
//      Performs the application search in one directory
//
//  Arguments:
//
//      szDirectory     -   Directory to traverse
//      fRecurse        -   Recursive flag
//      fSilent         -   Silent mode flag
//      pSearchList     -   The list of files to search
//      pWin16Restr     -   List of Win16 restrictions
//      pWin32Restr     -   List of Win32 restrictions
//      pDosRestr       -   List of DOS restrictions
//      pFoundList      -   Found list
//      Position        -   Gauge initial position
//      Range           -   Gauge range
//      szDisplayBuffer -   Tmp buffer.
//
//  Returns:
//
//      fTrue if success.
//
BOOL APIENTRY FSearchDirectory(
    SZ          szDirectory,
    BOOL        fRecurse,
    BOOL        fSilent,
    PSEARCHLIST pSearchList,
    PFILELIST   pWin16Restr,
    PFILELIST   pWin32Restr,
    PFILELIST   pDosRestr,
    PFOUNDLIST  pFoundList,
    INT         Position,
    INT         Range,
    SZ          szDisplayBuffer
    )
{

    SZ          pFileName;
    HANDLE      FindHandle;
    BOOL        fOkay        = fTrue;
    INT         cDirectories = 0;
    INT         SubRange;
    INT         Pos;
    PEXEINFO    pExeInfo;
    BOOL        fAdd;

    if ( !szDirectory || szDirectory[0] == '\0' || szDirectory[0] == '.') {
        return fFalse;
    }

    //
    // catch local source directory -- don't want to find files in there!
    //
    if(!_strnicmp(szDirectory+2,LOCAL_SOURCE_DIRECTORY,lstrlen(LOCAL_SOURCE_DIRECTORY))) {
        return fTrue;
    }

    if (!fSilent) {
        wsprintf(szDisplayBuffer, "%s%s", GaugeText2, szDirectory );
        ProSetText(ID_STATUS2, szDisplayBuffer);
    }

    pFileName = szDirectory + strlen( szDirectory );
    SzStrCat( szDirectory, "\\*.*" );

    FindHandle = FindFirstFile( szDirectory, &FindData );

    if ( FindHandle != INVALID_HANDLE_VALUE ) {

        //
        //  Look at all files under this directory.
        //
        do {
            if ( FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) {

                //
                //  Increment the count of directories just in case we're interactive
                //  and we want to recurse.
                //
                if ( FindData.cFileName[0] != '.' ) {
                    cDirectories++;
                }

            } else {

                //
                //  If the file is in the search list, determine if we have to add it
                //  to the found list and if so add it.
                //
                SzStrUpper( FindData.cFileName );

                if ( FFileInSearchList( FindData.cFileName, pSearchList ) ) {

                    *pFileName = '\0';
                    SzStrCat( szDirectory, "\\" );
                    SzStrCat( szDirectory, FindData.cFileName );
                    if ( ((pExeInfo = ExeInfoAlloc( szDirectory, FindData.cFileName )) != NULL) ) {

                        switch( ExeInfoGetType( pExeInfo ) ) {

                            case EXE_WIN16:
                                //
                                //  We only add if not in Win16Restr
                                //
                                fAdd = !FFileInFileList( FindData.cFileName, pWin16Restr );
                                break;

                            case EXE_WIN32:
                                //
                                //  We only add if not in Win32Restr
                                //
                                fAdd = !FFileInFileList( FindData.cFileName, pWin32Restr );
                                break;

                            case EXE_DOS:
                                //
                                //  We only add if in DosRestr
                                //
                                fAdd = FFileInFileList( FindData.cFileName, pDosRestr );
                                break;

                            default:
                                fAdd = fFalse;
                                break;
                        }

                        if ( fAdd ) {

                            if (!fSilent) {
                                wsprintf(szDisplayBuffer, "%s%s", GaugeText3, FindData.cFileName );
                                ProSetText(ID_STATUS3, szDisplayBuffer);
                            }

                            *pFileName     = '\\';
                            *(pFileName+1) = '\0';
                            fOkay = FoundListAdd( FindData.cFileName, szDirectory, pExeInfo, pFoundList );
                        }


                        ExeInfoFree( pExeInfo );
                    }
                }
            }

        } while ( fOkay && FYield() && !fUserQuit && FindNextFile( FindHandle, &FindData ));

        FindClose( FindHandle );


        //
        //  Recurse thru all the subdirectories if the fRecurse flag is set.
        //
        if ( fOkay && fRecurse && !fUserQuit && (cDirectories > 0) ) {

            *pFileName = '\0';
            SzStrCat( szDirectory, "\\*.*" );

            FindHandle   = FindFirstFile( szDirectory, &FindData );

            if ( FindHandle != INVALID_HANDLE_VALUE ) {

                SubRange = Range/cDirectories;
                Pos      = Position;

                do {

                    if ( (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
                        (FindData.cFileName[0] != '.') ) {

                        *pFileName      = '\\';
                        *(pFileName+1)  = '\0';
                        SzStrCat( szDirectory, FindData.cFileName );

                        fOkay = FSearchDirectory( szDirectory,
                                                  fRecurse,
                                                  fSilent,
                                                  pSearchList,
                                                  pWin16Restr,
                                                  pWin32Restr,
                                                  pDosRestr,
                                                  pFoundList,
                                                  Pos,
                                                  SubRange,
                                                  szDisplayBuffer );

                        Pos += SubRange;

                    }

                }  while ( fOkay && FYield() && !fUserQuit && FindNextFile( FindHandle, &FindData ));

                FindClose( FindHandle );
            }
        }
    }

    if ( !fSilent && (Range > 0) ) {
        ProSetBarPos( Position + Range - 1 );
    }

    //
    //  Restore original Directory name.
    //
    *pFileName = '\0';

    return fOkay;
}