Update ICU to 54.1 step 1

source/i18n/nfrule.cpp

 /*
 ******************************************************************************
-*   Copyright (C) 1997-2011, International Business Machines
+*   Copyright (C) 1997-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 ******************************************************************************
 *   file name:  nfrule.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 * Modification history
 * Date        Name      Comments
 * 10/11/2001  Doug      Ported from ICU4J
 */
 
 #include "nfrule.h"
 
 #if U_HAVE_RBNF
 
+#include "unicode/localpointer.h"
 #include "unicode/rbnf.h"
 #include "unicode/tblcoll.h"
+#include "unicode/plurfmt.h"
+#include "unicode/upluralrules.h"
 #include "unicode/coleitr.h"
 #include "unicode/uchar.h"
 #include "nfrs.h"
 #include "nfrlist.h"
 #include "nfsubs.h"
 #include "patternprops.h"
 
 U_NAMESPACE_BEGIN
 
 NFRule::NFRule(const RuleBasedNumberFormat* _rbnf)
   : baseValue((int32_t)0)
   , radix(0)
   , exponent(0)
   , ruleText()
   , sub1(NULL)
   , sub2(NULL)
   , formatter(_rbnf)
+  , rulePatternFormat(NULL)
 {
 }
 
 NFRule::~NFRule()
 {
-  delete sub1;
-  delete sub2;
+    if (sub1 != sub2) {
+        delete sub2;
+    }
+    delete sub1;
+    delete rulePatternFormat;
 }
 
 static const UChar gLeftBracket = 0x005b;
 static const UChar gRightBracket = 0x005d;
 static const UChar gColon = 0x003a;
 static const UChar gZero = 0x0030;
 static const UChar gNine = 0x0039;
 static const UChar gSpace = 0x0020;
 static const UChar gSlash = 0x002f;
 static const UChar gGreaterThan = 0x003e;
 static const UChar gLessThan = 0x003c;
 static const UChar gComma = 0x002c;
 static const UChar gDot = 0x002e;
 static const UChar gTick = 0x0027;
 //static const UChar gMinus = 0x002d;
 static const UChar gSemicolon = 0x003b;
 
 static const UChar gMinusX[] =                  {0x2D, 0x78, 0};    /* "-x" */
 static const UChar gXDotX[] =                   {0x78, 0x2E, 0x78, 0}; /* "x.x" */
 static const UChar gXDotZero[] =                {0x78, 0x2E, 0x30, 0}; /* "x.0" */
 static const UChar gZeroDotX[] =                {0x30, 0x2E, 0x78, 0}; /* "0.x" */
 
+static const UChar gDollarOpenParenthesis[] =   {0x24, 0x28, 0}; /* "$(" */
+static const UChar gClosedParenthesisDollar[] = {0x29, 0x24, 0}; /* ")$" */
+
 static const UChar gLessLess[] =                {0x3C, 0x3C, 0};    /* "<<" */
 static const UChar gLessPercent[] =             {0x3C, 0x25, 0};    /* "<%" */
 static const UChar gLessHash[] =                {0x3C, 0x23, 0};    /* "<#" */
 static const UChar gLessZero[] =                {0x3C, 0x30, 0};    /* "<0" */
 static const UChar gGreaterGreater[] =          {0x3E, 0x3E, 0};    /* ">>" */
 static const UChar gGreaterPercent[] =          {0x3E, 0x25, 0};    /* ">%" */
 static const UChar gGreaterHash[] =             {0x3E, 0x23, 0};    /* ">#" */
 static const UChar gGreaterZero[] =             {0x3E, 0x30, 0};    /* ">0" */
 static const UChar gEqualPercent[] =            {0x3D, 0x25, 0};    /* "=%" */
 static const UChar gEqualHash[] =               {0x3D, 0x23, 0};    /* "=#" */
