8  * particular file as subject to the "Classpath" exception as provided
18  * 2 along with this work; if not, write to the Free Software Foundation,
34  * Pattern#matcher matcher} method.  Once created, a matcher can be used to
39  *   <li><p> The {@link #matches matches} method attempts to match the entire
42  *   <li><p> The {@link #lookingAt lookingAt} method attempts to match the
66  * #appendTail appendTail} methods can be used in tandem in order to collect
68  * #replaceAll replaceAll} method can be used to create a string in which every
78  * <p> The explicit state of a matcher is initially undefined; attempting to
80  * IllegalStateException} to be thrown.  The explicit state of a matcher is
91  * to zero.
118      * The range within the sequence that is to be matched. Anchors
122     int from, to;
125      * Lookbehind uses this value to ensure that the subexpression
137      * match does not have to consume all of the input. ENDANCHOR is
163      * Storage used by nodes to tell what repetition they are on in
165      * so they rely on this field to hold state during a match.
174      * might cause a different match to be found.
176      * input could cause a match to be found.
180      * input will not cause a match to be found.
189      * input could cause the match to be lost.
198      * matcher's region are transparent to lookahead, lookbehind,
199      * and boundary matching constructs that try to see beyond them.
257       * Changes the <tt>Pattern</tt> that this <tt>Matcher</tt> uses to
260       * <p> This method causes this matcher to lose information
292      * and sets its append position to zero. The matcher's region is set to the
308         to = getTextLength();
316      * and sets its append position to zero.  The matcher's region is set to
351      * to right, starting at one.  Group zero denotes the entire pattern, so
352      * the expression <i>m.</i><tt>start(0)</tt> is equivalent to
398      * to right, starting at one.  Group zero denotes the entire pattern, so
399      * the expression <i>m.</i><tt>end(0)</tt> is equivalent to
458      * to right, starting at one.  Group zero denotes the entire pattern, so
459      * the expression <tt>m.group(0)</tt> is equivalent to <tt>m.group()</tt>.
462      * <p> If the match was successful but the group specified failed to match
473      *          failed to match part of the input
498      * <p> If the match was successful but the group specified failed to match
509      *          failed to match part of the input
539      * <p> Any non-negative integer smaller than or equal to the value
540      * returned by this method is guaranteed to be a valid group index for
550      * Attempts to match the entire region against the pattern.
563      * Attempts to find the next subsequence of the input sequence that matches
587         if (nextSearchIndex > to) {
596      * Resets this matcher and then attempts to find the next subsequence of
622      * Attempts to match the input sequence, starting at the beginning of the
650      * @param  s The string to be literalized
676      *   append position, and appends them to the given string buffer.  It
681      *   <li><p> It appends the given replacement string to the string buffer.
684      *   <li><p> It sets the append position of this matcher to the index of
685      *   the last character matched, plus one, that is, to {@link #end()}.
690      * <p> The replacement string may contain references to subsequences
702      * cause <tt>"foobar"</tt> to be appended to the string buffer. A dollar
707      * the replacement string may cause the results to be different than if it
709      * treated as references to captured subsequences as described above, and
710      * backslashes are used to escape literal characters in the replacement
713      * <p> This method is intended to be used in a loop together with the
716      * yard</tt> to the standard-output stream: </p>
741      *          If the replacement string refers to a named-capturing
745      *          If the replacement string refers to a capturing group
754         // Process substitution string to replace group references with groups
851      * the append position, and appends them to the given string buffer.  It is
852      * intended to be invoked after one or more invocations of the {@link
853      * #appendReplacement appendReplacement} method in order to copy the
872      * part of any match are appended directly to the result string; each match
874      * string may contain references to captured subsequences as in the {@link
878      * the replacement string may cause the results to be different than if it
880      * treated as references to captured subsequences as described above, and
881      * backslashes are used to escape literal characters in the replacement
890      * is to be used in further matching operations then it should first be
921      * part of the match are appended directly to the result string; the match
923      * string may contain references to captured subsequences as in the {@link
927      * the replacement string may cause the results to be different than if it
929      * treated as references to captured subsequences as described above, and
930      * backslashes are used to escape literal characters in the replacement
939      * is to be used in further matching operations then it should first be
962      * input sequence that will be searched to find a match. Invoking this
963      * method resets the matcher, and then sets the region to start at the
974      *         The index to start searching at (inclusive)
976      *         The index to end searching at (exclusive)
994         to = end;
1000      * searches this matcher conducts are limited to finding matches
1013      * The searches this matcher conducts are limited to finding matches
1021         return to;
1049      * matcher to use <i>transparent</i> bounds. If the boolean
1053      * matcher's region are transparent to lookahead, lookbehind,
1055      * boundaries of the region to see if a match is appropriate.
1058      * region are opaque to lookahead, lookbehind, and boundary matching
1059      * constructs that may try to see beyond them. Those constructs cannot
1060      * look past the boundaries so they will fail to match anything outside
1065      * @param  b a boolean indicating whether to use opaque or transparent
1100      * matcher to use <i>anchoring</i> bounds. If the boolean
1112      * @param  b a boolean indicating whether or not to use anchoring bounds.
1164      * input could cause the match to be lost. If this method returns false
1178      * Initiates a search to find a Pattern within the given bounds.
1184      * of the start of the search which anchors will set to. The from param
1186      * regex tries to match at that index but ^ won't match there. Subsequent
1187      * calls to the search methods start at a new "soft" boundary which is
1207      * Initiates a search for an anchored match to a Pattern within the given

Indexes created Tue Jul 24 14:28:13 CEST 2018