ICU upgrade to 54.1 step 2

source/i18n/regexcmp.h

 //
 //  regexcmp.h
 //
 //  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"
@@ skipping 86 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.
+    void        appendOp(int32_t type, int32_t val); // Build & append a new op to the compiled pattern.
+    int32_t     buildOp(int32_t type, int32_t val);  // Construct a new pcode instruction.
+    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();
@@ skipping 63 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.
+                                                     //   parenthesized block. Updated when processing
+                                                     //   a close to the location for the corresponding open.
+
     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