@@ skipping 31 matching lines @@
     int32_t brack1 = description.indexOf(gLeftBracket);
     int32_t brack2 = description.indexOf(gRightBracket);
 
     // if the description doesn't contain a matched pair of brackets,
     // or if it's of a type that doesn't recognize bracketed text,
     // then leave the description alone, initialize the rule's
     // rule text and substitutions, and return that rule
     if (brack1 == -1 || brack2 == -1 || brack1 > brack2
         || rule1->getType() == kProperFractionRule
         || rule1->getType() == kNegativeNumberRule) {
-        rule1->ruleText = description;
-        rule1->extractSubstitutions(ruleSet, predecessor, rbnf, status);
+        rule1->extractSubstitutions(ruleSet, description, predecessor, status);
         rules.add(rule1);
     } else {
         // if the description does contain a matched pair of brackets,
         // then it's really shorthand for two rules (with one exception)
         NFRule* rule2 = NULL;
         UnicodeString sbuf;
 
         // we'll actually only split the rule into two rules if its
         // base value is an even multiple of its divisor (or it's one
         // of the special rules)
@@ skipping 39 matching lines @@
             // same divisor)
             rule2->radix = rule1->radix;
             rule2->exponent = rule1->exponent;
 
             // rule2's rule text omits the stuff in brackets: initalize
             // its rule text and substitutions accordingly
             sbuf.append(description, 0, brack1);
             if (brack2 + 1 < description.length()) {
                 sbuf.append(description, brack2 + 1, description.length() - brack2 - 1);
             }
-            rule2->ruleText.setTo(sbuf);
-            rule2->extractSubstitutions(ruleSet, predecessor, rbnf, status);
+            rule2->extractSubstitutions(ruleSet, sbuf, predecessor, status);
         }
 
         // rule1's text includes the text in the brackets but omits
         // the brackets themselves: initialize _its_ rule text and
         // substitutions accordingly
         sbuf.setTo(description, 0, brack1);
         sbuf.append(description, brack1 + 1, brack2 - brack1 - 1);
         if (brack2 + 1 < description.length()) {
             sbuf.append(description, brack2 + 1, description.length() - brack2 - 1);
         }
-        rule1->ruleText.setTo(sbuf);
-        rule1->extractSubstitutions(ruleSet, predecessor, rbnf, status);
+        rule1->extractSubstitutions(ruleSet, sbuf, predecessor, status);
 
         // if we only have one rule, return it; if we have two, return
         // a two-element array containing them (notice that rule2 goes
         // BEFORE rule1 in the list: in all cases, rule2 OMITS the
         // material in the brackets and rule1 INCLUDES the material
         // in the brackets)
         if (rule2 != NULL) {
             rules.add(rule2);
         }
         rules.add(rule1);
