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

//
//  regexst.h
//
//  Copyright (C) 2004-2012, International Business Machines Corporation and others.
//  All Rights Reserved.
//
//  This file contains class RegexStaticSets
//
//  This class is internal to the regular expression implementation.
//  For the public Regular Expression API, see the file "unicode/regex.h"
//
//  RegexStaticSets groups together the common UnicodeSets that are needed
//   for compiling or executing RegularExpressions.  This grouping simplifies
//   the thread safe lazy creation and sharing of these sets across
//   all instances of regular expressions.
//
#include "unicode/utypes.h"

#if !UCONFIG_NO_REGULAR_EXPRESSIONS

#include "unicode/unistr.h"
#include "unicode/uniset.h"
#include "unicode/uchar.h"
#include "unicode/regex.h"
#include "uprops.h"
#include "cmemory.h"
#include "cstring.h"
#include "uassert.h"
#include "ucln_in.h"
#include "umutex.h"

#include "regexcst.h"   // Contains state table for the regex pattern parser.
                        //   generated by a Perl script.
#include "regexst.h"


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.
//
//------------------------------------------------------------------------------

// "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
//    as the inverse of those needing escaping --  [^\*\?\+\[\(\)\{\}\^\$\|\\\.]
static const UChar gRuleSet_rule_char_pattern[]       = {
 //   [    ^      \     *     \     ?     \     +     \     [     \     (     /     )
    0x5b, 0x5e, 0x5c, 0x2a, 0x5c, 0x3f, 0x5c, 0x2b, 0x5c, 0x5b, 0x5c, 0x28, 0x5c, 0x29,
 //   \     {    \     }     \     ^     \     $     \     |     \     \     \     .     ]
    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};

//
//   Here are the backslash escape characters that ICU's unescape() function
//    will handle.
//
static const UChar gUnescapeCharPattern[] = {
//    [     a     c     e     f     n     r     t     u     U     x    ]
    0x5b, 0x61, 0x63, 0x65, 0x66, 0x6e, 0x72, 0x74, 0x75, 0x55, 0x78, 0x5d, 0};


//
//  Unicode Set Definitions for Regular Expression  \w
//
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
          0x5c, 0x70, 0x7b, 0x4d, 0x7d,
//          \     p     {    N     d     }                         Digit_Numeric
          0x5c, 0x70, 0x7b, 0x4e, 0x64, 0x7d,
//          \     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
//
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};


//
//  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,
//    [     :     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     _
    0x5b, 0x3a, 0x47, 0x72, 0x61, 0x70, 0x68, 0x65, 0x6d, 0x65, 0x5f,
//    E     x     t     e     n     d     :     ]     ]
    0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x3a, 0x5d, 0x5d, 0};

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};

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     }     ]
    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
    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};

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     }    ]
    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
    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};

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     }     ]
    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)
:
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;
    }
    // Then init the sets to their correct values.
    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;
    }


    //
    // The following sets  are dynamically constructed, because their
    //   initialization strings would be unreasonable.
    //


    //
    //  "Normal" is the set of characters that don't need special handling
    //            when finding grapheme cluster boundaries.
    //
    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]);

    // Initialize the 8-bit fast bit sets from the parallel full
    //   UnicodeSets.
    for (i=0; i<URX_LAST_SET; 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
    fRuleSets[kRuleSet_rule_char-128]   = UnicodeSet(UnicodeString(TRUE, gRuleSet_rule_char_pattern, -1),   *status);
    fRuleSets[kRuleSet_digit_char-128]  = UnicodeSet(UnicodeString(TRUE, gRuleSet_digit_char_pattern, -1),  *status);
    fRuleDigitsAlias = &fRuleSets[kRuleSet_digit_char-128];
    for (i=0; i<(int32_t)(sizeof(fRuleSets)/sizeof(fRuleSets[0])); i++) {
        fRuleSets[i].compact();
    }
    
    // Finally, initialize an empty string for utility purposes
    fEmptyText = utext_openUChars(NULL, NULL, 0, status);
    
    return; // If we reached this point, everything is fine so just exit

ExitConstrDeleteAll: // Remove fPropSets and fRuleSets and return error
    for (i=0; i<URX_LAST_SET; i++) {
        delete fPropSets[i];
        fPropSets[i] = NULL;
    }
    *status = U_MEMORY_ALLOCATION_ERROR;
}


RegexStaticSets::~RegexStaticSets() {
    int32_t i;

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


//------------------------------------------------------------------------------
//
//   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;
    return TRUE;
}

U_CDECL_BEGIN
static UBool U_CALLCONV
regex_cleanup(void) {
    return RegexStaticSets::cleanup();
}
U_CDECL_END

