You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1818 lines
50 KiB
1818 lines
50 KiB
// MLStr.cpp : Implementation of CMLStr
|
|
#include "private.h"
|
|
|
|
#ifndef NEWMLSTR
|
|
|
|
#include "mlstr.h"
|
|
#ifdef ASTRIMPL
|
|
#include "mlsbwalk.h"
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMLStr Helper functions
|
|
|
|
HRESULT RegularizePosLen(long lStrLen, long* plPos, long* plLen)
|
|
{
|
|
ASSERT_WRITE_PTR(plPos);
|
|
ASSERT_WRITE_PTR(plLen);
|
|
|
|
long lPos = *plPos;
|
|
long lLen = *plLen;
|
|
|
|
if (lPos < 0)
|
|
lPos = lStrLen;
|
|
else
|
|
lPos = min(lPos, lStrLen);
|
|
|
|
if (lLen < 0)
|
|
lLen = lStrLen - lPos;
|
|
else
|
|
lLen = min(lLen, lStrLen - lPos);
|
|
|
|
*plPos = lPos;
|
|
*plLen = lLen;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
#ifdef ASTRIMPL
|
|
HRESULT LocaleToCodePage(LCID locale, UINT* puCodePage)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (puCodePage)
|
|
{
|
|
TCHAR szCodePage[8];
|
|
|
|
if (::GetLocaleInfo(locale, LOCALE_IDEFAULTANSICODEPAGE, szCodePage, ARRAYSIZE(szCodePage)) > 0)
|
|
*puCodePage = _ttoi(szCodePage);
|
|
else
|
|
hr = E_FAIL; // NLS failed
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMLStr
|
|
|
|
CMLStr::CMLStr(void) :
|
|
m_pMLStrBufW(NULL),
|
|
m_pMLStrBufA(NULL),
|
|
m_lBufFlags(0),
|
|
m_cchBuf(0),
|
|
m_locale(0),
|
|
#ifdef ASTRIMPL
|
|
m_LockInfo(this)
|
|
#else
|
|
m_lLockFlags(0)
|
|
#endif
|
|
{
|
|
DllAddRef();
|
|
m_dwThreadID = ::GetCurrentThreadId();
|
|
}
|
|
|
|
CMLStr::~CMLStr(void)
|
|
{
|
|
if (m_pMLStrBufW)
|
|
m_pMLStrBufW->Release();
|
|
if (m_pMLStrBufA)
|
|
m_pMLStrBufA->Release();
|
|
DllRelease();
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::Sync(BOOL)
|
|
{
|
|
ASSERT_THIS;
|
|
return S_OK; // No multithread supported; Always synchronized
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::GetLength(long* plLen)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_WRITE_PTR_OR_NULL(plLen);
|
|
|
|
HRESULT hr = CheckThread();
|
|
#ifdef ASTRIMPL
|
|
CLock Lock(FALSE, this, hr);
|
|
#endif
|
|
long lLen;
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = GetLen(0, GetBufCCh(), &lLen);
|
|
|
|
if (plLen)
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
*plLen = lLen;
|
|
else
|
|
*plLen = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::SetMLStr(long, long, IUnknown*, long, long)
|
|
{
|
|
return E_NOTIMPL; // IMLangString::SetMLStr()
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::GetMLStr(long, long, IUnknown*, DWORD, const IID*, IUnknown**, long*, long*)
|
|
{
|
|
return E_NOTIMPL; // IMLangString::GetMLStr()
|
|
}
|
|
|
|
#ifndef ASTRIMPL
|
|
STDMETHODIMP CMLStr::SetWStr(long lDestPos, long lDestLen, const WCHAR* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
|
|
{
|
|
return E_NOTIMPL; // !ASTRIMPL
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::SetStrBufW(long lDestPos, long lDestLen, IMLangStringBufW* pSrcBuf, long* pcchActual, long* plActualLen)
|
|
{
|
|
return SetStrBufCommon(NULL, lDestPos, lDestLen, 0, pSrcBuf, NULL, pcchActual, plActualLen);
|
|
}
|
|
#endif
|
|
|
|
HRESULT CMLStr::SetStrBufCommon(void* pMLStrX, long lDestPos, long lDestLen, UINT uCodePage, IMLangStringBufW* pSrcBufW, IMLangStringBufA* pSrcBufA, long* pcchActual, long* plActualLen)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_READ_PTR_OR_NULL(pSrcBufW);
|
|
ASSERT_READ_PTR_OR_NULL(pSrcBufA);
|
|
ASSERT(!pSrcBufW || !pSrcBufA); // Either one or both should be NULL
|
|
ASSERT_WRITE_PTR_OR_NULL(pcchActual);
|
|
ASSERT_WRITE_PTR_OR_NULL(plActualLen);
|
|
|
|
HRESULT hr = CheckThread();
|
|
#ifdef ASTRIMPL
|
|
CLock Lock(TRUE, this, hr);
|
|
#endif
|
|
long lBufFlags = 0; // '= 0' for in case of both of pSrcBufW and pSrcBufA are NULL
|
|
long cchBuf = 0;
|
|
long cchDestPos;
|
|
long cchDestLen;
|
|
long lActualLen = 0;
|
|
|
|
#ifndef ASTRIMPL
|
|
if (SUCCEEDED(hr) && IsLocked())
|
|
hr = E_INVALIDARG; // This MLStr is locked
|
|
#endif
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
(!pSrcBufW || SUCCEEDED(hr = pSrcBufW->GetStatus(&lBufFlags, &cchBuf))) &&
|
|
(!pSrcBufA || SUCCEEDED(hr = pSrcBufA->GetStatus(&lBufFlags, &cchBuf))) &&
|
|
SUCCEEDED(hr = RegularizePosLen(&lDestPos, &lDestLen)) &&
|
|
SUCCEEDED(hr = GetCCh(0, lDestPos, &cchDestPos)) &&
|
|
SUCCEEDED(hr = GetCCh(cchDestPos, lDestLen, &cchDestLen)))
|
|
{
|
|
if (!cchDestPos && cchDestLen == GetBufCCh()) // Replacing entire string
|
|
{
|
|
IMLangStringBufW* const pOldBufW = GetMLStrBufW();
|
|
IMLangStringBufA* const pOldBufA = GetMLStrBufA();
|
|
|
|
if (pOldBufW)
|
|
pOldBufW->Release();
|
|
else if (pOldBufA)
|
|
pOldBufA->Release();
|
|
|
|
if (pSrcBufW)
|
|
pSrcBufW->AddRef();
|
|
else if (pSrcBufA)
|
|
pSrcBufA->AddRef();
|
|
|
|
SetMLStrBufW(pSrcBufW);
|
|
SetMLStrBufA(pSrcBufA);
|
|
SetCodePage(uCodePage);
|
|
SetBufFlags(lBufFlags);
|
|
SetBufCCh(cchBuf);
|
|
|
|
if (plActualLen)
|
|
hr = GetLen(0, GetBufCCh(), &lActualLen);
|
|
}
|
|
else
|
|
{
|
|
#ifdef ASTRIMPL
|
|
if (pSrcBufW)
|
|
{
|
|
CMLStrBufWalkW BufWalk(pSrcBufW, 0, cchBuf, (pcchActual || plActualLen));
|
|
|
|
while (BufWalk.Lock(hr))
|
|
{
|
|
long cchSet;
|
|
long lSetLen;
|
|
|
|
hr = ((IMLangStringWStr*)pMLStrX)->SetWStr(lDestPos, lDestLen, BufWalk.GetStr(), BufWalk.GetCCh(), &cchSet, (plActualLen) ? &lSetLen : NULL);
|
|
lActualLen += lSetLen;
|
|
BufWalk.Unlock(hr, cchSet);
|
|
}
|
|
|
|
cchBuf = BufWalk.GetDoneCCh();
|
|
|
|
pSrcBufW->Release();
|
|
}
|
|
else if (pSrcBufA && pMLStrX)
|
|
{
|
|
CMLStrBufWalkA BufWalk(pSrcBufA, 0, cchBuf, (pcchActual || plActualLen));
|
|
|
|
while (BufWalk.Lock(hr))
|
|
{
|
|
long cchSet;
|
|
long lSetLen;
|
|
|
|
hr = ((IMLangStringAStr*)pMLStrX)->SetAStr(lDestPos, lDestLen, uCodePage, BufWalk.GetStr(), BufWalk.GetCCh(), &cchSet, (plActualLen) ? &lSetLen : NULL);
|
|
lActualLen += lSetLen;
|
|
BufWalk.Unlock(hr, cchSet);
|
|
}
|
|
|
|
cchBuf = BufWalk.GetDoneCCh();
|
|
|
|
pSrcBufA->Release();
|
|
}
|
|
else
|
|
{
|
|
hr = SetMLStr(lDestPos, lDestLen, NULL, 0, 0);
|
|
}
|
|
#else
|
|
hr = E_INVALIDARG; // !ASTRIMPL
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pcchActual)
|
|
*pcchActual = cchBuf;
|
|
if (plActualLen)
|
|
*plActualLen = lActualLen;
|
|
}
|
|
else
|
|
{
|
|
if (pcchActual)
|
|
*pcchActual = 0;
|
|
if (plActualLen)
|
|
*plActualLen = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
#ifndef ASTRIMPL
|
|
STDMETHODIMP CMLStr::GetWStr(long lSrcPos, long lSrcLen, WCHAR* pszDest, long cchDest, long* pcchActual, long* plActualLen)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_WRITE_BLOCK_OR_NULL(pszDest, cchDest);
|
|
ASSERT_WRITE_PTR_OR_NULL(pcchActual);
|
|
ASSERT_WRITE_PTR_OR_NULL(plActualLen);
|
|
|
|
HRESULT hr = CheckThread();
|
|
long cchSrcPos;
|
|
long cchSrcLen;
|
|
long cchActual;
|
|
long lActualLen;
|
|
|
|
if (SUCCEEDED(hr) && IsLocked())
|
|
hr = E_INVALIDARG; // This MLStr is locked
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
SUCCEEDED(hr = RegularizePosLen(&lSrcPos, &lSrcLen)) &&
|
|
SUCCEEDED(hr = GetCCh(0, lSrcPos, &cchSrcPos)) &&
|
|
SUCCEEDED(hr = GetCCh(cchSrcPos, lSrcLen, &cchSrcLen)))
|
|
{
|
|
if (pszDest)
|
|
{
|
|
long cchActualTemp = min(cchSrcLen, cchDest);
|
|
cchActual = cchActualTemp;
|
|
|
|
while (SUCCEEDED(hr) && cchActualTemp > 0)
|
|
{
|
|
WCHAR* pszBuf;
|
|
long cchBuf;
|
|
|
|
if (m_pMLStrBufW)
|
|
{
|
|
if (SUCCEEDED(hr = m_pMLStrBufW->LockBuf(cchSrcPos, cchActualTemp, &pszBuf, &cchBuf)))
|
|
{
|
|
::memcpy(pszDest, pszBuf, sizeof(WCHAR) * cchBuf);
|
|
hr = m_pMLStrBufW->UnlockBuf(pszBuf, 0, 0);
|
|
|
|
cchSrcPos += cchBuf;
|
|
cchActualTemp -= cchBuf;
|
|
pszDest += cchBuf;
|
|
}
|
|
}
|
|
else // m_pMLStrBufW
|
|
{
|
|
hr = E_FAIL; // !ASTRIMPL
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr) && cchActualTemp < cchActual && (pcchActual || plActualLen))
|
|
{
|
|
cchActual -= cchActualTemp;
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cchActual = cchSrcLen;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && plActualLen)
|
|
hr = CalcLenW(0, cchActual, &lActualLen);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pcchActual)
|
|
*pcchActual = cchActual;
|
|
if (plActualLen)
|
|
*plActualLen = lActualLen;
|
|
}
|
|
else
|
|
{
|
|
if (pcchActual)
|
|
*pcchActual = 0;
|
|
if (plActualLen)
|
|
*plActualLen = 0;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::GetStrBufW(long, long, IMLangStringBufW**, long*)
|
|
{
|
|
return E_NOTIMPL; // !ASTRIMPL
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::LockWStr(long lSrcPos, long lSrcLen, long lFlags, long cchRequest, WCHAR** ppszDest, long* pcchDest, long* plDestLen)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_WRITE_PTR_OR_NULL(ppszDest);
|
|
ASSERT_WRITE_PTR_OR_NULL(pcchDest);
|
|
ASSERT_WRITE_PTR_OR_NULL(plDestLen);
|
|
|
|
HRESULT hr = CheckThread();
|
|
long cchSrcPos;
|
|
long cchSrcLen;
|
|
WCHAR* pszBuf = NULL;
|
|
long cchBuf;
|
|
long lLockLen;
|
|
|
|
if (SUCCEEDED(hr) && (IsLocked() || !lFlags || (lFlags & ~GetBufFlags() & MLSTR_WRITE)))
|
|
hr = E_INVALIDARG; // This MLStr is locked, no flags specified or not writable
|
|
|
|
if (!(lFlags & MLSTR_WRITE))
|
|
cchRequest = 0;
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
SUCCEEDED(hr = PrepareMLStrBuf()) &&
|
|
SUCCEEDED(hr = RegularizePosLen(&lSrcPos, &lSrcLen)) &&
|
|
SUCCEEDED(hr = GetCCh(0, lSrcPos, &cchSrcPos)) &&
|
|
SUCCEEDED(hr = GetCCh(cchSrcPos, lSrcLen, &cchSrcLen)))
|
|
{
|
|
IMLangStringBufW* const pMLStrBufW = GetMLStrBufW();
|
|
SetDirectLockFlag(pMLStrBufW != 0);
|
|
|
|
if (IsDirectLock())
|
|
{
|
|
long cchInserted;
|
|
long cchLockLen = cchSrcLen;
|
|
|
|
if (cchRequest > cchSrcLen &&
|
|
SUCCEEDED(hr = pMLStrBufW->Insert(cchSrcPos + cchSrcLen, cchRequest - cchSrcLen, &cchInserted)))
|
|
{
|
|
SetBufCCh(GetBufCCh() + cchInserted);
|
|
cchLockLen += cchInserted;
|
|
|
|
if (!pcchDest && cchLockLen < cchRequest)
|
|
hr = E_OUTOFMEMORY; // Can't insert in StrBuf
|
|
}
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
SUCCEEDED(hr = pMLStrBufW->LockBuf(cchSrcPos, cchLockLen, &pszBuf, &cchBuf)) &&
|
|
!pcchDest && cchBuf < max(cchSrcLen, cchRequest))
|
|
{
|
|
hr = E_OUTOFMEMORY; // Can't lock StrBuf
|
|
}
|
|
|
|
}
|
|
else if (m_pMLStrBufA)
|
|
{
|
|
long cchSize;
|
|
|
|
if (SUCCEEDED(hr = CalcBufSizeW(lSrcLen, &cchSize)))
|
|
{
|
|
cchBuf = max(cchSize, cchRequest);
|
|
hr = MemAlloc(sizeof(*pszBuf) * cchBuf, (void**)&pszBuf);
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && (lFlags & MLSTR_READ))
|
|
hr = ConvertMLStrBufAToWStr(m_uCodePage, m_pMLStrBufA, cchSrcPos, cchSrcLen, pszBuf, cchBuf, (pcchDest) ? &cchBuf : NULL);
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL; // !ASTRIMPL
|
|
}
|
|
}
|
|
|
|
if (plDestLen && SUCCEEDED(hr))
|
|
hr = CalcLenW(pszBuf, cchBuf, &lLockLen);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
SetLockFlags(lFlags);
|
|
m_pszLockBuf = pszBuf;
|
|
m_cchLockPos = cchSrcPos;
|
|
m_cchLockLen = cchBuf;
|
|
m_lLockPos = lSrcPos;
|
|
m_lLockLen = lSrcLen;
|
|
|
|
if (ppszDest)
|
|
*ppszDest = pszBuf;
|
|
if (pcchDest)
|
|
*pcchDest = cchBuf;
|
|
if (plDestLen)
|
|
*plDestLen = lLockLen;
|
|
}
|
|
else
|
|
{
|
|
if (pszBuf)
|
|
{
|
|
if (IsDirectLock())
|
|
GetMLStrBufW()->UnlockBuf(pszBuf, 0, 0);
|
|
else
|
|
MemFree(pszBuf);
|
|
}
|
|
|
|
if (ppszDest)
|
|
*ppszDest = NULL;
|
|
if (pcchDest)
|
|
*pcchDest = 0;
|
|
if (plDestLen)
|
|
*plDestLen = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
#endif
|
|
|
|
#ifdef ASTRIMPL
|
|
HRESULT CMLStr::UnlockWStrDirect(void* pKey, const void* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
|
|
{
|
|
HRESULT hr;
|
|
IMLangStringBufW* const pMLStrBufW = GetMLStrBufW();
|
|
const long cchLockLen = GetLockInfo()->GetCChLen(pKey);
|
|
|
|
if (SUCCEEDED(hr = pMLStrBufW->UnlockBuf((WCHAR*)pszSrc, 0, cchSrc)) &&
|
|
(GetLockInfo()->GetFlags(pKey) & MLSTR_WRITE))
|
|
{
|
|
if (cchSrc < cchLockLen)
|
|
{
|
|
if (SUCCEEDED(hr = pMLStrBufW->Delete(GetLockInfo()->GetCChPos(pKey) + cchSrc, cchLockLen - cchSrc)))
|
|
SetBufCCh(GetBufCCh() - (cchLockLen - cchSrc));
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && plActualLen)
|
|
hr = CalcLenW((WCHAR*)pszSrc, cchSrc, plActualLen);
|
|
|
|
if (pcchActual)
|
|
*pcchActual = cchSrc;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CMLStr::UnlockWStrIndirect(void* pKey, const void* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (GetLockInfo()->GetFlags(pKey) & MLSTR_WRITE)
|
|
{
|
|
CComQIPtr<IMLangStringWStr, &IID_IMLangStringWStr> pMLStrW(this);
|
|
ASSERT(pMLStrW);
|
|
hr = pMLStrW->SetWStr(GetLockInfo()->GetPos(pKey), GetLockInfo()->GetLen(pKey), (WCHAR*)pszSrc, cchSrc, pcchActual, plActualLen);
|
|
}
|
|
|
|
ASSIGN_IF_FAILED(hr, MemFree((void*)pszSrc));
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CMLStr::UnlockAStrDirect(void* pKey, const void* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
|
|
{
|
|
HRESULT hr;
|
|
IMLangStringBufA* const pMLStrBufA = GetMLStrBufA();
|
|
const long cchLockLen = GetLockInfo()->GetCChLen(pKey);
|
|
|
|
if (SUCCEEDED(hr = pMLStrBufA->UnlockBuf((CHAR*)pszSrc, 0, cchSrc)) &&
|
|
(GetLockInfo()->GetFlags(pKey) & MLSTR_WRITE))
|
|
{
|
|
if (cchSrc < cchLockLen)
|
|
{
|
|
if (SUCCEEDED(hr = pMLStrBufA->Delete(GetLockInfo()->GetCChPos(pKey) + cchSrc, cchLockLen - cchSrc)))
|
|
SetBufCCh(GetBufCCh() - (cchLockLen - cchSrc));
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && plActualLen)
|
|
hr = CalcLenA(GetCodePage(), (CHAR*)pszSrc, cchSrc, plActualLen);
|
|
|
|
if (pcchActual)
|
|
*pcchActual = cchSrc;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CMLStr::UnlockAStrIndirect(void* pKey, const void* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (GetLockInfo()->GetFlags(pKey) & MLSTR_WRITE)
|
|
{
|
|
CComQIPtr<IMLangStringAStr, &IID_IMLangStringAStr> pMLStrA(this);
|
|
ASSERT(pMLStrA);
|
|
hr = pMLStrA->SetAStr(GetLockInfo()->GetPos(pKey), GetLockInfo()->GetLen(pKey), GetLockInfo()->GetCodePage(pKey), (CHAR*)pszSrc, cchSrc, pcchActual, plActualLen);
|
|
}
|
|
|
|
ASSIGN_IF_FAILED(hr, MemFree((void*)pszSrc));
|
|
|
|
return hr;
|
|
}
|
|
#endif
|
|
|
|
#ifndef ASTRIMPL
|
|
STDMETHODIMP CMLStr::UnlockWStr(const WCHAR* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_READ_BLOCK(pszSrc, cchSrc);
|
|
ASSERT_WRITE_PTR_OR_NULL(pcchActual);
|
|
ASSERT_WRITE_PTR_OR_NULL(plActualLen);
|
|
|
|
HRESULT hr = CheckThread();
|
|
long lSrcLen = 0;
|
|
const long lLockFlags = GetLockFlags();
|
|
|
|
if (SUCCEEDED(hr) && (!IsLocked() || pszSrc != m_pszLockBuf))
|
|
hr = E_INVALIDARG; // This MLStr is not locked
|
|
|
|
if (!(lLockFlags & MLSTR_WRITE))
|
|
{
|
|
cchSrc = 0;
|
|
lSrcLen = 0;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IMLangStringBufW* const pMLStrBufW = GetMLStrBufW();
|
|
|
|
if (IsDirectLock())
|
|
{
|
|
if (SUCCEEDED(hr = pMLStrBufW->UnlockBuf(pszSrc, 0, cchSrc)) &&
|
|
(lLockFlags & MLSTR_WRITE))
|
|
{
|
|
if (cchSrc < m_cchLockLen)
|
|
{
|
|
if (SUCCEEDED(hr = pMLStrBufW->Delete(m_cchLockPos + cchSrc, m_cchLockLen - cchSrc)))
|
|
SetBufCCh(GetBufCCh() - (m_cchLockLen - cchSrc));
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && plActualLen)
|
|
hr = CalcLenW(pszSrc, cchSrc, &lSrcLen);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (lLockFlags & MLSTR_WRITE)
|
|
hr = SetWStr(m_lLockPos, m_lLockLen, pszSrc, cchSrc, (pcchActual) ? &cchSrc : NULL, (plActualLen) ? &lSrcLen : NULL);
|
|
|
|
HRESULT hrTemp = MemFree((void*)pszSrc);
|
|
if (FAILED(hrTemp) && SUCCEEDED(hr))
|
|
hr = hrTemp;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pcchActual)
|
|
*pcchActual = cchSrc;
|
|
if (plActualLen)
|
|
*plActualLen = lSrcLen;
|
|
}
|
|
else
|
|
{
|
|
if (pcchActual)
|
|
*pcchActual = 0;
|
|
if (plActualLen)
|
|
*plActualLen = 0;
|
|
}
|
|
|
|
SetLockFlags(0); // Unlock it anyway
|
|
|
|
return hr;
|
|
}
|
|
#endif
|
|
|
|
#ifdef ASTRIMPL
|
|
HRESULT CMLStr::UnlockStrCommon(const void* pszSrc, long cchSrc, long* pcchActual, long* plActualLen)
|
|
{
|
|
HRESULT hr = CheckThread();
|
|
void* pLockKey;
|
|
long lSrcLen;
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = GetLockInfo()->Find(pszSrc, cchSrc, &pLockKey);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = GetLockInfo()->Unlock(pLockKey, pszSrc, cchSrc, (pcchActual) ? &cchSrc : NULL, (plActualLen) ? &lSrcLen : NULL);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pcchActual)
|
|
*pcchActual = cchSrc;
|
|
if (plActualLen)
|
|
*plActualLen = lSrcLen;
|
|
}
|
|
else
|
|
{
|
|
if (pcchActual)
|
|
*pcchActual = 0;
|
|
if (plActualLen)
|
|
*plActualLen = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
#endif
|
|
|
|
STDMETHODIMP CMLStr::SetLocale(long lDestPos, long lDestLen, LCID locale)
|
|
{
|
|
ASSERT_THIS;
|
|
|
|
HRESULT hr = CheckThread();
|
|
#ifdef ASTRIMPL
|
|
CLock Lock(TRUE, this, hr);
|
|
#endif
|
|
long cchDestPos;
|
|
long cchDestLen;
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
SUCCEEDED(hr = RegularizePosLen(&lDestPos, &lDestLen)) &&
|
|
SUCCEEDED(hr = GetCCh(0, lDestPos, &cchDestPos)) &&
|
|
SUCCEEDED(hr = GetCCh(cchDestPos, lDestLen, &cchDestLen)))
|
|
{
|
|
//if (!cchDestPos && cchDestLen == GetBufCCh())
|
|
SetLocale(locale);
|
|
//else
|
|
// hr = E_NOTIMPL; // Cannot set the locale to a part of string in this version.
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::GetLocale(long lSrcPos, long lSrcMaxLen, LCID* plocale, long* plLocalePos, long* plLocaleLen)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_WRITE_PTR_OR_NULL(plocale);
|
|
ASSERT_WRITE_PTR_OR_NULL(plLocalePos);
|
|
ASSERT_WRITE_PTR_OR_NULL(plLocaleLen);
|
|
|
|
HRESULT hr = CheckThread();
|
|
#ifdef ASTRIMPL
|
|
CLock Lock(FALSE, this, hr);
|
|
#endif
|
|
long lStrLen;
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
SUCCEEDED(hr = GetLen(0, GetBufCCh(), &lStrLen)) &&
|
|
SUCCEEDED(hr = ::RegularizePosLen(lStrLen, &lSrcPos, &lSrcMaxLen)))
|
|
{
|
|
if (plocale)
|
|
*plocale = GetLocale();
|
|
if (plLocalePos)
|
|
*plLocalePos = 0;
|
|
if (plLocaleLen)
|
|
{
|
|
if (plLocalePos)
|
|
*plLocaleLen = lStrLen;
|
|
else
|
|
*plLocaleLen = lSrcMaxLen;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (plocale)
|
|
*plocale = 0;
|
|
if (plLocalePos)
|
|
*plLocalePos = 0;
|
|
if (plLocaleLen)
|
|
*plLocaleLen = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CMLStr::PrepareMLStrBuf(void)
|
|
{
|
|
if (GetMLStrBufW() || GetMLStrBufA())
|
|
return S_OK;
|
|
#ifdef ASTRIMPL
|
|
|
|
IMLangStringBufW* pBuf = new CMLStr::CMLStrBufStandardW;
|
|
if (pBuf)
|
|
{
|
|
SetMLStrBufW(pBuf);
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
#else
|
|
else
|
|
return E_NOTIMPL; //!ASTRIMPL
|
|
#endif
|
|
}
|
|
|
|
HRESULT CMLStr::RegularizePosLen(long* plPos, long* plLen)
|
|
{
|
|
HRESULT hr;
|
|
long lStrLen;
|
|
|
|
if (SUCCEEDED(hr = GetLen(0, GetBufCCh(), &lStrLen)))
|
|
hr = ::RegularizePosLen(lStrLen, plPos, plLen);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CMLStr::GetCCh(long cchOffset, long lLen, long* pcchLen)
|
|
{
|
|
if (GetMLStrBufW())
|
|
{
|
|
if (pcchLen)
|
|
*pcchLen = lLen; // The number of characters is equal to the length
|
|
return S_OK;
|
|
}
|
|
else if (GetMLStrBufA())
|
|
{
|
|
HRESULT hr = S_OK;
|
|
#ifdef ASTRIMPL
|
|
CMLStrBufWalkA BufWalk(GetMLStrBufA(), cchOffset, GetBufCCh() - cchOffset);
|
|
|
|
while (lLen > 0 && BufWalk.Lock(hr))
|
|
{
|
|
for (LPCSTR pszTemp = BufWalk.GetStr(); lLen > 0 && *pszTemp; lLen--)
|
|
pszTemp = ::CharNextExA((WORD)GetCodePage(), pszTemp, 0);
|
|
|
|
if (!*pszTemp)
|
|
lLen = 0; // String terminated
|
|
|
|
BufWalk.Unlock(hr);
|
|
}
|
|
#else
|
|
long cchDone = 0;
|
|
long cchRest = GetBufCCh() - cchOffset;
|
|
|
|
while (SUCCEEDED(hr) && lLen > 0)
|
|
{
|
|
CHAR* pszBuf;
|
|
long cchBuf;
|
|
|
|
if (SUCCEEDED(hr = m_pMLStrBufA->LockBuf(cchOffset, cchRest, &pszBuf, &cchBuf)))
|
|
{
|
|
for (LPCSTR pszTemp = pszBuf; lLen > 0 && *pszTemp; lLen--)
|
|
pszTemp = ::CharNextExA((WORD)m_uCodePage, pszTemp, 0);
|
|
|
|
if (!*pszBuf)
|
|
lLen = 0; // String terminated
|
|
|
|
hr = m_pMLStrBufA->UnlockBuf(pszBuf, 0, 0);
|
|
|
|
cchOffset += cchBuf;
|
|
cchRest -= cchBuf;
|
|
cchDone += (int)(pszTemp - pszBuf);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (pcchLen)
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
#ifdef ASTRIMPL
|
|
*pcchLen = BufWalk.GetDoneCCh();
|
|
#else
|
|
*pcchLen = cchDone;
|
|
#endif
|
|
else
|
|
*pcchLen = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
else
|
|
{
|
|
if (pcchLen)
|
|
*pcchLen = 0; // No string
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
HRESULT CMLStr::GetLen(long cchOffset, long cchLen, long* plLen)
|
|
{
|
|
if (GetMLStrBufW())
|
|
{
|
|
if (plLen)
|
|
*plLen = cchLen; // The length is equal to the number of characters
|
|
return S_OK;
|
|
}
|
|
else if (GetMLStrBufA())
|
|
{
|
|
HRESULT hr = S_OK;
|
|
long lDoneLen = 0;
|
|
#ifdef ASTRIMPL
|
|
CMLStrBufWalkA BufWalk(GetMLStrBufA(), cchOffset, cchLen);
|
|
|
|
while (BufWalk.Lock(hr))
|
|
{
|
|
long lTempLen;
|
|
|
|
hr = CalcLenA(GetCodePage(), BufWalk.GetStr(), BufWalk.GetCCh(), &lTempLen);
|
|
if (hr == S_FALSE)
|
|
cchLen = 0; // String terminated
|
|
lDoneLen += lTempLen;
|
|
|
|
BufWalk.Unlock(hr);
|
|
}
|
|
#else
|
|
|
|
while (SUCCEEDED(hr) && cchLen > 0)
|
|
{
|
|
CHAR* pszBuf;
|
|
long cchBuf;
|
|
|
|
if (SUCCEEDED(hr = m_pMLStrBufA->LockBuf(cchOffset, cchLen, &pszBuf, &cchBuf)))
|
|
{
|
|
long lTempLen;
|
|
|
|
hr = CalcLenA(GetCodePage(), pszBuf, cchBuf, &lTempLen);
|
|
if (hr == S_FALSE)
|
|
cchLen = 0; // String terminated
|
|
lDoneLen += lTempLen;
|
|
|
|
hr = m_pMLStrBufA->UnlockBuf(pszBuf, 0, 0);
|
|
|
|
cchOffset += cchBuf;
|
|
cchLen -= cchBuf;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (plLen)
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
*plLen = lDoneLen;
|
|
else
|
|
*plLen = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
else
|
|
{
|
|
if (plLen)
|
|
*plLen = 0; // No string
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
HRESULT CMLStr::CalcLenA(UINT uCodePage, const CHAR* psz, long cchLen, long* plLen)
|
|
{
|
|
long lLen = 0;
|
|
const CHAR* const pszEnd = psz + cchLen;
|
|
|
|
for (; psz < pszEnd && *psz; lLen++)
|
|
{
|
|
const CHAR* const pszNew = ::CharNextExA((WORD)uCodePage, psz, 0);
|
|
|
|
if (pszNew > pszEnd) // Overrun out of buffer
|
|
break;
|
|
|
|
psz = pszNew;
|
|
}
|
|
|
|
if (plLen)
|
|
*plLen = lLen;
|
|
|
|
if (*psz)
|
|
return S_OK;
|
|
else
|
|
return S_FALSE;
|
|
}
|
|
|
|
#ifdef ASTRIMPL
|
|
HRESULT CMLStr::CalcCChA(UINT uCodePage, const CHAR* psz, long lLen, long* pcchLen)
|
|
{
|
|
const CHAR* const pszStart = psz;
|
|
|
|
for (; lLen > 0 && *psz; lLen--)
|
|
psz = ::CharNextExA((WORD)uCodePage, psz, 0);
|
|
|
|
if (pcchLen)
|
|
*pcchLen = psz - pszStart;
|
|
|
|
if (*psz)
|
|
return S_OK;
|
|
else
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT CMLStr::ConvAStrToWStr(UINT uCodePage, const CHAR* pszSrc, long cchSrc, WCHAR* pszDest, long cchDest, long* pcchActualA, long* pcchActualW, long* plActualLen)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
long lWrittenLen;
|
|
long cchWrittenA;
|
|
|
|
long cchWrittenW = ::MultiByteToWideChar(uCodePage, 0, pszSrc, cchSrc, pszDest, (pszDest) ? cchDest : 0);
|
|
if (!cchWrittenW)
|
|
hr = E_FAIL; // NLS failed
|
|
|
|
if ((pcchActualA || plActualLen) && SUCCEEDED(hr))
|
|
hr = CalcLenW(pszDest, cchWrittenW, &lWrittenLen); // BOGUS: pszDest may be NULL
|
|
|
|
if (pcchActualA && SUCCEEDED(hr))
|
|
hr = CalcCChA(uCodePage, pszSrc, lWrittenLen, &cchWrittenA);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pcchActualA)
|
|
*pcchActualA = cchWrittenA;
|
|
if (pcchActualW)
|
|
*pcchActualW = cchWrittenW;
|
|
if (plActualLen)
|
|
*plActualLen = lWrittenLen;
|
|
}
|
|
else
|
|
{
|
|
if (pcchActualA)
|
|
*pcchActualA = 0;
|
|
if (pcchActualW)
|
|
*pcchActualW = 0;
|
|
if (plActualLen)
|
|
*plActualLen = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CMLStr::ConvWStrToAStr(BOOL fCanStopAtMiddle, UINT uCodePage, const WCHAR* pszSrc, long cchSrc, CHAR* pszDest, long cchDest, long* pcchActualA, long* pcchActualW, long* plActualLen)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
long lWrittenLen;
|
|
long cchWrittenW;
|
|
|
|
long cchWrittenA = ::WideCharToMultiByte(uCodePage, (fCanStopAtMiddle) ? 0 : WC_DEFAULTCHAR, pszSrc, cchSrc, pszDest, (pszDest) ? cchDest : 0, NULL, NULL);
|
|
if (!cchWrittenA)
|
|
hr = E_FAIL; // NLS failed
|
|
|
|
if ((pcchActualW || plActualLen) && SUCCEEDED(hr))
|
|
{
|
|
if (pszDest)
|
|
hr = CalcLenA(uCodePage, pszDest, cchWrittenA, &lWrittenLen);
|
|
else
|
|
hr = E_NOTIMPL; // Can't retrieve pcchActualW and plActualLen
|
|
}
|
|
|
|
if (pcchActualW && SUCCEEDED(hr))
|
|
hr = CalcCChW(pszSrc, lWrittenLen, &cchWrittenW);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (pcchActualA)
|
|
*pcchActualA = cchWrittenA;
|
|
if (pcchActualW)
|
|
*pcchActualW = cchWrittenW;
|
|
if (plActualLen)
|
|
*plActualLen = lWrittenLen;
|
|
}
|
|
else
|
|
{
|
|
if (pcchActualA)
|
|
*pcchActualA = 0;
|
|
if (pcchActualW)
|
|
*pcchActualW = 0;
|
|
if (plActualLen)
|
|
*plActualLen = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
#endif
|
|
|
|
#ifndef ASTRIMPL
|
|
HRESULT CMLStr::ConvertMLStrBufAToWStr(UINT uCodePage, IMLangStringBufA* pMLStrBufA, long cchSrcPos, long cchSrcLen, WCHAR* pszBuf, long cchBuf, long* pcchActual)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
long cchDone = 0;
|
|
|
|
while (SUCCEEDED(hr) && cchSrcLen > 0)
|
|
{
|
|
CHAR* pszBufA;
|
|
long cchBufA;
|
|
|
|
if (SUCCEEDED(hr = pMLStrBufA->LockBuf(cchSrcPos, cchSrcLen, &pszBufA, &cchBufA)))
|
|
{
|
|
long cchWritten = ::MultiByteToWideChar(uCodePage, 0, pszBufA, cchBufA, pszBuf, cchBuf);
|
|
if (!cchWritten)
|
|
hr = E_FAIL; // NLS failed
|
|
|
|
HRESULT hrTemp = pMLStrBufA->UnlockBuf(pszBufA, 0, 0);
|
|
if (FAILED(hrTemp) && SUCCEEDED(hr))
|
|
hr = hrTemp;
|
|
|
|
cchSrcPos += cchBufA;
|
|
cchSrcLen -= cchBufA;
|
|
pszBuf += cchWritten;
|
|
cchBuf -= cchWritten;
|
|
cchDone += cchWritten;
|
|
ASSERT(cchBuf >= 0);
|
|
}
|
|
}
|
|
|
|
if (pcchActual)
|
|
{
|
|
*pcchActual = cchDone;
|
|
|
|
if (FAILED(hr) && cchDone > 0)
|
|
hr = S_OK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CMLStr::ConvertWStrToMLStrBufA(const WCHAR*, long, UINT, IMLangStringBufA*, long, long)
|
|
{
|
|
return E_NOTIMPL; // !ASTRIMPL
|
|
}
|
|
#endif
|
|
|
|
#ifdef ASTRIMPL
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMLStr::CLockInfo
|
|
|
|
HRESULT CMLStr::CLockInfo::UnlockAll(void)
|
|
{
|
|
if (m_pLockArray)
|
|
{
|
|
for (int n = 0; n < MAX_LOCK_COUNT; n++)
|
|
{
|
|
if (m_pLockArray[n].m_psz)
|
|
Unlock(&m_pLockArray[n], m_pLockArray[n].m_psz, m_pLockArray[n].m_cchLen, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CMLStr::CLockInfo::Lock(PFNUNLOCKPROC pfnUnlockProc, long lFlags, UINT uCodePage, void* psz, long lPos, long lLen, long cchPos, long cchLen)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
int nIndex;
|
|
|
|
if (!m_pLockArray)
|
|
{
|
|
m_pLockArray = new CLockInfoEntry[MAX_LOCK_COUNT];
|
|
|
|
if (m_pLockArray)
|
|
{
|
|
for (nIndex = 0; nIndex < MAX_LOCK_COUNT; nIndex++)
|
|
m_pLockArray[nIndex].m_psz = NULL;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (nIndex = 0; nIndex < MAX_LOCK_COUNT; nIndex++)
|
|
{
|
|
if (!m_pLockArray[nIndex].m_psz)
|
|
break;
|
|
}
|
|
if (nIndex >= MAX_LOCK_COUNT)
|
|
hr = MLSTR_E_TOOMANYNESTOFLOCK;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_pLockArray[nIndex].m_psz = psz;
|
|
m_pLockArray[nIndex].m_pfnUnlockProc = pfnUnlockProc;
|
|
m_pLockArray[nIndex].m_lFlags = lFlags;
|
|
m_pLockArray[nIndex].m_uCodePage = uCodePage;
|
|
m_pLockArray[nIndex].m_lPos = lPos;
|
|
m_pLockArray[nIndex].m_lLen = lLen;
|
|
m_pLockArray[nIndex].m_cchPos = cchPos;
|
|
m_pLockArray[nIndex].m_cchLen = cchLen;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CMLStr::CLockInfo::Find(const void* psz, long, void** ppKey)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
int nIndex;
|
|
|
|
if (m_pLockArray)
|
|
{
|
|
for (nIndex = 0; nIndex < MAX_LOCK_COUNT; nIndex++)
|
|
{
|
|
if (psz == m_pLockArray[nIndex].m_psz)
|
|
break;
|
|
}
|
|
}
|
|
if (!m_pLockArray || nIndex >= MAX_LOCK_COUNT)
|
|
hr = E_INVALIDARG;
|
|
|
|
if (ppKey)
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
*ppKey = &m_pLockArray[nIndex];
|
|
else
|
|
*ppKey = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CMLStr::CLockInfo::Unlock(void* pKey, const void* psz, long cch, long* pcchActual, long* plActualLen)
|
|
{
|
|
CLockInfoEntry* const pEntry = (CLockInfoEntry*)pKey;
|
|
HRESULT hr;
|
|
|
|
if (!(pEntry->m_lFlags & MLSTR_WRITE))
|
|
{
|
|
cch = 0;
|
|
if (plActualLen)
|
|
*plActualLen = 0;
|
|
}
|
|
|
|
hr = (m_pMLStr->*(pEntry->m_pfnUnlockProc))(pKey, psz, cch, pcchActual, plActualLen);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = EndLock(pEntry->m_lFlags & MLSTR_WRITE);
|
|
|
|
pEntry->m_psz = NULL; // Remove from lock array anyway
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
if (pcchActual)
|
|
*pcchActual = 0;
|
|
if (plActualLen)
|
|
*plActualLen = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMLStr::CMLStrBufStandardW
|
|
|
|
long CMLStr::CMLStrBufStandardW::RoundBufSize(long cchStr)
|
|
{
|
|
for (int n = 8; n < 12; n++)
|
|
{
|
|
if (cchStr < (1L << n))
|
|
break;
|
|
}
|
|
const long cchTick = (1L << (n - 4));
|
|
return (cchStr + cchTick - 1) / cchTick * cchTick;
|
|
}
|
|
|
|
#endif
|
|
|
|
#else // NEWMLSTR
|
|
|
|
#include "mlstr.h"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMLStr
|
|
|
|
CMLStr::CMLStr(void) :
|
|
m_lLen(0),
|
|
m_hUnlockEvent(NULL),
|
|
m_hZeroEvent(NULL)
|
|
{
|
|
DllAddRef();
|
|
}
|
|
|
|
CMLStr::~CMLStr(void)
|
|
{
|
|
void* pv;
|
|
|
|
if (m_hZeroEvent)
|
|
::CloseHandle(m_hZeroEvent);
|
|
if (m_hUnlockEvent)
|
|
::CloseHandle(m_hUnlockEvent);
|
|
|
|
// m_lock should be empty
|
|
ASSERT(SUCCEEDED(m_lock.Top(&pv)));
|
|
ASSERT(!pv);
|
|
|
|
// Release all attributes in m_attr
|
|
VERIFY(SUCCEEDED(m_attr.Top(&pv)));
|
|
while (pv)
|
|
{
|
|
IMLStrAttr* const pAttr = m_attr.GetAttr(pv);
|
|
ASSERT(pAttr);
|
|
VERIFY(SUCCEEDED(pAttr->SetClient(NULL))); // Reset
|
|
VERIFY(SUCCEEDED(StartEndConnectionAttr(pAttr, NULL, m_attr.GetCookie(pv)))); // Disconnect
|
|
pAttr->Release();
|
|
VERIFY(SUCCEEDED(m_attr.Next(pv, &pv)));
|
|
}
|
|
DllRelease();
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::LockMLStr(long lPos, long lLen, DWORD dwFlags, DWORD* pdwCookie, long* plActualPos, long* plActualLen)
|
|
{
|
|
ASSERT_WRITE_PTR_OR_NULL(pdwCookie);
|
|
ASSERT_WRITE_PTR_OR_NULL(plActualPos);
|
|
ASSERT_WRITE_PTR_OR_NULL(plActualLen);
|
|
|
|
HRESULT hr;
|
|
void* pv;
|
|
|
|
Lock();
|
|
|
|
if (SUCCEEDED(hr = ::RegularizePosLen(m_lLen, &lPos, &lLen)))
|
|
{
|
|
const DWORD dwThrd = ::GetCurrentThreadId();
|
|
|
|
if (SUCCEEDED(hr = CheckAccessValidation(lPos, lLen, dwFlags, dwThrd, plActualPos, plActualLen)) &&
|
|
SUCCEEDED(hr = m_lock.Add(&pv)))
|
|
{
|
|
if (plActualPos && !plActualLen)
|
|
lLen -= *plActualPos - lPos;
|
|
else if (plActualLen)
|
|
lLen = *plActualLen;
|
|
if (plActualPos)
|
|
lPos = *plActualPos;
|
|
|
|
hr = m_lock.SetLock(pv, lPos, lLen, dwFlags, dwThrd);
|
|
|
|
if (FAILED(hr))
|
|
VERIFY(SUCCEEDED(m_lock.Remove(pv)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (plActualPos)
|
|
*plActualPos = 0;
|
|
if (plActualLen)
|
|
*plActualLen = 0;
|
|
}
|
|
|
|
Unlock();
|
|
|
|
if (pdwCookie)
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
*pdwCookie = (DWORD)pv;
|
|
else
|
|
*pdwCookie = 0;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CMLStr::CheckAccessValidation(long lPos, long lLen, DWORD dwFlags, DWORD dwThrd, long* plActualPos, long* plActualLen)
|
|
{
|
|
HRESULT hr;
|
|
DWORD dwStartTime = 0;
|
|
long lActualPos;
|
|
long lActualLen;
|
|
|
|
for (;;) // Waiting unlock loop
|
|
{
|
|
void* pv;
|
|
HRESULT hrValidation = S_OK;
|
|
|
|
lActualPos = lPos;
|
|
lActualLen = lLen;
|
|
|
|
hr = m_lock.Top(&pv);
|
|
while (SUCCEEDED(hr) && pv) // Enumerate all locks
|
|
{
|
|
LOCKINFO* plinfo;
|
|
|
|
if (SUCCEEDED(hr = m_lock.GetLockInfo(pv, &plinfo))) // Retrieve info of a lock
|
|
{
|
|
if ((dwFlags & MLSTR_MOVE) && // Moving this lock
|
|
lPos < plinfo->lPos + plinfo->lLen && // Overwrap or left of this lock
|
|
(dwThrd != plinfo->dwThrd || // Another thread
|
|
(plinfo->dwFlags & (MLSTR_READ | MLSTR_WRITE)))) // Same thread and has read or write access
|
|
{
|
|
if (dwThrd == plinfo->dwThrd)
|
|
hr = MLSTR_E_ACCESSDENIED;
|
|
else
|
|
hr = MLSTR_E_BUSY;
|
|
}
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
lActualPos < plinfo->lPos + plinfo->lLen &&
|
|
lActualPos + lActualLen >= plinfo->lPos) // Overwraping with this lock
|
|
{
|
|
DWORD dwShareMask = 0;
|
|
if (dwThrd == plinfo->dwThrd) // Same thread
|
|
dwShareMask = ~(MLSTR_SHARE_DENYREAD | MLSTR_SHARE_DENYWRITE); // Ignore share flags
|
|
|
|
if (((dwFlags & MLSTR_WRITE) && (plinfo->dwFlags & (MLSTR_READ | MLSTR_WRITE | MLSTR_SHARE_DENYWRITE) & dwShareMask)) || // Write on read/write
|
|
((dwFlags & MLSTR_READ) && (plinfo->dwFlags & ( MLSTR_WRITE | MLSTR_SHARE_DENYREAD ) & dwShareMask)) || // Read on write
|
|
((dwFlags & MLSTR_SHARE_DENYWRITE & dwShareMask) && (plinfo->dwFlags & MLSTR_WRITE)) || // Share deny on write
|
|
((dwFlags & MLSTR_SHARE_DENYREAD & dwShareMask) && (plinfo->dwFlags & MLSTR_READ))) // Share deny on read
|
|
{
|
|
// Conflicting access
|
|
if ((plinfo->lPos <= lActualPos && plinfo->lPos + plinfo->lLen >= lActualPos + lActualLen) || // No valid range left
|
|
(!plActualPos && !plActualLen)) // Needs to lock entire range
|
|
{
|
|
lActualPos = 0;
|
|
lActualLen = 0;
|
|
if (dwThrd == plinfo->dwThrd)
|
|
hr = MLSTR_E_ACCESSDENIED;
|
|
else
|
|
hr = MLSTR_E_BUSY;
|
|
}
|
|
else if ((!plActualPos && plinfo->lPos <= lActualPos) || // Forward processing, Starting from invalid range
|
|
(!plActualLen && plinfo->lPos + plinfo->lLen < lActualPos + lActualLen) || // Backward processing, Trancate valid range
|
|
(plActualPos && plActualLen && plinfo->lPos - lActualPos >= (lActualPos + lActualLen) - (plinfo->lPos + plinfo->lLen))) // Maximum valid range, Right valid range is bigger
|
|
{
|
|
lActualLen += lActualPos;
|
|
lActualPos = plinfo->lPos + plinfo->lLen;
|
|
lActualLen -= lActualPos;
|
|
if (!plActualPos) // Forward processing
|
|
{
|
|
if (dwThrd == plinfo->dwThrd)
|
|
hrValidation = MLSTR_E_ACCESSDENIED;
|
|
else
|
|
hrValidation = MLSTR_E_BUSY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lActualLen = plinfo->lPos - lActualPos;
|
|
if (!plActualLen) // Backward processing
|
|
{
|
|
if (dwThrd == plinfo->dwThrd)
|
|
hrValidation = MLSTR_E_ACCESSDENIED;
|
|
else
|
|
hrValidation = MLSTR_E_BUSY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = m_lock.Next(pv, &pv);
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && FAILED(hrValidation))
|
|
{
|
|
hr = hrValidation;
|
|
if (plActualLen && lPos < lActualPos) // Forward processing
|
|
{
|
|
lActualLen = lActualPos - lPos;
|
|
lActualPos = lPos;
|
|
}
|
|
else if (plActualPos && lPos + lLen != lActualPos + lActualLen) // Backward processing
|
|
{
|
|
lActualPos += lActualLen;
|
|
lActualLen = lPos + lLen - lActualPos;
|
|
}
|
|
}
|
|
|
|
if (hr != MLSTR_E_BUSY || (dwFlags | MLSTR_NOWAIT)) // No busy state, or don't want to wait even if busy
|
|
break;
|
|
|
|
// Now, let's wait another thread run UnlockMLStr. Then, try validation again.
|
|
|
|
if (!dwStartTime) // Not initialized yet
|
|
dwStartTime = ::GetTickCount(); // Remember starting time
|
|
|
|
const DWORD dwElapsedTime = ::GetTickCount() - dwStartTime;
|
|
if (dwElapsedTime >= MLSTR_LOCK_TIMELIMIT) // Already elapsed long time
|
|
break;
|
|
|
|
if (!m_hUnlockEvent) // We don't have event object yet
|
|
{
|
|
m_hUnlockEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL); // Manual reset, initial reset
|
|
if (!m_hUnlockEvent)
|
|
break;
|
|
|
|
m_cWaitUnlock = -1; // Initialize
|
|
}
|
|
else // After second time
|
|
{
|
|
ASSERT(m_cWaitUnlock == 0 || m_cWaitUnlock == -1 || m_cWaitUnlock >= 1);
|
|
if (m_cWaitUnlock == 0) // Don't reset if m_cWaitUnlock is not zero
|
|
{
|
|
::ResetEvent(m_hUnlockEvent);
|
|
m_cWaitUnlock = -1;
|
|
}
|
|
else
|
|
{
|
|
if (!m_hZeroEvent)
|
|
{
|
|
m_hZeroEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL); // Auto-reset, initial reset
|
|
if (!m_hZeroEvent)
|
|
break;
|
|
}
|
|
if (m_cWaitUnlock == -1)
|
|
m_cWaitUnlock = 2;
|
|
else
|
|
m_cWaitUnlock++;
|
|
}
|
|
}
|
|
ASSERT(m_cWaitUnlock == -1 || m_cWaitUnlock >= 2);
|
|
|
|
// CAUTION: Don't leave here until we make sure m_cWaitUnlock gets zero.
|
|
|
|
Unlock();
|
|
|
|
// === The story of m_cWaitUnlock ===
|
|
// If we don't have m_cWaitUnlock, the following scenario can be considered.
|
|
// (1) Thread A: ResetEvent(m_hUnlockEvent)
|
|
// (2) Thread A: Unlock()
|
|
// (3) Thread B: SetEvent(m_hUnlockEvent) // UnlockMLStr!!!
|
|
// (4) Thread C: Lock()
|
|
// (5) Thread C: ResetEvent(m_hUnlockEvent) // Problem!!!
|
|
// (6) Thread C: Unlock()
|
|
// (7) Thread A: WaitForSingleObject(m_hUnlockEvent)
|
|
// In this scenario, thread A is missing a event of (3). This situation should not happen.
|
|
// m_cWaitUnlock solves the problem.
|
|
|
|
const DWORD dwWaitResult = ::WaitForSingleObject(m_hUnlockEvent, MLSTR_LOCK_TIMELIMIT - dwElapsedTime); // Now wait unlock
|
|
|
|
Lock();
|
|
|
|
ASSERT(m_cWaitUnlock == -1 || m_cWaitUnlock >= 1);
|
|
if (m_cWaitUnlock == -1)
|
|
{
|
|
m_cWaitUnlock = 0;
|
|
}
|
|
else // m_cWaitUnlock >= 1
|
|
{
|
|
m_cWaitUnlock--;
|
|
|
|
// Here, let's wait until m_cWaitUnlock gets zero.
|
|
// Unless this, it may not good for performance.
|
|
// In worst case, it makes thousands of loops in this function because it never reset m_hUnlockEvent.
|
|
// m_hUnlockEvent will be signaled even though UnlockMLStr is called yet.
|
|
if (m_cWaitUnlock > 0)
|
|
{
|
|
Unlock();
|
|
::WaitForSingleObject(m_hZeroEvent, INFINITE); // Wait until m_cWaitUnlock gets zero, auto-reset
|
|
Lock();
|
|
}
|
|
else // Now it's zero! Yeah!
|
|
{
|
|
::SetEvent(m_hZeroEvent); // Release other threads
|
|
}
|
|
}
|
|
// ASSERT(m_cWaitUnlock == 0); This is not true. Maybe non-zero for next time.
|
|
// Now we may leave here.
|
|
|
|
if (dwWaitResult != WAIT_OBJECT_0) // Time expired or an error occurred
|
|
break;
|
|
}
|
|
|
|
if (plActualPos)
|
|
*plActualPos = lActualPos;
|
|
if (plActualLen)
|
|
*plActualLen = lActualLen;
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::UnlockMLStr(DWORD dwCookie)
|
|
{
|
|
Lock();
|
|
|
|
void* const pv = (void*)dwCookie;
|
|
|
|
const HRESULT hr = m_lock.Remove(pv);
|
|
|
|
if (m_hUnlockEvent)
|
|
::SetEvent(m_hUnlockEvent);
|
|
|
|
Unlock();
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::GetLength(long* plLen)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_WRITE_PTR_OR_NULL(plLen);
|
|
|
|
if (plLen)
|
|
*plLen = m_lLen;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::SetMLStr(long, long, IUnknown*, long, long)
|
|
{
|
|
return E_NOTIMPL; // IMLangString::SetMLStr()
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::RegisterAttr(IUnknown* pUnk, DWORD* pdwCookie)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_READ_PTR(pUnk);
|
|
ASSERT_WRITE_PTR_OR_NULL(pdwCookie);
|
|
|
|
HRESULT hr;
|
|
void* pv;
|
|
IMLStrAttr* pAttr = NULL;
|
|
BOOL fConnStarted = FALSE;
|
|
DWORD dwConnCookie;
|
|
|
|
Lock();
|
|
|
|
if (SUCCEEDED(hr = m_attr.Add(&pv)) &&
|
|
SUCCEEDED(hr = pUnk->QueryInterface(IID_IMLStrAttr, (void**)&pAttr)))
|
|
{
|
|
ASSERT_READ_PTR(pAttr);
|
|
}
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
SUCCEEDED(hr = StartEndConnectionAttr(pAttr, &dwConnCookie, 0))) // Connect
|
|
{
|
|
fConnStarted = TRUE;
|
|
if (SUCCEEDED(hr = pAttr->SetClient((IMLangString*)this)))
|
|
{
|
|
CFire fire(hr, this);
|
|
while (fire.Next())
|
|
hr = fire.Sink()->OnRegisterAttr(pAttr);
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
SUCCEEDED(hr = pAttr->SetMLStr(0, -1, (IMLangString*)this, 0, m_lLen)))
|
|
{
|
|
m_attr.SetAttr(pv, pAttr);
|
|
m_attr.SetCookie(pv, dwConnCookie);
|
|
|
|
if (pdwCookie)
|
|
*pdwCookie = (DWORD)pv;
|
|
}
|
|
else
|
|
{
|
|
if (pAttr)
|
|
{
|
|
pAttr->SetClient(NULL);
|
|
if (fConnStarted)
|
|
VERIFY(SUCCEEDED(StartEndConnectionAttr(pAttr, NULL, dwConnCookie))); // Disconnect
|
|
pAttr->Release();
|
|
}
|
|
|
|
if (pv)
|
|
m_attr.Remove(pv);
|
|
|
|
if (pdwCookie)
|
|
*pdwCookie = NULL;
|
|
}
|
|
|
|
Unlock();
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::UnregisterAttr(DWORD dwCookie)
|
|
{
|
|
ASSERT_THIS;
|
|
|
|
void* const pv = (void*)dwCookie;
|
|
|
|
Lock();
|
|
|
|
IMLStrAttr* const pAttr = m_attr.GetAttr(pv);
|
|
ASSERT(pAttr);
|
|
|
|
// Fire OnUnregisterAttr
|
|
HRESULT hr;
|
|
CFire fire(hr, this);
|
|
while (fire.Next())
|
|
hr = fire.Sink()->OnUnregisterAttr(pAttr);
|
|
|
|
// Release attribute
|
|
if (SUCCEEDED(hr) &&
|
|
SUCCEEDED(hr = pAttr->SetClient(NULL))) // Reset
|
|
{
|
|
VERIFY(SUCCEEDED(hr = StartEndConnectionAttr(pAttr, NULL, m_attr.GetCookie(pv)))); // Disconnect
|
|
pAttr->Release();
|
|
|
|
// Remove entry from attr table
|
|
m_attr.Remove(pv);
|
|
}
|
|
|
|
Unlock();
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::EnumAttr(IEnumUnknown** ppEnumUnk)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_WRITE_PTR_OR_NULL(ppEnumUnk);
|
|
|
|
if (!ppEnumUnk)
|
|
return S_OK;
|
|
|
|
CEnumAttr* const pEnum = new CComObject<CEnumAttr>;
|
|
|
|
*ppEnumUnk = pEnum;
|
|
|
|
if (pEnum)
|
|
{
|
|
pEnum->Init(this);
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::FindAttr(REFIID riid, LPARAM lParam, IUnknown** ppUnk)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_WRITE_PTR_OR_NULL(ppUnk);
|
|
|
|
HRESULT hr;
|
|
void* pv;
|
|
IUnknown* pMaxUnk = NULL;
|
|
long lMaxConf = 0;
|
|
|
|
Lock();
|
|
|
|
for (hr = m_attr.Top(&pv); SUCCEEDED(hr) && pv; hr = m_attr.Next(pv, &pv))
|
|
{
|
|
IMLStrAttr* const pIMLStrAttr = m_attr.GetAttr(pv);
|
|
IUnknown* pUnk;
|
|
long lConf;
|
|
|
|
hr = pIMLStrAttr->QueryAttr(riid, lParam, &pUnk, &lConf);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (lConf > lMaxConf)
|
|
{
|
|
lMaxConf = lConf;
|
|
if (pMaxUnk)
|
|
pMaxUnk->Release();
|
|
pMaxUnk = pUnk;
|
|
}
|
|
else
|
|
{
|
|
if (pUnk)
|
|
pUnk->Release();
|
|
}
|
|
|
|
if (lMaxConf == MLSTR_CONF_MAX)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (ppUnk)
|
|
*ppUnk = pMaxUnk;
|
|
else if (pMaxUnk)
|
|
pMaxUnk->Release();
|
|
}
|
|
else
|
|
{
|
|
if (pMaxUnk)
|
|
pMaxUnk->Release();
|
|
if (ppUnk)
|
|
*ppUnk = NULL;
|
|
}
|
|
|
|
Unlock();
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::OnRequestEdit(long lDestPos, long lDestLen, long lNewLen, REFIID riid, LPARAM lParam, IUnknown* pUnk)
|
|
{
|
|
HRESULT hr;
|
|
CFire fire(hr, this);
|
|
while (fire.Next())
|
|
hr = fire.Sink()->OnRequestEdit(lDestPos, lDestLen, lNewLen, riid, lParam, pUnk);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::OnCanceledEdit(long lDestPos, long lDestLen, long lNewLen, REFIID riid, LPARAM lParam, IUnknown* pUnk)
|
|
{
|
|
HRESULT hr;
|
|
CFire fire(hr, this);
|
|
while (fire.Next())
|
|
hr = fire.Sink()->OnCanceledEdit(lDestPos, lDestLen, lNewLen, riid, lParam, pUnk);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMLStr::OnChanged(long lDestPos, long lDestLen, long lNewLen, REFIID riid, LPARAM lParam, IUnknown* pUnk)
|
|
{
|
|
HRESULT hr;
|
|
CFire fire(hr, this);
|
|
while (fire.Next())
|
|
hr = fire.Sink()->OnChanged(lDestPos, lDestLen, lNewLen, riid, lParam, pUnk);
|
|
return hr;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMLStr::CEnumAttr
|
|
|
|
CMLStr::CEnumAttr::CEnumAttr(void) :
|
|
m_pMLStr(NULL),
|
|
m_pv(NULL)
|
|
{
|
|
}
|
|
|
|
CMLStr::CEnumAttr::~CEnumAttr(void)
|
|
{
|
|
if (m_pMLStr)
|
|
m_pMLStr->Unlock();
|
|
}
|
|
|
|
void CMLStr::CEnumAttr::Init(CMLStr* pMLStr)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_READ_PTR(pMLStr);
|
|
|
|
if (m_pMLStr)
|
|
m_pMLStr->Unlock();
|
|
|
|
m_pMLStr = pMLStr;
|
|
m_pMLStr->Lock();
|
|
|
|
VERIFY(SUCCEEDED(Reset()));
|
|
}
|
|
|
|
HRESULT CMLStr::CEnumAttr::Next(ULONG celt, IUnknown** rgelt, ULONG* pceltFetched)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_WRITE_BLOCK_OR_NULL(rgelt, celt);
|
|
ASSERT_WRITE_PTR_OR_NULL(pceltFetched);
|
|
|
|
ULONG c = 0;
|
|
|
|
if (rgelt && m_pMLStr)
|
|
{
|
|
for (; m_pv && c < celt; c++)
|
|
{
|
|
*rgelt = m_pMLStr->m_attr.GetAttr(m_pv);
|
|
ASSERT(*rgelt);
|
|
(*rgelt)->AddRef();
|
|
|
|
VERIFY(SUCCEEDED(m_pMLStr->m_attr.Next(m_pv, &m_pv)));
|
|
rgelt++;
|
|
}
|
|
}
|
|
|
|
if (pceltFetched)
|
|
*pceltFetched = c;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CMLStr::CEnumAttr::Skip(ULONG celt)
|
|
{
|
|
ASSERT_THIS;
|
|
|
|
for (ULONG c = 0; m_pv && c < celt; c++)
|
|
VERIFY(SUCCEEDED(m_pMLStr->m_attr.Next(m_pv, &m_pv)));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CMLStr::CEnumAttr::Reset(void)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_READ_PTR(m_pMLStr);
|
|
|
|
VERIFY(SUCCEEDED(m_pMLStr->m_attr.Top(&m_pv)));
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CMLStr::CEnumAttr::Clone(IEnumUnknown** ppEnum)
|
|
{
|
|
ASSERT_THIS;
|
|
ASSERT_WRITE_PTR_OR_NULL(ppEnum);
|
|
ASSERT_READ_PTR(m_pMLStr);
|
|
|
|
return m_pMLStr->EnumAttr(ppEnum);
|
|
}
|
|
|
|
#endif // NEWMLSTR
|