@@ skipping 158 matching lines @@
 /**
 * Searches the rule's rule text for the substitution tokens,
 * creates the substitutions, and removes the substitution tokens
 * from the rule's rule text.
 * @param owner The rule set containing this rule
 * @param predecessor The rule preseding this one in "owners" rule list
 * @param ownersOwner The RuleBasedFormat that owns this rule
 */
 void
 NFRule::extractSubstitutions(const NFRuleSet* ruleSet,
+                             const UnicodeString &ruleText,
                              const NFRule* predecessor,
-                             const RuleBasedNumberFormat* rbnf,
                              UErrorCode& status)
 {
-    if (U_SUCCESS(status)) {
-        sub1 = extractSubstitution(ruleSet, predecessor, rbnf, status);
-        sub2 = extractSubstitution(ruleSet, predecessor, rbnf, status);
+    if (U_FAILURE(status)) {
+        return;
+    }
+    this->ruleText = ruleText;
+    this->rulePatternFormat = NULL;
+    sub1 = extractSubstitution(ruleSet, predecessor, status);
+    if (sub1 == NULL || sub1->isNullSubstitution()) {
+        // Small optimization. There is no need to create a redundant NullSubstitution.
+        sub2 = sub1;
+    }
+    else {
+        sub2 = extractSubstitution(ruleSet, predecessor, status);
+    }
+    int32_t pluralRuleStart = this->ruleText.indexOf(gDollarOpenParenthesis, -1, 0);
+    int32_t pluralRuleEnd = (pluralRuleStart >= 0 ? this->ruleText.indexOf(gClosedParenthesisDollar, -1, pluralRuleStart) : -1);
+    if (pluralRuleEnd >= 0) {
+        int32_t endType = this->ruleText.indexOf(gComma, pluralRuleStart);
+        if (endType < 0) {
+            status = U_PARSE_ERROR;
+            return;
+        }
+        UnicodeString type(this->ruleText.tempSubString(pluralRuleStart + 2, endType - pluralRuleStart - 2));
+        UPluralType pluralType;
+        if (type.startsWith(UNICODE_STRING_SIMPLE("cardinal"))) {
+            pluralType = UPLURAL_TYPE_CARDINAL;
+        }
+        else if (type.startsWith(UNICODE_STRING_SIMPLE("ordinal"))) {
+            pluralType = UPLURAL_TYPE_ORDINAL;
+        }
+        else {
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+            return;
+        }
+        rulePatternFormat = formatter->createPluralFormat(pluralType,
+                this->ruleText.tempSubString(endType + 1, pluralRuleEnd - endType - 1), status);
     }
 }
 
 /**
 * Searches the rule's rule text for the first substitution token,
 * creates a substitution based on it, and removes the token from
 * the rule's rule text.
 * @param owner The rule set containing this rule
 * @param predecessor The rule preceding this one in the rule set's
 * rule list
 * @param ownersOwner The RuleBasedNumberFormat that owns this rule
 * @return The newly-created substitution.  This is never null; if
 * the rule text doesn't contain any substitution tokens, this will
 * be a NullSubstitution.
 */
 NFSubstitution *
 NFRule::extractSubstitution(const NFRuleSet* ruleSet,
                             const NFRule* predecessor,
-                            const RuleBasedNumberFormat* rbnf,
                             UErrorCode& status)
 {
     NFSubstitution* result = NULL;
 
     // search the rule's rule text for the first two characters of
     // a substitution token
     int32_t subStart = indexOfAny(tokenStrings);
     int32_t subEnd = subStart;
 
     // if we didn't find one, create a null substitution positioned
     // at the end of the rule text
     if (subStart == -1) {
         return NFSubstitution::makeSubstitution(ruleText.length(), this, predecessor,
-            ruleSet, rbnf, UnicodeString(), status);
+            ruleSet, this->formatter, UnicodeString(), status);
     }
 
     // special-case the ">>>" token, since searching for the > at the
     // end will actually find the > in the middle
     if (ruleText.indexOf(gGreaterGreaterGreater, 3, 0) == subStart) {
         subEnd = subStart + 2;
 
         // otherwise the substitution token ends with the same character
         // it began with
     } else {
         UChar c = ruleText.charAt(subStart);
         subEnd = ruleText.indexOf(c, subStart + 1);
         // special case for '<%foo<<'
         if (c == gLessThan && subEnd != -1 && subEnd < ruleText.length() - 1 && ruleText.charAt(subEnd+1) == c) {
             // ordinals use "=#,##0==%abbrev=" as their rule.  Notice that the '==' in the middle
             // occurs because of the juxtaposition of two different rules.  The check for '<' is a hack
             // to get around this.  Having the duplicate at the front would cause problems with
             // rules like "<<%" to format, say, percents...
             ++subEnd;
         }
    }
 
     // if we don't find the end of the token (i.e., if we're on a single,
     // unmatched token character), create a null substitution positioned
     // at the end of the rule
     if (subEnd == -1) {
         return NFSubstitution::makeSubstitution(ruleText.length(), this, predecessor,
-            ruleSet, rbnf, UnicodeString(), status);
+            ruleSet, this->formatter, UnicodeString(), status);
     }
 
     // if we get here, we have a real substitution token (or at least
     // some text bounded by substitution token characters).  Use
     // makeSubstitution() to create the right kind of substitution
     UnicodeString subToken;
     subToken.setTo(ruleText, subStart, subEnd + 1 - subStart);
     result = NFSubstitution::makeSubstitution(subStart, this, predecessor, ruleSet,
-        rbnf, subToken, status);
+        this->formatter, subToken, status);
 
     // remove the substitution from the rule text
     ruleText.removeBetween(subStart, subEnd+1);
 
     return result;
 }
 
 /**
  * Sets the rule's base value, and causes the radix and exponent
  * to be recalculated.  This is used during construction when we
@@ skipping 178 matching lines @@
 /**
 * Formats the number, and inserts the resulting text into
 * toInsertInto.
 * @param number The number being formatted
 * @param toInsertInto The string where the resultant text should
 * be inserted
 * @param pos The position in toInsertInto where the resultant text
 * should be inserted
 */
 void
