| /* | |
| ************************************************************************* | |
| * COPYRIGHT: | |
| * Copyright (c) 1996-2012, International Business Machines Corporation and | |
| * others. All Rights Reserved. | |
| ************************************************************************* | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_NORMALIZATION | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "unicode/uniset.h" | |
| #include "unicode/unistr.h" | |
| #include "unicode/chariter.h" | |
| #include "unicode/schriter.h" | |
| #include "unicode/uchriter.h" | |
| #include "unicode/normlzr.h" | |
| #include "unicode/utf16.h" | |
| #include "cmemory.h" | |
| #include "normalizer2impl.h" | |
| #include "uprops.h" // for uniset_getUnicode32Instance() | |
| U_NAMESPACE_BEGIN | |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Normalizer) | |
| //------------------------------------------------------------------------- | |
| // Constructors and other boilerplate | |
| //------------------------------------------------------------------------- | |
| Normalizer::Normalizer(const UnicodeString& str, UNormalizationMode mode) : | |
| UObject(), fFilteredNorm2(NULL), fNorm2(NULL), fUMode(mode), fOptions(0), | |
| text(new StringCharacterIterator(str)), | |
| currentIndex(0), nextIndex(0), | |
| buffer(), bufferPos(0) | |
| { | |
| init(); | |
| } | |
| Normalizer::Normalizer(const UChar *str, int32_t length, UNormalizationMode mode) : | |
| UObject(), fFilteredNorm2(NULL), fNorm2(NULL), fUMode(mode), fOptions(0), | |
| text(new UCharCharacterIterator(str, length)), | |
| currentIndex(0), nextIndex(0), | |
| buffer(), bufferPos(0) | |
| { | |
| init(); | |
| } | |
| Normalizer::Normalizer(const CharacterIterator& iter, UNormalizationMode mode) : | |
| UObject(), fFilteredNorm2(NULL), fNorm2(NULL), fUMode(mode), fOptions(0), | |
| text(iter.clone()), | |
| currentIndex(0), nextIndex(0), | |
| buffer(), bufferPos(0) | |
| { | |
| init(); | |
| } | |
| Normalizer::Normalizer(const Normalizer ©) : | |
| UObject(copy), fFilteredNorm2(NULL), fNorm2(NULL), fUMode(copy.fUMode), fOptions(copy.fOptions), | |
| text(copy.text->clone()), | |
| currentIndex(copy.currentIndex), nextIndex(copy.nextIndex), | |
| buffer(copy.buffer), bufferPos(copy.bufferPos) | |
| { | |
| init(); | |
| } | |
| void | |
| Normalizer::init() { | |
| UErrorCode errorCode=U_ZERO_ERROR; | |
| fNorm2=Normalizer2Factory::getInstance(fUMode, errorCode); | |
| if(fOptions&UNORM_UNICODE_3_2) { | |
| delete fFilteredNorm2; | |
| fNorm2=fFilteredNorm2= | |
| new FilteredNormalizer2(*fNorm2, *uniset_getUnicode32Instance(errorCode)); | |
| } | |
| if(U_FAILURE(errorCode)) { | |
| errorCode=U_ZERO_ERROR; | |
| fNorm2=Normalizer2Factory::getNoopInstance(errorCode); | |
| } | |
| } | |
| Normalizer::~Normalizer() | |
| { | |
| delete fFilteredNorm2; | |
| delete text; | |
| } | |
| Normalizer* | |
| Normalizer::clone() const | |
| { | |
| return new Normalizer(*this); | |
| } | |
| /** | |
| * Generates a hash code for this iterator. | |
| */ | |
| int32_t Normalizer::hashCode() const | |
| { | |
| return text->hashCode() + fUMode + fOptions + buffer.hashCode() + bufferPos + currentIndex + nextIndex; | |
| } | |
| UBool Normalizer::operator==(const Normalizer& that) const | |
| { | |
| return | |
| this==&that || | |
| (fUMode==that.fUMode && | |
| fOptions==that.fOptions && | |
| *text==*that.text && | |
| buffer==that.buffer && | |
| bufferPos==that.bufferPos && | |
| nextIndex==that.nextIndex); | |
| } | |
| //------------------------------------------------------------------------- | |
| // Static utility methods | |
| //------------------------------------------------------------------------- | |
| void U_EXPORT2 | |
| Normalizer::normalize(const UnicodeString& source, | |
| UNormalizationMode mode, int32_t options, | |
| UnicodeString& result, | |
| UErrorCode &status) { | |
| if(source.isBogus() || U_FAILURE(status)) { | |
| result.setToBogus(); | |
| if(U_SUCCESS(status)) { | |
| status=U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| } else { | |
| UnicodeString localDest; | |
| UnicodeString *dest; | |
| if(&source!=&result) { | |
| dest=&result; | |
| } else { | |
| // the source and result strings are the same object, use a temporary one | |
| dest=&localDest; | |
| } | |
| const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, status); | |
| if(U_SUCCESS(status)) { | |
| if(options&UNORM_UNICODE_3_2) { | |
| FilteredNormalizer2(*n2, *uniset_getUnicode32Instance(status)). | |
| normalize(source, *dest, status); | |
| } else { | |
| n2->normalize(source, *dest, status); | |
| } | |
| } | |
| if(dest==&localDest && U_SUCCESS(status)) { | |
| result=*dest; | |
| } | |
| } | |
| } | |
| void U_EXPORT2 | |
| Normalizer::compose(const UnicodeString& source, | |
| UBool compat, int32_t options, | |
| UnicodeString& result, | |
| UErrorCode &status) { | |
| normalize(source, compat ? UNORM_NFKC : UNORM_NFC, options, result, status); | |
| } | |
| void U_EXPORT2 | |
| Normalizer::decompose(const UnicodeString& source, | |
| UBool compat, int32_t options, | |
| UnicodeString& result, | |
| UErrorCode &status) { | |
| normalize(source, compat ? UNORM_NFKD : UNORM_NFD, options, result, status); | |
| } | |
| UNormalizationCheckResult | |
| Normalizer::quickCheck(const UnicodeString& source, | |
| UNormalizationMode mode, int32_t options, | |
| UErrorCode &status) { | |
| const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, status); | |
| if(U_SUCCESS(status)) { | |
| if(options&UNORM_UNICODE_3_2) { | |
| return FilteredNormalizer2(*n2, *uniset_getUnicode32Instance(status)). | |
| quickCheck(source, status); | |
| } else { | |
| return n2->quickCheck(source, status); | |
| } | |
| } else { | |
| return UNORM_MAYBE; | |
| } | |
| } | |
| UBool | |
| Normalizer::isNormalized(const UnicodeString& source, | |
| UNormalizationMode mode, int32_t options, | |
| UErrorCode &status) { | |
| const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, status); | |
| if(U_SUCCESS(status)) { | |
| if(options&UNORM_UNICODE_3_2) { | |
| return FilteredNormalizer2(*n2, *uniset_getUnicode32Instance(status)). | |
| isNormalized(source, status); | |
| } else { | |
| return n2->isNormalized(source, status); | |
| } | |
| } else { | |
| return FALSE; | |
| } | |
| } | |
| UnicodeString & U_EXPORT2 | |
| Normalizer::concatenate(const UnicodeString &left, const UnicodeString &right, | |
| UnicodeString &result, | |
| UNormalizationMode mode, int32_t options, | |
| UErrorCode &errorCode) { | |
| if(left.isBogus() || right.isBogus() || U_FAILURE(errorCode)) { | |
| result.setToBogus(); | |
| if(U_SUCCESS(errorCode)) { | |
| errorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| } else { | |
| UnicodeString localDest; | |
| UnicodeString *dest; | |
| if(&right!=&result) { | |
| dest=&result; | |
| } else { | |
| // the right and result strings are the same object, use a temporary one | |
| dest=&localDest; | |
| } | |
| *dest=left; | |
| const Normalizer2 *n2=Normalizer2Factory::getInstance(mode, errorCode); | |
| if(U_SUCCESS(errorCode)) { | |
| if(options&UNORM_UNICODE_3_2) { | |
| FilteredNormalizer2(*n2, *uniset_getUnicode32Instance(errorCode)). | |
| append(*dest, right, errorCode); | |
| } else { | |
| n2->append(*dest, right, errorCode); | |
| } | |
| } | |
| if(dest==&localDest && U_SUCCESS(errorCode)) { | |
| result=*dest; | |
| } | |
| } | |
| return result; | |
| } | |
| //------------------------------------------------------------------------- | |
| // Iteration API | |
| //------------------------------------------------------------------------- | |
| /** | |
| * Return the current character in the normalized text. | |
| */ | |
| UChar32 Normalizer::current() { | |
| if(bufferPos<buffer.length() || nextNormalize()) { | |
| return buffer.char32At(bufferPos); | |
| } else { | |
| return DONE; | |
| } | |
| } | |
| /** | |
| * Return the next character in the normalized text and advance | |
| * the iteration position by one. If the end | |
| * of the text has already been reached, {@link #DONE} is returned. | |
| */ | |
| UChar32 Normalizer::next() { | |
| if(bufferPos<buffer.length() || nextNormalize()) { | |
| UChar32 c=buffer.char32At(bufferPos); | |
| bufferPos+=U16_LENGTH(c); | |
| return c; | |
| } else { | |
| return DONE; | |
| } | |
| } | |
| /** | |
| * Return the previous character in the normalized text and decrement | |
| * the iteration position by one. If the beginning | |
| * of the text has already been reached, {@link #DONE} is returned. | |
| */ | |
| UChar32 Normalizer::previous() { | |
| if(bufferPos>0 || previousNormalize()) { | |
| UChar32 c=buffer.char32At(bufferPos-1); | |
| bufferPos-=U16_LENGTH(c); | |
| return c; | |
| } else { | |
| return DONE; | |
| } | |
| } | |
| void Normalizer::reset() { | |
| currentIndex=nextIndex=text->setToStart(); | |
| clearBuffer(); | |
| } | |
| void | |
| Normalizer::setIndexOnly(int32_t index) { | |
| text->setIndex(index); // pins index | |
| currentIndex=nextIndex=text->getIndex(); | |
| clearBuffer(); | |
| } | |
| /** | |
| * Return the first character in the normalized text. This resets | |
| * the <tt>Normalizer's</tt> position to the beginning of the text. | |
| */ | |
| UChar32 Normalizer::first() { | |
| reset(); | |
| return next(); | |
| } | |
| /** | |
| * Return the last character in the normalized text. This resets | |
| * the <tt>Normalizer's</tt> position to be just before the | |
| * the input text corresponding to that normalized character. | |
| */ | |
| UChar32 Normalizer::last() { | |
| currentIndex=nextIndex=text->setToEnd(); | |
| clearBuffer(); | |
| return previous(); | |
| } | |
| /** | |
| * Retrieve the current iteration position in the input text that is | |
| * being normalized. This method is useful in applications such as | |
| * searching, where you need to be able to determine the position in | |
| * the input text that corresponds to a given normalized output character. | |
| * <p> | |
| * <b>Note:</b> This method sets the position in the <em>input</em>, while | |
| * {@link #next} and {@link #previous} iterate through characters in the | |
| * <em>output</em>. This means that there is not necessarily a one-to-one | |
| * correspondence between characters returned by <tt>next</tt> and | |
| * <tt>previous</tt> and the indices passed to and returned from | |
| * <tt>setIndex</tt> and {@link #getIndex}. | |
| * | |
| */ | |
| int32_t Normalizer::getIndex() const { | |
| if(bufferPos<buffer.length()) { | |
| return currentIndex; | |
| } else { | |
| return nextIndex; | |
| } | |
| } | |
| /** | |
| * Retrieve the index of the start of the input text. This is the begin index | |
| * of the <tt>CharacterIterator</tt> or the start (i.e. 0) of the <tt>String</tt> | |
| * over which this <tt>Normalizer</tt> is iterating | |
| */ | |
| int32_t Normalizer::startIndex() const { | |
| return text->startIndex(); | |
| } | |
| /** | |
| * Retrieve the index of the end of the input text. This is the end index | |
| * of the <tt>CharacterIterator</tt> or the length of the <tt>String</tt> | |
| * over which this <tt>Normalizer</tt> is iterating | |
| */ | |
| int32_t Normalizer::endIndex() const { | |
| return text->endIndex(); | |
| } | |
| //------------------------------------------------------------------------- | |
| // Property access methods | |
| //------------------------------------------------------------------------- | |
| void | |
| Normalizer::setMode(UNormalizationMode newMode) | |
| { | |
| fUMode = newMode; | |
| init(); | |
| } | |
| UNormalizationMode | |
| Normalizer::getUMode() const | |
| { | |
| return fUMode; | |
| } | |
| void | |
| Normalizer::setOption(int32_t option, | |
| UBool value) | |
| { | |
| if (value) { | |
| fOptions |= option; | |
| } else { | |
| fOptions &= (~option); | |
| } | |
| init(); | |
| } | |
| UBool | |
| Normalizer::getOption(int32_t option) const | |
| { | |
| return (fOptions & option) != 0; | |
| } | |
| /** | |
| * Set the input text over which this <tt>Normalizer</tt> will iterate. | |
| * The iteration position is set to the beginning of the input text. | |
| */ | |
| void | |
| Normalizer::setText(const UnicodeString& newText, | |
| UErrorCode &status) | |
| { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| CharacterIterator *newIter = new StringCharacterIterator(newText); | |
| if (newIter == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| delete text; | |
| text = newIter; | |
| reset(); | |
| } | |
| /** | |
| * Set the input text over which this <tt>Normalizer</tt> will iterate. | |
| * The iteration position is set to the beginning of the string. | |
| */ | |
| void | |
| Normalizer::setText(const CharacterIterator& newText, | |
| UErrorCode &status) | |
| { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| CharacterIterator *newIter = newText.clone(); | |
| if (newIter == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| delete text; | |
| text = newIter; | |
| reset(); | |
| } | |
| void | |
| Normalizer::setText(const UChar* newText, | |
| int32_t length, | |
| UErrorCode &status) | |
| { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| CharacterIterator *newIter = new UCharCharacterIterator(newText, length); | |
| if (newIter == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| delete text; | |
| text = newIter; | |
| reset(); | |
| } | |
| /** | |
| * Copies the text under iteration into the UnicodeString referred to by "result". | |
| * @param result Receives a copy of the text under iteration. | |
| */ | |
| void | |
| Normalizer::getText(UnicodeString& result) | |
| { | |
| text->getText(result); | |
| } | |
| //------------------------------------------------------------------------- | |
| // Private utility methods | |
| //------------------------------------------------------------------------- | |
| void Normalizer::clearBuffer() { | |
| buffer.remove(); | |
| bufferPos=0; | |
| } | |
| UBool | |
| Normalizer::nextNormalize() { | |
| clearBuffer(); | |
| currentIndex=nextIndex; | |
| text->setIndex(nextIndex); | |
| if(!text->hasNext()) { | |
| return FALSE; | |
| } | |
| // Skip at least one character so we make progress. | |
| UnicodeString segment(text->next32PostInc()); | |
| while(text->hasNext()) { | |
| UChar32 c; | |
| if(fNorm2->hasBoundaryBefore(c=text->next32PostInc())) { | |
| text->move32(-1, CharacterIterator::kCurrent); | |
| break; | |
| } | |
| segment.append(c); | |
| } | |
| nextIndex=text->getIndex(); | |
| UErrorCode errorCode=U_ZERO_ERROR; | |
| fNorm2->normalize(segment, buffer, errorCode); | |
| return U_SUCCESS(errorCode) && !buffer.isEmpty(); | |
| } | |
| UBool | |
| Normalizer::previousNormalize() { | |
| clearBuffer(); | |
| nextIndex=currentIndex; | |
| text->setIndex(currentIndex); | |
| if(!text->hasPrevious()) { | |
| return FALSE; | |
| } | |
| UnicodeString segment; | |
| while(text->hasPrevious()) { | |
| UChar32 c=text->previous32(); | |
| segment.insert(0, c); | |
| if(fNorm2->hasBoundaryBefore(c)) { | |
| break; | |
| } | |
| } | |
| currentIndex=text->getIndex(); | |
| UErrorCode errorCode=U_ZERO_ERROR; | |
| fNorm2->normalize(segment, buffer, errorCode); | |
| bufferPos=buffer.length(); | |
| return U_SUCCESS(errorCode) && !buffer.isEmpty(); | |
| } | |
| U_NAMESPACE_END | |
| #endif /* #if !UCONFIG_NO_NORMALIZATION */ |