Update ICU to 54.1 step 1

source/i18n/unicode/regex.h

 /*
 **********************************************************************
-*   Copyright (C) 2002-2013, International Business Machines
+*   Copyright (C) 2002-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 **********************************************************************
 *   file name:  regex.h
 *   encoding:   US-ASCII
 *   indentation:4
 *
 *   created on: 2002oct22
 *   created by: Andy Heninger
 *
 *   ICU Regular Expressions, API for C++
@@ skipping 47 matching lines @@
 class  RegexCImpl;
 class  RegexMatcher;
 class  RegexPattern;
 struct REStackFrame;
 class  RuleBasedBreakIterator;
 class  UnicodeSet;
 class  UVector;
 class  UVector32;
 class  UVector64;
 
-#ifndef U_HIDE_INTERNAL_API
-/**
- *   RBBIPatternDump   Debug function, displays the compiled form of a pattern.
- *   @internal
- */
-#ifdef REGEX_DEBUG
-U_INTERNAL void U_EXPORT2
-    RegexPatternDump(const RegexPattern *pat);
-#else
-    #undef RegexPatternDump
-    #define RegexPatternDump(pat)
-#endif
-#endif  /* U_HIDE_INTERNAL_API */
-
-
 
 /**
   * Class <code>RegexPattern</code> represents a compiled regular expression.  It includes
   * factory methods for creating a RegexPattern object from the source (string) form
   * of a regular expression, methods for creating RegexMatchers that allow the pattern
   * to be applied to input text, and a few convenience methods for simple common
   * uses of regular expressions.
   *
   * <p>Class RegexPattern is not intended to be subclassed.</p>
   *
   * @stable ICU 2.4
   */
-class U_I18N_API RegexPattern: public UObject {
+class U_I18N_API RegexPattern U_FINAL : public UObject {
 public:
 
     /**
      * default constructor.  Create a RegexPattern object that refers to no actual
      *   pattern.  Not normally needed; RegexPattern objects are usually
      *   created using the factory method <code>compile()</code>.
      *
      * @stable ICU 2.4
      */
     RegexPattern();
@@ skipping 497 matching lines @@
 
     friend class RegexCompile;
     friend class RegexMatcher;
     friend class RegexCImpl;
 
     //
     //  Implementation Methods
     //
     void        init();            // Common initialization, for use by constructors.
     void        zap();             // Common cleanup
-#ifdef REGEX_DEBUG
+
     void        dumpOp(int32_t index) const;
-    friend     void U_EXPORT2 RegexPatternDump(const RegexPattern *);
-#endif
 
+  public:
+#ifndef U_HIDE_INTERNAL_API
+    /**
+      * Dump a compiled pattern. Internal debug function.
+      * @internal
+      */
+    void        dumpPattern() const;
+#endif  /* U_HIDE_INTERNAL_API */
 };
 
 
 
 /**
  *  class RegexMatcher bundles together a regular expression pattern and
  *  input text to which the expression can be applied.  It includes methods
  *  for testing for matches, and for find and replace operations.
  *
  * <p>Class RegexMatcher is not intended to be subclassed.</p>
  *
  * @stable ICU 2.4
  */
-class U_I18N_API RegexMatcher: public UObject {
+class U_I18N_API RegexMatcher U_FINAL : public UObject {
 public:
 
     /**
       * Construct a RegexMatcher for a regular expression.
       * This is a convenience method that avoids the need to explicitly create
       * a RegexPattern object.  Note that if several RegexMatchers need to be
       * created for the same expression, it will be more efficient to
       * separately create and cache a RegexPattern object, and use
       * its matcher() method to create the RegexMatcher objects.
       *
@@ skipping 159 matching lines @@
     *  <p>Note that if the input string is changed by the application,
     *     use find(startPos, status) instead of find(), because the saved starting
     *     position may not be valid with the altered input string.</p>
     *  @return  TRUE if a match is found.
     *  @stable ICU 2.4
     */
     virtual UBool find();
 
 
    /**
+    *  Find the next pattern match in the input string.
+    *  The find begins searching the input at the location following the end of
+    *  the previous match, or at the start of the string if there is no previous match.
+    *  If a match is found, <code>start(), end()</code> and <code>group()</code>
+    *  will provide more information regarding the match.
+    *  <p>Note that if the input string is changed by the application,
+    *     use find(startPos, status) instead of find(), because the saved starting
+    *     position may not be valid with the altered input string.</p>
+    *  @param   status  A reference to a UErrorCode to receive any errors.
+    *  @return  TRUE if a match is found.
+    *  @internal
+    */
+    virtual UBool find(UErrorCode &status);
+
+   /**
     *   Resets this RegexMatcher and then attempts to find the next substring of the
     *   input string that matches the pattern, starting at the specified index.
     *
     *   @param   start     The (native) index in the input string to begin the search.
     *   @param   status    A reference to a UErrorCode to receive any errors.
     *   @return  TRUE if a match is found.
     *   @stable ICU 2.4
     */
     virtual UBool find(int64_t start, UErrorCode &status);
 
@@ skipping 922 matching lines @@
     //  MatchAt   This is the internal interface to the match engine itself.
     //            Match status comes back in matcher member variables.
     //
     void                 MatchAt(int64_t startIdx, UBool toEnd, UErrorCode &status);
     inline void          backTrack(int64_t &inputIdx, int32_t &patIdx);
     UBool                isWordBoundary(int64_t pos);         // perform Perl-like  \b test
     UBool                isUWordBoundary(int64_t pos);        // perform RBBI based \b test
     REStackFrame        *resetStack();
     inline REStackFrame *StateSave(REStackFrame *fp, int64_t savePatIdx, UErrorCode &status);
     void                 IncrementTime(UErrorCode &status);
-    UBool                ReportFindProgress(int64_t matchIndex, UErrorCode &status);
+
+    // Call user find callback function, if set. Return TRUE if operation should be interrupted.
+    inline UBool         findProgressInterrupt(int64_t matchIndex, UErrorCode &status);
     
     int64_t              appendGroup(int32_t groupNum, UText *dest, UErrorCode &status) const;
     
-    UBool                findUsingChunk();
+    UBool                findUsingChunk(UErrorCode &status);
     void                 MatchChunkAt(int32_t startIdx, UBool toEnd, UErrorCode &status);
     UBool                isChunkWordBoundary(int32_t pos);
 
     const RegexPattern  *fPattern;
     RegexPattern        *fPatternOwned;    // Non-NULL if this matcher owns the pattern, and
                                            //   should delete it when through.
 
     const UnicodeString *fInput;           // The string being matched. Only used for input()
     UText               *fInputText;       // The text being matched. Is never NULL.
     UText               *fAltInputText;    // A shallow copy of the text being matched.
@@ skipping 69 matching lines @@
 
     UErrorCode          fDeferredStatus;   // Save error state that cannot be immediately
                                            //   reported, or that permanently disables this matcher.
 
     RuleBasedBreakIterator  *fWordBreakItr;
 };
 
 U_NAMESPACE_END
 #endif  // UCONFIG_NO_REGULAR_EXPRESSIONS
 #endif