StrFunc.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: String functions.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/StrFunc.h>
#include <uLib/UtilFunc.h>
#include <uLib/RegFunc.h>
#include <uLib/Debug.h>
#include <uLib/_Internal.h>

//==----------------------------------------------------------------------------
//  CharIndex - C version(s)
//==----------------------------------------------------------------------------

INT_PTR CharIndexA( const char* Buffer, const char* Inside )
{
    INT_PTR ix = (Inside - Buffer);
    _ASSERTE( ix >= 0 ); // In case caller messed up...
    return ix;
}

INT_PTR CharIndexW( const wchar_t* Buffer, const wchar_t* Inside )
{
    INT_PTR ix = (Inside - Buffer); // Note, C typed ptr arithmetic!
    _ASSERTE( ix >= 0 ); // In case caller messed up...
    return ix;
}

//==----------------------------------------------------------------------------
// strecpy -- Copy and return a pointer to the terminating null in Dst.
// For concatenation strecpy beats strcat by a mile and a half..
//==----------------------------------------------------------------------------

char* __fastcall strecpy( register char* Dst, register const char* Src )
{
    while( *Src ) *Dst++ = *Src++;
    *Dst = 0;
    return Dst;
    /* Variant 1: String ops, longer prolog/epilog, faster loop
        push    esi
        push    edi
        mov     esi, edx
        mov     edi, ecx
    L1: lodsb
        or      al, al
        stosb
        jnz     L1
        mov     eax, edi
        dec     eax
        pop     edi
        pop     esi
    */
    /* Variant 2: Reg index, shorter prolog/epilog, slower loop
    L1: mov     al, [edx]
        inc     edx
        mov     [ecx], al
        inc     ecx
        or      al, al
        jnz     L1
        mov     eax, ecx
        dec     eax
    */
}

wchar_t* __fastcall wcsecpy( register wchar_t* Dst, register const wchar_t* Src )
{
    while( *Src ) *Dst++ = *Src++;
    *Dst = 0;
    return Dst;
}

// Run-length limited variants

char* __fastcall strnecpy( register char* Dst, register const char* Src, size_t n )
{
    if ( n ) while( *Src && n-- ) *Dst++ = *Src++;
    *Dst = 0; // 'n' was pre-decremented to make sure we can emit this _NUL.
    return Dst;
}

wchar_t* __fastcall wcsnecpy( register wchar_t* Dst, register const wchar_t* Src, size_t n )
{
    if ( n ) while( *Src && n-- ) *Dst++ = *Src++;
    *Dst = 0;
    return Dst;
}

//==----------------------------------------------------------------------------
// stristr - Case insensitive strstr.
// Credits to LefterisE@stackoverflow.com for the neat algorithm !
//==----------------------------------------------------------------------------

char* stristr( const char* str, const char* pattern )
{
    if ( !*pattern ) return (char*) str;
    char* curr = (char*) str;
    while( *curr )
    {
        register char* s = curr;
        register char* pat = (char*) pattern;
        while( *s && *pat && (0 == (tolower(*s)-tolower(*pat))) ) { // Loop while equal
            ++s; ++pat;
            }
        if (!*pat) return curr; // If the whole pattern was consumed, it was found
        ++curr;
    }
    return NULL;
}

wchar_t* wcsistr( const wchar_t* str, const wchar_t* pattern )
{
    if ( !*pattern ) return (wchar_t*) str;
    wchar_t* curr = (wchar_t*) str;
    while( *curr )
    {
        register wchar_t* s = curr;
        register wchar_t* pat = (wchar_t*) pattern;
        while( *s && *pat && (0 == (towlower(*s)-towlower(*pat))) ) { // Loop while equal
            ++s; ++pat;
            }
        if (!*pat) return curr; // If the whole pattern was consumed, it was found
        ++curr;
    }
    return NULL;
}

//==----------------------------------------------------------------------------
// strncpyz - Strncpy with guaranteed nul termination.
//==----------------------------------------------------------------------------

char* __fastcall strncpyz( register char* Dst, register const char* Src, size_t Count )
{
    char* result = Dst;
    while( *Src && --Count ) *Dst++ = *Src++;
    *Dst = 0;
    return result;
}

wchar_t* __fastcall wcsncpyz( register wchar_t* Dst, register const wchar_t* Src, size_t Count )
{
    wchar_t* result = Dst;
    while( *Src && --Count ) *Dst++ = *Src++;
    *Dst = 0;
    return result;
}

//==----------------------------------------------------------------------------
// Nr of bytes (incl.NUL) in wide string.
//==----------------------------------------------------------------------------

size_t wcsbytes( const wchar_t* Src )
{
    return Src ? (1 + wcslen( Src )) * sizeof(WCHAR) : 0;
}

//==----------------------------------------------------------------------------
// String duplicates
//==----------------------------------------------------------------------------

BEGIN_STRSAFE_OVERRIDE

// Note: These set ERROR_OUTOFMEMORY so (internal) callers don't have to..

CSTR newStr( CSTR Src ) // String 'new' duplicate
{
    // Note: Adding space for /two/ NUL terminator TCHARs.
    // The 2nd is so the string can be used as a multi-sz.

    UINT Len = (UINT)_tcslen( Src );
    TSTR Dup = new TCHAR[ Len + 2 ]; // +2 --> 2 NUL chars
    if (!Dup) SetLastError( ERROR_OUTOFMEMORY );
    else
    {
        _tcscpy( Dup, Src );
        Dup[ Len + 1 ] = 0; // The extra NUL
    }
    return Dup;
}

TSTR newStrBuf( WORD nChar ) // 'new' buffer
{
    TSTR pBuf = new TCHAR[ nChar + 2 ]; // +2 --> 2 NUL chars
    if (pBuf) memset( pBuf, 0, (nChar+2)*TCHAR_SIZE );
    else SetLastError( ERROR_OUTOFMEMORY );
    return pBuf;
}

CSTR deleteStr( CSTR Dup ) // Delete 'new' duplicate
{
    #ifndef HAVE_STRUCTURED_EH
    DELETE_ARRAY( Dup );
    #else
    __try { DELETE_ARRAY( Dup ); }
    __except_execute {
        DWORD xCode = GetExceptionCode();
        TRACE( DP_ERROR, _F("Exception %#x.\r\n"), xCode );
        }
    __end_except; // gcc kludge
    #endif
    return Dup; // NULL after successful delete[]
}

WCSTR newWStr( WCSTR Src )
{
    UINT Len = (UINT) wcslen( Src );
    LPWSTR Dup = new WCHAR[ Len + 2 ];
    if (!Dup) SetLastError( ERROR_OUTOFMEMORY );
    else
    {
        memcpy( Dup, Src, (Len + 1) * WCHAR_SIZE );
        Dup[ Len + 1 ] = 0; // The extra NUL
    }
    return Dup;
}

WCSTR deleteWStr( WCSTR Dup )
{
    #ifndef HAVE_STRUCTURED_EH
    DELETE_ARRAY( Dup );
    #else
    __try { DELETE_ARRAY( Dup ); }
    __except_execute {
        DWORD xCode = GetExceptionCode();
        TRACE( DP_ERROR, _F("Exception %#x in operator delete[].\r\n"), xCode );
    }
    __end_except; // gcc kludge
    #endif
    return Dup; // NULL after successful delete[]
}

// Guarantee use of mem_Alloc/mem_Free
// E.g. to satisfy DynArray's default DeleteItem.

ASTR mem_DupAStr( ACSTR Src ) // String 'mem_Alloc' duplicate
{
    UINT Len = (UINT) strlen( Src );
    ASTR Dup = mem_AllocAStr( Len ); // Sets ERROR_OUTOFMEMORY on failure
    if (Dup) strcpy( Dup, Src );

    // Note: Visavi newStr, setting the 2nd NUL here is superfluous,
    // because mem_Alloc zero-fills the allocated memory, and strcpy
    // doesn't touch anything beyond it's NUL terminator.

    return Dup;
}

