Cross Reference: /openjdk7/jdk/src/share/classes/java/util/regex/Pattern.java

Lines Matching refs:seq
3207     private static final int countChars(CharSequence seq, int index,
3210         if (lengthInCodePoints == 1 && !Character.isHighSurrogate(seq.charAt(index))) {
3211             assert (index >= 0 && index < seq.length());
3214         int length = seq.length();
3219                 if (Character.isHighSurrogate(seq.charAt(x++))) {
3220                     if (x < length && Character.isLowSurrogate(seq.charAt(x))) {
3234             if (Character.isLowSurrogate(seq.charAt(--x))) {
3235                 if (x > 0 && Character.isHighSurrogate(seq.charAt(x-1))) {
3243     private static final int countCodePoints(CharSequence seq) {
3244         int length = seq.length();
3248             if (Character.isHighSurrogate(seq.charAt(i++))) {
3249                 if (i < length && Character.isLowSurrogate(seq.charAt(i))) {
3353         boolean match(Matcher matcher, int i, CharSequence seq) {
3377         boolean match(Matcher matcher, int i, CharSequence seq) {
3401         boolean match(Matcher matcher, int i, CharSequence seq) {
3408                 if (next.match(matcher, i, seq)) {
3433         boolean match(Matcher matcher, int i, CharSequence seq) {
3440                 //if ((ret = next.match(matcher, i, seq)) || i == guard)
3441                 if (next.match(matcher, i, seq)) {
3450                 // faster than countChars(seq, i, 1).
3451                 if (Character.isHighSurrogate(seq.charAt(i++))) {
3452                     if (i < seq.length() &&
3453                         Character.isLowSurrogate(seq.charAt(i))) {
3469         boolean match(Matcher matcher, int i, CharSequence seq) {
3472             if (i == fromIndex && next.match(matcher, i, seq)) {
3488         boolean match(Matcher matcher, int i, CharSequence seq) {
3493                 return next.match(matcher, i, seq);
3504         boolean match(Matcher matcher, int i, CharSequence seq) {
3517                 char ch = seq.charAt(i-1);
3524                 if (ch == '\r' && seq.charAt(i) == '\n')
3527             return next.match(matcher, i, seq);
3535         boolean match(Matcher matcher, int i, CharSequence seq) {
3548                 char ch = seq.charAt(i-1);
3553             return next.match(matcher, i, seq);
3562         boolean match(Matcher matcher, int i, CharSequence seq) {
3565             return next.match(matcher, i, seq);
3587         boolean match(Matcher matcher, int i, CharSequence seq) {
3594                     char ch = seq.charAt(i);
3597                     ch = seq.charAt(i + 1);
3611                 char ch = seq.charAt(i);
3614                      if (i > 0 && seq.charAt(i-1) == '\r')
3617                          return next.match(matcher, i, seq);
3621                          return next.match(matcher, i, seq);
3631             return next.match(matcher, i, seq);
3648         boolean match(Matcher matcher, int i, CharSequence seq) {
3652                 char ch = seq.charAt(i);
3661                         return next.match(matcher, i, seq);
3672             return next.match(matcher, i, seq);
3691         boolean match(Matcher matcher, int i, CharSequence seq) {
3693                 int ch = Character.codePointAt(seq, i);
3695                     && next.match(matcher, i+Character.charCount(ch), seq);
3713         boolean match(Matcher matcher, int i, CharSequence seq) {
3715                 return isSatisfiedBy(seq.charAt(i))
3716                     && next.match(matcher, i+1, seq);
3859         boolean match(Matcher matcher, int i, CharSequence seq) {
3867                 if (buf[j] != seq.charAt(i+j))
3870             return next.match(matcher, i+len, seq);
3882         boolean match(Matcher matcher, int i, CharSequence seq) {
3890                 int c = seq.charAt(i+j);
3895             return next.match(matcher, i+len, seq);
3907         boolean match(Matcher matcher, int i, CharSequence seq) {
3915                 int c = seq.charAt(i+j);
3920             return next.match(matcher, i+len, seq);
3932         boolean match(Matcher matcher, int i, CharSequence seq) {
3940                 int c = Character.codePointAt(seq, x);
3949             return next.match(matcher, x, seq);
3964         boolean match(Matcher matcher, int i, CharSequence seq) {
3972                 int c = Character.codePointAt(seq, x);
3981             return next.match(matcher, x, seq);
4076         boolean match(Matcher matcher, int i, CharSequence seq) {
4079                 return (atom.match(matcher, i, seq) && next.match(matcher, matcher.last, seq))
4080                     || next.match(matcher, i, seq);
4082                 return next.match(matcher, i, seq)
4083                     || (atom.match(matcher, i, seq) && next.match(matcher, matcher.last, seq));
4085                 if (atom.match(matcher, i, seq)) i = matcher.last;
4086                 return next.match(matcher, i, seq);
4088                 return atom.match(matcher, i, seq) && next.match(matcher, matcher.last, seq);
4122         boolean match(Matcher matcher, int i, CharSequence seq) {
4125                 if (atom.match(matcher, i, seq)) {
4132                 return match0(matcher, i, j, seq);
4134                 return match1(matcher, i, j, seq);
4136                 return match2(matcher, i, j, seq);
4141         boolean match0(Matcher matcher, int i, int j, CharSequence seq) {
4145                 return next.match(matcher, i, seq);
4148             while (atom.match(matcher, i, seq)) {
4158                     if (!atom.match(matcher, i, seq))
4161                         if (match0(matcher, matcher.last, j+1, seq))
4170                    if (next.match(matcher, i, seq))
4177             return next.match(matcher, i, seq);
4182         boolean match1(Matcher matcher, int i, int j, CharSequence seq) {
4185                 if (next.match(matcher, i, seq))
4191                 if (!atom.match(matcher, i, seq))
4201         boolean match2(Matcher matcher, int i, int j, CharSequence seq) {
4203                 if (!atom.match(matcher, i, seq))
4209             return next.match(matcher, i, seq);
4273         boolean match(Matcher matcher, int i, CharSequence seq) {
4291                 if (atom.match(matcher, i, seq)) {
4304                     ret = match0(matcher, i, cmin, seq);
4306                     ret = match1(matcher, i, cmin, seq);
4308                     ret = match2(matcher, i, cmin, seq);
4321         boolean match0(Matcher matcher, int i, int j, CharSequence seq) {
4332                 if (!atom.match(matcher, i, seq))
4351                     if (!atom.match(matcher, i, seq))
4354                         if (match0(matcher, i, j, seq))
4360                     if (next.match(matcher, i, seq)) {
4382             return next.match(matcher, i, seq);
4385         boolean match1(Matcher matcher, int i, int j, CharSequence seq) {
4387                 if (next.match(matcher, i, seq))
4391                 if (!atom.match(matcher, i, seq))
4404         boolean match2(Matcher matcher, int i, int j, CharSequence seq) {
4406                 if (!atom.match(matcher, i, seq)) {
4418             return next.match(matcher, i, seq);
4465         boolean match(Matcher matcher, int i, CharSequence seq) {
4466             return next.match(matcher, i, seq);
4497         boolean match(Matcher matcher, int i, CharSequence seq) {
4500                     if (conn.next.match(matcher, i, seq))
4502                 } else if (atoms[n].match(matcher, i, seq)) {
4553         boolean match(Matcher matcher, int i, CharSequence seq) {
4556             boolean ret = next.match(matcher, i, seq);
4560         boolean matchRef(Matcher matcher, int i, CharSequence seq) {
4563             boolean ret = next.match(matcher, i, seq);
4579         boolean match(Matcher matcher, int i, CharSequence seq) {
4580             return head.matchRef(matcher, i, seq)
4581                 && next.match(matcher, matcher.last, seq);
4605         boolean match(Matcher matcher, int i, CharSequence seq) {
4615                 if (next.match(matcher, i, seq)) {
4638         boolean match(Matcher matcher, int i, CharSequence seq) {
4639             return loop.matchInit(matcher, i, seq);
4661         boolean match(Matcher matcher, int i, CharSequence seq) {
4670                     boolean b = body.match(matcher, i, seq);
4683                     boolean b = body.match(matcher, i, seq);
4692             return next.match(matcher, i, seq);
4694         boolean matchInit(Matcher matcher, int i, CharSequence seq) {
4699                 ret = body.match(matcher, i, seq);
4702                 ret = body.match(matcher, i, seq);
4704                     ret = next.match(matcher, i, seq);
4706                 ret = next.match(matcher, i, seq);
4728         boolean match(Matcher matcher, int i, CharSequence seq) {
4734                     boolean result = body.match(matcher, i, seq);
4741                 if (next.match(matcher, i, seq))
4745                     boolean result = body.match(matcher, i, seq);
4754             return next.match(matcher, i, seq);
4756         boolean matchInit(Matcher matcher, int i, CharSequence seq) {
4761                 ret = body.match(matcher, i, seq);
4762             } else if (next.match(matcher, i, seq)) {
4766                 ret = body.match(matcher, i, seq);
4788         boolean match(Matcher matcher, int i, CharSequence seq) {
4807                 if (seq.charAt(i+index) != seq.charAt(j+index))
4810             return next.match(matcher, i+groupSize, seq);
4826         boolean match(Matcher matcher, int i, CharSequence seq) {
4846                 int c1 = Character.codePointAt(seq, x);
4847                 int c2 = Character.codePointAt(seq, j);
4865             return next.match(matcher, i+groupSize, seq);
4884         boolean match(Matcher matcher, int i, CharSequence seq) {
4886                 return atom.match(matcher, i, seq)
4887                     && next.match(matcher, matcher.last, seq);
4894                 if (atom.match(matcher, i, seq)) {
4895                     return next.match(matcher, matcher.last, seq);
4897                 i += countChars(seq, i, 1);
4916         boolean match(Matcher matcher, int i, CharSequence seq) {
4917             if (cond.match(matcher, i, seq)) {
4918                 return yes.match(matcher, i, seq);
4920                 return not.match(matcher, i, seq);
4952         boolean match(Matcher matcher, int i, CharSequence seq) {
4960                 conditionMatched = cond.match(matcher, i, seq);
4965             return conditionMatched && next.match(matcher, i, seq);
4977         boolean match(Matcher matcher, int i, CharSequence seq) {
4986                     conditionMatched = !cond.match(matcher, i, seq);
4991                     conditionMatched = !cond.match(matcher, i, seq);
4997             return conditionMatched && next.match(matcher, i, seq);
5006         boolean match(Matcher matcher, int i, CharSequence seq) {
5023         boolean match(Matcher matcher, int i, CharSequence seq) {
5036                 conditionMatched = cond.match(matcher, j, seq);
5040             return conditionMatched && next.match(matcher, i, seq);
5052         boolean match(Matcher matcher, int i, CharSequence seq) {
5053             int rmaxChars = countChars(seq, i, -rmax);
5054             int rminChars = countChars(seq, i, -rmin);
5069                  j -= j>from ? countChars(seq, j, -1) : 1) {
5070                 conditionMatched = cond.match(matcher, j, seq);
5074             return conditionMatched && next.match(matcher, i, seq);
5090         boolean match(Matcher matcher, int i, CharSequence seq) {
5102                 conditionMatched = cond.match(matcher, j, seq);
5107             return !conditionMatched && next.match(matcher, i, seq);
5119         boolean match(Matcher matcher, int i, CharSequence seq) {
5120             int rmaxChars = countChars(seq, i, -rmax);
5121             int rminChars = countChars(seq, i, -rmin);
5134                  j -= j>from ? countChars(seq, j, -1) : 1) {
5135                 conditionMatched = cond.match(matcher, j, seq);
5140             return !conditionMatched && next.match(matcher, i, seq);
5198         int check(Matcher matcher, int i, CharSequence seq) {
5208                 ch = Character.codePointBefore(seq, i);
5211                      && hasBaseCharacter(matcher, i-1, seq)));
5215                 ch = Character.codePointAt(seq, i);
5218                      && hasBaseCharacter(matcher, i, seq)));
5227         boolean match(Matcher matcher, int i, CharSequence seq) {
5228             return (check(matcher, i, seq) & type) > 0
5229                 && next.match(matcher, i, seq);
5238                                             CharSequence seq)
5243             int ch = Character.codePointAt(seq, x);
5350         boolean match(Matcher matcher, int i, CharSequence seq) {
5359                     int ch = seq.charAt(i+j);
5369                 boolean ret = next.match(matcher, i + patternLength, seq);
5404         boolean match(Matcher matcher, int i, CharSequence seq) {
5413                 for (int j = countChars(seq, i, patternLength), x = patternLength - 1;
5415                     ch = Character.codePointBefore(seq, i+j);
5420                         i += countChars(seq, i, n);
5426                 boolean ret = next.match(matcher, i + lengthInChars, seq);
5433                 i += countChars(seq, i, 1);