RTDECL(int) RTUtf16ReallocTag(PRTUTF16 *ppwsz, size_t cbNew, const char *pszTag)
{
PRTUTF16 pwszOld = *ppwsz;
cbNew = RT_ALIGN_Z(cbNew, sizeof(RTUTF16));
if (!cbNew)
{
RTMemFree(pwszOld);
*ppwsz = NULL;
}
else if (pwszOld)
{
PRTUTF16 pwszNew = (PRTUTF16)RTMemReallocTag(pwszOld, cbNew, pszTag);
if (!pwszNew)
return VERR_NO_STR_MEMORY;
pwszNew[cbNew / sizeof(RTUTF16) - 1] = '\0';
*ppwsz = pwszNew;
}
else
{
PRTUTF16 pwszNew = (PRTUTF16)RTMemAllocTag(cbNew, pszTag);
if (!pwszNew)
return VERR_NO_UTF16_MEMORY;
pwszNew[0] = '\0';
pwszNew[cbNew / sizeof(RTUTF16) - 1] = '\0';
*ppwsz = pwszNew;
}
return VINF_SUCCESS;
}
RTDECL(int) RTStrReallocTag(char **ppsz, size_t cbNew, const char *pszTag)
{
char *pszOld = *ppsz;
if (!cbNew)
{
RTMemFree(pszOld);
*ppsz = NULL;
}
else if (pszOld)
{
char *pszNew = (char *)RTMemReallocTag(pszOld, cbNew, pszTag);
if (!pszNew)
return VERR_NO_STR_MEMORY;
pszNew[cbNew - 1] = '\0';
*ppsz = pszNew;
}
else
{
char *pszNew = (char *)RTMemAllocTag(cbNew, pszTag);
if (!pszNew)
return VERR_NO_STR_MEMORY;
pszNew[0] = '\0';
pszNew[cbNew - 1] = '\0';
*ppsz = pszNew;
}
return VINF_SUCCESS;
}
RTDECL(char *) RTStrAllocTag(size_t cb, const char *pszTag)
{
char *psz = (char *)RTMemAllocTag(RT_MAX(cb, 1), pszTag);
if (psz)
*psz = '\0';
return psz;
}
RTDECL(int) RTLatin1ToUtf16ExTag(const char *pszString, size_t cchString,
PRTUTF16 *ppwsz, size_t cwc, size_t *pcwc, const char *pszTag)
{
/*
* Validate input.
*/
Assert(VALID_PTR(pszString));
Assert(VALID_PTR(ppwsz));
Assert(!pcwc || VALID_PTR(pcwc));
/*
* Validate the input and calculate the length of the UTF-16 string.
*/
size_t cwcResult;
int rc = rtLatin1CalcUtf16Length(pszString, cchString, &cwcResult);
if (RT_SUCCESS(rc))
{
if (pcwc)
*pcwc = cwcResult;
/*
* Check buffer size / Allocate buffer.
*/
bool fShouldFree;
PRTUTF16 pwszResult;
if (cwc > 0 && *ppwsz)
{
fShouldFree = false;
if (cwc <= cwcResult)
return VERR_BUFFER_OVERFLOW;
pwszResult = *ppwsz;
}
else
{
*ppwsz = NULL;
fShouldFree = true;
cwc = RT_MAX(cwcResult + 1, cwc);
pwszResult = (PRTUTF16)RTMemAllocTag(cwc * sizeof(RTUTF16), pszTag);
}
if (pwszResult)
{
/*
* Encode the UTF-16 string.
*/
rc = rtLatin1RecodeAsUtf16(pszString, cchString, pwszResult, cwc - 1);
if (RT_SUCCESS(rc))
{
*ppwsz = pwszResult;
return rc;
}
if (fShouldFree)
RTMemFree(pwszResult);
}
else
rc = VERR_NO_UTF16_MEMORY;
}
return rc;
}
RTDECL(void *) RTMemAllocVarTag(size_t cbUnaligned, const char *pszTag)
{
size_t cbAligned;
if (cbUnaligned >= 16)
cbAligned = RT_ALIGN_Z(cbUnaligned, 16);
else
cbAligned = RT_ALIGN_Z(cbUnaligned, sizeof(void *));
return RTMemAllocTag(cbAligned, pszTag);
}
RTDECL(PRTUTF16) RTUtf16DupTag(PCRTUTF16 pwszString, const char *pszTag)
{
Assert(pwszString);
size_t cb = (RTUtf16Len(pwszString) + 1) * sizeof(RTUTF16);
PRTUTF16 pwsz = (PRTUTF16)RTMemAllocTag(cb, pszTag);
if (pwsz)
memcpy(pwsz, pwszString, cb);
return pwsz;
}
RTDECL(int) RTStrAllocExTag(char **ppsz, size_t cb, const char *pszTag)
{
char *psz = *ppsz = (char *)RTMemAllocTag(RT_MAX(cb, 1), pszTag);
if (psz)
{
*psz = '\0';
return VINF_SUCCESS;
}
return VERR_NO_STR_MEMORY;
}
RTDECL(int) RTUtf16ToLatin1ExTag(PCRTUTF16 pwszString, size_t cwcString, char **ppsz, size_t cch, size_t *pcch, const char *pszTag)
{
/*
* Validate input.
*/
AssertPtr(pwszString);
AssertPtr(ppsz);
AssertPtrNull(pcch);
/*
* Validate the UTF-16 string and calculate the length of the Latin1 encoding of it.
*/
size_t cchResult;
int rc = rtUtf16CalcLatin1Length(pwszString, cwcString, &cchResult);
if (RT_SUCCESS(rc))
{
if (pcch)
*pcch = cchResult;
/*
* Check buffer size / Allocate buffer and recode it.
*/
bool fShouldFree;
char *pszResult;
if (cch > 0 && *ppsz)
{
fShouldFree = false;
if (cch <= cchResult)
return VERR_BUFFER_OVERFLOW;
pszResult = *ppsz;
}
else
{
*ppsz = NULL;
fShouldFree = true;
cch = RT_MAX(cch, cchResult + 1);
pszResult = (char *)RTMemAllocTag(cch, pszTag);
}
if (pszResult)
{
rc = rtUtf16RecodeAsLatin1(pwszString, cwcString, pszResult, cch - 1);
if (RT_SUCCESS(rc))
{
*ppsz = pszResult;
return rc;
}
if (fShouldFree)
RTMemFree(pszResult);
}
else
rc = VERR_NO_STR_MEMORY;
}
return rc;
}
RTDECL(PRTUTF16) RTUtf16AllocTag(size_t cb, const char *pszTag)
{
if (cb > sizeof(RTUTF16))
cb = RT_ALIGN_Z(cb, sizeof(RTUTF16));
else
cb = sizeof(RTUTF16);
PRTUTF16 pwsz = (PRTUTF16)RTMemAllocTag(cb, pszTag);
if (pwsz)
*pwsz = '\0';
return pwsz;
}
RTDECL(char *) RTStrDupTag(const char *pszString, const char *pszTag)
{
#if defined(__cplusplus)
AssertPtr(pszString);
#endif
size_t cch = strlen(pszString) + 1;
char *psz = (char *)RTMemAllocTag(cch, pszTag);
if (psz)
memcpy(psz, pszString, cch);
return psz;
}
RTDECL(int) RTUtf16DupExTag(PRTUTF16 *ppwszString, PCRTUTF16 pwszString, size_t cwcExtra, const char *pszTag)
{
Assert(pwszString);
size_t cb = (RTUtf16Len(pwszString) + 1) * sizeof(RTUTF16);
PRTUTF16 pwsz = (PRTUTF16)RTMemAllocTag(cb + cwcExtra * sizeof(RTUTF16), pszTag);
if (pwsz)
{
memcpy(pwsz, pwszString, cb);
*ppwszString = pwsz;
return VINF_SUCCESS;
}
return VERR_NO_MEMORY;
}
RTDECL(char *) RTStrDupNTag(const char *pszString, size_t cchMax, const char *pszTag)
{
#if defined(__cplusplus)
AssertPtr(pszString);
#endif
char const *pszEnd = RTStrEnd(pszString, cchMax);
size_t cch = pszEnd ? (uintptr_t)pszEnd - (uintptr_t)pszString : cchMax;
char *pszDst = (char *)RTMemAllocTag(cch + 1, pszTag);
if (pszDst)
{
memcpy(pszDst, pszString, cch);
pszDst[cch] = '\0';
}
return pszDst;
}
RTDECL(int) RTStrDupExTag(char **ppszString, const char *pszString, const char *pszTag)
{
#if defined(__cplusplus)
AssertPtr(ppszString);
AssertPtr(pszString);
#endif
size_t cch = strlen(pszString) + 1;
char *psz = (char *)RTMemAllocTag(cch, pszTag);
if (psz)
{
memcpy(psz, pszString, cch);
*ppszString = psz;
return VINF_SUCCESS;
}
return VERR_NO_MEMORY;
}
RTDECL(int) RTLatin1ToUtf16Tag(const char *pszString, PRTUTF16 *ppwszString, const char *pszTag)
{
/*
* Validate input.
*/
Assert(VALID_PTR(ppwszString));
Assert(VALID_PTR(pszString));
*ppwszString = NULL;
/*
* Validate the input and calculate the length of the UTF-16 string.
*/
size_t cwc;
int rc = rtLatin1CalcUtf16Length(pszString, RTSTR_MAX, &cwc);
if (RT_SUCCESS(rc))
{
/*
* Allocate buffer.
*/
PRTUTF16 pwsz = (PRTUTF16)RTMemAllocTag((cwc + 1) * sizeof(RTUTF16), pszTag);
if (pwsz)
{
/*
* Encode the UTF-16 string.
*/
rc = rtLatin1RecodeAsUtf16(pszString, RTSTR_MAX, pwsz, cwc);
if (RT_SUCCESS(rc))
{
*ppwszString = pwsz;
return rc;
}
RTMemFree(pwsz);
}
else
rc = VERR_NO_UTF16_MEMORY;
}
return rc;
}
RTDECL(int) RTUtf16ToLatin1Tag(PCRTUTF16 pwszString, char **ppszString, const char *pszTag)
{
/*
* Validate input.
*/
Assert(VALID_PTR(ppszString));
Assert(VALID_PTR(pwszString));
*ppszString = NULL;
/*
* Validate the UTF-16 string and calculate the length of the UTF-8 encoding of it.
*/
size_t cch;
int rc = rtUtf16CalcLatin1Length(pwszString, RTSTR_MAX, &cch);
if (RT_SUCCESS(rc))
{
/*
* Allocate buffer and recode it.
*/
char *pszResult = (char *)RTMemAllocTag(cch + 1, pszTag);
if (pszResult)
{
rc = rtUtf16RecodeAsLatin1(pwszString, RTSTR_MAX, pszResult, cch);
if (RT_SUCCESS(rc))
{
*ppszString = pszResult;
return rc;
}
RTMemFree(pszResult);
}
else
rc = VERR_NO_STR_MEMORY;
}
return rc;
}