WSTR mem_DupWStr( WCSTR Src ) // String 'mem_Alloc' duplicate
{
    UINT Len = (UINT) wcslen( Src );
    WSTR Dup = mem_AllocWStr( Len );
    if (Dup) wcscpy( Dup, Src );
    return Dup;
}

ASTR mem_AllocAStr( WORD nChar )
{
    UINT size = nChar + 2; // +2 --> 2 NUL chars
    return (ASTR) mem_Alloc( size );
}

WSTR mem_AllocWStr( WORD nChar )
{
    UINT size = (nChar + 2) * WCHAR_SIZE; // +2 --> 2 NUL chars
    return (WSTR) mem_Alloc( size );
}

CSTR mem_FreeStr( CSTR Dup ) // Delete 'mem_Alloc' duplicate
{
    return (CSTR) mem_Free( PVOID( Dup ));
}

END_STRSAFE_OVERRIDE

//==----------------------------------------------------------------------------
// Unicode to multibyte hand-me-on-the-fly translate (e.g for DPrint()).
//==----------------------------------------------------------------------------

ACSTR _MBStr( WCSTR pwStr )
{
    static CHAR szBuf[ MAX_PATH ];
    WideCharToMultiByte( CP_ACP,0, pwStr,-1, szBuf,MAX_PATH, NULL, NULL );
    return szBuf;
}

// Allocate an ANSI string and translate from wide string, and vice versa.

ASTR mem_ADupWStr( WCSTR pWStr, UINT CodePg, UINT ccExtra )
{
    int len = WideCharToMultiByte( CodePg, 0, pWStr, -1, NULL, 0, NULL, NULL );
    ASTR pDup = mem_AllocAStr( len + ccExtra );
    if (pDup) WideCharToMultiByte( CodePg, 0, pWStr, -1, pDup, len, NULL, NULL );
    return pDup;
}

WSTR mem_WDupAStr( ACSTR pAStr, UINT CodePg, UINT ccExtra )
{
    int len = MultiByteToWideChar( CodePg, MB_PRECOMPOSED, pAStr, -1, NULL, 0 );
    WSTR pDup = mem_AllocWStr( len + ccExtra );
    if (pDup) MultiByteToWideChar( CodePg, MB_PRECOMPOSED, pAStr, -1, pDup, len );
    return pDup;
}

//==----------------------------------------------------------------------------
// LoadStr - Simplified use of LoadString (uses static buffer if none provided)
//==----------------------------------------------------------------------------

CSTR LoadStr( HMODULE hModule, UINT Id, TSTR Buf, UINT Count )
{
    static TCHAR sbuf[ MAX_PATH ];
    if (!Buf)
    {
        Buf = sbuf;
        Count = dimof( sbuf );
    }
    if (!LoadString( hModule, Id, Buf, Count )) Buf[0] = 0;
    return (CSTR) Buf;
}

// Return a read-only pointer directly to the string resource.

WCSTR GetResourceStr( HMODULE hModule, UINT Id, PWORD pCount )
{
    WSTR pwzStr = NULL; // Ptr to string resource.

    // Setting cchBufferMax to zero gives us a pointer to the resource itself.
    // LoadStringW returns zero and an empty string for a nonexistent resource.

    WORD count = LoadStringW( hModule, Id, (WSTR)&pwzStr, 0 );
    if (!count) pwzStr = NULL; // Change empty str to NULL.
    if (pCount) *pCount = count;
    return pwzStr;
}

// FindResourceStrEx - Adapted from (slightly flawed) code by Raymond Chen. Thank You.

WCSTR FindResourceStrEx( HMODULE hModule, UINT Id, LANGID Lang, PWORD pCount )
{
    UINT bundleNr = Id / 16 + 1; // Convert the string ID into a bundle number
    UINT strNr = Id & 15, cbRes; // and string number.
    WCSTR pwzStr = (WCSTR) LoadCustomResourceEx(
        hModule, (CSTR)(UINT_PTR) bundleNr, RT_STRING, Lang, &cbRes
        );
    if (pwzStr) // If we found it, then walk the string table..
    {
        for( UINT i = 0; i < strNr; i++ )
        {
            pwzStr += (1 + (WORD)*pwzStr); // WORD Raymond, not DWORD.
        }
    }
    WORD ccStr = (WORD) *pwzStr++;
    if (pCount) *pCount = ccStr;
    return pwzStr;
}

// Load, allocate, translate, and null terminate a resource string.

CSTR DupResourceStrEx( HMODULE hModule, UINT Id, LANGID Lang, PWORD pCount )
{
    TSTR pzStr = NULL;
    WORD count;
    WCSTR rcStr = FindResourceStrEx( hModule, Id, Lang, &count );
    if (rcStr)
    {
        pzStr = mem_AllocStr( count ); // Transmutable
        if (pzStr) 
        {
          #ifdef _UNICODE
            BEGIN_STRSAFE_OVERRIDE
            wcsncpy( pzStr, rcStr, count );
            END_STRSAFE_OVERRIDE
          #else // Translate to multibyte
            WideCharToMultiByte( CP_ACP, 0, rcStr, count, pzStr, count, NULL, NULL );
          #endif
            pzStr[ count ] = 0;
        }
    }
    return (CSTR)pzStr;
}

CSTR FreeResourceStrEx( CSTR pzRcDupStr )
{
    return (CSTR) mem_FreeStr( (TSTR)pzRcDupStr );
}

//==----------------------------------------------------------------------------
// Multi-string functions.
//==----------------------------------------------------------------------------

UINT EnumerateMultiSzA( ASTR MultiSz, PFnEnumMultiStringA Action, PVOID Context )
{
    ASTR pStr = MultiSz;
    UINT nStr = 0;
    while( *pStr )
    {
        ++nStr;
        // Prescan for next NUL, in case Action inserts extra NUL chars.
        ASTR pEnd = strchr( pStr, 0 );
        if (!Action( pStr, Context )) break; // Invoke caller's function
        pStr = pEnd + 1;
    }
    return nStr;
}

UINT EnumerateMultiSzW( WSTR MultiSz, PFnEnumMultiStringW Action, PVOID Context )
{
    PWSTR pStr = MultiSz;
    UINT nStr = 0;
    while( *pStr )
    {
        ++nStr;
        PWSTR pEnd = wcschr( pStr, 0 ); // Prescan for next NUL.
        if (!Action( pStr, Context )) break; // Invoke caller's function.
        pStr = pEnd + 1;
    }
    return nStr;
}

// Return length of multi-string, in TCHARs, incl final NUL.

UINT MultiSzLengthA( ACSTR MultiSz )
{
    register ACSTR pStr = MultiSz;
    while( *pStr ) pStr = strchr( pStr, 0 ) + 1;
    return UINT( 1 + UINT_PTR( pStr - MultiSz ));
}

UINT MultiSzLengthW( WCSTR MultiSz )
{
    register WCSTR pStr = MultiSz;
    while( *pStr ) pStr = wcschr( pStr, 0 ) + 1;
    return UINT( 1 + UINT_PTR( pStr - MultiSz ));
}

// Return nr of strings in multi-string.

UINT MultiSzCountA( ACSTR MultiSz )
{
    UINT count = 0;
    register ACSTR pStr = MultiSz;
    while( *pStr )
    {
        count++;
        pStr = strchr( pStr, 0 ) + 1;
    }
    return count;
}

UINT MultiSzCountW( WCSTR MultiSz )
{
    UINT count = 0;
    register WCSTR pStr = MultiSz;
    while( *pStr )
    {
        count++;
        pStr = wcschr( pStr, 0 ) + 1;
    }
    return count;
}

// Compact the string by changing CRLF into single LF delimiters.
// The presence of CRLF is assumed already detected.
// Note: This does *not* deal with (God forbid) Mac style CR only.

TSTR MultiCrLfToLf( TSTR pText )
{
    register TSTR pSrc = pText;
    register TSTR pDst = pText;

    while( *pSrc && *pSrc != CR ) {
        pSrc++; // Fast forward past initial text
        }
    pDst = pSrc;
    *pDst++ = LF; // Replace CR with LF
    pSrc += 2;    // Skip past CRLF

    while( *pSrc )
    {
        while( *pSrc && *pSrc != CR )
            *pDst++ = *pSrc++;
        *pDst++ = LF;
        pSrc += 2;
    }
    *pDst = 0;
    return pText;
}

