src/third_party/icu/source/i18n/uspoof_conf.cpp

   1 /*
   2 ******************************************************************************
   3 *
   4 *   Copyright (C) 2008-2013, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 ******************************************************************************
   8 *   file name:  uspoof_conf.cpp
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   created on: 2009Jan05  (refactoring earlier files)
  14 *   created by: Andy Heninger
  15 *
  16 *   Internal classes for compililing confusable data into its binary (runtime) form.
  17 */
  18
  19 #include "unicode/utypes.h"
  20 #include "unicode/uspoof.h"
  21 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
  22 #if !UCONFIG_NO_NORMALIZATION
  23
  24 #include "unicode/unorm.h"
  25 #include "unicode/uregex.h"
  26 #include "unicode/ustring.h"
  27 #include "cmemory.h"
  28 #include "uspoof_impl.h"
  29 #include "uhash.h"
  30 #include "uvector.h"
  31 #include "uassert.h"
  32 #include "uarrsort.h"
  33 #include "uspoof_conf.h"
  34
  35 U_NAMESPACE_USE
  36
  37
  38 //---------------------------------------------------------------------
  39 //
  40 //  buildConfusableData   Compile the source confusable data, as defined by
  41 //                        the Unicode data file confusables.txt, into the binary
  42 //                        structures used by the confusable detector.
  43 //
  44 //                        The binary structures are described in uspoof_impl.h
  45 //
  46 //     1.  parse the data, building 4 hash tables, one each for the SL, SA, ML and MA
  47 //         tables.  Each maps from a UChar32 to a String.
  48 //
  49 //     2.  Sort all of the strings encountered by length, since they will need to
  50 //         be stored in that order in the final string table.
  51 //
  52 //     3.  Build a list of keys (UChar32s) from the four mapping tables.  Sort the
  53 //         list because that will be the ordering of our runtime table.
  54 //
  55 //     4.  Generate the run time string table.  This is generated before the key & value
  56 //         tables because we need the string indexes when building those tables.
  57 //
  58 //     5.  Build the run-time key and value tables.  These are parallel tables, and are built
  59 //         at the same time
  60 //
  61
  62 SPUString::SPUString(UnicodeString *s) {
  63     fStr = s;
  64     fStrTableIndex = 0;
  65 }
  66
  67
  68 SPUString::~SPUString() {
  69     delete fStr;
  70 }
  71
  72
  73 SPUStringPool::SPUStringPool(UErrorCode &status) : fVec(NULL), fHash(NULL) {
  74     fVec = new UVector(status);
  75     fHash = uhash_open(uhash_hashUnicodeString,           // key hash function
  76                        uhash_compareUnicodeString,        // Key Comparator
  77                        NULL,                              // Value Comparator
  78                        &status);
  79 }
  80
  81
  82 SPUStringPool::~SPUStringPool() {
  83     int i;
  84     for (i=fVec->size()-1; i>=0; i--) {
  85         SPUString *s = static_cast<SPUString *>(fVec->elementAt(i));
  86         delete s;
  87     }
  88     delete fVec;
  89     uhash_close(fHash);
  90 }
  91
  92
  93 int32_t SPUStringPool::size() {
  94     return fVec->size();
  95 }
  96
  97 SPUString *SPUStringPool::getByIndex(int32_t index) {
  98     SPUString *retString = (SPUString *)fVec->elementAt(index);
  99     return retString;
 100 }
 101
 102
 103 // Comparison function for ordering strings in the string pool.
 104 // Compare by length first, then, within a group of the same length,
 105 // by code point order.
 106 // Conforms to the type signature for a USortComparator in uvector.h
 107
 108 static int8_t U_CALLCONV SPUStringCompare(UHashTok left, UHashTok right) {
 109         const SPUString *sL = const_cast<const SPUString *>(
 110         static_cast<SPUString *>(left.pointer));
 111         const SPUString *sR = const_cast<const SPUString *>(
 112             static_cast<SPUString *>(right.pointer));
 113     int32_t lenL = sL->fStr->length();
 114     int32_t lenR = sR->fStr->length();
 115     if (lenL < lenR) {
 116         return -1;
 117     } else if (lenL > lenR) {
 118         return 1;
 119     } else {
 120         return sL->fStr->compare(*(sR->fStr));
 121     }
 122 }
 123
 124 void SPUStringPool::sort(UErrorCode &status) {
 125     fVec->sort(SPUStringCompare, status);
 126 }
 127
 128
 129 SPUString *SPUStringPool::addString(UnicodeString *src, UErrorCode &status) {
 130     SPUString *hashedString = static_cast<SPUString *>(uhash_get(fHash, src));
 131     if (hashedString != NULL) {
 132         delete src;
 133     } else {
 134         hashedString = new SPUString(src);
 135         uhash_put(fHash, src, hashedString, &status);
 136         fVec->addElement(hashedString, status);
 137     }
 138     return hashedString;
 139 }
 140
 141
 142
 143 ConfusabledataBuilder::ConfusabledataBuilder(SpoofImpl *spImpl, UErrorCode &status) :
 144     fSpoofImpl(spImpl),
 145     fInput(NULL),
 146     fSLTable(NULL),
 147     fSATable(NULL),
 148     fMLTable(NULL),
 149     fMATable(NULL),
 150     fKeySet(NULL),
 151     fKeyVec(NULL),
 152     fValueVec(NULL),
 153     fStringTable(NULL),
 154     fStringLengthsTable(NULL),
 155     stringPool(NULL),
 156     fParseLine(NULL),
 157     fParseHexNum(NULL),
 158     fLineNum(0)
 159 {
 160     if (U_FAILURE(status)) {
 161         return;
 162     }
 163     fSLTable    = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status);
 164     fSATable    = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status);
 165     fMLTable    = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status);
 166     fMATable    = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status);
 167     fKeySet     = new UnicodeSet();
 168     fKeyVec     = new UVector(status);
 169     fValueVec   = new UVector(status);
 170     stringPool = new SPUStringPool(status);
 171 }
 172
 173
 174 ConfusabledataBuilder::~ConfusabledataBuilder() {
 175     uprv_free(fInput);
 176     uregex_close(fParseLine);
 177     uregex_close(fParseHexNum);
 178     uhash_close(fSLTable);
 179     uhash_close(fSATable);
 180     uhash_close(fMLTable);
 181     uhash_close(fMATable);
 182     delete fKeySet;
 183     delete fKeyVec;
 184     delete fStringTable;
 185     delete fStringLengthsTable;
 186     delete fValueVec;
 187     delete stringPool;
 188 }
 189
 190
 191 void ConfusabledataBuilder::buildConfusableData(SpoofImpl * spImpl, const char * confusables,
 192     int32_t confusablesLen, int32_t *errorType, UParseError *pe, UErrorCode &status) {
 193
 194     if (U_FAILURE(status)) {
 195         return;
 196     }
 197     ConfusabledataBuilder builder(spImpl, status);
 198     builder.build(confusables, confusablesLen, status);
 199     if (U_FAILURE(status) && errorType != NULL) {
 200         *errorType = USPOOF_SINGLE_SCRIPT_CONFUSABLE;
 201         pe->line = builder.fLineNum;
 202     }
 203 }
 204
 205
 206 void ConfusabledataBuilder::build(const char * confusables, int32_t confusablesLen,
 207                UErrorCode &status) {
 208
 209     // Convert the user input data from UTF-8 to UChar (UTF-16)
 210     int32_t inputLen = 0;
 211     if (U_FAILURE(status)) {
 212         return;
 213     }
 214     u_strFromUTF8(NULL, 0, &inputLen, confusables, confusablesLen, &status);
 215     if (status != U_BUFFER_OVERFLOW_ERROR) {
 216         return;
 217     }
 218     status = U_ZERO_ERROR;
 219     fInput = static_cast<UChar *>(uprv_malloc((inputLen+1) * sizeof(UChar)));
 220     if (fInput == NULL) {
 221         status = U_MEMORY_ALLOCATION_ERROR;
 222         return;
 223     }
 224     u_strFromUTF8(fInput, inputLen+1, NULL, confusables, confusablesLen, &status);
 225
 226
 227     // Regular Expression to parse a line from Confusables.txt.  The expression will match
 228     // any line.  What was matched is determined by examining which capture groups have a match.
 229     //   Capture Group 1:  the source char
 230     //   Capture Group 2:  the replacement chars
 231     //   Capture Group 3-6  the table type, SL, SA, ML, or MA
 232     //   Capture Group 7:  A blank or comment only line.
 233     //   Capture Group 8:  A syntactically invalid line.  Anything that didn't match before.
 234     // Example Line from the confusables.txt source file:
 235     //   "1D702 ;       006E 0329 ;     SL      # MATHEMATICAL ITALIC SMALL ETA ... "
 236     UnicodeString pattern(
 237         "(?m)^[ \\t]*([0-9A-Fa-f]+)[ \\t]+;"      // Match the source char
 238         "[ \\t]*([0-9A-Fa-f]+"                    // Match the replacement char(s)
 239            "(?:[ \\t]+[0-9A-Fa-f]+)*)[ \\t]*;"    //     (continued)
 240         "\\s*(?:(SL)|(SA)|(ML)|(MA))"             // Match the table type
 241         "[ \\t]*(?:#.*?)?$"                       // Match any trailing #comment
 242         "|^([ \\t]*(?:#.*?)?)$"       // OR match empty lines or lines with only a #comment
 243         "|^(.*?)$", -1, US_INV);      // OR match any line, which catches illegal lines.
 244     // TODO: Why are we using the regex C API here? C++ would just take UnicodeString...
 245     fParseLine = uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, &status);
 246
 247     // Regular expression for parsing a hex number out of a space-separated list of them.
 248     //   Capture group 1 gets the number, with spaces removed.
 249     pattern = UNICODE_STRING_SIMPLE("\\s*([0-9A-F]+)");
 250     fParseHexNum = uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, &status);
 251
 252     // Zap any Byte Order Mark at the start of input.  Changing it to a space is benign
 253     //   given the syntax of the input.
 254     if (*fInput == 0xfeff) {
 255         *fInput = 0x20;
 256     }
 257
 258     // Parse the input, one line per iteration of this loop.
 259     uregex_setText(fParseLine, fInput, inputLen, &status);
 260     while (uregex_findNext(fParseLine, &status)) {
 261         fLineNum++;
 262         if (uregex_start(fParseLine, 7, &status) >= 0) {
 263             // this was a blank or comment line.
 264             continue;
 265         }
 266         if (uregex_start(fParseLine, 8, &status) >= 0) {
 267             // input file syntax error.
 268             status = U_PARSE_ERROR;
 269             return;
 270         }
 271
 272         // We have a good input line.  Extract the key character and mapping string, and
 273         //    put them into the appropriate mapping table.
 274         UChar32 keyChar = SpoofImpl::ScanHex(fInput, uregex_start(fParseLine, 1, &status),
 275                           uregex_end(fParseLine, 1, &status), status);
 276
 277         int32_t mapStringStart = uregex_start(fParseLine, 2, &status);
 278         int32_t mapStringLength = uregex_end(fParseLine, 2, &status) - mapStringStart;
 279         uregex_setText(fParseHexNum, &fInput[mapStringStart], mapStringLength, &status);
 280
 281         UnicodeString  *mapString = new UnicodeString();
 282         if (mapString == NULL) {
 283             status = U_MEMORY_ALLOCATION_ERROR;
 284             return;
 285         }
 286         while (uregex_findNext(fParseHexNum, &status)) {
 287             UChar32 c = SpoofImpl::ScanHex(&fInput[mapStringStart], uregex_start(fParseHexNum, 1, &status),
 288                                  uregex_end(fParseHexNum, 1, &status), status);
 289             mapString->append(c);
 290         }
 291         U_ASSERT(mapString->length() >= 1);
 292
 293         // Put the map (value) string into the string pool
 294         // This a little like a Java intern() - any duplicates will be eliminated.
 295         SPUString *smapString = stringPool->addString(mapString, status);
 296
 297         // Add the UChar32 -> string mapping to the appropriate table.
 298         UHashtable *table = uregex_start(fParseLine, 3, &status) >= 0 ? fSLTable :
 299                             uregex_start(fParseLine, 4, &status) >= 0 ? fSATable :
 300                             uregex_start(fParseLine, 5, &status) >= 0 ? fMLTable :
 301                             uregex_start(fParseLine, 6, &status) >= 0 ? fMATable :
 302                             NULL;
 303         U_ASSERT(table != NULL);
 304         uhash_iput(table, keyChar, smapString, &status);
 305         fKeySet->add(keyChar);
 306         if (U_FAILURE(status)) {
 307             return;
 308         }
 309     }
 310
 311     // Input data is now all parsed and collected.
 312     // Now create the run-time binary form of the data.
 313     //
 314     // This is done in two steps.  First the data is assembled into vectors and strings,
 315     //   for ease of construction, then the contents of these collections are dumped
 316     //   into the actual raw-bytes data storage.
 317
 318     // Build up the string array, and record the index of each string therein
 319     //  in the (build time only) string pool.
 320     // Strings of length one are not entered into the strings array.
 321     // At the same time, build up the string lengths table, which records the
 322     // position in the string table of the first string of each length >= 4.
 323     // (Strings in the table are sorted by length)
 324     stringPool->sort(status);
 325     fStringTable = new UnicodeString();
 326     fStringLengthsTable = new UVector(status);
 327     int32_t previousStringLength = 0;
 328     int32_t previousStringIndex  = 0;
 329     int32_t poolSize = stringPool->size();
 330     int32_t i;
 331     for (i=0; i<poolSize; i++) {
 332         SPUString *s = stringPool->getByIndex(i);
 333         int32_t strLen = s->fStr->length();
 334         int32_t strIndex = fStringTable->length();
 335         U_ASSERT(strLen >= previousStringLength);
 336         if (strLen == 1) {
 337             // strings of length one do not get an entry in the string table.
 338             // Keep the single string character itself here, which is the same
 339             //  convention that is used in the final run-time string table index.
 340             s->fStrTableIndex = s->fStr->charAt(0);
 341         } else {
 342             if ((strLen > previousStringLength) && (previousStringLength >= 4)) {
 343                 fStringLengthsTable->addElement(previousStringIndex, status);
 344                 fStringLengthsTable->addElement(previousStringLength, status);
 345             }
 346             s->fStrTableIndex = strIndex;
 347             fStringTable->append(*(s->fStr));
 348         }
 349         previousStringLength = strLen;
 350         previousStringIndex  = strIndex;
 351     }
 352     // Make the final entry to the string lengths table.
 353     //   (it holds an entry for the _last_ string of each length, so adding the
 354     //    final one doesn't happen in the main loop because no longer string was encountered.)
 355     if (previousStringLength >= 4) {
 356         fStringLengthsTable->addElement(previousStringIndex, status);
 357         fStringLengthsTable->addElement(previousStringLength, status);
 358     }
 359
 360     // Construct the compile-time Key and Value tables
 361     //
 362     // For each key code point, check which mapping tables it applies to,
 363     //   and create the final data for the key & value structures.
 364     //
 365     //   The four logical mapping tables are conflated into one combined table.
 366     //   If multiple logical tables have the same mapping for some key, they
 367     //     share a single entry in the combined table.
 368     //   If more than one mapping exists for the same key code point, multiple
 369     //     entries will be created in the table
 370
 371     for (int32_t range=0; range<fKeySet->getRangeCount(); range++) {
 372         // It is an oddity of the UnicodeSet API that simply enumerating the contained
 373         //   code points requires a nested loop.
 374         for (UChar32 keyChar=fKeySet->getRangeStart(range);
 375                 keyChar <= fKeySet->getRangeEnd(range); keyChar++) {
 376             addKeyEntry(keyChar, fSLTable, USPOOF_SL_TABLE_FLAG, status);
 377             addKeyEntry(keyChar, fSATable, USPOOF_SA_TABLE_FLAG, status);
 378             addKeyEntry(keyChar, fMLTable, USPOOF_ML_TABLE_FLAG, status);
 379             addKeyEntry(keyChar, fMATable, USPOOF_MA_TABLE_FLAG, status);
 380         }
 381     }
 382
 383     // Put the assembled data into the flat runtime array
 384     outputData(status);
 385
 386     // All of the intermediate allocated data belongs to the ConfusabledataBuilder
 387     //  object  (this), and is deleted in the destructor.
 388     return;
 389 }
 390
 391 //
 392 // outputData     The confusable data has been compiled and stored in intermediate
 393 //                collections and strings.  Copy it from there to the final flat
 394 //                binary array.
 395 //
 396 //                Note that as each section is added to the output data, the
 397 //                expand (reserveSpace() function will likely relocate it in memory.
 398 //                Be careful with pointers.
 399 //
 400 void ConfusabledataBuilder::outputData(UErrorCode &status) {
 401
 402     U_ASSERT(fSpoofImpl->fSpoofData->fDataOwned == TRUE);
 403
 404     //  The Key Table
 405     //     While copying the keys to the runtime array,
 406     //       also sanity check that they are sorted.
 407
 408     int32_t numKeys = fKeyVec->size();
 409     int32_t *keys =
 410         static_cast<int32_t *>(fSpoofImpl->fSpoofData->reserveSpace(numKeys*sizeof(int32_t), status));
 411     if (U_FAILURE(status)) {
 412         return;
 413     }
 414     int i;
 415     int32_t previousKey = 0;
 416     for (i=0; i<numKeys; i++) {
 417         int32_t key =  fKeyVec->elementAti(i);
 418         (void)previousKey;         // Suppress unused variable warning on gcc.
 419         U_ASSERT((key & 0x00ffffff) >= (previousKey & 0x00ffffff));
 420         U_ASSERT((key & 0xff000000) != 0);
 421         keys[i] = key;
 422         previousKey = key;
 423     }
 424     SpoofDataHeader *rawData = fSpoofImpl->fSpoofData->fRawData;
 425     rawData->fCFUKeys = (int32_t)((char *)keys - (char *)rawData);
 426     rawData->fCFUKeysSize = numKeys;
 427     fSpoofImpl->fSpoofData->fCFUKeys = keys;
 428
 429
 430     // The Value Table, parallels the key table
 431     int32_t numValues = fValueVec->size();
 432     U_ASSERT(numKeys == numValues);
 433     uint16_t *values =
 434         static_cast<uint16_t *>(fSpoofImpl->fSpoofData->reserveSpace(numKeys*sizeof(uint16_t), status));
 435     if (U_FAILURE(status)) {
 436         return;
 437     }
 438     for (i=0; i<numValues; i++) {
 439         uint32_t value = static_cast<uint32_t>(fValueVec->elementAti(i));
 440         U_ASSERT(value < 0xffff);
 441         values[i] = static_cast<uint16_t>(value);
 442     }
 443     rawData = fSpoofImpl->fSpoofData->fRawData;
 444     rawData->fCFUStringIndex = (int32_t)((char *)values - (char *)rawData);
 445     rawData->fCFUStringIndexSize = numValues;
 446     fSpoofImpl->fSpoofData->fCFUValues = values;
 447
 448     // The Strings Table.
 449
 450     uint32_t stringsLength = fStringTable->length();
 451     // Reserve an extra space so the string will be nul-terminated.  This is
 452     // only a convenience, for when debugging; it is not needed otherwise.
 453     UChar *strings =
 454         static_cast<UChar *>(fSpoofImpl->fSpoofData->reserveSpace(stringsLength*sizeof(UChar)+2, status));
 455     if (U_FAILURE(status)) {
 456         return;
 457     }
 458     fStringTable->extract(strings, stringsLength+1, status);
 459     rawData = fSpoofImpl->fSpoofData->fRawData;
 460     U_ASSERT(rawData->fCFUStringTable == 0);
 461     rawData->fCFUStringTable = (int32_t)((char *)strings - (char *)rawData);
 462     rawData->fCFUStringTableLen = stringsLength;
 463     fSpoofImpl->fSpoofData->fCFUStrings = strings;
 464
 465     // The String Lengths Table
 466     //    While copying into the runtime array do some sanity checks on the values
 467     //    Each complete entry contains two fields, an index and an offset.
 468     //    Lengths should increase with each entry.
 469     //    Offsets should be less than the size of the string table.
 470     int32_t lengthTableLength = fStringLengthsTable->size();
 471     uint16_t *stringLengths =
 472         static_cast<uint16_t *>(fSpoofImpl->fSpoofData->reserveSpace(lengthTableLength*sizeof(uint16_t), status));
 473     if (U_FAILURE(status)) {
 474         return;
 475     }
 476     int32_t destIndex = 0;
 477     uint32_t previousLength = 0;
 478     for (i=0; i<lengthTableLength; i+=2) {
 479         uint32_t offset = static_cast<uint32_t>(fStringLengthsTable->elementAti(i));
 480         uint32_t length = static_cast<uint32_t>(fStringLengthsTable->elementAti(i+1));
 481         U_ASSERT(offset < stringsLength);
 482         U_ASSERT(length < 40);
 483         (void)previousLength;  // Suppress unused variable warning on gcc.
 484         U_ASSERT(length > previousLength);
 485         stringLengths[destIndex++] = static_cast<uint16_t>(offset);
 486         stringLengths[destIndex++] = static_cast<uint16_t>(length);
 487         previousLength = length;
 488     }
 489     rawData = fSpoofImpl->fSpoofData->fRawData;
 490     rawData->fCFUStringLengths = (int32_t)((char *)stringLengths - (char *)rawData);
 491     // Note: StringLengthsSize in the raw data is the number of complete entries,
 492     //       each consisting of a pair of 16 bit values, hence the divide by 2.
 493     rawData->fCFUStringLengthsSize = lengthTableLength / 2;
 494     fSpoofImpl->fSpoofData->fCFUStringLengths =
 495         reinterpret_cast<SpoofStringLengthsElement *>(stringLengths);
 496 }
 497
 498
 499
 500 //  addKeyEntry   Construction of the confusable Key and Mapping Values tables.
 501 //                This is an intermediate point in the building process.
 502 //                We already have the mappings in the hash tables fSLTable, etc.
 503 //                This function builds corresponding run-time style table entries into
 504 //                  fKeyVec and fValueVec
 505
 506 void ConfusabledataBuilder::addKeyEntry(
 507     UChar32     keyChar,     // The key character
 508     UHashtable *table,       // The table, one of SATable, MATable, etc.
 509     int32_t     tableFlag,   // One of USPOOF_SA_TABLE_FLAG, etc.
 510     UErrorCode &status) {
 511
 512     SPUString *targetMapping = static_cast<SPUString *>(uhash_iget(table, keyChar));
 513     if (targetMapping == NULL) {
 514         // No mapping for this key character.
 515         //   (This function is called for all four tables for each key char that
 516         //    is seen anywhere, so this no entry cases are very much expected.)
 517         return;
 518     }
 519
 520     // Check whether there is already an entry with the correct mapping.
 521     // If so, simply set the flag in the keyTable saying that the existing entry
 522     // applies to the table that we're doing now.
 523
 524     UBool keyHasMultipleValues = FALSE;
 525     int32_t i;
 526     for (i=fKeyVec->size()-1; i>=0 ; i--) {
 527         int32_t key = fKeyVec->elementAti(i);
 528         if ((key & 0x0ffffff) != keyChar) {
 529             // We have now checked all existing key entries for this key char (if any)
 530             //  without finding one with the same mapping.
 531             break;
 532         }
 533         UnicodeString mapping = getMapping(i);
 534         if (mapping == *(targetMapping->fStr)) {
 535             // The run time entry we are currently testing has the correct mapping.
 536             // Set the flag in it indicating that it applies to the new table also.
 537             key |= tableFlag;
 538             fKeyVec->setElementAt(key, i);
 539             return;
 540         }
 541         keyHasMultipleValues = TRUE;
 542     }
 543
 544     // Need to add a new entry to the binary data being built for this mapping.
 545     // Includes adding entries to both the key table and the parallel values table.
 546
 547     int32_t newKey = keyChar | tableFlag;
 548     if (keyHasMultipleValues) {
 549         newKey |= USPOOF_KEY_MULTIPLE_VALUES;
 550     }
 551     int32_t adjustedMappingLength = targetMapping->fStr->length() - 1;
 552     if (adjustedMappingLength>3) {
 553         adjustedMappingLength = 3;
 554     }
 555     newKey |= adjustedMappingLength << USPOOF_KEY_LENGTH_SHIFT;
 556
 557     int32_t newData = targetMapping->fStrTableIndex;
 558
 559     fKeyVec->addElement(newKey, status);
 560     fValueVec->addElement(newData, status);
 561
 562     // If the preceding key entry is for the same key character (but with a different mapping)
 563     //   set the multiple-values flag on it.
 564     if (keyHasMultipleValues) {
 565         int32_t previousKeyIndex = fKeyVec->size() - 2;
 566         int32_t previousKey = fKeyVec->elementAti(previousKeyIndex);
 567         previousKey |= USPOOF_KEY_MULTIPLE_VALUES;
 568         fKeyVec->setElementAt(previousKey, previousKeyIndex);
 569     }
 570 }
 571
 572
 573
 574 UnicodeString ConfusabledataBuilder::getMapping(int32_t index) {
 575     int32_t key = fKeyVec->elementAti(index);
 576     int32_t value = fValueVec->elementAti(index);
 577     int32_t length = USPOOF_KEY_LENGTH_FIELD(key);
 578     int32_t lastIndexWithLen;
 579     switch (length) {
 580       case 0:
 581         return UnicodeString(static_cast<UChar>(value));
 582       case 1:
 583       case 2:
 584         return UnicodeString(*fStringTable, value, length+1);
 585       case 3:
 586         length = 0;
 587         int32_t i;
 588         for (i=0; i<fStringLengthsTable->size(); i+=2) {
 589             lastIndexWithLen = fStringLengthsTable->elementAti(i);
 590             if (value <= lastIndexWithLen) {
 591                 length = fStringLengthsTable->elementAti(i+1);
 592                 break;
 593             }
 594         }
 595         U_ASSERT(length>=3);
 596         return UnicodeString(*fStringTable, value, length);
 597       default:
 598         U_ASSERT(FALSE);
 599     }
 600     return UnicodeString();
 601 }
 602
 603 #endif
 604 #endif // !UCONFIG_NO_REGULAR_EXPRESSIONS
 605