void RegexStaticSets::initGlobals(UErrorCode *status) {
    RegexStaticSets *p;
    UMTX_CHECK(NULL, gStaticSets, p);
    if (p == NULL) {
        p = new RegexStaticSets(status);
        if (p == NULL) {
        	*status = U_MEMORY_ALLOCATION_ERROR;
        	return;
        }
        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);
    }
}


U_NAMESPACE_END
#endif  // !UCONFIG_NO_REGULAR_EXPRESSIONS
Commit	Line	Data
b75a7d8f A	1	//
	2	// regexst.h
	3	//
4388f060	4	// Copyright (C) 2004-2012, International Business Machines Corporation and others.
b75a7d8f A	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
46f4442e	41	//------------------------------------------------------------------------------
b75a7d8f A	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	//
46f4442e	47	//------------------------------------------------------------------------------
b75a7d8f A	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	static const UChar gRuleSet_digit_char_pattern[] = {
	60	// [ 0 - 9 ]
	61	0x5b, 0x30, 0x2d, 0x39, 0x5d, 0};
b75a7d8f A	62
	63	//
	64	// Here are the backslash escape characters that ICU's unescape() function
	65	// will handle.
	66	//
	67	static const UChar gUnescapeCharPattern[] = {
	68	// [ a c e f n r t u U x ]
	69	0x5b, 0x61, 0x63, 0x65, 0x66, 0x6e, 0x72, 0x74, 0x75, 0x55, 0x78, 0x5d, 0};
	70
	71
b75a7d8f A	72	//
	73	// Unicode Set Definitions for Regular Expression \w
	74	//
	75	static const UChar gIsWordPattern[] = {
374ca955 A	76	// [ \ p { A l p h a b e t i c }
	77	0x5b, 0x5c, 0x70, 0x7b, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x62, 0x65, 0x74, 0x69, 0x63, 0x7d,
	78	// \ p { M } Mark
46f4442e	79	0x5c, 0x70, 0x7b, 0x4d, 0x7d,
374ca955 A	80	// \ p { N d } Digit_Numeric
374ca955 A	81	0x5c, 0x70, 0x7b, 0x4e, 0x64, 0x7d,
4388f060 A	82	// \ p { P c } Connector_Punctuation
	83	0x5c, 0x70, 0x7b, 0x50, 0x63, 0x7d,
	84	// \ u 2 0 0 c \ u 2 0 0 d ]
	85	0x5c, 0x75, 0x32, 0x30, 0x30, 0x63, 0x5c, 0x75, 0x32, 0x30, 0x30, 0x64, 0x5d, 0};
b75a7d8f A	86
	87
	88	//
	89	// Unicode Set Definitions for Regular Expression \s
	90	//
46f4442e	91	static const UChar gIsSpacePattern[] = {
374ca955 A	92	// [ \ p { W h i t e S p a c e } ]
374ca955 A	93	0x5b, 0x5c, 0x70, 0x7b, 0x57, 0x68, 0x69, 0x74, 0x65, 0x53, 0x70, 0x61, 0x63, 0x65, 0x7d, 0x5d, 0};
b75a7d8f A	94
	95
	96	//
	97	// UnicodeSets used in implementation of Grapheme Cluster detection, \X
	98	//
46f4442e A	99	static const UChar gGC_ControlPattern[] = {
	100	// [ [ : Z l : ] [ : Z p : ]
	101	0x5b, 0x5b, 0x3a, 0x5A, 0x6c, 0x3a, 0x5d, 0x5b, 0x3a, 0x5A, 0x70, 0x3a, 0x5d,
374ca955 A	102	// [ : C c : ] [ : C f : ] -
	103	0x5b, 0x3a, 0x43, 0x63, 0x3a, 0x5d, 0x5b, 0x3a, 0x43, 0x66, 0x3a, 0x5d, 0x2d,
	104	// [ : G r a p h e m e _
	105	0x5b, 0x3a, 0x47, 0x72, 0x61, 0x70, 0x68, 0x65, 0x6d, 0x65, 0x5f,
	106	// E x t e n d : ] ]
	107	0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x3a, 0x5d, 0x5d, 0};
b75a7d8f	108
46f4442e	109	static const UChar gGC_ExtendPattern[] = {
b75a7d8f A	110	// [ \ p { G r a p h e m e _
	111	0x5b, 0x5c, 0x70, 0x7b, 0x47, 0x72, 0x61, 0x70, 0x68, 0x65, 0x6d, 0x65, 0x5f,
	112	// E x t e n d } ]
	113	0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x7d, 0x5d, 0};
	114
