////////////////////////////////////////////////////////////////////////////////////
//
// File:    globals.cpp
//
// History: 16-Nov-00   markder     Created.
//
// Desc:    This file contains miscellaneous helper functions.
//
////////////////////////////////////////////////////////////////////////////////////

#include "StdAfx.h"
#include <errno.h>

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   PrintError, PrintErrorStack, Print
//
//  Desc:   Helper functions for console output
//
////////////////////////////////////////////////////////////////////////////////////

TCHAR gszT[1024]; // Global buffer for console output

void _cdecl PrintError(
                      LPCTSTR pszFmt,
                      ...)
{
    va_list arglist;

    va_start(arglist, pszFmt);
    StringCchVPrintf(gszT, ARRAYSIZE(gszT), pszFmt, arglist);
    gszT[1023] = _T('\0');              // ensure null termination
    va_end(arglist);
    _tprintf(_T("\nNMAKE :  U8604: 'ShimDBC': %s"), gszT);
}

void PrintErrorStack()
{
    CString csError;
    INT_PTR     i, j;

    Print(_T("\n\nErrors were encountered during compilation:\n"));
    for (i = g_rgErrors.GetSize() - 1; i >= 0; i--) {
        csError.Empty();
        j = g_rgErrors.GetSize() - i;
        while(--j) {
            csError += _T(" ");
        }
        csError += g_rgErrors[i];
        csError += _T("\n");
        PrintError(csError);
    }
}

void _cdecl Print(
                 LPCTSTR pszFmt,
                 ...)
{
    va_list arglist;

    if (g_bQuiet)
        return;

    va_start(arglist, pszFmt);
    StringCchVPrintf(gszT, ARRAYSIZE(gszT), pszFmt, arglist);
    gszT[1023] = _T('\0');              // ensure null termination
    va_end(arglist);
    _tprintf(_T("%s"), gszT);

}

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   StringToDword
//
//  Desc:   Converts a string to a DWORD. Handles the 0x prefix for hex strings.
//
DWORD StringToDword(
    CString cs)
{
    DWORD dwRet;

    cs.MakeLower();

    if (cs.Left(2) == _T("0x")) {
        _stscanf(cs, _T("0x%x"), &dwRet);
    } else {
        dwRet = _ttol(cs);
    }

    return dwRet;
}

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   StringToULong
//
//  Desc:   Converts a string to a unsigned long.
//
ULONG StringToULong(
    LPCTSTR lpszVal)
{
    TCHAR* pEnd;

    return _tcstoul(lpszVal, &pEnd, 0);
}

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   StringToMask
//
//  Desc:   Converts a string to a mask, with some checking
//
BOOL
StringToMask(
    LPDWORD pdwMask,
    LPCTSTR lpszVal
    )
{
    DWORD dwMask = 0;
    LPCTSTR pVal;
    BOOL bSuccess;
    TCHAR* pEnd = NULL;

    pVal = lpszVal + _tcsspn(lpszVal, _T(" \t"));
    dwMask = (DWORD)_tcstoul(pVal, &pEnd, 0);

    if (dwMask == 0) { // suspicious, possibly check errno
        if (errno != 0) {
            goto errHandle;
        }
    }

    //
    // if a mask is ending with some garbage -- it's an error
    //
    if (pEnd && *pEnd != _T('\0') && !_istspace(*pEnd)) {
        goto errHandle;
    }

    if (pdwMask) {
        *pdwMask = dwMask;
    }
    return TRUE;


errHandle:
    SDBERROR_FORMAT((_T("Failed to parse \"%s\"\n"), lpszVal));
    return FALSE;
}





