ICU-551.30.tar.gz

[apple/icu.git] / icuSources / i18n / regexst.cpp

diff --git a/icuSources/i18n/regexst.cpp b/icuSources/i18n/regexst.cpp
index e874f2ad557c47614ac3df532e4f442a11c7dd79..a8cbf23f86b9f02d98c57d17044920dca9a529a9 100644 (file)
--- a/icuSources/i18n/regexst.cpp
+++ b/icuSources/i18n/regexst.cpp
@@ -1,7 +1,7 @@
 //
 //  regexst.h
 //
 //
 //  regexst.h
 //

-//  Copyright (C) 2004, International Business Machines Corporation and others.
+//  Copyright (C) 2004-2015, International Business Machines Corporation and others.

 //  All Rights Reserved.
 //
 //  This file contains class RegexStaticSets
 //  All Rights Reserved.
 //
 //  This file contains class RegexStaticSets


@@ -38,13 +38,13 @@
 U_NAMESPACE_BEGIN
 
 
 U_NAMESPACE_BEGIN
 
 

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

 //
 // Unicode Set pattern strings for all of the required constant sets.
 //               Initialized with hex values for portability to EBCDIC based machines.
 //                Really ugly, but there's no good way to avoid it.
 //
 //
 // Unicode Set pattern strings for all of the required constant sets.
 //               Initialized with hex values for portability to EBCDIC based machines.
 //                Really ugly, but there's no good way to avoid it.
 //

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

 
 // "Rule Char" Characters are those with no special meaning, and therefore do not
 //    need to be escaped to appear as literals in a regexp.  Expressed
 
 // "Rule Char" Characters are those with no special meaning, and therefore do not
 //    need to be escaped to appear as literals in a regexp.  Expressed


@@ -55,14 +55,6 @@ static const UChar gRuleSet_rule_char_pattern[]       = {
  //   \     {    \     }     \     ^     \     $     \     |     \     \     \     .     ]
     0x5c, 0x7b,0x5c, 0x7d, 0x5c, 0x5e, 0x5c, 0x24, 0x5c, 0x7c, 0x5c, 0x5c, 0x5c, 0x2e, 0x5d, 0};
 
  //   \     {    \     }     \     ^     \     $     \     |     \     \     \     .     ]
     0x5c, 0x7b,0x5c, 0x7d, 0x5c, 0x5e, 0x5c, 0x24, 0x5c, 0x7c, 0x5c, 0x5c, 0x5c, 0x2e, 0x5d, 0};
 

-
-static const UChar gRuleSet_digit_char_pattern[] = {
-//    [    0      -    9     ]
-    0x5b, 0x30, 0x2d, 0x39, 0x5d, 0};
-//static const UnicodeSet *gRuleDigits = NULL;
-
-
-

 //
 //   Here are the backslash escape characters that ICU's unescape() function
 //    will handle.
 //
 //   Here are the backslash escape characters that ICU's unescape() function
 //    will handle.


@@ -72,16 +64,6 @@ static const UChar gUnescapeCharPattern[] = {
     0x5b, 0x61, 0x63, 0x65, 0x66, 0x6e, 0x72, 0x74, 0x75, 0x55, 0x78, 0x5d, 0};
 
 
     0x5b, 0x61, 0x63, 0x65, 0x66, 0x6e, 0x72, 0x74, 0x75, 0x55, 0x78, 0x5d, 0};
 
 

-//
-//  White space characters that may appear within a pattern in free-form mode
-//
-static const UChar gRuleWhiteSpacePattern[] = {
-    /* "[[:Cf:][:WSpace:]]" */
-    91, 91, 58, 67, 102, 58, 93, 91, 58, 87,
-        83, 112, 97, 99, 101, 58, 93, 93, 0 };
-
-
-

 //
 //  Unicode Set Definitions for Regular Expression  \w
 //
 //
 //  Unicode Set Definitions for Regular Expression  \w
 //