// Replace LFs with NUL in preparation for writing to registry or ini section.
// Optionally return length of multi-string in chars, incl final NUL.

TSTR LinesToMultiSz( TSTR pText, UINT* ccSz )
{
    TSTR pEnd = pText;
    while( *pEnd )
    {
        TSTR pBegin = pEnd; // Preserve ptr in case no LF found
        pEnd = _tcschr( pBegin, LF );
        if (pEnd) *pEnd++ = 0;
        else
        {
            pEnd = _tcschr( pBegin, 0 );
            *++pEnd = 0; // 2nd NUL if last line *don't* have LF end.
        }
    }
    *pEnd++ = 0; // 2nd NUL if last line have LF end.
    if (ccSz) *ccSz = (UINT) CharIndex( pText, pEnd );
    return pText;
}

// Replace NUL delimiters with LF (in multi-sz from e.g. registry or ini section).

TSTR MultiSzToLines( TSTR pText )
{
    TSTR pEnd = pText;
    while( *pEnd )
    {
        pEnd = _tcschr( pEnd,0 );
        *pEnd++ = LF;
    }
    return pText;
}

// Duplicate a multi-string

TSTR DuplicateMultiSz( CSTR pzMulti )
{
    UINT Len = MultiSzLength( pzMulti );
    TSTR pDup = newStrBuf( Len ); // Comply with newStr().
  #ifdef _UNICODE
    Len *= WCHAR_SIZE;
  #endif
    if (pDup) memcpy( pDup, pzMulti, Len );
    return pDup;
}

TSTR FreeMultiSz( TSTR pzMulti )
{
    return (TSTR) deleteStr( pzMulti );
}

//==----------------------------------------------------------------------------

CSTR __cdecl StrFmt( TSTR Buf, UINT ccBuf, CSTR Fmt, ... )
{
    static TCHAR szBuf[ MAX_PATH ];
    va_list va;

    if (!Buf)
    {
        if (ccBuf) Buf = newStrBuf( ccBuf );
        else
        {
            Buf = szBuf;
            ccBuf = dimof(szBuf);
        }
    }
    va_start( va, Fmt );
    _vstprintf_s( Buf, ccBuf, Fmt, va );
    va_end( va );

    return Buf;
}

//++ SplitUncPath ++------------------------------------------------------------

bool SplitUncPath( CSTR UncPath,
    TSTR Svr, UINT ccSvr, TSTR Share, UINT ccShare, TSTR Path, UINT ccPath )
{
    #define _INVALPARM  ERROR_INVALID_PARAMETER // shorthand

    // The UNC path must have at least server and share components.
    // The path component is optional.

    BOOL ok = __ChkOkSetErr( IsString( UncPath ), _INVALPARM );
    if (ok) ok = __ChkOkSetErr( _tcschr( UncPath, COLON ) == NULL, _INVALPARM ); // Exclude DOS paths.
    if (ok) ok = __ChkOkSetErr( !PathIsRelative( UncPath ), _INVALPARM ); // UNC can't be relative.
    if (ok) ok = __ChkOkSetErr( Svr && Share && ccSvr && ccShare, _INVALPARM );
    // There may be more to exclude but that should take care of the brunt of goofs.
    if (ok)
    {
        TCHAR szUncPath[ 80+80+MAX_PATH ]; // cch = 420
        _tcsncpyz( szUncPath, UncPath, dimof(szUncPath) );

        // Find the first char past any prefix (like \\.\).
        size_t offs = _tcsspn( szUncPath, _T("\\?.") );
        CSTR pzServer = &szUncPath[ offs ];
        ok = __ChkOkSetErr( *pzServer, _INVALPARM );
        if (ok)
        {
            ok = (0 != _tcsnicmp( pzServer, _T("UNC\\"), 4 ));
            if (!ok)
            {
                pzServer += 4; // Skip the UNC\ prefix
                ok = __ChkOkSetErr( *pzServer, _INVALPARM );
            }
            if (ok)
            {
                TSTR pzShare = (TSTR)_tcschr( pzServer, BSLASH );
                ok = __ChkOkSetErr( pzShare && *pzShare && *(pzShare+1), _INVALPARM );
                if (ok)
                {
                    *pzShare++ = 0;
                    // Locate an optional path component
                    TSTR pzPath = (TSTR)_tcschr( pzShare, BSLASH );
                    if (pzPath) *pzPath++ = 0;

                    // Validate reciever buffer sizes.

                    size_t svrLen = _tcslen( pzServer );
                    size_t shrLen = _tcslen( pzShare );
                    // Use > since there must be space for terminating NUL as well.
                    ok = (ccSvr > svrLen) && (ccShare > shrLen);
                    bool havePath = (Path && pzPath);
                    if (ok && havePath) ok = (ccPath > _tcslen( pzPath ));

                    if (!ok) SetLastError( ERROR_INSUFFICIENT_BUFFER );
                    else
                    {
                        _tcsncpyz( Svr, pzServer, ccSvr );
                        _tcsncpyz( Share, pzShare, ccShare );
                        if (havePath) _tcsncpyz( Path, pzPath, ccPath );
                    }
                }
            }
        }
    }
    return bool_cast( ok );
    #undef _INVALPARM
}
//++ SplitNetShareName ++------------------------------------------------------------

bool SplitNetShareName(
    IN CSTR ShareName, OUT WSTR Server, UINT ccServer, OUT WSTR Share, UINT ccShare )
{
    TCHAR pzServer[80], pzShare[80];

    // Get Server and Share names suitable for e.g. NetShareGetInfo.

    BOOL ok = SplitUncPath( ShareName, pzServer,80, pzShare,80, NULL,0 );
    if (ok)
    {
      #ifdef _UNICODE
        wcsncpyz( Server, pzServer, ccServer );
        wcsncpyz( Share, pzShare, ccShare );
      #else
        MultiByteToWideChar( CP_ACP, 0, pzServer,-1, Server, ccServer );
        MultiByteToWideChar( CP_ACP, 0, pzShare,-1, Share, ccShare );
      #endif
    }
    return bool_cast( ok );
}


//==----------------------------------------------------------------------------
// Return the root component of a filepath.
// Use the internal __GetRoot but change the param order
// to comply logically with the different id, GetRootOf.

bool GetRootOf( IN CSTR PathName, OUT TSTR Root, UINT ccRoot )
{
    return __GetRoot( Root, ccRoot, PathName );
}

//==----------------------------------------------------------------------------

CSTR WithoutBackslash( CSTR PathName )
{
    static __thread_local TCHAR szPath[ MAX_PATH ];

    CSTR pEnd = _tcschr( PathName, 0 ) - 1;
    if (*pEnd == BSLASH)
    {
        _tcscpy_s( szPath, dimof(szPath), PathName );
        szPath[ pEnd-PathName ] = 0;
        PathName = szPath;
    }
    return PathName;
}

CSTR WithBackslash( CSTR PathName )
{
    static __thread_local TCHAR szPath[ MAX_PATH ];

    TSTR pEnd = _tcschr( (TSTR)PathName, 0 ) - 1;
    if (*pEnd != BSLASH)
    {
        _tcscpy_s( szPath, dimof(szPath), PathName );
        pEnd = &szPath[ pEnd-PathName+1 ];
        *pEnd++ = BSLASH; *pEnd = 0;
        PathName = szPath;
    }
    return PathName;
}

//==----------------------------------------------------------------------------

TSTR ReplaceStrChar( TSTR Str, TCHAR From, TCHAR To, OPTOUT UINT* pCount )
{
    UINT count = 0;
    TSTR pzEnd = Str;
    TSTR pzItem = _tcschr( Str, From );
    while( pzItem )
    {
        count++;
        *pzItem++ = To;
        TSTR pzNext = _tcschr( pzItem, From );
        if (!pzNext) pzEnd = _tcschr( pzItem, 0 );
        pzItem = pzNext;
    }
    if (pCount) *pCount = count;
    return pzEnd; // Return ptr to terminating null
}