////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   StringToQword
//
//  Desc:   Converts a string to a 64-bit ULONGLONG (aka QWORD). Handles the 0x
//          prefix for hex strings.
//
ULONGLONG StringToQword(
    CString cs)
{
    ULONGLONG ullRet;

    cs.MakeLower();

    if (cs.Left(2) == _T("0x")) {
        _stscanf(cs, _T("0x%I64x"), &ullRet);
    } else {
        ullRet = _ttoi64(cs);
    }

    return ullRet;
}

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   VersionToQword
//
//  Desc:   Converts a version string to a 64-bit ULONGLONG (aka QWORD).
//          Version strings are of the form xx.xx.xx.xx, where each of
//          numbers is turned into a word and combined into a single
//          quad word. If a portion of the version string is a * or is
//          missing, it is stored as 0xFFFF.
//
BOOL VersionToQword(
    LPCTSTR lpszVersion,
    ULONGLONG* pullRet
    )
{
    BOOL          bSuccess = FALSE;
    ULONG     ulPart;
    LPTSTR    pEnd = NULL;
    int i;

    *pullRet = 0;

    for (i = 0; i < 4; i++) {

        ulPart = (WORD)0xFFFF;

        //
        // skip whitespace
        //

        lpszVersion += _tcsspn(lpszVersion, _T(" \t"));

        if (*lpszVersion == _T('*')) {

            //
            // we expect to see either *\0 or *.xxx
            // so move past *
            //
            pEnd = (LPTSTR)(lpszVersion + 1);

        }
        else {
            //
            // not a wildcard - if we have not reached the end of the string,
            // keep parsing numbers
            //
            if (*lpszVersion) {

                pEnd = NULL;

                ulPart = _tcstol(lpszVersion, &pEnd, 0);

                //
                // check to see that the part was converted properly
                //
                if (pEnd == NULL) {
                    SDBERROR_FORMAT((_T("Internal error, failed to parse \"%s\"\n"), lpszVersion));
                    goto eh;
                }
            }

        }

        if (pEnd == NULL) {
            break;
        }

        //
        // skip whitespace first
        //
        pEnd += _tcsspn(pEnd, _T(" \t"));

        //
        // at this point we should be at the end of
        // the string OR at the '.'
        //
        if (*pEnd && *pEnd != _T('.')) {
            SDBERROR_FORMAT((_T("Bad version specification, parsing stopped at \"%s\"\n"), pEnd));
            goto eh;
        }

        lpszVersion = (*pEnd == _T('.') ? pEnd + 1 : pEnd);

        *pullRet = (*pullRet << 16) | ((WORD)ulPart);
    }

    bSuccess = TRUE;

eh:

    return bSuccess;
}

BOOL VersionQwordToString(
    OUT CString&   rString,
    ULONGLONG      ullVersion
    )
{
    // we do conversion to string
    int       i;
    WORD      wPart;
    CString   csPart;
    ULONGLONG ullMask = (((ULONGLONG)0xFFFF) << 48);
    ULONGLONG ullPart;

    rString.Empty();

    for (i = 0; i < 4; ++i) {

        ullPart = ullVersion & ullMask;
        ullVersion = (ullVersion << 16) | (WORD)0xFFFF;

        //
        // get the part into the lower portion
        //
        wPart = (WORD)(ullPart >> 48);

        if (wPart == (WORD)0xFFFF) {
            csPart = _T('*');
        } else {
            csPart.Format(_T("%hu"), wPart);
        }

        if (i > 0) {
            rString += _T('.');
        }

        rString += csPart;

        if (ullVersion == (ULONGLONG)-1) {
            break;
        }

    }

    return TRUE;
}


////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   TrimParagraph
//
//  Desc:   Trims extra whitespace from a string
//
//

