// Licensed to the .NET Foundation under one or more agreements.

// The .NET Foundation licenses this file to you under the MIT license.

// See the LICENSE file in the project root for more information.

//*****************************************************************************

// StgPool.cpp

//

//

// Pools are used to reduce the amount of data actually required in the database.

// This allows for duplicate string and binary values to be folded into one

// copy shared by the rest of the database. Strings are tracked in a hash

// table when insert/changing data to find duplicates quickly. The strings

// are then persisted consecutively in a stream in the database format.

//

//*****************************************************************************

#include "stdafx.h" // Standard include.

#include <stgpool.h> // Our interface definitions.

#include <posterror.h> // Error handling.

#include <safemath.h> // CLRSafeInt integer overflow checking

#include "../md/inc/streamutil.h"

#include "ex.h"

#ifdef FEATURE_PREJIT

#include <corcompile.h>

#endif

using namespace StreamUtil;

#define MAX_CHAIN_LENGTH 20 // Max chain length before rehashing.

//

//

// StgPool

//

//

//*****************************************************************************

// Free any memory we allocated.

//*****************************************************************************

StgPool::~StgPool()

{

WRAPPER_NO_CONTRACT;

Uninit();

} // StgPool::~StgPool()

//*****************************************************************************

// Init the pool for use. This is called for both the create empty case.

//*****************************************************************************

__checkReturn

HRESULT

StgPool::InitNew(

ULONG cbSize, // Estimated size.

ULONG cItems) // Estimated item count.

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY);

}

CONTRACTL_END

// Make sure we aren't stomping anything and are properly initialized.

_ASSERTE(m_pSegData == m_zeros);

_ASSERTE(m_pNextSeg == 0);

_ASSERTE(m_pCurSeg == this);

_ASSERTE(m_cbCurSegOffset == 0);

_ASSERTE(m_cbSegSize == 0);

_ASSERTE(m_cbSegNext == 0);

m_bReadOnly = false;

m_bFree = false;

return S_OK;

} // StgPool::InitNew

//*****************************************************************************

// Init the pool from existing data.

//*****************************************************************************

__checkReturn

HRESULT

StgPool::InitOnMem(

void *pData, // Predefined data.

ULONG iSize, // Size of data.

int bReadOnly) // true if append is forbidden.

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY;);

}

CONTRACTL_END

// Make sure we aren't stomping anything and are properly initialized.

_ASSERTE(m_pSegData == m_zeros);

_ASSERTE(m_pNextSeg == 0);

_ASSERTE(m_pCurSeg == this);

_ASSERTE(m_cbCurSegOffset == 0);

// Create case requires no further action.

if (!pData)

return (E_INVALIDARG);

// Might we be extending this heap?

m_bReadOnly = bReadOnly;

m_pSegData = reinterpret_cast<BYTE*>(pData);

m_cbSegSize = iSize;

m_cbSegNext = iSize;

m_bFree = false;

return (S_OK);

} // StgPool::InitOnMem

//*****************************************************************************

// Called when the pool must stop accessing memory passed to InitOnMem().

//*****************************************************************************

__checkReturn

HRESULT

StgPool::TakeOwnershipOfInitMem()

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY;);

}

CONTRACTL_END

// If the pool doesn't have a pointer to non-owned memory, done.

if (m_bFree)

return (S_OK);

// If the pool doesn't have a pointer to memory at all, done.

if (m_pSegData == m_zeros)

{

_ASSERTE(m_cbSegSize == 0);

return (S_OK);

}

// Get some memory to keep.

BYTE *pData = new (nothrow) BYTE[m_cbSegSize+4];

if (pData == 0)

return (PostError(OutOfMemory()));

// Copy the old data to the new memory.

memcpy(pData, m_pSegData, m_cbSegSize);

m_pSegData = pData;

m_bFree = true;

return (S_OK);

} // StgPool::TakeOwnershipOfInitMem

//*****************************************************************************

// Clear out this pool. Cannot use until you call InitNew.

//*****************************************************************************

void StgPool::Uninit()

{

CONTRACTL

{

NOTHROW;

FORBID_FAULT;

}

CONTRACTL_END

// Free base segment, if appropriate.

if (m_bFree && (m_pSegData != m_zeros))

{

delete [] m_pSegData;

m_bFree = false;

}

// Free chain, if any.

StgPoolSeg *pSeg = m_pNextSeg;

while (pSeg)

{

StgPoolSeg *pNext = pSeg->m_pNextSeg;

delete [] (BYTE*)pSeg;

pSeg = pNext;

}

// Clear vars.

m_pSegData = (BYTE*)m_zeros;

m_cbSegSize = m_cbSegNext = 0;

m_pNextSeg = 0;

m_pCurSeg = this;

m_cbCurSegOffset = 0;

} // StgPool::Uninit

