sstring.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.
// ---------------------------------------------------------------------------
// SString.cpp
//

// ---------------------------------------------------------------------------

#include"stdafx.h"
#include"sstring.h"
#include"ex.h"
#include"holder.h"


#if defined(_MSC_VER)
#pragma inline_depth (25)
#endif

//-----------------------------------------------------------------------------
// Static variables
//-----------------------------------------------------------------------------

// Have one internal, well-known, literal for the empty string.
const BYTE SString::s_EmptyBuffer[2] = { 0 };

// @todo: these need to be initialized by calling GetACP()

UINT SString::s_ACP = 0;

#ifndef DACCESS_COMPILE
static BYTE s_EmptySpace[sizeof(SString)] = { 0 };
#endif// DACCESS_COMPILE

SPTR_IMPL(SString,SString,s_Empty);

voidSString::Startup()
{
 STATIC_CONTRACT_NOTHROW;
 STATIC_CONTRACT_GC_NOTRIGGER;

if (s_ACP == 0)
 {
 UINT ACP = GetACP();

#ifndef DACCESS_COMPILE
 s_Empty = PTR_SString(new (s_EmptySpace) SString());
 s_Empty->SetNormalized();
#endif// DACCESS_COMPILE

MemoryBarrier();
 s_ACP = ACP;
 }
}

CHECK SString::CheckStartup()
{
 WRAPPER_NO_CONTRACT;

CHECK(s_Empty != NULL);
 CHECK_OK;
}

//-----------------------------------------------------------------------------
// Case insensitive helpers.
//-----------------------------------------------------------------------------

static WCHAR MapChar(WCHAR wc, DWORD dwFlags)
{
 WRAPPER_NO_CONTRACT;

 WCHAR wTmp;

#ifndef FEATURE_PAL

int iRet = ::LCMapStringEx(LOCALE_NAME_INVARIANT, dwFlags, &wc, 1, &wTmp, 1, NULL, NULL, 0);
if (!iRet) {
// This can fail in non-exceptional cases becauseof unknown unicode characters.
 wTmp = wc;
 }

#else// !FEATURE_PAL
// For PAL, no locale specific processing is done

if (dwFlags == LCMAP_UPPERCASE)
 {
 wTmp =
#ifdef SELF_NO_HOST
toupper(wc);
#else
PAL_ToUpperInvariant(wc);
#endif
 }
else
 {
_ASSERTE(dwFlags == LCMAP_LOWERCASE);
 wTmp =
#ifdef SELF_NO_HOST
tolower(wc);
#else
PAL_ToLowerInvariant(wc);
#endif
 }
#endif// !FEATURE_PAL

return wTmp;
}

#defineIS_UPPER_A_TO_Z(x) (((x) >= W('A')) && ((x) <= W('Z')))
#defineIS_LOWER_A_TO_Z(x) (((x) >= W('a')) && ((x) <= W('z')))
#defineCAN_SIMPLE_UPCASE(x) (((x)&~0x7f) == 0)
#defineCAN_SIMPLE_DOWNCASE(x) (((x)&~0x7f) == 0)
#defineSIMPLE_UPCASE(x) (IS_LOWER_A_TO_Z(x) ? ((x) - W('a') + W('A')) : (x))
#defineSIMPLE_DOWNCASE(x) (IS_UPPER_A_TO_Z(x) ? ((x) - W('A') + W('a')) : (x))

/* static */
intSString::CaseCompareHelper(const WCHAR *buffer1, const WCHAR *buffer2, COUNT_T count, BOOL stopOnNull, BOOL stopOnCount)
{
 LIMITED_METHOD_CONTRACT;

_ASSERTE(stopOnNull || stopOnCount);

const WCHAR *buffer1End = buffer1 + count;
int diff = 0;

while (!stopOnCount || (buffer1 < buffer1End))
 {
 WCHAR ch1 = *buffer1++;
 WCHAR ch2 = *buffer2++;
 diff = ch1 - ch2;
if ((ch1 == 0) || (ch2 == 0))
 {
if (diff != 0 || stopOnNull)
 {
break;
 }
 }
else
 {
if (diff != 0)
 {
 diff = ((CAN_SIMPLE_UPCASE(ch1) ? SIMPLE_UPCASE(ch1) : MapChar(ch1, LCMAP_UPPERCASE))
 - (CAN_SIMPLE_UPCASE(ch2) ? SIMPLE_UPCASE(ch2) : MapChar(ch2, LCMAP_UPPERCASE)));
 }
if (diff != 0)
 {
break;
 }
 }
 }

return diff;
}