CString TrimParagraph(CString csInput)
{
    CString csOutput;
    long i;

    // Expand CString's buffer to size of input
    csOutput.GetBuffer(csInput.GetLength());
    csOutput.ReleaseBuffer();

    for (i = 0; i < csInput.GetLength(); i++) {
        TCHAR c = csInput.GetAt(i);

        if (_istspace(c)) {
            if (csOutput.GetLength() == 0)
                continue;

            if (csOutput.Mid(csOutput.GetLength() - 1) == _T(' ') ||
                csOutput.Mid(csOutput.GetLength() - 4, 4) == _T("BR/>") ||
                csOutput.Mid(csOutput.GetLength() - 3, 3) == _T("P/>"))
                continue;

            csOutput += _T(' ');
            continue;
        }

        if (csInput.Left(3) == _T("<BR") ||
            csInput.Left(2) == _T("<P")) {
            //
            // Get rid of spaces preceding a <BR/> tag
            //
            csOutput.TrimRight();
        }

        csOutput += c;
    }

    csOutput.TrimLeft();
    csOutput.TrimRight();

    return csOutput;
}

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   ReplaceStringNoCase
//
//  Desc:   Replaces all instances of lpszFindThis with lpszReplaceWithThis
//          within csText (case insensitive).
//
VOID ReplaceStringNoCase(CString& csText, LPCTSTR lpszFindThis, LPCTSTR lpszReplaceWithThis)
{
    LPTSTR lpszBuffer;
    LPTSTR lpszFind;

    if (0 == csText.GetLength()) {
        return;
    }

    CString strFindNoCase(lpszFindThis);

    lpszBuffer = csText.GetBuffer(csText.GetLength());

    strFindNoCase.MakeUpper();

    do {
        lpszFind = StrStrI(lpszBuffer, strFindNoCase);
        if (NULL != lpszFind) {
            memcpy(lpszFind, (LPCTSTR)strFindNoCase, strFindNoCase.GetLength() * sizeof(*lpszFind));
            lpszBuffer = lpszFind + strFindNoCase.GetLength();
        }
    } while (NULL != lpszFind);

    // now that all the instances of the lpszFindThis had been replaced with
    // the upper-cased version... do a regular replace
    csText.ReleaseBuffer();
    csText.Replace(strFindNoCase, lpszReplaceWithThis);
}

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   MakeFullPath
//
//  Desc:   Creates a full path from a (possible) relative one. Uses
//          GetCurrentDirectory to prepend the passed in string.
//
CString MakeFullPath(CString cs)
{
    CString csNewPath;
    DWORD dwCurDirSize;
    LPTSTR lpszCurDir;

    return cs;

#if 0
    //
    // Check if it's already a full path
    //
    if (cs.Mid(1, 1) == _T(":") ||
        cs.Left(2) == _T("\\\\")) {
        //
        // This is either a UNC full path or a DOS full path.
        // Drop out.
        //
        return cs;
    }

    dwCurDirSize = GetCurrentDirectory(0, NULL);
    lpszCurDir = csNewPath.GetBuffer(dwCurDirSize);

    if (0 == GetCurrentDirectory(dwCurDirSize, lpszCurDir)) {
        //
        // Something really weird happened. Not sure how to error out.
        //
        return cs;
    }

    csNewPath.ReleaseBuffer();

    if (csNewPath.Right(1) != _T("\\")) {
        csNewPath += _T("\\");
    }

    csNewPath += cs;

    return csNewPath;
#endif
}


////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   GetByteStringSize
//
//  Desc:   Parses a 'byte string' (used in <PATCH> declarations) to determine
//          how many bytes it contains.
//
DWORD GetByteStringSize(
    CString  csBytes)
{
    DWORD dwByteCount = 0;
    BOOL  bOnByte = FALSE;

    csBytes.MakeUpper();

    for (long i = 0; i < csBytes.GetLength(); i++) {
        if (_istxdigit(csBytes.GetAt(i))) {
            if (!bOnByte) {
                dwByteCount++;
                bOnByte = TRUE;
            }
        } else if (_istspace(csBytes.GetAt(i))) {
            bOnByte = FALSE;
        } else {
            SDBERROR_FORMAT((_T("Unrecognized byte character '%c' in <PATCH> block:\n%s\n"),
                              csBytes.GetAt(i), ((LPCTSTR)csBytes)+i));

            return 0xFFFFFFFF;
        }
    }

    return dwByteCount;
}

////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   GetBytesFromString
//
//  Desc:   Parses a 'byte string' (used in <PATCH> declarations) into an actual
//          memory block.
//
DWORD GetBytesFromString(
    CString  csBytes,
    BYTE*    pBuffer,
    DWORD    dwBufferSize)
{
    csBytes.MakeUpper();

    CString csByte;
    DWORD   dwRequiredBufferSize;
    LONG    nFirstByteChar = -1;
    DWORD   dwBufferCursor = 0;
    DWORD   dwByte;

    dwRequiredBufferSize = GetByteStringSize(csBytes);

    if (dwRequiredBufferSize < dwBufferSize || dwRequiredBufferSize == 0xFFFFFFFF) {
        return dwRequiredBufferSize;
    }

    for (long i = 0; i < csBytes.GetLength() + 1; i++) {
        if (_istxdigit(csBytes.GetAt(i))) {

            if (nFirstByteChar == -1) {
                nFirstByteChar = i;
            }
        } else if (_istspace(csBytes.GetAt(i))   ||
                   csBytes.GetAt(i) == _T('\0')) {

            if (nFirstByteChar != -1) {
                csByte = csBytes.Mid(nFirstByteChar, i - nFirstByteChar);
                _stscanf(csByte, _T("%x"), &dwByte);
                memcpy(pBuffer + dwBufferCursor++, &dwByte, sizeof(BYTE));
            }

            nFirstByteChar = -1;
        } else {
            SDBERROR_FORMAT((_T("Unrecognized byte character '%c' in <PATCH> block:\n%s\n"),
                              csBytes.GetAt(i), ((LPCTSTR)csBytes)+i));

            return 0xFFFFFFFF;
        }
    }

    return dwRequiredBufferSize;
}


