chstring.cpp

Go to the documentation of this file.

/*
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         ReactOS system libraries
 * FILE:            dll/win32/framedyn/chstring.cpp
 * PURPOSE:         CHString class implementation
 * PROGRAMMERS:     Pierre Schweitzer (pierre@reactos.org)
 *
 * NOTE:            This implementation is BROKEN on PURPOSE
 *                  The CHString is a mix between std::string and
 *                  UNICODE_STRING. It appears that basically it takes only
 *                  the worse from both approaches.
 *                  I've copied the behavior and implementation of Windows 2k3 even if
 *                  it implies unsafe, wrong or unefficient methods.
 *                  Note that the string at m_pchData might not be null terminated!
 *                  Also, important note, two (or even more) CHString instances might
 *                  have the same m_pchData object! Never forget that while modifying
 *                  a string. You might be modifying the string for everyone.
 *                  This is why a protected method is being used in the code: CopyBeforeWrite
 *                  It copies source first, to ensure we only modify current string
 *                  Side note, all the sizes are actually a number of chars. Only the size
 *                  for implementation is the number of bytes
 *                  Now, you know why this class is deprecated and shouldn't be used
 */
 
/* INCLUDES ******************************************************************/
 
#include <chstring.h>
#define NDEBUG
#include <debug.h>
 
/* PRIVATE FUNCTIONS *********************************************************/
 
// This is the empty string that defaults strings without text
// This is unsafe. This string show be LPCWSTR
// However we have to assign it to LPWSTR var. So, let's ignore about const,
// as MS does. Normally we check in our code that we don't overwrite this string.
CHSTRING_WCHAR afxPchNil[1] = {0};
// This is the data that are matching the null string upper
CHStringData afxNullData = {0, 0, 0};
// Exception we may throw in case of allocation failure
CHeap_Exception HeapException(CHeap_Exception::E_ALLOCATION_ERROR);
 
// Our own delete operator
// It is here basically because MS guys don't known about set_new_handler()
// See operator new
void operator delete(void* ptr)
{
    // In Windows 2k3, they check for ptr being null.
    // ISO, POSIX and even MSDN explains that it is allowed
    // to call free with NULL pointer...
    if (ptr)
    {
        free(ptr);
    }
}
 
// Implement our own new operator so that we can throw our own exception in case
// of allocation failure.
// It could have been done using set_new_handler(), but well. MS guys didn't do it
// that way. So, let's mimic.
void* operator new(size_t uSize)
{
    void* Buffer;
 
    Buffer = malloc(uSize);
    if (!Buffer)
    {
        throw HeapException;
    }
 
    return Buffer;
}
 
// This is a char to wchar string conversion helper
int mbstowcsz(LPWSTR lpDest, LPCSTR lpSrc, int nLen)
{
    int Conv;
 
    // If we have nothing to convert or if output doesn't exist, return
    if (nLen == 0 || lpDest == 0)
    {
        return 0;
    }
 
    // Then, simply convert
    Conv = MultiByteToWideChar(CP_ACP, 0, lpSrc, -1, lpDest, nLen);
    // In case of conversion success, null terminate the string
    if (Conv != 0)
    {
        lpDest[nLen] = 0;
    }
 
    return Conv;
}
 
/* PUBLIC FUNCTIONS **********************************************************/
 
/*
 * @implemented
 */
CHString::CHString()
{
    // Set to empty string
    m_pchData = afxPchNil;
}
 
/*
 * @implemented
 */
CHString::CHString(CHSTRING_WCHAR ch, int nRepeat)
{
    // Allow null initialize, in case something goes wrong
    m_pchData = afxPchNil;
 
    // If we have a char to insert
    if (nRepeat >= 1)
    {
        // Allocate a buffer big enough
        AllocBuffer(nRepeat);
        // And if possible, repeat char
        if (m_pchData)
        {
            for (int i = 0; i < nRepeat; ++i)
            {
                m_pchData[i] = ch;
            }
        }
    }
}
 
/*
 * @implemented
 */
CHString::CHString(CHSTRING_LPCWSTR lpsz)
{
    // Allow null initialize, in case something goes wrong
    m_pchData = afxPchNil;
 
    // If we have an input string
    if (lpsz != 0)
    {
        // Get its length
        int Len = SafeStrlen(lpsz);
        // Then, allocate a big enough buffer and copy string
        // Note that here, we don't null terminate the string...
        if (Len)
        {
            AllocBuffer(Len);
            wcsncpy(reinterpret_cast<LPWSTR>(m_pchData),
                    reinterpret_cast<LPCWSTR>(lpsz),
                    Len);
        }
    }
}
 
