icuSources/i18n/regexst.cpp

   1 //
   2 //  regexst.h
   3 //
   4 //  Copyright (C) 2004-2015, International Business Machines Corporation and others.
   5 //  All Rights Reserved.
   6 //
   7 //  This file contains class RegexStaticSets
   8 //
   9 //  This class is internal to the regular expression implementation.
  10 //  For the public Regular Expression API, see the file "unicode/regex.h"
  11 //
  12 //  RegexStaticSets groups together the common UnicodeSets that are needed
  13 //   for compiling or executing RegularExpressions.  This grouping simplifies
  14 //   the thread safe lazy creation and sharing of these sets across
  15 //   all instances of regular expressions.
  16 //
  17 #include "unicode/utypes.h"
  18
  19 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
  20
  21 #include "unicode/unistr.h"
  22 #include "unicode/uniset.h"
  23 #include "unicode/uchar.h"
  24 #include "unicode/regex.h"
  25 #include "uprops.h"
  26 #include "cmemory.h"
  27 #include "cstring.h"
  28 #include "uassert.h"
  29 #include "ucln_in.h"
  30 #include "umutex.h"
  31
  32 #include "regexcst.h"   // Contains state table for the regex pattern parser.
  33                         //   generated by a Perl script.
  34 #include "regexst.h"
  35
  36
  37
  38 U_NAMESPACE_BEGIN
  39
  40
  41 //------------------------------------------------------------------------------
  42 //
  43 // Unicode Set pattern strings for all of the required constant sets.
  44 //               Initialized with hex values for portability to EBCDIC based machines.
  45 //                Really ugly, but there's no good way to avoid it.
  46 //
  47 //------------------------------------------------------------------------------
  48
  49 // "Rule Char" Characters are those with no special meaning, and therefore do not
  50 //    need to be escaped to appear as literals in a regexp.  Expressed
  51 //    as the inverse of those needing escaping --  [^\*\?\+\[\(\)\{\}\^\$\|\\\.]
  52 static const UChar gRuleSet_rule_char_pattern[]       = {
  53  //   [    ^      \     *     \     ?     \     +     \     [     \     (     /     )
  54     0x5b, 0x5e, 0x5c, 0x2a, 0x5c, 0x3f, 0x5c, 0x2b, 0x5c, 0x5b, 0x5c, 0x28, 0x5c, 0x29,
  55  //   \     {    \     }     \     ^     \     $     \     |     \     \     \     .     ]
  56     0x5c, 0x7b,0x5c, 0x7d, 0x5c, 0x5e, 0x5c, 0x24, 0x5c, 0x7c, 0x5c, 0x5c, 0x5c, 0x2e, 0x5d, 0};
  57
  58 //
  59 //   Here are the backslash escape characters that ICU's unescape() function
  60 //    will handle.
  61 //
  62 static const UChar gUnescapeCharPattern[] = {
  63 //    [     a     c     e     f     n     r     t     u     U     x    ]
  64     0x5b, 0x61, 0x63, 0x65, 0x66, 0x6e, 0x72, 0x74, 0x75, 0x55, 0x78, 0x5d, 0};
  65
  66
  67 //
  68 //  Unicode Set Definitions for Regular Expression  \w
  69 //
  70 static const UChar gIsWordPattern[] = {
  71 //    [     \     p     {    A     l     p     h     a     b     e     t     i      c    }
  72     0x5b, 0x5c, 0x70, 0x7b, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x62, 0x65, 0x74, 0x69, 0x63, 0x7d,
  73 //          \     p     {    M     }                               Mark
  74           0x5c, 0x70, 0x7b, 0x4d, 0x7d,
  75 //          \     p     {    N     d     }                         Digit_Numeric
  76           0x5c, 0x70, 0x7b, 0x4e, 0x64, 0x7d,
  77 //          \     p     {    P     c     }                         Connector_Punctuation
  78           0x5c, 0x70, 0x7b, 0x50, 0x63, 0x7d,
  79 //          \     u     2    0     0     c      \     u     2    0     0     d     ]
  80           0x5c, 0x75, 0x32, 0x30, 0x30, 0x63, 0x5c, 0x75, 0x32, 0x30, 0x30, 0x64, 0x5d, 0};
  81
  82
  83 //
  84 //  Unicode Set Definitions for Regular Expression  \s
  85 //
  86 static const UChar gIsSpacePattern[] = {
  87 //        [     \     p     {     W     h     i     t     e     S     p     a     c     e     }     ]
  88         0x5b, 0x5c, 0x70, 0x7b, 0x57, 0x68, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x63, 0x65, 0x7d, 0x5d, 0};
  89
  90
  91 //
  92 //  UnicodeSets used in implementation of Grapheme Cluster detection, \X
  93 //
  94 static const UChar gGC_ControlPattern[] = {
  95 //    [     [     :     Z     l     :     ]     [     :     Z     p     :     ]
  96     0x5b, 0x5b, 0x3a, 0x5A, 0x6c, 0x3a, 0x5d, 0x5b, 0x3a, 0x5A, 0x70, 0x3a, 0x5d,
  97 //    [     :     C     c     :     ]     [     :     C     f     :     ]     -
  98     0x5b, 0x3a, 0x43, 0x63, 0x3a, 0x5d, 0x5b, 0x3a, 0x43, 0x66, 0x3a, 0x5d, 0x2d,
  99 //    [     :     G     r     a     p     h     e     m     e     _
 100     0x5b, 0x3a, 0x47, 0x72, 0x61, 0x70, 0x68, 0x65, 0x6d, 0x65, 0x5f,
 101 //    E     x     t     e     n     d     :     ]     ]
 102     0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x3a, 0x5d, 0x5d, 0};
 103
 104 static const UChar gGC_ExtendPattern[] = {
 105 //    [     \     p     {     G     r     a     p     h     e     m     e     _
 106     0x5b, 0x5c, 0x70, 0x7b, 0x47, 0x72, 0x61, 0x70, 0x68, 0x65, 0x6d, 0x65, 0x5f,
 107 //    E     x     t     e     n     d     }     ]
 108     0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x7d, 0x5d, 0};
 109
 110 static const UChar gGC_LPattern[] = {
 111 //    [     \     p     {     H     a     n     g     u     l     _     S     y     l
 112     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 113 //    l     a     b     l     e     _     T     y     p     e     =     L     }     ]
 114     0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x7d,  0x5d, 0};
 115
 116 static const UChar gGC_VPattern[] = {
 117 //    [     \     p     {     H     a     n     g     u     l     _     S     y     l
 118     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 119 //    l     a     b     l     e     _     T     y     p     e     =     V     }     ]
 120     0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x56, 0x7d,  0x5d, 0};
 121
 122 static const UChar gGC_TPattern[] = {
 123 //    [     \     p     {     H     a     n     g     u     l     _     S     y     l
 124     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 125 //    l     a     b     l     e     _     T     y     p     e     =     T     }    ]
 126     0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x54, 0x7d, 0x5d, 0};
 127
 128 static const UChar gGC_LVPattern[] = {
 129 //    [     \     p     {     H     a     n     g     u     l     _     S     y     l
 130     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 131 //    l     a     b     l     e     _     T     y     p     e     =     L     V     }     ]
 132     0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x56, 0x7d, 0x5d, 0};
 133
 134 static const UChar gGC_LVTPattern[] = {
 135 //    [     \     p     {     H     a     n     g     u     l     _     S     y     l
 136     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 137 //    l     a     b     l     e     _     T     y     p     e     =     L     V     T     }     ]
 138     0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x56, 0x54, 0x7d, 0x5d, 0};
 139
 140
 141 RegexStaticSets *RegexStaticSets::gStaticSets = NULL;
 142 UInitOnce gStaticSetsInitOnce = U_INITONCE_INITIALIZER;
 143
 144 RegexStaticSets::RegexStaticSets(UErrorCode *status)
 145 :
 146 fUnescapeCharSet(UnicodeString(TRUE, gUnescapeCharPattern, -1), *status),
 147 fRuleDigitsAlias(NULL),
 148 fEmptyText(NULL)
 149 {
 150     // First zero out everything
 151     int i;
 152     for (i=0; i<URX_LAST_SET; i++) {
 153         fPropSets[i] = NULL;
 154     }
 155     // Then init the sets to their correct values.
 156     fPropSets[URX_ISWORD_SET]  = new UnicodeSet(UnicodeString(TRUE, gIsWordPattern, -1),     *status);
 157     fPropSets[URX_ISSPACE_SET] = new UnicodeSet(UnicodeString(TRUE, gIsSpacePattern, -1),    *status);
 158     fPropSets[URX_GC_EXTEND]   = new UnicodeSet(UnicodeString(TRUE, gGC_ExtendPattern, -1),  *status);
 159     fPropSets[URX_GC_CONTROL]  = new UnicodeSet(UnicodeString(TRUE, gGC_ControlPattern, -1), *status);
 160     fPropSets[URX_GC_L]        = new UnicodeSet(UnicodeString(TRUE, gGC_LPattern, -1),       *status);
 161     fPropSets[URX_GC_V]        = new UnicodeSet(UnicodeString(TRUE, gGC_VPattern, -1),       *status);
 162     fPropSets[URX_GC_T]        = new UnicodeSet(UnicodeString(TRUE, gGC_TPattern, -1),       *status);
 163     fPropSets[URX_GC_LV]       = new UnicodeSet(UnicodeString(TRUE, gGC_LVPattern, -1),      *status);
 164     fPropSets[URX_GC_LVT]      = new UnicodeSet(UnicodeString(TRUE, gGC_LVTPattern, -1),     *status);
 165
 166     // Check for null pointers
 167     if (fPropSets[URX_ISWORD_SET] == NULL || fPropSets[URX_ISSPACE_SET] == NULL || fPropSets[URX_GC_EXTEND] == NULL ||
 168         fPropSets[URX_GC_CONTROL] == NULL || fPropSets[URX_GC_L] == NULL || fPropSets[URX_GC_V] == NULL ||
 169         fPropSets[URX_GC_T] == NULL || fPropSets[URX_GC_LV] == NULL || fPropSets[URX_GC_LVT] == NULL) {
 170         goto ExitConstrDeleteAll;
 171     }
 172     if (U_FAILURE(*status)) {
 173         // Bail out if we were unable to create the above sets.
 174         // The rest of the initialization needs them, so we cannot proceed.
 175         return;
 176     }
 177
 178
 179     //
 180     // The following sets  are dynamically constructed, because their
 181     //   initialization strings would be unreasonable.
 182     //
 183
 184
 185     //
 186     //  "Normal" is the set of characters that don't need special handling
 187     //            when finding grapheme cluster boundaries.
 188     //
 189     fPropSets[URX_GC_NORMAL] = new UnicodeSet(0, UnicodeSet::MAX_VALUE);
 190     // Null pointer check
 191     if (fPropSets[URX_GC_NORMAL] == NULL) {
 192         goto ExitConstrDeleteAll;
 193     }
 194     fPropSets[URX_GC_NORMAL]->remove(0xac00, 0xd7a4);
 195     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_CONTROL]);
 196     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_L]);
 197     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_V]);
 198     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_T]);
 199
 200     // Initialize the 8-bit fast bit sets from the parallel full
 201     //   UnicodeSets.
 202     for (i=0; i<URX_LAST_SET; i++) {
 203         if (fPropSets[i]) {
 204             fPropSets[i]->compact();
 205             fPropSets8[i].init(fPropSets[i]);
 206         }
 207     }
 208
 209     // Sets used while parsing rules, but not referenced from the parse state table
 210     fRuleSets[kRuleSet_rule_char-128]   = UnicodeSet(UnicodeString(TRUE, gRuleSet_rule_char_pattern, -1),   *status);
 211     fRuleSets[kRuleSet_digit_char-128].add((UChar)0x30, (UChar)0x39);    // [0-9]
 212     fRuleSets[kRuleSet_ascii_letter-128].add((UChar)0x41, (UChar)0x5A);  // [A-Z]
 213     fRuleSets[kRuleSet_ascii_letter-128].add((UChar)0x61, (UChar)0x7A);  // [a-z]
 214     fRuleDigitsAlias = &fRuleSets[kRuleSet_digit_char-128];
 215     for (i=0; i<UPRV_LENGTHOF(fRuleSets); i++) {
 216         fRuleSets[i].compact();
 217     }
 218
 219     // Finally, initialize an empty string for utility purposes
 220     fEmptyText = utext_openUChars(NULL, NULL, 0, status);
 221
 222     if (U_SUCCESS(*status)) {
 223         return;
 224     }
 225
 226 ExitConstrDeleteAll: // Remove fPropSets and fRuleSets and return error
 227     for (i=0; i<URX_LAST_SET; i++) {
 228         delete fPropSets[i];
 229         fPropSets[i] = NULL;
 230     }
 231     if (U_SUCCESS(*status)) {
 232         *status = U_MEMORY_ALLOCATION_ERROR;
 233     }
 234 }
 235
 236
 237 RegexStaticSets::~RegexStaticSets() {
 238     int32_t i;
 239
 240     for (i=0; i<URX_LAST_SET; i++) {
 241         delete fPropSets[i];
 242         fPropSets[i] = NULL;
 243     }
 244     fRuleDigitsAlias = NULL;
 245
 246     utext_close(fEmptyText);
 247 }
 248
 249
 250 //------------------------------------------------------------------------------
 251 //
 252 //   regex_cleanup      Memory cleanup function, free/delete all
 253 //                      cached memory.  Called by ICU's u_cleanup() function.
 254 //
 255 //------------------------------------------------------------------------------
 256 UBool
 257 RegexStaticSets::cleanup(void) {
 258     delete RegexStaticSets::gStaticSets;
 259     RegexStaticSets::gStaticSets = NULL;
 260     gStaticSetsInitOnce.reset();
 261     return TRUE;
 262 }
 263
 264 U_CDECL_BEGIN
 265 static UBool U_CALLCONV
 266 regex_cleanup(void) {
 267     return RegexStaticSets::cleanup();
 268 }
 269
 270 static void U_CALLCONV initStaticSets(UErrorCode &status) {
 271     U_ASSERT(RegexStaticSets::gStaticSets == NULL);
 272     ucln_i18n_registerCleanup(UCLN_I18N_REGEX, regex_cleanup);
 273     RegexStaticSets::gStaticSets = new RegexStaticSets(&status);
 274     if (U_FAILURE(status)) {
 275         delete RegexStaticSets::gStaticSets;
 276         RegexStaticSets::gStaticSets = NULL;
 277     }
 278     if (RegexStaticSets::gStaticSets == NULL && U_SUCCESS(status)) {
 279         status = U_MEMORY_ALLOCATION_ERROR;
 280     }
 281 }
 282 U_CDECL_END
 283
 284 void RegexStaticSets::initGlobals(UErrorCode *status) {
 285     umtx_initOnce(gStaticSetsInitOnce, &initStaticSets, *status);
 286 }
 287
 288 U_NAMESPACE_END
 289 #endif  // !UCONFIG_NO_REGULAR_EXPRESSIONS