////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   DecodeString
//
//  Desc:   Decodes a list of strings with flags
//
//  [00]  [00]    [00]   [00]
//    ^   Arch1   Arch2  Arch3
//    |- flags
//
//  syntax for the runtime platform:
//  [!] ( [!] STR1 [; STR2 ] ... )
//  example:
//  !STR1 - will evaluate to TRUE when the the string is NOT STR1
//  !(STR1; STR2) - will evaluate to TRUE when the string doesn't contain STR1 or STR2
//


BOOL DecodeString(LPCTSTR pszStr, LPDWORD pdwMask, PFNGETSTRINGMASK pfnGetStringMask)
{
    BOOL   bNot     = FALSE;
    BOOL   bBracket = FALSE;
    LPTSTR pEnd;
    TCHAR  chSave;
    DWORD  dwElement;
    BOOL   bNotElement;
    DWORD  dwMask = 0;
    INT    nElement = 0;
    BOOL   bSuccess = FALSE;

    pszStr += _tcsspn(pszStr, _T(" \t"));
    //
    // Got the first char
    //
    if (*pszStr == _T('!')) {
        //
        // Peek ahead and see whether we have a bracket
        //
        pEnd = (LPTSTR)(pszStr + 1);
        pEnd += _tcsspn(pEnd, _T(" \t"));
        if (*pEnd == '(') {
            // global not
            bNot = TRUE;
            pszStr = pEnd;
        } else {
            // local NOT -- so jump to parsing it
            goto ParseStart;
        }
    }

    if (*pszStr == _T('(')) {
        // bracket, we need to find closing one too
        ++pszStr;
        bBracket = TRUE;
    }

ParseStart:

    do {
        dwElement = 0;
        pszStr += _tcsspn(pszStr, _T(" ;,\t"));
        if (*pszStr == _T('\0') || *pszStr == _T(')')) {
            break;
        }

        bNotElement = (*pszStr == _T('!'));

        if (bNotElement) {
            pszStr++;
        }

        // find the end of this token
        pEnd = _tcspbrk(pszStr, _T(" \t;,)"));
        if (pEnd != NULL) {
            chSave = *pEnd;
            *pEnd = _T('\0');
        }

        dwElement = (*pfnGetStringMask)(pszStr);

        if (pEnd) {
            *pEnd = chSave;
        }

        if (dwElement == OS_SKU_NONE) {
            goto HandleError;
        }

        if (bNotElement) {
            dwElement ^= 0xFFFFFFFF;
        }

        dwMask |= dwElement;

        pszStr = pEnd;

    } while (pEnd);  // when pEnd == NULL -- it was the last token

    if (bBracket && (!pszStr || *pszStr != ')')) {
        // we expected a bracket here
        goto HandleError;
    }

    if (bNot) {
        dwMask ^= 0xFFFFFFFF;
    }

    *pdwMask = dwMask;
    bSuccess = TRUE;

HandleError:

    if (!bSuccess) {
        SDBERROR_FORMAT((_T("Failed to decode \"%s\"\n"), pszStr));
    }

    return bSuccess;
}



////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   DecodeRuntimePlatformString
//
//  Desc:   Decodes a list of Platform Strings with flags
//
//  [00]  [00]    [00]   [00]
//    ^   Arch1   Arch2  Arch3
//    |- flags
//
//  syntax for the runtime platform:
//  [!] ( [!] Platform1 [; Platform2 ] ... )
//  example:
//  !(IA64; !X86) - will evaluate to TRUE when it's NOT IA64 (native) and X86
//  (IA3264; X86) - will evaluate to TRUE when it's running on X86 or 32-bit subsystem on IA64
//  (AMD64; IA3264) - will evaluate to TRUE when it's running on AMD64 or 32-bit subsystem on ia64
//