//*****************************************************************************

// Called to copy the pool to writable memory, reset the r/o bit.

//*****************************************************************************

__checkReturn

HRESULT

StgPool::ConvertToRW()

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY;);

}

CONTRACTL_END

HRESULT hr; // A result.

IfFailRet(TakeOwnershipOfInitMem());

IfFailRet(SetHash(true));

m_bReadOnly = false;

return S_OK;

} // StgPool::ConvertToRW

//*****************************************************************************

// Turn hashing off or on. Real implementation as required in subclass.

//*****************************************************************************

__checkReturn

HRESULT

StgPool::SetHash(int bHash)

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY;);

}

CONTRACTL_END

return S_OK;

} // StgPool::SetHash

//*****************************************************************************

// Trim any empty final segment.

//*****************************************************************************

void StgPool::Trim()

{

CONTRACTL

{

NOTHROW;

FORBID_FAULT;

}

CONTRACTL_END

// If no chained segments, nothing to do.

if (m_pNextSeg == 0)

return;

// Handle special case for a segment that was completely unused.

if (m_pCurSeg->m_cbSegNext == 0)

{

// Find the segment which points to the empty segment.

StgPoolSeg *pPrev;

for (pPrev = this; pPrev && pPrev->m_pNextSeg != m_pCurSeg; pPrev = pPrev->m_pNextSeg);

_ASSERTE(pPrev && pPrev->m_pNextSeg == m_pCurSeg);

// Free the empty segment.

delete [] (BYTE*) m_pCurSeg;

// Fix the pCurSeg pointer.

pPrev->m_pNextSeg = 0;

m_pCurSeg = pPrev;

// Adjust the base offset, because the PREVIOUS seg is now current.

_ASSERTE(m_pCurSeg->m_cbSegNext <= m_cbCurSegOffset);

m_cbCurSegOffset = m_cbCurSegOffset - m_pCurSeg->m_cbSegNext;

}

} // StgPool::Trim

//*****************************************************************************

// Allocate memory if we don't have any, or grow what we have. If successful,

// then at least iRequired bytes will be allocated.

//*****************************************************************************

bool StgPool::Grow( // true if successful.

ULONG iRequired) // Min required bytes to allocate.

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return FALSE;);

}

CONTRACTL_END

ULONG iNewSize; // New size we want.

StgPoolSeg *pNew; // Temp pointer for malloc.

_ASSERTE(!m_bReadOnly);

// Would this put the pool over 2GB?

if ((m_cbCurSegOffset + iRequired) > INT_MAX)

return (false);

// Adjust grow size as a ratio to avoid too many reallocs.

if ((m_pCurSeg->m_cbSegNext + m_cbCurSegOffset) / m_ulGrowInc >= 3)

m_ulGrowInc *= 2;

// NOTE: MD\DataSource\RemoteMDInternalRWSource has taken a dependency that there

// won't be more than 1000 segments. Given the current exponential growth algorithm

// we'll never get anywhere close to that, but if the algorithm changes to allow for

// many segments, please update that source as well.

// If first time, handle specially.

if (m_pSegData == m_zeros)

{

// Allocate the buffer.

iNewSize = max(m_ulGrowInc, iRequired);

BYTE *pSegData = new (nothrow) BYTE[iNewSize + 4];

if (pSegData == NULL)

return false;

m_pSegData = pSegData;

// Will need to delete it.

m_bFree = true;

// How big is this initial segment?

m_cbSegSize = iNewSize;

// Do some validation of var fields.

_ASSERTE(m_cbSegNext == 0);

_ASSERTE(m_pCurSeg == this);

_ASSERTE(m_pNextSeg == NULL);

return true;

}

// Allocate the new space enough for header + data.

iNewSize = (ULONG)(max(m_ulGrowInc, iRequired) + sizeof(StgPoolSeg));

pNew = (StgPoolSeg *)new (nothrow) BYTE[iNewSize+4];

if (pNew == NULL)

return false;

// Set the fields in the new segment.

pNew->m_pSegData = reinterpret_cast<BYTE*>(pNew) + sizeof(StgPoolSeg);

