ICU 56 update step 1

source/common/dictbe.cpp

 /**
  *******************************************************************************
- * Copyright (C) 2006-2014, International Business Machines Corporation
+ * Copyright (C) 2006-2015, International Business Machines Corporation
  * and others. All Rights Reserved.
  *******************************************************************************
  */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_BREAK_ITERATION
 
 #include "brkeng.h"
 #include "dictbe.h"
@@ skipping 811 matching lines @@
 
 /*
  ******************************************************************
  * KhmerBreakEngine
  */
 
 // How many words in a row are "good enough"?
 static const int32_t KHMER_LOOKAHEAD = 3;
 
 // Will not combine a non-word with a preceding dictionary word longer than this
-static const int32_t KHMER_ROOT_COMBINE_THRESHOLD = 10;
+static const int32_t KHMER_ROOT_COMBINE_THRESHOLD = 3;
 
 // Will not combine a non-word that shares at least this much prefix with a
 // dictionary word, with a preceding word
-static const int32_t KHMER_PREFIX_COMBINE_THRESHOLD = 5;
+static const int32_t KHMER_PREFIX_COMBINE_THRESHOLD = 3;
 
 // Minimum word size
 static const int32_t KHMER_MIN_WORD = 2;
 
 // Minimum number of characters for two words
 static const int32_t KHMER_MIN_WORD_SPAN = KHMER_MIN_WORD * 2;
 
 KhmerBreakEngine::KhmerBreakEngine(DictionaryMatcher *adoptDictionary, UErrorCode &status)
     : DictionaryBreakEngine((1 << UBRK_WORD) | (1 << UBRK_LINE)),
       fDictionary(adoptDictionary)