/*
 * @implemented
 */
CHString::CHString(CHSTRING_LPCWSTR lpch, int nLength)
{
    // Allow null initialize, in case something goes wrong
    m_pchData = afxPchNil;
 
    // In case we have a string with a len
    if (lpch != 0 && nLength != 0)
    {
        // Just copy the string
        AllocBuffer(nLength);
        wcsncpy(reinterpret_cast<LPWSTR>(m_pchData),
                reinterpret_cast<LPCWSTR>(lpch),
                nLength);
    }
}
 
/*
 * @implemented
 */
CHString::CHString(LPCSTR lpsz)
{
    // Allow null initialize, in case something goes wrong
    m_pchData = afxPchNil;
 
    // If we have input string
    if (lpsz != 0)
    {
        // Get its length
        int Len = (int)strlen(lpsz);
        if (Len)
        {
            // Allocate and convert the string
            AllocBuffer(Len);
            mbstowcsz(reinterpret_cast<LPWSTR>(m_pchData), lpsz, Len + 1);
            // Releasing buffer here is to allow to
            // update the buffer size. We notify we're
            // done with changing the string: recompute its
            // length, please
            ReleaseBuffer();
        }
    }
}
 
/*
 * @implemented
 */
CHString::CHString(const unsigned char* lpsz)
{
    // Null init
    Init();
    // And call operator= with const char*, easier
    *this = (LPCSTR)lpsz;
}
 
/*
 * @implemented
 */
CHString::CHString(const CHString& stringSrc)
{
    // If we have currently no referenced string
    if (stringSrc.GetData()->nRefs < 0)
    {
        // Ensure we have the null string
        m_pchData = afxPchNil;
        // And then call, the copy operator with input string
        *this = stringSrc.m_pchData;
    }
    else
    {
        // Otherwise, just copy the input string
        m_pchData = stringSrc.m_pchData;
        // And increment the number of references
        InterlockedIncrement(&GetData()->nRefs);
        // The whole point here is: Am I forget to release the old
        // data?! MS doesn't release it, but I guess we should...
    }
}
 
/*
 * @implemented
 */
CHString::~CHString()
{
    // If we have a string
    if (GetData() != &afxNullData)
    {
        // Check whether it's still in use after we release it
        if (InterlockedDecrement(&GetData()->nRefs) == 0)
        {
            // If so, delete it
            delete GetData();
        }
    }
}
 
/*
 * @implemented
 */
void CHString::AllocBeforeWrite(int nLen)
{
    // In case we have several strings pointing to our memory zone
    // Or we need bigger buffer than actual
    if (GetData()->nRefs > 1 || nLen > GetData()->nAllocLength)
    {
        // Just drop current
        // And allocate a new one which is big enough
        Release();
        AllocBuffer(nLen);
    }
}
 
/*
 * @implemented
 */
void CHString::AllocBuffer(int nSize)
{
    // Here we have to allocate a buffer for the string
    // It actually consists in: CHStringData structure
    // with a buffer big enough at its end to store the
    // string.
    CHStringData* Data;
 
    // Null size is easy allocation
    if (nSize == 0)
    {
        m_pchData = afxPchNil;
        return;
    }
 
    // We cannot allow negative sizes
    if (nSize < 0)
    {
        RaiseException(ERROR_INVALID_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, 0);
    }
 
    // Nor too big
    if (nSize > (INT_MAX - (int)sizeof(CHStringData)) / (int)sizeof(WCHAR))
    {
        RaiseException(STATUS_INTEGER_OVERFLOW, EXCEPTION_NONCONTINUABLE, 0, 0);
    }
 
    // Just allocate big enough buffer, using our own operator new
    Data = (CHStringData *)operator new(nSize * sizeof(WCHAR) + sizeof(CHStringData));
    // In case Data is null, throw an exception
    // Yes, this is stupid! Our operator new is already supposed to through an exception...
    // Thanks MS
    if (!Data)
    {
        throw HeapException;
    }
 
    Data->nRefs = 1;
    Data->nDataLength = nSize;
    Data->nAllocLength = nSize;
    Data->data()[0] = 0;
 
    // We only return the string
    // We can find back data with some mathematics
    m_pchData = Data->data();
}
 
/*
 * @implemented
 */