46f4442e A	115	static const UChar gGC_LPattern[] = {
46f4442e A	116	// [ \ p { H a n g u l _ S y l
b75a7d8f A	117	0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
b75a7d8f A	118	// l a b l e _ T y p e = L } ]
46f4442e	119	0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x7d, 0x5d, 0};
b75a7d8f	120
46f4442e A	121	static const UChar gGC_VPattern[] = {
46f4442e A	122	// [ \ p { H a n g u l _ S y l
b75a7d8f A	123	0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
b75a7d8f A	124	// l a b l e _ T y p e = V } ]
46f4442e	125	0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x56, 0x7d, 0x5d, 0};
b75a7d8f	126
46f4442e A	127	static const UChar gGC_TPattern[] = {
46f4442e A	128	// [ \ p { H a n g u l _ S y l
b75a7d8f A	129	0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
b75a7d8f A	130	// l a b l e _ T y p e = T } ]
46f4442e	131	0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x54, 0x7d, 0x5d, 0};
b75a7d8f	132
46f4442e A	133	static const UChar gGC_LVPattern[] = {
46f4442e A	134	// [ \ p { H a n g u l _ S y l
b75a7d8f A	135	0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
b75a7d8f A	136	// l a b l e _ T y p e = L V } ]
46f4442e	137	0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x56, 0x7d, 0x5d, 0};
b75a7d8f	138
46f4442e A	139	static const UChar gGC_LVTPattern[] = {
46f4442e A	140	// [ \ p { H a n g u l _ S y l
b75a7d8f A	141	0x5b, 0x5c, 0x70, 0x7b, 0x48, 0x61, 0x6e, 0x67, 0x75, 0x6c, 0x5f, 0x53, 0x79, 0x6c,
b75a7d8f A	142	// l a b l e _ T y p e = L V T } ]
46f4442e A	143	0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x54, 0x79, 0x70, 0x65, 0x3d, 0x4c, 0x56, 0x54, 0x7d, 0x5d, 0};
46f4442e A	144
b75a7d8f A	145
	146	RegexStaticSets *RegexStaticSets::gStaticSets = NULL;
	147
46f4442e A	148	RegexStaticSets::RegexStaticSets(UErrorCode *status)
	149	:
	150	fUnescapeCharSet(UnicodeString(TRUE, gUnescapeCharPattern, -1), *status),
729e4ab9 A	151	fRuleDigitsAlias(NULL),
729e4ab9 A	152	fEmptyText(NULL)
46f4442e A	153	{
46f4442e A	154	// First zero out everything
b75a7d8f A	155	int i;
	156	for (i=0; i<URX_LAST_SET; i++) {
	157	fPropSets[i] = NULL;
	158	}
b75a7d8f	159	// Then init the sets to their correct values.
46f4442e A	160	fPropSets[URX_ISWORD_SET] = new UnicodeSet(UnicodeString(TRUE, gIsWordPattern, -1), *status);
	161	fPropSets[URX_ISSPACE_SET] = new UnicodeSet(UnicodeString(TRUE, gIsSpacePattern, -1), *status);
	162	fPropSets[URX_GC_EXTEND] = new UnicodeSet(UnicodeString(TRUE, gGC_ExtendPattern, -1), *status);
	163	fPropSets[URX_GC_CONTROL] = new UnicodeSet(UnicodeString(TRUE, gGC_ControlPattern, -1), *status);
	164	fPropSets[URX_GC_L] = new UnicodeSet(UnicodeString(TRUE, gGC_LPattern, -1), *status);
	165	fPropSets[URX_GC_V] = new UnicodeSet(UnicodeString(TRUE, gGC_VPattern, -1), *status);
	166	fPropSets[URX_GC_T] = new UnicodeSet(UnicodeString(TRUE, gGC_TPattern, -1), *status);
	167	fPropSets[URX_GC_LV] = new UnicodeSet(UnicodeString(TRUE, gGC_LVPattern, -1), *status);
	168	fPropSets[URX_GC_LVT] = new UnicodeSet(UnicodeString(TRUE, gGC_LVTPattern, -1), *status);
	169
	170	// Check for null pointers
	171	if (fPropSets[URX_ISWORD_SET] == NULL \|\| fPropSets[URX_ISSPACE_SET] == NULL \|\| fPropSets[URX_GC_EXTEND] == NULL \|\|
	172	fPropSets[URX_GC_CONTROL] == NULL \|\| fPropSets[URX_GC_L] == NULL \|\| fPropSets[URX_GC_V] == NULL \|\|
	173	fPropSets[URX_GC_T] == NULL \|\| fPropSets[URX_GC_LV] == NULL \|\| fPropSets[URX_GC_LVT] == NULL) {
	174	goto ExitConstrDeleteAll;
	175	}
b75a7d8f A	176	if (U_FAILURE(*status)) {
	177	// Bail out if we were unable to create the above sets.
	178	// The rest of the initialization needs them, so we cannot proceed.
	179	return;
	180	}
46f4442e A	181
46f4442e A	182
b75a7d8f A	183	//
b75a7d8f A	184	// The following sets are dynamically constructed, because their
46f4442e	185	// initialization strings would be unreasonable.
b75a7d8f	186	//
46f4442e A	187
46f4442e A	188
b75a7d8f A	189	//
	190	// "Normal" is the set of characters that don't need special handling
	191	// when finding grapheme cluster boundaries.
	192	//
46f4442e A	193	fPropSets[URX_GC_NORMAL] = new UnicodeSet(0, UnicodeSet::MAX_VALUE);
	194	// Null pointer check
	195	if (fPropSets[URX_GC_NORMAL] == NULL) {
	196	goto ExitConstrDeleteAll;
	197	}
b75a7d8f A	198	fPropSets[URX_GC_NORMAL]->remove(0xac00, 0xd7a4);
	199	fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_CONTROL]);
	200	fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_L]);
	201	fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_V]);
	202	fPropSets[URX_GC_NORMAL]->removeAll(*fPropSets[URX_GC_T]);