_ASSERTE(ALIGN4BYTE(reinterpret_cast<ULONG_PTR>(pNew->m_pSegData)) == reinterpret_cast<ULONG_PTR>(pNew->m_pSegData));

pNew->m_pNextSeg = 0;

pNew->m_cbSegSize = iNewSize - sizeof(StgPoolSeg);

pNew->m_cbSegNext = 0;

// Calculate the base offset of the new segment.

m_cbCurSegOffset = m_cbCurSegOffset + m_pCurSeg->m_cbSegNext;

// Handle special case for a segment that was completely unused.

//<TODO>@todo: Trim();</TODO>

if (m_pCurSeg->m_cbSegNext == 0)

{

// Find the segment which points to the empty segment.

StgPoolSeg *pPrev;

for (pPrev = this; pPrev && pPrev->m_pNextSeg != m_pCurSeg; pPrev = pPrev->m_pNextSeg);

_ASSERTE(pPrev && pPrev->m_pNextSeg == m_pCurSeg);

// Free the empty segment.

delete [] (BYTE *) m_pCurSeg;

// Link in the new segment.

pPrev->m_pNextSeg = pNew;

m_pCurSeg = pNew;

return true;

}

// Fix the size of the old segment.

m_pCurSeg->m_cbSegSize = m_pCurSeg->m_cbSegNext;

// Link the new segment into the chain.

m_pCurSeg->m_pNextSeg = pNew;

m_pCurSeg = pNew;

return true;

} // StgPool::Grow

//*****************************************************************************

// Add a segment to the chain of segments.

//*****************************************************************************

__checkReturn

HRESULT

StgPool::AddSegment(

const void *pData, // The data.

ULONG cbData, // Size of the data.

bool bCopy) // If true, make a copy of the data.

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY;);

}

CONTRACTL_END

StgPoolSeg *pNew; // Temp pointer for malloc.

// If we need to copy the data, just grow the heap by enough to take the

// the new data, and copy it in.

if (bCopy)

{

void *pDataToAdd = new (nothrow) BYTE[cbData];

IfNullRet(pDataToAdd);

memcpy(pDataToAdd, pData, cbData);

pData = pDataToAdd;

}

// If first time, handle specially.

if (m_pSegData == m_zeros)

{ // Data was passed in.

m_pSegData = reinterpret_cast<BYTE*>(const_cast<void*>(pData));

m_cbSegSize = cbData;

m_cbSegNext = cbData;

_ASSERTE(m_pNextSeg == NULL);

// Will not delete it.

m_bFree = false;

return S_OK;

}

// Not first time. Handle a completely empty tail segment.

Trim();

// Abandon any space past the end of the current live data.

_ASSERTE(m_pCurSeg->m_cbSegSize >= m_pCurSeg->m_cbSegNext);

m_pCurSeg->m_cbSegSize = m_pCurSeg->m_cbSegNext;

// Allocate a new segment header.

pNew = (StgPoolSeg *) new (nothrow) BYTE[sizeof(StgPoolSeg)];

IfNullRet(pNew);

// Set the fields in the new segment.

pNew->m_pSegData = reinterpret_cast<BYTE*>(const_cast<void*>(pData));

pNew->m_pNextSeg = NULL;

pNew->m_cbSegSize = cbData;

pNew->m_cbSegNext = cbData;

// Calculate the base offset of the new segment.

m_cbCurSegOffset = m_cbCurSegOffset + m_pCurSeg->m_cbSegNext;

// Link the segment into the chain.

_ASSERTE(m_pCurSeg->m_pNextSeg == NULL);

m_pCurSeg->m_pNextSeg = pNew;

m_pCurSeg = pNew;

return S_OK;

} // StgPool::AddSegment

#ifndef DACCESS_COMPILE

//*****************************************************************************

// The entire string pool is written to the given stream. The stream is aligned

// to a 4 byte boundary.

//*****************************************************************************

__checkReturn

HRESULT

StgPool::PersistToStream(

IStream *pIStream) // The stream to write to.

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY);

}

CONTRACTL_END

HRESULT hr = S_OK;

ULONG cbTotal; // Total bytes written.

StgPoolSeg *pSeg; // A segment being written.

_ASSERTE(m_pSegData != m_zeros);

// Start with the base segment.

pSeg = this;

cbTotal = 0;

EX_TRY