BOOL DecodeRuntimePlatformString(LPCTSTR pszPlatform, LPDWORD pdwRuntimePlatform)
{
    BOOL bNot        = FALSE;
    BOOL bBracket    = FALSE;
    LPTSTR pEnd;
    TCHAR  chSave;
    DWORD  dwElement;
    DWORD  dwNotElementFlag;
    DWORD  dwRuntimePlatform = 0;
    INT    nElement = 0;
    BOOL   bSuccess = FALSE;

    pszPlatform += _tcsspn(pszPlatform, _T(" \t"));
    // got the first char
    if (*pszPlatform == _T('!')) {
        // peek ahead and see whether we have a bracket

        pEnd = (LPTSTR)(pszPlatform + 1);
        pEnd += _tcsspn(pEnd, _T(" \t"));
        if (*pEnd == '(') {
            // global not
            bNot = TRUE;
            pszPlatform = pEnd;
        } else {
            // local NOT -- so jump to parsing it
            goto ParseStart;
        }
    }

    if (*pszPlatform == _T('(')) {
        // bracket, we need to find closing one too
        ++pszPlatform;
        bBracket = TRUE;
    }

ParseStart:

    do {
        dwElement = 0;
        pszPlatform += _tcsspn(pszPlatform, _T(" ;,\t"));
        if (*pszPlatform == _T('\0') || *pszPlatform == _T(')')) {
            break;
        }

        dwNotElementFlag = (*pszPlatform == _T('!')) ? RUNTIME_PLATFORM_FLAG_NOT_ELEMENT : 0;

        // find the end of this token
        pEnd = _tcspbrk(pszPlatform, _T(" \t;,)"));
        if (pEnd != NULL) {
            chSave = *pEnd;
            *pEnd = _T('\0');
        }

        dwElement = GetRuntimePlatformType(pszPlatform);
        if (pEnd) {
            *pEnd = chSave;
        }

        if (dwElement == PROCESSOR_ARCHITECTURE_UNKNOWN) {
            goto HandleError;
        }

        dwElement |= dwNotElementFlag | RUNTIME_PLATFORM_FLAG_VALID;

        if (nElement >= 3) {
            goto HandleError;
        }

        // now shift
        dwElement <<= (nElement * 8);
        ++nElement; // on to the next element
        dwRuntimePlatform |= dwElement;

        pszPlatform = pEnd;

    } while(pEnd);  // when pEnd == NULL -- it was the last token

    if (bBracket && (!pszPlatform || *pszPlatform != ')')) {
        // we expected a bracket here
        goto HandleError;
    }

    if (bNot && nElement > 1) {
        dwRuntimePlatform |= RUNTIME_PLATFORM_FLAG_NOT;
    }

    *pdwRuntimePlatform = dwRuntimePlatform;
    bSuccess = TRUE;

HandleError:

    return bSuccess;

}



////////////////////////////////////////////////////////////////////////////////////
//
//  Func:   ReadName
//
//  Desc:   Wrapper to read the name attribute from an XML node.
//
BOOL ReadName( IXMLDOMNode* pNode, CString* pcsName)
{
    BOOL bSuccess = FALSE;

    if (!GetAttribute(_T("NAME"), pNode, pcsName)) {
        SDBERROR_FORMAT((_T("NAME attribute required:\n%s\n\n"),
                          GetXML(pNode)));
        goto eh;
    }

    bSuccess = TRUE;

eh:

    return TRUE;
}

BOOL ReadLangID(IXMLDOMNode* pNode, SdbDatabase* pDB, CString* pcsLangID)
{
    if (!GetAttribute(_T("LANGID"), pNode, pcsLangID)) {
        if (!pDB->m_csCurrentLangID.GetLength())
        {
            SDBERROR_FORMAT((
                _T("Tag requires LANGID attribute if there is no LANGID on the DATABASE node\n%s\n"),
                GetXML(pNode)));
            return FALSE;
        }

        *pcsLangID = pDB->m_csCurrentLangID;
    }

    return TRUE;
}

