Lines Matching defs:pattern
43 * an instance of this class. The resulting pattern can then be used to create
47 * matcher, so many matchers can share the same pattern.
65 * is less efficient since it does not allow the compiled pattern to be reused.
533 * <tt>"\\u2014"</tt>, while not equal, compile into the same pattern, which
807 * Permits whitespace and comments in pattern.
831 * Enables literal parsing of the pattern.
834 * the pattern is treated as a sequence of literal characters.
914 /* Pattern has only two serialized components: The pattern string
915 * and the flags, which are all that is needed to recompile the pattern
923 * The original regular-expression pattern string.
927 private String pattern;
930 * The original pattern flags.
943 * The normalized pattern string.
954 * The root of object tree for a match operation. The pattern is matched
961 * Temporary storage used by parsing pattern slice.
977 * Temporary null terminated code point array used by pattern compiling.
994 * Index into the pattern string that keeps track of how much has been
1000 * Holds the length of the pattern string.
1007 * (1) There is supplementary char in pattern, or
1013 * Compiles the given regular expression into a pattern. </p>
1026 * Compiles the given regular expression into a pattern with the given
1051 * Returns the regular expression from which this pattern was compiled.
1054 * @return The source of this pattern
1056 public String pattern() {
1057 return pattern;
1061 * <p>Returns the string representation of this pattern. This
1062 * is the regular expression from which this pattern was
1065 * @return The string representation of this pattern
1069 return pattern;
1073 * Creates a matcher that will match the given input against this pattern.
1079 * @return A new matcher for this pattern
1093 * Returns this pattern's match flags. </p>
1095 * @return The match flags specified when this pattern was compiled
1115 * <p> If a pattern is to be used multiple times, compiling it once and reusing
1134 * Splits the given input sequence around matches of this pattern.
1138 * this pattern or is terminated by the end of the input sequence. The
1140 * input. If this pattern does not match any subsequence of the input then
1145 * pattern is applied and therefore affects the length of the resulting
1146 * array. If the limit <i>n</i> is greater than zero then the pattern
1150 * is non-positive then the pattern will be applied as many times as
1152 * the pattern will be applied as many times as possible, the array can
1191 * around matches of this pattern
1231 * Splits the given input sequence around matches of this pattern.
1256 * around matches of this pattern
1263 * Returns a literal pattern <code>String</code> for the specified
1268 * <code>s</code> as if it were a literal pattern.</p> Metacharacters
1296 * Recompile the Pattern instance from a stream. The original pattern
1311 if (pattern.length() == 0) {
1319 * This private constructor is used to create all Patterns. The pattern
1321 * a Pattern. An empty pattern string results in an object tree with
1325 pattern = p;
1336 if (pattern.length() > 0) {
1345 * The pattern is converted to normalizedD form and then a pure group
1352 // Convert pattern into normalizedD form
1353 normalizedPattern = Normalizer.normalize(pattern, Normalizer.Form.NFD);
1356 // Modify pattern to match canonical equivalences
1630 normalizedPattern = pattern;
1634 // Copy pattern to int array for convenience
1635 // Use double zero to terminate pattern
1660 // Literal pattern handling
1666 // Check extra pattern characters
1787 * Mark the end of pattern with a specific character.
1920 * Internal method used for handling all syntax errors. The pattern is
5256 * pattern can be shifted farther ahead in the search text if it is
5259 * The pattern is compared to the input one character at a time, from
5260 * the rightmost character in the pattern to the left. If the characters
5261 * all match the pattern has been found. If a character does not match,
5262 * the pattern is shifted right a distance that is the maximum of two
5268 * did not match. If the character does not appear in the pattern, the
5269 * pattern can be shifted completely beyond the bad character. If the
5270 * character does occur in the pattern, the pattern can be shifted to
5271 * line the pattern up with the next occurrence of that character.
5274 * side of the pattern has matched. When a bad character is found, the
5275 * pattern can be shifted right by the pattern length if the subset does
5276 * not occur again in pattern, or by the amount of distance to the
5277 * next occurrence of the subset in the pattern.
5301 // If the pattern is short don't use it, since
5302 // a shift larger than the pattern length cannot
5311 // It is a table for where in the pattern each
5357 // Loop over pattern from right to left
5367 // Entire pattern matched starting at i
5411 // Loop over pattern from right to left
5424 // Entire pattern matched starting at i