-NFRule::doFormat(int64_t number, UnicodeString& toInsertInto, int32_t pos) const
+NFRule::doFormat(int64_t number, UnicodeString& toInsertInto, int32_t pos, UErrorCode& status) const
 {
     // first, insert the rule's rule text into toInsertInto at the
     // specified position, then insert the results of the substitutions
     // into the right places in toInsertInto (notice we do the
     // substitutions in reverse order so that the offsets don't get
     // messed up)
-    toInsertInto.insert(pos, ruleText);
-    sub2->doSubstitution(number, toInsertInto, pos);
-    sub1->doSubstitution(number, toInsertInto, pos);
+    int32_t pluralRuleStart = ruleText.length();
+    int32_t lengthOffset = 0;
+    if (!rulePatternFormat) {
+        toInsertInto.insert(pos, ruleText);
+    }
+    else {
+        pluralRuleStart = ruleText.indexOf(gDollarOpenParenthesis, -1, 0);
+        int pluralRuleEnd = ruleText.indexOf(gClosedParenthesisDollar, -1, pluralRuleStart);
+        int initialLength = toInsertInto.length();
+        if (pluralRuleEnd < ruleText.length() - 1) {
+            toInsertInto.insert(pos, ruleText.tempSubString(pluralRuleEnd + 2));
+        }
+        toInsertInto.insert(pos,
+            rulePatternFormat->format((int32_t)(number/uprv_pow(radix, exponent)), status));
+        if (pluralRuleStart > 0) {
+            toInsertInto.insert(pos, ruleText.tempSubString(0, pluralRuleStart));
+        }
+        lengthOffset = ruleText.length() - (toInsertInto.length() - initialLength);
+    }
+
+    if (!sub2->isNullSubstitution()) {
+        sub2->doSubstitution(number, toInsertInto, pos - (sub2->getPos() > pluralRuleStart ? lengthOffset : 0), status);
+    }
+    if (!sub1->isNullSubstitution()) {
+        sub1->doSubstitution(number, toInsertInto, pos - (sub1->getPos() > pluralRuleStart ? lengthOffset : 0), status);
+    }
 }
 
 /**
 * Formats the number, and inserts the resulting text into
 * toInsertInto.
 * @param number The number being formatted
 * @param toInsertInto The string where the resultant text should
 * be inserted
 * @param pos The position in toInsertInto where the resultant text
 * should be inserted
 */
 void
-NFRule::doFormat(double number, UnicodeString& toInsertInto, int32_t pos) const
+NFRule::doFormat(double number, UnicodeString& toInsertInto, int32_t pos, UErrorCode& status) const
 {
     // first, insert the rule's rule text into toInsertInto at the
     // specified position, then insert the results of the substitutions
     // into the right places in toInsertInto
     // [again, we have two copies of this routine that do the same thing
     // so that we don't sacrifice precision in a long by casting it
     // to a double]
-    toInsertInto.insert(pos, ruleText);
-    sub2->doSubstitution(number, toInsertInto, pos);
-    sub1->doSubstitution(number, toInsertInto, pos);
+    int32_t pluralRuleStart = ruleText.length();
+    int32_t lengthOffset = 0;
+    if (!rulePatternFormat) {
+        toInsertInto.insert(pos, ruleText);
+    }
+    else {
+        pluralRuleStart = ruleText.indexOf(gDollarOpenParenthesis, -1, 0);
+        int pluralRuleEnd = ruleText.indexOf(gClosedParenthesisDollar, -1, pluralRuleStart);
+        int initialLength = toInsertInto.length();
+        if (pluralRuleEnd < ruleText.length() - 1) {
+            toInsertInto.insert(pos, ruleText.tempSubString(pluralRuleEnd + 2));
+        }
+        toInsertInto.insert(pos,
+            rulePatternFormat->format((int32_t)(number/uprv_pow(radix, exponent)), status));
+        if (pluralRuleStart > 0) {
+            toInsertInto.insert(pos, ruleText.tempSubString(0, pluralRuleStart));
+        }
+        lengthOffset = ruleText.length() - (toInsertInto.length() - initialLength);
+    }
+
+    if (!sub2->isNullSubstitution()) {
+        sub2->doSubstitution(number, toInsertInto, pos - (sub2->getPos() > pluralRuleStart ? lengthOffset : 0), status);
+    }
+    if (!sub1->isNullSubstitution()) {
+        sub1->doSubstitution(number, toInsertInto, pos - (sub1->getPos() > pluralRuleStart ? lengthOffset : 0), status);
+    }
 }
 
 /**
 * Used by the owning rule set to determine whether to invoke the
 * rollback rule (i.e., whether this rule or the one that precedes
 * it in the rule set's list should be used to format the number)
 * @param The number being formatted
 * @return True if the rule set should use the rule that precedes
 * this one in its list; false if it should use this rule
 */