BOOL FilterOSVersion(DOUBLE flOSVersion, CString csOSVersionSpec, LPDWORD lpdwSPMask)
{
    DOUBLE  flVerXML;
    CString csTemp;
    long    nBeg, i, nIndSP;
    int     nSPVersion;
    TCHAR   chSP;
    BOOL    bFilter = TRUE;
    DWORD   dwSPMask;

    if (flOSVersion == 0.0 || csOSVersionSpec.IsEmpty()) {
        *lpdwSPMask = 0xFFFFFFFF;
        return FALSE;
    }

    *lpdwSPMask = 0;

    nBeg = 0;

    for (i = 0; i <= csOSVersionSpec.GetLength(); i++) {
        if (csOSVersionSpec.GetAt(i) == _T('\0') || csOSVersionSpec.GetAt(i) == _T(';')) {

            csTemp = csOSVersionSpec.Mid(nBeg, i - nBeg);
            nBeg = i + 1;

            if (csTemp.GetLength() == 0) {
                continue;
            }

            dwSPMask = 0xFFFFFFFF;

            nSPVersion = -1;
            nIndSP = -1;

            if ((nIndSP = csTemp.Find('.')) != -1) {
                if ((nIndSP = csTemp.Find('.', nIndSP + 1)) != -1) {

                    CString csSP = csTemp.Right(csTemp.GetLength() - nIndSP - 1);

                    chSP = csTemp.GetAt(nIndSP);
                    csTemp.SetAt(nIndSP, 0);

                    nSPVersion = _ttoi(csSP);
                }
            }

            if (csTemp.Left(2) == _T("gt")) {
                if (csTemp.Left(3) == _T("gte")) {

                    flVerXML = _tcstod(csTemp.Right(csTemp.GetLength() - 3), NULL);

                    if (flOSVersion >= flVerXML) {
                        bFilter = FALSE;
                    }

                    if (nSPVersion != -1 && flOSVersion == flVerXML) {
                        dwSPMask = 0xFFFFFFFF - (1 << nSPVersion) + 1;
                    }

                } else {

                    flVerXML = _tcstod(csTemp.Right(csTemp.GetLength() - 2), NULL);

                    if (flOSVersion > flVerXML) {
                        bFilter = FALSE;
                    }

                    if (nSPVersion != -1 && flOSVersion == flVerXML) {
                        bFilter = FALSE;
                        dwSPMask = 0xFFFFFFFF - (1 << (nSPVersion + 1)) + 1;
                    }
                }
            } else if (csTemp.Left(2) == _T("lt")) {
                if (csTemp.Left(3) == _T("lte")) {

                    flVerXML = _tcstod(csTemp.Right(csTemp.GetLength() - 3), NULL);

                    if (flOSVersion <= flVerXML) {
                        bFilter = FALSE;
                    }

                    if (nSPVersion != -1 && flOSVersion == flVerXML) {
                        dwSPMask = 0xFFFFFFFF - (1 << (nSPVersion + 1)) + 1;
                        dwSPMask ^= 0xFFFFFFFF;
                    }

                } else {
                    flVerXML = _tcstod(csTemp.Right(csTemp.GetLength() - 2), NULL);

                    if (flOSVersion < flVerXML) {
                        bFilter = FALSE;
                    }

                    if (nSPVersion != -1 && flOSVersion == flVerXML) {
                        bFilter = FALSE;
                        dwSPMask = 0xFFFFFFFF - (1 << nSPVersion) + 1;
                        dwSPMask ^= 0xFFFFFFFF;
                    }
                }
            } else {
                if (flOSVersion == _tcstod(csTemp, NULL)) {
                    bFilter = FALSE;

                    if (nSPVersion != -1) {
                        dwSPMask = (1 << nSPVersion);
                    }
                }
            }

            if (nIndSP != -1) {
                csTemp.SetAt(nIndSP, chSP);
                *lpdwSPMask |= dwSPMask;
            }
        }
    }

    if (*lpdwSPMask == 0) {
        *lpdwSPMask = 0xFFFFFFFF;
    }

    return bFilter;
}


VOID ExpandEnvStrings(CString* pcs)
{
    LPTSTR lpszBuf;
    DWORD cchReqBufSize;
    CString cs(*pcs);

    cchReqBufSize = ExpandEnvironmentStrings(cs, NULL, 0);
    lpszBuf = pcs->GetBuffer(cchReqBufSize);
    ExpandEnvironmentStrings(cs, lpszBuf, cchReqBufSize);
    pcs->ReleaseBuffer();
}

BOOL MakeUTCTime(CString& cs, time_t* pt)
{
    BOOL bSuccess = FALSE;
    CString csTZ;

    //
    // Set TZ environment variable to override locale
    // settings so that date/time conversion routines
    // never do any localizations.
    //
    csTZ = _tgetenv(_T("TZ"));
    csTZ = _T("TZ=") + csTZ;
    _tputenv(_T("TZ=UTC0"));
    _tzset();

    COleDateTime odt;
    SYSTEMTIME st;
    CTime time;

    if (!odt.ParseDateTime(cs)) {
        goto eh;
    }

    if (!odt.GetAsSystemTime(st)) {
        goto eh;
    }

    time = st;

    *pt = time.GetTime();

    bSuccess = TRUE;

eh:
    _tputenv(csTZ);
    _tzset();

    return bSuccess;
}

BOOL ParseLanguageID(LPCTSTR pszLanguage, DWORD* pdwLanguageID)
{
    LPCTSTR pch;
    LPTSTR  pend = NULL;
    BOOL    bSuccess = FALSE;
    BOOL    bBracket = FALSE;
    DWORD   dwLangID = 0;

    pch = _tcschr(pszLanguage, TEXT('['));
    if (NULL != pch) {
        bBracket = TRUE;
        ++pch;
    } else {
        pch = pszLanguage;
    }

    while (_istspace(*pch)) {
        ++pch;
    }

    dwLangID = _tcstoul(pch, &pend, 0);

    if (dwLangID == 0) {
        goto cleanup;
    }

    if (pend != NULL) {
        bSuccess = bBracket ? (_istspace(*pend) || *pend == TEXT(']')) :
                              (_istspace(*pend) || *pend == TEXT('\0'));
    }

cleanup:

    if (bSuccess) {
        *pdwLanguageID = dwLangID;
    }

    return bSuccess;


}

BOOL ParseLanguagesString(CString csLanguages, CStringArray* prgLanguages)
{
    BOOL bSuccess = FALSE, bExistsAlready = FALSE;
    int nLastSemicolon = -1, i, j;
    CString csLangID;

    for (i = 0; i <= csLanguages.GetLength(); i++)
    {
        if (csLanguages[i] == _T(';') || csLanguages[i] == _T('\0')) {
            csLangID = csLanguages.Mid(nLastSemicolon + 1, i - nLastSemicolon - 1);
            csLangID.TrimLeft();
            csLangID.TrimRight();
            csLangID.MakeUpper();
            
            bExistsAlready = FALSE;
            for (j = 0; j < prgLanguages->GetSize(); j++)
            {
                if (prgLanguages->GetAt(j) == csLangID)
                {
                    bExistsAlready = TRUE;
                    break;
                }
            }

            if (!bExistsAlready)
            {
                prgLanguages->Add(csLangID);
            }

            nLastSemicolon = i;
        }
    }

    bSuccess = TRUE;

    return bSuccess;
}

CString GetGUID(REFGUID guid)
{
    CString csRet;
    LPOLESTR lpszGUID = NULL;

    StringFromCLSID(guid, &lpszGUID);

    csRet = lpszGUID;

    CoTaskMemFree(lpszGUID);

    return csRet;
}

CString ProcessShimCmdLine(
    CString& csCommandLine,
    GUID&    guidDB,
    TAGID    tiShimRef
    )
{
    //
    // find whether we have anything to expand in csCommandLine
    //

    LPCTSTR pch;
    int nIndex;
    CString csNewCmdLine = csCommandLine;
    CString csToken;
    int nIndexStart = 0;
    int nIndexEnd;

    while (nIndexStart < csNewCmdLine.GetLength()) {

        nIndex = csNewCmdLine.Find(_T('%'), nIndexStart);
        if (nIndex < 0) {
            goto Done;
        }

        nIndexEnd = csNewCmdLine.Find(_T('%'), nIndex + 1);
        if (nIndexEnd < 0) {
            goto Done;
        }

        //
        // we matched a token, see whether it's something we're interested in
        //
        csToken = csNewCmdLine.Mid(nIndex + 1, nIndexEnd - nIndex - 1);
        if (0 == csToken.CompareNoCase(_T("DBINFO"))) {

            csToken.Format(_T("-d%ls -t0x%lx"), (LPCTSTR)GetGUID(guidDB), tiShimRef);

            //
            // replace the token with csToken
            //
            csNewCmdLine.Delete(nIndex, nIndexEnd - nIndex + 1);
            csNewCmdLine.Insert(nIndex, csToken);

            //
            // adjust our position for scanning
            //
            nIndexEnd = nIndex + csToken.GetLength() - 1; // one char before the end of this token
        }

        nIndexStart = nIndexEnd + 1;
    }


Done:

    return csNewCmdLine;

}