@@ -89,17 +71,19 @@ static const UChar gIsWordPattern[] = {
 //    [     \     p     {    A     l     p     h     a     b     e     t     i      c    }
     0x5b, 0x5c, 0x70, 0x7b, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x62, 0x65, 0x74, 0x69, 0x63, 0x7d,
 //          \     p     {    M     }                               Mark
 //    [     \     p     {    A     l     p     h     a     b     e     t     i      c    }
     0x5b, 0x5c, 0x70, 0x7b, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x62, 0x65, 0x74, 0x69, 0x63, 0x7d,
 //          \     p     {    M     }                               Mark

-          0x5c, 0x70, 0x7b, 0x4d, 0x7d, 
+          0x5c, 0x70, 0x7b, 0x4d, 0x7d,

 //          \     p     {    N     d     }                         Digit_Numeric
           0x5c, 0x70, 0x7b, 0x4e, 0x64, 0x7d,
 //          \     p     {    N     d     }                         Digit_Numeric
           0x5c, 0x70, 0x7b, 0x4e, 0x64, 0x7d,

-//          \     p     {    P     c     }      ]                  Connector_Punctuation
-          0x5c, 0x70, 0x7b, 0x50, 0x63, 0x7d, 0x5d, 0};
+//          \     p     {    P     c     }                         Connector_Punctuation
+          0x5c, 0x70, 0x7b, 0x50, 0x63, 0x7d,
+//          \     u     2    0     0     c      \     u     2    0     0     d     ]
+          0x5c, 0x75, 0x32, 0x30, 0x30, 0x63, 0x5c, 0x75, 0x32, 0x30, 0x30, 0x64, 0x5d, 0};

 
 
 //
 //  Unicode Set Definitions for Regular Expression  \s
 //
 
 
 //
 //  Unicode Set Definitions for Regular Expression  \s
 //

-    static const UChar gIsSpacePattern[] = {
+static const UChar gIsSpacePattern[] = {

 //        [     \     p     {     W     h     i     t     e     S     p     a     c     e     }     ]
         0x5b, 0x5c, 0x70, 0x7b, 0x57, 0x68, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x63, 0x65, 0x7d, 0x5d, 0};
 
 //        [     \     p     {     W     h     i     t     e     S     p     a     c     e     }     ]
         0x5b, 0x5c, 0x70, 0x7b, 0x57, 0x68, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x63, 0x65, 0x7d, 0x5d, 0};
 