{

// As long as there is data, write it.

while (pSeg != NULL)

{

// If there is data in the segment . . .

if (pSeg->m_cbSegNext)

{ // . . . write and count the data.

if (FAILED(hr = pIStream->Write(pSeg->m_pSegData, pSeg->m_cbSegNext, 0)))

break;

cbTotal += pSeg->m_cbSegNext;

}

// Get the next segment.

pSeg = pSeg->m_pNextSeg;

}

if (SUCCEEDED(hr))

{

// Align to variable (0-4 byte) boundary.

UINT32 cbTotalAligned;

if (FAILED(Align(cbTotal, &cbTotalAligned)))

{

hr = COR_E_BADIMAGEFORMAT;

}

else

{

if (cbTotalAligned > cbTotal)

{

_ASSERTE(sizeof(hr) >= 3);

hr = 0;

hr = pIStream->Write(&hr, cbTotalAligned - cbTotal, 0);

}

}

}

}

EX_CATCH

{

hr = E_FAIL;

}

EX_END_CATCH(SwallowAllExceptions);

return hr;

} // StgPool::PersistToStream

#endif //!DACCESS_COMPILE

//*****************************************************************************

// The entire string pool is written to the given stream. The stream is aligned

// to a 4 byte boundary.

//*****************************************************************************

__checkReturn

HRESULT

StgPool::PersistPartialToStream(

IStream *pIStream, // The stream to write to.

ULONG iOffset) // Starting offset.

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY);

}

CONTRACTL_END

HRESULT hr = S_OK; // A result.

ULONG cbTotal; // Total bytes written.

StgPoolSeg *pSeg; // A segment being written.

_ASSERTE(m_pSegData != m_zeros);

// Start with the base segment.

pSeg = this;

cbTotal = 0;

// As long as there is data, write it.

while (pSeg != NULL)

{

// If there is data in the segment . . .

if (pSeg->m_cbSegNext)

{ // If this data should be skipped...

if (iOffset >= pSeg->m_cbSegNext)

{ // Skip it

iOffset -= pSeg->m_cbSegNext;

}

else

{ // At least some data should be written, so write and count the data.

IfFailRet(pIStream->Write(pSeg->m_pSegData+iOffset, pSeg->m_cbSegNext-iOffset, 0));

cbTotal += pSeg->m_cbSegNext-iOffset;

iOffset = 0;

}

}

// Get the next segment.

pSeg = pSeg->m_pNextSeg;

}

// Align to variable (0-4 byte) boundary.

UINT32 cbTotalAligned;

if (FAILED(Align(cbTotal, &cbTotalAligned)))

{

return COR_E_BADIMAGEFORMAT;

}

if (cbTotalAligned > cbTotal)

{

_ASSERTE(sizeof(hr) >= 3);

hr = 0;

hr = pIStream->Write(&hr, cbTotalAligned - cbTotal, 0);

}

return hr;

} // StgPool::PersistPartialToStream

// Copies data from pSourcePool starting at index nStartSourceIndex.

__checkReturn

HRESULT

StgPool::CopyPool(

UINT32 nStartSourceIndex,

const StgPool *pSourcePool)

{

HRESULT hr;

UINT32 cbDataSize;

BYTE *pbData = NULL;

if (nStartSourceIndex == pSourcePool->GetRawSize())

{ // There's nothing to copy

return S_OK;

}

if (nStartSourceIndex > pSourcePool->GetRawSize())

{ // Invalid input

Debug_ReportInternalError("The caller should not pass invalid start index in the pool.");

IfFailGo(METADATA_E_INDEX_NOTFOUND);

}

// Allocate new segment

cbDataSize = pSourcePool->GetRawSize() - nStartSourceIndex;

pbData = new (nothrow) BYTE[cbDataSize];

IfNullGo(pbData);

// Copy data to the new segment

UINT32 cbCopiedDataSize;

IfFailGo(pSourcePool->CopyData(

nStartSourceIndex,

pbData,

cbDataSize,

&cbCopiedDataSize));

// Check that we copied everything

if (cbDataSize != cbCopiedDataSize)

{

Debug_ReportInternalError("It is expected to copy everything from the source pool.");

IfFailGo(E_FAIL);

}

// Add the newly allocated segment to the pool

IfFailGo(AddSegment(

pbData,

cbDataSize,

false)); // fCopyData

ErrExit:

if (FAILED(hr))

{

if (pbData != NULL)

{

delete [] pbData;

}

}

return hr;

} // StgPool::CopyPool

// Copies data from the pool into a buffer. It will correctly walk all segments for the copy.

__checkReturn

HRESULT

StgPool::CopyData(

UINT32 nOffset,

BYTE *pBuffer,

UINT32 cbBuffer,

UINT32 *pcbWritten) const

{

CONTRACTL

{

NOTHROW;

PRECONDITION(CheckPointer(pBuffer));

PRECONDITION(CheckPointer(pcbWritten));

}

CONTRACTL_END

HRESULT hr = S_OK;

const StgPoolSeg *pSeg; // A segment being written.

_ASSERTE(m_pSegData != m_zeros);

// Start with the base segment.

pSeg = this;

*pcbWritten = 0;

// As long as there is data, write it.

while (pSeg != NULL)

{

// If there is data in the segment . . .

if (pSeg->m_cbSegNext)

{ // If this data should be skipped...

if (nOffset >= pSeg->m_cbSegNext)

{ // Skip it

nOffset -= pSeg->m_cbSegNext;

}

else

{

ULONG nNumBytesToCopy = pSeg->m_cbSegNext - nOffset;

if (nNumBytesToCopy > (cbBuffer - *pcbWritten))

{

_ASSERTE(!"Buffer isn't big enough to copy everything!");

nNumBytesToCopy = cbBuffer - *pcbWritten;

}

memcpy(pBuffer + *pcbWritten, pSeg->m_pSegData+nOffset, nNumBytesToCopy);

*pcbWritten += nNumBytesToCopy;

nOffset = 0;

}

}

// Get the next segment.

pSeg = pSeg->m_pNextSeg;

}

return hr;

} // StgPool::CopyData

//*****************************************************************************

// Get a pointer to the data at some offset. May require traversing the

// chain of extensions. It is the caller's responsibility not to attempt

// to access data beyond the end of a segment.

// This is an internal accessor, and should only be called when the data

// is not in the base segment.

//*****************************************************************************

__checkReturn

HRESULT

StgPool::GetData_i(

UINT32 nOffset,

MetaData::DataBlob *pData)

{

LIMITED_METHOD_CONTRACT;

// Shouldn't be called on base segment.

_ASSERTE(nOffset >= m_cbSegNext);

StgPoolSeg *pSeg = this;

while ((nOffset > 0) && (nOffset >= pSeg->m_cbSegNext))

{

// On to next segment.

nOffset -= pSeg->m_cbSegNext;

pSeg = pSeg->m_pNextSeg;

// Is there a next?

if (pSeg == NULL)

{

Debug_ReportError("Invalid offset passed - reached end of pool.");

pData->Clear();

return CLDB_E_INDEX_NOTFOUND;

}

}

// For the case where we want to read the first item and the pool is empty.

if (nOffset == pSeg->m_cbSegNext)

{ // Can only be if both == 0

Debug_ReportError("Invalid offset passed - it is at the end of pool.");

pData->Clear();

return CLDB_E_INDEX_NOTFOUND;

}

pData->Init(pSeg->m_pSegData + nOffset, pSeg->m_cbSegNext - nOffset);

return S_OK;

} // StgPool::GetData_i

//

//

// StgStringPool

//

//

//*****************************************************************************

// Create a new, empty string pool.

//*****************************************************************************

__checkReturn

HRESULT

StgStringPool::InitNew(

ULONG cbSize, // Estimated size.

ULONG cItems) // Estimated item count.

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY);

}

CONTRACTL_END

HRESULT hr;

UINT32 nEmptyStringOffset;

// Let base class intialize.

IfFailRet(StgPool::InitNew());

// Set initial table sizes, if specified.

if (cbSize > 0)

{

if (!Grow(cbSize))

{

return E_OUTOFMEMORY;

}

}

if (cItems > 0)

{

m_Hash.SetBuckets(cItems);

}

// Init with empty string.

IfFailRet(AddString("", &nEmptyStringOffset));

// Empty string had better be at offset 0.

_ASSERTE(nEmptyStringOffset == 0);

return hr;

} // StgStringPool::InitNew

//*****************************************************************************

// Load a string heap from persisted memory. If a copy of the data is made

// (so that it may be updated), then a new hash table is generated which can

// be used to elminate duplicates with new strings.

//*****************************************************************************

__checkReturn

HRESULT

StgStringPool::InitOnMem(

void *pData, // Predefined data.

ULONG iSize, // Size of data.

int bReadOnly) // true if append is forbidden.

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY);

}

CONTRACTL_END

HRESULT hr = S_OK;

// There may be up to three extra '\0' characters appended for padding. Trim them.