void CHString::AllocCopy(CHString& dest, int nCopyLen, int nCopyIndex, int nExtraLen) const
{
    // Once again, we cannot deal with negative lens
    if (nCopyLen < 0)
    {
        RaiseException(ERROR_INVALID_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, 0);
    }
 
    if (nCopyIndex < 0)
    {
        RaiseException(ERROR_INVALID_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, 0);
    }
 
    if (nExtraLen < 0)
    {
        RaiseException(ERROR_INVALID_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, 0);
    }
 
    // In case what we have to copy is null-sized, just set empty string
    if (nCopyLen + nExtraLen == 0)
    {
        dest.m_pchData = afxPchNil;
        return;
    }
 
    // Otherwise, allocate a buffer in new string which is big enough
    // You can note that we absolutely don't check about any existing
    // (referenced) buffer in dest. Actually, dest is to be EMPTY string.
    // The whole point of this function is to initialize a virgin string by
    // copying data from another. This is needed by Left/Mid/Right
    dest.AllocBuffer(nCopyLen + nExtraLen);
    // And copy our stuff in
    wcsncpy(reinterpret_cast<LPWSTR>(dest.m_pchData),
            reinterpret_cast<LPWSTR>(m_pchData + nCopyIndex),
            nCopyLen);
}
 
/*
 * @implemented
 */
CHSTRING_LPWSTR CHString::AllocSysString() const
{
    BSTR SysString;
 
    // Just allocate the string
    SysString = SysAllocStringLen(reinterpret_cast<LPWSTR>(m_pchData), GetData()->nDataLength);
    if (!SysString)
    {
        throw HeapException;
    }
 
    return reinterpret_cast<CHSTRING_LPWSTR>(SysString);
}
 
/*
 * @implemented
 */
void CHString::AssignCopy(int nSrcLen, CHSTRING_LPCWSTR lpszSrcData)
{
    // Don't allow negative len
    if (nSrcLen < 0)
    {
        RaiseException(ERROR_INVALID_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, 0);
    }
 
    // We will have to modify a string that might be shared, so duplicate it
    // Ensuring it's big enough to contain our new stuff
    AllocBeforeWrite(nSrcLen);
    if (nSrcLen == 0)
    {
        Release();
        return;
    }
 
    // Just copy, write down new size, and ensure it's null terminated
    wcsncpy(reinterpret_cast<LPWSTR>(m_pchData),
            reinterpret_cast<LPCWSTR>(lpszSrcData), nSrcLen);
    GetData()->nDataLength = nSrcLen;
    m_pchData[nSrcLen] = 0;
}
 
/*
 * @implemented
 */
int CHString::Collate(CHSTRING_LPCWSTR lpsz) const
{
    // Just call the deprecated function here - no matter we are null terminated
    // Did you read my statement about how safe is this implementation?
    return wcscoll(reinterpret_cast<LPCWSTR>(m_pchData), reinterpret_cast<LPCWSTR>(lpsz));
}
 
/*
 * @implemented
 */
int CHString::Compare(CHSTRING_LPCWSTR lpsz) const
{
    // Just call the deprecated function here - no matter we are null terminated
    // Did you read my statement about how safe is this implementation?
    return wcscmp(reinterpret_cast<LPCWSTR>(m_pchData), reinterpret_cast<LPCWSTR>(lpsz));
}
 
/*
 * @implemented
 */
int CHString::CompareNoCase(CHSTRING_LPCWSTR lpsz) const
{
    // Just call the deprecated function here - no matter we are null terminated
    // Did you read my statement about how safe is this implementation?
    return wcsicmp(reinterpret_cast<LPCWSTR>(m_pchData), reinterpret_cast<LPCWSTR>(lpsz));
}
 
/*
 * @implemented
 */
void CHString::ConcatInPlace(int nSrcLen, CHSTRING_LPCWSTR lpszSrcData)
{
    // With null length, there's not that much to concat...
    if (nSrcLen == 0)
    {
        return;
    }
 
    // Still no negative length
    if (nSrcLen < 0)
    {
        RaiseException(ERROR_INVALID_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, 0);
    }
 
    // Ensure we wouldn't overflow with the concat
    if (GetData()->nDataLength > INT_MAX - nSrcLen)
    {
        RaiseException(STATUS_INTEGER_OVERFLOW, EXCEPTION_NONCONTINUABLE, 0, 0);
    }
 
    // In case we have to modify a shared string OR if it can't fit into current buffer...
    if (GetData()->nRefs > 1 || GetData()->nDataLength + nSrcLen > GetData()->nAllocLength)
    {
        // Allocate a new buffer! (without forgetting to release old one)
        CHStringData* OldData = GetData();
 
        // You remember about "InPlace" in the function's name?
        // The cake is a lie
        ConcatCopy(GetData()->nDataLength, m_pchData, nSrcLen, lpszSrcData);
        Release(OldData);
    }
    else
    {
        // Ensure we don't overflow
        if (nSrcLen > INT_MAX - GetData()->nDataLength)
        {
            RaiseException(STATUS_INTEGER_OVERFLOW, EXCEPTION_NONCONTINUABLE, 0, 0);
        }
 
        // Then, just copy and null terminate
        wcsncpy(reinterpret_cast<LPWSTR>(m_pchData + GetData()->nDataLength),
                reinterpret_cast<LPCWSTR>(lpszSrcData),
                nSrcLen);
        GetData()->nDataLength += nSrcLen;
        m_pchData[GetData()->nDataLength] = 0;
    }
}
 
