Update ICU to 54.1 step 1

source/i18n/regexcmp.h

 //
 //  regexcmp.h
 //
-//  Copyright (C) 2002-2012, International Business Machines Corporation and others.
+//  Copyright (C) 2002-2014, International Business Machines Corporation and others.
 //  All Rights Reserved.
 //
 //  This file contains declarations for the class RegexCompile
 //
 //  This class is internal to the regular expression implementation.
 //  For the public Regular Expression API, see the file "unicode/regex.h"
 //
 
 
 #ifndef RBBISCAN_H
 #define RBBISCAN_H
 
 #include "unicode/utypes.h"
 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
 
 #include "unicode/uobject.h"
 #include "unicode/uniset.h"
 #include "unicode/parseerr.h"
 #include "uhash.h"
 #include "uvector.h"
+#include "uvectr32.h"
 
 
 
 U_NAMESPACE_BEGIN
 
 
 //--------------------------------------------------------------------------------
 //
 //  class RegexCompile    Contains the regular expression compiler.
 //
 //--------------------------------------------------------------------------------
 struct  RegexTableEl;
 class   RegexPattern;
 
 
-class RegexCompile : public UMemory {
+class U_I18N_API RegexCompile : public UMemory {
 public:
 
     enum {
         kStackSize = 100            // The size of the state stack for
     };                              //   pattern parsing.  Corresponds roughly
                                     //   to the depth of parentheses nesting
                                     //   that is allowed in the rules.
 
     struct RegexPatternChar {
         UChar32             fChar;
@@ skipping 45 matching lines @@
                                                      //  there is space to add an opcode there.
     void        compileSet(UnicodeSet *theSet);      // Generate the compiled pattern for
                                                      //   a reference to a UnicodeSet.
     void        compileInterval(int32_t InitOp,      // Generate the code for a {min,max} quantifier.
                                int32_t LoopOp);
     UBool       compileInlineInterval();             // Generate inline code for a {min,max} quantifier
     void        literalChar(UChar32 c);              // Compile a literal char
     void        fixLiterals(UBool split=FALSE);      // Generate code for pending literal characters.
     void        insertOp(int32_t where);             // Open up a slot for a new op in the
                                                      //   generated code at the specified location.
-    void        appendOp(int32_t op);                // Append a new op to the compiled pattern.
-    int32_t     allocateData(int32_t size);          // Allocate space in the matcher data area.
-                                                     //   Return index of the newly allocated data.
-    int32_t     allocateStackData(int32_t size);     // Allocate space in the match back-track stack frame.
-                                                     //   Return offset index in the frame.
     int32_t     minMatchLength(int32_t start,
                                int32_t end);
     int32_t     maxMatchLength(int32_t start,
                                int32_t end);
     void        matchStartType();
     void        stripNOPs();
 
     void        setEval(int32_t op);
     void        setPushOp(int32_t op);
     UChar32     scanNamedChar();
     UnicodeSet *createSetForProperty(const UnicodeString &propName, UBool negated);
 
+public:   // Public for testing only.
+    static void U_EXPORT2 findCaseInsensitiveStarters(UChar32 c, UnicodeSet *starterChars);
+private:
+
 
     UErrorCode                    *fStatus;
     RegexPattern                  *fRXPat;
     UParseError                   *fParseErr;
 
     //
     //  Data associated with low level character scanning
     //
     int64_t                       fScanIndex;        // Index of current character being processed
                                                      //   in the rule input string.
@@ skipping 47 matching lines @@
                                                      //   spot reserved for use when a quantifier
                                                      //   needs to add a SAVE at the start of a (block)
                                                      //   The negative value (-1, -2,...) indicates
                                                      //   the kind of paren that opened the frame.  Some
                                                      //   need special handling on close.
 
 
     int32_t                       fMatchOpenParen;   // The position in the compiled pattern
                                                      //   of the slot reserved for a state save
                                                      //   at the start of the most recently processed
-                                                     //   parenthesized block. Updated when processing
-                                                     //   a close to the location for the corresponding open.
-
+                                                     //   parenthesized block.
     int32_t                       fMatchCloseParen;  // The position in the pattern of the first
                                                      //   location after the most recently processed
                                                      //   parenthesized block.
 
     int32_t                       fIntervalLow;      // {lower, upper} interval quantifier values.
     int32_t                       fIntervalUpper;    // Placed here temporarily, when pattern is
                                                      //   initially scanned.  Each new interval
                                                      //   encountered overwrites these values.
                                                      //   -1 for the upper interval value means none
                                                      //   was specified (unlimited occurences.)
@@ skipping 23 matching lines @@
     setDifference2   = 3 << 16 | 4,    // '--' set difference operator
     setIntersection2 = 3 << 16 | 5,    // '&&' set intersection operator
     setUnion         = 4 << 16 | 6,    // implicit union of adjacent items
     setDifference1   = 4 << 16 | 7,    // '-', single dash difference op, for compatibility with old UnicodeSet.
     setIntersection1 = 4 << 16 | 8     // '&', single amp intersection op, for compatibility with old UnicodeSet.
     };
 
 U_NAMESPACE_END
 #endif   // !UCONFIG_NO_REGULAR_EXPRESSIONS
 #endif   // RBBISCAN_H