@@ -107,9 +91,9 @@ static const UChar gIsWordPattern[] = {
 //
 //  UnicodeSets used in implementation of Grapheme Cluster detection, \X
 //
 //
 //  UnicodeSets used in implementation of Grapheme Cluster detection, \X
 //

-    static const UChar gGC_ControlPattern[] = {
-//    [     [     :     Z     l     :     ]     [     :     Z     p     :     ]    
-    0x5b, 0x5b, 0x3a, 0x5A, 0x6c, 0x3a, 0x5d, 0x5b, 0x3a, 0x5A, 0x70, 0x3a, 0x5d, 
+static const UChar gGC_ControlPattern[] = {
+//    [     [     :     Z     l     :     ]     [     :     Z     p     :     ]
+    0x5b, 0x5b, 0x3a, 0x5A, 0x6c, 0x3a, 0x5d, 0x5b, 0x3a, 0x5A, 0x70, 0x3a, 0x5d,

 //    [     :     C     c     :     ]     [     :     C     f     :     ]     -
     0x5b, 0x3a, 0x43, 0x63, 0x3a, 0x5d, 0x5b, 0x3a, 0x43, 0x66, 0x3a, 0x5d, 0x2d,
 //    [     :     G     r     a     p     h     e     m     e     _
 //    [     :     C     c     :     ]     [     :     C     f     :     ]     -
     0x5b, 0x3a, 0x43, 0x63, 0x3a, 0x5d, 0x5b, 0x3a, 0x43, 0x66, 0x3a, 0x5d, 0x2d,
 //    [     :     G     r     a     p     h     e     m     e     _


@@ -117,140 +101,163 @@ static const UChar gIsWordPattern[] = {
 //    E     x     t     e     n     d     :     ]     ]
     0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x3a, 0x5d, 0x5d, 0};
 
 //    E     x     t     e     n     d     :     ]     ]
     0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x3a, 0x5d, 0x5d, 0};
 

-    static const UChar gGC_ExtendPattern[] = {
+static const UChar gGC_ExtendPattern[] = {

 //    [     \     p     {     G     r     a     p     h     e     m     e     _
     0x5b, 0x5c, 0x70, 0x7b, 0x47, 0x72, 0x61, 0x70, 0x68, 0x65, 0x6d, 0x65, 0x5f,
 //    E     x     t     e     n     d     }     ]
     0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x7d, 0x5d, 0};
 
 //    [     \     p     {     G     r     a     p     h     e     m     e     _
     0x5b, 0x5c, 0x70, 0x7b, 0x47, 0x72, 0x61, 0x70, 0x68, 0x65, 0x6d, 0x65, 0x5f,
 //    E     x     t     e     n     d     }     ]
     0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x7d, 0x5d, 0};
 

-    static const UChar gGC_LPattern[] = {
-//    [     \     p     {     H     a     n     g     u     l     _     S     y     l    
+static const UChar gGC_LPattern[] = {
+//    [     \     p     {     H     a     n     g     u     l     _     S     y     l

     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 //    l     a     b     l     e     _     T     y     p     e     =     L     }     ]
     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 //    l     a     b     l     e     _     T     y     p     e     =     L     }     ]

-    0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x7d,  0x5d, 0}; 
+    0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x7d,  0x5d, 0};

 
 

-    static const UChar gGC_VPattern[] = {
-//    [     \     p     {     H     a     n     g     u     l     _     S     y     l    
+static const UChar gGC_VPattern[] = {
+//    [     \     p     {     H     a     n     g     u     l     _     S     y     l

     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 //    l     a     b     l     e     _     T     y     p     e     =     V     }     ]
     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 //    l     a     b     l     e     _     T     y     p     e     =     V     }     ]

-    0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x56, 0x7d,  0x5d, 0}; 
+    0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x56, 0x7d,  0x5d, 0};

 
 

-    static const UChar gGC_TPattern[] = {
-//    [     \     p     {     H     a     n     g     u     l     _     S     y     l    
+static const UChar gGC_TPattern[] = {
+//    [     \     p     {     H     a     n     g     u     l     _     S     y     l

     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 //    l     a     b     l     e     _     T     y     p     e     =     T     }    ]
     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 //    l     a     b     l     e     _     T     y     p     e     =     T     }    ]

-    0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x54, 0x7d, 0x5d, 0}; 
+    0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x54, 0x7d, 0x5d, 0};

 
 

-    static const UChar gGC_LVPattern[] = {
-//    [     \     p     {     H     a     n     g     u     l     _     S     y     l    
+static const UChar gGC_LVPattern[] = {
+//    [     \     p     {     H     a     n     g     u     l     _     S     y     l

     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 //    l     a     b     l     e     _     T     y     p     e     =     L     V     }     ]
     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 //    l     a     b     l     e     _     T     y     p     e     =     L     V     }     ]

-    0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x56, 0x7d, 0x5d, 0}; 
+    0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x56, 0x7d, 0x5d, 0};

 
 

-    static const UChar gGC_LVTPattern[] = {
-//    [     \     p     {     H     a     n     g     u     l     _     S     y     l    
+static const UChar gGC_LVTPattern[] = {
+//    [     \     p     {     H     a     n     g     u     l     _     S     y     l

     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 //    l     a     b     l     e     _     T     y     p     e     =     L     V     T     }     ]
     0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
 //    l     a     b     l     e     _     T     y     p     e     =     L     V     T     }     ]

-    0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x56, 0x54, 0x7d, 0x5d, 0}; 
+    0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x56, 0x54, 0x7d, 0x5d, 0};

 
 

-RegexStaticSets *RegexStaticSets::gStaticSets = NULL;

 
 

-RegexStaticSets::RegexStaticSets(UErrorCode *status) {
-    // First zero out everything  
+RegexStaticSets *RegexStaticSets::gStaticSets = NULL;
+UInitOnce gStaticSetsInitOnce = U_INITONCE_INITIALIZER;
+
+RegexStaticSets::RegexStaticSets(UErrorCode *status)
+:
+fUnescapeCharSet(UnicodeString(TRUE, gUnescapeCharPattern, -1), *status),
+fRuleDigitsAlias(NULL),
+fEmptyText(NULL)
+{
+    // First zero out everything

     int i;
     for (i=0; i<URX_LAST_SET; i++) {
         fPropSets[i] = NULL;
     }
     int i;
     for (i=0; i<URX_LAST_SET; i++) {
         fPropSets[i] = NULL;
     }

-    for (i=0; i<10; i++) {
-        fRuleSets[i] = NULL;
-    }
-    fUnescapeCharSet = NULL;
-    fRuleDigits      = NULL;
-    fEmptyString     = NULL;
-

     // Then init the sets to their correct values.
     // Then init the sets to their correct values.

-    fPropSets[URX_ISWORD_SET]  = new UnicodeSet(gIsWordPattern,     *status);
-    fPropSets[URX_ISSPACE_SET] = new UnicodeSet(gIsSpacePattern,    *status);    
-    fPropSets[URX_GC_EXTEND]   = new UnicodeSet(gGC_ExtendPattern,  *status);
-    fPropSets[URX_GC_CONTROL]  = new UnicodeSet(gGC_ControlPattern, *status);
-    fPropSets[URX_GC_L]        = new UnicodeSet(gGC_LPattern,       *status);
-    fPropSets[URX_GC_V]        = new UnicodeSet(gGC_VPattern,       *status);
-    fPropSets[URX_GC_T]        = new UnicodeSet(gGC_TPattern,       *status);
-    fPropSets[URX_GC_LV]       = new UnicodeSet(gGC_LVPattern,      *status);
-    fPropSets[URX_GC_LVT]      = new UnicodeSet(gGC_LVTPattern,     *status);
+    fPropSets[URX_ISWORD_SET]  = new UnicodeSet(UnicodeString(TRUE, gIsWordPattern, -1),     *status);
+    fPropSets[URX_ISSPACE_SET] = new UnicodeSet(UnicodeString(TRUE, gIsSpacePattern, -1),    *status);
+    fPropSets[URX_GC_EXTEND]   = new UnicodeSet(UnicodeString(TRUE, gGC_ExtendPattern, -1),  *status);
+    fPropSets[URX_GC_CONTROL]  = new UnicodeSet(UnicodeString(TRUE, gGC_ControlPattern, -1), *status);
+    fPropSets[URX_GC_L]        = new UnicodeSet(UnicodeString(TRUE, gGC_LPattern, -1),       *status);
+    fPropSets[URX_GC_V]        = new UnicodeSet(UnicodeString(TRUE, gGC_VPattern, -1),       *status);
+    fPropSets[URX_GC_T]        = new UnicodeSet(UnicodeString(TRUE, gGC_TPattern, -1),       *status);
+    fPropSets[URX_GC_LV]       = new UnicodeSet(UnicodeString(TRUE, gGC_LVPattern, -1),      *status);
+    fPropSets[URX_GC_LVT]      = new UnicodeSet(UnicodeString(TRUE, gGC_LVTPattern, -1),     *status);
+    
+    // Check for null pointers
+    if (fPropSets[URX_ISWORD_SET] == NULL || fPropSets[URX_ISSPACE_SET] == NULL || fPropSets[URX_GC_EXTEND] == NULL || 
+        fPropSets[URX_GC_CONTROL] == NULL || fPropSets[URX_GC_L] == NULL || fPropSets[URX_GC_V] == NULL || 
+        fPropSets[URX_GC_T] == NULL || fPropSets[URX_GC_LV] == NULL || fPropSets[URX_GC_LVT] == NULL) {
+        goto ExitConstrDeleteAll;
+    }

     if (U_FAILURE(*status)) {
         // Bail out if we were unable to create the above sets.
         // The rest of the initialization needs them, so we cannot proceed.
         return;
     }
     if (U_FAILURE(*status)) {
         // Bail out if we were unable to create the above sets.
         // The rest of the initialization needs them, so we cannot proceed.
         return;
     }

-    
-    
+
+

     //
     // The following sets  are dynamically constructed, because their
     //
     // The following sets  are dynamically constructed, because their

-    //   intialization strings would be unreasonable.
+    //   initialization strings would be unreasonable.

     //
     //

-    
-    
+
+

     //
     //  "Normal" is the set of characters that don't need special handling
     //            when finding grapheme cluster boundaries.
     //
     //
     //  "Normal" is the set of characters that don't need special handling
     //            when finding grapheme cluster boundaries.
     //

-    fPropSets[URX_GC_NORMAL] = new UnicodeSet;
-    fPropSets[URX_GC_NORMAL]->complement();
+    fPropSets[URX_GC_NORMAL] = new UnicodeSet(0, UnicodeSet::MAX_VALUE);
+    // Null pointer check
+    if (fPropSets[URX_GC_NORMAL] == NULL) {
+       goto ExitConstrDeleteAll;
+    }

     fPropSets[URX_GC_NORMAL]->remove(0xac00, 0xd7a4);
     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_CONTROL]);
     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_L]);
     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_V]);
     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_T]);
     fPropSets[URX_GC_NORMAL]->remove(0xac00, 0xd7a4);
     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_CONTROL]);
     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_L]);
     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_V]);
     fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_T]);