@@ skipping 439 matching lines @@
 #if !UCONFIG_NO_COLLATION
     // go through all this grief if we're in lenient-parse mode
     if (formatter->isLenient()) {
         // get the formatter's collator and use it to create two
         // collation element iterators, one over the target string
         // and another over the prefix (right now, we'll throw an
         // exception if the collator we get back from the formatter
         // isn't a RuleBasedCollator, because RuleBasedCollator defines
         // the CollationElementIterator protocol.  Hopefully, this
         // will change someday.)
-        RuleBasedCollator* collator = (RuleBasedCollator*)formatter->getCollator();
-        CollationElementIterator* strIter = collator->createCollationElementIterator(str);
-        CollationElementIterator* prefixIter = collator->createCollationElementIterator(prefix);
+        const RuleBasedCollator* collator = formatter->getCollator();
+        if (collator == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return 0;
+        }
+        LocalPointer<CollationElementIterator> strIter(collator->createCollationElementIterator(str));
+        LocalPointer<CollationElementIterator> prefixIter(collator->createCollationElementIterator(prefix));
         // Check for memory allocation error.
-        if (collator == NULL || strIter == NULL || prefixIter == NULL) {
-                delete collator;
-                delete strIter;
-                delete prefixIter;
-                status = U_MEMORY_ALLOCATION_ERROR;
-                return 0;
+        if (strIter.isNull() || prefixIter.isNull()) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return 0;
         }
 
         UErrorCode err = U_ZERO_ERROR;
 
         // The original code was problematic.  Consider this match:
         // prefix = "fifty-"
         // string = " fifty-7"
         // The intent is to match string up to the '7', by matching 'fifty-' at position 1
         // in the string.  Unfortunately, we were getting a match, and then computing where
         // the match terminated by rematching the string.  The rematch code was using as an
@@ skipping 31 matching lines @@
 
             // if skipping over ignorables brought to the end of
             // the prefix, we DID match: drop out of the loop
             if (oPrefix == CollationElementIterator::NULLORDER) {
                 break;
             }
 
             // if skipping over ignorables brought us to the end
             // of the target string, we didn't match and return 0
             if (oStr == CollationElementIterator::NULLORDER) {
-                delete prefixIter;
-                delete strIter;
                 return 0;
             }
 
             // match collation elements from the two strings
             // (considering only primary differences).  If we
             // get a mismatch, dump out and return 0
             if (CollationElementIterator::primaryOrder(oStr)
                 != CollationElementIterator::primaryOrder(oPrefix)) {
-                delete prefixIter;
-                delete strIter;
                 return 0;
 
                 // otherwise, advance to the next character in each string
                 // and loop (we drop out of the loop when we exhaust
                 // collation elements in the prefix)
             } else {
                 oStr = strIter->next(err);
                 oPrefix = prefixIter->next(err);
             }
         }
 
         int32_t result = strIter->getOffset();
         if (oStr != CollationElementIterator::NULLORDER) {
             --result; // back over character that we don't want to consume;
         }
 
 #ifdef RBNF_DEBUG
         fprintf(stderr, "prefix length: %d\n", result);
 #endif
-        delete prefixIter;
-        delete strIter;
-
         return result;
 #if 0
         //----------------------------------------------------------------
         // JDK 1.2-specific API call
         // return strIter.getOffset();
         //----------------------------------------------------------------
         // JDK 1.1 HACK (take out for 1.2-specific code)
 
         // if we make it to here, we have a successful match.  Now we
         // have to find out HOW MANY characters from the target string