#defineIS_LOWER_A_TO_Z_ANSI(x) (((x) >= 'a') && ((x) <= 'z'))
#defineCAN_SIMPLE_UPCASE_ANSI(x) (((x) >= 0x20) && ((x) <= 0x7f))
#defineSIMPLE_UPCASE_ANSI(x) (IS_LOWER_A_TO_Z(x) ? ((x) - 'a' + 'A') : (x))

intGetCaseInsensitiveValueA(const CHAR *buffer, int length) {
 LIMITED_METHOD_CONTRACT;
_ASSERTE(buffer != NULL);
_ASSERTE(length == 1 || ((length == 2) && IsDBCSLeadByte(*buffer)));

 WCHAR wideCh;
int sortValue;
int conversionReturn = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, length, &wideCh, 1);
if (conversionReturn == 0)
 {
// An invalid sequence should only compare equal to itself, so use a negative mapping.
if (length == 1)
 {
 sortValue = -((int)((unsignedchar)(*buffer)));
 }
else
 {
 sortValue = -(((((int)((unsignedchar)(*buffer))) << 8) | ((int)((unsignedchar)(*(buffer + 1))))));
 }
 }
else
 {
_ASSERTE(conversionReturn == 1);
 sortValue = MapChar(wideCh, LCMAP_UPPERCASE);
 }
return sortValue;
}

/* static */
intSString::CaseCompareHelperA(const CHAR *buffer1, const CHAR *buffer2, COUNT_T count, BOOL stopOnNull, BOOL stopOnCount)
{
 LIMITED_METHOD_CONTRACT;

_ASSERTE(stopOnNull || stopOnCount);

const CHAR *buffer1End = buffer1 + count;
int diff = 0;

while (!stopOnCount || (buffer1 < buffer1End))
 {
 CHAR ch1 = *buffer1;
 CHAR ch2 = *buffer2;
if ((ch1 == 0) || (ch2 == 0))
 {
 diff = ch1 - ch2;
if (diff != 0 || stopOnNull)
 {
break;
 }
 buffer1++;
 buffer2++;
 }
elseif (CAN_SIMPLE_UPCASE_ANSI(ch1) && CAN_SIMPLE_UPCASE_ANSI(ch2))
 {
 diff = ch1 - ch2;
if (diff != 0)
 {
 diff = (SIMPLE_UPCASE_ANSI(ch1) - SIMPLE_UPCASE_ANSI(ch2));
if (diff != 0)
 {
break;
 }
 }
 buffer1++;
 buffer2++;
 }
else
 {
int length = 1;
if (IsDBCSLeadByte(ch1)
 && IsDBCSLeadByte(ch2)
 && (!stopOnCount || ((buffer1 + 1) < buffer1End)))
 {
 length = 2;
 }
int sortValue1 = GetCaseInsensitiveValueA(buffer1, length);
int sortValue2 = GetCaseInsensitiveValueA(buffer2, length);
 diff = sortValue1 - sortValue2;
if (diff != 0)
 {
break;
 }
 buffer1 += length;
 buffer2 += length;
 }
 }
return diff;
}


intCaseHashHelper(const WCHAR *buffer, COUNT_T count)
{
 LIMITED_METHOD_CONTRACT;

const WCHAR *bufferEnd = buffer + count;
 ULONG hash = 5381;

while (buffer < bufferEnd)
 {
 WCHAR ch = *buffer++;
 ch = CAN_SIMPLE_UPCASE(ch) ? SIMPLE_UPCASE(ch) : MapChar(ch, LCMAP_UPPERCASE);

 hash = (((hash << 5) + hash) ^ ch);
 }

return hash;
}

staticintCaseHashHelperA(const CHAR *buffer, COUNT_T count)
{
 LIMITED_METHOD_CONTRACT;

const CHAR *bufferEnd = buffer + count;
 ULONG hash = 5381;

while (buffer < bufferEnd)
 {
 CHAR ch = *buffer++;
 ch = SIMPLE_UPCASE_ANSI(ch);

 hash = (((hash << 5) + hash) ^ ch);
 }

return hash;
}

//-----------------------------------------------------------------------------
// Set this string to a copy of the unicode string
//-----------------------------------------------------------------------------
voidSString::Set(const WCHAR *string)
{
 CONTRACT_VOID
 {
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(string, NULL_OK));
 THROWS;
 GC_NOTRIGGER;
 SUPPORTS_DAC_HOST_ONLY;
 }
 CONTRACT_END;

if (string == NULL || *string == 0)
Clear();
else
 {
Resize((COUNT_T) wcslen(string), REPRESENTATION_UNICODE);
wcscpy_s(GetRawUnicode(), GetBufferSizeInCharIncludeNullChar(), string);
 }

 RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to a copy of the first count characters of the given
// unicode string.
//-----------------------------------------------------------------------------
voidSString::Set(const WCHAR *string, COUNT_T count)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(string, NULL_OK));
PRECONDITION(CheckCount(count));
 THROWS;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

if (count == 0)
Clear();
else
 {
Resize(count, REPRESENTATION_UNICODE);
wcsncpy_s(GetRawUnicode(), GetBufferSizeInCharIncludeNullChar(), string, count);
GetRawUnicode()[count] = 0;
 }

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to a point to the first count characters of the given
// preallocated unicode string (shallow copy).
//-----------------------------------------------------------------------------
voidSString::SetPreallocated(const WCHAR *string, COUNT_T count)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(string, NULL_OK));
PRECONDITION(CheckCount(count));
SS_POSTCONDITION(IsEmpty());
 GC_NOTRIGGER;
 NOTHROW;
 SUPPORTS_DAC_HOST_ONLY;
 }
 SS_CONTRACT_END;

SetImmutable();
SetImmutable((BYTE*) string, count*2);
ClearAllocated();
SetRepresentation(REPRESENTATION_UNICODE);

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to a copy of the given ansi string
//-----------------------------------------------------------------------------
voidSString::SetASCII(const ASCII *string)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(string, NULL_OK));
PRECONDITION(CheckASCIIString(string));
 THROWS;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

if (string == NULL || *string == 0)
Clear();
else
 {
Resize((COUNT_T) strlen(string), REPRESENTATION_ASCII);
strcpy_s(GetRawUTF8(), GetBufferSizeInCharIncludeNullChar(), string);
 }

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to a copy of the first count characters of the given
// ascii string
//-----------------------------------------------------------------------------
voidSString::SetASCII(const ASCII *string, COUNT_T count)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(string, NULL_OK));
PRECONDITION(CheckASCIIString(string, count));
PRECONDITION(CheckCount(count));
 THROWS;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

if (count == 0)
Clear();
else
 {
Resize(count, REPRESENTATION_ASCII);
strncpy_s(GetRawASCII(), GetBufferSizeInCharIncludeNullChar(), string, count);
GetRawASCII()[count] = 0;
 }

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to a copy of the given UTF8 string
//-----------------------------------------------------------------------------
voidSString::SetUTF8(const UTF8 *string)
{
 SS_CONTRACT_VOID
 {
// !!! Check for illegal UTF8 encoding?
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(string, NULL_OK));
 THROWS;
 GC_NOTRIGGER;
 SUPPORTS_DAC_HOST_ONLY;
 }
 SS_CONTRACT_END;

if (string == NULL || *string == 0)
Clear();
else
 {
Resize((COUNT_T) strlen(string), REPRESENTATION_UTF8);
strcpy_s(GetRawUTF8(), GetBufferSizeInCharIncludeNullChar(), string);
 }

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to a copy of the first count characters of the given
// UTF8 string.
//-----------------------------------------------------------------------------
voidSString::SetUTF8(const UTF8 *string, COUNT_T count)
{
 SS_CONTRACT_VOID
 {
// !!! Check for illegal UTF8 encoding?
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(string, NULL_OK));
PRECONDITION(CheckCount(count));
 THROWS;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

if (count == 0)
Clear();
else
 {
Resize(count, REPRESENTATION_UTF8);
strncpy_s(GetRawUTF8(), GetBufferSizeInCharIncludeNullChar(), string, count);
GetRawUTF8()[count] = 0;
 }

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to a copy of the given ANSI string
//-----------------------------------------------------------------------------
voidSString::SetANSI(const ANSI *string)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(string, NULL_OK));
 THROWS;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

if (string == NULL || *string == 0)
Clear();
else
 {
Resize((COUNT_T) strlen(string), REPRESENTATION_ANSI);
strcpy_s(GetRawANSI(), GetBufferSizeInCharIncludeNullChar(), string);
 }

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to a copy of the first count characters of the given
// ANSI string.
//-----------------------------------------------------------------------------
voidSString::SetANSI(const ANSI *string, COUNT_T count)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(string, NULL_OK));
PRECONDITION(CheckCount(count));
 THROWS;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

if (count == 0)
Clear();
else
 {
Resize(count, REPRESENTATION_ANSI);
strncpy_s(GetRawANSI(), GetBufferSizeInCharIncludeNullChar(), string, count);
GetRawANSI()[count] = 0;
 }

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to the given unicode character
//-----------------------------------------------------------------------------
voidSString::Set(WCHAR character)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
 THROWS;
 GC_NOTRIGGER;
 SUPPORTS_DAC_HOST_ONLY;
 }
 SS_CONTRACT_END;

if (character == 0)
Clear();
else
 {
Resize(1, REPRESENTATION_UNICODE);
GetRawUnicode()[0] = character;
GetRawUnicode()[1] = 0;
 }

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to the given UTF8 character
//-----------------------------------------------------------------------------
voidSString::SetUTF8(CHAR character)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
 THROWS;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

if (character == 0)
Clear();
else
 {
Resize(1, REPRESENTATION_UTF8);
GetRawUTF8()[0] = character;
GetRawUTF8()[1] = 0;
 }

 SS_RETURN;
}


//-----------------------------------------------------------------------------
// Set this string to the given ansi literal.
// This will share the memory and not make a copy.
//-----------------------------------------------------------------------------
voidSString::SetLiteral(const ASCII *literal)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(literal));
PRECONDITION(CheckASCIIString(literal));
 THROWS;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

 SString s(Literal, literal);
Set(s);

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Set this string to the given unicode literal.
// This will share the memory and not make a copy.
//-----------------------------------------------------------------------------
voidSString::SetLiteral(const WCHAR *literal)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
PRECONDITION(CheckPointer(literal));
 THROWS;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

 SString s(Literal, literal);
Set(s);

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Hash the string contents
//-----------------------------------------------------------------------------
ULONG SString::Hash() const
{
SS_CONTRACT(ULONG)
 {
 INSTANCE_CHECK;
 THROWS_UNLESS_NORMALIZED;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

ConvertToUnicode();

 SS_RETURN HashString(GetRawUnicode());
}

//-----------------------------------------------------------------------------
// Hash the string contents
//-----------------------------------------------------------------------------
ULONG SString::HashCaseInsensitive() const
{
SS_CONTRACT(ULONG)
 {
 INSTANCE_CHECK;
 THROWS_UNLESS_NORMALIZED;
 GC_NOTRIGGER;
 }
 SS_CONTRACT_END;

ConvertToIteratable();

 ULONG result;

switch (GetRepresentation())
 {
case REPRESENTATION_UNICODE:
case REPRESENTATION_EMPTY:
 result = CaseHashHelper(GetRawUnicode(), GetRawCount());
break;

case REPRESENTATION_ASCII:
 result = CaseHashHelperA(GetRawASCII(), GetRawCount());
break;

default:
UNREACHABLE();
 }

 SS_RETURN result;
}

//-----------------------------------------------------------------------------
// Truncate this string to count characters.
//-----------------------------------------------------------------------------
voidSString::Truncate(const Iterator &i)
{
 SS_CONTRACT_VOID
 {
 INSTANCE_CHECK;
PRECONDITION(CheckIteratorRange(i));
SS_POSTCONDITION(GetRawCount() == i - Begin());
 THROWS;
 GC_NOTRIGGER;
 SUPPORTS_DAC_HOST_ONLY;
 }
 SS_CONTRACT_END;

CONSISTENCY_CHECK(IsFixedSize());

 COUNT_T size = i - Begin();

Resize(size, GetRepresentation(), PRESERVE);

 i.Resync(this, (BYTE *) (GetRawUnicode() + size));

 SS_RETURN;
}

//-----------------------------------------------------------------------------
// Convert the ASCII representation for this String to Unicode. We can do this
// quickly and in-place (if this == &dest), which is why it is optimized.
//-----------------------------------------------------------------------------
voidSString::ConvertASCIIToUnicode(SString &dest) const
{
 CONTRACT_VOID
 {
PRECONDITION(IsRepresentation(REPRESENTATION_ASCII));
POSTCONDITION(dest.IsRepresentation(REPRESENTATION_UNICODE));
 THROWS;
 GC_NOTRIGGER;
 SUPPORTS_DAC_HOST_ONLY;
 }
 CONTRACT_END;

// Handle the empty case.
if (IsEmpty())
 {
 dest.Clear();
 RETURN;
 }

CONSISTENCY_CHECK(CheckPointer(GetRawASCII()));
CONSISTENCY_CHECK(GetRawCount() > 0);

// If dest is the same as this, then we need to preserve on resize.
 dest.Resize(GetRawCount(), REPRESENTATION_UNICODE,
this == &dest ? PRESERVE : DONT_PRESERVE);

// Make sure the buffer is big enough.
CONSISTENCY_CHECK(dest.GetAllocation() > (GetRawCount() * sizeof(WCHAR)));

// This is a poor man's widen. Since we know that the representation is ASCII,
// we can just pad the string with a bunch of zero-value bytes. Of course,
// we move from the end of the string to the start so that we can convert in
// place (in the case that &dest == this).
 WCHAR *outBuf = dest.GetRawUnicode() + dest.GetRawCount();
 ASCII *inBuf = GetRawASCII() + GetRawCount();

while (GetRawASCII() <= inBuf)
 {
CONSISTENCY_CHECK(dest.GetRawUnicode() <= outBuf);
// The casting zero-extends the value, thus giving us the zero-valued byte.
 *outBuf = (WCHAR) *inBuf;
 outBuf--;
 inBuf--;
 }

 RETURN;
}

//-----------------------------------------------------------------------------
// Convert the internal representation for this String to Unicode.
//-----------------------------------------------------------------------------
voidSString::ConvertToUnicode() const
{
 CONTRACT_VOID
 {
POSTCONDITION(IsRepresentation(REPRESENTATION_UNICODE));
if (IsRepresentation(REPRESENTATION_UNICODE)) NOTHROW; else THROWS;
 GC_NOTRIGGER;
 SUPPORTS_DAC_HOST_ONLY;
 }
 CONTRACT_END;

if (!IsRepresentation(REPRESENTATION_UNICODE))
 {
if (IsRepresentation(REPRESENTATION_ASCII))
 {
ConvertASCIIToUnicode(*(const_cast<SString *>(this)));
 }
else
 {
 StackSString s;
ConvertToUnicode(s);
PREFIX_ASSUME(!s.IsImmutable());
 (const_cast<SString*>(this))->Set(s);
 }
 }

 RETURN;
}

//-----------------------------------------------------------------------------
// Convert the internal representation for this String to Unicode, while
// preserving the iterator if the conversion is done.
//-----------------------------------------------------------------------------
voidSString::ConvertToUnicode(const CIterator &i) const
{
 CONTRACT_VOID
 {
PRECONDITION(i.Check());
POSTCONDITION(IsRepresentation(REPRESENTATION_UNICODE));
if (IsRepresentation(REPRESENTATION_UNICODE)) NOTHROW; else THROWS;
 GC_NOTRIGGER;
 SUPPORTS_DAC_HOST_ONLY;
 }
 CONTRACT_END;

if (!IsRepresentation(REPRESENTATION_UNICODE))
 {
CONSISTENCY_CHECK(IsFixedSize());

 COUNT_T index = 0;
// Get the current index of the iterator
if (i.m_ptr != NULL)
 {
CONSISTENCY_CHECK(GetCharacterSizeShift() == 0);
index = (COUNT_T) (i.m_ptr - m_buffer);
 }

if (IsRepresentation(REPRESENTATION_ASCII))
 {
ConvertASCIIToUnicode(*(const_cast<SString *>(this)));
 }
else
 {
 StackSString s;
ConvertToUnicode(s);
 (const_cast<SString*>(this))->Set(s);
 }

// Move the iterator to the new location.
if (i.m_ptr != NULL)
 {
 i.Resync(this, (BYTE *) (GetRawUnicode() + index));
 }
 }

 RETURN;
}

//-----------------------------------------------------------------------------
// Set s to be a copy of this string's contents, but in the unicode format.
//-----------------------------------------------------------------------------
voidSString::ConvertToUnicode(SString &s) const
{
 CONTRACT_VOID
 {
PRECONDITION(s.Check());
POSTCONDITION(s.IsRepresentation(REPRESENTATION_UNICODE));
 THROWS;
 GC_NOTRIGGER;
 SUPPORTS_DAC_HOST_ONLY;
 }
 CONTRACT_END;

int page = 0;

switch (GetRepresentation())
 {
case REPRESENTATION_EMPTY:
 s.Clear();
 RETURN;

case REPRESENTATION_UNICODE:
 s.Set(*this);
 RETURN;

case REPRESENTATION_UTF8:
 page = CP_UTF8;
break;

case REPRESENTATION_ASCII:
ConvertASCIIToUnicode(s);
 RETURN;

case REPRESENTATION_ANSI:
 page = CP_ACP;
break;

default:
UNREACHABLE();
 }

 COUNT_T length = WszMultiByteToWideChar(page, 0, GetRawANSI(), GetRawCount()+1, 0, 0);
if (length == 0)
ThrowLastError();

 s.Resize(length-1, REPRESENTATION_UNICODE);

 length = WszMultiByteToWideChar(page, 0, GetRawANSI(), GetRawCount()+1, s.GetRawUnicode(), length);
if (length == 0)
ThrowLastError();

 RETURN;
}

//-----------------------------------------------------------------------------
// Set s to be a copy of this string's contents, but in the ANSI format.
//-----------------------------------------------------------------------------
voidSString::ConvertToANSI(SString &s) const
{
 CONTRACT_VOID
 {
PRECONDITION(s.Check());
POSTCONDITION(s.IsRepresentation(REPRESENTATION_ANSI));
 THROWS;
 GC_NOTRIGGER;
 }
 CONTRACT_END;

switch (GetRepresentation())
 {
case REPRESENTATION_EMPTY:
 s.Clear();
 RETURN;

case REPRESENTATION_ASCII:
case REPRESENTATION_ANSI:
 s.Set(*this);
 RETURN;

case REPRESENTATION_UTF8:
// No direct conversion to ANSI
ConvertToUnicode();
// fall through

case REPRESENTATION_UNICODE:
break;

default:
UNREACHABLE();
 }

// @todo: use WC_NO_BEST_FIT_CHARS
 COUNT_T length = WszWideCharToMultiByte(CP_ACP, 0, GetRawUnicode(), GetRawCount()+1,
NULL, 0, NULL, NULL);

 s.Resize(length-1, REPRESENTATION_ANSI);

// @todo: use WC_NO_BEST_FIT_CHARS
 length = WszWideCharToMultiByte(CP_ACP, 0, GetRawUnicode(), GetRawCount()+1,
 s.GetRawANSI(), length, NULL, NULL);
if (length == 0)
ThrowLastError();

 RETURN;
}

//-----------------------------------------------------------------------------
// Set s to be a copy of this string's contents, but in the utf8 format.
//-----------------------------------------------------------------------------
COUNT_T SString::ConvertToUTF8(SString &s) const
{
CONTRACT(COUNT_T)
 {
PRECONDITION(s.Check());
POSTCONDITION(s.IsRepresentation(REPRESENTATION_UTF8));
 THROWS;
 GC_NOTRIGGER;
 }
 CONTRACT_END;

switch (GetRepresentation())
 {
case REPRESENTATION_EMPTY:
 s.Clear();
 RETURN 1;

case REPRESENTATION_ASCII:
case REPRESENTATION_UTF8:
 s.Set(*this);
 RETURN s.GetRawCount()+1;

case REPRESENTATION_ANSI:
// No direct conversion from ANSI to UTF8
ConvertToUnicode();
// fall through

case REPRESENTATION_UNICODE:
break;

default:
UNREACHABLE();
 }

// <TODO> @todo: use WC_NO_BEST_FIT_CHARS </TODO>
bool allAscii;
 DWORD length;

 HRESULT hr = FString::Unicode_Utf8_Length(GetRawUnicode(), & allAscii, & length);

if (SUCCEEDED(hr))
 {
 s.Resize(length, REPRESENTATION_UTF8);

//FString::Unicode_Utf8 expects an array all the time
//we optimize the empty string by replacing it with null for SString above in Resize
if (length > 0)
 {
 hr = FString::Unicode_Utf8(GetRawUnicode(), allAscii, (LPSTR) s.GetRawUTF8(), length);
 }
 }

IfFailThrow(hr);