//UINT strToInt( TSTR pStr )
//{
//    TSTR end;
//    int radix;
//    if (_tcsnicmp( pStr, _T("0x"), 2 ) == 0) {
//        radix = 16; pStr += 2;
//    } else radix = 10;
//    return strtoul( pStr, &end, radix );
//}

// Wildcard pattern match, including char set matching (i.e [aex-z]).
// MatchPattern is based on an Microsoft SDK sample that I improved.

static const TCHAR _STARTBRACK = _T('[');
static const TCHAR _ENDBRACK   = _T(']');
static const TCHAR _ASTERISK   = _T('*');
static const TCHAR _QUESTMARK  = _T('?');
static const TCHAR _DASH       =_T('-');

static int __cdecl as_is( int ch ) { return ch; }


bool MatchPattern( CSTR String, CSTR Pattern, bool CaseSens )
{
    TCHAR c, p, l;
    int (__cdecl *_getcase)( int ch ) = CaseSens ? as_is : toupper;

    for (;;)
    {
        switch( p = _getcase( *Pattern++ ))
        {
            case 0: // end of pattern
                return *String ? false : true; // if end of string TRUE

            case _ASTERISK:
                while( *String ) // match zero or more char
                {
                    if (MatchPattern( String++, Pattern, CaseSens ))
                        return true;
                }
                return MatchPattern( String, Pattern, CaseSens );

            case _QUESTMARK:
                if (*String++ == 0) // match any one char
                    return false; // except end of string
                break;

            case _STARTBRACK:
                if ( (c = *String++) == 0) // match char set
                    return false; // syntax

                c = _getcase( c );
                l = 0;
                while( p = _getcase( *Pattern++ ))
                {
                    if (p == _ENDBRACK) // if end of char set, then
                        return false; // no match found

                    if (p == _DASH) // check a range of chars?
                    {
                        p = _getcase( *Pattern ); // get high limit of range
                        if (p == 0  ||  p == _ENDBRACK)
                            return false; // syntax

                        if (c >= l  &&  c <= p)
                            break; // if in range, move on
                    }

                    l = p;
                    if (c == p) // if char matches this element
                        break; // move on
                }

                while( p  &&  p != _ENDBRACK ) // got a match in char set
                    p = *Pattern++; // skip to end of set
                break;

            default:
                c = _getcase( *String++ );
                if (c != p) // check for exact char
                    return false; // not a match
                break;
        }
    }
}

//==----------------------------------------------------------------------------
// DeduplicateCharSeparatedText
//==----------------------------------------------------------------------------

#ifndef _UNICODE
// class WordList, which is used as the deduplicator,
// doesn't have a Unicode implementation. At least not yet..

namespace { // internal
struct __textDedupData // internal data..
{
    PWordList list;
    bool      caseSens;
    TCHAR     *pzText, Sep;
    UINT      nParts, nEmitted;
};
} // end internal

static bool __stdcall __addtoWordList( TSTR Str, PVOID pData )
{
    __textDedupData* pdd = (__textDedupData*) pData;

    bool added = pdd->list->AddString( Str, pdd->caseSens );
    UNUSED( added );
    return true;
}

static bool __stdcall __emitTextPart( TSTR partStr, PVOID pData )
{
    __textDedupData* pdd = (__textDedupData*) pData;

    pdd->pzText = _tcsecpy( pdd->pzText, partStr );
    if (++pdd->nEmitted < pdd->nParts) *pdd->pzText++ = pdd->Sep;
    return true;
}

// PONDER: Rewrite DeduplicateCharSepText to /not/ use WordList,
// so as to make it available in Unicode as well,
// or make WordList available in UNICODE too.

UINT DeduplicateCharSepText(
    ASTR Text, CHAR Separator, bool caseSens, bool emitSorted )
{
    UINT Len = (UINT)_tcslen( Text );
    bool endSep = (Text[Len-1] == Separator);
    // (#1) Must have room for a second _NUL char at the end..
    if (!endSep && IsBadWritePtr( &Text[Len+1], TCHAR_SIZE )) // Try to prevent GPF..
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        Len = 0; // Not really.. Just used as error indicator.
    }
    else
    {
        UINT Count; // Convert text in-place into a multi-sz..
        TSTR pzEnd = ReplaceStrChar( Text, Separator, 0, &Count );
        if (!endSep) // If Text did not end with Separator..
        {
            // Note: There's a minute risk that pzEnd might still clobber
            // an innocent char if the caller was careless about the buffer.
            *++pzEnd = 0; // (#1) Add a second null char..
            Count++; // Count the last part.
        }

        WordList partList( Count, Len, 4, 16 ); // Use a WordList as deduplicator.
        __textDedupData dd = { 0,0,0,0,0,0 }; // Passed to EnumerateMultiSz callbacks.

        dd.list = &partList;
        dd.caseSens = caseSens;
        EnumerateMultiSz( Text, __addtoWordList, &dd );
        TRACE( DP_INFO, _F("%lu duplicates removed.\n"), Count - partList.Count );

        if (emitSorted)
        {
            TSTR pzPart = Text;
            for( UINT ix = 0, last = partList.Count-1; ix < partList.Count; ++ix )
            {
                pzPart = _tcsecpy( pzPart, partList.Strings[ ix ]);
                if (ix < last) *pzPart++ = Separator;
            }
        }
        else // Emit in original order by enumerating Storage..
        {
            dd.pzText = Text;
            dd.Sep = Separator;
            dd.nParts = partList.Count;
            EnumerateMultiSz( partList.Storage, __emitTextPart, &dd );
        }
        Len = (UINT)_tcslen( Text );
    }
    return Len;
}
#endif//ndef _UNICODE

//==----------------------------------------------------------------------------
// Prepend or append a string in-place..
//==----------------------------------------------------------------------------

UINT PrependString( TSTR String, UINT ccBuf, TCHAR Sep, CSTR Prolog )
{
    UINT newLen = 0;
    UINT strLen = (UINT)_tcslen( String );
    UINT addLen = (UINT)_tcslen( Prolog );
    UINT sepLen = Sep ? 1 : 0;

    if (strLen + addLen + sepLen + 1 > ccBuf)
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
    else
    {
        UINT cbMove = (strLen + 1) * TCHAR_SIZE;
        memmove( &String[ addLen + sepLen ], String, cbMove );
        if (Sep) String[ addLen ] = Sep;
        memcpy( String, Prolog, addLen * TCHAR_SIZE );
        newLen = strLen + addLen + sepLen;
    }
    return newLen;
}

UINT AppendString( TSTR String, UINT ccBuf, TCHAR Sep, CSTR Epilog )
{
    UINT newLen = 0;
    UINT strLen = (UINT)_tcslen( String );
    UINT addLen = (UINT)_tcslen( Epilog );
    UINT sepLen = Sep ? 1 : 0;

    if (strLen + addLen + sepLen + 1 > ccBuf)
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
    else
    {
        memcpy( &String[ strLen + sepLen ], Epilog, addLen * TCHAR_SIZE );
        if (Sep) String[ strLen ] = Sep;
        newLen = strLen + addLen + sepLen;
    }
    return newLen;
}

//==----------------------------------------------------------------------------
// System compatible string hash
//==----------------------------------------------------------------------------
#ifndef NO_WINTERNAL // UNICODE_STRING

ULONG GetStringHash( WCSTR Str, ULONG Algorithm, bool caseSens ) // preliminary
{
    static NTSTATUS (NTAPI *_RtlHashUnicodeString)(
        const PUNICODE_STRING String, BOOLEAN CaseInSensitive,
        ULONG HashAlgorithm, PULONG HashValue
        );
    UNICODE_STRING us;
    ULONG hash = 0;
    HMODULE hMod = NULL;

    if (!_RtlHashUnicodeString)
    {
        hMod = GetModuleHandleA( "NTDLL" );
        (FARPROC&)_RtlHashUnicodeString = GetProcAddress( hMod, "RtlHashUnicodeString" );
    }

    if (_RtlHashUnicodeString)
    {
        _InitUnicodeString( &us, Str );
        NTSTATUS rc = _RtlHashUnicodeString( &us, !caseSens, Algorithm, &hash );
        if (!NT_SUCCESS( rc ))
        {
            hash = 0;
            SetLastErrorFromNtStatus( rc );
        }
    }
    return hash;
}

#endif//ndef NO_WINTERNAL
//==----------------------------------------------------------------------------
// Hex string
//==----------------------------------------------------------------------------

CSTR HexString( PBYTE data, UINT len, TSTR buf, UINT size, bool dots )
{
    static TCHAR buffer[ MAX_PATH ];
    static CCSTR hex = _T("0123456789ABCDEF");

    // Bit of a hack, this one.. but it's lean and it works.

    TSTR dst;
    UINT bufrem;
    bool usrbuf = (buf != NULL && size != 0);

    if (usrbuf) {
        dst = buf;
        bufrem = size;
    } else {
        dst = buffer;
        bufrem = dimof(buffer);
    }

    if (dots && bufrem < 7) { // 7="XX ...\0"
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return S_BLANK;
    }

    if (dots) bufrem -= 4; // reserve buffer space for "...\0"
    for( *dst=0; len && bufrem; len--, bufrem -= 2 )
    {
        if ((bufrem <= 4) && (len > 1))
        {
            dots = true; // more data...
            break;
        }
        *dst++ = hex[ *data >> 4 ];
        *dst++ = hex[ *data & 0x0F ];
        if (len > 1)
        {
            *dst++ = SPACE;
            bufrem--;
            data++;
        }
    }
    if (dots) for( len=3; len && bufrem > 1; len--, bufrem-- )
        *dst++ = DOT;
    *dst = 0;
    return usrbuf ? buf : buffer;
}

//==----------------------------------------------------------------------------
// Special strings
//==----------------------------------------------------------------------------

static TSTR _scatCh( TSTR ps, TCHAR ch ) { // String concatenate char.
    *ps++ = ch; *ps = 0;
    return ps;
    }

BEGIN_STRSAFE_OVERRIDE //++ These two can't possibly overrun the buffer.

static CCSTR sizePrefix = _T(" kMGTPEZY"); // Prefix of the size suffix (B/iB).

#if 1 // Changed to fpt calc (for consistency w IsoDataSizeStr)
CSTR DataSizeStr( UINT64 Size ) // xxx B(kB,MB,GB,TB,EB,PB)..
{
    static TCHAR sbuf[40]; // Not on stack.
    CSTR pfx; double size = (double) Size;
    for( pfx = sizePrefix; size >= 1000; size /= 1000, pfx++ );

    _stprintf( sbuf, _T("%0.2f %cB"), size, *pfx );
    return sbuf;
}
#else // The legacy integer algorithm..
CSTR DataSizeStr( UINT64 Size ) // xxx B(kB,MB,GB,TB,EB,PB)..
{
    static TCHAR sbuf[40]; // Not on stack.
    CSTR pfx; ULONG frac = 0; static const UINT DIV = 1000;
    for( pfx = sizePrefix; Size >= DIV; frac = Size % DIV, Size /= DIV, pfx++ );

    _stprintf( sbuf, _T("%lu.%lu %cB"), ULONG(Size), frac/100, *pfx );
    return sbuf;
}
#endif

// Note: Explorer is actually showing kiB, but doesn't use the correct 'i' suffix.

#if 1 // FIX: Take the performance hit of floating point calculation..
CSTR IsoDataSizeStr( UINT64 _Size ) // xxx B(kiB,MiB,GiB,TiB,EiB,PiB)..
{
    static TCHAR sbuf[40]; // Not on stack.
    CSTR pfx; double size = (double)_Size;
    for( pfx = sizePrefix; size >= 1024; size /= 1024, pfx++ );

    _stprintf( sbuf, _T("%0.2f %ciB"), size, *pfx );
    return sbuf;
}
#else // BUGBUG: This begets wrong value for peculiar corner case Size arguments.
CSTR IsoDataSizeStr( UINT64 _Size ) // xxx B(kiB,MiB,GiB,TiB,EiB,PiB)..
{
    static TCHAR sbuf[40]; // Not on stack.
    TRACE( DP_WARNING, _F("Size = %llu\n"), _Size );
    CSTR pfx; ULONG frac = 0;

    for( pfx = sizePrefix; Size >= 1024; frac = Size & 0x3FF, Size >>= 10, pfx++ );

    _stprintf( sbuf, _T("%lu.%lu %ciB"), ULONG(_Size), frac/100, *pfx );
    TRACE( DP_WARNING, _F("WTF? IsoSize = %s ??\n"), sbuf );
    return sbuf;
}
#endif

END_STRSAFE_OVERRIDE //--

CSTR FileAttribStr( DWORD Attr )
{
    static TCHAR sbuf[16]; // Not on stack.
    // D|A|H|R|S|C|E|O|P|Z|T
    //   D: Directory
    //   A: Archive
    //   H: Hidden
    //   R: ReadOnly
    //   S: System
    //   C: Compressed
    //   E: Encrypted
    //   O: OffLine
    //   P: ReparsePoint
    //   Z: Sparse
    //   T: Temporary
    TSTR pz = sbuf;
    *pz = 0;
    if (Attr & FILE_ATTRIBUTE_DIRECTORY) pz = _scatCh( pz, _T('D') );
    if (Attr & FILE_ATTRIBUTE_HIDDEN)    pz = _scatCh( pz, _T('H') );
    if (Attr & FILE_ATTRIBUTE_READONLY)  pz = _scatCh( pz, _T('R') );
    if (Attr & FILE_ATTRIBUTE_SYSTEM)    pz = _scatCh( pz, _T('S') );
    if (Attr & FILE_ATTRIBUTE_ARCHIVE)   pz = _scatCh( pz, _T('A') );
    //
    if (Attr & FILE_ATTRIBUTE_COMPRESSED)    pz = _scatCh( pz, _T('C') );
    if (Attr & FILE_ATTRIBUTE_ENCRYPTED)     pz = _scatCh( pz, _T('E') );
    if (Attr & FILE_ATTRIBUTE_OFFLINE)       pz = _scatCh( pz, _T('O') );
    if (Attr & FILE_ATTRIBUTE_REPARSE_POINT) pz = _scatCh( pz, _T('P') );
    if (Attr & FILE_ATTRIBUTE_SPARSE_FILE)   pz = _scatCh( pz, _T('Z') );
    if (Attr & FILE_ATTRIBUTE_TEMPORARY)     pz = _scatCh( pz, _T('T') );
    return sbuf;
}

CSTR FileTimeStr( FILETIME* FTime, CSTR Fmt )
{
    SYSTEMTIME st;
    FileTimeToSystemTime( FTime, &st );
    return SysTimeStr( &st, Fmt );
}

CSTR SysTimeStr( SYSTEMTIME* Time, CSTR Fmt )
{
    static TCHAR sbuf[ 80 ]; // Not on stack.
    struct tm  T;

    sbuf[0] = 0;
    T.tm_sec  = Time->wSecond;
    T.tm_min  = Time->wMinute;
    T.tm_hour = Time->wHour;
    T.tm_mday = Time->wDay;         // day of the month - [1,31]
    T.tm_mon  = Time->wMonth - 1;   // months since January - [0,11]
    T.tm_year = Time->wYear - 1900; // years since 1900
    T.tm_wday = Time->wDayOfWeek;   // days since Sunday - [0,6]
    T.tm_yday = 0;  // ComputeDayNr( T ); // days since January 1 - [0..365]
    T.tm_isdst = 0; // GetDaylightSavings( T, timezone ); // daylight savings time flag

    _tcsftime( sbuf,40, Fmt, &T );
    return sbuf;
}

CSTR FileTypeStr( CSTR FName )
{
    static TCHAR sbuf[ 80 ]; // In data section, not on stack. Mind concurrency!

    bool shInit = ShellFuncInitialized(); // Is shell access already initialized?
    if (!shInit) InitShellFunc();

    SHFILEINFO fi;
    if (SHGetFileInfo( FName, 0, &fi, sizeof(fi), SHGFI_TYPENAME ))
        _tcscpy_s( sbuf, dimof(sbuf), fi.szTypeName );
    else sbuf[0] = 0;

    if (!shInit) DoneShellFunc(); // If it wasn't then revert before returning
    return sbuf;
}