/*
 * @implemented
 */
void CHString::ConcatCopy(
    int nSrc1Len, CHSTRING_LPCWSTR lpszSrc1Data,
    int nSrc2Len, CHSTRING_LPCWSTR lpszSrc2Data)
{
    int TotalLen;
 
    if (nSrc1Len < 0 || nSrc2Len < 0)
    {
        RaiseException(ERROR_INVALID_PARAMETER, EXCEPTION_NONCONTINUABLE, 0, 0);
    }
 
    // If both len are null, do nothing
    TotalLen = nSrc1Len + nSrc2Len;
    if (TotalLen == 0)
    {
        return;
    }
 
    // Otherwise, allocate a new buffer to hold everything (caller will release previous buffer)
    AllocBuffer(TotalLen);
    // And concat stuff
    wcsncpy(reinterpret_cast<LPWSTR>(m_pchData),
            reinterpret_cast<LPCWSTR>(lpszSrc1Data),
            nSrc1Len);
    wcsncpy(reinterpret_cast<LPWSTR>(m_pchData + nSrc1Len),
            reinterpret_cast<LPCWSTR>(lpszSrc2Data),
            nSrc2Len);
}
 
/*
 * @implemented
 */
void CHString::CopyBeforeWrite()
{
    CHStringData* Data;
 
    // First, we need to get reference count
    // And we also need to save Data for later copy
    Data = GetData();
 
    if (Data->nRefs <= 1)
    {
        // If its not used, don't waste time to realloc, it will do the job
        return;
    }
 
    // Release current data - we are sure it won't be freed upon that point
    // Thanks to the reference count check previously done
    Release();
    // Alloc new buffer and copy old data in it
    AllocBuffer(Data->nDataLength);
    wcsncpy(reinterpret_cast<LPWSTR>(m_pchData),
            reinterpret_cast<LPCWSTR>(Data->data()),
            Data->nDataLength);
}
 
/*
 * @implemented
 */
void CHString::Empty()
{
    // Already empty
    if (GetData()->nDataLength == 0)
    {
        return;
    }
 
    // Empty it easily given it's reference count
    if (GetData()->nRefs < 0)
    {
        *this = afxPchNil;
    }
    else
    {
        // Otherwise, just release it
        // It will set back this instance to afxPchNil
        // while decreasing reference count
        Release();
    }
}
 
/*
 * @implemented
 */
int CHString::Find(CHSTRING_WCHAR ch) const
{
    CHSTRING_LPCWSTR Found;
 
    // Let's use appropriate helper
    Found = reinterpret_cast<CHSTRING_LPCWSTR>(wcschr(reinterpret_cast<LPCWSTR>(m_pchData), ch));
    // We have to return a position, so compute it
    if (Found)
    {
        return (Found - m_pchData);
    }
 
    // Otherwise, return no position
    return -1;
}
 
/*
 * @implemented
 */
int CHString::Find(CHSTRING_LPCWSTR lpszSub) const
{
    CHSTRING_LPCWSTR Found;
 
    // Let's use appropriate helper
    Found = reinterpret_cast<CHSTRING_LPCWSTR>(wcsstr(reinterpret_cast<LPCWSTR>(m_pchData), reinterpret_cast<LPCWSTR>(lpszSub)));
    // We have to return a position, so compute it
    if (Found)
    {
        return (Found - m_pchData);
    }
 
    // Otherwise, return no position
    return -1;
}
 
/*
 * @implemented
 */
int CHString::FindOneOf(CHSTRING_LPCWSTR lpszCharSet) const
{
    CHSTRING_LPCWSTR Found;
 
    // Let's use appropriate helper
    Found = reinterpret_cast<CHSTRING_LPCWSTR>(wcspbrk(reinterpret_cast<LPCWSTR>(m_pchData), reinterpret_cast<LPCWSTR>(lpszCharSet)));
    // We have to return a position, so compute it
    if (Found)
    {
        return (Found - m_pchData);
    }
 
    // Otherwise, return no position
    return -1;
}
 
/*
 * @implemented
 */