@@ skipping 63 matching lines @@
 * of the match, or -1 if there was no match.  Element 1 is the
 * number of characters in "str" that matched (which isn't necessarily
 * the same as the length of "key")
 */
 int32_t
 NFRule::findText(const UnicodeString& str,
                  const UnicodeString& key,
                  int32_t startingAt,
                  int32_t* length) const
 {
-#if !UCONFIG_NO_COLLATION
-    // if lenient parsing is turned off, this is easy: just call
-    // String.indexOf() and we're done
+    if (rulePatternFormat) {
+        Formattable result;
+        FieldPosition position(UNUM_INTEGER_FIELD);
+        position.setBeginIndex(startingAt);
+        rulePatternFormat->parseType(str, this, result, position);
+        int start = position.getBeginIndex();
+        if (start >= 0) {
+            int32_t pluralRuleStart = ruleText.indexOf(gDollarOpenParenthesis, -1, 0);
+            int32_t pluralRuleSuffix = ruleText.indexOf(gClosedParenthesisDollar, -1, pluralRuleStart) + 2;
+            int32_t matchLen = position.getEndIndex() - start;
+            UnicodeString prefix(ruleText.tempSubString(0, pluralRuleStart));
+            UnicodeString suffix(ruleText.tempSubString(pluralRuleSuffix));
+            if (str.compare(start - prefix.length(), prefix.length(), prefix, 0, prefix.length()) == 0
+                    && str.compare(start + matchLen, suffix.length(), suffix, 0, suffix.length()) == 0)
+            {
+                *length = matchLen + prefix.length() + suffix.length();
+                return start - prefix.length();
+            }
+        }
+        *length = 0;
+        return -1;
+    }
     if (!formatter->isLenient()) {
+        // if lenient parsing is turned off, this is easy: just call
+        // String.indexOf() and we're done
         *length = key.length();
         return str.indexOf(key, startingAt);
-
+    }
+    else {
         // but if lenient parsing is turned ON, we've got some work
         // ahead of us
-    } else
-#endif
-    {
-        //----------------------------------------------------------------
-        // JDK 1.1 HACK (take out of 1.2-specific code)
-
-        // in JDK 1.2, CollationElementIterator provides us with an
-        // API to map between character offsets and collation elements
-        // and we can do this by marching through the string comparing
-        // collation elements.  We can't do that in JDK 1.1.  Insted,
-        // we have to go through this horrible slow mess:
-        int32_t p = startingAt;
-        int32_t keyLen = 0;
-
-        // basically just isolate smaller and smaller substrings of
-        // the target string (each running to the end of the string,
-        // and with the first one running from startingAt to the end)
-        // and then use prefixLength() to see if the search key is at
-        // the beginning of each substring.  This is excruciatingly
-        // slow, but it will locate the key and tell use how long the
-        // matching text was.
-        UnicodeString temp;
-        UErrorCode status = U_ZERO_ERROR;
-        while (p < str.length() && keyLen == 0) {
-            temp.setTo(str, p, str.length() - p);
-            keyLen = prefixLength(temp, key, status);
-            if (U_FAILURE(status)) {
-                break;
-            }
-            if (keyLen != 0) {
-                *length = keyLen;
-                return p;
-            }
-            ++p;
-        }
-        // if we make it to here, we didn't find it.  Return -1 for the
-        // location.  The length should be ignored, but set it to 0,
-        // which should be "safe"
-        *length = 0;
-        return -1;
-
-        //----------------------------------------------------------------
-        // JDK 1.2 version of this routine
-        //RuleBasedCollator collator = (RuleBasedCollator)formatter.getCollator();
-        //
-        //CollationElementIterator strIter = collator.getCollationElementIterator(str);
-        //CollationElementIterator keyIter = collator.getCollationElementIterator(key);
-        //
-        //int keyStart = -1;
-        //
-        //str.setOffset(startingAt);
-        //
-        //int oStr = strIter.next();
-        //int oKey = keyIter.next();
-        //while (oKey != CollationElementIterator.NULLORDER) {
-        //    while (oStr != CollationElementIterator.NULLORDER &&
-        //                CollationElementIterator.primaryOrder(oStr) == 0)
-        //        oStr = strIter.next();
-        //
-        //    while (oKey != CollationElementIterator.NULLORDER &&
-        //                CollationElementIterator.primaryOrder(oKey) == 0)
-        //        oKey = keyIter.next();
-        //
-        //    if (oStr == CollationElementIterator.NULLORDER) {
-        //        return new int[] { -1, 0 };
-        //    }
-        //
-        //    if (oKey == CollationElementIterator.NULLORDER) {
-        //        break;
-        //    }
-        //
-        //    if (CollationElementIterator.primaryOrder(oStr) ==
-        //            CollationElementIterator.primaryOrder(oKey)) {
-        //        keyStart = strIter.getOffset();
-        //        oStr = strIter.next();
-        //        oKey = keyIter.next();
-        //    } else {
-        //        if (keyStart != -1) {
-        //            keyStart = -1;
-        //            keyIter.reset();
-        //        } else {
-        //            oStr = strIter.next();
-        //        }
-        //    }
-        //}
-        //
-        //if (oKey == CollationElementIterator.NULLORDER) {
-        //    return new int[] { keyStart, strIter.getOffset() - keyStart };
-        //} else {
-        //    return new int[] { -1, 0 };
-        //}
+        return findTextLenient(str, key, startingAt, length);
     }
 }
 
