Lines Matching full:the
20 * <p>This is a C wrapper around the C++ RegexPattern and RegexMatcher classes.</p>
36 * Structure representing a compiled regular expression, plus the results
65 /** If set, treat the entire pattern as a literal string.
66 * Metacharacters or escape sequences in the input sequence will be given
69 * The flag UREGEX_CASE_INSENSITIVE retains its impact
71 * The other flags become superfluous.
85 * in the behavior of ., ^, and $.
91 * If set, \b uses the Unicode TR 29 definition of word boundaries.
111 * Open (compile) an ICU regular expression. Compiles the regular expression in
112 * string form into an internal representation using the specified match mode flags.
113 * The resulting regular expression handle can then be used to perform various
117 * @param pattern The Regular Expression pattern to be compiled.
118 * @param patternLength The length of the pattern, or -1 if the pattern is
120 * @param flags Flags that alter the default matching behavior for
121 * the regular expression, UREGEX_CASE_INSENSITIVE, for
125 * @param pe Receives the position (line and column numbers) of any syntax
126 * error within the source regular expression string. If this
140 * Open (compile) an ICU regular expression. Compiles the regular expression in
141 * string form into an internal representation using the specified match mode flags.
142 * The resulting regular expression handle can then be used to perform various
145 * The contents of the pattern UText will be extracted and saved. Ownership of the
146 * UText struct itself remains with the caller. This is to match the behavior of
149 * @param pattern The Regular Expression pattern to be compiled.
150 * @param flags Flags that alter the default matching behavior for
151 * the regular expression, UREGEX_CASE_INSENSITIVE, for
155 * @param pe Receives the position (line and column numbers) of any syntax
156 * error within the source regular expression string. If this
169 * Open (compile) an ICU regular expression. The resulting regular expression
172 * This function is the same as uregex_open, except that the pattern
173 * is supplied as an 8 bit char * string in the default code page.
175 * @param pattern The Regular Expression pattern to be compiled,
177 * @param flags Flags that alter the default matching behavior for
178 * the regular expression, UREGEX_CASE_INSENSITIVE, for
182 * @param pe Receives the position (line and column numbers) of any syntax
183 * error within the source regular expression string. If this
186 * @return The URegularExpression object representing the compiled
202 * Close the regular expression, recovering all resources (memory) it
205 * @param regexp The regular expression to be closed.
218 * For most methods see the LocalPointerBase base class.
232 * expression is faster than opening a second instance from the source
233 * form of the expression, and requires less memory.
235 * Note that the current input string and the position of any matched text
236 * within it are not cloned; only the pattern itself and the
243 * @param regexp The compiled regular expression to be cloned.
245 * @return the cloned copy of the compiled regular expression.
252 * Returns a pointer to the source form of the pattern for this regular expression.
253 * This function will work even if the pattern was originally specified as a UText.
255 * @param regexp The compiled regular expression.
256 * @param patLength This output parameter will be set to the length of the
257 * pattern string. A NULL pointer may be used here if the
258 * pattern length is not needed, as would be the case if
259 * the pattern is known in advance to be a NUL terminated
262 * @return a pointer to the pattern string. The storage for the string is
263 * owned by the regular expression object, and must not be
264 * altered or deleted by the application. The returned string
265 * will remain valid until the regular expression is closed.
274 * Returns the source text of the pattern for this regular expression.
275 * This function will work even if the pattern was originally specified as a UChar string.
277 * @param regexp The compiled regular expression.
279 * @return the pattern text. The storage for the text is owned by the regular expression
289 * Get the match mode flags that were specified when compiling this regular expression.
291 * @param regexp The compiled regular expression.
292 * @return The match mode flags
302 * Set the subject text string upon which the regular expression will look for matches.
303 * This function may be called any number of times, allowing the regular
306 * Regular expression matching operations work directly on the application's
307 * string data. No copy is made. The subject string data must not be
312 * operation will dereference the text string pointer.
314 * @param regexp The compiled regular expression.
315 * @param text The subject text string.
316 * @param textLength The length of the subject text, or -1 if the string
329 * Set the subject text string upon which the regular expression will look for matches.
330 * This function may be called any number of times, allowing the regular
333 * Regular expression matching operations work directly on the application's
334 * string data; only a shallow clone is made. The subject string data must not be
338 * @param regexp The compiled regular expression.
339 * @param text The subject text string.
350 * Get the subject text that is currently associated with this
351 * regular expression object. If the input was supplied using uregex_setText(),
352 * that pointer will be returned. Otherwise, the characters in the input will
354 * with the regular expression object.
356 * This function will work even if the input was originally specified as a UText.
358 * @param regexp The compiled regular expression.
359 * @param textLength The length of the string is returned in this output parameter.
360 * A NULL pointer may be used here if the
361 * text length is not needed, as would be the case if
362 * the text is known in advance to be a NUL terminated
365 * @return Pointer to the subject text string currently associated with
375 * Get the subject text that is currently associated with this
378 * This function will work even if the input was originally specified as a UChar string.
380 * @param regexp The compiled regular expression.
381 * @param dest A mutable UText in which to store the current input.
383 * of the actual input string.
385 * @return The subject text currently associated with this regular expression.
396 * Set the subject text string upon which the regular expression is looking for matches
397 * without changing any other aspect of the matching state.
398 * The new and previous text strings must have the same content.
402 * ICU that the string has been relocated, and providing a new UText to access the
405 * Note that the regular expression implementation never copies the underlying text
406 * of a string being matched, but always operates directly on the original text
407 * provided by the user. Refreshing simply drops the references to the old text
408 * and replaces them with references to the new.
412 * that moves the text in memory.
414 * @param regexp The compiled regular expression.
415 * @param text The new (moved) text string.
426 * Attempts to match the input string against the pattern.
427 * To succeed, the match must extend to the end of the string,
428 * or cover the complete match region.
430 * If startIndex >= zero the match operation starts at the specified
431 * index and must extend to the end of the input string. Any region
434 * If startIndex == -1 the match must cover the input region, or the entire
438 * @param regexp The compiled regular expression.
439 * @param startIndex The input string (native) index at which to begin matching, or -1
440 * to match the input Region.
452 * Attempts to match the input string against the pattern.
453 * To succeed, the match must extend to the end of the string,
454 * or cover the complete match region.
456 * If startIndex >= zero the match operation starts at the specified
457 * index and must extend to the end of the input string. Any region
460 * If startIndex == -1 the match must cover the input region, or the entire
464 * @param regexp The compiled regular expression.
465 * @param startIndex The input string (native) index at which to begin matching, or -1
466 * to match the input Region.
477 * Attempts to match the input string, starting from the specified index, against the pattern.
478 * The match may be of any length, and is not required to extend to the end
479 * of the input string. Contrast with uregex_matches().
482 * URegularExpression is reset before the operation begins.
484 * <p>If the specified starting index == -1 the match begins at the start of the input
485 * region, or at the start of the full string if no region has been specified.
488 * <p>If the match succeeds then more information can be obtained via the
492 * @param regexp The compiled regular expression.
493 * @param startIndex The input string (native) index at which to begin matching, or
494 * -1 to match the Input Region
506 * Attempts to match the input string, starting from the specified index, against the pattern.
507 * The match may be of any length, and is not required to extend to the end
508 * of the input string. Contrast with uregex_matches().
511 * URegularExpression is reset before the operation begins.
513 * <p>If the specified starting index == -1 the match begins at the start of the input
514 * region, or at the start of the full string if no region has been specified.
517 * <p>If the match succeeds then more information can be obtained via the
521 * @param regexp The compiled regular expression.
522 * @param startIndex The input string (native) index at which to begin matching, or
523 * -1 to match the Input Region
534 * Find the first matching substring of the input string that matches the pattern.
535 * If startIndex is >= zero the search for a match begins at the specified index,
539 * If startIndex == -1 the search begins at the start of the input region,
540 * or at the start of the full string if no region has been specified.
543 * <code>uregex_group()</code> will provide more information regarding the match.
545 * @param regexp The compiled regular expression.
546 * @param startIndex The position (native) in the input string to begin the search, or
547 * -1 to search within the Input Region.
559 * Find the first matching substring of the input string that matches the pattern.
560 * If startIndex is >= zero the search for a match begins at the specified index,
564 * If startIndex == -1 the search begins at the start of the input region,
565 * or at the start of the full string if no region has been specified.
568 * <code>uregex_group()</code> will provide more information regarding the match.
570 * @param regexp The compiled regular expression.
571 * @param startIndex The position (native) in the input string to begin the search, or
572 * -1 to search within the Input Region.
583 * Find the next pattern match in the input string. Begin searching
584 * the input at the location following the end of he previous match,
585 * or at the start of the string (or region) if there is no
587 * <code>uregex_group()</code> will provide more information regarding the match.
589 * @param regexp The compiled regular expression.
600 * Get the number of capturing groups in this regular expression's pattern.
601 * @param regexp The compiled regular expression.
603 * @return the number of capture groups
612 * Get the group number corresponding to a named capture group.
613 * The returned number can be used with any function that access
616 * The function returns an error status if the specified name does not
617 * appear in the pattern.
619 * @param regexp The compiled regular expression.
620 * @param groupName The capture group name.
621 * @param nameLength The length of the name, or -1 if the name is a
635 * Get the group number corresponding to a named capture group.
636 * The returned number can be used with any function that access
639 * The function returns an error status if the specified name does not
640 * appear in the pattern.
642 * @param regexp The compiled regular expression.
643 * @param groupName The capture group name,
645 * @param nameLength The length of the name, or -1 if the name is
658 /** Extract the string for the specified matching expression or subexpression.
659 * Group #0 is the complete string of matched text.
660 * Group #1 is the text matched by the first set of capturing parentheses.
662 * @param regexp The compiled regular expression.
663 * @param groupNum The capture group to extract. Group 0 is the complete
664 * match. The value of this parameter must be
665 * less than or equal to the number of capture groups in
666 * the pattern.
667 * @param dest Buffer to receive the matching string data
668 * @param destCapacity Capacity of the dest buffer.
681 /** Returns a shallow immutable clone of the entire input string with the current index set
682 * to the beginning of the requested capture group. The capture group length is also
684 * Group #0 is the complete string of matched text.
685 * Group #1 is the text matched by the first set of capturing parentheses.
687 * @param regexp The compiled regular expression.
688 * @param groupNum The capture group to extract. Group 0 is the complete
689 * match. The value of this parameter must be
690 * less than or equal to the number of capture groups in
691 * the pattern.
692 * @param dest A mutable UText in which to store the current input.
694 * of the entire input string.
695 * @param groupLength The group length of the desired capture group. Output parameter.
697 * @return The subject text currently associated with this regular expression.
711 * Returns the index in the input string of the start of the text matched by the
712 * specified capture group during the previous match operation. Return -1 if
713 * the capture group was not part of the last match.
714 * Group #0 refers to the complete range of matched text.
715 * Group #1 refers to the text matched by the first set of capturing parentheses.
717 * @param regexp The compiled regular expression.
718 * @param groupNum The capture group number
720 * @return the starting (native) position in the input of the text matched
721 * by the specified group.
731 * Returns the index in the input string of the start of the text matched by the
732 * specified capture group during the previous match operation. Return -1 if
733 * the capture group was not part of the last match.
734 * Group #0 refers to the complete range of matched text.
735 * Group #1 refers to the text matched by the first set of capturing parentheses.
737 * @param regexp The compiled regular expression.
738 * @param groupNum The capture group number
740 * @return the starting (native) position in the input of the text matched
741 * by the specified group.
750 * Returns the index in the input string of the position following the end
751 * of the text matched by the specified capture group.
752 * Return -1 if the capture group was not part of the last match.
753 * Group #0 refers to the complete range of matched text.
754 * Group #1 refers to the text matched by the first set of capturing parentheses.
756 * @param regexp The compiled regular expression.
757 * @param groupNum The capture group number
759 * @return the (native) index of the position following the last matched character.
769 * Returns the index in the input string of the position following the end
770 * of the text matched by the specified capture group.
771 * Return -1 if the capture group was not part of the last match.
772 * Group #0 refers to the complete range of matched text.
773 * Group #1 refers to the text matched by the first set of capturing parentheses.
775 * @param regexp The compiled regular expression.
776 * @param groupNum The capture group number
778 * @return the (native) index of the position following the last matched character.
787 * Reset any saved state from the previous match. Has the effect of
788 * causing uregex_findNext to begin at the specified index, and causing
793 * @param regexp The compiled regular expression.
794 * @param index The position (native) in the text at which a
806 * Reset any saved state from the previous match. Has the effect of
807 * causing uregex_findNext to begin at the specified index, and causing
812 * @param regexp The compiled regular expression.
813 * @param index The position (native) in the text at which a
824 * Sets the limits of the matching region for this URegularExpression.
825 * The region is the part of the input string that will be considered when matching.
826 * Invoking this method resets any saved state from the previous match,
827 * then sets the region to start at the index specified by the start parameter
828 * and end at the index specified by the end parameter.
830 * Depending on the transparency and anchoring being used (see useTransparentBounds
832 * at or around the boundaries of the region
834 * The function will fail if start is greater than limit, or if either index
835 * is less than zero or greater than the length of the string being matched.
837 * @param regexp The compiled regular expression.
838 * @param regionStart The (native) index to begin searches at.
839 * @param regionLimit The (native) index to end searches at (exclusive).
851 * Sets the limits of the matching region for this URegularExpression.
852 * The region is the part of the input string that will be considered when matching.
853 * Invoking this method resets any saved state from the previous match,
854 * then sets the region to start at the index specified by the start parameter
855 * and end at the index specified by the end parameter.
857 * Depending on the transparency and anchoring being used (see useTransparentBounds
859 * at or around the boundaries of the region
861 * The function will fail if start is greater than limit, or if either index
862 * is less than zero or greater than the length of the string being matched.
864 * @param regexp The compiled regular expression.
865 * @param regionStart The (native) index to begin searches at.
866 * @param regionLimit The (native) index to end searches at (exclusive).
877 * Set the matching region and the starting index for subsequent matches
879 * This is useful because the usual function for setting the starting
882 * @param regexp The compiled regular expression.
883 * @param regionStart The (native) index to begin searches at.
884 * @param regionLimit The (native) index to end searches at (exclusive).
885 * @param startIndex The index in the input text at which the next
898 * Reports the start index of the matching region. Any matches found are limited to
899 * to the region bounded by regionStart (inclusive) and regionEnd (exclusive).
901 * @param regexp The compiled regular expression.
903 * @return The starting (native) index of this matcher's region.
912 * Reports the start index of the matching region. Any matches found are limited to
913 * to the region bounded by regionStart (inclusive) and regionEnd (exclusive).
915 * @param regexp The compiled regular expression.
917 * @return The starting (native) index of this matcher's region.
925 * Reports the end index (exclusive) of the matching region for this URegularExpression.
926 * Any matches found are limited to to the region bounded by regionStart (inclusive)
929 * @param regexp The compiled regular expression.
931 * @return The ending point (native) of this matcher's region.
940 * Reports the end index (exclusive) of the matching region for this URegularExpression.
941 * Any matches found are limited to to the region bounded by regionStart (inclusive)
944 * @param regexp The compiled regular expression.
946 * @return The ending point (native) of this matcher's region.
954 * Queries the transparency of region bounds for this URegularExpression.
958 * @param regexp The compiled regular expression.
969 * Sets the transparency of region bounds for this URegularExpression.
971 * If the boolean argument is FALSE, then opaque bounds will be used.
973 * Using transparent bounds, the boundaries of the matching region are transparent
975 * see text beyond the boundaries of the region while checking for a match.
977 * With opaque bounds, no text outside of the matching region is visible to lookahead,
982 * @param regexp The compiled regular expression.
997 * @param regexp The compiled regular expression.
1009 * With anchoring bounds, pattern anchors such as ^ and $ will match at the start
1010 * and end of the region. Without Anchoring Bounds, anchors will only match at
1011 * the positions they would in the complete text.
1013 * Anchoring Bounds are the default for regions.
1015 * @param regexp The compiled regular expression.
1026 * Return TRUE if the most recent matching operation touched the
1027 * end of the text being processed. In this case, additional input text could
1028 * change the results of that match.
1030 * @param regexp The compiled regular expression.
1032 * @return TRUE if the most recent match hit the end of input
1040 * Return TRUE the most recent match succeeded and additional input could cause
1042 * might change the match but the match won't be lost. If a match was not found,
1045 * @param regexp The compiled regular expression.
1047 * @return TRUE if more input could cause the most recent match to no longer match.
1059 * Replaces every substring of the input that matches the pattern
1060 * with the given replacement string. This is a convenience function that
1063 * This method scans the input string looking for matches of the pattern.
1064 * Input that is not part of any match is copied unchanged to the
1065 * destination buffer. Matched regions are replaced in the output
1066 * buffer by the replacement string. The replacement string may contain
1067 * references to capture groups; these take the form of $1, $2, etc.
1069 * @param regexp The compiled regular expression.
1070 * @param replacementText A string containing the replacement text.
1071 * @param replacementLength The length of the replacement string, or
1073 * @param destBuf A (UChar *) buffer that will receive the result.
1074 * @param destCapacity The capacity of the destination buffer.
1076 * @return The length of the string resulting from the find
1077 * and replace operation. In the event that the
1078 * destination capacity is inadequate, the return value
1079 * is still the full length of the untruncated string.
1091 * Replaces every substring of the input that matches the pattern
1092 * with the given replacement string. This is a convenience function that
1095 * This method scans the input string looking for matches of the pattern.
1096 * Input that is not part of any match is copied unchanged to the
1097 * destination buffer. Matched regions are replaced in the output
1098 * buffer by the replacement string. The replacement string may contain
1099 * references to capture groups; these take the form of $1, $2, etc.
1101 * @param regexp The compiled regular expression.
1102 * @param replacement A string containing the replacement text.
1103 * @param dest A mutable UText that will receive the result.
1106 * @return A UText containing the results of the find and replace.
1118 * Replaces the first substring of the input that matches the pattern
1119 * with the given replacement string. This is a convenience function that
1122 * This method scans the input string looking for a match of the pattern.
1123 * All input that is not part of the match is copied unchanged to the
1124 * destination buffer. The matched region is replaced in the output
1125 * buffer by the replacement string. The replacement string may contain
1126 * references to capture groups; these take the form of $1, $2, etc.
1128 * @param regexp The compiled regular expression.
1129 * @param replacementText A string containing the replacement text.
1130 * @param replacementLength The length of the replacement string, or
1132 * @param destBuf A (UChar *) buffer that will receive the result.
1133 * @param destCapacity The capacity of the destination buffer.
1135 * @return The length of the string resulting from the find
1136 * and replace operation. In the event that the
1137 * destination capacity is inadequate, the return value
1138 * is still the full length of the untruncated string.
1150 * Replaces the first substring of the input that matches the pattern
1151 * with the given replacement string. This is a convenience function that
1154 * This method scans the input string looking for a match of the pattern.
1155 * All input that is not part of the match is copied unchanged to the
1156 * destination buffer. The matched region is replaced in the output
1157 * buffer by the replacement string. The replacement string may contain
1158 * references to capture groups; these take the form of $1, $2, etc.
1160 * @param regexp The compiled regular expression.
1161 * @param replacement A string containing the replacement text.
1162 * @param dest A mutable UText that will receive the result.
1165 * @return A UText containing the results of the find and replace.
1180 * <p>The input string, starting from the end of the previous match and ending at
1181 * the start of the current match, is appended to the destination string. Then the
1182 * replacement string is appended to the output string,
1187 * designed to be chained, one after another, with the destination
1189 * to for the next. If the destination buffer is exhausted partway through such a
1199 * @param regexp The regular expression object.
1200 * @param replacementText The string that will replace the matched portion of the
1201 * input string as it is copied to the destination buffer.
1202 * The replacement text may contain references ($1, for
1203 * example) to capture groups from the match.
1204 * @param replacementLength The length of the replacement text string,
1205 * or -1 if the string is NUL terminated.
1206 * @param destBuf The buffer into which the results of the
1208 * will be updated to refer to the beginning of the
1211 * @param destCapacity The size of the output buffer, On return, this
1212 * parameter will be updated to reflect the space remaining
1213 * unused in the output buffer.
1215 * @return The length of the result string. In the event that
1216 * destCapacity is inadequate, the full length of the
1234 * <p>The input string, starting from the end of the previous match and ending at
1235 * the start of the current match, is appended to the destination string. Then the
1236 * replacement string is appended to the output string,
1242 * @param regexp The regular expression object.
1243 * @param replacementText The string that will replace the matched portion of the
1244 * input string as it is copied to the destination buffer.
1245 * The replacement text may contain references ($1, for
1246 * example) to capture groups from the match.
1247 * @param dest A mutable UText that will receive the result. Must not be NULL.
1259 * As the final step in a find-and-replace operation, append the remainder
1260 * of the input string, starting at the position following the last match,
1261 * to the destination string. <code>uregex_appendTail()</code> is intended
1262 * to be invoked after one or more invocations of the
1265 * @param regexp The regular expression object. This is needed to
1266 * obtain the input string and with the position
1267 * of the last match within it.
1268 * @param destBuf The buffer in which the results of the
1269 * find-and-replace are placed. On return, the pointer
1270 * will be updated to refer to the beginning of the
1272 * @param destCapacity The size of the output buffer, On return, this
1273 * value will be updated to reflect the space remaining
1274 * unused in the output buffer.
1276 * @return The length of the result string. In the event that
1277 * destCapacity is inadequate, the full length of the
1289 * As the final step in a find-and-replace operation, append the remainder
1290 * of the input string, starting at the position following the last match,
1291 * to the destination string. <code>uregex_appendTailUText()</code> is intended
1292 * to be invoked after one or more invocations of the
1295 * @param regexp The regular expression object. This is needed to
1296 * obtain the input string and with the position
1297 * of the last match within it.
1298 * @param dest A mutable UText that will receive the result. Must not be NULL.
1302 * @return The destination UText.
1313 * The pattern matches identify delimiters that separate the input
1314 * into fields. The input data between the matches becomes the
1317 * Each of the fields is copied from the input string to the destination
1318 * buffer, and NUL terminated. The position of each field within
1319 * the destination buffer is returned in the destFields array.
1321 * If the delimiter pattern includes capture groups, the captured text will
1322 * also appear in the destination array of output strings, interspersed
1323 * with the fields. This is similar to Perl, but differs from Java,
1324 * which ignores the presence of capture groups in the pattern.
1327 * destination capacity. This differs from the default behavior for Java
1330 * The number of strings produced by the split operation is returned.
1331 * This count includes the strings from capture groups in the delimiter pattern.
1334 * @param regexp The compiled regular expression.
1335 * @param destBuf A (UChar *) buffer to receive the fields that
1336 * are extracted from the input string. These
1337 * field pointers will refer to positions within the
1338 * destination buffer supplied by the caller. Any
1339 * extra positions within the destFields array will be
1341 * @param destCapacity The capacity of the destBuf.
1342 * @param requiredCapacity The actual capacity required of the destBuf.
1344 * the total capacity required to hold all of the output, and
1346 * @param destFields An array to be filled with the position of each
1347 * of the extracted fields within destBuf.
1348 * @param destFieldsCapacity The number of elements in the destFields array.
1349 * If the number of fields found is less than destFieldsCapacity,
1350 * the extra destFields elements are set to zero.
1351 * If destFieldsCapacity is too small, the trailing part of the
1353 * were the last field - it is copied to the destBuf, and
1354 * its position is in the destBuf is stored in the last element
1359 * @return The number of fields into which the input string was split.
1373 * The pattern matches identify delimiters that separate the input
1374 * into fields. The input data between the matches becomes the
1377 * The behavior of this function is not very closely aligned with uregex_split();
1378 * instead, it is based on (and implemented directly on top of) the C++ split method.
1380 * @param regexp The compiled regular expression.
1381 * @param destFields An array of mutable UText structs to receive the results of the split.
1382 * If a field is NULL, a new UText is allocated to contain the results for
1384 * @param destFieldsCapacity The number of elements in the destination array.
1385 * If the number of fields found is less than destCapacity, the
1386 * extra strings in the destination array are not altered.
1387 * If the number of destination strings is less than the number
1388 * of fields, the trailing part of the input string, including any
1389 * field delimiters, is placed in the last destination string.
1393 * @return The number of fields into which the input string was split.
1407 * For practical purposes, the match operation may appear to be in an
1409 * When a limit is set a match operation will fail with an error if the
1412 * The units of the limit are steps of the match engine.
1413 * Correspondence with actual processor time will depend on the speed
1414 * of the processor and the details of the specific pattern, but will
1415 * typically be on the order of milliseconds.
1417 * By default, the matching time is not limited.
1420 * @param regexp The compiled regular expression.
1421 * @param limit The limit value, or 0 for no limit.
1431 * Get the time limit for for matches with this URegularExpression.
1434 * @param regexp The compiled regular expression.
1436 * @return the maximum allowed time for a match, in units of processing steps.
1444 * Set the amount of heap storage available for use by the match backtracking stack.
1446 * ICU uses a backtracking regular expression engine, with the backtrack stack
1447 * maintained on the heap. This function sets the limit to the amount of memory
1449 * result in an error from the match operation that caused it.
1452 * excessive memory, potentially crashing the process. A limit is enabled
1455 * @param regexp The compiled regular expression.
1456 * @param limit The maximum size, in bytes, of the matching backtrack stack.
1458 * The limit must be greater than or equal to zero.
1469 * Get the size of the heap storage available for use by the back tracking stack.
1471 * @return the maximum backtracking stack size, in bytes, or zero if the
1483 * operations. If the call back function returns FALSE, the matching
1486 * Note: the callback function must not call other functions on this
1489 * @param context context pointer. The callback function will be invoked
1490 * with the context specified at the time that
1492 * @param steps the accumulated processing time, in match steps,
1494 * @return TRUE to continue the matching operation.
1495 * FALSE to terminate the matching operation.
1506 * During matching operations the function will be called periodically,
1507 * giving the application the opportunity to terminate a long-running
1510 * @param regexp The compiled regular expression.
1511 * @param callback A pointer to the user-supplied callback function.
1512 * @param context User context pointer. The value supplied at the
1513 * time the callback function is set will be saved
1514 * and passed to the callback each time that it is called.
1526 * Get the callback function for this URegularExpression.
1528 * @param regexp The compiled regular expression.
1529 * @param callback Out parameter, receives a pointer to the user-supplied
1531 * @param context Out parameter, receives the user context pointer that
1548 * The callback will usually be called after each attempt at a match, but this is not a
1549 * guarantee that the callback will be invoked at each character. For finds where the
1551 * for more optimized loops where the pattern is known to only start, and the match
1553 * When invoked, this callback will specify the index at which a match operation is about
1554 * to be attempted, giving the application the opportunity to terminate a long-running
1557 * If the call back function returns FALSE, the find operation will be terminated early.
1559 * Note: the callback function must not call other functions on this
1562 * @param context context pointer. The callback function will be invoked
1563 * with the context specified at the time that
1565 * @param matchIndex the next index at which a match attempt will be attempted for this
1566 * find operation. If this callback interrupts the search, this is the
1568 * @return TRUE to continue the matching operation.
1569 * FALSE to terminate the matching operation.
1580 * Set the find progress callback function for this URegularExpression.
1582 * @param regexp The compiled regular expression.
1583 * @param callback A pointer to the user-supplied callback function.
1584 * @param context User context pointer. The value supplied at the
1585 * time the callback function is set will be saved
1586 * and passed to the callback each time that it is called.
1597 * Get the find progress callback function for this URegularExpression.
1599 * @param regexp The compiled regular expression.
1600 * @param callback Out parameter, receives a pointer to the user-supplied
1602 * @param context Out parameter, receives the user context pointer that