{

if (t_codepoint < 0x10000)

{

*r_surrogates = (unichar_t)t_codepoint;

return false;

}

else

{

r_surrogates[0] = (((t_codepoint - 0x10000) & 0xFFC00) >> 10) + 0xD800;

r_surrogates[1] = (t_codepoint & 0x3FF) + 0xDC00;

return true;

}

{

if (p_property != kMCUnicodePropertyNumericValue)

return std::numeric_limits<double>::quiet_NaN();

return u_getNumericValue(p_codepoint);

{

// Only a subset of the string properties are supported here

switch (p_property)

{

case kMCUnicodePropertyBidiMirroringGlyph:

return u_charMirror(p_codepoint);

case kMCUnicodePropertyBidiPairedBracket:

return u_getBidiPairedBracket(p_codepoint);

case kMCUnicodePropertySimpleLowercaseMapping:

return u_tolower(p_codepoint);

case kMCUnicodePropertySimpleUppercaseMapping:

return u_toupper(p_codepoint);

case kMCUnicodePropertySimpleTitlecaseMapping:

return u_totitle(p_codepoint);

case kMCUnicodePropertySimpleCaseFolding:

return u_foldCase(p_codepoint, U_FOLD_CASE_DEFAULT);

default:

return ~codepoint_t(0);

}

MCUnicodePropertyType p_property_type, void *x_result_array)

{

// Scan through the character string

uindex_t t_offset = 0;

while (t_offset < p_char_count)

{

// Is this a simple character or a surrogate?

// If the surrogate is not valid, just ignore the error

codepoint_t t_char = p_chars[t_offset];

uindex_t t_advance = 1;

if (MCUnicodeCodepointIsLeadingSurrogate(t_char) &&

(t_offset + 1) < p_char_count &&

MCUnicodeCodepointIsTrailingSurrogate(p_chars[t_offset + 1]))

{

t_char = MCUnicodeCombineSurrogates(t_char, p_chars[t_offset + 1]);

t_advance = 2;

}

// Look up the property

//

// The general behaviour of this is to retrieve the property at its full

// precision and then attempt to convert it to the requested type. If

// the conversion would alter the value, it is rejected and the function

// call fails. Otherwise it moves on to the next character.

//

// When UTF-16 surrogate pairs are encountered, the slots in the result

// array for the upper and lower surrogates are set to the same value

// (that being the value of the property for the corresponding Unicode

// codepoint rather than the surrogates as individual values).

switch (p_property_type)

{

case kMCUnicodePropertyTypeBool:

{

bool t_prop;

t_prop = MCUnicodeGetBinaryProperty(t_char, p_property);

((bool*)x_result_array)[t_offset] = t_prop;

if (t_advance == 2)

((bool*)x_result_array)[t_offset + 1] = t_prop;

break;

}

case kMCUnicodePropertyTypeUint8:

{

int32_t t_prop;

t_prop = MCUnicodeGetIntegerProperty(t_char, p_property);

if (t_prop < 0 || t_prop > UINT8_MAX)

return false;

((uint8_t*)x_result_array)[t_offset] = uint8_t(t_prop);

if (t_advance == 2)

((uint8_t*)x_result_array)[t_offset + 1] = uint8_t(t_prop);

break;

}

case kMCUnicodePropertyTypeUint16:

{

int32_t t_prop;

t_prop = MCUnicodeGetIntegerProperty(t_char, p_property);

if (t_prop < 0 || t_prop > UINT16_MAX)

return false;

((uint16_t*)x_result_array)[t_offset] = uint16_t(t_prop);

if (t_advance == 2)

((uint16_t*)x_result_array)[t_offset + 1] = uint16_t(t_prop);

break;

}

case kMCUnicodePropertyTypeUint32:

{

int32_t t_prop;

t_prop = MCUnicodeGetIntegerProperty(t_char, p_property);

if (t_prop < 0 || t_prop > UINT32_MAX)

return false;

((uint32_t*)x_result_array)[t_offset] = uint32_t(t_prop);

if (t_advance == 2)

((uint32_t*)x_result_array)[t_offset + 1] = uint32_t(t_prop);

break;

}

case kMCUnicodePropertyTypeFloat:

{

// There is no checking to ensure that the double can be losslessly

// converted to a float; doing so would make certain values (e.g.

// 1/3) unrepresentable as floats. The FPU should also handle

// out-of-range values correctly, turning them into infinities.

//

// On the other hand, (hopefully) nobody expects floating-point

// values to be exact in the first place...

double t_prop;

t_prop = MCUnicodeGetFloatProperty(t_char, p_property);

((float*)x_result_array)[t_offset] = float(t_prop);

if (t_advance == 2)

((float*)x_result_array)[t_offset + 1] = float(t_prop);

break;

}

case kMCUnicodePropertyTypeDouble:

{

double t_prop;

t_prop = MCUnicodeGetFloatProperty(t_char, p_property);

((double*)x_result_array)[t_offset] = t_prop;

if (t_advance == 2)

((double*)x_result_array)[t_offset + 1] = t_prop;

break;

}

case kMCUnicodePropertyTypeCharacter:

{

codepoint_t t_prop;

t_prop = MCUnicodeGetCharacterProperty(t_char, p_property);

((codepoint_t*)x_result_array)[t_offset] = t_prop;

if (t_advance == 2)

((codepoint_t*)x_result_array)[t_offset + 1] = t_prop;

break;

}

case kMCUnicodePropertyTypeString:

{

const unichar_t *t_prop;

t_prop = MCUnicodeGetStringProperty(t_char, p_property);

((const unichar_t**)x_result_array)[t_offset] = t_prop;

if (t_advance == 2)

((const unichar_t**)x_result_array)[t_offset + 1] = t_prop;

break;

}

default:

// Shouldn't get here

MCAssert(false);

}

// Move on to the next UTF-16 character

t_offset += t_advance;

}

// All done

return true;

unichar_t *&r_out, uindex_t &r_out_length)

{

// Get the instance of the NFC normaliser

UErrorCode t_error;

const Normalizer2 *t_normaliser;

t_error = U_ZERO_ERROR;

t_normaliser = icu::Normalizer2::getNFCInstance(t_error);

if (U_FAILURE(t_error))

return false;

// Create an ICU string for the input string

icu::UnicodeString t_input(p_in, p_in_length);

// Normalise

icu::UnicodeString t_output;

t_output = t_normaliser->normalize(t_input, t_error);

if (U_FAILURE(t_error))

return false;

// Allocate the output buffer

MCAutoArray<unichar_t> t_buffer;

if (!t_buffer.New(t_output.length()))

return false;

// Copy the normalised string to the buffer

t_output.extract(t_buffer.Ptr(), t_buffer.Size(), t_error);

if (U_FAILURE(t_error))

return false;

// All done

t_buffer.Take(r_out, r_out_length);

return true;

unichar_t *&r_out, uindex_t &r_out_length)

{

// Get the instance of the NFKC normaliser

UErrorCode t_error;

const Normalizer2 *t_normaliser;

t_error = U_ZERO_ERROR;

t_normaliser = icu::Normalizer2::getNFKCInstance(t_error);

if (U_FAILURE(t_error))

return false;

// Create an ICU string for the input string

icu::UnicodeString t_input(p_in, p_in_length);

// Normalise

icu::UnicodeString t_output;

t_output = t_normaliser->normalize(t_input, t_error);

if (U_FAILURE(t_error))

return false;

// Allocate the output buffer

MCAutoArray<unichar_t> t_buffer;

if (!t_buffer.New(t_output.length()))

return false;

// Copy the normalised string to the buffer

t_output.extract(t_buffer.Ptr(), t_buffer.Size(), t_error);

if (U_FAILURE(t_error))

return false;

// All done

t_buffer.Take(r_out, r_out_length);

return true;

unichar_t *&r_out, uindex_t &r_out_length)

{

// Get the instance of the NFD normaliser

UErrorCode t_error;

const Normalizer2 *t_normaliser;

t_error = U_ZERO_ERROR;

t_normaliser = icu::Normalizer2::getNFDInstance(t_error);

if (U_FAILURE(t_error))

return false;

// Create an ICU string for the input string

icu::UnicodeString t_input(p_in, p_in_length);

// Normalise

icu::UnicodeString t_output;

t_output = t_normaliser->normalize(t_input, t_error);

if (U_FAILURE(t_error))

return false;

// Allocate the output buffer

MCAutoArray<unichar_t> t_buffer;

if (!t_buffer.New(t_output.length()))

return false;

// Copy the normalised string to the buffer

t_output.extract(t_buffer.Ptr(), t_buffer.Size(), t_error);

if (U_FAILURE(t_error))

return false;

// All done

t_buffer.Take(r_out, r_out_length);

return true;

unichar_t *&r_out, uindex_t &r_out_length)

{

// Get the instance of the NFC normaliser

UErrorCode t_error;

const Normalizer2 *t_normaliser;

t_error = U_ZERO_ERROR;

t_normaliser = icu::Normalizer2::getNFCInstance(t_error);

if (U_FAILURE(t_error))

return false;

// Create an ICU string for the input string

icu::UnicodeString t_input(p_in, p_in_length);

// Normalise

icu::UnicodeString t_output;

t_output = t_normaliser->normalize(t_input, t_error);

if (U_FAILURE(t_error))

return false;

// Allocate the output buffer

MCAutoArray<unichar_t> t_buffer;

if (!t_buffer.New(t_output.length()))

return false;

// Copy the normalised string to the buffer

t_output.extract(t_buffer.Ptr(), t_buffer.Size(), t_error);

if (U_FAILURE(t_error))

return false;

// All done

t_buffer.Take(r_out, r_out_length);

return true;

{

// Get the instance of the NFC normaliser

UErrorCode t_error;

const UNormalizer2 *t_normalizer;

t_error = U_ZERO_ERROR;

t_normalizer = unorm2_getNFCInstance(&t_error);

if (U_FAILURE(t_error))

return false;

// Check for normalisation

UBool t_result;

t_result = unorm2_isNormalized(t_normalizer, p_string, p_length, &t_error);

if (U_FAILURE(t_error))

return false;

return !!t_result;

{

// Get the instance of the NFKC normaliser

UErrorCode t_error;

const UNormalizer2 *t_normalizer;

t_error = U_ZERO_ERROR;

t_normalizer = unorm2_getNFKCInstance(&t_error);

if (U_FAILURE(t_error))

return false;

// Check for normalisation

UBool t_result;

t_result = unorm2_isNormalized(t_normalizer, p_string, p_length, &t_error);

if (U_FAILURE(t_error))

return false;

return !!t_result;

{

// Get the instance of the NFD normaliser

UErrorCode t_error;

const UNormalizer2 *t_normalizer;

t_error = U_ZERO_ERROR;

t_normalizer = unorm2_getNFDInstance(&t_error);

if (U_FAILURE(t_error))

return false;

// Check for normalisation

UBool t_result;

t_result = unorm2_isNormalized(t_normalizer, p_string, p_length, &t_error);

if (U_FAILURE(t_error))

return false;

return !!t_result;

{

// Get the instance of the NFKD normaliser

UErrorCode t_error;

const UNormalizer2 *t_normalizer;

t_error = U_ZERO_ERROR;

t_normalizer = unorm2_getNFKDInstance(&t_error);

if (U_FAILURE(t_error))

return false;

// Check for normalisation

UBool t_result;

t_result = unorm2_isNormalized(t_normalizer, p_string, p_length, &t_error);

if (U_FAILURE(t_error))

return false;

return !!t_result;

const unichar_t *p_in, uindex_t p_in_length,

unichar_t *&r_out, uindex_t &r_out_length)

{

// Do the casing using icu::UnicodeString. Note that a locale is required.

UErrorCode t_error = U_ZERO_ERROR;

icu::UnicodeString t_input(p_in, p_in_length);

t_input.toLower(MCLocaleGetICULocale(p_locale));

// Allocate the output buffer

MCAutoArray<unichar_t> t_buffer;

if (!t_buffer.New(t_input.length() + 1))

return false;

// Extract the converted characters

t_input.extract(t_buffer.Ptr(), t_input.length(), t_error);

if (U_FAILURE(t_error))

return false;

// Done

t_buffer.Take(r_out, r_out_length);

r_out_length--;

r_out[r_out_length] = 0;

return true;

const unichar_t *p_in, uindex_t p_in_length,

unichar_t *&r_out, uindex_t &r_out_length)

{

// Do the casing using icu::UnicodeString. Note that a locale is required.

UErrorCode t_error = U_ZERO_ERROR;

icu::UnicodeString t_input(p_in, p_in_length);

t_input.toUpper(MCLocaleGetICULocale(p_locale));

// Allocate the output buffer

MCAutoArray<unichar_t> t_buffer;

if (!t_buffer.New(t_input.length()))

return false;

// Extract the converted characters

t_input.extract(t_buffer.Ptr(), t_buffer.Size(), t_error);

if (U_FAILURE(t_error))

return false;

// Done

t_buffer.Take(r_out, r_out_length);

return true;

const unichar_t *p_in, uindex_t p_in_length,

unichar_t *&r_out, uindex_t &r_out_length)

{

// The ICU UnicodeString class is convenient for case transformations

UErrorCode t_error = U_ZERO_ERROR;

icu::UnicodeString t_input(p_in, p_in_length);

// By supplying no specific break iterator, the default is used

t_input.toTitle(NULL, MCLocaleGetICULocale(p_locale));

// Allocate the output buffer

MCAutoArray<unichar_t> t_buffer;

if (!t_buffer.New(t_input.length()))

return false;

// Extract the converted characters

t_input.extract(t_buffer.Ptr(), t_buffer.Size(), t_error);

if (U_FAILURE(t_error))

return false;

// Done

t_buffer.Take(r_out, r_out_length);

return true;

{

icu::UnicodeString t_temp;

int32_t i = 0;

while(i < p_string.length())

{

t_temp.append(u_toupper(p_string.char32At(i)/*, U_FOLD_CASE_DEFAULT*/));

i = p_string.moveIndex32(i, 1);

}

p_string.setTo(t_temp);

unichar_t *&r_out, uindex_t &r_out_length)

{

// The ICU UnicodeString class is convenient for case transformations

UErrorCode t_error = U_ZERO_ERROR;

icu::UnicodeString t_input(p_in, p_in_length);

// Unlike the other case transformations, case folding does not depend on

// locale. Its only option is whether to use the special Turkish rules for

// casefolding dotless i and dotted l but we don't support this.

__MCUnicodeSimpleCaseFold(t_input);

// Allocate the output buffer

MCAutoArray<unichar_t> t_buffer;

if (!t_buffer.New(t_input.length()))

return false;

// Extract the converted characters

t_input.extract(t_buffer.Ptr(), t_buffer.Size(), t_error);

if (U_FAILURE(t_error))

return false;

// Done

t_buffer.Take(r_out, r_out_length);

return true;

const void *p_second, uindex_t p_second_length, bool p_second_native,

MCUnicodeCompareOption p_option)

{

// Create the filters

MCAutoPointer<MCTextFilter> t_first_filter =

MCTextFilterCreate(p_first, p_first_length, p_first_native ? kMCStringEncodingNative : kMCStringEncodingUTF16, p_option);

MCAutoPointer<MCTextFilter> t_second_filter =

MCTextFilterCreate(p_second, p_second_length, p_second_native ? kMCStringEncodingNative : kMCStringEncodingUTF16, p_option);

while (t_first_filter->HasData() && t_second_filter->HasData())

{

// NOTE: this is a simple codepoint compare and produces a binary

// ordering rather than a lexical ordering.

int32_t t_diff;

t_diff = t_first_filter->GetNextCodepoint() - t_second_filter->GetNextCodepoint();

if (t_diff != 0)

{

return t_diff;

}

t_first_filter->AdvanceCursor();

t_second_filter->AdvanceCursor();

}

bool t_first_longer = t_first_filter->HasData();

bool t_second_longer = t_second_filter->HasData();

if (t_first_longer)

return 1;

else if (t_second_longer)

return -1;

else

return 0;

const void *p_second, uindex_t p_second_length, bool p_second_native,

MCUnicodeCompareOption p_option, uindex_t *r_first_match_length)

{

// Check for a shared prefix

uindex_t t_first_match_length, t_second_match_length;

MCUnicodeSharedPrefix(p_first, p_first_length, p_first_native, p_second, p_second_length, p_second_native, p_option, t_first_match_length, t_second_match_length);

if (t_second_match_length != p_second_length)

return false;

if (r_first_match_length != nil)

*r_first_match_length = t_first_match_length;

return true;

const void *p_second, uindex_t p_second_length, bool p_second_native,

MCUnicodeCompareOption p_option, uindex_t *r_first_match_length)

{

// Check for a shared suffix

uindex_t t_first_match_length, t_second_match_length;

MCUnicodeSharedSuffix(p_first, p_first_length, p_first_native, p_second, p_second_length, p_second_native, p_option, t_first_match_length, t_second_match_length);

if (t_second_match_length != p_second_length)

return false;

if (r_first_match_length != nil)

*r_first_match_length = t_first_match_length;

return true;

const void *p_needle, uindex_t p_needle_length, bool p_needle_native,

MCUnicodeCompareOption p_option)

{

uindex_t ignored;

return MCUnicodeFirstIndexOf(p_string, p_string_length, p_string_native, p_needle, p_needle_length, p_needle_native, p_option, ignored);

const void *p_needle, uindex_t p_needle_length, bool p_needle_native,

MCUnicodeCompareOption p_option, uindex_t &r_index)

{

// Avoid potential problems

if (p_string_length == 0 || p_needle_length == 0)

return false;

// Shortcut for native char - for which we are sure to have only one char to compare, and no composing characters

if (p_needle_length == 1)

{

codepoint_t t_needle;

bool t_ok_fast;

if (p_needle_native)

{

t_needle = codepoint_t(*reinterpret_cast<const char_t *>(p_needle));

t_ok_fast = t_needle < 0x80; /* Needle is one ASCII char */

}

else

{

t_needle = codepoint_t(*reinterpret_cast<const unichar_t *>(p_needle));

t_ok_fast = t_needle < 0xd800; /* Needle is in BMP */

}

if (t_ok_fast)

{

// if we got here, the string should not have been native.

MCAssert(!p_string_native);

return MCUnicodeFirstIndexOfChar((const unichar_t *)p_string, p_string_length, t_needle, p_option, r_index);

}

}

// Create filter chains for the strings being searched