Home | History | Annotate | Download | only in common
      1 /*
      2 ********************************************************************************
      3 *   Copyright (C) 1996-2012, International Business Machines
      4 *   Corporation and others.  All Rights Reserved.
      5 ********************************************************************************
      6 */
      7 
      8 #include "unicode/utypes.h"
      9 
     10 #if !UCONFIG_NO_BREAK_ITERATION
     11 
     12 #include "unicode/ubrk.h"
     13 
     14 #include "unicode/brkiter.h"
     15 #include "unicode/uloc.h"
     16 #include "unicode/ustring.h"
     17 #include "unicode/uchriter.h"
     18 #include "unicode/rbbi.h"
     19 #include "rbbirb.h"
     20 #include "uassert.h"
     21 
     22 U_NAMESPACE_USE
     23 
     24 //------------------------------------------------------------------------------
     25 //
     26 //    ubrk_open      Create a canned type of break iterator based on type (word, line, etc.)
     27 //                   and locale.
     28 //
     29 //------------------------------------------------------------------------------
     30 U_CAPI UBreakIterator* U_EXPORT2
     31 ubrk_open(UBreakIteratorType type,
     32       const char *locale,
     33       const UChar *text,
     34       int32_t textLength,
     35       UErrorCode *status)
     36 {
     37 
     38   if(U_FAILURE(*status)) return 0;
     39 
     40   BreakIterator *result = 0;
     41 
     42   switch(type) {
     43 
     44   case UBRK_CHARACTER:
     45     result = BreakIterator::createCharacterInstance(Locale(locale), *status);
     46     break;
     47 
     48   case UBRK_WORD:
     49     result = BreakIterator::createWordInstance(Locale(locale), *status);
     50     break;
     51 
     52   case UBRK_LINE:
     53     result = BreakIterator::createLineInstance(Locale(locale), *status);
     54     break;
     55 
     56   case UBRK_SENTENCE:
     57     result = BreakIterator::createSentenceInstance(Locale(locale), *status);
     58     break;
     59 
     60   case UBRK_TITLE:
     61     result = BreakIterator::createTitleInstance(Locale(locale), *status);
     62     break;
     63 
     64   default:
     65     *status = U_ILLEGAL_ARGUMENT_ERROR;
     66   }
     67 
     68   // check for allocation error
     69   if (U_FAILURE(*status)) {
     70      return 0;
     71   }
     72   if(result == 0) {
     73     *status = U_MEMORY_ALLOCATION_ERROR;
     74     return 0;
     75   }
     76 
     77 
     78   UBreakIterator *uBI = (UBreakIterator *)result;
     79   if (text != NULL) {
     80       ubrk_setText(uBI, text, textLength, status);
     81   }
     82   return uBI;
     83 }
     84 
     85 
     86 
     87 //------------------------------------------------------------------------------
     88 //
     89 //   ubrk_openRules      open a break iterator from a set of break rules.
     90 //                       Invokes the rule builder.
     91 //
     92 //------------------------------------------------------------------------------
     93 U_CAPI UBreakIterator* U_EXPORT2
     94 ubrk_openRules(  const UChar        *rules,
     95                        int32_t       rulesLength,
     96                  const UChar        *text,
     97                        int32_t       textLength,
     98                        UParseError  *parseErr,
     99                        UErrorCode   *status)  {
    100 
    101     if (status == NULL || U_FAILURE(*status)){
    102         return 0;
    103     }
    104 
    105     BreakIterator *result = 0;
    106     UnicodeString ruleString(rules, rulesLength);
    107     result = RBBIRuleBuilder::createRuleBasedBreakIterator(ruleString, parseErr, *status);
    108     if(U_FAILURE(*status)) {
    109         return 0;
    110     }
    111 
    112     UBreakIterator *uBI = (UBreakIterator *)result;
    113     if (text != NULL) {
    114         ubrk_setText(uBI, text, textLength, status);
    115     }
    116     return uBI;
    117 }
    118 
    119 
    120 
    121 
    122 
    123 U_CAPI UBreakIterator * U_EXPORT2
    124 ubrk_safeClone(
    125           const UBreakIterator *bi,
    126           void *stackBuffer,
    127           int32_t *pBufferSize,
    128           UErrorCode *status)
    129 {
    130     if (status == NULL || U_FAILURE(*status)){
    131         return 0;
    132     }
    133     if (!pBufferSize || !bi){
    134        *status = U_ILLEGAL_ARGUMENT_ERROR;
    135         return 0;
    136     }
    137     // Clear any incoming Safe Clone Allocated warning.
    138     //  Propagating this through to our return would really
    139     //  confuse our caller.
    140     if (*status==U_SAFECLONE_ALLOCATED_WARNING) {
    141         *status = U_ZERO_ERROR;
    142     }
    143     return (UBreakIterator *)(((BreakIterator*)bi)->
    144         createBufferClone(stackBuffer, *pBufferSize, *status));
    145 }
    146 
    147 
    148 
    149 U_CAPI void U_EXPORT2
    150 ubrk_close(UBreakIterator *bi)
    151 {
    152     BreakIterator *ubi = (BreakIterator*) bi;
    153     if (ubi) {
    154         if (ubi->isBufferClone()) {
    155             ubi->~BreakIterator();
    156             *(uint32_t *)ubi = 0xdeadbeef;
    157         } else {
    158             delete ubi;
    159         }
    160     }
    161 }
    162 
    163 U_CAPI void U_EXPORT2
    164 ubrk_setText(UBreakIterator* bi,
    165              const UChar*    text,
    166              int32_t         textLength,
    167              UErrorCode*     status)
    168 {
    169     BreakIterator *brit = (BreakIterator *)bi;
    170     UText  ut = UTEXT_INITIALIZER;
    171     utext_openUChars(&ut, text, textLength, status);
    172     brit->setText(&ut, *status);
    173     // A stack allocated UText wrapping a UCHar * string
    174     //   can be dumped without explicitly closing it.
    175 }
    176 
    177 
    178 
    179 U_CAPI void U_EXPORT2
    180 ubrk_setUText(UBreakIterator *bi,
    181              UText          *text,
    182              UErrorCode     *status)
    183 {
    184     RuleBasedBreakIterator *brit = (RuleBasedBreakIterator *)bi;
    185     brit->RuleBasedBreakIterator::setText(text, *status);
    186 }
    187 
    188 
    189 
    190 
    191 
    192 U_CAPI int32_t U_EXPORT2
    193 ubrk_current(const UBreakIterator *bi)
    194 {
    195 
    196   return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::current();
    197 }
    198 
    199 U_CAPI int32_t U_EXPORT2
    200 ubrk_next(UBreakIterator *bi)
    201 {
    202 
    203   return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::next();
    204 }
    205 
    206 U_CAPI int32_t U_EXPORT2
    207 ubrk_previous(UBreakIterator *bi)
    208 {
    209 
    210   return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::previous();
    211 }
    212 
    213 U_CAPI int32_t U_EXPORT2
    214 ubrk_first(UBreakIterator *bi)
    215 {
    216 
    217   return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::first();
    218 }
    219 
    220 U_CAPI int32_t U_EXPORT2
    221 ubrk_last(UBreakIterator *bi)
    222 {
    223 
    224   return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::last();
    225 }
    226 
    227 U_CAPI int32_t U_EXPORT2
    228 ubrk_preceding(UBreakIterator *bi,
    229            int32_t offset)
    230 {
    231 
    232   return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::preceding(offset);
    233 }
    234 
    235 U_CAPI int32_t U_EXPORT2
    236 ubrk_following(UBreakIterator *bi,
    237            int32_t offset)
    238 {
    239 
    240   return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::following(offset);
    241 }
    242 
    243 U_CAPI const char* U_EXPORT2
    244 ubrk_getAvailable(int32_t index)
    245 {
    246 
    247   return uloc_getAvailable(index);
    248 }
    249 
    250 U_CAPI int32_t U_EXPORT2
    251 ubrk_countAvailable()
    252 {
    253 
    254   return uloc_countAvailable();
    255 }
    256 
    257 
    258 U_CAPI  UBool U_EXPORT2
    259 ubrk_isBoundary(UBreakIterator *bi, int32_t offset)
    260 {
    261     return ((RuleBasedBreakIterator *)bi)->RuleBasedBreakIterator::isBoundary(offset);
    262 }
    263 
    264 
    265 U_CAPI  int32_t U_EXPORT2
    266 ubrk_getRuleStatus(UBreakIterator *bi)
    267 {
    268     return ((RuleBasedBreakIterator *)bi)->RuleBasedBreakIterator::getRuleStatus();
    269 }
    270 
    271 U_CAPI  int32_t U_EXPORT2
    272 ubrk_getRuleStatusVec(UBreakIterator *bi, int32_t *fillInVec, int32_t capacity, UErrorCode *status)
    273 {
    274     return ((RuleBasedBreakIterator *)bi)->RuleBasedBreakIterator::getRuleStatusVec(fillInVec, capacity, *status);
    275 }
    276 
    277 
    278 U_CAPI const char* U_EXPORT2
    279 ubrk_getLocaleByType(const UBreakIterator *bi,
    280                      ULocDataLocaleType type,
    281                      UErrorCode* status)
    282 {
    283     if (bi == NULL) {
    284         if (U_SUCCESS(*status)) {
    285             *status = U_ILLEGAL_ARGUMENT_ERROR;
    286         }
    287         return NULL;
    288     }
    289     return ((BreakIterator*)bi)->getLocaleID(type, *status);
    290 }
    291 
    292 
    293 void ubrk_refreshUText(UBreakIterator *bi,
    294                        UText          *text,
    295                        UErrorCode     *status)
    296 {
    297     BreakIterator *bii = reinterpret_cast<BreakIterator *>(bi);
    298     bii->refreshInputText(text, *status);
    299 }
    300 
    301 
    302 
    303 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */
    304