void CHString::Format(UINT nFormatID, ...)
{
    // Deprecated and not implemented any longer - well, this is its implementation
    return;
}
 
/*
 * @implemented
 */
void CHString::Format(CHSTRING_LPCWSTR lpszFormat, ...)
{
    // Forward to FormatV
    va_list ArgsList;
 
    va_start(ArgsList, lpszFormat);
    FormatV(lpszFormat, ArgsList);
    va_end(ArgsList);
}
 
/*
 * @implemented
 */
void CHString::FormatMessageW(UINT nFormatID, ...)
{
    // Deprecated and not implemented any longer - well, this is its implementation
    return;
}
 
/*
 * @unimplemented
 */
void CHString::FormatMessageW(CHSTRING_LPCWSTR lpszFormat, ...)
{
    UNIMPLEMENTED;
}
 
/*
 * @unimplemented
 */
void CHString::FormatV(CHSTRING_LPCWSTR lpszFormat, va_list argList)
{
    UNIMPLEMENTED;
}
 
/*
 * @implemented
 */
void CHString::FreeExtra()
{
    CHStringData* OldData;
 
    // No extra? Do nothing
    if (GetData()->nDataLength == GetData()->nAllocLength)
    {
        return;
    }
 
    // Get old buffer
    OldData = GetData();
    // Allocate a new one, at the right size (with no place for \0 :-))
    AllocBuffer(GetData()->nDataLength);
    // Copy old and release it
    wcsncpy(reinterpret_cast<LPWSTR>(m_pchData), reinterpret_cast<LPCWSTR>(OldData->data()), OldData->nDataLength);
    Release(OldData);
}
 
/*
 * @implemented
 */
int CHString::GetAllocLength() const
{
    return GetData()->nAllocLength;
}
 
/*
 * @implemented
 */
CHSTRING_WCHAR CHString::GetAt(int nIndex) const
{
    // It's up to you to check the index!
    return m_pchData[nIndex];
}
 
/*
 * @implemented
 */
CHSTRING_LPWSTR CHString::GetBuffer(int nMinBufLength)
{
    CHSTRING_LPWSTR OldBuffer = m_pchData;
 
    // We'll have to allocate a new buffer if it's not big enough
    // or if it's shared by several strings
    if (GetData()->nRefs > 1 || GetData()->nAllocLength < nMinBufLength)
    {
        CHStringData* OldData = GetData();
        int OldLen = GetData()->nDataLength;
 
        // Ensure we can hold enough
        if (OldLen > nMinBufLength)
        {
            nMinBufLength = OldLen;
        }
 
        // Allocate new buffer
        AllocBuffer(nMinBufLength);
        // Copy contents
        wcsncpy(reinterpret_cast<LPWSTR>(m_pchData), reinterpret_cast<LPCWSTR>(OldBuffer), OldLen);
        GetData()->nDataLength = OldLen;
 
        // Release old
        Release(OldData);
    }
 
    // Weirdly, here Windows always returns the old buffer
    // Which basically exposes a wrong buffer
    return OldBuffer;
}
 
/*
 * @implemented
 */
CHSTRING_LPWSTR CHString::GetBufferSetLength(int nNewLength)
{
    // Get a buffer big enough
    // We don't care about the return, it will be set in the string
    (void)GetBuffer(nNewLength);
    // Set length, null-terminate and return
    GetData()->nDataLength = nNewLength;
    m_pchData[nNewLength] = 0;
    return m_pchData;
}
 
/*
 * @implemented
 */
CHStringData* CHString::GetData() const
{
    // In case of empty string, return empty data
    if (m_pchData == afxPchNil)
    {
        return &afxNullData;
    }
 
    // Otherwise, do maths
    return (CHStringData*)((ULONG_PTR)m_pchData - sizeof(CHStringData));
}
 
/*
 * @implemented
 */
int CHString::GetLength() const
{
    return GetData()->nDataLength;
}
 
/*
 * @implemented
 */
void CHString::Init()
{
    m_pchData = afxPchNil;
}
 
/*
 * @implemented
 */
BOOL CHString::IsEmpty() const
{
    return (GetData()->nDataLength == 0);
}
 
/*
 * @implemented
 */
CHString CHString::Left(int nCount) const
{
    CHString NewString;
 
    // Validate input (we can't get more than what we have ;-))
    if (nCount)
    {
        if (nCount > GetData()->nDataLength)
        {
            nCount = GetData()->nDataLength;
        }
    }
 
    AllocCopy(NewString, nCount, 0, 0);
 
    return NewString;
}
 
/*
 * @implemented
 */