@@ skipping 281 matching lines @@
  */
 int32_t 
 CjkBreakEngine::divideUpDictionaryRange( UText *inText,
         int32_t rangeStart,
         int32_t rangeEnd,
         UStack &foundBreaks ) const {
     if (rangeStart >= rangeEnd) {
         return 0;
     }
 
-    // UnicodeString version of input UText, NFKC normalized in necessary.
-    UnicodeString *inString;
+    // UnicodeString version of input UText, NFKC normalized if necessary.
+    UnicodeString inString;
 
     // inputMap[inStringIndex] = corresponding native index from UText inText.
     // If NULL then mapping is 1:1
-    UVector32     *inputMap    = NULL;
+    LocalPointer<UVector32>     inputMap;
 
     UErrorCode     status      = U_ZERO_ERROR;
 
 
     // if UText has the input string as one contiguous UTF-16 chunk
     if ((inText->providerProperties & utext_i32_flag(UTEXT_PROVIDER_STABLE_CHUNKS)) &&
          inText->chunkNativeStart <= rangeStart &&
          inText->chunkNativeLimit >= rangeEnd   &&
          inText->nativeIndexingLimit >= rangeEnd - inText->chunkNativeStart) {
-         
-        // Input UTtxt is in one contiguous UTF-16 chunk.
-        // Use Read-only aliasing UnicodeString constructor on it.
-        inString = new UnicodeString(FALSE, 
-                              inText->chunkContents + rangeStart - inText->chunkNativeStart,
-                              rangeEnd - rangeStart);
+
+        // Input UText is in one contiguous UTF-16 chunk.
+        // Use Read-only aliasing UnicodeString.
+        inString.setTo(FALSE,
+                       inText->chunkContents + rangeStart - inText->chunkNativeStart,
+                       rangeEnd - rangeStart);
     } else {
         // Copy the text from the original inText (UText) to inString (UnicodeString).
         // Create a map from UnicodeString indices -> UText offsets.
         utext_setNativeIndex(inText, rangeStart);
         int32_t limit = rangeEnd;
         U_ASSERT(limit <= utext_nativeLength(inText));
         if (limit > utext_nativeLength(inText)) {
             limit = utext_nativeLength(inText);
         }
-        inString = new UnicodeString;
-        inputMap = new UVector32(status);
+        inputMap.adoptInsteadAndCheckErrorCode(new UVector32(status), status);
+        if (U_FAILURE(status)) {
+            return 0;
+        }
         while (utext_getNativeIndex(inText) < limit) {
             int32_t nativePosition = utext_getNativeIndex(inText);
             UChar32 c = utext_next32(inText);
             U_ASSERT(c != U_SENTINEL);
-            inString->append(c);
-            while (inputMap->size() < inString->length()) {
+            inString.append(c);
+            while (inputMap->size() < inString.length()) {
                 inputMap->addElement(nativePosition, status);
             }
         }
         inputMap->addElement(limit, status);
     }
 
 
-    if (!nfkcNorm2->isNormalized(*inString, status)) {
-        UnicodeString *normalizedInput = new UnicodeString();   
+    if (!nfkcNorm2->isNormalized(inString, status)) {
+        UnicodeString normalizedInput;
         //  normalizedMap[normalizedInput position] ==  original UText position.
-        UVector32 *normalizedMap = new UVector32(status);
+        LocalPointer<UVector32> normalizedMap(new UVector32(status), status);
         if (U_FAILURE(status)) {
             return 0;
         }
         
         UnicodeString fragment;
         UnicodeString normalizedFragment;
-        for (int32_t srcI = 0; srcI < inString->length();) {                 // Once per normalization chunk
+        for (int32_t srcI = 0; srcI < inString.length();) {  // Once per normalization chunk
             fragment.remove();
             int32_t fragmentStartI = srcI;
-            UChar32 c = inString->char32At(srcI);
+            UChar32 c = inString.char32At(srcI);
             for (;;) {
                 fragment.append(c);
-                srcI = inString->moveIndex32(srcI, 1);
-                if (srcI == inString->length()) {
+                srcI = inString.moveIndex32(srcI, 1);
+                if (srcI == inString.length()) {
                     break;
                 }
-                c = inString->char32At(srcI);
+                c = inString.char32At(srcI);
                 if (nfkcNorm2->hasBoundaryBefore(c)) {
                     break;
                 }
             }
             nfkcNorm2->normalize(fragment, normalizedFragment, status);
-            normalizedInput->append(normalizedFragment);
+            normalizedInput.append(normalizedFragment);
 
             // Map every position in the normalized chunk to the start of the chunk
             //   in the original input.
-            int32_t fragmentOriginalStart = inputMap? inputMap->elementAti(fragmentStartI) : fragmentStartI+rangeStart;
-            while (normalizedMap->size() < normalizedInput->length()) {
+            int32_t fragmentOriginalStart = inputMap.isValid() ?
+                    inputMap->elementAti(fragmentStartI) : fragmentStartI+rangeStart;
+            while (normalizedMap->size() < normalizedInput.length()) {
                 normalizedMap->addElement(fragmentOriginalStart, status);
                 if (U_FAILURE(status)) {
                     break;
                 }
             }
         }
-        U_ASSERT(normalizedMap->size() == normalizedInput->length());
-        int32_t nativeEnd = inputMap? inputMap->elementAti(inString->length()) : inString->length()+rangeStart;
+        U_ASSERT(normalizedMap->size() == normalizedInput.length());
+        int32_t nativeEnd = inputMap.isValid() ?
+                inputMap->elementAti(inString.length()) : inString.length()+rangeStart;
         normalizedMap->addElement(nativeEnd, status);
 
-        delete inputMap;
-        inputMap = normalizedMap;
-        delete inString;
-        inString = normalizedInput;
+        inputMap.moveFrom(normalizedMap);
+        inString.moveFrom(normalizedInput);
     }
 
-    int32_t numCodePts = inString->countChar32();
-    if (numCodePts != inString->length()) {
+    int32_t numCodePts = inString.countChar32();
+    if (numCodePts != inString.length()) {
         // There are supplementary characters in the input.
         // The dictionary will produce boundary positions in terms of code point indexes,
         //   not in terms of code unit string indexes.
         // Use the inputMap mechanism to take care of this in addition to indexing differences
         //    from normalization and/or UTF-8 input.
-        UBool hadExistingMap = (inputMap != NULL);
+        UBool hadExistingMap = inputMap.isValid();
         if (!hadExistingMap) {
-            inputMap = new UVector32(status);
+            inputMap.adoptInsteadAndCheckErrorCode(new UVector32(status), status);
+            if (U_FAILURE(status)) {
+                return 0;
+            }
         }
         int32_t cpIdx = 0;
-        for (int32_t cuIdx = 0; ; cuIdx = inString->moveIndex32(cuIdx, 1)) {
+        for (int32_t cuIdx = 0; ; cuIdx = inString.moveIndex32(cuIdx, 1)) {
             U_ASSERT(cuIdx >= cpIdx);
             if (hadExistingMap) {
                 inputMap->setElementAt(inputMap->elementAti(cuIdx), cpIdx);
             } else {
                 inputMap->addElement(cuIdx+rangeStart, status);
             }
             cpIdx++;
-            if (cuIdx == inString->length()) {
+            if (cuIdx == inString.length()) {
                break;
             }
         }
     }
                 
     // bestSnlp[i] is the snlp of the best segmentation of the first i
     // code points in the range to be matched.
     UVector32 bestSnlp(numCodePts + 1, status);
     bestSnlp.addElement(0, status);
     for(int32_t i = 1; i <= numCodePts; i++) {
         bestSnlp.addElement(kuint32max, status);
     }
 
 
     // prev[i] is the index of the last CJK code point in the previous word in 
     // the best segmentation of the first i characters.
     UVector32 prev(numCodePts + 1, status);
     for(int32_t i = 0; i <= numCodePts; i++){
         prev.addElement(-1, status);
     }
 
     const int32_t maxWordSize = 20;
     UVector32 values(numCodePts, status);
     values.setSize(numCodePts);
     UVector32 lengths(numCodePts, status);
     lengths.setSize(numCodePts);
 
     UText fu = UTEXT_INITIALIZER;
-    utext_openUnicodeString(&fu, inString, &status);
+    utext_openUnicodeString(&fu, &inString, &status);
 
     // Dynamic programming to find the best segmentation.
 
     // In outer loop, i  is the code point index,
     //                ix is the corresponding string (code unit) index.
     //    They differ when the string contains supplementary characters.
     int32_t ix = 0;
-    for (int32_t i = 0;  i < numCodePts;  ++i, ix = inString->moveIndex32(ix, 1)) {
+    for (int32_t i = 0;  i < numCodePts;  ++i, ix = inString.moveIndex32(ix, 1)) {
         if ((uint32_t)bestSnlp.elementAti(i) == kuint32max) {
             continue;
         }
 
         int32_t count;
         utext_setNativeIndex(&fu, ix);
         count = fDictionary->matches(&fu, maxWordSize, numCodePts,
                              NULL, lengths.getBuffer(), values.getBuffer(), NULL);
                              // Note: lengths is filled with code point lengths
                              //       The NULL parameter is the ignored code unit lengths.
 
         // if there are no single character matches found in the dictionary 
         // starting with this charcter, treat character as a 1-character word 
         // with the highest value possible, i.e. the least likely to occur.
         // Exclude Korean characters from this treatment, as they should be left
         // together by default.
         if ((count == 0 || lengths.elementAti(0) != 1) &&
-                !fHangulWordSet.contains(inString->char32At(ix))) {
+                !fHangulWordSet.contains(inString.char32At(ix))) {
             values.setElementAt(maxSnlp, count);   // 255
             lengths.setElementAt(1, count++);
         }
 
         for (int32_t j = 0; j < count; j++) {
             uint32_t newSnlp = (uint32_t)bestSnlp.elementAti(i) + (uint32_t)values.elementAti(j);
             int32_t ln_j_i = lengths.elementAti(j) + i;
             if (newSnlp < (uint32_t)bestSnlp.elementAti(ln_j_i)) {
                 bestSnlp.setElementAt(newSnlp, ln_j_i);
                 prev.setElementAt(i, ln_j_i);
             }
         }
 
         // In Japanese,
         // Katakana word in single character is pretty rare. So we apply
         // the following heuristic to Katakana: any continuous run of Katakana
         // characters is considered a candidate word with a default cost
         // specified in the katakanaCost table according to its length.
 
         bool is_prev_katakana = false;
-        bool is_katakana = isKatakana(inString->char32At(ix));
+        bool is_katakana = isKatakana(inString.char32At(ix));
         int32_t katakanaRunLength = 1;
         if (!is_prev_katakana && is_katakana) {
-            int32_t j = inString->moveIndex32(ix, 1);
+            int32_t j = inString.moveIndex32(ix, 1);
             // Find the end of the continuous run of Katakana characters
-            while (j < inString->length() && katakanaRunLength < kMaxKatakanaGroupLength &&
-                    isKatakana(inString->char32At(j))) {
-                j = inString->moveIndex32(j, 1);
+            while (j < inString.length() && katakanaRunLength < kMaxKatakanaGroupLength &&
+                    isKatakana(inString.char32At(j))) {
+                j = inString.moveIndex32(j, 1);
                 katakanaRunLength++;
             }
             if (katakanaRunLength < kMaxKatakanaGroupLength) {
                 uint32_t newSnlp = bestSnlp.elementAti(i) + getKatakanaCost(katakanaRunLength);
                 if (newSnlp < (uint32_t)bestSnlp.elementAti(j)) {
                     bestSnlp.setElementAt(newSnlp, j);
                     prev.setElementAt(i, i+katakanaRunLength);  // prev[j] = i;
                 }
             }
         }
@@ skipping 25 matching lines @@
     if (foundBreaks.size() == 0 || foundBreaks.peeki() < rangeStart) {
         t_boundary.addElement(0, status);
         numBreaks++;
     }
 
     // Now that we're done, convert positions in t_boundary[] (indices in 
     // the normalized input string) back to indices in the original input UText
     // while reversing t_boundary and pushing values to foundBreaks.
     for (int32_t i = numBreaks-1; i >= 0; i--) {
         int32_t cpPos = t_boundary.elementAti(i);
-        int32_t utextPos =  inputMap ? inputMap->elementAti(cpPos) : cpPos + rangeStart;
+        int32_t utextPos =  inputMap.isValid() ? inputMap->elementAti(cpPos) : cpPos + rangeStart;
         // Boundaries are added to foundBreaks output in ascending order.
         U_ASSERT(foundBreaks.size() == 0 ||foundBreaks.peeki() < utextPos);
         foundBreaks.push(utextPos, status);
     }
 
-    delete inString;
-    delete inputMap;
+    // inString goes out of scope
+    // inputMap goes out of scope
     return numBreaks;
 }
 #endif
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */