{

// All filters other than the first just pass on the message

m_Prev->MarkText();

{

// All filters other than the first just pass on the message

return m_Prev->GetMarkedLength();

{

p_filter->m_Prev = this;

m_Next = p_filter;

return true;

{

p_filter->m_Next = this;

m_Prev = p_filter;

return true;

: m_Next(nil), m_Prev(nil)

{

;

{

if (!m_Reverse)

{

// Read the first codeunit and check whether it is a leading surrogate half

unichar_t t_lead = (m_ReadIndex < m_DataLength) ? m_Data[m_ReadIndex] : -1;

if (t_lead < 0xD800 || t_lead >= 0xDC00)

return t_lead;

// Read another codeunit to check whether it is an trailing surrogate half

unichar_t t_trail = (m_ReadIndex + 1 < m_DataLength) ? m_Data[m_ReadIndex+1] : -1;

if (t_trail < 0xDC00 || t_trail >= 0xE000)

return t_lead;

// Valid surrogate pair

m_surrogate = true;

return MCUnicodeSurrogatesToCodepoint(t_lead, t_trail);

}

// Read the first codeunit from end and check whether it is a trailing surrogate half

unichar_t t_trail = (m_ReadIndex < m_DataLength) ? m_Data[m_DataLength - m_ReadIndex - 1] : -1;

if (t_trail < 0xDC00 || t_trail >= 0xE000)

return t_trail;

// Read another codeunit to check whether it is an trailing surrogate half

unichar_t t_lead = (m_ReadIndex + 1 < m_DataLength) ? m_Data[m_DataLength - m_ReadIndex - 2] : -1;

if (t_lead < 0xD800 || t_lead >= 0xDC00)

return t_trail;

// Valid surrogate pair

m_surrogate = true;

return MCUnicodeSurrogatesToCodepoint(t_lead, t_trail);

{

if (m_surrogate)

m_ReadIndex += 2;

else

m_ReadIndex += 1;

m_surrogate = false;

return m_ReadIndex < m_DataLength;

: m_surrogate(false), m_AcceptedIndex(-1), m_ReadIndex(0), m_Data(p_text), m_DataLength(p_length), m_Reverse(p_from_end)

{

;

{

// Don't read beyond the end of the input if no data remains

if (m_ReadIndex >= m_DataLength)

return 0;

if (m_Reverse)

return MCUnicodeMapFromNative(m_Data[m_DataLength - m_ReadIndex - 1]);

return MCUnicodeMapFromNative(m_Data[m_ReadIndex]);

: m_Data(p_text), m_DataLength(p_length), m_AcceptedIndex(-1), m_ReadIndex(0), m_Reverse(p_from_end)

{

;

{

// Get a codepoint from the preceding filter

codepoint_t t_raw;

t_raw = PrevFilter()->GetNextCodepoint();

// Case fold the codepoint

codepoint_t t_folded;

t_folded = MCUnicodeGetCharacterProperty(t_raw, kMCUnicodePropertySimpleCaseFolding);

return t_folded;

{

if (m_Reverse)

return GetNextCodepointReverse();

// If possible, return a codepoint from the cached state

if (m_ReadIndex < m_StateLength)

{

// AL-2014-10-23: [[ Bug 13762 ]] Update the mark point when fetching codepoints from the state

m_MarkPoint++;

// Check whether we have a surrogate pair

// We are sure to have the following trail surrogate if we find a lead surrogate

if (m_State[m_ReadIndex] > 0xD800 && m_State[m_ReadIndex] < 0xDBFF)

{

m_MarkPoint++;

m_surrogate = true;

return MCUnicodeSurrogatesToCodepoint(m_State[m_ReadIndex], m_State[m_ReadIndex + 1]);

}

return m_State[m_ReadIndex];

}

PrevFilter()->MarkText();

m_MarkPoint = PrevFilter()->GetMarkedLength();

// Otherwise, the state needs to be refreshed. Loop until we get to a

// normalisation boundary (i.e a base character)

codepoint_t t_cp;

m_StateLength = 0;

while (PrevFilter()->HasData())

{

t_cp = PrevFilter()->GetNextCodepoint();

// The first character is always added to the state

if (m_StateLength == 0)

{

// Check whether the codepoint we got is a surrogate pair

if (MCUnicodeCodepointToSurrogates(t_cp, m_State[m_StateLength],

m_State[m_StateLength + 1]))

m_StateLength++;

m_StateLength++;

PrevFilter()->AdvanceCursor();

}

// Non-first grapheme base characters terminate the run

else if (MCUnicodeGetBinaryProperty(t_cp, kMCUnicodePropertyGraphemeBase) || MCUnicodeGetBinaryProperty(t_cp, kMCUnicodePropertyWhiteSpace))

{

break;

}

// All other characters are appended to the state

else

{

// Check whether the codepoint we got is a surrogate pair

if (MCUnicodeCodepointToSurrogates(t_cp, m_State[m_StateLength],

m_State[m_StateLength+1]))

m_StateLength++;

m_StateLength++;

PrevFilter()->AdvanceCursor();

}

// Abort if our arbitrary limit has been reached

if (m_StateLength == kMCTextFilterMaxNormLength)

break;

}

// Normalise the state

unichar_t *t_norm;

uindex_t t_norm_length;

MCUnicodeNormaliseNFC(m_State, m_StateLength, t_norm, t_norm_length);

// Copy the normalised state to the internal state (note: we assume that

// composing will never create a longer string)

MCMemoryCopy(m_State, t_norm, t_norm_length * sizeof(unichar_t));

m_StateLength = t_norm_length;

m_ReadIndex = 0;

free (t_norm);

// All done

if (m_State[0] > 0xD800 && m_State[0] < 0xDBFF)

{

m_surrogate = true;

return MCUnicodeSurrogatesToCodepoint(m_State[0], m_State[1]);

}

else

return m_State[0];

{

// If possible, return a codepoint from the cached state

if (m_ReadIndex < m_StateLength)

{

// AL-2014-10-23: [[ Bug 13762 ]] Update the mark point when fetching codepoints from the state

m_MarkPoint++;

// We are sure to have the preceding lead surrogate if we find a trail surrogate

if (m_State[kMCTextFilterMaxNormLength - m_ReadIndex - 1] >= 0xDC00 && m_State[kMCTextFilterMaxNormLength - m_ReadIndex - 1] < 0xE000)

{

m_MarkPoint++;

m_surrogate = true;

return MCUnicodeSurrogatesToCodepoint(m_State[kMCTextFilterMaxNormLength - m_ReadIndex - 2], m_State[kMCTextFilterMaxNormLength - m_ReadIndex - 1]);

}

return m_State[kMCTextFilterMaxNormLength - m_ReadIndex - 1];

}

PrevFilter()->MarkText();

m_MarkPoint = PrevFilter()->GetMarkedLength();

// Otherwise, the state needs to be refreshed. Loop until we get to a

// normalisation boundary (i.e a base character)

codepoint_t t_cp;

m_StateLength = 0;

while (PrevFilter()->HasData())

{

t_cp = PrevFilter()->GetNextCodepoint();

// The first character is always added to the state

if (m_StateLength == 0)

{

// Check whether the codepoint we got is a surrogate pair

if (MCUnicodeCodepointToSurrogates(t_cp,

m_State[kMCTextFilterMaxNormLength - 2],

m_State[kMCTextFilterMaxNormLength - 1]))

m_StateLength++;

else

m_State[kMCTextFilterMaxNormLength - 1] = m_State[kMCTextFilterMaxNormLength - 2];

m_StateLength++;

PrevFilter()->AdvanceCursor();

}

// All other characters are appended to the state

else

{

// Check whether the codepoint we got is a surrogate pair

if (MCUnicodeCodepointToSurrogates(t_cp,

m_State[kMCTextFilterMaxNormLength - m_StateLength - 2],

m_State[kMCTextFilterMaxNormLength - m_StateLength - 1]))

m_StateLength++;

else

m_State[kMCTextFilterMaxNormLength - m_StateLength - 1] = m_State[kMCTextFilterMaxNormLength - m_StateLength - 2];

m_StateLength++;

PrevFilter()->AdvanceCursor();

}

// The backwards run is terminated after a grapheme base.

if (MCUnicodeGetBinaryProperty(t_cp, kMCUnicodePropertyGraphemeBase) || MCUnicodeGetBinaryProperty(t_cp, kMCUnicodePropertyWhiteSpace))

{

break;

}

// Abort if our arbitrary limit has been reached

if (m_StateLength == kMCTextFilterMaxNormLength)

break;

}

// Normalise the state

unichar_t *t_norm;

uindex_t t_norm_length;

MCUnicodeNormaliseNFC(m_State + kMCTextFilterMaxNormLength - m_StateLength, m_StateLength, t_norm, t_norm_length);

// Copy the normalised state to the internal state (note: we assume that

// composing will never create a longer string)

uindex_t i = 0;

while (t_norm_length)

m_State[kMCTextFilterMaxNormLength - t_norm_length--] = t_norm[i++];

m_StateLength = i;

m_ReadIndex = 0;

free (t_norm);

// All done

if (m_StateLength > 1 && m_State[kMCTextFilterMaxNormLength - 2] > 0xD800 && m_State[kMCTextFilterMaxNormLength - 2] < 0xDBFF)

{

m_surrogate = true;

return MCUnicodeSurrogatesToCodepoint(m_State[kMCTextFilterMaxNormLength - 2], m_State[kMCTextFilterMaxNormLength - 1]);

}

else

return m_State[kMCTextFilterMaxNormLength - 1];

{

m_ReadIndex++;

if (m_surrogate)

{

m_ReadIndex++;

m_surrogate = false;

}

return HasData();

{

// Only mark on run boundaries

m_MarkedLength = m_MarkPoint;

: m_StateLength(0), m_ReadIndex(0), m_MarkedLength(0), m_MarkPoint(0), m_surrogate(false), m_Reverse(p_from_end)

{

;