//==----------------------------------------------------------------------------
// EngFormat - Format value with engineering/scientific SI prefix unit.
//==----------------------------------------------------------------------------

CSTR EngFormat( long double Value, BYTE nDecimals, CSTR Unit )
{
    static CCSTR pfix = _T("yzafpnum kMGTPEZY"); // SI Prefix 10^-24 .. 10^24
    static const int midIx = 8; // Whole units, no prefix
    //static CCSTR smallPfix = _T("cd hD");

    // 10^24   yotta   Y
    // 10^21   zetta   Z
    // 10^18   exa     E
    // 10^15   peta    P
    // 10^12   tera    T
    // 10^9    giga    G
    // 10^6    mega    M
    // 10^3    kilo    k
    // #10^2   hekto   h  // not supported
    // #10^1   deka    da // not supported
    // 1                  // unity
    // #10^-1  deci    d  // not supported
    // #10^-2  centi   c  // not supported
    // 10^-3   milli   m
    // 10^-6   micro   µ
    // 10^-9   nano    n
    // 10^-12  pico    p
    // 10^-15  femto   f
    // 10^-18  atto    a
    // 10^-21  zepto   z
    // 10^-24  yocto   y

    static TCHAR sbuf[ 50 ];
    TCHAR pfixCh;
    int   expo;

    Value = EngUnits( Value, &expo ); // In UtilFunc.cpp
    sbuf[0] = 0;
    if (!Unit) Unit = S_BLANK; // Suffix ?

    // MS (and MinGW) CRTL flavor of printf doesn't support 80-bit long double,
    // so we must unfortunately truncate them to a measly 64-bit precision :/

    double val = (double) Value;

    if (expo == 0)
        _stprintf_s( sbuf, dimof(sbuf), _T("%.*f %s"), nDecimals, val, Unit );
    else if (expo < -24 || expo > 24)
        _stprintf_s( sbuf, dimof(sbuf), _T("%.*fe%i %s"), nDecimals, val, expo, Unit );
    else
    {
        pfixCh = pfix[ midIx + (expo/3) ];
        _stprintf_s( sbuf, dimof(sbuf), _T("%.*f %c%s"), nDecimals, val, pfixCh, Unit );
    }
    return sbuf;
}

//==----------------------------------------------------------------------------
//  GUID strings
//==----------------------------------------------------------------------------

// Note that these APIs use static result buffers, so they're not re-entrant.

CSTR GetGUIDString( REFIID riid, TSTR pzBuf, UINT ccBuf ) // GUID
{
    static TCHAR szBuf[ 64 ]; // 39++
    static CCSTR S_GuidFmt = _T("{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}");
    //static CCSTR S_GuidFmt2 = _T("{ %08X, %04X, %04X, { %02X,%02X,%02X,%02X, %02X,%02X,%02X,%02X }}");

    if (!pzBuf)
    {
        pzBuf = szBuf;
        ccBuf = dimof(szBuf);
    }
    _stprintf_s( pzBuf, ccBuf, S_GuidFmt,
        riid.Data1, riid.Data2, riid.Data3, riid.Data4[0], riid.Data4[1],
        riid.Data4[2], riid.Data4[3], riid.Data4[4], riid.Data4[5],
        riid.Data4[6], riid.Data4[7]
        );
    return szBuf;
}

CSTR GetIIDString( REFIID riid, TSTR pzBuf, UINT ccBuf )
{
    static TCHAR szBuf[ 128 ];

    TCHAR regPath[ 64 ];
    CSTR pzGuid = GetGUIDString( riid );
    int len = _stprintf_s( regPath, dimof(regPath), _T("Interface\\%s"), pzGuid );
    UNUSED( len );

    if (!pzBuf)
    {
        pzBuf = szBuf;
        ccBuf = dimof(szBuf);
    }
    *pzBuf = 0;

    TSTR pzDst = _tcsecpy( pzBuf, _T("IID_") );
    ccBuf -= 4; // "IID_"
    LONG cbData = ccBuf;
    #ifdef _UNICODE
    cbData *= sizeof(WCHAR);
    #endif

    bool ok = REG_OK( RegQueryValue( HKEY_CLASSES_ROOT, regPath, pzDst, &cbData ));
    if (!ok) _tcsncpyz( pzBuf, pzGuid, ccBuf ); // Rtn only the GUID string

    return pzBuf;
}

CSTR GetCLSIDString( REFIID riid, TSTR pzBuf, UINT ccBuf )
{
    static TCHAR szBuf[256];
    if (!pzBuf)
    {
        pzBuf = szBuf;
        ccBuf = dimof(szBuf);
    }
    *pzBuf = 0;
    LPOLESTR poStr = NULL;
    HRESULT rc = OleRegGetUserType( riid, USERCLASSTYPE_SHORT, &poStr );
    if (FAILED( rc ) || !poStr)
        GetGUIDString( riid, pzBuf, ccBuf ); //_tcsncpyz( pzBuf, GetGUIDString( riid ), ccBuf );
    else
    {
        TSTR pzDst;
        if (0 == wcsncmp( poStr, L"CLSID_", 6 )) pzDst = pzBuf;
        else
        {
            pzDst = _tcsecpy( pzBuf, _T("CLSID_") );
            ccBuf -= 6; // "CLSID_"
        }
      #ifdef _UNICODE
        wcsncpyz( pzDst, poStr, ccBuf );
      #else
        WideCharToMultiByte( CP_ACP,0, poStr, -1, pzDst, ccBuf, NULL, NULL );
      #endif
    }
    if (poStr) CoTaskMemFree( poStr );
    return pzBuf;
}

CSTR GetCLSIDAppname( REFIID riid, TSTR pzBuf, UINT ccBuf )
{
    static TCHAR szBuf[256];
    if (!pzBuf)
    {
        pzBuf = szBuf;
        ccBuf = dimof(szBuf);
    }
    *pzBuf = 0;
    LPOLESTR poStr = NULL;
    HRESULT rc = OleRegGetUserType( riid, USERCLASSTYPE_APPNAME, &poStr );
    if (FAILED( rc ) || !poStr)
        _tcsncpyz( pzBuf, GetGUIDString( riid ), ccBuf );
    else
    {
      #ifdef _UNICODE
        wcsncpyz( pzBuf, poStr, ccBuf );
      #else
        WideCharToMultiByte( CP_ACP,0, poStr, -1, pzBuf, ccBuf, NULL, NULL );
      #endif
    }
    if (poStr) CoTaskMemFree( poStr );
    return pzBuf;
}

//==----------------------------------------------------------------------------
// UNICODE_STRING support
//==----------------------------------------------------------------------------
#ifndef NO_WINTERNAL // UNICODE_STRING

PUNICODE_STRING _InitUnicodeString( PUNICODE_STRING puStr, PCWSTR pwzSrc )
{
    puStr->Buffer = (PWSTR) pwzSrc;
    if (!pwzSrc) puStr->Length = puStr->MaximumLength = 0;
    else
    {
        puStr->Length = (USHORT) wcslen( pwzSrc ) * sizeof(WCHAR);
        puStr->MaximumLength = puStr->Length + sizeof(WCHAR); // Incl _NUL
    }
    return puStr;
}

PSTRING _InitString( PSTRING pStr, LPCSTR pzSrc )
{
    pStr->Buffer = (LPSTR) pzSrc;
    if (!pzSrc) pStr->Length = pStr->MaximumLength = 0;
    else
    {
        pStr->Length = (USHORT) strlen( pzSrc );
        pStr->MaximumLength = pStr->Length + 1;
    }
    return pStr;
}

PUNICODE_STRING InitPackedUnicodeString( PVOID Buffer, USHORT cbBuffer )
{
    INIT_PACKED_UNICODE_STRING( (PUNICODE_STRING) Buffer, cbBuffer );
    return (PUNICODE_STRING) Buffer;
}

bool SetUnicodeString( PUNICODE_STRING puStr, WCSTR wzSrc )
{
    USHORT cbSrc = (USHORT) wcsbytes( wzSrc ); // Including _NUL
    bool ok = (cbSrc <= puStr->MaximumLength);
    if ( ok )
    {
        puStr->Length = cbSrc - WCHAR_SIZE; // Excluding _NUL
        memcpy( puStr->Buffer, wzSrc, cbSrc );
    }
    return ok;
}

PUNICODE_STRING mem_AllocUniStr( WORD ccStr, PULONG cbAlloc )
{
    UINT cbStr = (ccStr + 2) * WCHAR_SIZE; // 2 extra ch (double _NUL)
    UINT cbBuf = sizeof(UNICODE_STRING) + cbStr;

    PUNICODE_STRING pu = (PUNICODE_STRING) mem_Alloc( cbBuf );
    if ( pu )
    {
        pu->Length = 0; pu->MaximumLength = cbStr;
        pu->Buffer = PWSTR( pu + 1 ); // Note: C typed ptr arithmetic.
    }
    if (cbAlloc) *cbAlloc = cbBuf;
    return pu;
}

#endif//ndef NO_WINTERNAL // UNICODE_STRING
#ifdef __cplusplus

//==----------------------------------------------------------------------------
// UString - UNICODE_STRING class with automatic conversion
//==----------------------------------------------------------------------------
#ifndef NO_WINTERNAL // UNICODE_STRING

UString::UString() : Flags( 0 )
{
    _InitUnicodeString( this, NULL );
}

UString::UString( WCSTR Src ) : Flags( 0 )
{
    MaximumLength = 0;
    Buffer = NULL;
    Set( Src );
}

UString::UString( ACSTR Src ) : Flags( 0 )
{
    MaximumLength = 0;
    Buffer = NULL;
    Set( Src );
}

UString::UString( const UNICODE_STRING& Src ) : Flags( 0 )
{
    MaximumLength = 0;
    Buffer = NULL;
    Set( Src );
}

UString::UString( size_t Len ) : Flags( 0 )
{
    Length = MaximumLength = 0;
    Buffer = NULL;
    _allocBuf( Len );
}

UString::~UString()
{
    _freeBuf();
}

void UString::Set( WCSTR Src )
{
    _freeBuf(); // Wide source don't require a conversion buffer.
    _InitUnicodeString( this, Src );
}

bool UString::Set( ACSTR Src )
{
    Length = Src ? (USHORT) strlen( Src ) : 0;
    bool ok = _allocBuf( Length ); // Ansi source require a conversion buffer.
    if (!ok) Length = 0;
    else if ( Src )
    {
        MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, Src, Length+1, Buffer, Length+1 );
        Length *= sizeof(WCHAR);
    }
    return ok;
}

bool UString::Set( const UNICODE_STRING& Src )
{
    USHORT Len = Src.Length / sizeof(WCHAR);
    USHORT Max = Src.MaximumLength / sizeof(WCHAR);
    bool ok = true; // All but one path in here lead to success.

    if (Src.Buffer[ Len ] != 0) // If not already null terminated...
    {
        if ((Max > Len) && !IsBadWritePtr( Src.Buffer + Len, WCHAR_SIZE ))
        {
            Src.Buffer[ Len ] = 0; // NUL terminate in place
            goto shallow_Copy;
        }
        else // Source buffer is too small for NUL termination
        {
            if (_allocBuf( Len )) // Sets MaximumLength on success
            {
                memcpy( Buffer, Src.Buffer, Src.Length );
                Buffer[ Len ] = 0;
            }
            else // The probability of this is infinitessimally small.
            {
                ok = false;
                TRACE( DP_ERROR, _F("Alloc failed. Target will not be NUL terminated!\n") );
                BREAK();
                goto shallow_Copy;
            }
        }
    }
    else // Source is already NUL terminated
    {
        shallow_Copy: _freeBuf(); // Free internal buffer, if any
        MaximumLength = Src.MaximumLength;
        Buffer = Src.Buffer;
    }
    Length = Src.Length;
    return ok;
}

UString& UString::operator = ( WCSTR Src )
{
    Set( Src );
    return *this;
}

UString& UString::operator = ( ACSTR Src )
{
    Set( Src );
    return *this;
}

UString& UString::operator = ( const UNICODE_STRING& Src )
{
    Set( Src );
    return *this;
}

bool UString::_allocBuf( size_t nChar )
{
    static const size_t _CHUNK = 16;

    size_t nBytes = nChar * sizeof(WCHAR);
    bool ok = ((Flags & UF_OWN_BUFFER) && (MaximumLength > nBytes));
    if (!ok)
    {
        nBytes += sizeof(WCHAR); // Add space for NUL terminator
        MaximumLength = (USHORT) ROUND_UP( nBytes, _CHUNK );
        if (!(Flags & UF_OWN_BUFFER)) Buffer = NULL;

        if (!Buffer) Buffer = (PWSTR) mem_Alloc( MaximumLength );
        else Buffer = (PWSTR) mem_Realloc( Buffer, MaximumLength );

        ok = (Buffer != NULL);
        if (ok) Flags |= UF_OWN_BUFFER;
        else
        {
            Length = MaximumLength = 0;
            Flags &= ~UF_OWN_BUFFER;
        }
    }
    return ok;
}

void UString::_freeBuf()
{
    if ((Flags & UF_OWN_BUFFER) && Buffer) mem_Free( Buffer );
    Length = MaximumLength = 0;
    Flags &= ~UF_OWN_BUFFER;
    Buffer = NULL;
}

#endif//ndef NO_WINTERNAL
//==----------------------------------------------------------------------------
// StringCache
//==----------------------------------------------------------------------------

StringCache::StringCache( UINT InitSize, UINT ChunkSize )
{
    StgUsed = 0;  // Memory amount

    // The defaults used here protect thoughtless callers from themselves,
    // and enssure proper function of the StringCache instance..

    StgChunk = ChunkSize ? ChunkSize : 1024; // Better safe than sorry..
    StgSize = InitSize ? ROUND_UP( InitSize, StgChunk ) : StgChunk;

    Storage = (char*) mem_Alloc( StgSize );
    if (!Storage) StgSize = 0;
}

StringCache::~StringCache()
{
    mem_Free( Storage );
}

void StringCache::Reset()
{
    if (Storage) Storage[ StgUsed = 0 ] = 0; // Hehe.. ;)
}

void StringCache::Free()
{
    Storage = (char*) mem_Free( Storage );
    StgSize = StgUsed = 0;
}

bool StringCache::GrowStorage()
{
    bool ok = false;
    UINT newSize = StgSize + StgChunk;
    #ifdef HAVE_STRUCTURED_EH
    __try {
    #endif
        char* tmp = Storage
            ? (char*) mem_Realloc( Storage, newSize )
            : (char*) mem_Alloc( newSize ); // If repurposed after Free().
        ok = (tmp != NULL);
        if (ok)
        {
            Storage = tmp;
            StgSize = newSize;
        }
        TRACE( DP_DEBUG, _F("[%p] newSize=%li (%s)\n"), Storage, newSize, ok ? "ok":"fail" );
    #ifdef HAVE_STRUCTURED_EH
    } __except_execute {
        DWORD xcode = GetExceptionCode();
        TRACE( DP_DEBUG, _F("[%p] newSize=%li: Exceprion 0x%08x)\n"), Storage, newSize, xcode );
        BREAK();
    }
    __end_except
    #endif
    return ok;
}

char* StringCache::DupStr( char* Str )
{
    UINT len = UINT( 1 + strlen( Str ));
    UINT end = StgUsed + len + 1;
    if (end > StgSize) GrowStorage();

    char* dup = NULL;
    #ifdef HAVE_STRUCTURED_EH
    __try {
    #endif
        dup = &Storage[ StgUsed ];
        memcpy( dup, Str, len );
        // Second multi-sz null is added below..
    #ifdef HAVE_STRUCTURED_EH
    } __except_execute {
        DWORD xcode = GetExceptionCode();
        TRACE( DP_ERROR, _F("Exception 0x%08X\n"), xcode );
        BREAK();
    }
    __end_except
    #endif

    StgUsed += len;
    Storage[ StgUsed ] = 0; // Extra null char (for multi-sz)
    return dup;
}

