ICU-6.2.10.tar.gz

[apple/icu.git] / icuSources / common / dbbi.cpp

diff --git a/icuSources/common/dbbi.cpp b/icuSources/common/dbbi.cpp
index def45650022bf365d765ca1929bc3b03231667f2..2f83f6c3e39932cce5441f05431bbc8041dde709 100644 (file)
--- a/icuSources/common/dbbi.cpp
+++ b/icuSources/common/dbbi.cpp
@@ -1,6 +1,6 @@
 /*
 **********************************************************************
 /*
 **********************************************************************

-*   Copyright (C) 1999-2001 IBM Corp. All rights reserved.
+*   Copyright (C) 1999-2004 IBM Corp. All rights reserved.

 **********************************************************************
 *   Date        Name        Description
 *   12/1/99    rgillam     Complete port from Java.
 **********************************************************************
 *   Date        Name        Description
 *   12/1/99    rgillam     Complete port from Java.


@@ -17,17 +17,18 @@
 #include "dbbi_tbl.h"
 #include "uvector.h"
 #include "cmemory.h"
 #include "dbbi_tbl.h"
 #include "uvector.h"
 #include "cmemory.h"

+#include "uassert.h"

 
 U_NAMESPACE_BEGIN
 
 
 U_NAMESPACE_BEGIN
 

-const char DictionaryBasedBreakIterator::fgClassID = 0;
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DictionaryBasedBreakIterator)

 
 
 
 

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 //
 // constructors
 //
 //
 // constructors
 //

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 
 DictionaryBasedBreakIterator::DictionaryBasedBreakIterator() :
 RuleBasedBreakIterator() {
 
 DictionaryBasedBreakIterator::DictionaryBasedBreakIterator() :
 RuleBasedBreakIterator() {


@@ -43,17 +44,18 @@ DictionaryBasedBreakIterator::DictionaryBasedBreakIterator(UDataMemory* rbbiData
     init();
     if (U_FAILURE(status)) {return;};
     fTables = new DictionaryBasedBreakIteratorTables(dictionaryFilename, status);
     init();
     if (U_FAILURE(status)) {return;};
     fTables = new DictionaryBasedBreakIteratorTables(dictionaryFilename, status);

+    if (U_FAILURE(status)) {
+        if (fTables != NULL) {
+            fTables->removeReference();
+            fTables = NULL;
+        }
+        return;
+    }

     /* test for NULL */
     if(fTables == 0) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
     /* test for NULL */
     if(fTables == 0) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }

-    
-    if (U_FAILURE(status)) {
-        fTables->removeReference();
-        fTables = NULL;
-        return;
-    }

 }
 
 
 }
 
 