char *pchData = reinterpret_cast<char*>(pData);

while (iSize > 1 && pchData[iSize-1] == 0 && pchData[iSize-2] == 0)

--iSize;

// Let base class init our memory structure.

IfFailRet(StgPool::InitOnMem(pData, iSize, bReadOnly));

//<TODO>@todo: defer this until we hand out a pointer.</TODO>

if (!bReadOnly)

{

IfFailRet(TakeOwnershipOfInitMem());

IfFailRet(RehashStrings());

}

return hr;

} // StgStringPool::InitOnMem

//*****************************************************************************

// Clears the hash table then calls the base class.

//*****************************************************************************

void StgStringPool::Uninit()

{

CONTRACTL

{

NOTHROW;

FORBID_FAULT;

}

CONTRACTL_END

// Clear the hash table.

m_Hash.Clear();

// Let base class clean up.

StgPool::Uninit();

} // StgStringPool::Uninit

//*****************************************************************************

// Turn hashing off or on. If you turn hashing on, then any existing data is

// thrown away and all data is rehashed during this call.

//*****************************************************************************

__checkReturn

HRESULT

StgStringPool::SetHash(int bHash)

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY;);

}

CONTRACTL_END

HRESULT hr = S_OK;

// If turning on hash again, need to rehash all strings.

if (bHash)

hr = RehashStrings();

m_bHash = bHash;

return (hr);

} // StgStringPool::SetHash

//*****************************************************************************

// The string will be added to the pool. The offset of the string in the pool

// is returned in *piOffset. If the string is already in the pool, then the

// offset will be to the existing copy of the string.

//*****************************************************************************

__checkReturn

HRESULT

StgStringPool::AddString(

LPCSTR szString, // The string to add to pool.

UINT32 *pnOffset) // Return offset of string here.

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY;);

}

CONTRACTL_END

STRINGHASH *pHash; // Hash item for add.

ULONG iLen; // To handle non-null strings.

LPSTR pData; // Pointer to location for new string.

HRESULT hr;

_ASSERTE(!m_bReadOnly);

// Null pointer is an error.

if (szString == 0)

return (PostError(E_INVALIDARG));

// Find the real length we need in buffer.

iLen = (ULONG)(strlen(szString) + 1);

// Where to put the new string?

if (iLen > GetCbSegAvailable())

{

if (!Grow(iLen))

return (PostError(OutOfMemory()));

}

pData = reinterpret_cast<LPSTR>(GetNextLocation());

// Copy the data into the buffer.

strcpy_s(pData, iLen, szString);

// If the hash table is to be kept built (default).

if (m_bHash)

{

// Find or add the entry.

pHash = m_Hash.Find(pData, true);

if (!pHash)

return (PostError(OutOfMemory()));

// If the entry was new, keep the new string.

if (pHash->iOffset == 0xffffffff)

{

*pnOffset = pHash->iOffset = GetNextOffset();

SegAllocate(iLen);

// Check for hash chains that are too long.

if (m_Hash.MaxChainLength() > MAX_CHAIN_LENGTH)

{

IfFailRet(RehashStrings());

}

}

// Else use the old one.

else

{

*pnOffset = pHash->iOffset;

}

}

// Probably an import which defers the hash table for speed.

else

{

*pnOffset = GetNextOffset();

SegAllocate(iLen);

}

return S_OK;

} // StgStringPool::AddString

//*****************************************************************************

// Add a string to the pool with Unicode to UTF8 conversion.

//*****************************************************************************

__checkReturn

HRESULT

StgStringPool::AddStringW(

LPCWSTR szString, // The string to add to pool.

UINT32 *pnOffset) // Return offset of string here.

{

CONTRACTL

{

NOTHROW;

INJECT_FAULT(return E_OUTOFMEMORY;);

}

CONTRACTL_END

STRINGHASH *pHash; // Hash item for add.

ULONG iLen; // Correct length after conversion.

LPSTR pData; // Pointer to location for new string.

_ASSERTE(!m_bReadOnly);

// Null pointer is an error.

if (szString == 0)

return (PostError(E_INVALIDARG));

// Special case empty string.

if (*szString == '\0')

{

*pnOffset = 0;

return (S_OK);

}

// How many bytes will be required in the heap?

iLen = ::WszWideCharToMultiByte(

CP_UTF8,

0,

szString,

-1, // null-terminated string

NULL,

0,

NULL,

NULL);

// WCTMB includes trailing 0 if (when passing parameter #4 (length) -1.