int CHString::LoadStringW(UINT nID)
{
    // Deprecated and not implemented any longer - well, this is its implementation
    return 0;
}
 
/*
 * @implemented
 */
int CHString::LoadStringW(UINT nID, CHSTRING_LPWSTR lpszBuf, UINT nMaxBuf)
{
    // Deprecated and not implemented any longer - well, this is its implementation
    return 0;
}
 
/*
 * @implemented
 */
CHSTRING_LPWSTR CHString::LockBuffer()
{
    CHSTRING_LPWSTR LockedBuffer;
 
    // The purpose here is basically to set the nRefs to max int
    LockedBuffer = GetBuffer(0);
    GetData()->nRefs = INT_MAX;
 
    return LockedBuffer;
}
 
/*
 * @implemented
 */
void CHString::MakeLower()
{
    // We'll modify string, duplicate it first if needed
    CopyBeforeWrite();
 
    // Let's use appropriate helper
    _wcslwr(reinterpret_cast<LPWSTR>(m_pchData));
}
 
/*
 * @implemented
 */
void CHString::MakeReverse()
{
    // We'll modify string, duplicate it first if needed
    CopyBeforeWrite();
 
    // Let's use appropriate helper
    _wcsrev(reinterpret_cast<LPWSTR>(m_pchData));
}
 
/*
 * @implemented
 */
void CHString::MakeUpper()
{
    // We'll modify string, duplicate it first if needed
    CopyBeforeWrite();
 
    // Let's use appropriate helper
    _wcsupr(reinterpret_cast<LPWSTR>(m_pchData));
}
 
/*
 * @implemented
 */
CHString CHString::Mid(int nFirst) const
{
    // Take string from nFirst up to the end
    return Mid(nFirst, GetData()->nDataLength - nFirst);
}
 
/*
 * @implemented
 */
CHString CHString::Mid(int nFirst, int nCount) const
{
    CHString NewString;
 
    // Validate sizes first
    if (nFirst < 0)
    {
        nFirst = 0;
    }
 
    if (nCount < 0)
    {
        nCount = 0;
    }
 
    // Ensure we don't go beyond the string
    if (nFirst + nCount > GetData()->nDataLength)
    {
        nCount = GetData()->nDataLength - nFirst;
    }
 
    // Also ensure we don't read beyond
    // Yes, this should have been done before previous check
    // MS does it that way
    if (nFirst > GetData()->nDataLength)
    {
        nCount = 0;
    }
 
    AllocCopy(NewString, nCount, nFirst, 0);
 
    return NewString;
}
 
/*
 * @implemented
 */
void CHString::Release()
{
    // If null string, nothing to do
    if (GetData() == &afxNullData)
    {
        return;
    }
 
    // Otherwise, decrement ref count and release if required
    if (InterlockedDecrement(&GetData()->nRefs) == 0)
    {
        delete GetData();
    }
 
    // In all cases, caller doesn't want string anymore
    // So, switch back to empty string
    m_pchData = afxPchNil;
}
 
/*
 * @implemented
 */
void WINAPI CHString::Release(CHStringData* pData)
{
    // If empty string, ignore
    if (pData == &afxNullData)
    {
        return;
    }
 
    // Otherwise, simply and free if needed
    if (InterlockedDecrement(&pData->nRefs) == 0)
    {
        delete pData;
    }
}
 
/*
 * @implemented
 */
void CHString::ReleaseBuffer(int nNewLength)
{
    CHStringData* Data;
 
    // We'll modify buffer, so duplicate
    CopyBeforeWrite();
 
    // If no len provided, get one
    if (nNewLength == -1)
    {
        nNewLength = (int)wcslen(reinterpret_cast<LPCWSTR>(m_pchData));
    }
 
    // Set appropriate size and null-terminate
    Data = GetData();
    Data->nDataLength = nNewLength;
    Data->data()[nNewLength] = 0;
}
 
/*
 * @implemented
 */
int CHString::ReverseFind(CHSTRING_WCHAR ch) const
{
    CHSTRING_WCHAR *Last;
 
    // Let's use appropriate helper
    Last = reinterpret_cast<CHSTRING_WCHAR*>(wcsrchr(reinterpret_cast<LPCWSTR>(m_pchData), ch));
    // We have to return a position, so compute it
    if (Last)
    {
        return (Last - m_pchData);
    }
 
    // Otherwise, return no position
    return -1;
}
 
/*
 * @implemented
 */
CHString CHString::Right(int nCount) const
{
    CHString NewString;
 
    // Validate input (we can't get more than what we have ;-))
    if (nCount >= 0)
    {
        if (nCount > GetData()->nDataLength)
        {
            nCount = GetData()->nDataLength;
        }
    }
 
    AllocCopy(NewString, nCount, GetData()->nDataLength - nCount, 0);
 
    return NewString;
}
 