-    
+

     // Initialize the 8-bit fast bit sets from the parallel full
     //   UnicodeSets.
     for (i=0; i<URX_LAST_SET; i++) {
     // Initialize the 8-bit fast bit sets from the parallel full
     //   UnicodeSets.
     for (i=0; i<URX_LAST_SET; i++) {

-        fPropSets8[i].init(fPropSets[i]);
+        if (fPropSets[i]) {
+            fPropSets[i]->compact();
+            fPropSets8[i].init(fPropSets[i]);
+        }

     }
 
     // Sets used while parsing rules, but not referenced from the parse state table
     }
 
     // Sets used while parsing rules, but not referenced from the parse state table

-    fRuleSets[kRuleSet_rule_char-128]   = new UnicodeSet(gRuleSet_rule_char_pattern,  *status);
-    fRuleSets[kRuleSet_white_space-128] = new UnicodeSet(gRuleWhiteSpacePattern,      *status);
-    fRuleSets[kRuleSet_digit_char-128]  = new UnicodeSet(gRuleSet_digit_char_pattern, *status);
-    fRuleDigits                         = new UnicodeSet(gRuleSet_digit_char_pattern, *status);
-    fUnescapeCharSet                    = new UnicodeSet(gUnescapeCharPattern,        *status);
-
-    // Empty UnicodeString, for use by matchers with NULL input.
-    fEmptyString = new UnicodeString;
+    fRuleSets[kRuleSet_rule_char-128]   = UnicodeSet(UnicodeString(TRUE, gRuleSet_rule_char_pattern, -1),   *status);
+    fRuleSets[kRuleSet_digit_char-128].add((UChar)0x30, (UChar)0x39);    // [0-9]
+    fRuleSets[kRuleSet_ascii_letter-128].add((UChar)0x41, (UChar)0x5A);  // [A-Z]
+    fRuleSets[kRuleSet_ascii_letter-128].add((UChar)0x61, (UChar)0x7A);  // [a-z]
+    fRuleDigitsAlias = &fRuleSets[kRuleSet_digit_char-128];
+    for (i=0; i<UPRV_LENGTHOF(fRuleSets); i++) {
+        fRuleSets[i].compact();
+    }
+    
+    // Finally, initialize an empty string for utility purposes
+    fEmptyText = utext_openUChars(NULL, NULL, 0, status);
+    
+    if (U_SUCCESS(*status)) {
+        return;
+    }
+
+ExitConstrDeleteAll: // Remove fPropSets and fRuleSets and return error
+    for (i=0; i<URX_LAST_SET; i++) {
+        delete fPropSets[i];
+        fPropSets[i] = NULL;
+    }
+    if (U_SUCCESS(*status)) {
+        *status = U_MEMORY_ALLOCATION_ERROR;
+    }

 }
 
 
 RegexStaticSets::~RegexStaticSets() {
 }
 
 
 RegexStaticSets::~RegexStaticSets() {

-    int i;
+    int32_t i;

 
     for (i=0; i<URX_LAST_SET; i++) {
         delete fPropSets[i];
         fPropSets[i] = NULL;
     }
 
     for (i=0; i<URX_LAST_SET; i++) {
         delete fPropSets[i];
         fPropSets[i] = NULL;
     }

-    for (i=0; i<10; i++) {
-        delete fRuleSets[i];
-        fRuleSets[i] = NULL;
-    }
-    delete fUnescapeCharSet;
-    fUnescapeCharSet = NULL;
-    delete fRuleDigits;
-    fRuleDigits = NULL;
-    delete fEmptyString;
-    fEmptyString = NULL;
+    fRuleDigitsAlias = NULL;
+    
+    utext_close(fEmptyText);

 }
 
 
 }
 
 

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

 //
 //   regex_cleanup      Memory cleanup function, free/delete all
 //                      cached memory.  Called by ICU's u_cleanup() function.
 //
 //
 //   regex_cleanup      Memory cleanup function, free/delete all
 //                      cached memory.  Called by ICU's u_cleanup() function.
 //

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

 UBool
 RegexStaticSets::cleanup(void) {
     delete RegexStaticSets::gStaticSets;
     RegexStaticSets::gStaticSets = NULL;
 UBool
 RegexStaticSets::cleanup(void) {
     delete RegexStaticSets::gStaticSets;
     RegexStaticSets::gStaticSets = NULL;

+    gStaticSetsInitOnce.reset();

     return TRUE;
 }
 
     return TRUE;
 }
 


