stgpool.cpp

// 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

usingnamespaceStreamUtil;

#defineMAX_CHAIN_LENGTH20// 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.
//*****************************************************************************
voidStgPool::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.
//*****************************************************************************
voidStgPool::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.
//*****************************************************************************
boolStgPool::Grow( // true if successful.
 ULONG iRequired) // Min required bytes to allocate.
{
 CONTRACTL
 {
 NOTHROW;
INJECT_FAULT(returnFALSE;);
 }
 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)
returnfalse;
 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);

returntrue;
 }

// 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)
returnfalse;

// 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;

returntrue;
 }

// 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;

returntrue;
} // StgPool::Grow

//*****************************************************************************
// Add a segment to the chain of segments.
//*****************************************************************************
__checkReturn
HRESULT
StgPool::AddSegment(
constvoid *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.
//*****************************************************************************
voidStgStringPool::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.