46f4442e	203
b75a7d8f A	204	// Initialize the 8-bit fast bit sets from the parallel full
	205	// UnicodeSets.
	206	for (i=0; i<URX_LAST_SET; i++) {
46f4442e A	207	if (fPropSets[i]) {
	208	fPropSets[i]->compact();
	209	fPropSets8[i].init(fPropSets[i]);
	210	}
b75a7d8f A	211	}
	212
	213	// Sets used while parsing rules, but not referenced from the parse state table
46f4442e A	214	fRuleSets[kRuleSet_rule_char-128] = UnicodeSet(UnicodeString(TRUE, gRuleSet_rule_char_pattern, -1), *status);
	215	fRuleSets[kRuleSet_digit_char-128] = UnicodeSet(UnicodeString(TRUE, gRuleSet_digit_char_pattern, -1), *status);
	216	fRuleDigitsAlias = &fRuleSets[kRuleSet_digit_char-128];
	217	for (i=0; i<(int32_t)(sizeof(fRuleSets)/sizeof(fRuleSets[0])); i++) {
	218	fRuleSets[i].compact();
	219	}
729e4ab9 A	220
	221	// Finally, initialize an empty string for utility purposes
	222	fEmptyText = utext_openUChars(NULL, NULL, 0, status);
	223
46f4442e A	224	return; // If we reached this point, everything is fine so just exit
	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	*status = U_MEMORY_ALLOCATION_ERROR;
374ca955	232	}
b75a7d8f A	233
	234
	235	RegexStaticSets::~RegexStaticSets() {
46f4442e	236	int32_t i;
b75a7d8f A	237
	238	for (i=0; i<URX_LAST_SET; i++) {
	239	delete fPropSets[i];
	240	fPropSets[i] = NULL;
	241	}
46f4442e	242	fRuleDigitsAlias = NULL;
729e4ab9 A	243
729e4ab9 A	244	utext_close(fEmptyText);
374ca955 A	245	}
	246
	247
46f4442e	248	//------------------------------------------------------------------------------
374ca955 A	249	//
	250	// regex_cleanup Memory cleanup function, free/delete all
	251	// cached memory. Called by ICU's u_cleanup() function.
	252	//
46f4442e	253	//------------------------------------------------------------------------------
374ca955 A	254	UBool
	255	RegexStaticSets::cleanup(void) {
	256	delete RegexStaticSets::gStaticSets;
	257	RegexStaticSets::gStaticSets = NULL;
	258	return TRUE;
	259	}
b75a7d8f	260
374ca955 A	261	U_CDECL_BEGIN
	262	static UBool U_CALLCONV
	263	regex_cleanup(void) {
	264	return RegexStaticSets::cleanup();
	265	}
	266	U_CDECL_END
b75a7d8f A	267
b75a7d8f A	268	void RegexStaticSets::initGlobals(UErrorCode *status) {
46f4442e A	269	RegexStaticSets *p;
46f4442e A	270	UMTX_CHECK(NULL, gStaticSets, p);
b75a7d8f A	271	if (p == NULL) {
b75a7d8f A	272	p = new RegexStaticSets(status);
46f4442e A	273	if (p == NULL) {
	274	*status = U_MEMORY_ALLOCATION_ERROR;
	275	return;
	276	}
b75a7d8f A	277	if (U_FAILURE(*status)) {
	278	delete p;
	279	return;
	280	}
	281	umtx_lock(NULL);
	282	if (gStaticSets == NULL) {
	283	gStaticSets = p;
	284	p = NULL;
	285	}
	286	umtx_unlock(NULL);
	287	if (p) {
	288	delete p;
	289	}
374ca955	290	ucln_i18n_registerCleanup(UCLN_I18N_REGEX, regex_cleanup);
b75a7d8f A	291	}
b75a7d8f A	292	}
46f4442e	293
b75a7d8f A	294
	295	U_NAMESPACE_END
	296	#endif // !UCONFIG_NO_REGULAR_EXPRESSIONS