@@ -259,31 +266,24 @@ static UBool U_CALLCONV
 regex_cleanup(void) {
     return RegexStaticSets::cleanup();
 }
 regex_cleanup(void) {
     return RegexStaticSets::cleanup();
 }

+
+static void U_CALLCONV initStaticSets(UErrorCode &status) {
+    U_ASSERT(RegexStaticSets::gStaticSets == NULL);
+    ucln_i18n_registerCleanup(UCLN_I18N_REGEX, regex_cleanup);
+    RegexStaticSets::gStaticSets = new RegexStaticSets(&status);
+    if (U_FAILURE(status)) {
+        delete RegexStaticSets::gStaticSets;
+        RegexStaticSets::gStaticSets = NULL;
+    }
+    if (RegexStaticSets::gStaticSets == NULL && U_SUCCESS(status)) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+    }
+}

 U_CDECL_END
 
 void RegexStaticSets::initGlobals(UErrorCode *status) {
 U_CDECL_END
 
 void RegexStaticSets::initGlobals(UErrorCode *status) {

-    umtx_lock(NULL);
-    RegexStaticSets *p = gStaticSets;
-    umtx_unlock(NULL);
-    if (p == NULL) {
-        p = new RegexStaticSets(status);
-        if (U_FAILURE(*status)) {
-            delete p;
-            return;
-        }
-        umtx_lock(NULL);
-        if (gStaticSets == NULL) {
-            gStaticSets = p;
-            p = NULL;
-        }
-        umtx_unlock(NULL);
-        if (p) {
-            delete p;
-        }
-        ucln_i18n_registerCleanup(UCLN_I18N_REGEX, regex_cleanup);
-    }
+    umtx_initOnce(gStaticSetsInitOnce, &initStaticSets, *status);

 }
 }

-    

 
 U_NAMESPACE_END
 #endif  // !UCONFIG_NO_REGULAR_EXPRESSIONS
 
 U_NAMESPACE_END
 #endif  // !UCONFIG_NO_REGULAR_EXPRESSIONS