@@ -70,11 +72,11 @@ RuleBasedBreakIterator(other)
 
 
 
 
 
 

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 //
 //   Destructor
 //
 //
 //   Destructor
 //

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 DictionaryBasedBreakIterator::~DictionaryBasedBreakIterator()
 {
     uprv_free(cachedBreakPositions);
 DictionaryBasedBreakIterator::~DictionaryBasedBreakIterator()
 {
     uprv_free(cachedBreakPositions);


@@ -82,12 +84,12 @@ DictionaryBasedBreakIterator::~DictionaryBasedBreakIterator()
     if (fTables != NULL) {fTables->removeReference();};
 }
 
     if (fTables != NULL) {fTables->removeReference();};
 }
 

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 //
 //   Assignment operator.     Sets this iterator to have the same behavior,
 //                            and iterate over the same text, as the one passed in.
 //
 //
 //   Assignment operator.     Sets this iterator to have the same behavior,
 //                            and iterate over the same text, as the one passed in.
 //

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 DictionaryBasedBreakIterator&
 DictionaryBasedBreakIterator::operator=(const DictionaryBasedBreakIterator& that) {
     if (this == &that) {
 DictionaryBasedBreakIterator&
 DictionaryBasedBreakIterator::operator=(const DictionaryBasedBreakIterator& that) {
     if (this == &that) {


@@ -103,12 +105,12 @@ DictionaryBasedBreakIterator::operator=(const DictionaryBasedBreakIterator& that
     return *this;
 }
 
     return *this;
 }
 

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 //
 //   Clone()    Returns a newly-constructed RuleBasedBreakIterator with the same
 //              behavior, and iterating over the same text, as this one.
 //
 //
 //   Clone()    Returns a newly-constructed RuleBasedBreakIterator with the same
 //              behavior, and iterating over the same text, as this one.
 //

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 BreakIterator*
 DictionaryBasedBreakIterator::clone() const {
     return new DictionaryBasedBreakIterator(*this);
 BreakIterator*
 DictionaryBasedBreakIterator::clone() const {
     return new DictionaryBasedBreakIterator(*this);


@@ -141,7 +143,14 @@ DictionaryBasedBreakIterator::previous()
         reset();
         int32_t result = RuleBasedBreakIterator::previous();
         if (cachedBreakPositions != NULL) {
         reset();
         int32_t result = RuleBasedBreakIterator::previous();
         if (cachedBreakPositions != NULL) {

-            positionInCache = numCachedBreakPositions - 2;
+            for (positionInCache=0; 
+                cachedBreakPositions[positionInCache] != result;
+                positionInCache++);
+            U_ASSERT(positionInCache < numCachedBreakPositions);
+            if (positionInCache >= numCachedBreakPositions) {
+                // Something has gone wrong.  Dump the cache.
+                reset();
+            }

         }
         return result;
     }
         }
         return result;
     }


@@ -256,8 +265,13 @@ DictionaryBasedBreakIterator::handleNext()
         // for the new range
         if (fDictionaryCharCount > 1 && result - startPos > 1) {
             divideUpDictionaryRange(startPos, result, status);
         // for the new range
         if (fDictionaryCharCount > 1 && result - startPos > 1) {
             divideUpDictionaryRange(startPos, result, status);

+            U_ASSERT(U_SUCCESS(status));

             if (U_FAILURE(status)) {
             if (U_FAILURE(status)) {

-                return -9999;   // SHOULD NEVER GET HERE!
+                // Something went badly wrong, an internal error.
+                // We have no way from here to report it to caller.
+                // Treat as if this is if the dictionary did not apply to range.
+                reset();
+                return result;

             }
         }
 
             }
         }
 


@@ -292,11 +306,11 @@ DictionaryBasedBreakIterator::reset()
 
 
 
 
 
 

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 //
 //    init()    Common initialization routine, for use by constructors, etc.
 //
 //
 //    init()    Common initialization routine, for use by constructors, etc.
 //

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 void DictionaryBasedBreakIterator::init() {
     cachedBreakPositions    = NULL;
     fTables                 = NULL;
 void DictionaryBasedBreakIterator::init() {
     cachedBreakPositions    = NULL;
     fTables                 = NULL;


@@ -306,11 +320,11 @@ void DictionaryBasedBreakIterator::init() {
 }
 
 
 }
 
 

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 //
 //    BufferClone
 //
 //
 //    BufferClone
 //

-//-------------------------------------------------------------------------------
+//------------------------------------------------------------------------------

 BreakIterator *  DictionaryBasedBreakIterator::createBufferClone(void *stackBuffer,
                                    int32_t &bufferSize,
                                    UErrorCode &status)
 BreakIterator *  DictionaryBasedBreakIterator::createBufferClone(void *stackBuffer,
                                    int32_t &bufferSize,
                                    UErrorCode &status)


@@ -396,6 +410,9 @@ DictionaryBasedBreakIterator::divideUpDictionaryRange(int32_t startPos, int32_t
         c = fText->next();
     }
 
         c = fText->next();
     }
 

+    if (U_FAILURE(status)) {
+        return; // UStack below overwrites the status error codes
+    }

     
     // initialize.  We maintain two stacks: currentBreakPositions contains
     // the list of break positions that will be returned if we successfully
     
     // initialize.  We maintain two stacks: currentBreakPositions contains
     // the list of break positions that will be returned if we successfully


@@ -412,7 +429,9 @@ DictionaryBasedBreakIterator::divideUpDictionaryRange(int32_t startPos, int32_t
     // further, this saves us from having to follow each possible path
     // through the text all the way to the error (hopefully avoiding many
     // future recursive calls as well).
     // further, this saves us from having to follow each possible path
     // through the text all the way to the error (hopefully avoiding many
     // future recursive calls as well).

-    UStack currentBreakPositions(status);
+    // there can be only one kind of error in UStack and UVector, so we'll 
+    // just let the error fall through
+    UStack currentBreakPositions(status); 

     UStack possibleBreakPositions(status);
     UVector wrongBreakPositions(status);
 
     UStack possibleBreakPositions(status);
     UVector wrongBreakPositions(status);
 


@@ -445,6 +464,9 @@ DictionaryBasedBreakIterator::divideUpDictionaryRange(int32_t startPos, int32_t
         // the possible-break-positions stack
         if (fTables->fDictionary->at(state, (int32_t)0) == -1) {
             possibleBreakPositions.push(fText->getIndex(), status);
         // the possible-break-positions stack
         if (fTables->fDictionary->at(state, (int32_t)0) == -1) {
             possibleBreakPositions.push(fText->getIndex(), status);

+            if (U_FAILURE(status)) {
+                return;
+            }

         }
 
         // look up the new state to transition to in the dictionary
         }
 
         // look up the new state to transition to in the dictionary


@@ -456,6 +478,9 @@ DictionaryBasedBreakIterator::divideUpDictionaryRange(int32_t startPos, int32_t
         // of the loop.
         if (state == -1) {
             currentBreakPositions.push(fText->getIndex(), status);
         // of the loop.
         if (state == -1) {
             currentBreakPositions.push(fText->getIndex(), status);

+            if (U_FAILURE(status)) {
+                return;
+            }

             break;
         }
 
             break;
         }
 


@@ -501,6 +526,9 @@ DictionaryBasedBreakIterator::divideUpDictionaryRange(int32_t startPos, int32_t
                     currentBreakPositions.removeAllElements();
                     for (int32_t i = 0; i < bestBreakPositions.size(); i++) {
                         currentBreakPositions.push(bestBreakPositions.elementAti(i), status);
                     currentBreakPositions.removeAllElements();
                     for (int32_t i = 0; i < bestBreakPositions.size(); i++) {
                         currentBreakPositions.push(bestBreakPositions.elementAti(i), status);

+                        if (U_FAILURE(status)) {
+                            return;
+                        }

                     }
                     bestBreakPositions.removeAllElements();
                     if (farthestEndPoint < endPos) {
                     }
                     bestBreakPositions.removeAllElements();
                     if (farthestEndPoint < endPos) {


@@ -515,9 +543,15 @@ DictionaryBasedBreakIterator::divideUpDictionaryRange(int32_t startPos, int32_t
                             || currentBreakPositions.peeki() != fText->getIndex())
                             && fText->getIndex() != startPos) {
                         currentBreakPositions.push(fText->getIndex(), status);
                             || currentBreakPositions.peeki() != fText->getIndex())
                             && fText->getIndex() != startPos) {
                         currentBreakPositions.push(fText->getIndex(), status);

+                        if (U_FAILURE(status)) {
+                            return;
+                        }

                     }
                     fText->next();
                     currentBreakPositions.push(fText->getIndex(), status);
                     }
                     fText->next();
                     currentBreakPositions.push(fText->getIndex(), status);

+                    if (U_FAILURE(status)) {
+                        return;
+                    }

                 }
             }
 
                 }
             }
 


@@ -561,6 +595,9 @@ DictionaryBasedBreakIterator::divideUpDictionaryRange(int32_t startPos, int32_t
         currentBreakPositions.popi();
     }
     currentBreakPositions.push(endPos, status);
         currentBreakPositions.popi();
     }
     currentBreakPositions.push(endPos, status);

+    if (U_FAILURE(status)) {
+        return;
+    }

 
     // create a regular array to hold the break positions and copy
     // the break positions from the stack to the array (in addition,
 
     // create a regular array to hold the break positions and copy
     // the break positions from the stack to the array (in addition,