//---------------------------------------------------------------------------------------
#if 0 // UNDER CONSIDERATION. Initial alphatest passed..

template <typename TCh>
class TStringCache {
public:
    TCh* Storage;  


    TStringCache( UINT InitSize DEF_(4096), UINT ChunkSize DEF_(4096) )
    {
        StgUsed = 0;  // Memory amount

        // The defaults used here protect thoughtless callers from themselves,
        // and enssure proper function of the StringCache instance..

        StgChunk = ChunkSize ? ChunkSize : 1024; // Better safe than sorry..
        StgSize = InitSize ? ROUND_UP( InitSize, StgChunk ) : StgChunk;
        //StgSize *= sizeof(TCh); // No, sizes are already in bytes!

        Storage = (TCh*) mem_Alloc( StgSize );
        if (!Storage) StgSize = 0;
    }

    // TODO: Add ctor for existing multi-sz block, eg. ini section..

    ~TStringCache() 
    {
        mem_Free( Storage );
    }

    TCh* DupStr( TCh* Str ) 
    {
        //UINT len = UINT( 1 + strlen( Str )); // FIXME
        TCh* _pz = Str; while( *_pz != 0 ) _pz++;
        // TODO: Add length constraint..
        UINT nbytes = UINT_PTR(_pz) - UINT_PTR(Str) + sizeof(TCh); // Incl NUL
        UINT end = StgUsed + nbytes;
        if (end > StgSize) GrowStorage();

        TCh* dup = NULL;
        #ifdef HAVE_STRUCTURED_EH
        __try {
        #endif
            dup = &Storage[ StgUsed ];
            memcpy( dup, Str, nbytes ); // Incl NUL
            // Second multi-sz null is added below..
        #ifdef HAVE_STRUCTURED_EH
        } __except_execute {
            DWORD xcode = GetExceptionCode();
            DebugBreak();
            //TRACE( DP_DEBUG, _F("Exception 0x%08X\n"), xcode );
            //BREAK();
        }
        __end_except
        #endif

        StgUsed += nbytes;
        Storage[ StgUsed ] = 0; // Extra null char (for multi-sz)
        return dup;
    }

    void Reset() 
    {
        if (Storage) Storage[ StgUsed = 0 ] = 0; // Hehe.. ;)
    }

    void Free()  
    {
        Storage = (TCh*) mem_Free( Storage );
        StgSize = StgUsed = 0;
    }

    int StorageSize() { return StgSize; }
    int StorageUsed() { return StgUsed; }

protected:
    UINT  StgSize, StgUsed, StgChunk; // Storage size, used, chunk size
    bool  GrowStorage() // Grow the string content block.
    {
        bool ok = false;
        UINT newSize = StgSize + StgChunk;
        #ifdef HAVE_STRUCTURED_EH
        __try {
        #endif
            TCh* tmp = Storage
                ? (TCh*) mem_Realloc( Storage, newSize )
                : (TCh*) mem_Alloc( newSize ); // If repurposed after Free().
            ok = (tmp != NULL);
            if (ok)
            {
                Storage = tmp;
                StgSize = newSize;
            }
            //TRACE( DP_DEBUG, _F("[%p] newSize=%li (%s)\n"), Storage, newSize, ok ? "ok":"fail" );
        #ifdef HAVE_STRUCTURED_EH
        } __except_execute {
            DWORD xcode = GetExceptionCode();
            //TRACE( DP_DEBUG, _F("[%p] newSize=%li: Exceprion 0x%08x)\n"), Storage, newSize, xcode );
            //BREAK();
        }
        __end_except
        #endif
        return ok;
    }
}; // TStringCache
#endif

//==----------------------------------------------------------------------------
// WordList
//==----------------------------------------------------------------------------

WordList::WordList( UINT InitListDim, UINT InitStgSize, UINT ListGrowBy, UINT StgGrowBy )
: StringCache( InitStgSize, StgGrowBy )
{
    Count = 0;
    ListChunk = ListGrowBy ? ListGrowBy : 32; // Better safe than sorry
    Dim = InitListDim ? ROUND_UP( InitListDim, ListChunk ) : ListChunk;
    Strings = (char**) mem_Alloc( Dim * sizeof(char*) );
    if (!Strings) Dim = 0;
}

WordList::~WordList()
{
    mem_Free( Strings );
}

void WordList::Reset()
{
    Count = 0;
    StringCache::Reset();
}

void WordList::Free()
{
    StringCache::Free();
    Strings = (char**) mem_Free( Strings );
    Dim = Count = 0;
}

bool WordList::Grow()
{
    int newDim = Dim + ListChunk;
    int newSize = newDim * sizeof(char*);
    char** tmp = Strings
        ? (char**) mem_Realloc( Strings, newSize )
        : (char**) mem_Alloc( newSize );
    bool ok = (tmp != NULL);
    if (ok)
    {
        Strings = tmp;
        Dim = newDim;
    }
    TRACE( DP_DEBUG, _F("[%p] newSize=%li(%li) (%s)\n"), Strings, newSize, newDim, ok ? "ok":"fail" );
    return ok;
}

bool WordList::AddString( char* Str, bool caseSens )
{
    bool added = false;
    UINT cbMove;

    int (*cmpfunc)( const char *string1, const char *string2 );
    cmpfunc = caseSens ? strcmp : _stricmp;

    // Iterative binary search...

    int l = 0, r = Count-1, m = 0, cmp = 0;
    while( l <= r )
    {
        m = l + (r - l) / 2;
        cmp = cmpfunc( Str, Strings[ m ]);
        if (cmp == 0) // Don't add, it's already there.
        {
            TRACE( DP_DEBUG, _F("Skip duplicate: %s\n"), Str );
           #if defined(__GNUC__)
            return false;
           #else
            goto add_Done;
           #endif
        }
        else if (cmp > 0) l = m + 1;
        else r = m - 1;
    }

    // Not found...

    #ifdef HAVE_STRUCTURED_EH
    __try {
    #endif
        if (cmp > 0) m++; // Compute where it would have been if it existed.
        if (Count == Dim) Grow(); // If list is full, grow it.

        cbMove = (Count - m) * sizeof(char*);
        if (cbMove) memmove( &Strings[ m + 1 ], &Strings[ m ], cbMove ); // Make a hole..

        // Insert new cache item in sorted order.
        // Relocate the previous Strings if Storage changed due to realloc.

        INT_PTR preDup = (INT_PTR) Storage;
        Strings[ m ] = StringCache::DupStr( Str ); // Cache it
        INT_PTR offset = INT_PTR(Storage) - preDup;
        if (offset)
        {
            // Relocate preexisting string ptrs if the Storage block changed
            // address during a GrowStorage call in DupStr. Use the offset
            // between old and new Storage block to adjust the Strings pointers.

            for( UINT ix=0; ix <= Count; ix++ )
            {
                if (ix == UINT(m)) continue; // Dont clobber the present insert
                LITERAL( INT_PTR, Strings[ix] ) += offset; // Adjust string ptr
            }
        }

        added = true;
        Count++;
    #ifdef HAVE_STRUCTURED_EH
    } __except_execute {
        DWORD xcode = GetExceptionCode();
        TRACE( DP_ERROR, _F("Exception 0x%08X\n"), xcode );
        BREAK();
    }
    __end_except
    #endif
add_Done:
    return added;
}

char* WordList::Search( char* Key,
    int (__stdcall *Compare)( char* Key, char* Str, void* Ctx ),
    void* Context )
{
    char* item = NULL;

    // Iterative binary search...

    int l = 0, m = 0, r = Count-1, cmp = 0;
    while( l <= r )
    {
        m = l + (r - l) / 2;
        cmp = Compare( Key, Strings[ m ], Context );
        if (cmp == 0) // If found
        {
            item = Strings[ m ];
            break;
        }
        else if (cmp > 0) l = m + 1;
        else r = m - 1;
    }

    return item;
}

//==----------------------------------------------------------------------------
#endif//def __cplusplus
// EOF