| /* | |
| ******************************************************************************** | |
| * Copyright (C) 1996-2015, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| ******************************************************************************** | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_BREAK_ITERATION | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "unicode/ubrk.h" | |
| #include "unicode/brkiter.h" | |
| #include "unicode/uloc.h" | |
| #include "unicode/ustring.h" | |
| #include "unicode/uchriter.h" | |
| #include "unicode/rbbi.h" | |
| #include "rbbirb.h" | |
| #include "uassert.h" | |
| U_NAMESPACE_USE | |
| //------------------------------------------------------------------------------ | |
| // | |
| // ubrk_open Create a canned type of break iterator based on type (word, line, etc.) | |
| // and locale. | |
| // | |
| //------------------------------------------------------------------------------ | |
| U_CAPI UBreakIterator* U_EXPORT2 | |
| ubrk_open(UBreakIteratorType type, | |
| const char *locale, | |
| const UChar *text, | |
| int32_t textLength, | |
| UErrorCode *status) | |
| { | |
| if(U_FAILURE(*status)) return 0; | |
| BreakIterator *result = 0; | |
| switch(type) { | |
| case UBRK_CHARACTER: | |
| result = BreakIterator::createCharacterInstance(Locale(locale), *status); | |
| break; | |
| case UBRK_WORD: | |
| result = BreakIterator::createWordInstance(Locale(locale), *status); | |
| break; | |
| case UBRK_LINE: | |
| result = BreakIterator::createLineInstance(Locale(locale), *status); | |
| break; | |
| case UBRK_SENTENCE: | |
| result = BreakIterator::createSentenceInstance(Locale(locale), *status); | |
| break; | |
| case UBRK_TITLE: | |
| result = BreakIterator::createTitleInstance(Locale(locale), *status); | |
| break; | |
| default: | |
| *status = U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| // check for allocation error | |
| if (U_FAILURE(*status)) { | |
| return 0; | |
| } | |
| if(result == 0) { | |
| *status = U_MEMORY_ALLOCATION_ERROR; | |
| return 0; | |
| } | |
| UBreakIterator *uBI = (UBreakIterator *)result; | |
| if (text != NULL) { | |
| ubrk_setText(uBI, text, textLength, status); | |
| } | |
| return uBI; | |
| } | |
| //------------------------------------------------------------------------------ | |
| // | |
| // ubrk_openRules open a break iterator from a set of break rules. | |
| // Invokes the rule builder. | |
| // | |
| //------------------------------------------------------------------------------ | |
| U_CAPI UBreakIterator* U_EXPORT2 | |
| ubrk_openRules( const UChar *rules, | |
| int32_t rulesLength, | |
| const UChar *text, | |
| int32_t textLength, | |
| UParseError *parseErr, | |
| UErrorCode *status) { | |
| if (status == NULL || U_FAILURE(*status)){ | |
| return 0; | |
| } | |
| BreakIterator *result = 0; | |
| UnicodeString ruleString(rules, rulesLength); | |
| result = RBBIRuleBuilder::createRuleBasedBreakIterator(ruleString, parseErr, *status); | |
| if(U_FAILURE(*status)) { | |
| return 0; | |
| } | |
| UBreakIterator *uBI = (UBreakIterator *)result; | |
| if (text != NULL) { | |
| ubrk_setText(uBI, text, textLength, status); | |
| } | |
| return uBI; | |
| } | |
| U_CAPI UBreakIterator * U_EXPORT2 | |
| ubrk_safeClone( | |
| const UBreakIterator *bi, | |
| void * /*stackBuffer*/, | |
| int32_t *pBufferSize, | |
| UErrorCode *status) | |
| { | |
| if (status == NULL || U_FAILURE(*status)){ | |
| return NULL; | |
| } | |
| if (bi == NULL) { | |
| *status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return NULL; | |
| } | |
| if (pBufferSize != NULL) { | |
| int32_t inputSize = *pBufferSize; | |
| *pBufferSize = 1; | |
| if (inputSize == 0) { | |
| return NULL; // preflighting for deprecated functionality | |
| } | |
| } | |
| BreakIterator *newBI = ((BreakIterator *)bi)->clone(); | |
| if (newBI == NULL) { | |
| *status = U_MEMORY_ALLOCATION_ERROR; | |
| } else { | |
| *status = U_SAFECLONE_ALLOCATED_WARNING; | |
| } | |
| return (UBreakIterator *)newBI; | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ubrk_close(UBreakIterator *bi) | |
| { | |
| delete (BreakIterator *)bi; | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ubrk_setText(UBreakIterator* bi, | |
| const UChar* text, | |
| int32_t textLength, | |
| UErrorCode* status) | |
| { | |
| UText ut = UTEXT_INITIALIZER; | |
| utext_openUChars(&ut, text, textLength, status); | |
| ((BreakIterator*)bi)->setText(&ut, *status); | |
| // A stack allocated UText wrapping a UChar * string | |
| // can be dumped without explicitly closing it. | |
| } | |
| U_CAPI void U_EXPORT2 | |
| ubrk_setUText(UBreakIterator *bi, | |
| UText *text, | |
| UErrorCode *status) | |
| { | |
| ((BreakIterator*)bi)->setText(text, *status); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubrk_current(const UBreakIterator *bi) | |
| { | |
| return ((BreakIterator*)bi)->current(); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubrk_next(UBreakIterator *bi) | |
| { | |
| return ((BreakIterator*)bi)->next(); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubrk_previous(UBreakIterator *bi) | |
| { | |
| return ((BreakIterator*)bi)->previous(); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubrk_first(UBreakIterator *bi) | |
| { | |
| return ((BreakIterator*)bi)->first(); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubrk_last(UBreakIterator *bi) | |
| { | |
| return ((BreakIterator*)bi)->last(); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubrk_preceding(UBreakIterator *bi, | |
| int32_t offset) | |
| { | |
| return ((BreakIterator*)bi)->preceding(offset); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubrk_following(UBreakIterator *bi, | |
| int32_t offset) | |
| { | |
| return ((BreakIterator*)bi)->following(offset); | |
| } | |
| U_CAPI const char* U_EXPORT2 | |
| ubrk_getAvailable(int32_t index) | |
| { | |
| return uloc_getAvailable(index); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubrk_countAvailable() | |
| { | |
| return uloc_countAvailable(); | |
| } | |
| U_CAPI UBool U_EXPORT2 | |
| ubrk_isBoundary(UBreakIterator *bi, int32_t offset) | |
| { | |
| return ((BreakIterator*)bi)->isBoundary(offset); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubrk_getRuleStatus(UBreakIterator *bi) | |
| { | |
| return ((BreakIterator*)bi)->getRuleStatus(); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| ubrk_getRuleStatusVec(UBreakIterator *bi, int32_t *fillInVec, int32_t capacity, UErrorCode *status) | |
| { | |
| return ((BreakIterator*)bi)->getRuleStatusVec(fillInVec, capacity, *status); | |
| } | |
| U_CAPI const char* U_EXPORT2 | |
| ubrk_getLocaleByType(const UBreakIterator *bi, | |
| ULocDataLocaleType type, | |
| UErrorCode* status) | |
| { | |
| if (bi == NULL) { | |
| if (U_SUCCESS(*status)) { | |
| *status = U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| return NULL; | |
| } | |
| return ((BreakIterator*)bi)->getLocaleID(type, *status); | |
| } | |
| void ubrk_refreshUText(UBreakIterator *bi, | |
| UText *text, | |
| UErrorCode *status) | |
| { | |
| BreakIterator *bii = reinterpret_cast<BreakIterator *>(bi); | |
| bii->refreshInputText(text, *status); | |
| } | |
| #endif /* #if !UCONFIG_NO_BREAK_ITERATION */ |