/*
 * @implemented
 */
int CHString::SafeStrlen(CHSTRING_LPCWSTR lpsz)
{
    // Check we have a string and then get its length
    if (lpsz == 0)
    {
        return 0;
    }
 
    // Of course, it's not safe at all in case string is not null-terminated.
    // Things that may happen given strings are not to be null-terminated
    // in this class...
    return (int)wcslen(reinterpret_cast<LPCWSTR>(lpsz));
}
 
/*
 * @implemented
 */
void CHString::SetAt(int nIndex, CHSTRING_WCHAR ch)
{
    CopyBeforeWrite();
 
    m_pchData[nIndex] = ch;
}
 
/*
 * @implemented
 */
CHString CHString::SpanExcluding(CHSTRING_LPCWSTR lpszCharSet) const
{
    int Count;
 
    // Get position and then, extract
    Count = (int)wcscspn(reinterpret_cast<LPCWSTR>(m_pchData), reinterpret_cast<LPCWSTR>(lpszCharSet));
    return Left(Count);
}
 
/*
 * @implemented
 */
CHString CHString::SpanIncluding(CHSTRING_LPCWSTR lpszCharSet) const
{
    int Count;
 
    // Get position and then, extract
    Count = (int)wcsspn(reinterpret_cast<LPCWSTR>(m_pchData), reinterpret_cast<LPCWSTR>(lpszCharSet));
    return Left(Count);
}
 
/*
 * @implemented
 */
void CHString::TrimLeft()
{
    int NewBegin;
    int NewLength;
    CHSTRING_WCHAR *CurrentChar;
 
    // We'll modify, so copy first
    CopyBeforeWrite();
 
    // Start at the begin of the string
    CurrentChar = m_pchData;
    while (*CurrentChar != 0)
    {
        // Browse string till we find something which is not a space
        if (!iswspace(*CurrentChar))
        {
            break;
        }
 
        CurrentChar++;
    }
 
    // Then, calculate new begin (easy) and new length
    // And move memory
    NewBegin = (CurrentChar - m_pchData);
    NewLength = GetData()->nDataLength - NewBegin;
    memmove(m_pchData, CurrentChar, NewLength * sizeof(CHSTRING_WCHAR));
    GetData()->nDataLength = NewLength;
}
 
/*
 * @implemented
 */
void CHString::TrimRight()
{
    CHSTRING_WCHAR *CurrentChar;
    CHSTRING_WCHAR *CanBeEaten;
 
    // We'll modify, so copy first
    CopyBeforeWrite();
 
    // Start at the begin of the string -- WHAT?!
    // Yes, this algorithm is the same that MS is
    // using for its TrimRight.
    // It is highly unefficient. It would have been
    // easier to start at nDataLength and to get back to
    // the begin. Note that it would have been safer as
    // well, in case the caller is using non-null-terminated
    // strings. But, well...
    CurrentChar = m_pchData;
    CanBeEaten = 0;
    while (*CurrentChar != 0)
    {
        // If not a space, reset what we can trim
        if (!iswspace(*CurrentChar))
        {
            CanBeEaten = 0;
        }
        // If it is one, and the first of the spaces serie
        // Keep its position
        else if (CanBeEaten == 0)
        {
            CanBeEaten = CurrentChar;
        }
 
        CurrentChar++;
    }
 
    // If nothing to trim, quit
    if (CanBeEaten == 0)
    {
        return;
    }
 
    // Otherwise, shorten the string
    GetData()->nDataLength = (CanBeEaten - m_pchData);
}
 
/*
 * @implemented
 */
void CHString::UnlockBuffer()
{
    // Unlock means just put ref back to 1
    // It was previously set to MAX_INT
    if (GetData() != &afxNullData)
    {
        GetData()->nRefs = 1;
    }
}
 
/*
 * @implemented
 */
const CHString& CHString::operator=(char ch)
{
    *this = (CHSTRING_WCHAR)ch;
    return *this;
}
 
/*
 * @implemented
 */
const CHString& CHString::operator=(CHSTRING_WCHAR ch)
{
    AssignCopy(1, &ch);
    return *this;
}
 
/*
 * @implemented
 */
const CHString& CHString::operator=(CHString *p)
{
    *this = *p;
    return *this;
}
 
/*
 * @implemented
 */
const CHString& CHString::operator=(LPCSTR lpsz)
{
    int Len;
 
    // If we have string, get its len
    if (lpsz != 0)
    {
        Len = (int)strlen(lpsz);
    }
    else
    {
        Len = 0;
    }
 
    // Do this call, even with null len, just to get empty string
    AllocBeforeWrite(Len);
    if (Len == 0)
    {
        Release();
        return *this;
    }
 
    // Convert and copy
    mbstowcsz(reinterpret_cast<LPWSTR>(m_pchData), lpsz, Len + 1);
    // Get new size and so on
    ReleaseBuffer();
 
    return *this;
}
 
/*
 * @implemented
 */
const CHString& CHString::operator=(CHSTRING_LPCWSTR lpsz)
{
    int Len;
 
    Len = SafeStrlen(lpsz);
    AssignCopy(Len, lpsz);
 
    return *this;
}
 
/*
 * @implemented
 */
const CHString& CHString::operator=(const CHString& stringSrc)
{
    // Don't copy string on itself
    if (&stringSrc == this)
    {
        return *this;
    }
 
    // In case we don't have a referenced string here,
    // or if the other is not referenced, just copy here
    if ((GetData()->nRefs < 0 && GetData() != &afxNullData) ||
         stringSrc.GetData()->nRefs < 0)
    {
        AssignCopy(stringSrc.GetData()->nDataLength, stringSrc.m_pchData);
        return *this;
    }
 
    // Otherwise, release current buffer
    Release();
    // And set buffer as stringSrc buffer
    // And increase its reference count
    m_pchData = stringSrc.m_pchData;
    InterlockedIncrement(&GetData()->nRefs);
 
    return *this;
}
 
/*
 * @implemented
 */
const CHString& CHString::operator=(const unsigned char* lpsz)
{
    *this = (LPCSTR)lpsz;
    return *this;
}
 
/*
 * @implemented
 */
const CHString& CHString::operator+=(char ch)
{
    *this += (CHSTRING_WCHAR)ch;
    return *this;
}
 
/*
 * @implemented
 */
const CHString& CHString::operator+=(CHSTRING_WCHAR ch)
{
    ConcatInPlace(1, &ch);
    return *this;
}
 
/*
 * @implemented
 */
const CHString& CHString::operator+=(CHSTRING_LPCWSTR lpsz)
{
    int Len;
 
    Len = SafeStrlen(lpsz);
    ConcatInPlace(Len, lpsz);
 
    return *this;
}
 
/*
 * @implemented
 */
const CHString& CHString::operator+=(const CHString& string)
{
    ConcatInPlace(string.GetData()->nDataLength, string.m_pchData);
 
    return *this;
}
 
/*
 * @implemented
 */
CHSTRING_WCHAR CHString::operator[](int nIndex) const
{
    return m_pchData[nIndex];
}
 
/*
 * @implemented
 */
CHString::operator CHSTRING_LPCWSTR() const
{
    return m_pchData;
}
 
/*
 * @implemented
 */
CHString WINAPI operator+(CHSTRING_WCHAR ch, const CHString& string)
{
    CHString NewString;
 
    // Basically concat in a new string
    NewString.ConcatCopy(1, &ch, string.GetData()->nDataLength, string.m_pchData);
 
    return NewString;
}
 
/*
 * @implemented
 */
CHString WINAPI operator+(const CHString& string, CHSTRING_WCHAR ch)
{
    CHString NewString;
 
    // Basically concat in a new string
    NewString.ConcatCopy(string.GetData()->nDataLength, string.m_pchData, 1, &ch);
 
    return NewString;
}
 
/*
 * @implemented
 */
CHString WINAPI operator+(const CHString& string, CHSTRING_LPCWSTR lpsz)
{
    int Len;
    CHString NewString;
 
    // Get string length
    Len = CHString::SafeStrlen(lpsz);
    // And concat in new string
    NewString.ConcatCopy(string.GetData()->nDataLength, string.m_pchData, Len, lpsz);
 
    return NewString;
}
 
/*
 * @implemented
 */
CHString WINAPI operator+(CHSTRING_LPCWSTR lpsz, const CHString& string)
{
    int Len;
    CHString NewString;
 
    // Get string length
    Len = CHString::SafeStrlen(lpsz);
    // And concat in new string
    NewString.ConcatCopy(Len, lpsz, string.GetData()->nDataLength, string.m_pchData);
 
    return NewString;
}
 
/*
 * @implemented
 */
CHString WINAPI operator+(const CHString& string1, const CHString& string2)
{
    CHString NewString;
 
    // Basically concat in a new string
    NewString.ConcatCopy(string1.GetData()->nDataLength, string1.m_pchData,
                         string2.GetData()->nDataLength, string2.m_pchData);
 
    return NewString;
}