source/i18n/uspoof_wsconf.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_wsconf.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 functions for compililing Whole Script confusable source data
  17 *   into its binary (runtime) form.  The binary data format is described
  18 *   in uspoof_impl.h
  19 */
  20
  21 #include "unicode/utypes.h"
  22 #include "unicode/uspoof.h"
  23
  24 #if !UCONFIG_NO_NORMALIZATION
  25
  26 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
  27
  28 #include "unicode/unorm.h"
  29 #include "unicode/uregex.h"
  30 #include "unicode/ustring.h"
  31 #include "cmemory.h"
  32 #include "scriptset.h"
  33 #include "uspoof_impl.h"
  34 #include "uhash.h"
  35 #include "uvector.h"
  36 #include "uassert.h"
  37 #include "uspoof_wsconf.h"
  38
  39 U_NAMESPACE_USE
  40
  41
  42 // Regular expression for parsing a line from the Unicode file confusablesWholeScript.txt
  43 // Example Lines:
  44 //   006F          ; Latn; Deva; A #      (o)  LATIN SMALL LETTER O
  45 //   0048..0049    ; Latn; Grek; A #  [2] (H..I)  LATIN CAPITAL LETTER H..LATIN CAPITAL LETTER I
  46 //    |               |     |    |
  47 //    |               |     |    |---- Which table, Any Case or Lower Case (A or L)
  48 //    |               |     |----------Target script.   We need this.
  49 //    |               |----------------Src script.  Should match the script of the source
  50 //    |                                code points.  Beyond checking that, we don't keep it.
  51 //    |--------------------------------Source code points or range.
  52 //
  53 // The expression will match _all_ lines, including erroneous lines.
  54 // The result of the parse is returned via the contents of the (match) groups.
  55 static const char *parseExp =
  56         "(?m)"                                         // Multi-line mode
  57         "^([ \\t]*(?:#.*?)?)$"                         // A blank or comment line.  Matches Group 1.
  58         "|^(?:"                                        //   OR
  59         "\\s*([0-9A-F]{4,})(?:..([0-9A-F]{4,}))?\\s*;" // Code point range.  Groups 2 and 3.
  60         "\\s*([A-Za-z]+)\\s*;"                         // The source script.  Group 4.
  61         "\\s*([A-Za-z]+)\\s*;"                         // The target script.  Group 5.
  62         "\\s*(?:(A)|(L))"                              // The table A or L.   Group 6 or 7
  63         "[ \\t]*(?:#.*?)?"                             // Trailing commment
  64         ")$|"                                          //   OR
  65         "^(.*?)$";                                     // An error line.      Group 8.
  66                                                        //    Any line not matching the preceding
  67                                                        //    parts of the expression.will match
  68                                                        //    this, and thus be flagged as an error
  69
  70
  71 // Extract a regular expression match group into a char * string.
  72 //    The group must contain only invariant characters.
  73 //    Used for script names
  74 //
  75 static void extractGroup(
  76     URegularExpression *e, int32_t group, char *destBuf, int32_t destCapacity, UErrorCode &status) {
  77
  78     UChar ubuf[50];
  79     ubuf[0] = 0;
  80     destBuf[0] = 0;
  81     int32_t len = uregex_group(e, group, ubuf, 50, &status);
  82     if (U_FAILURE(status) || len == -1 || len >= destCapacity) {
  83         return;
  84     }
  85     UnicodeString s(FALSE, ubuf, len);   // Aliasing constructor
  86     s.extract(0, len, destBuf, destCapacity, US_INV);
  87 }
  88
  89
  90
  91 U_NAMESPACE_BEGIN
  92
  93 //  Build the Whole Script Confusable data
  94 //
  95 //     TODO:  Reorganize.  Either get rid of the WSConfusableDataBuilder class,
  96 //                         because everything is local to this one build function anyhow,
  97 //                           OR
  98 //                         break this function into more reasonably sized pieces, with
  99 //                         state in WSConfusableDataBuilder.
 100 //
 101 void buildWSConfusableData(SpoofImpl *spImpl, const char * confusablesWS,
 102           int32_t confusablesWSLen, UParseError *pe, UErrorCode &status)
 103 {
 104     if (U_FAILURE(status)) {
 105         return;
 106     }
 107     URegularExpression *parseRegexp = NULL;
 108     int32_t             inputLen    = 0;
 109     UChar              *input       = NULL;
 110     int32_t             lineNum     = 0;
 111
 112     UVector            *scriptSets        = NULL;
 113     uint32_t            rtScriptSetsCount = 2;
 114
 115     UTrie2             *anyCaseTrie   = NULL;
 116     UTrie2             *lowerCaseTrie = NULL;
 117
 118     anyCaseTrie = utrie2_open(0, 0, &status);
 119     lowerCaseTrie = utrie2_open(0, 0, &status);
 120
 121     UnicodeString pattern(parseExp, -1, US_INV);
 122
 123     // The scriptSets vector provides a mapping from TRIE values to the set of scripts.
 124     //
 125     // Reserved TRIE values:
 126     //   0:  Code point has no whole script confusables.
 127     //   1:  Code point is of script Common or Inherited.
 128     //       These code points do not participate in whole script confusable detection.
 129     //       (This is logically equivalent to saying that they contain confusables in
 130     //        all scripts)
 131     //
 132     // Because Trie values are indexes into the ScriptSets vector, pre-fill
 133     // vector positions 0 and 1 to avoid conflicts with the reserved values.
 134
 135     scriptSets = new UVector(status);
 136     if (scriptSets == NULL) {
 137         status = U_MEMORY_ALLOCATION_ERROR;
 138         goto cleanup;
 139     }
 140     scriptSets->addElement((void *)NULL, status);
 141     scriptSets->addElement((void *)NULL, status);
 142
 143     // Convert the user input data from UTF-8 to UChar (UTF-16)
 144     u_strFromUTF8(NULL, 0, &inputLen, confusablesWS, confusablesWSLen, &status);
 145     if (status != U_BUFFER_OVERFLOW_ERROR) {
 146         goto cleanup;
 147     }
 148     status = U_ZERO_ERROR;
 149     input = static_cast<UChar *>(uprv_malloc((inputLen+1) * sizeof(UChar)));
 150     if (input == NULL) {
 151         status = U_MEMORY_ALLOCATION_ERROR;
 152         goto cleanup;
 153     }
 154     u_strFromUTF8(input, inputLen+1, NULL, confusablesWS, confusablesWSLen, &status);
 155
 156     parseRegexp = uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, &status);
 157
 158     // Zap any Byte Order Mark at the start of input.  Changing it to a space is benign
 159     //   given the syntax of the input.
 160     if (*input == 0xfeff) {
 161         *input = 0x20;
 162     }
 163
 164     // Parse the input, one line per iteration of this loop.
 165     uregex_setText(parseRegexp, input, inputLen, &status);
 166     while (uregex_findNext(parseRegexp, &status)) {
 167         lineNum++;
 168         if (uregex_start(parseRegexp, 1, &status) >= 0) {
 169             // this was a blank or comment line.
 170             continue;
 171         }
 172         if (uregex_start(parseRegexp, 8, &status) >= 0) {
 173             // input file syntax error.
 174             status = U_PARSE_ERROR;
 175             goto cleanup;
 176         }
 177         if (U_FAILURE(status)) {
 178             goto cleanup;
 179         }
 180
 181         // Pick up the start and optional range end code points from the parsed line.
 182         UChar32  startCodePoint = SpoofImpl::ScanHex(
 183             input, uregex_start(parseRegexp, 2, &status), uregex_end(parseRegexp, 2, &status), status);
 184         UChar32  endCodePoint = startCodePoint;
 185         if (uregex_start(parseRegexp, 3, &status) >=0) {
 186             endCodePoint = SpoofImpl::ScanHex(
 187                 input, uregex_start(parseRegexp, 3, &status), uregex_end(parseRegexp, 3, &status), status);
 188         }
 189
 190         // Extract the two script names from the source line.  We need these in an 8 bit
 191         //   default encoding (will be EBCDIC on IBM mainframes) in order to pass them on
 192         //   to the ICU u_getPropertyValueEnum() function.  Ugh.
 193         char  srcScriptName[20];
 194         char  targScriptName[20];
 195         extractGroup(parseRegexp, 4, srcScriptName, sizeof(srcScriptName), status);
 196         extractGroup(parseRegexp, 5, targScriptName, sizeof(targScriptName), status);
 197         UScriptCode srcScript  =
 198             static_cast<UScriptCode>(u_getPropertyValueEnum(UCHAR_SCRIPT, srcScriptName));
 199         UScriptCode targScript =
 200             static_cast<UScriptCode>(u_getPropertyValueEnum(UCHAR_SCRIPT, targScriptName));
 201         if (U_FAILURE(status)) {
 202             goto cleanup;
 203         }
 204         if (srcScript == USCRIPT_INVALID_CODE || targScript == USCRIPT_INVALID_CODE) {
 205             status = U_INVALID_FORMAT_ERROR;
 206             goto cleanup;
 207         }
 208
 209         // select the table - (A) any case or (L) lower case only
 210         UTrie2 *table = anyCaseTrie;
 211         if (uregex_start(parseRegexp, 7, &status) >= 0) {
 212             table = lowerCaseTrie;
 213         }
 214
 215         // Build the set of scripts containing confusable characters for
 216         //   the code point(s) specified in this input line.
 217         // Sanity check that the script of the source code point is the same
 218         //   as the source script indicated in the input file.  Failure of this check is
 219         //   an error in the input file.
 220         // Include the source script in the set (needed for Mixed Script Confusable detection).
 221         //
 222         UChar32 cp;
 223         for (cp=startCodePoint; cp<=endCodePoint; cp++) {
 224             int32_t setIndex = utrie2_get32(table, cp);
 225             BuilderScriptSet *bsset = NULL;
 226             if (setIndex > 0) {
 227                 U_ASSERT(setIndex < scriptSets->size());
 228                 bsset = static_cast<BuilderScriptSet *>(scriptSets->elementAt(setIndex));
 229             } else {
 230                 bsset = new BuilderScriptSet();
 231                 if (bsset == NULL) {
 232                     status = U_MEMORY_ALLOCATION_ERROR;
 233                     goto cleanup;
 234                 }
 235                 bsset->codePoint = cp;
 236                 bsset->trie = table;
 237                 bsset->sset = new ScriptSet();
 238                 setIndex = scriptSets->size();
 239                 bsset->index = setIndex;
 240                 bsset->rindex = 0;
 241                 if (bsset->sset == NULL) {
 242                     status = U_MEMORY_ALLOCATION_ERROR;
 243                     goto cleanup;
 244                 }
 245                 scriptSets->addElement(bsset, status);
 246                 utrie2_set32(table, cp, setIndex, &status);
 247             }
 248             bsset->sset->set(targScript, status);
 249             bsset->sset->set(srcScript, status);
 250
 251             if (U_FAILURE(status)) {
 252                 goto cleanup;
 253             }
 254             UScriptCode cpScript = uscript_getScript(cp, &status);
 255             if (cpScript != srcScript) {
 256                 status = U_INVALID_FORMAT_ERROR;
 257                 goto cleanup;
 258             }
 259         }
 260     }
 261
 262     // Eliminate duplicate script sets.  At this point we have a separate
 263     // script set for every code point that had data in the input file.
 264     //
 265     // We eliminate underlying ScriptSet objects, not the BuildScriptSets that wrap them
 266     //
 267     // printf("Number of scriptSets: %d\n", scriptSets->size());
 268     {
 269         int32_t duplicateCount = 0;
 270         rtScriptSetsCount = 2;
 271         for (int32_t outeri=2; outeri<scriptSets->size(); outeri++) {
 272             BuilderScriptSet *outerSet = static_cast<BuilderScriptSet *>(scriptSets->elementAt(outeri));
 273             if (outerSet->index != static_cast<uint32_t>(outeri)) {
 274                 // This set was already identified as a duplicate.
 275                 //   It will not be allocated a position in the runtime array of ScriptSets.
 276                 continue;
 277             }
 278             outerSet->rindex = rtScriptSetsCount++;
 279             for (int32_t inneri=outeri+1; inneri<scriptSets->size(); inneri++) {
 280                 BuilderScriptSet *innerSet = static_cast<BuilderScriptSet *>(scriptSets->elementAt(inneri));
 281                 if (*(outerSet->sset) == *(innerSet->sset) && outerSet->sset != innerSet->sset) {
 282                     delete innerSet->sset;
 283                     innerSet->scriptSetOwned = FALSE;
 284                     innerSet->sset = outerSet->sset;
 285                     innerSet->index = outeri;
 286                     innerSet->rindex = outerSet->rindex;
 287                     duplicateCount++;
 288                 }
 289                 // But this doesn't get all.  We need to fix the TRIE.
 290             }
 291         }
 292         // printf("Number of distinct script sets: %d\n", rtScriptSetsCount);
 293     }
 294
 295
 296
 297     // Update the Trie values to be reflect the run time script indexes (after duplicate merging).
 298     //    (Trie Values 0 and 1 are reserved, and the corresponding slots in scriptSets
 299     //     are unused, which is why the loop index starts at 2.)
 300     {
 301         for (int32_t i=2; i<scriptSets->size(); i++) {
 302             BuilderScriptSet *bSet = static_cast<BuilderScriptSet *>(scriptSets->elementAt(i));
 303             if (bSet->rindex != (uint32_t)i) {
 304                 utrie2_set32(bSet->trie, bSet->codePoint, bSet->rindex, &status);
 305             }
 306         }
 307     }
 308
 309     // For code points with script==Common or script==Inherited,
 310     //   Set the reserved value of 1 into both Tries.  These characters do not participate
 311     //   in Whole Script Confusable detection; this reserved value is the means
 312     //   by which they are detected.
 313     {
 314         UnicodeSet ignoreSet;
 315         ignoreSet.applyIntPropertyValue(UCHAR_SCRIPT, USCRIPT_COMMON, status);
 316         UnicodeSet inheritedSet;
 317         inheritedSet.applyIntPropertyValue(UCHAR_SCRIPT, USCRIPT_INHERITED, status);
 318         ignoreSet.addAll(inheritedSet);
 319         for (int32_t rn=0; rn<ignoreSet.getRangeCount(); rn++) {
 320             UChar32 rangeStart = ignoreSet.getRangeStart(rn);
 321             UChar32 rangeEnd   = ignoreSet.getRangeEnd(rn);
 322             utrie2_setRange32(anyCaseTrie,   rangeStart, rangeEnd, 1, TRUE, &status);
 323             utrie2_setRange32(lowerCaseTrie, rangeStart, rangeEnd, 1, TRUE, &status);
 324         }
 325     }
 326
 327     // Serialize the data to the Spoof Detector
 328     {
 329         utrie2_freeze(anyCaseTrie,   UTRIE2_16_VALUE_BITS, &status);
 330         int32_t size = utrie2_serialize(anyCaseTrie, NULL, 0, &status);
 331         // printf("Any case Trie size: %d\n", size);
 332         if (status != U_BUFFER_OVERFLOW_ERROR) {
 333             goto cleanup;
 334         }
 335         status = U_ZERO_ERROR;
 336         spImpl->fSpoofData->fRawData->fAnyCaseTrie = spImpl->fSpoofData->fMemLimit;
 337         spImpl->fSpoofData->fRawData->fAnyCaseTrieLength = size;
 338         spImpl->fSpoofData->fAnyCaseTrie = anyCaseTrie;
 339         void *where = spImpl->fSpoofData->reserveSpace(size, status);
 340         utrie2_serialize(anyCaseTrie, where, size, &status);
 341
 342         utrie2_freeze(lowerCaseTrie, UTRIE2_16_VALUE_BITS, &status);
 343         size = utrie2_serialize(lowerCaseTrie, NULL, 0, &status);
 344         // printf("Lower case Trie size: %d\n", size);
 345         if (status != U_BUFFER_OVERFLOW_ERROR) {
 346             goto cleanup;
 347         }
 348         status = U_ZERO_ERROR;
 349         spImpl->fSpoofData->fRawData->fLowerCaseTrie = spImpl->fSpoofData->fMemLimit;
 350         spImpl->fSpoofData->fRawData->fLowerCaseTrieLength = size;
 351         spImpl->fSpoofData->fLowerCaseTrie = lowerCaseTrie;
 352         where = spImpl->fSpoofData->reserveSpace(size, status);
 353         utrie2_serialize(lowerCaseTrie, where, size, &status);
 354
 355         spImpl->fSpoofData->fRawData->fScriptSets = spImpl->fSpoofData->fMemLimit;
 356         spImpl->fSpoofData->fRawData->fScriptSetsLength = rtScriptSetsCount;
 357         ScriptSet *rtScriptSets =  static_cast<ScriptSet *>
 358             (spImpl->fSpoofData->reserveSpace(rtScriptSetsCount * sizeof(ScriptSet), status));
 359         uint32_t rindex = 2;
 360         for (int32_t i=2; i<scriptSets->size(); i++) {
 361             BuilderScriptSet *bSet = static_cast<BuilderScriptSet *>(scriptSets->elementAt(i));
 362             if (bSet->rindex < rindex) {
 363                 // We have already copied this script set to the serialized data.
 364                 continue;
 365             }
 366             U_ASSERT(rindex == bSet->rindex);
 367             rtScriptSets[rindex] = *bSet->sset;   // Assignment of a ScriptSet just copies the bits.
 368             rindex++;
 369         }
 370     }
 371
 372     // Open new utrie2s from the serialized data.  We don't want to keep the ones
 373     //   we just built because we would then have two copies of the data, one internal to
 374     //   the utries that we have already constructed, and one in the serialized data area.
 375     //   An alternative would be to not pre-serialize the Trie data, but that makes the
 376     //   spoof detector data different, depending on how the detector was constructed.
 377     //   It's simpler to keep the data always the same.
 378
 379     spImpl->fSpoofData->fAnyCaseTrie = utrie2_openFromSerialized(
 380             UTRIE2_16_VALUE_BITS,
 381             (const char *)spImpl->fSpoofData->fRawData + spImpl->fSpoofData->fRawData->fAnyCaseTrie,
 382             spImpl->fSpoofData->fRawData->fAnyCaseTrieLength,
 383             NULL,
 384             &status);
 385
 386     spImpl->fSpoofData->fLowerCaseTrie = utrie2_openFromSerialized(
 387             UTRIE2_16_VALUE_BITS,
 388             (const char *)spImpl->fSpoofData->fRawData + spImpl->fSpoofData->fRawData->fLowerCaseTrie,
 389             spImpl->fSpoofData->fRawData->fAnyCaseTrieLength,
 390             NULL,
 391             &status);
 392
 393
 394
 395 cleanup:
 396     if (U_FAILURE(status)) {
 397         pe->line = lineNum;
 398     }
 399     uregex_close(parseRegexp);
 400     uprv_free(input);
 401
 402     int32_t i;
 403     if (scriptSets != NULL) {
 404         for (i=0; i<scriptSets->size(); i++) {
 405             BuilderScriptSet *bsset = static_cast<BuilderScriptSet *>(scriptSets->elementAt(i));
 406             delete bsset;
 407         }
 408         delete scriptSets;
 409     }
 410     utrie2_close(anyCaseTrie);
 411     utrie2_close(lowerCaseTrie);
 412     return;
 413 }
 414
 415 U_NAMESPACE_END
 416
 417
 418
 419 BuilderScriptSet::BuilderScriptSet() {
 420     codePoint = -1;
 421     trie = NULL;
 422     sset = NULL;
 423     index = 0;
 424     rindex = 0;
 425     scriptSetOwned = TRUE;
 426 }
 427
 428 BuilderScriptSet::~BuilderScriptSet() {
 429     if (scriptSetOwned) {
 430         delete sset;
 431     }
 432 }
 433
 434 #endif
 435 #endif //  !UCONFIG_NO_REGULAR_EXPRESSIONS
 436