+int32_t
+NFRule::findTextLenient(const UnicodeString& str,
+                 const UnicodeString& key,
+                 int32_t startingAt,
+                 int32_t* length) const
+{
+    //----------------------------------------------------------------
+    // JDK 1.1 HACK (take out of 1.2-specific code)
+
+    // in JDK 1.2, CollationElementIterator provides us with an
+    // API to map between character offsets and collation elements
+    // and we can do this by marching through the string comparing
+    // collation elements.  We can't do that in JDK 1.1.  Insted,
+    // we have to go through this horrible slow mess:
+    int32_t p = startingAt;
+    int32_t keyLen = 0;
+
+    // basically just isolate smaller and smaller substrings of
+    // the target string (each running to the end of the string,
+    // and with the first one running from startingAt to the end)
+    // and then use prefixLength() to see if the search key is at
+    // the beginning of each substring.  This is excruciatingly
+    // slow, but it will locate the key and tell use how long the
+    // matching text was.
+    UnicodeString temp;
+    UErrorCode status = U_ZERO_ERROR;
+    while (p < str.length() && keyLen == 0) {
+        temp.setTo(str, p, str.length() - p);
+        keyLen = prefixLength(temp, key, status);
+        if (U_FAILURE(status)) {
+            break;
+        }
+        if (keyLen != 0) {
+            *length = keyLen;
+            return p;
+        }
+        ++p;
+    }
+    // if we make it to here, we didn't find it.  Return -1 for the
+    // location.  The length should be ignored, but set it to 0,
+    // which should be "safe"
+    *length = 0;
+    return -1;
+}
+
 /**
 * Checks to see whether a string consists entirely of ignorable
 * characters.
 * @param str The string to test.
 * @return true if the string is empty of consists entirely of
 * characters that the number formatter's collator says are
 * ignorable at the primary-order level.  false otherwise.
 */
 UBool
 NFRule::allIgnorable(const UnicodeString& str, UErrorCode& status) const
 {
     // if the string is empty, we can just return true
     if (str.length() == 0) {
         return TRUE;
     }
 
 #if !UCONFIG_NO_COLLATION
     // if lenient parsing is turned on, walk through the string with
     // a collation element iterator and make sure each collation
     // element is 0 (ignorable) at the primary level
     if (formatter->isLenient()) {
-        RuleBasedCollator* collator = (RuleBasedCollator*)(formatter->getCollator());
-        CollationElementIterator* iter = collator->createCollationElementIterator(str);
-        
+        const RuleBasedCollator* collator = formatter->getCollator();
+        if (collator == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return FALSE;
+        }
+        LocalPointer<CollationElementIterator> iter(collator->createCollationElementIterator(str));
+
         // Memory allocation error check.
-        if (collator == NULL || iter == NULL) {
-                delete collator;
-                delete iter;
-                status = U_MEMORY_ALLOCATION_ERROR;
-                return FALSE;
+        if (iter.isNull()) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return FALSE;
         }
 
         UErrorCode err = U_ZERO_ERROR;
         int32_t o = iter->next(err);
         while (o != CollationElementIterator::NULLORDER
             && CollationElementIterator::primaryOrder(o) == 0) {
             o = iter->next(err);
         }
 
-        delete iter;
         return o == CollationElementIterator::NULLORDER;
     }
 #endif
 
     // if lenient parsing is turned off, there is no such thing as
     // an ignorable character: return true only if the string is empty
     return FALSE;
 }
 
 U_NAMESPACE_END
 
 /* U_HAVE_RBNF */
 #endif
-
-