{

m_ptr = nil;

}

~MCAutoPointer(void)

{

};

MCTextFilter *MCTextFilterCreate(MCStringRef, MCStringOptions);

MCTextFilter *MCTextFilterCreate(MCDataRef, MCStringEncoding, MCStringOptions);

MCTextFilter *MCTextFilterCreate(const void *, uindex_t, MCStringEncoding, MCStringOptions, bool from_end = false);

#endif

return t_chain;

}

MCUnicodeCompareOption p_option)

{

// Create the filters

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

{

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

if (t_diff != 0)

{

return t_diff;

}

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)

}

// Create filter chains for the strings being searched

// We only want the first codepoint of the needle (for now)

codepoint_t t_needle_start = t_needle_filter->GetNextCodepoint();

if (t_needle_matched_len == p_needle_length)

{

r_index = t_offset;

return true;

}

}

}

// No match was found

return false;

}

}

// Create filter chains for the strings being searched

// We only want the last codepoint of the needle (for now)

codepoint_t t_needle_end = t_needle_filter->GetNextCodepoint();

if (t_needle_matched_len == p_needle_length)

{

r_index = t_offset - t_string_matched_len;

return true;

}

}

}

// No match was found

return false;

}

uindex_t &r_index)

{

// Create filter chain for the string being searched

// Process the needle codepoint according to the string options.

// We use NFC for normalization, so all single char unicode strings

{

t_string_filter->MarkText();

r_index = t_string_filter->GetMarkedLength() - 1;

return true;

}

t_string_filter->AdvanceCursor();

}

// Could not find the character

return false;

}

uindex_t &r_index)

{

// Create filter chain for the string being searched

// Loop until we find the character

while (t_string_filter->HasData())

{

t_string_filter->MarkText();

r_index = p_string_length - t_string_filter->GetMarkedLength();

return true;

}

t_string_filter->AdvanceCursor();

}

// Could not find the character

return false;

}

}

// Set up the filter chains for the strings

// Keep looping until the strings no longer match

while (t_string_filter->GetNextCodepoint() == t_prefix_filter->GetNextCodepoint())

// subsequences of normalised runs of combining chars.

r_len_in_string = t_string_filter->GetMarkedLength() - 1;

r_len_in_prefix = t_prefix_filter->GetMarkedLength() - 1;

}

void MCUnicodeSharedSuffix(const void *p_string, uindex_t p_string_length, bool p_string_native,

}

// Set up the filter chains for the strings

// Keep looping until the strings no longer match

while (t_string_filter->GetNextCodepoint() == t_suffix_filter->GetNextCodepoint())

// subsequences of normalised runs of combining chars.

r_len_in_string = t_string_filter->GetMarkedLength() - 1;

r_len_in_suffix = t_suffix_filter->GetMarkedLength() - 1;

}

bool MCUnicodeFind(const void *p_string, uindex_t p_string_length, bool p_string_native,

hash_t MCUnicodeHash(const unichar_t *p_string, uindex_t p_string_length, MCUnicodeCompareOption p_option)

{

// Create a filter for the string

// Fowler-Noll-Vo 1a hash function

if (sizeof(hash_t) == sizeof(uint64_t))

t_hash *= kPrime;

}

return t_hash;

}

else

t_hash ^= t_char >> 8;

t_hash *= kPrime;

}

return t_hash;

}

}

bool MCUnicodeWildcardMatch(const void *source_chars, uindex_t source_length, bool p_source_native, const void *pattern_chars, uindex_t pattern_length, bool p_pattern_native, MCUnicodeCompareOption p_option)

{

// Set up the filter chains for the strings

codepoint_t t_source_cp, t_pattern_cp;