jdk/src/share/classes/java/util/regex/Pattern.java
author psandoz
Wed, 03 Jul 2013 21:43:49 +0200
changeset 18822 4b6be7c19547
parent 18787 8a57ff107238
child 19577 a6259d4a0211
permissions -rw-r--r--
8019395: Consolidate StreamSupport.{stream,parallelStream} into a single method Reviewed-by: henryjen, briangoetz
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
17447
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
     2
 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4820
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4820
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4820
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4820
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 4820
diff changeset
    23
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package java.util.regex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
import java.text.Normalizer;
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
    29
import java.util.Locale;
17447
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
    30
import java.util.Iterator;
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
    31
import java.util.Map;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
import java.util.ArrayList;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
import java.util.HashMap;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
import java.util.Arrays;
17447
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
    35
import java.util.NoSuchElementException;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
    36
import java.util.Spliterator;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
    37
import java.util.Spliterators;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
    38
import java.util.function.Predicate;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
    39
import java.util.stream.Stream;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
    40
import java.util.stream.StreamSupport;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
 * A compiled representation of a regular expression.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
 * <p> A regular expression, specified as a string, must first be compiled into
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
 * an instance of this class.  The resulting pattern can then be used to create
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
    48
 * a {@link Matcher} object that can match arbitrary {@linkplain
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
    49
 * java.lang.CharSequence character sequences} against the regular
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
 * expression.  All of the state involved in performing a match resides in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
 * matcher, so many matchers can share the same pattern.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
 * <p> A typical invocation sequence is thus
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
 * <blockquote><pre>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
 * Pattern p = Pattern.{@link #compile compile}("a*b");
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
 * Matcher m = p.{@link #matcher matcher}("aaaaab");
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
 * boolean b = m.{@link Matcher#matches matches}();</pre></blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
 * <p> A {@link #matches matches} method is defined by this class as a
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
 * convenience for when a regular expression is used just once.  This method
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
 * compiles an expression and matches an input sequence against it in a single
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
 * invocation.  The statement
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
 * <blockquote><pre>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
 * boolean b = Pattern.matches("a*b", "aaaaab");</pre></blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
 * is equivalent to the three statements above, though for repeated matches it
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
 * is less efficient since it does not allow the compiled pattern to be reused.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
 * <p> Instances of this class are immutable and are safe for use by multiple
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
 * concurrent threads.  Instances of the {@link Matcher} class are not safe for
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
 * such use.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
    76
 * <h3><a name="sum">Summary of regular-expression constructs</a></h3>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
 * <table border="0" cellpadding="1" cellspacing="0"
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
 *  summary="Regular expression constructs, and what they match">
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
 * <tr align="left">
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
    82
 * <th align="left" id="construct">Construct</th>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
    83
 * <th align="left" id="matches">Matches</th>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
 * </tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
 * <tr><th>&nbsp;</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
 * <tr align="left"><th colspan="2" id="characters">Characters</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
 * <tr><td valign="top" headers="construct characters"><i>x</i></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
 *     <td headers="matches">The character <i>x</i></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
 * <tr><td valign="top" headers="construct characters"><tt>\\</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
 *     <td headers="matches">The backslash character</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
 * <tr><td valign="top" headers="construct characters"><tt>\0</tt><i>n</i></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
 *     <td headers="matches">The character with octal value <tt>0</tt><i>n</i>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
 *         (0&nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;7)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
 * <tr><td valign="top" headers="construct characters"><tt>\0</tt><i>nn</i></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
 *     <td headers="matches">The character with octal value <tt>0</tt><i>nn</i>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
 *         (0&nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;7)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
 * <tr><td valign="top" headers="construct characters"><tt>\0</tt><i>mnn</i></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
 *     <td headers="matches">The character with octal value <tt>0</tt><i>mnn</i>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
 *         (0&nbsp;<tt>&lt;=</tt>&nbsp;<i>m</i>&nbsp;<tt>&lt;=</tt>&nbsp;3,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
 *         0&nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;7)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
 * <tr><td valign="top" headers="construct characters"><tt>\x</tt><i>hh</i></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
 *     <td headers="matches">The character with hexadecimal&nbsp;value&nbsp;<tt>0x</tt><i>hh</i></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
 * <tr><td valign="top" headers="construct characters"><tt>&#92;u</tt><i>hhhh</i></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
 *     <td headers="matches">The character with hexadecimal&nbsp;value&nbsp;<tt>0x</tt><i>hhhh</i></td></tr>
8173
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
   107
 * <tr><td valign="top" headers="construct characters"><tt>&#92;x</tt><i>{h...h}</i></td>
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
   108
 *     <td headers="matches">The character with hexadecimal&nbsp;value&nbsp;<tt>0x</tt><i>h...h</i>
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
   109
 *         ({@link java.lang.Character#MIN_CODE_POINT Character.MIN_CODE_POINT}
18156
edb590d448c5 8016217: More javadoc warnings
alanb
parents: 17447
diff changeset
   110
 *         &nbsp;&lt;=&nbsp;<tt>0x</tt><i>h...h</i>&nbsp;&lt;=&nbsp;
8173
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
   111
 *          {@link java.lang.Character#MAX_CODE_POINT Character.MAX_CODE_POINT})</td></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
 * <tr><td valign="top" headers="matches"><tt>\t</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
 *     <td headers="matches">The tab character (<tt>'&#92;u0009'</tt>)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
 * <tr><td valign="top" headers="construct characters"><tt>\n</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
 *     <td headers="matches">The newline (line feed) character (<tt>'&#92;u000A'</tt>)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
 * <tr><td valign="top" headers="construct characters"><tt>\r</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
 *     <td headers="matches">The carriage-return character (<tt>'&#92;u000D'</tt>)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
 * <tr><td valign="top" headers="construct characters"><tt>\f</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
 *     <td headers="matches">The form-feed character (<tt>'&#92;u000C'</tt>)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
 * <tr><td valign="top" headers="construct characters"><tt>\a</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
 *     <td headers="matches">The alert (bell) character (<tt>'&#92;u0007'</tt>)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
 * <tr><td valign="top" headers="construct characters"><tt>\e</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
 *     <td headers="matches">The escape character (<tt>'&#92;u001B'</tt>)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
 * <tr><td valign="top" headers="construct characters"><tt>\c</tt><i>x</i></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
 *     <td headers="matches">The control character corresponding to <i>x</i></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
 * <tr><th>&nbsp;</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
 * <tr align="left"><th colspan="2" id="classes">Character classes</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   130
 * <tr><td valign="top" headers="construct classes">{@code [abc]}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   131
 *     <td headers="matches">{@code a}, {@code b}, or {@code c} (simple class)</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   132
 * <tr><td valign="top" headers="construct classes">{@code [^abc]}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   133
 *     <td headers="matches">Any character except {@code a}, {@code b}, or {@code c} (negation)</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   134
 * <tr><td valign="top" headers="construct classes">{@code [a-zA-Z]}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   135
 *     <td headers="matches">{@code a} through {@code z}
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   136
 *         or {@code A} through {@code Z}, inclusive (range)</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   137
 * <tr><td valign="top" headers="construct classes">{@code [a-d[m-p]]}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   138
 *     <td headers="matches">{@code a} through {@code d},
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   139
 *      or {@code m} through {@code p}: {@code [a-dm-p]} (union)</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   140
 * <tr><td valign="top" headers="construct classes">{@code [a-z&&[def]]}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   141
 *     <td headers="matches">{@code d}, {@code e}, or {@code f} (intersection)</tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   142
 * <tr><td valign="top" headers="construct classes">{@code [a-z&&[^bc]]}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   143
 *     <td headers="matches">{@code a} through {@code z},
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   144
 *         except for {@code b} and {@code c}: {@code [ad-z]} (subtraction)</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   145
 * <tr><td valign="top" headers="construct classes">{@code [a-z&&[^m-p]]}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   146
 *     <td headers="matches">{@code a} through {@code z},
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   147
 *          and not {@code m} through {@code p}: {@code [a-lq-z]}(subtraction)</td></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
 * <tr><th>&nbsp;</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
 * <tr align="left"><th colspan="2" id="predef">Predefined character classes</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
 * <tr><td valign="top" headers="construct predef"><tt>.</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
 *     <td headers="matches">Any character (may or may not match <a href="#lt">line terminators</a>)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
 * <tr><td valign="top" headers="construct predef"><tt>\d</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
 *     <td headers="matches">A digit: <tt>[0-9]</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
 * <tr><td valign="top" headers="construct predef"><tt>\D</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
 *     <td headers="matches">A non-digit: <tt>[^0-9]</tt></td></tr>
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   158
 * <tr><td valign="top" headers="construct predef"><tt>\h</tt></td>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   159
 *     <td headers="matches">A horizontal whitespace character:
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   160
 *     <tt>[ \t\xA0&#92;u1680&#92;u180e&#92;u2000-&#92;u200a&#92;u202f&#92;u205f&#92;u3000]</tt></td></tr>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   161
 * <tr><td valign="top" headers="construct predef"><tt>\H</tt></td>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   162
 *     <td headers="matches">A non-horizontal whitespace character: <tt>[^\h]</tt></td></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
 * <tr><td valign="top" headers="construct predef"><tt>\s</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
 *     <td headers="matches">A whitespace character: <tt>[ \t\n\x0B\f\r]</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
 * <tr><td valign="top" headers="construct predef"><tt>\S</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
 *     <td headers="matches">A non-whitespace character: <tt>[^\s]</tt></td></tr>
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   167
 * <tr><td valign="top" headers="construct predef"><tt>\v</tt></td>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   168
 *     <td headers="matches">A vertical whitespace character: <tt>[\n\x0B\f\r\x85&#92;u2028&#92;u2029]</tt>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   169
 *     </td></tr>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   170
 * <tr><td valign="top" headers="construct predef"><tt>\V</tt></td>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   171
 *     <td headers="matches">A non-vertical whitespace character: <tt>[^\v]</tt></td></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
 * <tr><td valign="top" headers="construct predef"><tt>\w</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
 *     <td headers="matches">A word character: <tt>[a-zA-Z_0-9]</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
 * <tr><td valign="top" headers="construct predef"><tt>\W</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
 *     <td headers="matches">A non-word character: <tt>[^\w]</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
 * <tr><th>&nbsp;</th></tr>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   177
 * <tr align="left"><th colspan="2" id="posix"><b>POSIX character classes (US-ASCII only)</b></th></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   179
 * <tr><td valign="top" headers="construct posix">{@code \p{Lower}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   180
 *     <td headers="matches">A lower-case alphabetic character: {@code [a-z]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   181
 * <tr><td valign="top" headers="construct posix">{@code \p{Upper}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   182
 *     <td headers="matches">An upper-case alphabetic character:{@code [A-Z]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   183
 * <tr><td valign="top" headers="construct posix">{@code \p{ASCII}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   184
 *     <td headers="matches">All ASCII:{@code [\x00-\x7F]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   185
 * <tr><td valign="top" headers="construct posix">{@code \p{Alpha}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   186
 *     <td headers="matches">An alphabetic character:{@code [\p{Lower}\p{Upper}]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   187
 * <tr><td valign="top" headers="construct posix">{@code \p{Digit}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   188
 *     <td headers="matches">A decimal digit: {@code [0-9]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   189
 * <tr><td valign="top" headers="construct posix">{@code \p{Alnum}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   190
 *     <td headers="matches">An alphanumeric character:{@code [\p{Alpha}\p{Digit}]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   191
 * <tr><td valign="top" headers="construct posix">{@code \p{Punct}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   192
 *     <td headers="matches">Punctuation: One of {@code !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   193
 *     <!-- {@code [\!"#\$%&'\(\)\*\+,\-\./:;\<=\>\?@\[\\\]\^_`\{\|\}~]}
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   194
 *          {@code [\X21-\X2F\X31-\X40\X5B-\X60\X7B-\X7E]} -->
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   195
 * <tr><td valign="top" headers="construct posix">{@code \p{Graph}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   196
 *     <td headers="matches">A visible character: {@code [\p{Alnum}\p{Punct}]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   197
 * <tr><td valign="top" headers="construct posix">{@code \p{Print}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   198
 *     <td headers="matches">A printable character: {@code [\p{Graph}\x20]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   199
 * <tr><td valign="top" headers="construct posix">{@code \p{Blank}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   200
 *     <td headers="matches">A space or a tab: {@code [ \t]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   201
 * <tr><td valign="top" headers="construct posix">{@code \p{Cntrl}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   202
 *     <td headers="matches">A control character: {@code [\x00-\x1F\x7F]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   203
 * <tr><td valign="top" headers="construct posix">{@code \p{XDigit}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   204
 *     <td headers="matches">A hexadecimal digit: {@code [0-9a-fA-F]}</td></tr>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   205
 * <tr><td valign="top" headers="construct posix">{@code \p{Space}}</td>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   206
 *     <td headers="matches">A whitespace character: {@code [ \t\n\x0B\f\r]}</td></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
 * <tr><th>&nbsp;</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
 * <tr align="left"><th colspan="2">java.lang.Character classes (simple <a href="#jcc">java character type</a>)</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
 * <tr><td valign="top"><tt>\p{javaLowerCase}</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
 *     <td>Equivalent to java.lang.Character.isLowerCase()</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
 * <tr><td valign="top"><tt>\p{javaUpperCase}</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
 *     <td>Equivalent to java.lang.Character.isUpperCase()</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
 * <tr><td valign="top"><tt>\p{javaWhitespace}</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
 *     <td>Equivalent to java.lang.Character.isWhitespace()</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
 * <tr><td valign="top"><tt>\p{javaMirrored}</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
 *     <td>Equivalent to java.lang.Character.isMirrored()</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
 * <tr><th>&nbsp;</th></tr>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   221
 * <tr align="left"><th colspan="2" id="unicode">Classes for Unicode scripts, blocks, categories and binary properties</th></tr>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   222
 * * <tr><td valign="top" headers="construct unicode">{@code \p{IsLatin}}</td>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   223
 *     <td headers="matches">A Latin&nbsp;script character (<a href="#usc">script</a>)</td></tr>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   224
 * <tr><td valign="top" headers="construct unicode">{@code \p{InGreek}}</td>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   225
 *     <td headers="matches">A character in the Greek&nbsp;block (<a href="#ubc">block</a>)</td></tr>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   226
 * <tr><td valign="top" headers="construct unicode">{@code \p{Lu}}</td>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   227
 *     <td headers="matches">An uppercase letter (<a href="#ucc">category</a>)</td></tr>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   228
 * <tr><td valign="top" headers="construct unicode">{@code \p{IsAlphabetic}}</td>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   229
 *     <td headers="matches">An alphabetic character (<a href="#ubpc">binary property</a>)</td></tr>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   230
 * <tr><td valign="top" headers="construct unicode">{@code \p{Sc}}</td>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
 *     <td headers="matches">A currency symbol</td></tr>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   232
 * <tr><td valign="top" headers="construct unicode">{@code \P{InGreek}}</td>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
 *     <td headers="matches">Any character except one in the Greek block (negation)</td></tr>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   234
 * <tr><td valign="top" headers="construct unicode">{@code [\p{L}&&[^\p{Lu}]]}</td>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
 *     <td headers="matches">Any letter except an uppercase letter (subtraction)</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
 * <tr><th>&nbsp;</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
 * <tr align="left"><th colspan="2" id="bounds">Boundary matchers</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
 * <tr><td valign="top" headers="construct bounds"><tt>^</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
 *     <td headers="matches">The beginning of a line</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
 * <tr><td valign="top" headers="construct bounds"><tt>$</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
 *     <td headers="matches">The end of a line</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
 * <tr><td valign="top" headers="construct bounds"><tt>\b</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
 *     <td headers="matches">A word boundary</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
 * <tr><td valign="top" headers="construct bounds"><tt>\B</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
 *     <td headers="matches">A non-word boundary</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
 * <tr><td valign="top" headers="construct bounds"><tt>\A</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
 *     <td headers="matches">The beginning of the input</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
 * <tr><td valign="top" headers="construct bounds"><tt>\G</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
 *     <td headers="matches">The end of the previous match</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
 * <tr><td valign="top" headers="construct bounds"><tt>\Z</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
 *     <td headers="matches">The end of the input but for the final
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
 *         <a href="#lt">terminator</a>, if&nbsp;any</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
 * <tr><td valign="top" headers="construct bounds"><tt>\z</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
 *     <td headers="matches">The end of the input</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
 * <tr><th>&nbsp;</th></tr>
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   259
 * <tr align="left"><th colspan="2" id="lineending">Linebreak matcher</th></tr>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   260
 * <tr><td valign="top" headers="construct lineending"><tt>\R</tt></td>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   261
 *     <td headers="matches">Any Unicode linebreak sequence, is equivalent to
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   262
 *     <tt>&#92;u000D&#92;u000A|[&#92;u000A&#92;u000B&#92;u000C&#92;u000D&#92;u0085&#92;u2028&#92;u2029]
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   263
 *     </tt></td></tr>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   264
 *
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   265
 * <tr><th>&nbsp;</th></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
 * <tr align="left"><th colspan="2" id="greedy">Greedy quantifiers</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
 * <tr><td valign="top" headers="construct greedy"><i>X</i><tt>?</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
 *     <td headers="matches"><i>X</i>, once or not at all</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
 * <tr><td valign="top" headers="construct greedy"><i>X</i><tt>*</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
 *     <td headers="matches"><i>X</i>, zero or more times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
 * <tr><td valign="top" headers="construct greedy"><i>X</i><tt>+</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
 *     <td headers="matches"><i>X</i>, one or more times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
 * <tr><td valign="top" headers="construct greedy"><i>X</i><tt>{</tt><i>n</i><tt>}</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
 *     <td headers="matches"><i>X</i>, exactly <i>n</i> times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
 * <tr><td valign="top" headers="construct greedy"><i>X</i><tt>{</tt><i>n</i><tt>,}</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
 *     <td headers="matches"><i>X</i>, at least <i>n</i> times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
 * <tr><td valign="top" headers="construct greedy"><i>X</i><tt>{</tt><i>n</i><tt>,</tt><i>m</i><tt>}</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
 *     <td headers="matches"><i>X</i>, at least <i>n</i> but not more than <i>m</i> times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
 * <tr><th>&nbsp;</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
 * <tr align="left"><th colspan="2" id="reluc">Reluctant quantifiers</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
 * <tr><td valign="top" headers="construct reluc"><i>X</i><tt>??</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
 *     <td headers="matches"><i>X</i>, once or not at all</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
 * <tr><td valign="top" headers="construct reluc"><i>X</i><tt>*?</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
 *     <td headers="matches"><i>X</i>, zero or more times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
 * <tr><td valign="top" headers="construct reluc"><i>X</i><tt>+?</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
 *     <td headers="matches"><i>X</i>, one or more times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
 * <tr><td valign="top" headers="construct reluc"><i>X</i><tt>{</tt><i>n</i><tt>}?</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
 *     <td headers="matches"><i>X</i>, exactly <i>n</i> times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
 * <tr><td valign="top" headers="construct reluc"><i>X</i><tt>{</tt><i>n</i><tt>,}?</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
 *     <td headers="matches"><i>X</i>, at least <i>n</i> times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
 * <tr><td valign="top" headers="construct reluc"><i>X</i><tt>{</tt><i>n</i><tt>,</tt><i>m</i><tt>}?</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
 *     <td headers="matches"><i>X</i>, at least <i>n</i> but not more than <i>m</i> times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
 * <tr><th>&nbsp;</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
 * <tr align="left"><th colspan="2" id="poss">Possessive quantifiers</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
 * <tr><td valign="top" headers="construct poss"><i>X</i><tt>?+</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
 *     <td headers="matches"><i>X</i>, once or not at all</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
 * <tr><td valign="top" headers="construct poss"><i>X</i><tt>*+</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
 *     <td headers="matches"><i>X</i>, zero or more times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
 * <tr><td valign="top" headers="construct poss"><i>X</i><tt>++</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
 *     <td headers="matches"><i>X</i>, one or more times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
 * <tr><td valign="top" headers="construct poss"><i>X</i><tt>{</tt><i>n</i><tt>}+</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
 *     <td headers="matches"><i>X</i>, exactly <i>n</i> times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
 * <tr><td valign="top" headers="construct poss"><i>X</i><tt>{</tt><i>n</i><tt>,}+</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
 *     <td headers="matches"><i>X</i>, at least <i>n</i> times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
 * <tr><td valign="top" headers="construct poss"><i>X</i><tt>{</tt><i>n</i><tt>,</tt><i>m</i><tt>}+</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
 *     <td headers="matches"><i>X</i>, at least <i>n</i> but not more than <i>m</i> times</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
 * <tr><th>&nbsp;</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
 * <tr align="left"><th colspan="2" id="logical">Logical operators</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
 * <tr><td valign="top" headers="construct logical"><i>XY</i></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
 *     <td headers="matches"><i>X</i> followed by <i>Y</i></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
 * <tr><td valign="top" headers="construct logical"><i>X</i><tt>|</tt><i>Y</i></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
 *     <td headers="matches">Either <i>X</i> or <i>Y</i></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
 * <tr><td valign="top" headers="construct logical"><tt>(</tt><i>X</i><tt>)</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
 *     <td headers="matches">X, as a <a href="#cg">capturing group</a></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
 * <tr><th>&nbsp;</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
 * <tr align="left"><th colspan="2" id="backref">Back references</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
 * <tr><td valign="bottom" headers="construct backref"><tt>\</tt><i>n</i></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
 *     <td valign="bottom" headers="matches">Whatever the <i>n</i><sup>th</sup>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
 *     <a href="#cg">capturing group</a> matched</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
 *
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   330
 * <tr><td valign="bottom" headers="construct backref"><tt>\</tt><i>k</i>&lt;<i>name</i>&gt;</td>
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   331
 *     <td valign="bottom" headers="matches">Whatever the
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   332
 *     <a href="#groupname">named-capturing group</a> "name" matched</td></tr>
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   333
 *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
 * <tr><th>&nbsp;</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
 * <tr align="left"><th colspan="2" id="quot">Quotation</th></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
 * <tr><td valign="top" headers="construct quot"><tt>\</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
 *     <td headers="matches">Nothing, but quotes the following character</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
 * <tr><td valign="top" headers="construct quot"><tt>\Q</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
 *     <td headers="matches">Nothing, but quotes all characters until <tt>\E</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
 * <tr><td valign="top" headers="construct quot"><tt>\E</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
 *     <td headers="matches">Nothing, but ends quoting started by <tt>\Q</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
 *     <!-- Metachars: !$()*+.<>?[\]^{|} -->
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
 * <tr><th>&nbsp;</th></tr>
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   346
 * <tr align="left"><th colspan="2" id="special">Special constructs (named-capturing and non-capturing)</th></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
 *
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   348
 * <tr><td valign="top" headers="construct special"><tt>(?&lt;<a href="#groupname">name</a>&gt;</tt><i>X</i><tt>)</tt></td>
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   349
 *     <td headers="matches"><i>X</i>, as a named-capturing group</td></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
 * <tr><td valign="top" headers="construct special"><tt>(?:</tt><i>X</i><tt>)</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
 *     <td headers="matches"><i>X</i>, as a non-capturing group</td></tr>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   352
 * <tr><td valign="top" headers="construct special"><tt>(?idmsuxU-idmsuxU)&nbsp;</tt></td>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
 *     <td headers="matches">Nothing, but turns match flags <a href="#CASE_INSENSITIVE">i</a>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
 * <a href="#UNIX_LINES">d</a> <a href="#MULTILINE">m</a> <a href="#DOTALL">s</a>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   355
 * <a href="#UNICODE_CASE">u</a> <a href="#COMMENTS">x</a> <a href="#UNICODE_CHARACTER_CLASS">U</a>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   356
 * on - off</td></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
 * <tr><td valign="top" headers="construct special"><tt>(?idmsux-idmsux:</tt><i>X</i><tt>)</tt>&nbsp;&nbsp;</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
 *     <td headers="matches"><i>X</i>, as a <a href="#cg">non-capturing group</a> with the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
 *         given flags <a href="#CASE_INSENSITIVE">i</a> <a href="#UNIX_LINES">d</a>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
 * <a href="#MULTILINE">m</a> <a href="#DOTALL">s</a> <a href="#UNICODE_CASE">u</a >
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
 * <a href="#COMMENTS">x</a> on - off</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
 * <tr><td valign="top" headers="construct special"><tt>(?=</tt><i>X</i><tt>)</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
 *     <td headers="matches"><i>X</i>, via zero-width positive lookahead</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
 * <tr><td valign="top" headers="construct special"><tt>(?!</tt><i>X</i><tt>)</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
 *     <td headers="matches"><i>X</i>, via zero-width negative lookahead</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
 * <tr><td valign="top" headers="construct special"><tt>(?&lt;=</tt><i>X</i><tt>)</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
 *     <td headers="matches"><i>X</i>, via zero-width positive lookbehind</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
 * <tr><td valign="top" headers="construct special"><tt>(?&lt;!</tt><i>X</i><tt>)</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
 *     <td headers="matches"><i>X</i>, via zero-width negative lookbehind</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
 * <tr><td valign="top" headers="construct special"><tt>(?&gt;</tt><i>X</i><tt>)</tt></td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
 *     <td headers="matches"><i>X</i>, as an independent, non-capturing group</td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
 * </table>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
 * <hr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   376
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   378
 * <h3><a name="bs">Backslashes, escapes, and quoting</a></h3>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
 * <p> The backslash character (<tt>'\'</tt>) serves to introduce escaped
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
 * constructs, as defined in the table above, as well as to quote characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
 * that otherwise would be interpreted as unescaped constructs.  Thus the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
 * expression <tt>\\</tt> matches a single backslash and <tt>\{</tt> matches a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
 * left brace.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
 * <p> It is an error to use a backslash prior to any alphabetic character that
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
 * does not denote an escaped construct; these are reserved for future
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
 * extensions to the regular-expression language.  A backslash may be used
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
 * prior to a non-alphabetic character regardless of whether that character is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
 * part of an unescaped construct.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   392
 * <p> Backslashes within string literals in Java source code are interpreted
9266
121fb370f179 7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents: 8173
diff changeset
   393
 * as required by
121fb370f179 7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents: 8173
diff changeset
   394
 * <cite>The Java&trade; Language Specification</cite>
121fb370f179 7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents: 8173
diff changeset
   395
 * as either Unicode escapes (section 3.3) or other character escapes (section 3.10.6)
121fb370f179 7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents: 8173
diff changeset
   396
 * It is therefore necessary to double backslashes in string
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
 * literals that represent regular expressions to protect them from
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
 * interpretation by the Java bytecode compiler.  The string literal
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
 * <tt>"&#92;b"</tt>, for example, matches a single backspace character when
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
 * interpreted as a regular expression, while <tt>"&#92;&#92;b"</tt> matches a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
 * word boundary.  The string literal <tt>"&#92;(hello&#92;)"</tt> is illegal
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
 * and leads to a compile-time error; in order to match the string
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
 * <tt>(hello)</tt> the string literal <tt>"&#92;&#92;(hello&#92;&#92;)"</tt>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
 * must be used.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   406
 * <h3><a name="cc">Character Classes</a></h3>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
 *    <p> Character classes may appear within other character classes, and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
 *    may be composed by the union operator (implicit) and the intersection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
 *    operator (<tt>&amp;&amp;</tt>).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
 *    The union operator denotes a class that contains every character that is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
 *    in at least one of its operand classes.  The intersection operator
90ce3da70b43 Initial load
duke
parents:
diff changeset
   413
 *    denotes a class that contains every character that is in both of its
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
 *    operand classes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   416
 *    <p> The precedence of character-class operators is as follows, from
90ce3da70b43 Initial load
duke
parents:
diff changeset
   417
 *    highest to lowest:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   418
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
 *    <blockquote><table border="0" cellpadding="1" cellspacing="0"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   420
 *                 summary="Precedence of character class operators.">
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
 *      <tr><th>1&nbsp;&nbsp;&nbsp;&nbsp;</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
 *        <td>Literal escape&nbsp;&nbsp;&nbsp;&nbsp;</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
 *        <td><tt>\x</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
 *     <tr><th>2&nbsp;&nbsp;&nbsp;&nbsp;</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
 *        <td>Grouping</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
 *        <td><tt>[...]</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   427
 *     <tr><th>3&nbsp;&nbsp;&nbsp;&nbsp;</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   428
 *        <td>Range</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   429
 *        <td><tt>a-z</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   430
 *      <tr><th>4&nbsp;&nbsp;&nbsp;&nbsp;</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
 *        <td>Union</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   432
 *        <td><tt>[a-e][i-u]</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
 *      <tr><th>5&nbsp;&nbsp;&nbsp;&nbsp;</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
 *        <td>Intersection</td>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   435
 *        <td>{@code [a-z&&[aeiou]]}</td></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
 *    </table></blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   437
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   438
 *    <p> Note that a different set of metacharacters are in effect inside
90ce3da70b43 Initial load
duke
parents:
diff changeset
   439
 *    a character class than outside a character class. For instance, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   440
 *    regular expression <tt>.</tt> loses its special meaning inside a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   441
 *    character class, while the expression <tt>-</tt> becomes a range
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
 *    forming metacharacter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   443
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   444
 * <h3><a name="lt">Line terminators</a></h3>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   445
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   446
 * <p> A <i>line terminator</i> is a one- or two-character sequence that marks
90ce3da70b43 Initial load
duke
parents:
diff changeset
   447
 * the end of a line of the input character sequence.  The following are
90ce3da70b43 Initial load
duke
parents:
diff changeset
   448
 * recognized as line terminators:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
 * <ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
 *   <li> A newline (line feed) character&nbsp;(<tt>'\n'</tt>),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
 *   <li> A carriage-return character followed immediately by a newline
90ce3da70b43 Initial load
duke
parents:
diff changeset
   455
 *   character&nbsp;(<tt>"\r\n"</tt>),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   456
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   457
 *   <li> A standalone carriage-return character&nbsp;(<tt>'\r'</tt>),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   458
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
 *   <li> A next-line character&nbsp;(<tt>'&#92;u0085'</tt>),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   460
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
 *   <li> A line-separator character&nbsp;(<tt>'&#92;u2028'</tt>), or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
 *   <li> A paragraph-separator character&nbsp;(<tt>'&#92;u2029</tt>).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
 * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
 * <p>If {@link #UNIX_LINES} mode is activated, then the only line terminators
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
 * recognized are newline characters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   468
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   469
 * <p> The regular expression <tt>.</tt> matches any character except a line
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
 * terminator unless the {@link #DOTALL} flag is specified.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   472
 * <p> By default, the regular expressions <tt>^</tt> and <tt>$</tt> ignore
90ce3da70b43 Initial load
duke
parents:
diff changeset
   473
 * line terminators and only match at the beginning and the end, respectively,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   474
 * of the entire input sequence. If {@link #MULTILINE} mode is activated then
90ce3da70b43 Initial load
duke
parents:
diff changeset
   475
 * <tt>^</tt> matches at the beginning of input and after any line terminator
90ce3da70b43 Initial load
duke
parents:
diff changeset
   476
 * except at the end of input. When in {@link #MULTILINE} mode <tt>$</tt>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
 * matches just before a line terminator or the end of the input sequence.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   479
 * <h3><a name="cg">Groups and capturing</a></h3>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   481
 * <h4><a name="gnumber">Group number</a></h4>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
 * <p> Capturing groups are numbered by counting their opening parentheses from
90ce3da70b43 Initial load
duke
parents:
diff changeset
   483
 * left to right.  In the expression <tt>((A)(B(C)))</tt>, for example, there
90ce3da70b43 Initial load
duke
parents:
diff changeset
   484
 * are four such groups: </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   485
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
 * <blockquote><table cellpadding=1 cellspacing=0 summary="Capturing group numberings">
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
 * <tr><th>1&nbsp;&nbsp;&nbsp;&nbsp;</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   488
 *     <td><tt>((A)(B(C)))</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
 * <tr><th>2&nbsp;&nbsp;&nbsp;&nbsp;</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
 *     <td><tt>(A)</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   491
 * <tr><th>3&nbsp;&nbsp;&nbsp;&nbsp;</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   492
 *     <td><tt>(B(C))</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   493
 * <tr><th>4&nbsp;&nbsp;&nbsp;&nbsp;</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   494
 *     <td><tt>(C)</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   495
 * </table></blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   496
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   497
 * <p> Group zero always stands for the entire expression.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
 * <p> Capturing groups are so named because, during a match, each subsequence
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
 * of the input sequence that matches such a group is saved.  The captured
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
 * subsequence may be used later in the expression, via a back reference, and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   502
 * may also be retrieved from the matcher once the match operation is complete.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   504
 * <h4><a name="groupname">Group name</a></h4>
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   505
 * <p>A capturing group can also be assigned a "name", a <tt>named-capturing group</tt>,
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   506
 * and then be back-referenced later by the "name". Group names are composed of
4161
679d00486dc6 6878475: Better syntax for the named capture group in regex
sherman
parents: 2291
diff changeset
   507
 * the following characters. The first character must be a <tt>letter</tt>.
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   508
 *
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   509
 * <ul>
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   510
 *   <li> The uppercase letters <tt>'A'</tt> through <tt>'Z'</tt>
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   511
 *        (<tt>'&#92;u0041'</tt>&nbsp;through&nbsp;<tt>'&#92;u005a'</tt>),
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   512
 *   <li> The lowercase letters <tt>'a'</tt> through <tt>'z'</tt>
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   513
 *        (<tt>'&#92;u0061'</tt>&nbsp;through&nbsp;<tt>'&#92;u007a'</tt>),
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   514
 *   <li> The digits <tt>'0'</tt> through <tt>'9'</tt>
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   515
 *        (<tt>'&#92;u0030'</tt>&nbsp;through&nbsp;<tt>'&#92;u0039'</tt>),
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   516
 * </ul>
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   517
 *
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   518
 * <p> A <tt>named-capturing group</tt> is still numbered as described in
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   519
 * <a href="#gnumber">Group number</a>.
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   520
 *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
 * <p> The captured input associated with a group is always the subsequence
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
 * that the group most recently matched.  If a group is evaluated a second time
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
 * because of quantification then its previously-captured value, if any, will
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
 * be retained if the second evaluation fails.  Matching the string
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
 * <tt>"aba"</tt> against the expression <tt>(a(b)?)+</tt>, for example, leaves
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
 * group two set to <tt>"b"</tt>.  All captured input is discarded at the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
 * beginning of each match.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
 *
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   529
 * <p> Groups beginning with <tt>(?</tt> are either pure, <i>non-capturing</i> groups
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   530
 * that do not capture text and do not count towards the group total, or
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   531
 * <i>named-capturing</i> group.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   533
 * <h3> Unicode support </h3>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
 * <p> This class is in conformance with Level 1 of <a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
 * href="http://www.unicode.org/reports/tr18/"><i>Unicode Technical
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   537
 * Standard #18: Unicode Regular Expression</i></a>, plus RL2.1
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
 * Canonical Equivalents.
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   539
 * <p>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   540
 * <b>Unicode escape sequences</b> such as <tt>&#92;u2014</tt> in Java source code
9266
121fb370f179 7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents: 8173
diff changeset
   541
 * are processed as described in section 3.3 of
121fb370f179 7032960: API files in java.awt need to be updated for references to JVM Spec with editions/hyperlinks
jjh
parents: 8173
diff changeset
   542
 * <cite>The Java&trade; Language Specification</cite>.
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   543
 * Such escape sequences are also implemented directly by the regular-expression
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   544
 * parser so that Unicode escapes can be used in expressions that are read from
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   545
 * files or from the keyboard.  Thus the strings <tt>"&#92;u2014"</tt> and
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   546
 * <tt>"\\u2014"</tt>, while not equal, compile into the same pattern, which
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   547
 * matches the character with hexadecimal value <tt>0x2014</tt>.
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   548
 * <p>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   549
 * A Unicode character can also be represented in a regular-expression by
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   550
 * using its <b>Hex notation</b>(hexadecimal code point value) directly as described in construct
8173
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
   551
 * <tt>&#92;x{...}</tt>, for example a supplementary character U+2011F
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
   552
 * can be specified as <tt>&#92;x{2011F}</tt>, instead of two consecutive
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
   553
 * Unicode escape sequences of the surrogate pair
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
   554
 * <tt>&#92;uD840</tt><tt>&#92;uDD1F</tt>.
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   555
 * <p>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   556
 * Unicode scripts, blocks, categories and binary properties are written with
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   557
 * the <tt>\p</tt> and <tt>\P</tt> constructs as in Perl.
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   558
 * <tt>\p{</tt><i>prop</i><tt>}</tt> matches if
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   559
 * the input has the property <i>prop</i>, while <tt>\P{</tt><i>prop</i><tt>}</tt>
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   560
 * does not match if the input has that property.
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   561
 * <p>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   562
 * Scripts, blocks, categories and binary properties can be used both inside
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   563
 * and outside of a character class.
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   564
 *
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   565
 * <p>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   566
 * <b><a name="usc">Scripts</a></b> are specified either with the prefix {@code Is}, as in
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   567
 * {@code IsHiragana}, or by using  the {@code script} keyword (or its short
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   568
 * form {@code sc})as in {@code script=Hiragana} or {@code sc=Hiragana}.
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   569
 * <p>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   570
 * The script names supported by <code>Pattern</code> are the valid script names
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   571
 * accepted and defined by
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   572
 * {@link java.lang.Character.UnicodeScript#forName(String) UnicodeScript.forName}.
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   573
 *
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   574
 * <p>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   575
 * <b><a name="ubc">Blocks</a></b> are specified with the prefix {@code In}, as in
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   576
 * {@code InMongolian}, or by using the keyword {@code block} (or its short
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   577
 * form {@code blk}) as in {@code block=Mongolian} or {@code blk=Mongolian}.
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   578
 * <p>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   579
 * The block names supported by <code>Pattern</code> are the valid block names
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   580
 * accepted and defined by
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   581
 * {@link java.lang.Character.UnicodeBlock#forName(String) UnicodeBlock.forName}.
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   582
 * <p>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   583
 *
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   584
 * <b><a name="ucc">Categories</a></b> may be specified with the optional prefix {@code Is}:
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   585
 * Both {@code \p{L}} and {@code \p{IsL}} denote the category of Unicode
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   586
 * letters. Same as scripts and blocks, categories can also be specified
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   587
 * by using the keyword {@code general_category} (or its short form
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   588
 * {@code gc}) as in {@code general_category=Lu} or {@code gc=Lu}.
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   589
 * <p>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   590
 * The supported categories are those of
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   591
 * <a href="http://www.unicode.org/unicode/standard/standard.html">
90ce3da70b43 Initial load
duke
parents:
diff changeset
   592
 * <i>The Unicode Standard</i></a> in the version specified by the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   593
 * {@link java.lang.Character Character} class. The category names are those
90ce3da70b43 Initial load
duke
parents:
diff changeset
   594
 * defined in the Standard, both normative and informative.
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   595
 * <p>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   596
 *
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   597
 * <b><a name="ubpc">Binary properties</a></b> are specified with the prefix {@code Is}, as in
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   598
 * {@code IsAlphabetic}. The supported binary properties by <code>Pattern</code>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   599
 * are
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   600
 * <ul>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   601
 *   <li> Alphabetic
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   602
 *   <li> Ideographic
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   603
 *   <li> Letter
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   604
 *   <li> Lowercase
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   605
 *   <li> Uppercase
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   606
 *   <li> Titlecase
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   607
 *   <li> Punctuation
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   608
 *   <Li> Control
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   609
 *   <li> White_Space
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   610
 *   <li> Digit
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   611
 *   <li> Hex_Digit
17434
4a04d7127e80 8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents: 17183
diff changeset
   612
 *   <li> Join_Control
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   613
 *   <li> Noncharacter_Code_Point
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   614
 *   <li> Assigned
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   615
 * </ul>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   616
 * <p>
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   617
 * The following <b>Predefined Character classes</b> and <b>POSIX character classes</b>
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
   618
 * are in conformance with the recommendation of <i>Annex C: Compatibility Properties</i>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   619
 * of <a href="http://www.unicode.org/reports/tr18/"><i>Unicode Regular Expression
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   620
 * </i></a>, when {@link #UNICODE_CHARACTER_CLASS} flag is specified.
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
   621
 * <p>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   622
 * <table border="0" cellpadding="1" cellspacing="0"
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   623
 *  summary="predefined and posix character classes in Unicode mode">
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   624
 * <tr align="left">
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   625
 * <th align="left" id="predef_classes">Classes</th>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   626
 * <th align="left" id="predef_matches">Matches</th>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   627
 *</tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   628
 * <tr><td><tt>\p{Lower}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   629
 *     <td>A lowercase character:<tt>\p{IsLowercase}</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   630
 * <tr><td><tt>\p{Upper}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   631
 *     <td>An uppercase character:<tt>\p{IsUppercase}</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   632
 * <tr><td><tt>\p{ASCII}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   633
 *     <td>All ASCII:<tt>[\x00-\x7F]</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   634
 * <tr><td><tt>\p{Alpha}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   635
 *     <td>An alphabetic character:<tt>\p{IsAlphabetic}</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   636
 * <tr><td><tt>\p{Digit}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   637
 *     <td>A decimal digit character:<tt>p{IsDigit}</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   638
 * <tr><td><tt>\p{Alnum}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   639
 *     <td>An alphanumeric character:<tt>[\p{IsAlphabetic}\p{IsDigit}]</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   640
 * <tr><td><tt>\p{Punct}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   641
 *     <td>A punctuation character:<tt>p{IsPunctuation}</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   642
 * <tr><td><tt>\p{Graph}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   643
 *     <td>A visible character: <tt>[^\p{IsWhite_Space}\p{gc=Cc}\p{gc=Cs}\p{gc=Cn}]</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   644
 * <tr><td><tt>\p{Print}</tt></td>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   645
 *     <td>A printable character: {@code [\p{Graph}\p{Blank}&&[^\p{Cntrl}]]}</td></tr>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   646
 * <tr><td><tt>\p{Blank}</tt></td>
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   647
 *     <td>A space or a tab: {@code [\p{IsWhite_Space}&&[^\p{gc=Zl}\p{gc=Zp}\x0a\x0b\x0c\x0d\x85]]}</td></tr>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   648
 * <tr><td><tt>\p{Cntrl}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   649
 *     <td>A control character: <tt>\p{gc=Cc}</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   650
 * <tr><td><tt>\p{XDigit}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   651
 *     <td>A hexadecimal digit: <tt>[\p{gc=Nd}\p{IsHex_Digit}]</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   652
 * <tr><td><tt>\p{Space}</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   653
 *     <td>A whitespace character:<tt>\p{IsWhite_Space}</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   654
 * <tr><td><tt>\d</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   655
 *     <td>A digit: <tt>\p{IsDigit}</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   656
 * <tr><td><tt>\D</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   657
 *     <td>A non-digit: <tt>[^\d]</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   658
 * <tr><td><tt>\s</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   659
 *     <td>A whitespace character: <tt>\p{IsWhite_Space}</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   660
 * <tr><td><tt>\S</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   661
 *     <td>A non-whitespace character: <tt>[^\s]</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   662
 * <tr><td><tt>\w</tt></td>
17434
4a04d7127e80 8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents: 17183
diff changeset
   663
 *     <td>A word character: <tt>[\p{Alpha}\p{gc=Mn}\p{gc=Me}\p{gc=Mc}\p{Digit}\p{gc=Pc}\p{IsJoin_Control}]</tt></td></tr>
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   664
 * <tr><td><tt>\W</tt></td>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   665
 *     <td>A non-word character: <tt>[^\w]</tt></td></tr>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   666
 * </table>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   667
 * <p>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   668
 * <a name="jcc">
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   669
 * Categories that behave like the java.lang.Character
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   670
 * boolean is<i>methodname</i> methods (except for the deprecated ones) are
90ce3da70b43 Initial load
duke
parents:
diff changeset
   671
 * available through the same <tt>\p{</tt><i>prop</i><tt>}</tt> syntax where
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   672
 * the specified property has the name <tt>java<i>methodname</i></tt></a>.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   673
 *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
   674
 * <h3> Comparison to Perl 5 </h3>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   675
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   676
 * <p>The <code>Pattern</code> engine performs traditional NFA-based matching
90ce3da70b43 Initial load
duke
parents:
diff changeset
   677
 * with ordered alternation as occurs in Perl 5.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   678
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   679
 * <p> Perl constructs not supported by this class: </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   680
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   681
 * <ul>
9543
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   682
 *    <li><p> Predefined character classes (Unicode character)
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   683
 *    <p><tt>\X&nbsp;&nbsp;&nbsp;&nbsp;</tt>Match Unicode
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   684
 *    <a href="http://www.unicode.org/reports/tr18/#Default_Grapheme_Clusters">
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   685
 *    <i>extended grapheme cluster</i></a>
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   686
 *    </p></li>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   687
 *
9543
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   688
 *    <li><p> The backreference constructs, <tt>\g{</tt><i>n</i><tt>}</tt> for
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   689
 *    the <i>n</i><sup>th</sup><a href="#cg">capturing group</a> and
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   690
 *    <tt>\g{</tt><i>name</i><tt>}</tt> for
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   691
 *    <a href="#groupname">named-capturing group</a>.
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   692
 *    </p></li>
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   693
 *
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   694
 *    <li><p> The named character construct, <tt>\N{</tt><i>name</i><tt>}</tt>
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   695
 *    for a Unicode character by its name.
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   696
 *    </p></li>
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   697
 *
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   698
 *    <li><p> The conditional constructs
3d4bcfaa8627 7036522: j.u.r.Pattern documentation errors
sherman
parents: 9536
diff changeset
   699
 *    <tt>(?(</tt><i>condition</i><tt>)</tt><i>X</i><tt>)</tt> and
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   700
 *    <tt>(?(</tt><i>condition</i><tt>)</tt><i>X</i><tt>|</tt><i>Y</i><tt>)</tt>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   701
 *    </p></li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   702
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   703
 *    <li><p> The embedded code constructs <tt>(?{</tt><i>code</i><tt>})</tt>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   704
 *    and <tt>(??{</tt><i>code</i><tt>})</tt>,</p></li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   705
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   706
 *    <li><p> The embedded comment syntax <tt>(?#comment)</tt>, and </p></li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   707
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   708
 *    <li><p> The preprocessing operations <tt>\l</tt> <tt>&#92;u</tt>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   709
 *    <tt>\L</tt>, and <tt>\U</tt>.  </p></li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   710
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   711
 * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   712
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   713
 * <p> Constructs supported by this class but not by Perl: </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   714
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   715
 * <ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   716
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   717
 *    <li><p> Character-class union and intersection as described
90ce3da70b43 Initial load
duke
parents:
diff changeset
   718
 *    <a href="#cc">above</a>.</p></li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   719
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   720
 * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   721
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   722
 * <p> Notable differences from Perl: </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   723
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   724
 * <ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   725
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   726
 *    <li><p> In Perl, <tt>\1</tt> through <tt>\9</tt> are always interpreted
90ce3da70b43 Initial load
duke
parents:
diff changeset
   727
 *    as back references; a backslash-escaped number greater than <tt>9</tt> is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   728
 *    treated as a back reference if at least that many subexpressions exist,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   729
 *    otherwise it is interpreted, if possible, as an octal escape.  In this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   730
 *    class octal escapes must always begin with a zero. In this class,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   731
 *    <tt>\1</tt> through <tt>\9</tt> are always interpreted as back
90ce3da70b43 Initial load
duke
parents:
diff changeset
   732
 *    references, and a larger number is accepted as a back reference if at
90ce3da70b43 Initial load
duke
parents:
diff changeset
   733
 *    least that many subexpressions exist at that point in the regular
90ce3da70b43 Initial load
duke
parents:
diff changeset
   734
 *    expression, otherwise the parser will drop digits until the number is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   735
 *    smaller or equal to the existing number of groups or it is one digit.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   736
 *    </p></li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   737
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   738
 *    <li><p> Perl uses the <tt>g</tt> flag to request a match that resumes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   739
 *    where the last match left off.  This functionality is provided implicitly
90ce3da70b43 Initial load
duke
parents:
diff changeset
   740
 *    by the {@link Matcher} class: Repeated invocations of the {@link
90ce3da70b43 Initial load
duke
parents:
diff changeset
   741
 *    Matcher#find find} method will resume where the last match left off,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   742
 *    unless the matcher is reset.  </p></li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   743
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   744
 *    <li><p> In Perl, embedded flags at the top level of an expression affect
90ce3da70b43 Initial load
duke
parents:
diff changeset
   745
 *    the whole expression.  In this class, embedded flags always take effect
90ce3da70b43 Initial load
duke
parents:
diff changeset
   746
 *    at the point at which they appear, whether they are at the top level or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   747
 *    within a group; in the latter case, flags are restored at the end of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   748
 *    group just as in Perl.  </p></li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   749
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   750
 * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   751
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   752
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   753
 * <p> For a more precise description of the behavior of regular expression
90ce3da70b43 Initial load
duke
parents:
diff changeset
   754
 * constructs, please see <a href="http://www.oreilly.com/catalog/regex3/">
90ce3da70b43 Initial load
duke
parents:
diff changeset
   755
 * <i>Mastering Regular Expressions, 3nd Edition</i>, Jeffrey E. F. Friedl,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   756
 * O'Reilly and Associates, 2006.</a>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   757
 * </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   758
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   759
 * @see java.lang.String#split(String, int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   760
 * @see java.lang.String#split(String)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   761
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   762
 * @author      Mike McCloskey
90ce3da70b43 Initial load
duke
parents:
diff changeset
   763
 * @author      Mark Reinhold
90ce3da70b43 Initial load
duke
parents:
diff changeset
   764
 * @author      JSR-51 Expert Group
90ce3da70b43 Initial load
duke
parents:
diff changeset
   765
 * @since       1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   766
 * @spec        JSR-51
90ce3da70b43 Initial load
duke
parents:
diff changeset
   767
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   768
90ce3da70b43 Initial load
duke
parents:
diff changeset
   769
public final class Pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
   770
    implements java.io.Serializable
90ce3da70b43 Initial load
duke
parents:
diff changeset
   771
{
90ce3da70b43 Initial load
duke
parents:
diff changeset
   772
90ce3da70b43 Initial load
duke
parents:
diff changeset
   773
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   774
     * Regular expression modifier values.  Instead of being passed as
90ce3da70b43 Initial load
duke
parents:
diff changeset
   775
     * arguments, they can also be passed as inline modifiers.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   776
     * For example, the following statements have the same effect.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   777
     * <pre>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   778
     * RegExp r1 = RegExp.compile("abc", Pattern.I|Pattern.M);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   779
     * RegExp r2 = RegExp.compile("(?im)abc", 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   780
     * </pre>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   781
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   782
     * The flags are duplicated so that the familiar Perl match flag
90ce3da70b43 Initial load
duke
parents:
diff changeset
   783
     * names are available.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   784
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   785
90ce3da70b43 Initial load
duke
parents:
diff changeset
   786
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   787
     * Enables Unix lines mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   788
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   789
     * <p> In this mode, only the <tt>'\n'</tt> line terminator is recognized
90ce3da70b43 Initial load
duke
parents:
diff changeset
   790
     * in the behavior of <tt>.</tt>, <tt>^</tt>, and <tt>$</tt>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   791
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   792
     * <p> Unix lines mode can also be enabled via the embedded flag
90ce3da70b43 Initial load
duke
parents:
diff changeset
   793
     * expression&nbsp;<tt>(?d)</tt>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   794
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   795
    public static final int UNIX_LINES = 0x01;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   796
90ce3da70b43 Initial load
duke
parents:
diff changeset
   797
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   798
     * Enables case-insensitive matching.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   799
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   800
     * <p> By default, case-insensitive matching assumes that only characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
   801
     * in the US-ASCII charset are being matched.  Unicode-aware
90ce3da70b43 Initial load
duke
parents:
diff changeset
   802
     * case-insensitive matching can be enabled by specifying the {@link
90ce3da70b43 Initial load
duke
parents:
diff changeset
   803
     * #UNICODE_CASE} flag in conjunction with this flag.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   804
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   805
     * <p> Case-insensitive matching can also be enabled via the embedded flag
90ce3da70b43 Initial load
duke
parents:
diff changeset
   806
     * expression&nbsp;<tt>(?i)</tt>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   807
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   808
     * <p> Specifying this flag may impose a slight performance penalty.  </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   809
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   810
    public static final int CASE_INSENSITIVE = 0x02;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   811
90ce3da70b43 Initial load
duke
parents:
diff changeset
   812
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   813
     * Permits whitespace and comments in pattern.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   814
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   815
     * <p> In this mode, whitespace is ignored, and embedded comments starting
90ce3da70b43 Initial load
duke
parents:
diff changeset
   816
     * with <tt>#</tt> are ignored until the end of a line.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   817
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   818
     * <p> Comments mode can also be enabled via the embedded flag
90ce3da70b43 Initial load
duke
parents:
diff changeset
   819
     * expression&nbsp;<tt>(?x)</tt>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   820
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   821
    public static final int COMMENTS = 0x04;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   822
90ce3da70b43 Initial load
duke
parents:
diff changeset
   823
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   824
     * Enables multiline mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   825
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   826
     * <p> In multiline mode the expressions <tt>^</tt> and <tt>$</tt> match
90ce3da70b43 Initial load
duke
parents:
diff changeset
   827
     * just after or just before, respectively, a line terminator or the end of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   828
     * the input sequence.  By default these expressions only match at the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   829
     * beginning and the end of the entire input sequence.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   830
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   831
     * <p> Multiline mode can also be enabled via the embedded flag
90ce3da70b43 Initial load
duke
parents:
diff changeset
   832
     * expression&nbsp;<tt>(?m)</tt>.  </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   833
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   834
    public static final int MULTILINE = 0x08;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   835
90ce3da70b43 Initial load
duke
parents:
diff changeset
   836
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   837
     * Enables literal parsing of the pattern.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   838
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   839
     * <p> When this flag is specified then the input string that specifies
90ce3da70b43 Initial load
duke
parents:
diff changeset
   840
     * the pattern is treated as a sequence of literal characters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   841
     * Metacharacters or escape sequences in the input sequence will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
   842
     * given no special meaning.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   843
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   844
     * <p>The flags CASE_INSENSITIVE and UNICODE_CASE retain their impact on
90ce3da70b43 Initial load
duke
parents:
diff changeset
   845
     * matching when used in conjunction with this flag. The other flags
90ce3da70b43 Initial load
duke
parents:
diff changeset
   846
     * become superfluous.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   847
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   848
     * <p> There is no embedded flag character for enabling literal parsing.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   849
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   850
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   851
    public static final int LITERAL = 0x10;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   852
90ce3da70b43 Initial load
duke
parents:
diff changeset
   853
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   854
     * Enables dotall mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   855
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   856
     * <p> In dotall mode, the expression <tt>.</tt> matches any character,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   857
     * including a line terminator.  By default this expression does not match
90ce3da70b43 Initial load
duke
parents:
diff changeset
   858
     * line terminators.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   859
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   860
     * <p> Dotall mode can also be enabled via the embedded flag
90ce3da70b43 Initial load
duke
parents:
diff changeset
   861
     * expression&nbsp;<tt>(?s)</tt>.  (The <tt>s</tt> is a mnemonic for
90ce3da70b43 Initial load
duke
parents:
diff changeset
   862
     * "single-line" mode, which is what this is called in Perl.)  </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   863
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   864
    public static final int DOTALL = 0x20;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   865
90ce3da70b43 Initial load
duke
parents:
diff changeset
   866
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   867
     * Enables Unicode-aware case folding.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   868
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   869
     * <p> When this flag is specified then case-insensitive matching, when
90ce3da70b43 Initial load
duke
parents:
diff changeset
   870
     * enabled by the {@link #CASE_INSENSITIVE} flag, is done in a manner
90ce3da70b43 Initial load
duke
parents:
diff changeset
   871
     * consistent with the Unicode Standard.  By default, case-insensitive
90ce3da70b43 Initial load
duke
parents:
diff changeset
   872
     * matching assumes that only characters in the US-ASCII charset are being
90ce3da70b43 Initial load
duke
parents:
diff changeset
   873
     * matched.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   874
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   875
     * <p> Unicode-aware case folding can also be enabled via the embedded flag
90ce3da70b43 Initial load
duke
parents:
diff changeset
   876
     * expression&nbsp;<tt>(?u)</tt>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   877
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   878
     * <p> Specifying this flag may impose a performance penalty.  </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   879
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   880
    public static final int UNICODE_CASE = 0x40;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   881
90ce3da70b43 Initial load
duke
parents:
diff changeset
   882
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   883
     * Enables canonical equivalence.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   884
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   885
     * <p> When this flag is specified then two characters will be considered
90ce3da70b43 Initial load
duke
parents:
diff changeset
   886
     * to match if, and only if, their full canonical decompositions match.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   887
     * The expression <tt>"a&#92;u030A"</tt>, for example, will match the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   888
     * string <tt>"&#92;u00E5"</tt> when this flag is specified.  By default,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   889
     * matching does not take canonical equivalence into account.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   890
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   891
     * <p> There is no embedded flag character for enabling canonical
90ce3da70b43 Initial load
duke
parents:
diff changeset
   892
     * equivalence.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   893
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   894
     * <p> Specifying this flag may impose a performance penalty.  </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   895
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   896
    public static final int CANON_EQ = 0x80;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   897
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   898
    /**
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   899
     * Enables the Unicode version of <i>Predefined character classes</i> and
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   900
     * <i>POSIX character classes</i>.
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   901
     *
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   902
     * <p> When this flag is specified then the (US-ASCII only)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   903
     * <i>Predefined character classes</i> and <i>POSIX character classes</i>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   904
     * are in conformance with
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   905
     * <a href="http://www.unicode.org/reports/tr18/"><i>Unicode Technical
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   906
     * Standard #18: Unicode Regular Expression</i></a>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   907
     * <i>Annex C: Compatibility Properties</i>.
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   908
     * <p>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   909
     * The UNICODE_CHARACTER_CLASS mode can also be enabled via the embedded
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   910
     * flag expression&nbsp;<tt>(?U)</tt>.
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   911
     * <p>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   912
     * The flag implies UNICODE_CASE, that is, it enables Unicode-aware case
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   913
     * folding.
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   914
     * <p>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   915
     * Specifying this flag may impose a performance penalty.  </p>
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   916
     * @since 1.7
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   917
     */
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   918
    public static final int UNICODE_CHARACTER_CLASS = 0x100;
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
   919
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   920
    /* Pattern has only two serialized components: The pattern string
90ce3da70b43 Initial load
duke
parents:
diff changeset
   921
     * and the flags, which are all that is needed to recompile the pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
   922
     * when it is deserialized.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   923
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   924
90ce3da70b43 Initial load
duke
parents:
diff changeset
   925
    /** use serialVersionUID from Merlin b59 for interoperability */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   926
    private static final long serialVersionUID = 5073258162644648461L;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   927
90ce3da70b43 Initial load
duke
parents:
diff changeset
   928
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   929
     * The original regular-expression pattern string.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   930
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   931
     * @serial
90ce3da70b43 Initial load
duke
parents:
diff changeset
   932
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   933
    private String pattern;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   934
90ce3da70b43 Initial load
duke
parents:
diff changeset
   935
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   936
     * The original pattern flags.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   937
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   938
     * @serial
90ce3da70b43 Initial load
duke
parents:
diff changeset
   939
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   940
    private int flags;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   941
90ce3da70b43 Initial load
duke
parents:
diff changeset
   942
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   943
     * Boolean indicating this Pattern is compiled; this is necessary in order
90ce3da70b43 Initial load
duke
parents:
diff changeset
   944
     * to lazily compile deserialized Patterns.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   945
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   946
    private transient volatile boolean compiled = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   947
90ce3da70b43 Initial load
duke
parents:
diff changeset
   948
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   949
     * The normalized pattern string.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   950
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   951
    private transient String normalizedPattern;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   952
90ce3da70b43 Initial load
duke
parents:
diff changeset
   953
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   954
     * The starting point of state machine for the find operation.  This allows
90ce3da70b43 Initial load
duke
parents:
diff changeset
   955
     * a match to start anywhere in the input.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   956
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   957
    transient Node root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   958
90ce3da70b43 Initial load
duke
parents:
diff changeset
   959
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   960
     * The root of object tree for a match operation.  The pattern is matched
90ce3da70b43 Initial load
duke
parents:
diff changeset
   961
     * at the beginning.  This may include a find that uses BnM or a First
90ce3da70b43 Initial load
duke
parents:
diff changeset
   962
     * node.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   963
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   964
    transient Node matchRoot;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   965
90ce3da70b43 Initial load
duke
parents:
diff changeset
   966
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   967
     * Temporary storage used by parsing pattern slice.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   968
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   969
    transient int[] buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   970
90ce3da70b43 Initial load
duke
parents:
diff changeset
   971
    /**
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   972
     * Map the "name" of the "named capturing group" to its group id
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   973
     * node.
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   974
     */
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   975
    transient volatile Map<String, Integer> namedGroups;
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   976
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
   977
    /**
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   978
     * Temporary storage used while parsing group references.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   979
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   980
    transient GroupHead[] groupNodes;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   981
90ce3da70b43 Initial load
duke
parents:
diff changeset
   982
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   983
     * Temporary null terminated code point array used by pattern compiling.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   984
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   985
    private transient int[] temp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   986
90ce3da70b43 Initial load
duke
parents:
diff changeset
   987
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   988
     * The number of capturing groups in this Pattern. Used by matchers to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   989
     * allocate storage needed to perform a match.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   990
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   991
    transient int capturingGroupCount;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   992
90ce3da70b43 Initial load
duke
parents:
diff changeset
   993
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   994
     * The local variable count used by parsing tree. Used by matchers to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   995
     * allocate storage needed to perform a match.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   996
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   997
    transient int localCount;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   998
90ce3da70b43 Initial load
duke
parents:
diff changeset
   999
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1000
     * Index into the pattern string that keeps track of how much has been
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1001
     * parsed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1002
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1003
    private transient int cursor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1004
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1005
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1006
     * Holds the length of the pattern string.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1007
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1008
    private transient int patternLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1009
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1010
    /**
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1011
     * If the Start node might possibly match supplementary characters.
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1012
     * It is set to true during compiling if
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1013
     * (1) There is supplementary char in pattern, or
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1014
     * (2) There is complement node of Category or Block
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1015
     */
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1016
    private transient boolean hasSupplementary;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1017
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1018
    /**
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1019
     * Compiles the given regular expression into a pattern.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1020
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1021
     * @param  regex
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1022
     *         The expression to be compiled
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1023
     * @return the given regular expression compiled into a pattern
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1024
     * @throws  PatternSyntaxException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1025
     *          If the expression's syntax is invalid
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1026
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1027
    public static Pattern compile(String regex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1028
        return new Pattern(regex, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1029
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1030
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1031
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1032
     * Compiles the given regular expression into a pattern with the given
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1033
     * flags.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1034
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1035
     * @param  regex
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1036
     *         The expression to be compiled
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1037
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1038
     * @param  flags
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1039
     *         Match flags, a bit mask that may include
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1040
     *         {@link #CASE_INSENSITIVE}, {@link #MULTILINE}, {@link #DOTALL},
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1041
     *         {@link #UNICODE_CASE}, {@link #CANON_EQ}, {@link #UNIX_LINES},
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  1042
     *         {@link #LITERAL}, {@link #UNICODE_CHARACTER_CLASS}
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  1043
     *         and {@link #COMMENTS}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1044
     *
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1045
     * @return the given regular expression compiled into a pattern with the given flags
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1046
     * @throws  IllegalArgumentException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1047
     *          If bit values other than those corresponding to the defined
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1048
     *          match flags are set in <tt>flags</tt>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1049
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1050
     * @throws  PatternSyntaxException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1051
     *          If the expression's syntax is invalid
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1052
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1053
    public static Pattern compile(String regex, int flags) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1054
        return new Pattern(regex, flags);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1055
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1056
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1057
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1058
     * Returns the regular expression from which this pattern was compiled.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1059
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1060
     * @return  The source of this pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1061
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1062
    public String pattern() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1063
        return pattern;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1064
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1065
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1066
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1067
     * <p>Returns the string representation of this pattern. This
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1068
     * is the regular expression from which this pattern was
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1069
     * compiled.</p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1070
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1071
     * @return  The string representation of this pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1072
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1073
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1074
    public String toString() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1075
        return pattern;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1076
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1077
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1078
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1079
     * Creates a matcher that will match the given input against this pattern.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1080
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1081
     * @param  input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1082
     *         The character sequence to be matched
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1083
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1084
     * @return  A new matcher for this pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1085
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1086
    public Matcher matcher(CharSequence input) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1087
        if (!compiled) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1088
            synchronized(this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1089
                if (!compiled)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1090
                    compile();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1091
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1092
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1093
        Matcher m = new Matcher(this, input);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1094
        return m;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1095
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1096
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1097
    /**
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1098
     * Returns this pattern's match flags.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1099
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1100
     * @return  The match flags specified when this pattern was compiled
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1101
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1102
    public int flags() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1103
        return flags;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1104
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1105
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1106
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1107
     * Compiles the given regular expression and attempts to match the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1108
     * input against it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1109
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1110
     * <p> An invocation of this convenience method of the form
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1111
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1112
     * <blockquote><pre>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1113
     * Pattern.matches(regex, input);</pre></blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1114
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1115
     * behaves in exactly the same way as the expression
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1116
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1117
     * <blockquote><pre>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1118
     * Pattern.compile(regex).matcher(input).matches()</pre></blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1119
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1120
     * <p> If a pattern is to be used multiple times, compiling it once and reusing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1121
     * it will be more efficient than invoking this method each time.  </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1122
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1123
     * @param  regex
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1124
     *         The expression to be compiled
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1125
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1126
     * @param  input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1127
     *         The character sequence to be matched
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1128
     * @return whether or not the regular expression matches on the input
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1129
     * @throws  PatternSyntaxException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1130
     *          If the expression's syntax is invalid
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1131
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1132
    public static boolean matches(String regex, CharSequence input) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1133
        Pattern p = Pattern.compile(regex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1134
        Matcher m = p.matcher(input);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1135
        return m.matches();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1136
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1137
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1138
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1139
     * Splits the given input sequence around matches of this pattern.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1140
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1141
     * <p> The array returned by this method contains each substring of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1142
     * input sequence that is terminated by another subsequence that matches
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1143
     * this pattern or is terminated by the end of the input sequence.  The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1144
     * substrings in the array are in the order in which they occur in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1145
     * input.  If this pattern does not match any subsequence of the input then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1146
     * the resulting array has just one element, namely the input sequence in
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1147
     * string form.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1148
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1149
     * <p> The <tt>limit</tt> parameter controls the number of times the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1150
     * pattern is applied and therefore affects the length of the resulting
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1151
     * array.  If the limit <i>n</i> is greater than zero then the pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1152
     * will be applied at most <i>n</i>&nbsp;-&nbsp;1 times, the array's
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1153
     * length will be no greater than <i>n</i>, and the array's last entry
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1154
     * will contain all input beyond the last matched delimiter.  If <i>n</i>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1155
     * is non-positive then the pattern will be applied as many times as
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1156
     * possible and the array can have any length.  If <i>n</i> is zero then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1157
     * the pattern will be applied as many times as possible, the array can
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1158
     * have any length, and trailing empty strings will be discarded.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1159
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1160
     * <p> The input <tt>"boo:and:foo"</tt>, for example, yields the following
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1161
     * results with these parameters:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1162
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1163
     * <blockquote><table cellpadding=1 cellspacing=0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1164
     *              summary="Split examples showing regex, limit, and result">
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1165
     * <tr><th align="left"><i>Regex&nbsp;&nbsp;&nbsp;&nbsp;</i></th>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1166
     *     <th align="left"><i>Limit&nbsp;&nbsp;&nbsp;&nbsp;</i></th>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1167
     *     <th align="left"><i>Result&nbsp;&nbsp;&nbsp;&nbsp;</i></th></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1168
     * <tr><td align=center>:</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1169
     *     <td align=center>2</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1170
     *     <td><tt>{ "boo", "and:foo" }</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1171
     * <tr><td align=center>:</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1172
     *     <td align=center>5</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1173
     *     <td><tt>{ "boo", "and", "foo" }</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1174
     * <tr><td align=center>:</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1175
     *     <td align=center>-2</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1176
     *     <td><tt>{ "boo", "and", "foo" }</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1177
     * <tr><td align=center>o</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1178
     *     <td align=center>5</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1179
     *     <td><tt>{ "b", "", ":and:f", "", "" }</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1180
     * <tr><td align=center>o</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1181
     *     <td align=center>-2</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1182
     *     <td><tt>{ "b", "", ":and:f", "", "" }</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1183
     * <tr><td align=center>o</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1184
     *     <td align=center>0</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1185
     *     <td><tt>{ "b", "", ":and:f" }</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1186
     * </table></blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1187
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1188
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1189
     * @param  input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1190
     *         The character sequence to be split
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1191
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1192
     * @param  limit
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1193
     *         The result threshold, as described above
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1194
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1195
     * @return  The array of strings computed by splitting the input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1196
     *          around matches of this pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1197
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1198
    public String[] split(CharSequence input, int limit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1199
        int index = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1200
        boolean matchLimited = limit > 0;
7803
56bc97d69d93 6880112: Project Coin: Port JDK core library code to use diamond operator
smarks
parents: 5627
diff changeset
  1201
        ArrayList<String> matchList = new ArrayList<>();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1202
        Matcher m = matcher(input);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1203
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1204
        // Add segments before each match found
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1205
        while(m.find()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1206
            if (!matchLimited || matchList.size() < limit - 1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1207
                String match = input.subSequence(index, m.start()).toString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1208
                matchList.add(match);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1209
                index = m.end();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1210
            } else if (matchList.size() == limit - 1) { // last one
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1211
                String match = input.subSequence(index,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1212
                                                 input.length()).toString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1213
                matchList.add(match);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1214
                index = m.end();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1215
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1216
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1217
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1218
        // If no match was found, return this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1219
        if (index == 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1220
            return new String[] {input.toString()};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1221
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1222
        // Add remaining segment
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1223
        if (!matchLimited || matchList.size() < limit)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1224
            matchList.add(input.subSequence(index, input.length()).toString());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1225
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1226
        // Construct result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1227
        int resultSize = matchList.size();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1228
        if (limit == 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1229
            while (resultSize > 0 && matchList.get(resultSize-1).equals(""))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1230
                resultSize--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1231
        String[] result = new String[resultSize];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1232
        return matchList.subList(0, resultSize).toArray(result);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1233
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1234
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1235
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1236
     * Splits the given input sequence around matches of this pattern.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1237
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1238
     * <p> This method works as if by invoking the two-argument {@link
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1239
     * #split(java.lang.CharSequence, int) split} method with the given input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1240
     * sequence and a limit argument of zero.  Trailing empty strings are
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1241
     * therefore not included in the resulting array. </p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1242
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1243
     * <p> The input <tt>"boo:and:foo"</tt>, for example, yields the following
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1244
     * results with these expressions:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1245
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1246
     * <blockquote><table cellpadding=1 cellspacing=0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1247
     *              summary="Split examples showing regex and result">
18787
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1248
     * <tr><th align="left"><i>Regex&nbsp;&nbsp;&nbsp;&nbsp;</i></th>
8a57ff107238 8020095: Fix doclint warnings in java.util.regex
darcy
parents: 18156
diff changeset
  1249
     *     <th align="left"><i>Result</i></th></tr>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1250
     * <tr><td align=center>:</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1251
     *     <td><tt>{ "boo", "and", "foo" }</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1252
     * <tr><td align=center>o</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1253
     *     <td><tt>{ "b", "", ":and:f" }</tt></td></tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1254
     * </table></blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1255
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1256
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1257
     * @param  input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1258
     *         The character sequence to be split
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1259
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1260
     * @return  The array of strings computed by splitting the input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1261
     *          around matches of this pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1262
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1263
    public String[] split(CharSequence input) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1264
        return split(input, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1265
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1266
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1267
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1268
     * Returns a literal pattern <code>String</code> for the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1269
     * <code>String</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1270
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1271
     * <p>This method produces a <code>String</code> that can be used to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1272
     * create a <code>Pattern</code> that would match the string
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1273
     * <code>s</code> as if it were a literal pattern.</p> Metacharacters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1274
     * or escape sequences in the input sequence will be given no special
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1275
     * meaning.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1276
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1277
     * @param  s The string to be literalized
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1278
     * @return  A literal string replacement
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1279
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1280
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1281
    public static String quote(String s) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1282
        int slashEIndex = s.indexOf("\\E");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1283
        if (slashEIndex == -1)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1284
            return "\\Q" + s + "\\E";
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1285
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1286
        StringBuilder sb = new StringBuilder(s.length() * 2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1287
        sb.append("\\Q");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1288
        slashEIndex = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1289
        int current = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1290
        while ((slashEIndex = s.indexOf("\\E", current)) != -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1291
            sb.append(s.substring(current, slashEIndex));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1292
            current = slashEIndex + 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1293
            sb.append("\\E\\\\E\\Q");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1294
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1295
        sb.append(s.substring(current, s.length()));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1296
        sb.append("\\E");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1297
        return sb.toString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1298
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1299
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1300
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1301
     * Recompile the Pattern instance from a stream.  The original pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1302
     * string is read in and the object tree is recompiled from it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1303
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1304
    private void readObject(java.io.ObjectInputStream s)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1305
        throws java.io.IOException, ClassNotFoundException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1306
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1307
        // Read in all fields
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1308
        s.defaultReadObject();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1309
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1310
        // Initialize counts
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1311
        capturingGroupCount = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1312
        localCount = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1313
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1314
        // if length > 0, the Pattern is lazily compiled
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1315
        compiled = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1316
        if (pattern.length() == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1317
            root = new Start(lastAccept);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1318
            matchRoot = lastAccept;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1319
            compiled = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1320
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1321
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1322
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1323
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1324
     * This private constructor is used to create all Patterns. The pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1325
     * string and match flags are all that is needed to completely describe
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1326
     * a Pattern. An empty pattern string results in an object tree with
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1327
     * only a Start node and a LastNode node.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1328
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1329
    private Pattern(String p, int f) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1330
        pattern = p;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1331
        flags = f;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1332
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  1333
        // to use UNICODE_CASE if UNICODE_CHARACTER_CLASS present
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  1334
        if ((flags & UNICODE_CHARACTER_CLASS) != 0)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  1335
            flags |= UNICODE_CASE;
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  1336
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1337
        // Reset group index count
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1338
        capturingGroupCount = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1339
        localCount = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1340
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1341
        if (pattern.length() > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1342
            compile();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1343
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1344
            root = new Start(lastAccept);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1345
            matchRoot = lastAccept;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1346
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1347
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1348
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1349
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1350
     * The pattern is converted to normalizedD form and then a pure group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1351
     * is constructed to match canonical equivalences of the characters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1352
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1353
    private void normalize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1354
        boolean inCharClass = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1355
        int lastCodePoint = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1356
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1357
        // Convert pattern into normalizedD form
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1358
        normalizedPattern = Normalizer.normalize(pattern, Normalizer.Form.NFD);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1359
        patternLength = normalizedPattern.length();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1360
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1361
        // Modify pattern to match canonical equivalences
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1362
        StringBuilder newPattern = new StringBuilder(patternLength);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1363
        for(int i=0; i<patternLength; ) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1364
            int c = normalizedPattern.codePointAt(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1365
            StringBuilder sequenceBuffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1366
            if ((Character.getType(c) == Character.NON_SPACING_MARK)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1367
                && (lastCodePoint != -1)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1368
                sequenceBuffer = new StringBuilder();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1369
                sequenceBuffer.appendCodePoint(lastCodePoint);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1370
                sequenceBuffer.appendCodePoint(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1371
                while(Character.getType(c) == Character.NON_SPACING_MARK) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1372
                    i += Character.charCount(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1373
                    if (i >= patternLength)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1374
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1375
                    c = normalizedPattern.codePointAt(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1376
                    sequenceBuffer.appendCodePoint(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1377
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1378
                String ea = produceEquivalentAlternation(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1379
                                               sequenceBuffer.toString());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1380
                newPattern.setLength(newPattern.length()-Character.charCount(lastCodePoint));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1381
                newPattern.append("(?:").append(ea).append(")");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1382
            } else if (c == '[' && lastCodePoint != '\\') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1383
                i = normalizeCharClass(newPattern, i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1384
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1385
                newPattern.appendCodePoint(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1386
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1387
            lastCodePoint = c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1388
            i += Character.charCount(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1389
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1390
        normalizedPattern = newPattern.toString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1391
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1392
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1393
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1394
     * Complete the character class being parsed and add a set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1395
     * of alternations to it that will match the canonical equivalences
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1396
     * of the characters within the class.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1397
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1398
    private int normalizeCharClass(StringBuilder newPattern, int i) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1399
        StringBuilder charClass = new StringBuilder();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1400
        StringBuilder eq = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1401
        int lastCodePoint = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1402
        String result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1403
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1404
        i++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1405
        charClass.append("[");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1406
        while(true) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1407
            int c = normalizedPattern.codePointAt(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1408
            StringBuilder sequenceBuffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1409
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1410
            if (c == ']' && lastCodePoint != '\\') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1411
                charClass.append((char)c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1412
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1413
            } else if (Character.getType(c) == Character.NON_SPACING_MARK) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1414
                sequenceBuffer = new StringBuilder();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1415
                sequenceBuffer.appendCodePoint(lastCodePoint);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1416
                while(Character.getType(c) == Character.NON_SPACING_MARK) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1417
                    sequenceBuffer.appendCodePoint(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1418
                    i += Character.charCount(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1419
                    if (i >= normalizedPattern.length())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1420
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1421
                    c = normalizedPattern.codePointAt(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1422
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1423
                String ea = produceEquivalentAlternation(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1424
                                                  sequenceBuffer.toString());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1425
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1426
                charClass.setLength(charClass.length()-Character.charCount(lastCodePoint));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1427
                if (eq == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1428
                    eq = new StringBuilder();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1429
                eq.append('|');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1430
                eq.append(ea);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1431
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1432
                charClass.appendCodePoint(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1433
                i++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1434
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1435
            if (i == normalizedPattern.length())
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1436
                throw error("Unclosed character class");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1437
            lastCodePoint = c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1438
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1439
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1440
        if (eq != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1441
            result = "(?:"+charClass.toString()+eq.toString()+")";
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1442
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1443
            result = charClass.toString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1444
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1445
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1446
        newPattern.append(result);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1447
        return i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1448
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1449
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1450
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1451
     * Given a specific sequence composed of a regular character and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1452
     * combining marks that follow it, produce the alternation that will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1453
     * match all canonical equivalences of that sequence.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1454
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1455
    private String produceEquivalentAlternation(String source) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1456
        int len = countChars(source, 0, 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1457
        if (source.length() == len)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1458
            // source has one character.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1459
            return source;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1460
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1461
        String base = source.substring(0,len);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1462
        String combiningMarks = source.substring(len);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1463
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1464
        String[] perms = producePermutations(combiningMarks);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1465
        StringBuilder result = new StringBuilder(source);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1466
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1467
        // Add combined permutations
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1468
        for(int x=0; x<perms.length; x++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1469
            String next = base + perms[x];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1470
            if (x>0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1471
                result.append("|"+next);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1472
            next = composeOneStep(next);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1473
            if (next != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1474
                result.append("|"+produceEquivalentAlternation(next));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1475
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1476
        return result.toString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1477
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1478
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1479
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1480
     * Returns an array of strings that have all the possible
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1481
     * permutations of the characters in the input string.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1482
     * This is used to get a list of all possible orderings
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1483
     * of a set of combining marks. Note that some of the permutations
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1484
     * are invalid because of combining class collisions, and these
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1485
     * possibilities must be removed because they are not canonically
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1486
     * equivalent.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1487
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1488
    private String[] producePermutations(String input) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1489
        if (input.length() == countChars(input, 0, 1))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1490
            return new String[] {input};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1491
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1492
        if (input.length() == countChars(input, 0, 2)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1493
            int c0 = Character.codePointAt(input, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1494
            int c1 = Character.codePointAt(input, Character.charCount(c0));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1495
            if (getClass(c1) == getClass(c0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1496
                return new String[] {input};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1497
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1498
            String[] result = new String[2];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1499
            result[0] = input;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1500
            StringBuilder sb = new StringBuilder(2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1501
            sb.appendCodePoint(c1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1502
            sb.appendCodePoint(c0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1503
            result[1] = sb.toString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1504
            return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1505
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1506
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1507
        int length = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1508
        int nCodePoints = countCodePoints(input);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1509
        for(int x=1; x<nCodePoints; x++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1510
            length = length * (x+1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1511
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1512
        String[] temp = new String[length];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1513
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1514
        int combClass[] = new int[nCodePoints];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1515
        for(int x=0, i=0; x<nCodePoints; x++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1516
            int c = Character.codePointAt(input, i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1517
            combClass[x] = getClass(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1518
            i +=  Character.charCount(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1519
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1520
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1521
        // For each char, take it out and add the permutations
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1522
        // of the remaining chars
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1523
        int index = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1524
        int len;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1525
        // offset maintains the index in code units.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1526
loop:   for(int x=0, offset=0; x<nCodePoints; x++, offset+=len) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1527
            len = countChars(input, offset, 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1528
            boolean skip = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1529
            for(int y=x-1; y>=0; y--) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1530
                if (combClass[y] == combClass[x]) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1531
                    continue loop;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1532
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1533
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1534
            StringBuilder sb = new StringBuilder(input);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1535
            String otherChars = sb.delete(offset, offset+len).toString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1536
            String[] subResult = producePermutations(otherChars);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1537
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1538
            String prefix = input.substring(offset, offset+len);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1539
            for(int y=0; y<subResult.length; y++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1540
                temp[index++] =  prefix + subResult[y];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1541
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1542
        String[] result = new String[index];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1543
        for (int x=0; x<index; x++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1544
            result[x] = temp[x];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1545
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1546
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1547
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1548
    private int getClass(int c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1549
        return sun.text.Normalizer.getCombiningClass(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1550
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1551
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1552
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1553
     * Attempts to compose input by combining the first character
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1554
     * with the first combining mark following it. Returns a String
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1555
     * that is the composition of the leading character with its first
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1556
     * combining mark followed by the remaining combining marks. Returns
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1557
     * null if the first two characters cannot be further composed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1558
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1559
    private String composeOneStep(String input) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1560
        int len = countChars(input, 0, 2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1561
        String firstTwoCharacters = input.substring(0, len);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1562
        String result = Normalizer.normalize(firstTwoCharacters, Normalizer.Form.NFC);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1563
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1564
        if (result.equals(firstTwoCharacters))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1565
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1566
        else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1567
            String remainder = input.substring(len);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1568
            return result + remainder;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1569
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1570
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1571
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1572
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1573
     * Preprocess any \Q...\E sequences in `temp', meta-quoting them.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1574
     * See the description of `quotemeta' in perlfunc(1).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1575
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1576
    private void RemoveQEQuoting() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1577
        final int pLen = patternLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1578
        int i = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1579
        while (i < pLen-1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1580
            if (temp[i] != '\\')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1581
                i += 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1582
            else if (temp[i + 1] != 'Q')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1583
                i += 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1584
            else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1585
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1586
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1587
        if (i >= pLen - 1)    // No \Q sequence found
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1588
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1589
        int j = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1590
        i += 2;
11287
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1591
        int[] newtemp = new int[j + 3*(pLen-i) + 2];
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1592
        System.arraycopy(temp, 0, newtemp, 0, j);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1593
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1594
        boolean inQuote = true;
11287
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1595
        boolean beginQuote = true;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1596
        while (i < pLen) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1597
            int c = temp[i++];
11287
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1598
            if (!ASCII.isAscii(c) || ASCII.isAlpha(c)) {
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1599
                newtemp[j++] = c;
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1600
            } else if (ASCII.isDigit(c)) {
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1601
                if (beginQuote) {
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1602
                    /*
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1603
                     * A unicode escape \[0xu] could be before this quote,
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1604
                     * and we don't want this numeric char to processed as
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1605
                     * part of the escape.
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1606
                     */
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1607
                    newtemp[j++] = '\\';
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1608
                    newtemp[j++] = 'x';
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1609
                    newtemp[j++] = '3';
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1610
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1611
                newtemp[j++] = c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1612
            } else if (c != '\\') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1613
                if (inQuote) newtemp[j++] = '\\';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1614
                newtemp[j++] = c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1615
            } else if (inQuote) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1616
                if (temp[i] == 'E') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1617
                    i++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1618
                    inQuote = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1619
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1620
                    newtemp[j++] = '\\';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1621
                    newtemp[j++] = '\\';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1622
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1623
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1624
                if (temp[i] == 'Q') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1625
                    i++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1626
                    inQuote = true;
11287
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1627
                    beginQuote = true;
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1628
                    continue;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1629
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1630
                    newtemp[j++] = c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1631
                    if (i != pLen)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1632
                        newtemp[j++] = temp[i++];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1633
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1634
            }
11287
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1635
3db172a5433c 6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents: 9694
diff changeset
  1636
            beginQuote = false;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1637
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1638
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1639
        patternLength = j;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1640
        temp = Arrays.copyOf(newtemp, j + 2); // double zero termination
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1641
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1642
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1643
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1644
     * Copies regular expression to an int array and invokes the parsing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1645
     * of the expression which will create the object tree.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1646
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1647
    private void compile() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1648
        // Handle canonical equivalences
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1649
        if (has(CANON_EQ) && !has(LITERAL)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1650
            normalize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1651
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1652
            normalizedPattern = pattern;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1653
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1654
        patternLength = normalizedPattern.length();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1655
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1656
        // Copy pattern to int array for convenience
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1657
        // Use double zero to terminate pattern
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1658
        temp = new int[patternLength + 2];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1659
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1660
        hasSupplementary = false;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1661
        int c, count = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1662
        // Convert all chars into code points
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1663
        for (int x = 0; x < patternLength; x += Character.charCount(c)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1664
            c = normalizedPattern.codePointAt(x);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1665
            if (isSupplementary(c)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1666
                hasSupplementary = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1667
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1668
            temp[count++] = c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1669
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1670
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1671
        patternLength = count;   // patternLength now in code points
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1672
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1673
        if (! has(LITERAL))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1674
            RemoveQEQuoting();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1675
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1676
        // Allocate all temporary objects here.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1677
        buffer = new int[32];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1678
        groupNodes = new GroupHead[10];
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  1679
        namedGroups = null;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1680
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1681
        if (has(LITERAL)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1682
            // Literal pattern handling
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1683
            matchRoot = newSlice(temp, patternLength, hasSupplementary);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1684
            matchRoot.next = lastAccept;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1685
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1686
            // Start recursive descent parsing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1687
            matchRoot = expr(lastAccept);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1688
            // Check extra pattern characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1689
            if (patternLength != cursor) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1690
                if (peek() == ')') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1691
                    throw error("Unmatched closing ')'");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1692
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1693
                    throw error("Unexpected internal error");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1694
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1695
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1696
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1697
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1698
        // Peephole optimization
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1699
        if (matchRoot instanceof Slice) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1700
            root = BnM.optimize(matchRoot);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1701
            if (root == matchRoot) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1702
                root = hasSupplementary ? new StartS(matchRoot) : new Start(matchRoot);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1703
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1704
        } else if (matchRoot instanceof Begin || matchRoot instanceof First) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1705
            root = matchRoot;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1706
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1707
            root = hasSupplementary ? new StartS(matchRoot) : new Start(matchRoot);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1708
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1709
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1710
        // Release temporary storage
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1711
        temp = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1712
        buffer = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1713
        groupNodes = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1714
        patternLength = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1715
        compiled = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1716
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1717
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  1718
    Map<String, Integer> namedGroups() {
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  1719
        if (namedGroups == null)
7803
56bc97d69d93 6880112: Project Coin: Port JDK core library code to use diamond operator
smarks
parents: 5627
diff changeset
  1720
            namedGroups = new HashMap<>(2);
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  1721
        return namedGroups;
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  1722
    }
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  1723
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1724
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1725
     * Used to print out a subtree of the Pattern to help with debugging.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1726
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1727
    private static void printObjectTree(Node node) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1728
        while(node != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1729
            if (node instanceof Prolog) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1730
                System.out.println(node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1731
                printObjectTree(((Prolog)node).loop);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1732
                System.out.println("**** end contents prolog loop");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1733
            } else if (node instanceof Loop) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1734
                System.out.println(node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1735
                printObjectTree(((Loop)node).body);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1736
                System.out.println("**** end contents Loop body");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1737
            } else if (node instanceof Curly) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1738
                System.out.println(node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1739
                printObjectTree(((Curly)node).atom);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1740
                System.out.println("**** end contents Curly body");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1741
            } else if (node instanceof GroupCurly) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1742
                System.out.println(node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1743
                printObjectTree(((GroupCurly)node).atom);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1744
                System.out.println("**** end contents GroupCurly body");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1745
            } else if (node instanceof GroupTail) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1746
                System.out.println(node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1747
                System.out.println("Tail next is "+node.next);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1748
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1749
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1750
                System.out.println(node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1751
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1752
            node = node.next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1753
            if (node != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1754
                System.out.println("->next:");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1755
            if (node == Pattern.accept) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1756
                System.out.println("Accept Node");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1757
                node = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1758
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1759
       }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1760
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1761
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1762
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1763
     * Used to accumulate information about a subtree of the object graph
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1764
     * so that optimizations can be applied to the subtree.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1765
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1766
    static final class TreeInfo {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1767
        int minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1768
        int maxLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1769
        boolean maxValid;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1770
        boolean deterministic;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1771
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1772
        TreeInfo() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1773
            reset();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1774
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1775
        void reset() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1776
            minLength = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1777
            maxLength = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1778
            maxValid = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1779
            deterministic = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1780
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1781
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1782
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1783
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1784
     * The following private methods are mainly used to improve the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1785
     * readability of the code. In order to let the Java compiler easily
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1786
     * inline them, we should not put many assertions or error checks in them.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1787
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1788
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1789
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1790
     * Indicates whether a particular flag is set or not.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1791
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1792
    private boolean has(int f) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1793
        return (flags & f) != 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1794
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1795
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1796
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1797
     * Match next character, signal error if failed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1798
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1799
    private void accept(int ch, String s) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1800
        int testChar = temp[cursor++];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1801
        if (has(COMMENTS))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1802
            testChar = parsePastWhitespace(testChar);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1803
        if (ch != testChar) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1804
            throw error(s);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1805
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1806
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1807
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1808
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1809
     * Mark the end of pattern with a specific character.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1810
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1811
    private void mark(int c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1812
        temp[patternLength] = c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1813
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1814
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1815
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1816
     * Peek the next character, and do not advance the cursor.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1817
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1818
    private int peek() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1819
        int ch = temp[cursor];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1820
        if (has(COMMENTS))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1821
            ch = peekPastWhitespace(ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1822
        return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1823
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1824
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1825
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1826
     * Read the next character, and advance the cursor by one.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1827
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1828
    private int read() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1829
        int ch = temp[cursor++];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1830
        if (has(COMMENTS))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1831
            ch = parsePastWhitespace(ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1832
        return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1833
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1834
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1835
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1836
     * Read the next character, and advance the cursor by one,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1837
     * ignoring the COMMENTS setting
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1838
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1839
    private int readEscaped() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1840
        int ch = temp[cursor++];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1841
        return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1842
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1843
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1844
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1845
     * Advance the cursor by one, and peek the next character.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1846
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1847
    private int next() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1848
        int ch = temp[++cursor];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1849
        if (has(COMMENTS))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1850
            ch = peekPastWhitespace(ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1851
        return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1852
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1853
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1854
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1855
     * Advance the cursor by one, and peek the next character,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1856
     * ignoring the COMMENTS setting
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1857
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1858
    private int nextEscaped() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1859
        int ch = temp[++cursor];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1860
        return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1861
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1862
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1863
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1864
     * If in xmode peek past whitespace and comments.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1865
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1866
    private int peekPastWhitespace(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1867
        while (ASCII.isSpace(ch) || ch == '#') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1868
            while (ASCII.isSpace(ch))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1869
                ch = temp[++cursor];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1870
            if (ch == '#') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1871
                ch = peekPastLine();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1872
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1873
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1874
        return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1875
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1876
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1877
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1878
     * If in xmode parse past whitespace and comments.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1879
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1880
    private int parsePastWhitespace(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1881
        while (ASCII.isSpace(ch) || ch == '#') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1882
            while (ASCII.isSpace(ch))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1883
                ch = temp[cursor++];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1884
            if (ch == '#')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1885
                ch = parsePastLine();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1886
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1887
        return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1888
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1889
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1890
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1891
     * xmode parse past comment to end of line.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1892
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1893
    private int parsePastLine() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1894
        int ch = temp[cursor++];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1895
        while (ch != 0 && !isLineSeparator(ch))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1896
            ch = temp[cursor++];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1897
        return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1898
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1899
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1900
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1901
     * xmode peek past comment to end of line.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1902
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1903
    private int peekPastLine() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1904
        int ch = temp[++cursor];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1905
        while (ch != 0 && !isLineSeparator(ch))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1906
            ch = temp[++cursor];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1907
        return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1908
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1909
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1910
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1911
     * Determines if character is a line separator in the current mode
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1912
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1913
    private boolean isLineSeparator(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1914
        if (has(UNIX_LINES)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1915
            return ch == '\n';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1916
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1917
            return (ch == '\n' ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1918
                    ch == '\r' ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1919
                    (ch|1) == '\u2029' ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1920
                    ch == '\u0085');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1921
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1922
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1923
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1924
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1925
     * Read the character after the next one, and advance the cursor by two.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1926
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1927
    private int skip() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1928
        int i = cursor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1929
        int ch = temp[i+1];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1930
        cursor = i + 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1931
        return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1932
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1933
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1934
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1935
     * Unread one next character, and retreat cursor by one.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1936
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1937
    private void unread() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1938
        cursor--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1939
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1940
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1941
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1942
     * Internal method used for handling all syntax errors. The pattern is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1943
     * displayed with a pointer to aid in locating the syntax error.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1944
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1945
    private PatternSyntaxException error(String s) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1946
        return new PatternSyntaxException(s, normalizedPattern,  cursor - 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1947
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1948
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1949
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1950
     * Determines if there is any supplementary character or unpaired
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1951
     * surrogate in the specified range.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1952
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1953
    private boolean findSupplementary(int start, int end) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1954
        for (int i = start; i < end; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1955
            if (isSupplementary(temp[i]))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1956
                return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1957
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1958
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1959
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1960
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1961
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1962
     * Determines if the specified code point is a supplementary
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1963
     * character or unpaired surrogate.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1964
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1965
    private static final boolean isSupplementary(int ch) {
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1966
        return ch >= Character.MIN_SUPPLEMENTARY_CODE_POINT ||
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  1967
               Character.isSurrogate((char)ch);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1968
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1969
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1970
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1971
     *  The following methods handle the main parsing. They are sorted
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1972
     *  according to their precedence order, the lowest one first.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1973
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1974
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1975
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1976
     * The expression is parsed with branch nodes added for alternations.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1977
     * This may be called recursively to parse sub expressions that may
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1978
     * contain alternations.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1979
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1980
    private Node expr(Node end) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1981
        Node prev = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1982
        Node firstTail = null;
13554
ad737436c54a 7189363: Regex Pattern compilation buggy for special sequences
sherman
parents: 13158
diff changeset
  1983
        Branch branch = null;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1984
        Node branchConn = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1985
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1986
        for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1987
            Node node = sequence(end);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1988
            Node nodeTail = root;      //double return
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1989
            if (prev == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1990
                prev = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1991
                firstTail = nodeTail;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1992
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1993
                // Branch
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1994
                if (branchConn == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1995
                    branchConn = new BranchConn();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1996
                    branchConn.next = end;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1997
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1998
                if (node == end) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1999
                    // if the node returned from sequence() is "end"
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2000
                    // we have an empty expr, set a null atom into
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2001
                    // the branch to indicate to go "next" directly.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2002
                    node = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2003
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2004
                    // the "tail.next" of each atom goes to branchConn
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2005
                    nodeTail.next = branchConn;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2006
                }
13554
ad737436c54a 7189363: Regex Pattern compilation buggy for special sequences
sherman
parents: 13158
diff changeset
  2007
                if (prev == branch) {
ad737436c54a 7189363: Regex Pattern compilation buggy for special sequences
sherman
parents: 13158
diff changeset
  2008
                    branch.add(node);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2009
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2010
                    if (prev == end) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2011
                        prev = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2012
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2013
                        // replace the "end" with "branchConn" at its tail.next
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2014
                        // when put the "prev" into the branch as the first atom.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2015
                        firstTail.next = branchConn;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2016
                    }
13554
ad737436c54a 7189363: Regex Pattern compilation buggy for special sequences
sherman
parents: 13158
diff changeset
  2017
                    prev = branch = new Branch(prev, node, branchConn);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2018
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2019
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2020
            if (peek() != '|') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2021
                return prev;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2022
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2023
            next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2024
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2025
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2026
13158
f628cbfcbfa0 7176907: additional warnings cleanup in java.util, java.util.regexp, java.util.zip
smarks
parents: 12675
diff changeset
  2027
    @SuppressWarnings("fallthrough")
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2028
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2029
     * Parsing of sequences between alternations.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2030
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2031
    private Node sequence(Node end) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2032
        Node head = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2033
        Node tail = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2034
        Node node = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2035
    LOOP:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2036
        for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2037
            int ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2038
            switch (ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2039
            case '(':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2040
                // Because group handles its own closure,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2041
                // we need to treat it differently
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2042
                node = group0();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2043
                // Check for comment or flag group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2044
                if (node == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2045
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2046
                if (head == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2047
                    head = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2048
                else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2049
                    tail.next = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2050
                // Double return: Tail was returned in root
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2051
                tail = root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2052
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2053
            case '[':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2054
                node = clazz(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2055
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2056
            case '\\':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2057
                ch = nextEscaped();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2058
                if (ch == 'p' || ch == 'P') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2059
                    boolean oneLetter = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2060
                    boolean comp = (ch == 'P');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2061
                    ch = next(); // Consume { if present
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2062
                    if (ch != '{') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2063
                        unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2064
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2065
                        oneLetter = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2066
                    }
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2067
                    node = family(oneLetter, comp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2068
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2069
                    unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2070
                    node = atom();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2071
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2072
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2073
            case '^':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2074
                next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2075
                if (has(MULTILINE)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2076
                    if (has(UNIX_LINES))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2077
                        node = new UnixCaret();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2078
                    else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2079
                        node = new Caret();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2080
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2081
                    node = new Begin();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2082
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2083
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2084
            case '$':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2085
                next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2086
                if (has(UNIX_LINES))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2087
                    node = new UnixDollar(has(MULTILINE));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2088
                else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2089
                    node = new Dollar(has(MULTILINE));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2090
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2091
            case '.':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2092
                next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2093
                if (has(DOTALL)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2094
                    node = new All();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2095
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2096
                    if (has(UNIX_LINES))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2097
                        node = new UnixDot();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2098
                    else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2099
                        node = new Dot();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2100
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2101
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2102
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2103
            case '|':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2104
            case ')':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2105
                break LOOP;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2106
            case ']': // Now interpreting dangling ] and } as literals
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2107
            case '}':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2108
                node = atom();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2109
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2110
            case '?':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2111
            case '*':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2112
            case '+':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2113
                next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2114
                throw error("Dangling meta character '" + ((char)ch) + "'");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2115
            case 0:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2116
                if (cursor >= patternLength) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2117
                    break LOOP;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2118
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2119
                // Fall through
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2120
            default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2121
                node = atom();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2122
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2123
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2124
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2125
            node = closure(node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2126
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2127
            if (head == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2128
                head = tail = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2129
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2130
                tail.next = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2131
                tail = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2132
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2133
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2134
        if (head == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2135
            return end;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2136
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2137
        tail.next = end;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2138
        root = tail;      //double return
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2139
        return head;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2140
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2141
13158
f628cbfcbfa0 7176907: additional warnings cleanup in java.util, java.util.regexp, java.util.zip
smarks
parents: 12675
diff changeset
  2142
    @SuppressWarnings("fallthrough")
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2143
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2144
     * Parse and add a new Single or Slice.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2145
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2146
    private Node atom() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2147
        int first = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2148
        int prev = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2149
        boolean hasSupplementary = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2150
        int ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2151
        for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2152
            switch (ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2153
            case '*':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2154
            case '+':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2155
            case '?':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2156
            case '{':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2157
                if (first > 1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2158
                    cursor = prev;    // Unwind one character
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2159
                    first--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2160
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2161
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2162
            case '$':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2163
            case '.':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2164
            case '^':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2165
            case '(':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2166
            case '[':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2167
            case '|':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2168
            case ')':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2169
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2170
            case '\\':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2171
                ch = nextEscaped();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2172
                if (ch == 'p' || ch == 'P') { // Property
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2173
                    if (first > 0) { // Slice is waiting; handle it first
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2174
                        unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2175
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2176
                    } else { // No slice; just return the family node
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2177
                        boolean comp = (ch == 'P');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2178
                        boolean oneLetter = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2179
                        ch = next(); // Consume { if present
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2180
                        if (ch != '{')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2181
                            unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2182
                        else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2183
                            oneLetter = false;
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2184
                        return family(oneLetter, comp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2185
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2186
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2187
                unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2188
                prev = cursor;
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2189
                ch = escape(false, first == 0, false);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2190
                if (ch >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2191
                    append(ch, first);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2192
                    first++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2193
                    if (isSupplementary(ch)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2194
                        hasSupplementary = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2195
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2196
                    ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2197
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2198
                } else if (first == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2199
                    return root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2200
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2201
                // Unwind meta escape sequence
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2202
                cursor = prev;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2203
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2204
            case 0:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2205
                if (cursor >= patternLength) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2206
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2207
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2208
                // Fall through
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2209
            default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2210
                prev = cursor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2211
                append(ch, first);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2212
                first++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2213
                if (isSupplementary(ch)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2214
                    hasSupplementary = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2215
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2216
                ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2217
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2218
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2219
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2220
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2221
        if (first == 1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2222
            return newSingle(buffer[0]);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2223
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2224
            return newSlice(buffer, first, hasSupplementary);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2225
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2226
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2227
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2228
    private void append(int ch, int len) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2229
        if (len >= buffer.length) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2230
            int[] tmp = new int[len+len];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2231
            System.arraycopy(buffer, 0, tmp, 0, len);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2232
            buffer = tmp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2233
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2234
        buffer[len] = ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2235
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2236
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2237
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2238
     * Parses a backref greedily, taking as many numbers as it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2239
     * can. The first digit is always treated as a backref, but
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2240
     * multi digit numbers are only treated as a backref if at
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2241
     * least that many backrefs exist at this point in the regex.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2242
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2243
    private Node ref(int refNum) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2244
        boolean done = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2245
        while(!done) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2246
            int ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2247
            switch(ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2248
            case '0':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2249
            case '1':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2250
            case '2':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2251
            case '3':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2252
            case '4':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2253
            case '5':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2254
            case '6':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2255
            case '7':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2256
            case '8':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2257
            case '9':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2258
                int newRefNum = (refNum * 10) + (ch - '0');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2259
                // Add another number if it doesn't make a group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2260
                // that doesn't exist
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2261
                if (capturingGroupCount - 1 < newRefNum) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2262
                    done = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2263
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2264
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2265
                refNum = newRefNum;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2266
                read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2267
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2268
            default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2269
                done = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2270
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2271
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2272
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2273
        if (has(CASE_INSENSITIVE))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2274
            return new CIBackRef(refNum, has(UNICODE_CASE));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2275
        else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2276
            return new BackRef(refNum);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2277
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2278
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2279
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2280
     * Parses an escape sequence to determine the actual value that needs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2281
     * to be matched.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2282
     * If -1 is returned and create was true a new object was added to the tree
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2283
     * to handle the escape sequence.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2284
     * If the returned value is greater than zero, it is the value that
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2285
     * matches the escape sequence.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2286
     */
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2287
    private int escape(boolean inclass, boolean create, boolean isrange) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2288
        int ch = skip();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2289
        switch (ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2290
        case '0':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2291
            return o();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2292
        case '1':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2293
        case '2':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2294
        case '3':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2295
        case '4':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2296
        case '5':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2297
        case '6':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2298
        case '7':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2299
        case '8':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2300
        case '9':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2301
            if (inclass) break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2302
            if (create) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2303
                root = ref((ch - '0'));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2304
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2305
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2306
        case 'A':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2307
            if (inclass) break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2308
            if (create) root = new Begin();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2309
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2310
        case 'B':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2311
            if (inclass) break;
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2312
            if (create) root = new Bound(Bound.NONE, has(UNICODE_CHARACTER_CLASS));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2313
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2314
        case 'C':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2315
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2316
        case 'D':
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2317
            if (create) root = has(UNICODE_CHARACTER_CLASS)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2318
                               ? new Utype(UnicodeProp.DIGIT).complement()
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2319
                               : new Ctype(ASCII.DIGIT).complement();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2320
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2321
        case 'E':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2322
        case 'F':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2323
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2324
        case 'G':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2325
            if (inclass) break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2326
            if (create) root = new LastMatch();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2327
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2328
        case 'H':
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2329
            if (create) root = new HorizWS().complement();
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2330
            return -1;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2331
        case 'I':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2332
        case 'J':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2333
        case 'K':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2334
        case 'L':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2335
        case 'M':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2336
        case 'N':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2337
        case 'O':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2338
        case 'P':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2339
        case 'Q':
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2340
            break;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2341
        case 'R':
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2342
            if (inclass) break;
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2343
            if (create) root = new LineEnding();
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2344
            return -1;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2345
        case 'S':
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2346
            if (create) root = has(UNICODE_CHARACTER_CLASS)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2347
                               ? new Utype(UnicodeProp.WHITE_SPACE).complement()
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2348
                               : new Ctype(ASCII.SPACE).complement();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2349
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2350
        case 'T':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2351
        case 'U':
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2352
            break;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2353
        case 'V':
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2354
            if (create) root = new VertWS().complement();
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2355
            return -1;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2356
        case 'W':
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2357
            if (create) root = has(UNICODE_CHARACTER_CLASS)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2358
                               ? new Utype(UnicodeProp.WORD).complement()
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2359
                               : new Ctype(ASCII.WORD).complement();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2360
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2361
        case 'X':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2362
        case 'Y':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2363
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2364
        case 'Z':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2365
            if (inclass) break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2366
            if (create) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2367
                if (has(UNIX_LINES))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2368
                    root = new UnixDollar(false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2369
                else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2370
                    root = new Dollar(false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2371
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2372
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2373
        case 'a':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2374
            return '\007';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2375
        case 'b':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2376
            if (inclass) break;
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2377
            if (create) root = new Bound(Bound.BOTH, has(UNICODE_CHARACTER_CLASS));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2378
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2379
        case 'c':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2380
            return c();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2381
        case 'd':
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2382
            if (create) root = has(UNICODE_CHARACTER_CLASS)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2383
                               ? new Utype(UnicodeProp.DIGIT)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2384
                               : new Ctype(ASCII.DIGIT);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2385
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2386
        case 'e':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2387
            return '\033';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2388
        case 'f':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2389
            return '\f';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2390
        case 'g':
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2391
            break;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2392
        case 'h':
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2393
            if (create) root = new HorizWS();
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2394
            return -1;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2395
        case 'i':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2396
        case 'j':
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2397
            break;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2398
        case 'k':
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2399
            if (inclass)
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2400
                break;
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2401
            if (read() != '<')
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2402
                throw error("\\k is not followed by '<' for named capturing group");
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2403
            String name = groupname(read());
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2404
            if (!namedGroups().containsKey(name))
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2405
                throw error("(named capturing group <"+ name+"> does not exit");
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2406
            if (create) {
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2407
                if (has(CASE_INSENSITIVE))
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2408
                    root = new CIBackRef(namedGroups().get(name), has(UNICODE_CASE));
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2409
                else
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2410
                    root = new BackRef(namedGroups().get(name));
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2411
            }
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2412
            return -1;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2413
        case 'l':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2414
        case 'm':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2415
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2416
        case 'n':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2417
            return '\n';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2418
        case 'o':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2419
        case 'p':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2420
        case 'q':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2421
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2422
        case 'r':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2423
            return '\r';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2424
        case 's':
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2425
            if (create) root = has(UNICODE_CHARACTER_CLASS)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2426
                               ? new Utype(UnicodeProp.WHITE_SPACE)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2427
                               : new Ctype(ASCII.SPACE);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2428
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2429
        case 't':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2430
            return '\t';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2431
        case 'u':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2432
            return u();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2433
        case 'v':
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2434
            // '\v' was implemented as VT/0x0B in releases < 1.8 (though
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2435
            // undocumented). In JDK8 '\v' is specified as a predefined
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2436
            // character class for all vertical whitespace characters.
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2437
            // So [-1, root=VertWS node] pair is returned (instead of a
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2438
            // single 0x0B). This breaks the range if '\v' is used as
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2439
            // the start or end value, such as [\v-...] or [...-\v], in
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2440
            // which a single definite value (0x0B) is expected. For
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2441
            // compatiblity concern '\013'/0x0B is returned if isrange.
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2442
            if (isrange)
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2443
                return '\013';
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2444
            if (create) root = new VertWS();
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2445
            return -1;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2446
        case 'w':
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2447
            if (create) root = has(UNICODE_CHARACTER_CLASS)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2448
                               ? new Utype(UnicodeProp.WORD)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2449
                               : new Ctype(ASCII.WORD);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2450
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2451
        case 'x':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2452
            return x();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2453
        case 'y':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2454
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2455
        case 'z':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2456
            if (inclass) break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2457
            if (create) root = new End();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2458
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2459
        default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2460
            return ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2461
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2462
        throw error("Illegal/unsupported escape sequence");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2463
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2464
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2465
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2466
     * Parse a character class, and return the node that matches it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2467
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2468
     * Consumes a ] on the way out if consume is true. Usually consume
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2469
     * is true except for the case of [abc&&def] where def is a separate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2470
     * right hand node with "understood" brackets.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2471
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2472
    private CharProperty clazz(boolean consume) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2473
        CharProperty prev = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2474
        CharProperty node = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2475
        BitClass bits = new BitClass();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2476
        boolean include = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2477
        boolean firstInClass = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2478
        int ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2479
        for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2480
            switch (ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2481
                case '^':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2482
                    // Negates if first char in a class, otherwise literal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2483
                    if (firstInClass) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2484
                        if (temp[cursor-1] != '[')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2485
                            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2486
                        ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2487
                        include = !include;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2488
                        continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2489
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2490
                        // ^ not first in class, treat as literal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2491
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2492
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2493
                case '[':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2494
                    firstInClass = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2495
                    node = clazz(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2496
                    if (prev == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2497
                        prev = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2498
                    else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2499
                        prev = union(prev, node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2500
                    ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2501
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2502
                case '&':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2503
                    firstInClass = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2504
                    ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2505
                    if (ch == '&') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2506
                        ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2507
                        CharProperty rightNode = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2508
                        while (ch != ']' && ch != '&') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2509
                            if (ch == '[') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2510
                                if (rightNode == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2511
                                    rightNode = clazz(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2512
                                else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2513
                                    rightNode = union(rightNode, clazz(true));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2514
                            } else { // abc&&def
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2515
                                unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2516
                                rightNode = clazz(false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2517
                            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2518
                            ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2519
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2520
                        if (rightNode != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2521
                            node = rightNode;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2522
                        if (prev == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2523
                            if (rightNode == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2524
                                throw error("Bad class syntax");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2525
                            else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2526
                                prev = rightNode;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2527
                        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2528
                            prev = intersection(prev, node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2529
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2530
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2531
                        // treat as a literal &
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2532
                        unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2533
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2534
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2535
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2536
                case 0:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2537
                    firstInClass = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2538
                    if (cursor >= patternLength)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2539
                        throw error("Unclosed character class");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2540
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2541
                case ']':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2542
                    firstInClass = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2543
                    if (prev != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2544
                        if (consume)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2545
                            next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2546
                        return prev;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2547
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2548
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2549
                default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2550
                    firstInClass = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2551
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2552
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2553
            node = range(bits);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2554
            if (include) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2555
                if (prev == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2556
                    prev = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2557
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2558
                    if (prev != node)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2559
                        prev = union(prev, node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2560
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2561
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2562
                if (prev == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2563
                    prev = node.complement();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2564
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2565
                    if (prev != node)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2566
                        prev = setDifference(prev, node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2567
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2568
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2569
            ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2570
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2571
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2572
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2573
    private CharProperty bitsOrSingle(BitClass bits, int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2574
        /* Bits can only handle codepoints in [u+0000-u+00ff] range.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2575
           Use "single" node instead of bits when dealing with unicode
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2576
           case folding for codepoints listed below.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2577
           (1)Uppercase out of range: u+00ff, u+00b5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2578
              toUpperCase(u+00ff) -> u+0178
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2579
              toUpperCase(u+00b5) -> u+039c
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2580
           (2)LatinSmallLetterLongS u+17f
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2581
              toUpperCase(u+017f) -> u+0053
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2582
           (3)LatinSmallLetterDotlessI u+131
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2583
              toUpperCase(u+0131) -> u+0049
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2584
           (4)LatinCapitalLetterIWithDotAbove u+0130
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2585
              toLowerCase(u+0130) -> u+0069
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2586
           (5)KelvinSign u+212a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2587
              toLowerCase(u+212a) ==> u+006B
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2588
           (6)AngstromSign u+212b
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2589
              toLowerCase(u+212b) ==> u+00e5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2590
        */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2591
        int d;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2592
        if (ch < 256 &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2593
            !(has(CASE_INSENSITIVE) && has(UNICODE_CASE) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2594
              (ch == 0xff || ch == 0xb5 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2595
               ch == 0x49 || ch == 0x69 ||  //I and i
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2596
               ch == 0x53 || ch == 0x73 ||  //S and s
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2597
               ch == 0x4b || ch == 0x6b ||  //K and k
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2598
               ch == 0xc5 || ch == 0xe5)))  //A+ring
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2599
            return bits.add(ch, flags());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2600
        return newSingle(ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2601
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2602
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2603
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2604
     * Parse a single character or a character range in a character class
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2605
     * and return its representative node.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2606
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2607
    private CharProperty range(BitClass bits) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2608
        int ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2609
        if (ch == '\\') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2610
            ch = nextEscaped();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2611
            if (ch == 'p' || ch == 'P') { // A property
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2612
                boolean comp = (ch == 'P');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2613
                boolean oneLetter = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2614
                // Consume { if present
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2615
                ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2616
                if (ch != '{')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2617
                    unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2618
                else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2619
                    oneLetter = false;
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2620
                return family(oneLetter, comp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2621
            } else { // ordinary escape
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2622
                boolean isrange = temp[cursor+1] == '-';
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2623
                unread();
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2624
                ch = escape(true, true, isrange);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2625
                if (ch == -1)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2626
                    return (CharProperty) root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2627
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2628
        } else {
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2629
            next();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2630
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2631
        if (ch >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2632
            if (peek() == '-') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2633
                int endRange = temp[cursor+1];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2634
                if (endRange == '[') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2635
                    return bitsOrSingle(bits, ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2636
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2637
                if (endRange != ']') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2638
                    next();
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2639
                    int m = peek();
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2640
                    if (m == '\\') {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2641
                        m = escape(true, false, true);
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2642
                    } else {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2643
                        next();
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2644
                    }
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2645
                    if (m < ch) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2646
                        throw error("Illegal character range");
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  2647
                    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2648
                    if (has(CASE_INSENSITIVE))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2649
                        return caseInsensitiveRangeFor(ch, m);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2650
                    else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2651
                        return rangeFor(ch, m);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2652
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2653
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2654
            return bitsOrSingle(bits, ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2655
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2656
        throw error("Unexpected character '"+((char)ch)+"'");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2657
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2658
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2659
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2660
     * Parses a Unicode character family and returns its representative node.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2661
     */
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2662
    private CharProperty family(boolean singleLetter,
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2663
                                boolean maybeComplement)
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2664
    {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2665
        next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2666
        String name;
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2667
        CharProperty node = null;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2668
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2669
        if (singleLetter) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2670
            int c = temp[cursor];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2671
            if (!Character.isSupplementaryCodePoint(c)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2672
                name = String.valueOf((char)c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2673
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2674
                name = new String(temp, cursor, 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2675
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2676
            read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2677
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2678
            int i = cursor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2679
            mark('}');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2680
            while(read() != '}') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2681
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2682
            mark('\000');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2683
            int j = cursor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2684
            if (j > patternLength)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2685
                throw error("Unclosed character family");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2686
            if (i + 1 >= j)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2687
                throw error("Empty character family");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2688
            name = new String(temp, i, j-i-1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2689
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2690
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2691
        int i = name.indexOf('=');
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2692
        if (i != -1) {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2693
            // property construct \p{name=value}
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2694
            String value = name.substring(i + 1);
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2695
            name = name.substring(0, i).toLowerCase(Locale.ENGLISH);
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2696
            if ("sc".equals(name) || "script".equals(name)) {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2697
                node = unicodeScriptPropertyFor(value);
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2698
            } else if ("blk".equals(name) || "block".equals(name)) {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2699
                node = unicodeBlockPropertyFor(value);
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2700
            } else if ("gc".equals(name) || "general_category".equals(name)) {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2701
                node = charPropertyNodeFor(value);
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2702
            } else {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2703
                throw error("Unknown Unicode property {name=<" + name + ">, "
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2704
                             + "value=<" + value + ">}");
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2705
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2706
        } else {
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2707
            if (name.startsWith("In")) {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2708
                // \p{inBlockName}
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2709
                node = unicodeBlockPropertyFor(name.substring(2));
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2710
            } else if (name.startsWith("Is")) {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2711
                // \p{isGeneralCategory} and \p{isScriptName}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2712
                name = name.substring(2);
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2713
                UnicodeProp uprop = UnicodeProp.forName(name);
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2714
                if (uprop != null)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2715
                    node = new Utype(uprop);
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2716
                if (node == null)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2717
                    node = CharPropertyNames.charPropertyFor(name);
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2718
                if (node == null)
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2719
                    node = unicodeScriptPropertyFor(name);
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2720
            } else {
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2721
                if (has(UNICODE_CHARACTER_CLASS)) {
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2722
                    UnicodeProp uprop = UnicodeProp.forPOSIXName(name);
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2723
                    if (uprop != null)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2724
                        node = new Utype(uprop);
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2725
                }
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2726
                if (node == null)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  2727
                    node = charPropertyNodeFor(name);
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2728
            }
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2729
        }
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2730
        if (maybeComplement) {
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2731
            if (node instanceof Category || node instanceof Block)
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2732
                hasSupplementary = true;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2733
            node = node.complement();
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2734
        }
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2735
        return node;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2736
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2737
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2738
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2739
    /**
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2740
     * Returns a CharProperty matching all characters belong to
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2741
     * a UnicodeScript.
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2742
     */
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2743
    private CharProperty unicodeScriptPropertyFor(String name) {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2744
        final Character.UnicodeScript script;
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2745
        try {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2746
            script = Character.UnicodeScript.forName(name);
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2747
        } catch (IllegalArgumentException iae) {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2748
            throw error("Unknown character script name {" + name + "}");
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2749
        }
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2750
        return new Script(script);
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2751
    }
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  2752
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2753
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2754
     * Returns a CharProperty matching all characters in a UnicodeBlock.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2755
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2756
    private CharProperty unicodeBlockPropertyFor(String name) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2757
        final Character.UnicodeBlock block;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2758
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2759
            block = Character.UnicodeBlock.forName(name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2760
        } catch (IllegalArgumentException iae) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2761
            throw error("Unknown character block name {" + name + "}");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2762
        }
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  2763
        return new Block(block);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2764
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2765
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2766
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2767
     * Returns a CharProperty matching all characters in a named property.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2768
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2769
    private CharProperty charPropertyNodeFor(String name) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2770
        CharProperty p = CharPropertyNames.charPropertyFor(name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2771
        if (p == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2772
            throw error("Unknown character property name {" + name + "}");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2773
        return p;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2774
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2775
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2776
    /**
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2777
     * Parses and returns the name of a "named capturing group", the trailing
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2778
     * ">" is consumed after parsing.
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2779
     */
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2780
    private String groupname(int ch) {
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2781
        StringBuilder sb = new StringBuilder();
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2782
        sb.append(Character.toChars(ch));
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2783
        while (ASCII.isLower(ch=read()) || ASCII.isUpper(ch) ||
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2784
               ASCII.isDigit(ch)) {
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2785
            sb.append(Character.toChars(ch));
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2786
        }
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2787
        if (sb.length() == 0)
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2788
            throw error("named capturing group has 0 length name");
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2789
        if (ch != '>')
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2790
            throw error("named capturing group is missing trailing '>'");
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2791
        return sb.toString();
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2792
    }
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2793
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2794
    /**
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2795
     * Parses a group and returns the head node of a set of nodes that process
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2796
     * the group. Sometimes a double return system is used where the tail is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2797
     * returned in root.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2798
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2799
    private Node group0() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2800
        boolean capturingGroup = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2801
        Node head = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2802
        Node tail = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2803
        int save = flags;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2804
        root = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2805
        int ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2806
        if (ch == '?') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2807
            ch = skip();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2808
            switch (ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2809
            case ':':   //  (?:xxx) pure group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2810
                head = createGroup(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2811
                tail = root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2812
                head.next = expr(tail);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2813
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2814
            case '=':   // (?=xxx) and (?!xxx) lookahead
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2815
            case '!':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2816
                head = createGroup(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2817
                tail = root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2818
                head.next = expr(tail);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2819
                if (ch == '=') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2820
                    head = tail = new Pos(head);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2821
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2822
                    head = tail = new Neg(head);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2823
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2824
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2825
            case '>':   // (?>xxx)  independent group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2826
                head = createGroup(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2827
                tail = root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2828
                head.next = expr(tail);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2829
                head = tail = new Ques(head, INDEPENDENT);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2830
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2831
            case '<':   // (?<xxx)  look behind
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2832
                ch = read();
4161
679d00486dc6 6878475: Better syntax for the named capture group in regex
sherman
parents: 2291
diff changeset
  2833
                if (ASCII.isLower(ch) || ASCII.isUpper(ch)) {
2290
3a3bde061968 6817475: named-capturing group name started with digit causes PSE exception
sherman
parents: 2070
diff changeset
  2834
                    // named captured group
2070
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2835
                    String name = groupname(ch);
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2836
                    if (namedGroups().containsKey(name))
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2837
                        throw error("Named capturing group <" + name
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2838
                                    + "> is already defined");
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2839
                    capturingGroup = true;
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2840
                    head = createGroup(false);
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2841
                    tail = root;
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2842
                    namedGroups().put(name, capturingGroupCount-1);
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2843
                    head.next = expr(tail);
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2844
                    break;
6e9972fbd965 6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents: 715
diff changeset
  2845
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2846
                int start = cursor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2847
                head = createGroup(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2848
                tail = root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2849
                head.next = expr(tail);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2850
                tail.next = lookbehindEnd;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2851
                TreeInfo info = new TreeInfo();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2852
                head.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2853
                if (info.maxValid == false) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2854
                    throw error("Look-behind group does not have "
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2855
                                + "an obvious maximum length");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2856
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2857
                boolean hasSupplementary = findSupplementary(start, patternLength);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2858
                if (ch == '=') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2859
                    head = tail = (hasSupplementary ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2860
                                   new BehindS(head, info.maxLength,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2861
                                               info.minLength) :
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2862
                                   new Behind(head, info.maxLength,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2863
                                              info.minLength));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2864
                } else if (ch == '!') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2865
                    head = tail = (hasSupplementary ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2866
                                   new NotBehindS(head, info.maxLength,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2867
                                                  info.minLength) :
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2868
                                   new NotBehind(head, info.maxLength,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2869
                                                 info.minLength));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2870
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2871
                    throw error("Unknown look-behind group");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2872
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2873
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2874
            case '$':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2875
            case '@':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2876
                throw error("Unknown group type");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2877
            default:    // (?xxx:) inlined match flags
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2878
                unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2879
                addFlag();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2880
                ch = read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2881
                if (ch == ')') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2882
                    return null;    // Inline modifier only
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2883
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2884
                if (ch != ':') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2885
                    throw error("Unknown inline modifier");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2886
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2887
                head = createGroup(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2888
                tail = root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2889
                head.next = expr(tail);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2890
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2891
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2892
        } else { // (xxx) a regular group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2893
            capturingGroup = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2894
            head = createGroup(false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2895
            tail = root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2896
            head.next = expr(tail);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2897
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2898
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2899
        accept(')', "Unclosed group");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2900
        flags = save;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2901
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2902
        // Check for quantifiers
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2903
        Node node = closure(head);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2904
        if (node == head) { // No closure
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2905
            root = tail;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2906
            return node;    // Dual return
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2907
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2908
        if (head == tail) { // Zero length assertion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2909
            root = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2910
            return node;    // Dual return
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2911
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2912
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2913
        if (node instanceof Ques) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2914
            Ques ques = (Ques) node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2915
            if (ques.type == POSSESSIVE) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2916
                root = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2917
                return node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2918
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2919
            tail.next = new BranchConn();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2920
            tail = tail.next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2921
            if (ques.type == GREEDY) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2922
                head = new Branch(head, null, tail);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2923
            } else { // Reluctant quantifier
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2924
                head = new Branch(null, head, tail);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2925
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2926
            root = tail;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2927
            return head;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2928
        } else if (node instanceof Curly) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2929
            Curly curly = (Curly) node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2930
            if (curly.type == POSSESSIVE) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2931
                root = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2932
                return node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2933
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2934
            // Discover if the group is deterministic
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2935
            TreeInfo info = new TreeInfo();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2936
            if (head.study(info)) { // Deterministic
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2937
                GroupTail temp = (GroupTail) tail;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2938
                head = root = new GroupCurly(head.next, curly.cmin,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2939
                                   curly.cmax, curly.type,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2940
                                   ((GroupTail)tail).localIndex,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2941
                                   ((GroupTail)tail).groupIndex,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2942
                                             capturingGroup);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2943
                return head;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2944
            } else { // Non-deterministic
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2945
                int temp = ((GroupHead) head).localIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2946
                Loop loop;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2947
                if (curly.type == GREEDY)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2948
                    loop = new Loop(this.localCount, temp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2949
                else  // Reluctant Curly
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2950
                    loop = new LazyLoop(this.localCount, temp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2951
                Prolog prolog = new Prolog(loop);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2952
                this.localCount += 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2953
                loop.cmin = curly.cmin;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2954
                loop.cmax = curly.cmax;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2955
                loop.body = head;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2956
                tail.next = loop;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2957
                root = loop;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2958
                return prolog; // Dual return
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2959
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2960
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2961
        throw error("Internal logic error");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2962
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2963
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2964
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2965
     * Create group head and tail nodes using double return. If the group is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2966
     * created with anonymous true then it is a pure group and should not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2967
     * affect group counting.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2968
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2969
    private Node createGroup(boolean anonymous) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2970
        int localIndex = localCount++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2971
        int groupIndex = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2972
        if (!anonymous)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2973
            groupIndex = capturingGroupCount++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2974
        GroupHead head = new GroupHead(localIndex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2975
        root = new GroupTail(localIndex, groupIndex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2976
        if (!anonymous && groupIndex < 10)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2977
            groupNodes[groupIndex] = head;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2978
        return head;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2979
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2980
13158
f628cbfcbfa0 7176907: additional warnings cleanup in java.util, java.util.regexp, java.util.zip
smarks
parents: 12675
diff changeset
  2981
    @SuppressWarnings("fallthrough")
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2982
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2983
     * Parses inlined match flags and set them appropriately.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2984
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2985
    private void addFlag() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2986
        int ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2987
        for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2988
            switch (ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2989
            case 'i':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2990
                flags |= CASE_INSENSITIVE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2991
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2992
            case 'm':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2993
                flags |= MULTILINE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2994
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2995
            case 's':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2996
                flags |= DOTALL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2997
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2998
            case 'd':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2999
                flags |= UNIX_LINES;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3000
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3001
            case 'u':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3002
                flags |= UNICODE_CASE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3003
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3004
            case 'c':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3005
                flags |= CANON_EQ;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3006
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3007
            case 'x':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3008
                flags |= COMMENTS;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3009
                break;
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3010
            case 'U':
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3011
                flags |= (UNICODE_CHARACTER_CLASS | UNICODE_CASE);
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3012
                break;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3013
            case '-': // subFlag then fall through
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3014
                ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3015
                subFlag();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3016
            default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3017
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3018
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3019
            ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3020
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3021
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3022
13158
f628cbfcbfa0 7176907: additional warnings cleanup in java.util, java.util.regexp, java.util.zip
smarks
parents: 12675
diff changeset
  3023
    @SuppressWarnings("fallthrough")
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3024
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3025
     * Parses the second part of inlined match flags and turns off
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3026
     * flags appropriately.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3027
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3028
    private void subFlag() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3029
        int ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3030
        for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3031
            switch (ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3032
            case 'i':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3033
                flags &= ~CASE_INSENSITIVE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3034
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3035
            case 'm':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3036
                flags &= ~MULTILINE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3037
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3038
            case 's':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3039
                flags &= ~DOTALL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3040
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3041
            case 'd':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3042
                flags &= ~UNIX_LINES;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3043
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3044
            case 'u':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3045
                flags &= ~UNICODE_CASE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3046
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3047
            case 'c':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3048
                flags &= ~CANON_EQ;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3049
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3050
            case 'x':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3051
                flags &= ~COMMENTS;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3052
                break;
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3053
            case 'U':
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3054
                flags &= ~(UNICODE_CHARACTER_CLASS | UNICODE_CASE);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3055
            default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3056
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3057
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3058
            ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3059
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3060
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3061
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3062
    static final int MAX_REPS   = 0x7FFFFFFF;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3063
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3064
    static final int GREEDY     = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3065
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3066
    static final int LAZY       = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3067
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3068
    static final int POSSESSIVE = 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3069
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3070
    static final int INDEPENDENT = 3;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3071
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3072
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3073
     * Processes repetition. If the next character peeked is a quantifier
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3074
     * then new nodes must be appended to handle the repetition.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3075
     * Prev could be a single or a group, so it could be a chain of nodes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3076
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3077
    private Node closure(Node prev) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3078
        Node atom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3079
        int ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3080
        switch (ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3081
        case '?':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3082
            ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3083
            if (ch == '?') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3084
                next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3085
                return new Ques(prev, LAZY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3086
            } else if (ch == '+') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3087
                next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3088
                return new Ques(prev, POSSESSIVE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3089
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3090
            return new Ques(prev, GREEDY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3091
        case '*':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3092
            ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3093
            if (ch == '?') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3094
                next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3095
                return new Curly(prev, 0, MAX_REPS, LAZY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3096
            } else if (ch == '+') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3097
                next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3098
                return new Curly(prev, 0, MAX_REPS, POSSESSIVE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3099
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3100
            return new Curly(prev, 0, MAX_REPS, GREEDY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3101
        case '+':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3102
            ch = next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3103
            if (ch == '?') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3104
                next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3105
                return new Curly(prev, 1, MAX_REPS, LAZY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3106
            } else if (ch == '+') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3107
                next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3108
                return new Curly(prev, 1, MAX_REPS, POSSESSIVE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3109
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3110
            return new Curly(prev, 1, MAX_REPS, GREEDY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3111
        case '{':
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3112
            ch = temp[cursor+1];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3113
            if (ASCII.isDigit(ch)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3114
                skip();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3115
                int cmin = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3116
                do {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3117
                    cmin = cmin * 10 + (ch - '0');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3118
                } while (ASCII.isDigit(ch = read()));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3119
                int cmax = cmin;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3120
                if (ch == ',') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3121
                    ch = read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3122
                    cmax = MAX_REPS;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3123
                    if (ch != '}') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3124
                        cmax = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3125
                        while (ASCII.isDigit(ch)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3126
                            cmax = cmax * 10 + (ch - '0');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3127
                            ch = read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3128
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3129
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3130
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3131
                if (ch != '}')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3132
                    throw error("Unclosed counted closure");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3133
                if (((cmin) | (cmax) | (cmax - cmin)) < 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3134
                    throw error("Illegal repetition range");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3135
                Curly curly;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3136
                ch = peek();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3137
                if (ch == '?') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3138
                    next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3139
                    curly = new Curly(prev, cmin, cmax, LAZY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3140
                } else if (ch == '+') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3141
                    next();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3142
                    curly = new Curly(prev, cmin, cmax, POSSESSIVE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3143
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3144
                    curly = new Curly(prev, cmin, cmax, GREEDY);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3145
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3146
                return curly;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3147
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3148
                throw error("Illegal repetition");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3149
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3150
        default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3151
            return prev;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3152
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3153
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3154
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3155
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3156
     *  Utility method for parsing control escape sequences.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3157
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3158
    private int c() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3159
        if (cursor < patternLength) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3160
            return read() ^ 64;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3161
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3162
        throw error("Illegal control escape sequence");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3163
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3164
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3165
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3166
     *  Utility method for parsing octal escape sequences.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3167
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3168
    private int o() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3169
        int n = read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3170
        if (((n-'0')|('7'-n)) >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3171
            int m = read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3172
            if (((m-'0')|('7'-m)) >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3173
                int o = read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3174
                if ((((o-'0')|('7'-o)) >= 0) && (((n-'0')|('3'-n)) >= 0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3175
                    return (n - '0') * 64 + (m - '0') * 8 + (o - '0');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3176
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3177
                unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3178
                return (n - '0') * 8 + (m - '0');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3179
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3180
            unread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3181
            return (n - '0');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3182
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3183
        throw error("Illegal octal escape sequence");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3184
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3185
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3186
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3187
     *  Utility method for parsing hexadecimal escape sequences.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3188
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3189
    private int x() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3190
        int n = read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3191
        if (ASCII.isHexDigit(n)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3192
            int m = read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3193
            if (ASCII.isHexDigit(m)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3194
                return ASCII.toDigit(n) * 16 + ASCII.toDigit(m);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3195
            }
8173
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
  3196
        } else if (n == '{' && ASCII.isHexDigit(peek())) {
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
  3197
            int ch = 0;
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
  3198
            while (ASCII.isHexDigit(n = read())) {
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
  3199
                ch = (ch << 4) + ASCII.toDigit(n);
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
  3200
                if (ch > Character.MAX_CODE_POINT)
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
  3201
                    throw error("Hexadecimal codepoint is too big");
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
  3202
            }
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
  3203
            if (n != '}')
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
  3204
                throw error("Unclosed hexadecimal escape sequence");
a3a39b98e05a 7014645: Support perl style Unicode hex notation \x{...}
sherman
parents: 7816
diff changeset
  3205
            return ch;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3206
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3207
        throw error("Illegal hexadecimal escape sequence");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3208
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3209
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3210
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3211
     *  Utility method for parsing unicode escape sequences.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3212
     */
404
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3213
    private int cursor() {
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3214
        return cursor;
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3215
    }
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3216
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3217
    private void setcursor(int pos) {
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3218
        cursor = pos;
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3219
    }
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3220
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3221
    private int uxxxx() {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3222
        int n = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3223
        for (int i = 0; i < 4; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3224
            int ch = read();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3225
            if (!ASCII.isHexDigit(ch)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3226
                throw error("Illegal Unicode escape sequence");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3227
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3228
            n = n * 16 + ASCII.toDigit(ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3229
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3230
        return n;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3231
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3232
404
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3233
    private int u() {
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3234
        int n = uxxxx();
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3235
        if (Character.isHighSurrogate((char)n)) {
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3236
            int cur = cursor();
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3237
            if (read() == '\\' && read() == 'u') {
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3238
                int n2 = uxxxx();
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3239
                if (Character.isLowSurrogate((char)n2))
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3240
                    return Character.toCodePoint((char)n, (char)n2);
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3241
            }
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3242
            setcursor(cur);
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3243
        }
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3244
        return n;
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3245
    }
0f6ea24796a4 6635133: Exception thrown when using a Unicode escape
sherman
parents: 2
diff changeset
  3246
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3247
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3248
    // Utility methods for code point support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3249
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3250
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3251
    private static final int countChars(CharSequence seq, int index,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3252
                                        int lengthInCodePoints) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3253
        // optimization
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3254
        if (lengthInCodePoints == 1 && !Character.isHighSurrogate(seq.charAt(index))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3255
            assert (index >= 0 && index < seq.length());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3256
            return 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3257
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3258
        int length = seq.length();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3259
        int x = index;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3260
        if (lengthInCodePoints >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3261
            assert (index >= 0 && index < length);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3262
            for (int i = 0; x < length && i < lengthInCodePoints; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3263
                if (Character.isHighSurrogate(seq.charAt(x++))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3264
                    if (x < length && Character.isLowSurrogate(seq.charAt(x))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3265
                        x++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3266
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3267
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3268
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3269
            return x - index;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3270
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3271
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3272
        assert (index >= 0 && index <= length);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3273
        if (index == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3274
            return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3275
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3276
        int len = -lengthInCodePoints;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3277
        for (int i = 0; x > 0 && i < len; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3278
            if (Character.isLowSurrogate(seq.charAt(--x))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3279
                if (x > 0 && Character.isHighSurrogate(seq.charAt(x-1))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3280
                    x--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3281
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3282
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3283
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3284
        return index - x;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3285
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3286
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3287
    private static final int countCodePoints(CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3288
        int length = seq.length();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3289
        int n = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3290
        for (int i = 0; i < length; ) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3291
            n++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3292
            if (Character.isHighSurrogate(seq.charAt(i++))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3293
                if (i < length && Character.isLowSurrogate(seq.charAt(i))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3294
                    i++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3295
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3296
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3297
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3298
        return n;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3299
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3300
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3301
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3302
     *  Creates a bit vector for matching Latin-1 values. A normal BitClass
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3303
     *  never matches values above Latin-1, and a complemented BitClass always
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3304
     *  matches values above Latin-1.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3305
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3306
    private static final class BitClass extends BmpCharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3307
        final boolean[] bits;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3308
        BitClass() { bits = new boolean[256]; }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3309
        private BitClass(boolean[] bits) { this.bits = bits; }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3310
        BitClass add(int c, int flags) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3311
            assert c >= 0 && c <= 255;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3312
            if ((flags & CASE_INSENSITIVE) != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3313
                if (ASCII.isAscii(c)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3314
                    bits[ASCII.toUpper(c)] = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3315
                    bits[ASCII.toLower(c)] = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3316
                } else if ((flags & UNICODE_CASE) != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3317
                    bits[Character.toLowerCase(c)] = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3318
                    bits[Character.toUpperCase(c)] = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3319
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3320
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3321
            bits[c] = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3322
            return this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3323
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3324
        boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3325
            return ch < 256 && bits[ch];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3326
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3327
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3328
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3329
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3330
     *  Returns a suitably optimized, single character matcher.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3331
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3332
    private CharProperty newSingle(final int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3333
        if (has(CASE_INSENSITIVE)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3334
            int lower, upper;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3335
            if (has(UNICODE_CASE)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3336
                upper = Character.toUpperCase(ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3337
                lower = Character.toLowerCase(upper);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3338
                if (upper != lower)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3339
                    return new SingleU(lower);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3340
            } else if (ASCII.isAscii(ch)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3341
                lower = ASCII.toLower(ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3342
                upper = ASCII.toUpper(ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3343
                if (lower != upper)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3344
                    return new SingleI(lower, upper);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3345
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3346
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3347
        if (isSupplementary(ch))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3348
            return new SingleS(ch);    // Match a given Unicode character
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3349
        return new Single(ch);         // Match a given BMP character
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3350
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3351
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3352
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3353
     *  Utility method for creating a string slice matcher.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3354
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3355
    private Node newSlice(int[] buf, int count, boolean hasSupplementary) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3356
        int[] tmp = new int[count];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3357
        if (has(CASE_INSENSITIVE)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3358
            if (has(UNICODE_CASE)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3359
                for (int i = 0; i < count; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3360
                    tmp[i] = Character.toLowerCase(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3361
                                 Character.toUpperCase(buf[i]));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3362
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3363
                return hasSupplementary? new SliceUS(tmp) : new SliceU(tmp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3364
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3365
            for (int i = 0; i < count; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3366
                tmp[i] = ASCII.toLower(buf[i]);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3367
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3368
            return hasSupplementary? new SliceIS(tmp) : new SliceI(tmp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3369
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3370
        for (int i = 0; i < count; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3371
            tmp[i] = buf[i];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3372
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3373
        return hasSupplementary ? new SliceS(tmp) : new Slice(tmp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3374
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3375
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3376
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3377
     * The following classes are the building components of the object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3378
     * tree that represents a compiled regular expression. The object tree
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3379
     * is made of individual elements that handle constructs in the Pattern.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3380
     * Each type of object knows how to match its equivalent construct with
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3381
     * the match() method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3382
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3383
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3384
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3385
     * Base class for all node classes. Subclasses should override the match()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3386
     * method as appropriate. This class is an accepting node, so its match()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3387
     * always returns true.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3388
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3389
    static class Node extends Object {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3390
        Node next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3391
        Node() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3392
            next = Pattern.accept;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3393
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3394
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3395
         * This method implements the classic accept node.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3396
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3397
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3398
            matcher.last = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3399
            matcher.groups[0] = matcher.first;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3400
            matcher.groups[1] = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3401
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3402
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3403
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3404
         * This method is good for all zero length assertions.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3405
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3406
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3407
            if (next != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3408
                return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3409
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3410
                return info.deterministic;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3411
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3412
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3413
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3414
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3415
    static class LastNode extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3416
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3417
         * This method implements the classic accept node with
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3418
         * the addition of a check to see if the match occurred
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3419
         * using all of the input.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3420
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3421
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3422
            if (matcher.acceptMode == Matcher.ENDANCHOR && i != matcher.to)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3423
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3424
            matcher.last = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3425
            matcher.groups[0] = matcher.first;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3426
            matcher.groups[1] = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3427
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3428
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3429
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3430
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3431
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3432
     * Used for REs that can start anywhere within the input string.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3433
     * This basically tries to match repeatedly at each spot in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3434
     * input string, moving forward after each try. An anchored search
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3435
     * or a BnM will bypass this node completely.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3436
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3437
    static class Start extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3438
        int minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3439
        Start(Node node) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3440
            this.next = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3441
            TreeInfo info = new TreeInfo();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3442
            next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3443
            minLength = info.minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3444
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3445
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3446
            if (i > matcher.to - minLength) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3447
                matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3448
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3449
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3450
            int guard = matcher.to - minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3451
            for (; i <= guard; i++) {
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3452
                if (next.match(matcher, i, seq)) {
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3453
                    matcher.first = i;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3454
                    matcher.groups[0] = matcher.first;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3455
                    matcher.groups[1] = matcher.last;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3456
                    return true;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3457
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3458
            }
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3459
            matcher.hitEnd = true;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3460
            return false;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3461
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3462
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3463
            next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3464
            info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3465
            info.deterministic = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3466
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3467
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3468
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3469
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3470
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3471
     * StartS supports supplementary characters, including unpaired surrogates.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3472
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3473
    static final class StartS extends Start {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3474
        StartS(Node node) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3475
            super(node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3476
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3477
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3478
            if (i > matcher.to - minLength) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3479
                matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3480
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3481
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3482
            int guard = matcher.to - minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3483
            while (i <= guard) {
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3484
                //if ((ret = next.match(matcher, i, seq)) || i == guard)
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3485
                if (next.match(matcher, i, seq)) {
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3486
                    matcher.first = i;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3487
                    matcher.groups[0] = matcher.first;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3488
                    matcher.groups[1] = matcher.last;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3489
                    return true;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3490
                }
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3491
                if (i == guard)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3492
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3493
                // Optimization to move to the next character. This is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3494
                // faster than countChars(seq, i, 1).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3495
                if (Character.isHighSurrogate(seq.charAt(i++))) {
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3496
                    if (i < seq.length() &&
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3497
                        Character.isLowSurrogate(seq.charAt(i))) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3498
                        i++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3499
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3500
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3501
            }
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3502
            matcher.hitEnd = true;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3503
            return false;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3504
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3505
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3506
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3507
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3508
     * Node to anchor at the beginning of input. This object implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3509
     * match for a \A sequence, and the caret anchor will use this if not in
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3510
     * multiline mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3511
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3512
    static final class Begin extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3513
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3514
            int fromIndex = (matcher.anchoringBounds) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3515
                matcher.from : 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3516
            if (i == fromIndex && next.match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3517
                matcher.first = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3518
                matcher.groups[0] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3519
                matcher.groups[1] = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3520
                return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3521
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3522
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3523
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3524
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3525
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3526
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3527
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3528
     * Node to anchor at the end of input. This is the absolute end, so this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3529
     * should not match at the last newline before the end as $ will.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3530
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3531
    static final class End extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3532
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3533
            int endIndex = (matcher.anchoringBounds) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3534
                matcher.to : matcher.getTextLength();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3535
            if (i == endIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3536
                matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3537
                return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3538
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3539
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3540
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3541
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3542
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3543
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3544
     * Node to anchor at the beginning of a line. This is essentially the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3545
     * object to match for the multiline ^.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3546
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3547
    static final class Caret extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3548
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3549
            int startIndex = matcher.from;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3550
            int endIndex = matcher.to;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3551
            if (!matcher.anchoringBounds) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3552
                startIndex = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3553
                endIndex = matcher.getTextLength();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3554
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3555
            // Perl does not match ^ at end of input even after newline
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3556
            if (i == endIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3557
                matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3558
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3559
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3560
            if (i > startIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3561
                char ch = seq.charAt(i-1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3562
                if (ch != '\n' && ch != '\r'
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3563
                    && (ch|1) != '\u2029'
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3564
                    && ch != '\u0085' ) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3565
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3566
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3567
                // Should treat /r/n as one newline
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3568
                if (ch == '\r' && seq.charAt(i) == '\n')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3569
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3570
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3571
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3572
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3573
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3574
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3575
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3576
     * Node to anchor at the beginning of a line when in unixdot mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3577
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3578
    static final class UnixCaret extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3579
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3580
            int startIndex = matcher.from;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3581
            int endIndex = matcher.to;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3582
            if (!matcher.anchoringBounds) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3583
                startIndex = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3584
                endIndex = matcher.getTextLength();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3585
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3586
            // Perl does not match ^ at end of input even after newline
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3587
            if (i == endIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3588
                matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3589
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3590
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3591
            if (i > startIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3592
                char ch = seq.charAt(i-1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3593
                if (ch != '\n') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3594
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3595
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3596
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3597
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3598
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3599
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3600
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3601
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3602
     * Node to match the location where the last match ended.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3603
     * This is used for the \G construct.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3604
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3605
    static final class LastMatch extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3606
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3607
            if (i != matcher.oldLast)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3608
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3609
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3610
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3611
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3612
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3613
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3614
     * Node to anchor at the end of a line or the end of input based on the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3615
     * multiline mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3616
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3617
     * When not in multiline mode, the $ can only match at the very end
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3618
     * of the input, unless the input ends in a line terminator in which
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3619
     * it matches right before the last line terminator.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3620
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3621
     * Note that \r\n is considered an atomic line terminator.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3622
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3623
     * Like ^ the $ operator matches at a position, it does not match the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3624
     * line terminators themselves.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3625
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3626
    static final class Dollar extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3627
        boolean multiline;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3628
        Dollar(boolean mul) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3629
            multiline = mul;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3630
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3631
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3632
            int endIndex = (matcher.anchoringBounds) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3633
                matcher.to : matcher.getTextLength();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3634
            if (!multiline) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3635
                if (i < endIndex - 2)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3636
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3637
                if (i == endIndex - 2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3638
                    char ch = seq.charAt(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3639
                    if (ch != '\r')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3640
                        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3641
                    ch = seq.charAt(i + 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3642
                    if (ch != '\n')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3643
                        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3644
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3645
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3646
            // Matches before any line terminator; also matches at the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3647
            // end of input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3648
            // Before line terminator:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3649
            // If multiline, we match here no matter what
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3650
            // If not multiline, fall through so that the end
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3651
            // is marked as hit; this must be a /r/n or a /n
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3652
            // at the very end so the end was hit; more input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3653
            // could make this not match here
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3654
            if (i < endIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3655
                char ch = seq.charAt(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3656
                 if (ch == '\n') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3657
                     // No match between \r\n
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3658
                     if (i > 0 && seq.charAt(i-1) == '\r')
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3659
                         return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3660
                     if (multiline)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3661
                         return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3662
                 } else if (ch == '\r' || ch == '\u0085' ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3663
                            (ch|1) == '\u2029') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3664
                     if (multiline)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3665
                         return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3666
                 } else { // No line terminator, no match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3667
                     return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3668
                 }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3669
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3670
            // Matched at current end so hit end
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3671
            matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3672
            // If a $ matches because of end of input, then more input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3673
            // could cause it to fail!
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3674
            matcher.requireEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3675
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3676
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3677
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3678
            next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3679
            return info.deterministic;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3680
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3681
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3682
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3683
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3684
     * Node to anchor at the end of a line or the end of input based on the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3685
     * multiline mode when in unix lines mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3686
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3687
    static final class UnixDollar extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3688
        boolean multiline;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3689
        UnixDollar(boolean mul) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3690
            multiline = mul;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3691
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3692
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3693
            int endIndex = (matcher.anchoringBounds) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3694
                matcher.to : matcher.getTextLength();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3695
            if (i < endIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3696
                char ch = seq.charAt(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3697
                if (ch == '\n') {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3698
                    // If not multiline, then only possible to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3699
                    // match at very end or one before end
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3700
                    if (multiline == false && i != endIndex - 1)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3701
                        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3702
                    // If multiline return next.match without setting
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3703
                    // matcher.hitEnd
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3704
                    if (multiline)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3705
                        return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3706
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3707
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3708
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3709
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3710
            // Matching because at the end or 1 before the end;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3711
            // more input could change this so set hitEnd
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3712
            matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3713
            // If a $ matches because of end of input, then more input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3714
            // could cause it to fail!
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3715
            matcher.requireEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3716
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3717
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3718
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3719
            next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3720
            return info.deterministic;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3721
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3722
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3723
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3724
    /**
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3725
     * Node class that matches a Unicode line ending '\R'
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3726
     */
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3727
    static final class LineEnding extends Node {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3728
        boolean match(Matcher matcher, int i, CharSequence seq) {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3729
            // (u+000Du+000A|[u+000Au+000Bu+000Cu+000Du+0085u+2028u+2029])
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3730
            if (i < matcher.to) {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3731
                int ch = seq.charAt(i);
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3732
                if (ch == 0x0A || ch == 0x0B || ch == 0x0C ||
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3733
                    ch == 0x85 || ch == 0x2028 || ch == 0x2029)
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3734
                    return next.match(matcher, i + 1, seq);
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3735
                if (ch == 0x0D) {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3736
                    i++;
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3737
                    if (i < matcher.to && seq.charAt(i) == 0x0A)
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3738
                        i++;
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3739
                    return next.match(matcher, i, seq);
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3740
                }
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3741
            } else {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3742
                matcher.hitEnd = true;
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3743
            }
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3744
            return false;
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3745
        }
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3746
        boolean study(TreeInfo info) {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3747
            info.minLength++;
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3748
            info.maxLength += 2;
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3749
            return next.study(info);
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3750
        }
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3751
    }
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3752
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3753
    /**
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3754
     * Abstract node class to match one character satisfying some
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3755
     * boolean property.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3756
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3757
    private static abstract class CharProperty extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3758
        abstract boolean isSatisfiedBy(int ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3759
        CharProperty complement() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3760
            return new CharProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3761
                    boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3762
                        return ! CharProperty.this.isSatisfiedBy(ch);}};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3763
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3764
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3765
            if (i < matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3766
                int ch = Character.codePointAt(seq, i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3767
                return isSatisfiedBy(ch)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3768
                    && next.match(matcher, i+Character.charCount(ch), seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3769
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3770
                matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3771
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3772
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3773
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3774
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3775
            info.minLength++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3776
            info.maxLength++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3777
            return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3778
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3779
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3780
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3781
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3782
     * Optimized version of CharProperty that works only for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3783
     * properties never satisfied by Supplementary characters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3784
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3785
    private static abstract class BmpCharProperty extends CharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3786
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3787
            if (i < matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3788
                return isSatisfiedBy(seq.charAt(i))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3789
                    && next.match(matcher, i+1, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3790
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3791
                matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3792
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3793
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3794
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3795
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3796
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3797
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3798
     * Node class that matches a Supplementary Unicode character
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3799
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3800
    static final class SingleS extends CharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3801
        final int c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3802
        SingleS(int c) { this.c = c; }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3803
        boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3804
            return ch == c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3805
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3806
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3807
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3808
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3809
     * Optimization -- matches a given BMP character
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3810
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3811
    static final class Single extends BmpCharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3812
        final int c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3813
        Single(int c) { this.c = c; }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3814
        boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3815
            return ch == c;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3816
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3817
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3818
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3819
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3820
     * Case insensitive matches a given BMP character
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3821
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3822
    static final class SingleI extends BmpCharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3823
        final int lower;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3824
        final int upper;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3825
        SingleI(int lower, int upper) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3826
            this.lower = lower;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3827
            this.upper = upper;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3828
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3829
        boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3830
            return ch == lower || ch == upper;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3831
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3832
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3833
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3834
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3835
     * Unicode case insensitive matches a given Unicode character
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3836
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3837
    static final class SingleU extends CharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3838
        final int lower;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3839
        SingleU(int lower) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3840
            this.lower = lower;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3841
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3842
        boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3843
            return lower == ch ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3844
                lower == Character.toLowerCase(Character.toUpperCase(ch));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3845
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3846
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3847
4820
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3848
    /**
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3849
     * Node class that matches a Unicode block.
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3850
     */
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3851
    static final class Block extends CharProperty {
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3852
        final Character.UnicodeBlock block;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3853
        Block(Character.UnicodeBlock block) {
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3854
            this.block = block;
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3855
        }
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3856
        boolean isSatisfiedBy(int ch) {
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3857
            return block == Character.UnicodeBlock.of(ch);
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3858
        }
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3859
    }
e32f5d2ba062 6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents: 4161
diff changeset
  3860
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3861
    /**
5610
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3862
     * Node class that matches a Unicode script
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3863
     */
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3864
    static final class Script extends CharProperty {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3865
        final Character.UnicodeScript script;
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3866
        Script(Character.UnicodeScript script) {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3867
            this.script = script;
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3868
        }
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3869
        boolean isSatisfiedBy(int ch) {
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3870
            return script == Character.UnicodeScript.of(ch);
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3871
        }
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3872
    }
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3873
fd2427610c7f 6945564: Unicode script support in Character class
sherman
parents: 4820
diff changeset
  3874
    /**
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3875
     * Node class that matches a Unicode category.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3876
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3877
    static final class Category extends CharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3878
        final int typeMask;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3879
        Category(int typeMask) { this.typeMask = typeMask; }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3880
        boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3881
            return (typeMask & (1 << Character.getType(ch))) != 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3882
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3883
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3884
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3885
    /**
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3886
     * Node class that matches a Unicode "type"
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3887
     */
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3888
    static final class Utype extends CharProperty {
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3889
        final UnicodeProp uprop;
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3890
        Utype(UnicodeProp uprop) { this.uprop = uprop; }
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3891
        boolean isSatisfiedBy(int ch) {
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3892
            return uprop.is(ch);
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3893
        }
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3894
    }
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3895
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  3896
    /**
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3897
     * Node class that matches a POSIX type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3898
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3899
    static final class Ctype extends BmpCharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3900
        final int ctype;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3901
        Ctype(int ctype) { this.ctype = ctype; }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3902
        boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3903
            return ch < 128 && ASCII.isType(ch, ctype);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3904
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3905
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3906
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3907
    /**
12675
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3908
     * Node class that matches a Perl vertical whitespace
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3909
     */
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3910
    static final class VertWS extends BmpCharProperty {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3911
        boolean isSatisfiedBy(int cp) {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3912
            return (cp >= 0x0A && cp <= 0x0D) ||
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3913
                   cp == 0x85 || cp == 0x2028 || cp == 0x2029;
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3914
        }
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3915
    }
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3916
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3917
    /**
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3918
     * Node class that matches a Perl horizontal whitespace
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3919
     */
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3920
    static final class HorizWS extends BmpCharProperty {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3921
        boolean isSatisfiedBy(int cp) {
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3922
            return cp == 0x09 || cp == 0x20 || cp == 0xa0 ||
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3923
                   cp == 0x1680 || cp == 0x180e ||
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3924
                   cp >= 0x2000 && cp <= 0x200a ||
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3925
                   cp == 0x202f || cp == 0x205f || cp == 0x3000;
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3926
        }
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3927
    }
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3928
3b7d71495649 7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents: 11287
diff changeset
  3929
    /**
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3930
     * Base class for all Slice nodes
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3931
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3932
    static class SliceNode extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3933
        int[] buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3934
        SliceNode(int[] buf) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3935
            buffer = buf;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3936
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3937
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3938
            info.minLength += buffer.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3939
            info.maxLength += buffer.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3940
            return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3941
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3942
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3943
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3944
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3945
     * Node class for a case sensitive/BMP-only sequence of literal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3946
     * characters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3947
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3948
    static final class Slice extends SliceNode {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3949
        Slice(int[] buf) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3950
            super(buf);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3951
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3952
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3953
            int[] buf = buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3954
            int len = buf.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3955
            for (int j=0; j<len; j++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3956
                if ((i+j) >= matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3957
                    matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3958
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3959
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3960
                if (buf[j] != seq.charAt(i+j))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3961
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3962
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3963
            return next.match(matcher, i+len, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3964
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3965
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3966
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3967
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3968
     * Node class for a case_insensitive/BMP-only sequence of literal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3969
     * characters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3970
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3971
    static class SliceI extends SliceNode {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3972
        SliceI(int[] buf) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3973
            super(buf);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3974
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3975
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3976
            int[] buf = buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3977
            int len = buf.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3978
            for (int j=0; j<len; j++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3979
                if ((i+j) >= matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3980
                    matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3981
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3982
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3983
                int c = seq.charAt(i+j);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3984
                if (buf[j] != c &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3985
                    buf[j] != ASCII.toLower(c))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3986
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3987
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3988
            return next.match(matcher, i+len, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3989
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3990
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3991
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3992
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3993
     * Node class for a unicode_case_insensitive/BMP-only sequence of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3994
     * literal characters. Uses unicode case folding.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3995
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3996
    static final class SliceU extends SliceNode {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3997
        SliceU(int[] buf) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3998
            super(buf);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3999
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4000
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4001
            int[] buf = buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4002
            int len = buf.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4003
            for (int j=0; j<len; j++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4004
                if ((i+j) >= matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4005
                    matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4006
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4007
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4008
                int c = seq.charAt(i+j);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4009
                if (buf[j] != c &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4010
                    buf[j] != Character.toLowerCase(Character.toUpperCase(c)))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4011
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4012
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4013
            return next.match(matcher, i+len, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4014
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4015
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4016
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4017
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4018
     * Node class for a case sensitive sequence of literal characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4019
     * including supplementary characters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4020
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4021
    static final class SliceS extends SliceNode {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4022
        SliceS(int[] buf) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4023
            super(buf);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4024
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4025
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4026
            int[] buf = buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4027
            int x = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4028
            for (int j = 0; j < buf.length; j++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4029
                if (x >= matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4030
                    matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4031
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4032
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4033
                int c = Character.codePointAt(seq, x);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4034
                if (buf[j] != c)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4035
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4036
                x += Character.charCount(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4037
                if (x > matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4038
                    matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4039
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4040
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4041
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4042
            return next.match(matcher, x, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4043
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4044
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4045
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4046
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4047
     * Node class for a case insensitive sequence of literal characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4048
     * including supplementary characters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4049
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4050
    static class SliceIS extends SliceNode {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4051
        SliceIS(int[] buf) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4052
            super(buf);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4053
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4054
        int toLower(int c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4055
            return ASCII.toLower(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4056
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4057
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4058
            int[] buf = buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4059
            int x = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4060
            for (int j = 0; j < buf.length; j++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4061
                if (x >= matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4062
                    matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4063
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4064
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4065
                int c = Character.codePointAt(seq, x);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4066
                if (buf[j] != c && buf[j] != toLower(c))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4067
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4068
                x += Character.charCount(c);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4069
                if (x > matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4070
                    matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4071
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4072
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4073
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4074
            return next.match(matcher, x, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4075
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4076
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4077
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4078
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4079
     * Node class for a case insensitive sequence of literal characters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4080
     * Uses unicode case folding.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4081
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4082
    static final class SliceUS extends SliceIS {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4083
        SliceUS(int[] buf) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4084
            super(buf);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4085
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4086
        int toLower(int c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4087
            return Character.toLowerCase(Character.toUpperCase(c));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4088
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4089
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4090
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4091
    private static boolean inRange(int lower, int ch, int upper) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4092
        return lower <= ch && ch <= upper;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4093
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4094
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4095
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4096
     * Returns node for matching characters within an explicit value range.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4097
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4098
    private static CharProperty rangeFor(final int lower,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4099
                                         final int upper) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4100
        return new CharProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4101
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4102
                    return inRange(lower, ch, upper);}};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4103
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4104
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4105
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4106
     * Returns node for matching characters within an explicit value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4107
     * range in a case insensitive manner.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4108
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4109
    private CharProperty caseInsensitiveRangeFor(final int lower,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4110
                                                 final int upper) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4111
        if (has(UNICODE_CASE))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4112
            return new CharProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4113
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4114
                    if (inRange(lower, ch, upper))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4115
                        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4116
                    int up = Character.toUpperCase(ch);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4117
                    return inRange(lower, up, upper) ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4118
                           inRange(lower, Character.toLowerCase(up), upper);}};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4119
        return new CharProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4120
            boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4121
                return inRange(lower, ch, upper) ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4122
                    ASCII.isAscii(ch) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4123
                        (inRange(lower, ASCII.toUpper(ch), upper) ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4124
                         inRange(lower, ASCII.toLower(ch), upper));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4125
            }};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4126
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4127
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4128
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4129
     * Implements the Unicode category ALL and the dot metacharacter when
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4130
     * in dotall mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4131
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4132
    static final class All extends CharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4133
        boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4134
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4135
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4136
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4137
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4138
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4139
     * Node class for the dot metacharacter when dotall is not enabled.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4140
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4141
    static final class Dot extends CharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4142
        boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4143
            return (ch != '\n' && ch != '\r'
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4144
                    && (ch|1) != '\u2029'
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4145
                    && ch != '\u0085');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4146
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4147
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4148
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4149
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4150
     * Node class for the dot metacharacter when dotall is not enabled
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4151
     * but UNIX_LINES is enabled.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4152
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4153
    static final class UnixDot extends CharProperty {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4154
        boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4155
            return ch != '\n';
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4156
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4157
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4158
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4159
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4160
     * The 0 or 1 quantifier. This one class implements all three types.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4161
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4162
    static final class Ques extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4163
        Node atom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4164
        int type;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4165
        Ques(Node node, int type) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4166
            this.atom = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4167
            this.type = type;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4168
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4169
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4170
            switch (type) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4171
            case GREEDY:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4172
                return (atom.match(matcher, i, seq) && next.match(matcher, matcher.last, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4173
                    || next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4174
            case LAZY:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4175
                return next.match(matcher, i, seq)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4176
                    || (atom.match(matcher, i, seq) && next.match(matcher, matcher.last, seq));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4177
            case POSSESSIVE:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4178
                if (atom.match(matcher, i, seq)) i = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4179
                return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4180
            default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4181
                return atom.match(matcher, i, seq) && next.match(matcher, matcher.last, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4182
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4183
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4184
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4185
            if (type != INDEPENDENT) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4186
                int minL = info.minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4187
                atom.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4188
                info.minLength = minL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4189
                info.deterministic = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4190
                return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4191
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4192
                atom.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4193
                return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4194
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4195
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4196
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4197
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4198
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4199
     * Handles the curly-brace style repetition with a specified minimum and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4200
     * maximum occurrences. The * quantifier is handled as a special case.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4201
     * This class handles the three types.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4202
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4203
    static final class Curly extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4204
        Node atom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4205
        int type;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4206
        int cmin;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4207
        int cmax;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4208
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4209
        Curly(Node node, int cmin, int cmax, int type) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4210
            this.atom = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4211
            this.type = type;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4212
            this.cmin = cmin;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4213
            this.cmax = cmax;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4214
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4215
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4216
            int j;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4217
            for (j = 0; j < cmin; j++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4218
                if (atom.match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4219
                    i = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4220
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4221
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4222
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4223
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4224
            if (type == GREEDY)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4225
                return match0(matcher, i, j, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4226
            else if (type == LAZY)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4227
                return match1(matcher, i, j, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4228
            else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4229
                return match2(matcher, i, j, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4230
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4231
        // Greedy match.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4232
        // i is the index to start matching at
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4233
        // j is the number of atoms that have matched
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4234
        boolean match0(Matcher matcher, int i, int j, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4235
            if (j >= cmax) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4236
                // We have matched the maximum... continue with the rest of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4237
                // the regular expression
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4238
                return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4239
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4240
            int backLimit = j;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4241
            while (atom.match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4242
                // k is the length of this match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4243
                int k = matcher.last - i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4244
                if (k == 0) // Zero length match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4245
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4246
                // Move up index and number matched
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4247
                i = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4248
                j++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4249
                // We are greedy so match as many as we can
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4250
                while (j < cmax) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4251
                    if (!atom.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4252
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4253
                    if (i + k != matcher.last) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4254
                        if (match0(matcher, matcher.last, j+1, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4255
                            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4256
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4257
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4258
                    i += k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4259
                    j++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4260
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4261
                // Handle backing off if match fails
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4262
                while (j >= backLimit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4263
                   if (next.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4264
                        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4265
                    i -= k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4266
                    j--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4267
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4268
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4269
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4270
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4271
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4272
        // Reluctant match. At this point, the minimum has been satisfied.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4273
        // i is the index to start matching at
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4274
        // j is the number of atoms that have matched
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4275
        boolean match1(Matcher matcher, int i, int j, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4276
            for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4277
                // Try finishing match without consuming any more
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4278
                if (next.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4279
                    return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4280
                // At the maximum, no match found
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4281
                if (j >= cmax)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4282
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4283
                // Okay, must try one more atom
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4284
                if (!atom.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4285
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4286
                // If we haven't moved forward then must break out
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4287
                if (i == matcher.last)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4288
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4289
                // Move up index and number matched
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4290
                i = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4291
                j++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4292
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4293
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4294
        boolean match2(Matcher matcher, int i, int j, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4295
            for (; j < cmax; j++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4296
                if (!atom.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4297
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4298
                if (i == matcher.last)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4299
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4300
                i = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4301
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4302
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4303
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4304
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4305
            // Save original info
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4306
            int minL = info.minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4307
            int maxL = info.maxLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4308
            boolean maxV = info.maxValid;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4309
            boolean detm = info.deterministic;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4310
            info.reset();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4311
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4312
            atom.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4313
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4314
            int temp = info.minLength * cmin + minL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4315
            if (temp < minL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4316
                temp = 0xFFFFFFF; // arbitrary large number
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4317
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4318
            info.minLength = temp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4319
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4320
            if (maxV & info.maxValid) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4321
                temp = info.maxLength * cmax + maxL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4322
                info.maxLength = temp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4323
                if (temp < maxL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4324
                    info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4325
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4326
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4327
                info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4328
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4329
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4330
            if (info.deterministic && cmin == cmax)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4331
                info.deterministic = detm;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4332
            else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4333
                info.deterministic = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4334
            return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4335
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4336
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4337
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4338
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4339
     * Handles the curly-brace style repetition with a specified minimum and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4340
     * maximum occurrences in deterministic cases. This is an iterative
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4341
     * optimization over the Prolog and Loop system which would handle this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4342
     * in a recursive way. The * quantifier is handled as a special case.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4343
     * If capture is true then this class saves group settings and ensures
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4344
     * that groups are unset when backing off of a group match.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4345
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4346
    static final class GroupCurly extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4347
        Node atom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4348
        int type;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4349
        int cmin;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4350
        int cmax;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4351
        int localIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4352
        int groupIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4353
        boolean capture;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4354
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4355
        GroupCurly(Node node, int cmin, int cmax, int type, int local,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4356
                   int group, boolean capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4357
            this.atom = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4358
            this.type = type;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4359
            this.cmin = cmin;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4360
            this.cmax = cmax;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4361
            this.localIndex = local;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4362
            this.groupIndex = group;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4363
            this.capture = capture;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4364
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4365
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4366
            int[] groups = matcher.groups;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4367
            int[] locals = matcher.locals;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4368
            int save0 = locals[localIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4369
            int save1 = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4370
            int save2 = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4371
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4372
            if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4373
                save1 = groups[groupIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4374
                save2 = groups[groupIndex+1];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4375
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4376
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4377
            // Notify GroupTail there is no need to setup group info
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4378
            // because it will be set here
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4379
            locals[localIndex] = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4380
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4381
            boolean ret = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4382
            for (int j = 0; j < cmin; j++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4383
                if (atom.match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4384
                    if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4385
                        groups[groupIndex] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4386
                        groups[groupIndex+1] = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4387
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4388
                    i = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4389
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4390
                    ret = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4391
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4392
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4393
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4394
            if (ret) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4395
                if (type == GREEDY) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4396
                    ret = match0(matcher, i, cmin, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4397
                } else if (type == LAZY) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4398
                    ret = match1(matcher, i, cmin, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4399
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4400
                    ret = match2(matcher, i, cmin, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4401
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4402
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4403
            if (!ret) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4404
                locals[localIndex] = save0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4405
                if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4406
                    groups[groupIndex] = save1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4407
                    groups[groupIndex+1] = save2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4408
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4409
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4410
            return ret;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4411
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4412
        // Aggressive group match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4413
        boolean match0(Matcher matcher, int i, int j, CharSequence seq) {
17183
1e21e0bc10e7 8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents: 14342
diff changeset
  4414
            // don't back off passing the starting "j"
1e21e0bc10e7 8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents: 14342
diff changeset
  4415
            int min = j;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4416
            int[] groups = matcher.groups;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4417
            int save0 = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4418
            int save1 = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4419
            if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4420
                save0 = groups[groupIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4421
                save1 = groups[groupIndex+1];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4422
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4423
            for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4424
                if (j >= cmax)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4425
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4426
                if (!atom.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4427
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4428
                int k = matcher.last - i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4429
                if (k <= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4430
                    if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4431
                        groups[groupIndex] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4432
                        groups[groupIndex+1] = i + k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4433
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4434
                    i = i + k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4435
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4436
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4437
                for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4438
                    if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4439
                        groups[groupIndex] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4440
                        groups[groupIndex+1] = i + k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4441
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4442
                    i = i + k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4443
                    if (++j >= cmax)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4444
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4445
                    if (!atom.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4446
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4447
                    if (i + k != matcher.last) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4448
                        if (match0(matcher, i, j, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4449
                            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4450
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4451
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4452
                }
17183
1e21e0bc10e7 8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents: 14342
diff changeset
  4453
                while (j > min) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4454
                    if (next.match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4455
                        if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4456
                            groups[groupIndex+1] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4457
                            groups[groupIndex] = i - k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4458
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4459
                        i = i - k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4460
                        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4461
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4462
                    // backing off
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4463
                    if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4464
                        groups[groupIndex+1] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4465
                        groups[groupIndex] = i - k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4466
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4467
                    i = i - k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4468
                    j--;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4469
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4470
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4471
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4472
            if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4473
                groups[groupIndex] = save0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4474
                groups[groupIndex+1] = save1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4475
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4476
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4477
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4478
        // Reluctant matching
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4479
        boolean match1(Matcher matcher, int i, int j, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4480
            for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4481
                if (next.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4482
                    return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4483
                if (j >= cmax)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4484
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4485
                if (!atom.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4486
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4487
                if (i == matcher.last)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4488
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4489
                if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4490
                    matcher.groups[groupIndex] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4491
                    matcher.groups[groupIndex+1] = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4492
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4493
                i = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4494
                j++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4495
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4496
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4497
        // Possessive matching
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4498
        boolean match2(Matcher matcher, int i, int j, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4499
            for (; j < cmax; j++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4500
                if (!atom.match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4501
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4502
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4503
                if (capture) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4504
                    matcher.groups[groupIndex] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4505
                    matcher.groups[groupIndex+1] = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4506
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4507
                if (i == matcher.last) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4508
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4509
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4510
                i = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4511
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4512
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4513
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4514
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4515
            // Save original info
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4516
            int minL = info.minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4517
            int maxL = info.maxLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4518
            boolean maxV = info.maxValid;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4519
            boolean detm = info.deterministic;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4520
            info.reset();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4521
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4522
            atom.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4523
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4524
            int temp = info.minLength * cmin + minL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4525
            if (temp < minL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4526
                temp = 0xFFFFFFF; // Arbitrary large number
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4527
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4528
            info.minLength = temp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4529
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4530
            if (maxV & info.maxValid) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4531
                temp = info.maxLength * cmax + maxL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4532
                info.maxLength = temp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4533
                if (temp < maxL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4534
                    info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4535
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4536
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4537
                info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4538
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4539
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4540
            if (info.deterministic && cmin == cmax) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4541
                info.deterministic = detm;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4542
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4543
                info.deterministic = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4544
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4545
            return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4546
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4547
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4548
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4549
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4550
     * A Guard node at the end of each atom node in a Branch. It
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4551
     * serves the purpose of chaining the "match" operation to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4552
     * "next" but not the "study", so we can collect the TreeInfo
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4553
     * of each atom node without including the TreeInfo of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4554
     * "next".
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4555
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4556
    static final class BranchConn extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4557
        BranchConn() {};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4558
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4559
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4560
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4561
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4562
            return info.deterministic;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4563
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4564
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4565
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4566
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4567
     * Handles the branching of alternations. Note this is also used for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4568
     * the ? quantifier to branch between the case where it matches once
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4569
     * and where it does not occur.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4570
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4571
    static final class Branch extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4572
        Node[] atoms = new Node[2];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4573
        int size = 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4574
        Node conn;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4575
        Branch(Node first, Node second, Node branchConn) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4576
            conn = branchConn;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4577
            atoms[0] = first;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4578
            atoms[1] = second;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4579
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4580
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4581
        void add(Node node) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4582
            if (size >= atoms.length) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4583
                Node[] tmp = new Node[atoms.length*2];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4584
                System.arraycopy(atoms, 0, tmp, 0, atoms.length);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4585
                atoms = tmp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4586
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4587
            atoms[size++] = node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4588
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4589
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4590
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4591
            for (int n = 0; n < size; n++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4592
                if (atoms[n] == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4593
                    if (conn.next.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4594
                        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4595
                } else if (atoms[n].match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4596
                    return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4597
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4598
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4599
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4600
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4601
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4602
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4603
            int minL = info.minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4604
            int maxL = info.maxLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4605
            boolean maxV = info.maxValid;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4606
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4607
            int minL2 = Integer.MAX_VALUE; //arbitrary large enough num
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4608
            int maxL2 = -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4609
            for (int n = 0; n < size; n++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4610
                info.reset();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4611
                if (atoms[n] != null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4612
                    atoms[n].study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4613
                minL2 = Math.min(minL2, info.minLength);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4614
                maxL2 = Math.max(maxL2, info.maxLength);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4615
                maxV = (maxV & info.maxValid);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4616
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4617
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4618
            minL += minL2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4619
            maxL += maxL2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4620
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4621
            info.reset();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4622
            conn.next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4623
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4624
            info.minLength += minL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4625
            info.maxLength += maxL;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4626
            info.maxValid &= maxV;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4627
            info.deterministic = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4628
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4629
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4630
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4631
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4632
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4633
     * The GroupHead saves the location where the group begins in the locals
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4634
     * and restores them when the match is done.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4635
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4636
     * The matchRef is used when a reference to this group is accessed later
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4637
     * in the expression. The locals will have a negative value in them to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4638
     * indicate that we do not want to unset the group if the reference
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4639
     * doesn't match.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4640
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4641
    static final class GroupHead extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4642
        int localIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4643
        GroupHead(int localCount) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4644
            localIndex = localCount;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4645
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4646
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4647
            int save = matcher.locals[localIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4648
            matcher.locals[localIndex] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4649
            boolean ret = next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4650
            matcher.locals[localIndex] = save;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4651
            return ret;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4652
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4653
        boolean matchRef(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4654
            int save = matcher.locals[localIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4655
            matcher.locals[localIndex] = ~i; // HACK
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4656
            boolean ret = next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4657
            matcher.locals[localIndex] = save;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4658
            return ret;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4659
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4660
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4661
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4662
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4663
     * Recursive reference to a group in the regular expression. It calls
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4664
     * matchRef because if the reference fails to match we would not unset
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4665
     * the group.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4666
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4667
    static final class GroupRef extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4668
        GroupHead head;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4669
        GroupRef(GroupHead head) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4670
            this.head = head;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4671
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4672
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4673
            return head.matchRef(matcher, i, seq)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4674
                && next.match(matcher, matcher.last, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4675
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4676
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4677
            info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4678
            info.deterministic = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4679
            return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4680
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4681
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4682
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4683
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4684
     * The GroupTail handles the setting of group beginning and ending
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4685
     * locations when groups are successfully matched. It must also be able to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4686
     * unset groups that have to be backed off of.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4687
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4688
     * The GroupTail node is also used when a previous group is referenced,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4689
     * and in that case no group information needs to be set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4690
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4691
    static final class GroupTail extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4692
        int localIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4693
        int groupIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4694
        GroupTail(int localCount, int groupCount) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4695
            localIndex = localCount;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4696
            groupIndex = groupCount + groupCount;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4697
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4698
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4699
            int tmp = matcher.locals[localIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4700
            if (tmp >= 0) { // This is the normal group case.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4701
                // Save the group so we can unset it if it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4702
                // backs off of a match.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4703
                int groupStart = matcher.groups[groupIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4704
                int groupEnd = matcher.groups[groupIndex+1];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4705
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4706
                matcher.groups[groupIndex] = tmp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4707
                matcher.groups[groupIndex+1] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4708
                if (next.match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4709
                    return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4710
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4711
                matcher.groups[groupIndex] = groupStart;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4712
                matcher.groups[groupIndex+1] = groupEnd;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4713
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4714
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4715
                // This is a group reference case. We don't need to save any
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4716
                // group info because it isn't really a group.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4717
                matcher.last = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4718
                return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4719
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4720
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4721
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4722
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4723
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4724
     * This sets up a loop to handle a recursive quantifier structure.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4725
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4726
    static final class Prolog extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4727
        Loop loop;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4728
        Prolog(Loop loop) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4729
            this.loop = loop;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4730
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4731
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4732
            return loop.matchInit(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4733
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4734
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4735
            return loop.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4736
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4737
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4738
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4739
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4740
     * Handles the repetition count for a greedy Curly. The matchInit
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4741
     * is called from the Prolog to save the index of where the group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4742
     * beginning is stored. A zero length group check occurs in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4743
     * normal match but is skipped in the matchInit.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4744
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4745
    static class Loop extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4746
        Node body;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4747
        int countIndex; // local count index in matcher locals
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4748
        int beginIndex; // group beginning index
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4749
        int cmin, cmax;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4750
        Loop(int countIndex, int beginIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4751
            this.countIndex = countIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4752
            this.beginIndex = beginIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4753
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4754
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4755
            // Avoid infinite loop in zero-length case.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4756
            if (i > matcher.locals[beginIndex]) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4757
                int count = matcher.locals[countIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4758
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4759
                // This block is for before we reach the minimum
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4760
                // iterations required for the loop to match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4761
                if (count < cmin) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4762
                    matcher.locals[countIndex] = count + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4763
                    boolean b = body.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4764
                    // If match failed we must backtrack, so
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4765
                    // the loop count should NOT be incremented
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4766
                    if (!b)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4767
                        matcher.locals[countIndex] = count;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4768
                    // Return success or failure since we are under
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4769
                    // minimum
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4770
                    return b;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4771
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4772
                // This block is for after we have the minimum
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4773
                // iterations required for the loop to match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4774
                if (count < cmax) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4775
                    matcher.locals[countIndex] = count + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4776
                    boolean b = body.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4777
                    // If match failed we must backtrack, so
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4778
                    // the loop count should NOT be incremented
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4779
                    if (!b)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4780
                        matcher.locals[countIndex] = count;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4781
                    else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4782
                        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4783
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4784
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4785
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4786
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4787
        boolean matchInit(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4788
            int save = matcher.locals[countIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4789
            boolean ret = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4790
            if (0 < cmin) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4791
                matcher.locals[countIndex] = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4792
                ret = body.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4793
            } else if (0 < cmax) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4794
                matcher.locals[countIndex] = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4795
                ret = body.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4796
                if (ret == false)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4797
                    ret = next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4798
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4799
                ret = next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4800
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4801
            matcher.locals[countIndex] = save;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4802
            return ret;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4803
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4804
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4805
            info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4806
            info.deterministic = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4807
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4808
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4809
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4810
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4811
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4812
     * Handles the repetition count for a reluctant Curly. The matchInit
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4813
     * is called from the Prolog to save the index of where the group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4814
     * beginning is stored. A zero length group check occurs in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4815
     * normal match but is skipped in the matchInit.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4816
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4817
    static final class LazyLoop extends Loop {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4818
        LazyLoop(int countIndex, int beginIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4819
            super(countIndex, beginIndex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4820
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4821
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4822
            // Check for zero length group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4823
            if (i > matcher.locals[beginIndex]) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4824
                int count = matcher.locals[countIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4825
                if (count < cmin) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4826
                    matcher.locals[countIndex] = count + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4827
                    boolean result = body.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4828
                    // If match failed we must backtrack, so
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4829
                    // the loop count should NOT be incremented
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4830
                    if (!result)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4831
                        matcher.locals[countIndex] = count;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4832
                    return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4833
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4834
                if (next.match(matcher, i, seq))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4835
                    return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4836
                if (count < cmax) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4837
                    matcher.locals[countIndex] = count + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4838
                    boolean result = body.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4839
                    // If match failed we must backtrack, so
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4840
                    // the loop count should NOT be incremented
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4841
                    if (!result)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4842
                        matcher.locals[countIndex] = count;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4843
                    return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4844
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4845
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4846
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4847
            return next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4848
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4849
        boolean matchInit(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4850
            int save = matcher.locals[countIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4851
            boolean ret = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4852
            if (0 < cmin) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4853
                matcher.locals[countIndex] = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4854
                ret = body.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4855
            } else if (next.match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4856
                ret = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4857
            } else if (0 < cmax) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4858
                matcher.locals[countIndex] = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4859
                ret = body.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4860
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4861
            matcher.locals[countIndex] = save;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4862
            return ret;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4863
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4864
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4865
            info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4866
            info.deterministic = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4867
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4868
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4869
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4870
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4871
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4872
     * Refers to a group in the regular expression. Attempts to match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4873
     * whatever the group referred to last matched.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4874
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4875
    static class BackRef extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4876
        int groupIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4877
        BackRef(int groupCount) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4878
            super();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4879
            groupIndex = groupCount + groupCount;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4880
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4881
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4882
            int j = matcher.groups[groupIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4883
            int k = matcher.groups[groupIndex+1];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4884
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4885
            int groupSize = k - j;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4886
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4887
            // If the referenced group didn't match, neither can this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4888
            if (j < 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4889
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4890
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4891
            // If there isn't enough input left no match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4892
            if (i + groupSize > matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4893
                matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4894
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4895
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4896
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4897
            // Check each new char to make sure it matches what the group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4898
            // referenced matched last time around
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4899
            for (int index=0; index<groupSize; index++)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4900
                if (seq.charAt(i+index) != seq.charAt(j+index))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4901
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4902
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4903
            return next.match(matcher, i+groupSize, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4904
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4905
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4906
            info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4907
            return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4908
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4909
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4910
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4911
    static class CIBackRef extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4912
        int groupIndex;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4913
        boolean doUnicodeCase;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4914
        CIBackRef(int groupCount, boolean doUnicodeCase) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4915
            super();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4916
            groupIndex = groupCount + groupCount;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4917
            this.doUnicodeCase = doUnicodeCase;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4918
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4919
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4920
            int j = matcher.groups[groupIndex];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4921
            int k = matcher.groups[groupIndex+1];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4922
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4923
            int groupSize = k - j;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4924
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4925
            // If the referenced group didn't match, neither can this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4926
            if (j < 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4927
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4928
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4929
            // If there isn't enough input left no match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4930
            if (i + groupSize > matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4931
                matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4932
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4933
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4934
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4935
            // Check each new char to make sure it matches what the group
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4936
            // referenced matched last time around
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4937
            int x = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4938
            for (int index=0; index<groupSize; index++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4939
                int c1 = Character.codePointAt(seq, x);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4940
                int c2 = Character.codePointAt(seq, j);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4941
                if (c1 != c2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4942
                    if (doUnicodeCase) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4943
                        int cc1 = Character.toUpperCase(c1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4944
                        int cc2 = Character.toUpperCase(c2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4945
                        if (cc1 != cc2 &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4946
                            Character.toLowerCase(cc1) !=
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4947
                            Character.toLowerCase(cc2))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4948
                            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4949
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4950
                        if (ASCII.toLower(c1) != ASCII.toLower(c2))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4951
                            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4952
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4953
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4954
                x += Character.charCount(c1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4955
                j += Character.charCount(c2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4956
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4957
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4958
            return next.match(matcher, i+groupSize, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4959
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4960
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4961
            info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4962
            return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4963
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4964
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4965
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4966
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4967
     * Searches until the next instance of its atom. This is useful for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4968
     * finding the atom efficiently without passing an instance of it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4969
     * (greedy problem) and without a lot of wasted search time (reluctant
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4970
     * problem).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4971
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4972
    static final class First extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4973
        Node atom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4974
        First(Node node) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4975
            this.atom = BnM.optimize(node);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4976
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4977
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4978
            if (atom instanceof BnM) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4979
                return atom.match(matcher, i, seq)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4980
                    && next.match(matcher, matcher.last, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4981
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4982
            for (;;) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4983
                if (i > matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4984
                    matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4985
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4986
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4987
                if (atom.match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4988
                    return next.match(matcher, matcher.last, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4989
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4990
                i += countChars(seq, i, 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4991
                matcher.first++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4992
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4993
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4994
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4995
            atom.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4996
            info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4997
            info.deterministic = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4998
            return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4999
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5000
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5001
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5002
    static final class Conditional extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5003
        Node cond, yes, not;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5004
        Conditional(Node cond, Node yes, Node not) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5005
            this.cond = cond;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5006
            this.yes = yes;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5007
            this.not = not;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5008
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5009
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5010
            if (cond.match(matcher, i, seq)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5011
                return yes.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5012
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5013
                return not.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5014
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5015
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5016
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5017
            int minL = info.minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5018
            int maxL = info.maxLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5019
            boolean maxV = info.maxValid;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5020
            info.reset();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5021
            yes.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5022
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5023
            int minL2 = info.minLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5024
            int maxL2 = info.maxLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5025
            boolean maxV2 = info.maxValid;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5026
            info.reset();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5027
            not.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5028
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5029
            info.minLength = minL + Math.min(minL2, info.minLength);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5030
            info.maxLength = maxL + Math.max(maxL2, info.maxLength);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5031
            info.maxValid = (maxV & maxV2 & info.maxValid);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5032
            info.deterministic = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5033
            return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5034
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5035
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5036
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5037
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5038
     * Zero width positive lookahead.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5039
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5040
    static final class Pos extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5041
        Node cond;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5042
        Pos(Node cond) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5043
            this.cond = cond;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5044
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5045
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5046
            int savedTo = matcher.to;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5047
            boolean conditionMatched = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5048
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5049
            // Relax transparent region boundaries for lookahead
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5050
            if (matcher.transparentBounds)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5051
                matcher.to = matcher.getTextLength();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5052
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5053
                conditionMatched = cond.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5054
            } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5055
                // Reinstate region boundaries
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5056
                matcher.to = savedTo;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5057
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5058
            return conditionMatched && next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5059
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5060
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5061
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5062
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5063
     * Zero width negative lookahead.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5064
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5065
    static final class Neg extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5066
        Node cond;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5067
        Neg(Node cond) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5068
            this.cond = cond;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5069
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5070
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5071
            int savedTo = matcher.to;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5072
            boolean conditionMatched = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5073
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5074
            // Relax transparent region boundaries for lookahead
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5075
            if (matcher.transparentBounds)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5076
                matcher.to = matcher.getTextLength();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5077
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5078
                if (i < matcher.to) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5079
                    conditionMatched = !cond.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5080
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5081
                    // If a negative lookahead succeeds then more input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5082
                    // could cause it to fail!
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5083
                    matcher.requireEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5084
                    conditionMatched = !cond.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5085
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5086
            } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5087
                // Reinstate region boundaries
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5088
                matcher.to = savedTo;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5089
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5090
            return conditionMatched && next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5091
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5092
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5093
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5094
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5095
     * For use with lookbehinds; matches the position where the lookbehind
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5096
     * was encountered.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5097
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5098
    static Node lookbehindEnd = new Node() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5099
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5100
            return i == matcher.lookbehindTo;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5101
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5102
    };
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5103
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5104
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5105
     * Zero width positive lookbehind.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5106
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5107
    static class Behind extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5108
        Node cond;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5109
        int rmax, rmin;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5110
        Behind(Node cond, int rmax, int rmin) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5111
            this.cond = cond;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5112
            this.rmax = rmax;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5113
            this.rmin = rmin;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5114
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5115
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5116
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5117
            int savedFrom = matcher.from;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5118
            boolean conditionMatched = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5119
            int startIndex = (!matcher.transparentBounds) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5120
                             matcher.from : 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5121
            int from = Math.max(i - rmax, startIndex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5122
            // Set end boundary
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5123
            int savedLBT = matcher.lookbehindTo;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5124
            matcher.lookbehindTo = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5125
            // Relax transparent region boundaries for lookbehind
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5126
            if (matcher.transparentBounds)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5127
                matcher.from = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5128
            for (int j = i - rmin; !conditionMatched && j >= from; j--) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5129
                conditionMatched = cond.match(matcher, j, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5130
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5131
            matcher.from = savedFrom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5132
            matcher.lookbehindTo = savedLBT;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5133
            return conditionMatched && next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5134
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5135
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5136
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5137
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5138
     * Zero width positive lookbehind, including supplementary
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5139
     * characters or unpaired surrogates.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5140
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5141
    static final class BehindS extends Behind {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5142
        BehindS(Node cond, int rmax, int rmin) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5143
            super(cond, rmax, rmin);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5144
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5145
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5146
            int rmaxChars = countChars(seq, i, -rmax);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5147
            int rminChars = countChars(seq, i, -rmin);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5148
            int savedFrom = matcher.from;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5149
            int startIndex = (!matcher.transparentBounds) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5150
                             matcher.from : 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5151
            boolean conditionMatched = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5152
            int from = Math.max(i - rmaxChars, startIndex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5153
            // Set end boundary
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5154
            int savedLBT = matcher.lookbehindTo;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5155
            matcher.lookbehindTo = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5156
            // Relax transparent region boundaries for lookbehind
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5157
            if (matcher.transparentBounds)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5158
                matcher.from = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5159
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5160
            for (int j = i - rminChars;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5161
                 !conditionMatched && j >= from;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5162
                 j -= j>from ? countChars(seq, j, -1) : 1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5163
                conditionMatched = cond.match(matcher, j, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5164
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5165
            matcher.from = savedFrom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5166
            matcher.lookbehindTo = savedLBT;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5167
            return conditionMatched && next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5168
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5169
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5170
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5171
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5172
     * Zero width negative lookbehind.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5173
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5174
    static class NotBehind extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5175
        Node cond;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5176
        int rmax, rmin;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5177
        NotBehind(Node cond, int rmax, int rmin) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5178
            this.cond = cond;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5179
            this.rmax = rmax;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5180
            this.rmin = rmin;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5181
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5182
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5183
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5184
            int savedLBT = matcher.lookbehindTo;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5185
            int savedFrom = matcher.from;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5186
            boolean conditionMatched = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5187
            int startIndex = (!matcher.transparentBounds) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5188
                             matcher.from : 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5189
            int from = Math.max(i - rmax, startIndex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5190
            matcher.lookbehindTo = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5191
            // Relax transparent region boundaries for lookbehind
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5192
            if (matcher.transparentBounds)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5193
                matcher.from = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5194
            for (int j = i - rmin; !conditionMatched && j >= from; j--) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5195
                conditionMatched = cond.match(matcher, j, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5196
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5197
            // Reinstate region boundaries
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5198
            matcher.from = savedFrom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5199
            matcher.lookbehindTo = savedLBT;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5200
            return !conditionMatched && next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5201
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5202
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5203
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5204
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5205
     * Zero width negative lookbehind, including supplementary
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5206
     * characters or unpaired surrogates.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5207
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5208
    static final class NotBehindS extends NotBehind {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5209
        NotBehindS(Node cond, int rmax, int rmin) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5210
            super(cond, rmax, rmin);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5211
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5212
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5213
            int rmaxChars = countChars(seq, i, -rmax);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5214
            int rminChars = countChars(seq, i, -rmin);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5215
            int savedFrom = matcher.from;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5216
            int savedLBT = matcher.lookbehindTo;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5217
            boolean conditionMatched = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5218
            int startIndex = (!matcher.transparentBounds) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5219
                             matcher.from : 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5220
            int from = Math.max(i - rmaxChars, startIndex);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5221
            matcher.lookbehindTo = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5222
            // Relax transparent region boundaries for lookbehind
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5223
            if (matcher.transparentBounds)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5224
                matcher.from = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5225
            for (int j = i - rminChars;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5226
                 !conditionMatched && j >= from;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5227
                 j -= j>from ? countChars(seq, j, -1) : 1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5228
                conditionMatched = cond.match(matcher, j, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5229
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5230
            //Reinstate region boundaries
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5231
            matcher.from = savedFrom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5232
            matcher.lookbehindTo = savedLBT;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5233
            return !conditionMatched && next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5234
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5235
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5236
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5237
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5238
     * Returns the set union of two CharProperty nodes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5239
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5240
    private static CharProperty union(final CharProperty lhs,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5241
                                      final CharProperty rhs) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5242
        return new CharProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5243
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5244
                    return lhs.isSatisfiedBy(ch) || rhs.isSatisfiedBy(ch);}};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5245
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5246
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5247
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5248
     * Returns the set intersection of two CharProperty nodes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5249
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5250
    private static CharProperty intersection(final CharProperty lhs,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5251
                                             final CharProperty rhs) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5252
        return new CharProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5253
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5254
                    return lhs.isSatisfiedBy(ch) && rhs.isSatisfiedBy(ch);}};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5255
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5256
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5257
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5258
     * Returns the set difference of two CharProperty nodes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5259
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5260
    private static CharProperty setDifference(final CharProperty lhs,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5261
                                              final CharProperty rhs) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5262
        return new CharProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5263
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5264
                    return ! rhs.isSatisfiedBy(ch) && lhs.isSatisfiedBy(ch);}};
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5265
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5266
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5267
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5268
     * Handles word boundaries. Includes a field to allow this one class to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5269
     * deal with the different types of word boundaries we can match. The word
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5270
     * characters include underscores, letters, and digits. Non spacing marks
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5271
     * can are also part of a word if they have a base character, otherwise
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5272
     * they are ignored for purposes of finding word boundaries.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5273
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5274
    static final class Bound extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5275
        static int LEFT = 0x1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5276
        static int RIGHT= 0x2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5277
        static int BOTH = 0x3;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5278
        static int NONE = 0x4;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5279
        int type;
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5280
        boolean useUWORD;
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5281
        Bound(int n, boolean useUWORD) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5282
            type = n;
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5283
            this.useUWORD = useUWORD;
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5284
        }
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5285
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5286
        boolean isWord(int ch) {
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5287
            return useUWORD ? UnicodeProp.WORD.is(ch)
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5288
                            : (ch == '_' || Character.isLetterOrDigit(ch));
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5289
        }
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5290
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5291
        int check(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5292
            int ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5293
            boolean left = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5294
            int startIndex = matcher.from;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5295
            int endIndex = matcher.to;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5296
            if (matcher.transparentBounds) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5297
                startIndex = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5298
                endIndex = matcher.getTextLength();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5299
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5300
            if (i > startIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5301
                ch = Character.codePointBefore(seq, i);
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5302
                left = (isWord(ch) ||
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5303
                    ((Character.getType(ch) == Character.NON_SPACING_MARK)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5304
                     && hasBaseCharacter(matcher, i-1, seq)));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5305
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5306
            boolean right = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5307
            if (i < endIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5308
                ch = Character.codePointAt(seq, i);
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5309
                right = (isWord(ch) ||
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5310
                    ((Character.getType(ch) == Character.NON_SPACING_MARK)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5311
                     && hasBaseCharacter(matcher, i, seq)));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5312
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5313
                // Tried to access char past the end
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5314
                matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5315
                // The addition of another char could wreck a boundary
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5316
                matcher.requireEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5317
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5318
            return ((left ^ right) ? (right ? LEFT : RIGHT) : NONE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5319
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5320
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5321
            return (check(matcher, i, seq) & type) > 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5322
                && next.match(matcher, i, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5323
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5324
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5325
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5326
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5327
     * Non spacing marks only count as word characters in bounds calculations
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5328
     * if they have a base character.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5329
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5330
    private static boolean hasBaseCharacter(Matcher matcher, int i,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5331
                                            CharSequence seq)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5332
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5333
        int start = (!matcher.transparentBounds) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5334
            matcher.from : 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5335
        for (int x=i; x >= start; x--) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5336
            int ch = Character.codePointAt(seq, x);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5337
            if (Character.isLetterOrDigit(ch))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5338
                return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5339
            if (Character.getType(ch) == Character.NON_SPACING_MARK)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5340
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5341
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5342
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5343
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5344
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5345
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5346
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5347
     * Attempts to match a slice in the input using the Boyer-Moore string
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5348
     * matching algorithm. The algorithm is based on the idea that the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5349
     * pattern can be shifted farther ahead in the search text if it is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5350
     * matched right to left.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5351
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5352
     * The pattern is compared to the input one character at a time, from
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5353
     * the rightmost character in the pattern to the left. If the characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5354
     * all match the pattern has been found. If a character does not match,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5355
     * the pattern is shifted right a distance that is the maximum of two
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5356
     * functions, the bad character shift and the good suffix shift. This
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5357
     * shift moves the attempted match position through the input more
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5358
     * quickly than a naive one position at a time check.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5359
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5360
     * The bad character shift is based on the character from the text that
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5361
     * did not match. If the character does not appear in the pattern, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5362
     * pattern can be shifted completely beyond the bad character. If the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5363
     * character does occur in the pattern, the pattern can be shifted to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5364
     * line the pattern up with the next occurrence of that character.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5365
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5366
     * The good suffix shift is based on the idea that some subset on the right
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5367
     * side of the pattern has matched. When a bad character is found, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5368
     * pattern can be shifted right by the pattern length if the subset does
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5369
     * not occur again in pattern, or by the amount of distance to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5370
     * next occurrence of the subset in the pattern.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5371
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5372
     * Boyer-Moore search methods adapted from code by Amy Yu.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5373
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5374
    static class BnM extends Node {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5375
        int[] buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5376
        int[] lastOcc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5377
        int[] optoSft;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5378
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5379
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5380
         * Pre calculates arrays needed to generate the bad character
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5381
         * shift and the good suffix shift. Only the last seven bits
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5382
         * are used to see if chars match; This keeps the tables small
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5383
         * and covers the heavily used ASCII range, but occasionally
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5384
         * results in an aliased match for the bad character shift.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5385
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5386
        static Node optimize(Node node) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5387
            if (!(node instanceof Slice)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5388
                return node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5389
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5390
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5391
            int[] src = ((Slice) node).buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5392
            int patternLength = src.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5393
            // The BM algorithm requires a bit of overhead;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5394
            // If the pattern is short don't use it, since
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5395
            // a shift larger than the pattern length cannot
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5396
            // be used anyway.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5397
            if (patternLength < 4) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5398
                return node;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5399
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5400
            int i, j, k;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5401
            int[] lastOcc = new int[128];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5402
            int[] optoSft = new int[patternLength];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5403
            // Precalculate part of the bad character shift
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5404
            // It is a table for where in the pattern each
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5405
            // lower 7-bit value occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5406
            for (i = 0; i < patternLength; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5407
                lastOcc[src[i]&0x7F] = i + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5408
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5409
            // Precalculate the good suffix shift
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5410
            // i is the shift amount being considered
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5411
NEXT:       for (i = patternLength; i > 0; i--) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5412
                // j is the beginning index of suffix being considered
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5413
                for (j = patternLength - 1; j >= i; j--) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5414
                    // Testing for good suffix
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5415
                    if (src[j] == src[j-i]) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5416
                        // src[j..len] is a good suffix
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5417
                        optoSft[j-1] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5418
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5419
                        // No match. The array has already been
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5420
                        // filled up with correct values before.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5421
                        continue NEXT;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5422
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5423
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5424
                // This fills up the remaining of optoSft
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5425
                // any suffix can not have larger shift amount
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5426
                // then its sub-suffix. Why???
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5427
                while (j > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5428
                    optoSft[--j] = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5429
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5430
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5431
            // Set the guard value because of unicode compression
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5432
            optoSft[patternLength-1] = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5433
            if (node instanceof SliceS)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5434
                return new BnMS(src, lastOcc, optoSft, node.next);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5435
            return new BnM(src, lastOcc, optoSft, node.next);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5436
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5437
        BnM(int[] src, int[] lastOcc, int[] optoSft, Node next) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5438
            this.buffer = src;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5439
            this.lastOcc = lastOcc;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5440
            this.optoSft = optoSft;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5441
            this.next = next;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5442
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5443
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5444
            int[] src = buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5445
            int patternLength = src.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5446
            int last = matcher.to - patternLength;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5447
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5448
            // Loop over all possible match positions in text
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5449
NEXT:       while (i <= last) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5450
                // Loop over pattern from right to left
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5451
                for (int j = patternLength - 1; j >= 0; j--) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5452
                    int ch = seq.charAt(i+j);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5453
                    if (ch != src[j]) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5454
                        // Shift search to the right by the maximum of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5455
                        // bad character shift and the good suffix shift
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5456
                        i += Math.max(j + 1 - lastOcc[ch&0x7F], optoSft[j]);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5457
                        continue NEXT;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5458
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5459
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5460
                // Entire pattern matched starting at i
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5461
                matcher.first = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5462
                boolean ret = next.match(matcher, i + patternLength, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5463
                if (ret) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5464
                    matcher.first = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5465
                    matcher.groups[0] = matcher.first;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5466
                    matcher.groups[1] = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5467
                    return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5468
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5469
                i++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5470
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5471
            // BnM is only used as the leading node in the unanchored case,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5472
            // and it replaced its Start() which always searches to the end
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5473
            // if it doesn't find what it's looking for, so hitEnd is true.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5474
            matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5475
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5476
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5477
        boolean study(TreeInfo info) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5478
            info.minLength += buffer.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5479
            info.maxValid = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5480
            return next.study(info);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5481
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5482
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5483
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5484
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5485
     * Supplementary support version of BnM(). Unpaired surrogates are
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5486
     * also handled by this class.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5487
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5488
    static final class BnMS extends BnM {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5489
        int lengthInChars;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5490
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5491
        BnMS(int[] src, int[] lastOcc, int[] optoSft, Node next) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5492
            super(src, lastOcc, optoSft, next);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5493
            for (int x = 0; x < buffer.length; x++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5494
                lengthInChars += Character.charCount(buffer[x]);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5495
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5496
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5497
        boolean match(Matcher matcher, int i, CharSequence seq) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5498
            int[] src = buffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5499
            int patternLength = src.length;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5500
            int last = matcher.to - lengthInChars;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5501
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5502
            // Loop over all possible match positions in text
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5503
NEXT:       while (i <= last) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5504
                // Loop over pattern from right to left
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5505
                int ch;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5506
                for (int j = countChars(seq, i, patternLength), x = patternLength - 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5507
                     j > 0; j -= Character.charCount(ch), x--) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5508
                    ch = Character.codePointBefore(seq, i+j);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5509
                    if (ch != src[x]) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5510
                        // Shift search to the right by the maximum of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5511
                        // bad character shift and the good suffix shift
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5512
                        int n = Math.max(x + 1 - lastOcc[ch&0x7F], optoSft[x]);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5513
                        i += countChars(seq, i, n);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5514
                        continue NEXT;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5515
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5516
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5517
                // Entire pattern matched starting at i
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5518
                matcher.first = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5519
                boolean ret = next.match(matcher, i + lengthInChars, seq);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5520
                if (ret) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5521
                    matcher.first = i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5522
                    matcher.groups[0] = matcher.first;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5523
                    matcher.groups[1] = matcher.last;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5524
                    return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5525
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5526
                i += countChars(seq, i, 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5527
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5528
            matcher.hitEnd = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5529
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5530
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5531
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5532
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5533
///////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5534
///////////////////////////////////////////////////////////////////////////////
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5535
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5536
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5537
     *  This must be the very first initializer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5538
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5539
    static Node accept = new Node();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5540
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5541
    static Node lastAccept = new LastNode();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5542
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5543
    private static class CharPropertyNames {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5544
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5545
        static CharProperty charPropertyFor(String name) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5546
            CharPropertyFactory m = map.get(name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5547
            return m == null ? null : m.make();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5548
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5549
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5550
        private static abstract class CharPropertyFactory {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5551
            abstract CharProperty make();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5552
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5553
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5554
        private static void defCategory(String name,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5555
                                        final int typeMask) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5556
            map.put(name, new CharPropertyFactory() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5557
                    CharProperty make() { return new Category(typeMask);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5558
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5559
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5560
        private static void defRange(String name,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5561
                                     final int lower, final int upper) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5562
            map.put(name, new CharPropertyFactory() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5563
                    CharProperty make() { return rangeFor(lower, upper);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5564
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5565
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5566
        private static void defCtype(String name,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5567
                                     final int ctype) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5568
            map.put(name, new CharPropertyFactory() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5569
                    CharProperty make() { return new Ctype(ctype);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5570
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5571
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5572
        private static abstract class CloneableProperty
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5573
            extends CharProperty implements Cloneable
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5574
        {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5575
            public CloneableProperty clone() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5576
                try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5577
                    return (CloneableProperty) super.clone();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5578
                } catch (CloneNotSupportedException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5579
                    throw new AssertionError(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5580
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5581
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5582
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5583
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5584
        private static void defClone(String name,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5585
                                     final CloneableProperty p) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5586
            map.put(name, new CharPropertyFactory() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5587
                    CharProperty make() { return p.clone();}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5588
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5589
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5590
        private static final HashMap<String, CharPropertyFactory> map
7803
56bc97d69d93 6880112: Project Coin: Port JDK core library code to use diamond operator
smarks
parents: 5627
diff changeset
  5591
            = new HashMap<>();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5592
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5593
        static {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5594
            // Unicode character property aliases, defined in
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5595
            // http://www.unicode.org/Public/UNIDATA/PropertyValueAliases.txt
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5596
            defCategory("Cn", 1<<Character.UNASSIGNED);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5597
            defCategory("Lu", 1<<Character.UPPERCASE_LETTER);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5598
            defCategory("Ll", 1<<Character.LOWERCASE_LETTER);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5599
            defCategory("Lt", 1<<Character.TITLECASE_LETTER);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5600
            defCategory("Lm", 1<<Character.MODIFIER_LETTER);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5601
            defCategory("Lo", 1<<Character.OTHER_LETTER);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5602
            defCategory("Mn", 1<<Character.NON_SPACING_MARK);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5603
            defCategory("Me", 1<<Character.ENCLOSING_MARK);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5604
            defCategory("Mc", 1<<Character.COMBINING_SPACING_MARK);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5605
            defCategory("Nd", 1<<Character.DECIMAL_DIGIT_NUMBER);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5606
            defCategory("Nl", 1<<Character.LETTER_NUMBER);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5607
            defCategory("No", 1<<Character.OTHER_NUMBER);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5608
            defCategory("Zs", 1<<Character.SPACE_SEPARATOR);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5609
            defCategory("Zl", 1<<Character.LINE_SEPARATOR);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5610
            defCategory("Zp", 1<<Character.PARAGRAPH_SEPARATOR);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5611
            defCategory("Cc", 1<<Character.CONTROL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5612
            defCategory("Cf", 1<<Character.FORMAT);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5613
            defCategory("Co", 1<<Character.PRIVATE_USE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5614
            defCategory("Cs", 1<<Character.SURROGATE);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5615
            defCategory("Pd", 1<<Character.DASH_PUNCTUATION);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5616
            defCategory("Ps", 1<<Character.START_PUNCTUATION);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5617
            defCategory("Pe", 1<<Character.END_PUNCTUATION);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5618
            defCategory("Pc", 1<<Character.CONNECTOR_PUNCTUATION);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5619
            defCategory("Po", 1<<Character.OTHER_PUNCTUATION);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5620
            defCategory("Sm", 1<<Character.MATH_SYMBOL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5621
            defCategory("Sc", 1<<Character.CURRENCY_SYMBOL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5622
            defCategory("Sk", 1<<Character.MODIFIER_SYMBOL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5623
            defCategory("So", 1<<Character.OTHER_SYMBOL);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5624
            defCategory("Pi", 1<<Character.INITIAL_QUOTE_PUNCTUATION);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5625
            defCategory("Pf", 1<<Character.FINAL_QUOTE_PUNCTUATION);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5626
            defCategory("L", ((1<<Character.UPPERCASE_LETTER) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5627
                              (1<<Character.LOWERCASE_LETTER) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5628
                              (1<<Character.TITLECASE_LETTER) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5629
                              (1<<Character.MODIFIER_LETTER)  |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5630
                              (1<<Character.OTHER_LETTER)));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5631
            defCategory("M", ((1<<Character.NON_SPACING_MARK) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5632
                              (1<<Character.ENCLOSING_MARK)   |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5633
                              (1<<Character.COMBINING_SPACING_MARK)));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5634
            defCategory("N", ((1<<Character.DECIMAL_DIGIT_NUMBER) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5635
                              (1<<Character.LETTER_NUMBER)        |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5636
                              (1<<Character.OTHER_NUMBER)));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5637
            defCategory("Z", ((1<<Character.SPACE_SEPARATOR) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5638
                              (1<<Character.LINE_SEPARATOR)  |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5639
                              (1<<Character.PARAGRAPH_SEPARATOR)));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5640
            defCategory("C", ((1<<Character.CONTROL)     |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5641
                              (1<<Character.FORMAT)      |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5642
                              (1<<Character.PRIVATE_USE) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5643
                              (1<<Character.SURROGATE))); // Other
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5644
            defCategory("P", ((1<<Character.DASH_PUNCTUATION)      |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5645
                              (1<<Character.START_PUNCTUATION)     |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5646
                              (1<<Character.END_PUNCTUATION)       |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5647
                              (1<<Character.CONNECTOR_PUNCTUATION) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5648
                              (1<<Character.OTHER_PUNCTUATION)     |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5649
                              (1<<Character.INITIAL_QUOTE_PUNCTUATION) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5650
                              (1<<Character.FINAL_QUOTE_PUNCTUATION)));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5651
            defCategory("S", ((1<<Character.MATH_SYMBOL)     |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5652
                              (1<<Character.CURRENCY_SYMBOL) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5653
                              (1<<Character.MODIFIER_SYMBOL) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5654
                              (1<<Character.OTHER_SYMBOL)));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5655
            defCategory("LC", ((1<<Character.UPPERCASE_LETTER) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5656
                               (1<<Character.LOWERCASE_LETTER) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5657
                               (1<<Character.TITLECASE_LETTER)));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5658
            defCategory("LD", ((1<<Character.UPPERCASE_LETTER) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5659
                               (1<<Character.LOWERCASE_LETTER) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5660
                               (1<<Character.TITLECASE_LETTER) |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5661
                               (1<<Character.MODIFIER_LETTER)  |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5662
                               (1<<Character.OTHER_LETTER)     |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5663
                               (1<<Character.DECIMAL_DIGIT_NUMBER)));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5664
            defRange("L1", 0x00, 0xFF); // Latin-1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5665
            map.put("all", new CharPropertyFactory() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5666
                    CharProperty make() { return new All(); }});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5667
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5668
            // Posix regular expression character classes, defined in
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5669
            // http://www.unix.org/onlinepubs/009695399/basedefs/xbd_chap09.html
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5670
            defRange("ASCII", 0x00, 0x7F);   // ASCII
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5671
            defCtype("Alnum", ASCII.ALNUM);  // Alphanumeric characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5672
            defCtype("Alpha", ASCII.ALPHA);  // Alphabetic characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5673
            defCtype("Blank", ASCII.BLANK);  // Space and tab characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5674
            defCtype("Cntrl", ASCII.CNTRL);  // Control characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5675
            defRange("Digit", '0', '9');     // Numeric characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5676
            defCtype("Graph", ASCII.GRAPH);  // printable and visible
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5677
            defRange("Lower", 'a', 'z');     // Lower-case alphabetic
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5678
            defRange("Print", 0x20, 0x7E);   // Printable characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5679
            defCtype("Punct", ASCII.PUNCT);  // Punctuation characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5680
            defCtype("Space", ASCII.SPACE);  // Space characters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5681
            defRange("Upper", 'A', 'Z');     // Upper-case alphabetic
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5682
            defCtype("XDigit",ASCII.XDIGIT); // hexadecimal digits
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5683
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5684
            // Java character properties, defined by methods in Character.java
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5685
            defClone("javaLowerCase", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5686
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5687
                    return Character.isLowerCase(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5688
            defClone("javaUpperCase", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5689
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5690
                    return Character.isUpperCase(ch);}});
9536
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5691
            defClone("javaAlphabetic", new CloneableProperty() {
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5692
                boolean isSatisfiedBy(int ch) {
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5693
                    return Character.isAlphabetic(ch);}});
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5694
            defClone("javaIdeographic", new CloneableProperty() {
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5695
                boolean isSatisfiedBy(int ch) {
648c9add2a74 7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents: 9275
diff changeset
  5696
                    return Character.isIdeographic(ch);}});
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5697
            defClone("javaTitleCase", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5698
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5699
                    return Character.isTitleCase(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5700
            defClone("javaDigit", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5701
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5702
                    return Character.isDigit(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5703
            defClone("javaDefined", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5704
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5705
                    return Character.isDefined(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5706
            defClone("javaLetter", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5707
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5708
                    return Character.isLetter(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5709
            defClone("javaLetterOrDigit", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5710
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5711
                    return Character.isLetterOrDigit(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5712
            defClone("javaJavaIdentifierStart", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5713
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5714
                    return Character.isJavaIdentifierStart(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5715
            defClone("javaJavaIdentifierPart", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5716
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5717
                    return Character.isJavaIdentifierPart(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5718
            defClone("javaUnicodeIdentifierStart", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5719
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5720
                    return Character.isUnicodeIdentifierStart(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5721
            defClone("javaUnicodeIdentifierPart", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5722
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5723
                    return Character.isUnicodeIdentifierPart(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5724
            defClone("javaIdentifierIgnorable", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5725
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5726
                    return Character.isIdentifierIgnorable(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5727
            defClone("javaSpaceChar", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5728
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5729
                    return Character.isSpaceChar(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5730
            defClone("javaWhitespace", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5731
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5732
                    return Character.isWhitespace(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5733
            defClone("javaISOControl", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5734
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5735
                    return Character.isISOControl(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5736
            defClone("javaMirrored", new CloneableProperty() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5737
                boolean isSatisfiedBy(int ch) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5738
                    return Character.isMirrored(ch);}});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5739
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5740
    }
17447
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5741
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5742
    /**
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5743
     * Creates a predicate which can be used to match a string.
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5744
     *
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5745
     * @return  The predicate which can be used for matching on a string
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5746
     * @since   1.8
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5747
     */
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5748
    public Predicate<String> asPredicate() {
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5749
        return s -> matcher(s).find();
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5750
    }
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5751
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5752
    /**
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5753
     * Creates a stream from the given input sequence around matches of this
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5754
     * pattern.
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5755
     *
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5756
     * <p> The stream returned by this method contains each substring of the
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5757
     * input sequence that is terminated by another subsequence that matches
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5758
     * this pattern or is terminated by the end of the input sequence.  The
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5759
     * substrings in the stream are in the order in which they occur in the
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5760
     * input.
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5761
     *
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5762
     * <p> If this pattern does not match any subsequence of the input then
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5763
     * the resulting stream has just one element, namely the input sequence in
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5764
     * string form.
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5765
     *
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5766
     * <p> If the input sequence is mutable, it must remain constant during the
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5767
     * execution of the terminal stream operation.  Otherwise, the result of the
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5768
     * terminal stream operation is undefined.
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5769
     *
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5770
     * @param   input
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5771
     *          The character sequence to be split
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5772
     *
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5773
     * @return  The stream of strings computed by splitting the input
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5774
     *          around matches of this pattern
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5775
     * @see     #split(CharSequence)
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5776
     * @since   1.8
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5777
     */
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5778
    public Stream<String> splitAsStream(final CharSequence input) {
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5779
        class MatcherIterator implements Iterator<String> {
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5780
            private final Matcher matcher;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5781
            // The start position of the next sub-sequence of input
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5782
            // when current == input.length there are no more elements
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5783
            private int current;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5784
            // null if the next element, if any, needs to obtained
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5785
            private String nextElement;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5786
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5787
            MatcherIterator() {
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5788
                this.matcher = matcher(input);
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5789
            }
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5790
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5791
            public String next() {
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5792
                if (!hasNext())
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5793
                    throw new NoSuchElementException();
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5794
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5795
                String n = nextElement;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5796
                nextElement = null;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5797
                return n;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5798
            }
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5799
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5800
            public boolean hasNext() {
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5801
                if (nextElement != null)
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5802
                    return true;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5803
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5804
                if (current == input.length())
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5805
                    return false;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5806
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5807
                if (matcher.find()) {
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5808
                    nextElement = input.subSequence(current, matcher.start()).toString();
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5809
                    current = matcher.end();
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5810
                } else {
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5811
                    nextElement = input.subSequence(current, input.length()).toString();
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5812
                    current = input.length();
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5813
                }
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5814
                return true;
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5815
            }
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5816
        }
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5817
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
18822
4b6be7c19547 8019395: Consolidate StreamSupport.{stream,parallelStream} into a single method
psandoz
parents: 18787
diff changeset
  5818
                new MatcherIterator(), Spliterator.ORDERED | Spliterator.NONNULL), false);
17447
3031deba3fbe 8012646: Pattern.splitAsStream
psandoz
parents: 17434
diff changeset
  5819
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  5820
}