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

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

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

// SString.cpp

//

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

#include "stdafx.h"

#include "sstring.h"

#include "ex.h"

#include "holder.h"

#include <minipal/strings.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);

void SString::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 TARGET_UNIX

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

// For PAL, no locale specific processing is done

if (dwFlags == LCMAP_UPPERCASE)

{

wTmp = (WCHAR)

#ifdef SELF_NO_HOST

toupper(wc);

#else

minipal_toupper_invariant(wc);

#endif

}

else

{

_ASSERTE(dwFlags == LCMAP_LOWERCASE);

wTmp = (WCHAR)

#ifdef SELF_NO_HOST

tolower(wc);

#else

minipal_tolower_invariant(wc);

#endif

}

#endif // !TARGET_UNIX

return wTmp;

}

#define IS_UPPER_A_TO_Z(x) (((x) >= W('A')) && ((x) <= W('Z')))

#define IS_LOWER_A_TO_Z(x) (((x) >= W('a')) && ((x) <= W('z')))

#define CAN_SIMPLE_UPCASE(x) (((x)&~0x7f) == 0)

#define CAN_SIMPLE_DOWNCASE(x) (((x)&~0x7f) == 0)

#define SIMPLE_UPCASE(x) (IS_LOWER_A_TO_Z(x) ? ((x) - W('a') + W('A')) : (x))

#define SIMPLE_DOWNCASE(x) (IS_UPPER_A_TO_Z(x) ? ((x) - W('A') + W('a')) : (x))

/* static */

int SString::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;

}

#define IS_LOWER_A_TO_Z_ANSI(x) (((x) >= 'a') && ((x) <= 'z'))

#define CAN_SIMPLE_UPCASE_ANSI(x) (((x) >= 0x20) && ((x) <= 0x7f))

#define SIMPLE_UPCASE_ANSI(x) (IS_LOWER_A_TO_Z(x) ? ((x) - 'a' + 'A') : (x))

/* static */

int SString::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;

diff = ch1 - ch2;

if (diff != 0 || stopOnNull)

{

if (ch1 == 0 || ch2 == 0)

{

break;

}

diff = (SIMPLE_UPCASE_ANSI(ch1) - SIMPLE_UPCASE_ANSI(ch2));

if (diff != 0)

{

break;

}

}

buffer1++;

buffer2++;

}

return diff;

}

int CaseHashHelper(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;

}

static int CaseHashHelperA(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

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

void SString::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) u16_strlen(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.

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

void SString::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).

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

void SString::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

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

void SString::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

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

void SString::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

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

void SString::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.

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

void SString::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 UTF16 string transcoded to UTF8

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

void SString::SetAndConvertToUTF8(const WCHAR *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;

SString utf16Str(Literal, string);

utf16Str.ConvertToUTF8(*this);

SS_RETURN;

}

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

// Set this string to the given unicode character

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

void SString::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

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

void SString::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.

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

void SString::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.

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

void SString::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.

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

void SString::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.

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

void SString::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.

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

void SString::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.

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

void SString::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;

}

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

// Convert the internal representation for this String to UTF8.

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

void SString::ConvertToUTF8() const

{

CONTRACT_VOID

{

POSTCONDITION(IsRepresentation(REPRESENTATION_UTF8));

if (IsRepresentation(REPRESENTATION_UTF8)) NOTHROW; else THROWS;

GC_NOTRIGGER;

SUPPORTS_DAC_HOST_ONLY;

}

CONTRACT_END;

if (!IsRepresentation(REPRESENTATION_UTF8))

{

if (IsRepresentation(REPRESENTATION_ASCII))

{

// ASCII is a subset of UTF8, so we can just set the representation.

(const_cast<SString*>(this))->SetRepresentation(REPRESENTATION_UTF8);

}

else

{

StackSString s;

ConvertToUTF8(s);

PREFIX_ASSUME(!s.IsImmutable());

(const_cast<SString*>(this))->Set(s);

}

}

RETURN;

}

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

// Set s to be a copy of this string's contents, but in the unicode format.

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

void SString::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;

default:

UNREACHABLE();

}

COUNT_T length = MultiByteToWideChar(page, 0, GetRawANSI(), GetRawCount()+1, 0, 0);

if (length == 0)

ThrowLastError();

s.Resize(length-1, REPRESENTATION_UNICODE);

length = MultiByteToWideChar(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 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_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);

RETURN length + 1;

}

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

// Replace a single character with another character.

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

void SString::Replace(const Iterator &i, WCHAR c)

{

CONTRACT_VOID

{

INSTANCE_CHECK;

PRECONDITION(CheckIteratorRange(i, 1));

POSTCONDITION(Match(i, c));

THROWS;

GC_NOTRIGGER;

}

CONTRACT_END;

if (IsRepresentation(REPRESENTATION_ASCII) && ((c&~0x7f) == 0))

{

*(BYTE*)i.m_ptr = (BYTE) c;

}

else

{

ConvertToUnicode(i);

*(USHORT*)i.m_ptr = c;

}

RETURN;

}

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

// Replace the substring specified by position, length with the given string s.

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

void SString::Replace(const Iterator &i, COUNT_T length, const SString &s)

{

CONTRACT_VOID

{

INSTANCE_CHECK;

PRECONDITION(CheckIteratorRange(i, length));

PRECONDITION(s.Check());

POSTCONDITION(Match(i, s));

THROWS;

GC_NOTRIGGER;

SUPPORTS_DAC_HOST_ONLY;

}

CONTRACT_END;

Representation representation = GetRepresentation();

if (representation == REPRESENTATION_EMPTY)

{

// This special case contains some optimizations (like literal sharing).

Set(s);

ConvertToIteratable();

i.Resync(this, m_buffer);

}

else

{

StackSString temp;

const SString &source = GetCompatibleString(s, temp, i);

COUNT_T deleteSize = length<<GetCharacterSizeShift();

COUNT_T insertSize = source.GetRawCount()<<source.GetCharacterSizeShift();

SBuffer::Replace(i, deleteSize, insertSize);

SBuffer::Copy(i, source.m_buffer, insertSize);

}

RETURN;

}

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

// Find s in this string starting at i. Return TRUE & update iterator if found.

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

BOOL SString::Find(CIterator &i, const SString &s) const

{

CONTRACT(BOOL)

{

INSTANCE_CHECK;

PRECONDITION(CheckIteratorRange(i));

PRECONDITION(s.Check());

POSTCONDITION(RETVAL == Match(i, s));

THROWS_UNLESS_BOTH_NORMALIZED(s);

GC_NOTRIGGER;

}

CONTRACT_END;

// Get a compatible string from s

StackSString temp;

const SString &source = GetCompatibleString(s, temp, i);

switch (GetRepresentation())

{

case REPRESENTATION_UNICODE:

{

COUNT_T count = source.GetRawCount();

const WCHAR *start = i.GetUnicode();

const WCHAR *end = GetUnicode() + GetRawCount() - count;

while (start <= end)

{

if (u16_strncmp(start, source.GetRawUnicode(), count) == 0)

{

i.Resync(this, (BYTE*) start);

RETURN TRUE;

}

start++;

}

}

break;

case REPRESENTATION_ASCII:

{

COUNT_T count = source.GetRawCount();