示例#1
0
 public DescribedAs(string descriptionTemplate, Matcher matcher, object[] values)
 {
   DescribedAs describedAs = this;
   this.descriptionTemplate = descriptionTemplate;
   this.matcher = matcher;
   this.values = (object[]) values.Clone();
 }
 public Matcher matcher(CharSequence input) {
     if (!compiled) {
         lock(this) {
             if (!compiled)
                 compile();
         }
     }
     Matcher m = new Matcher(this, input);
     return m;
 }
 internal boolean matchRef(Matcher matcher, int i, CharSequence seq) {
     int save = matcher.locals[localIndex];
     matcher.locals[localIndex] = ~i; // HACK
     boolean ret = next.match(matcher, i, seq);
     matcher.locals[localIndex] = save;
     return ret;
 }
示例#4
0
		internal static void ReplaceMatch (string replacementPattern, Matcher match, StringBuffer sb, string input, PatternData patternData) {

			replacementPattern = JavaUtils.ReplaceAll (replacementPattern, COPY_ENTIRE_MATCH_PATTERN, match.group ());
			replacementPattern = JavaUtils.ReplaceAll (replacementPattern, INPUT_BEFORE_MATCH_PATTERN, input.Substring (0, match.start ()));
			replacementPattern = JavaUtils.ReplaceAll (replacementPattern, INPUT_AFTER_MATCH_PATTERN, input.Substring (match.end ()));
			replacementPattern = JavaUtils.ReplaceAll (replacementPattern, INPUT_PATTERN, input);

			int groupsNumber = match.groupCount ();
			if (groupsNumber > 0) {
				Pattern p = Pattern.compile (LAST_CAPTURED_GROUP_PATTERN);
				Matcher m = p.matcher ((CharSequence) (object) replacementPattern);
				if (m.find ()) {
					while (groupsNumber > 0) {
						if (match.start (patternData.NetToJavaNumbersMap [groupsNumber]) >= 0) {
							break;
						}
						--groupsNumber;
					}
					if (groupsNumber > 0) {
						replacementPattern = m.replaceAll (match.group (patternData.NetToJavaNumbersMap [groupsNumber]));
					}
				}
			}

			match.appendReplacement (sb, replacementPattern);
		}
		private string ReplaceGroupName (Matcher match,
			string reformattedPattern,
			PatternGrouping patternGrouping,
			RegexOptions options) {

			if (patternGrouping.GroupCount == -1){
				return null;
			}

			string groupName = match.group (1);
			Pattern p = Pattern.compile (NUMBER);
			Matcher m = p.matcher ((CharSequence) (object) groupName);
			if (m.matches ()) {
				return ReplaceGroupNumber (match, reformattedPattern, patternGrouping, options);
			}

			if (!patternGrouping.GroupNameToNumberMap.Contains (groupName)) {
				return null;
			}

			int javaGroupNumber = patternGrouping.NetToJavaNumbersMap [(int) patternGrouping.GroupNameToNumberMap [groupName]];
			return match.replaceFirst (@"\\" + javaGroupNumber);
		}
示例#6
0
 public static Matcher describedAs(string description, Matcher matcher, params object[] values)
 {
   return (Matcher) new DescribedAs(description, matcher, values);
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     int[] src = buffer;
     int patternLength = src.Length;
     int last = matcher.to - patternLength;
     // Loop over all possible match positions in text
     while (i <= last) {
         // Loop over pattern from right to left
         for (int j = patternLength - 1; j >= 0; j--) {
             int ch = seq.charAt(i+j);
             if (ch != src[j]) {
                 // Shift search to the right by the maximum of the
                 // bad character shift and the good suffix shift
                 i += Math.max(j + 1 - lastOcc[ch&0x7F], optoSft[j]);
                 goto continue4;
             }
         }
         // Entire pattern matched starting at i
         matcher.first = i;
         boolean ret = next.match(matcher, i + patternLength, seq);
         if (ret) {
             matcher.first = i;
             matcher.groups[0] = matcher.first;
             matcher.groups[1] = matcher.last;
             return true;
         }
         i++;
     continue4:
         ;
     }
     // BnM is only used as the leading node in the unanchored case,
     // and it replaced its Start() which always searches to the end
     // if it doesn't find what it's looking for, so hitEnd is true.
     matcher._hitEnd = true;
     return false;
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     return (check(matcher, i, seq) & type) > 0
         && next.match(matcher, i, seq);
 }
 internal override boolean matchInit(Matcher matcher, int i, CharSequence seq)
 {
     int save = matcher.locals[countIndex];
     boolean ret = false;
     if (0 < cmin) {
         matcher.locals[countIndex] = 1;
         ret = body.match(matcher, i, seq);
     } else if (next.match(matcher, i, seq)) {
         ret = true;
     } else if (0 < cmax) {
         matcher.locals[countIndex] = 1;
         ret = body.match(matcher, i, seq);
     }
     matcher.locals[countIndex] = save;
     return ret;
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     // Check for zero length group
     if (i > matcher.locals[beginIndex]) {
         int count = matcher.locals[countIndex];
         if (count < cmin) {
             matcher.locals[countIndex] = count + 1;
             boolean result = body.match(matcher, i, seq);
             // If match failed we must backtrack, so
             // the loop count should NOT be incremented
             if (!result)
                 matcher.locals[countIndex] = count;
             return result;
         }
         if (next.match(matcher, i, seq))
             return true;
         if (count < cmax) {
             matcher.locals[countIndex] = count + 1;
             boolean result = body.match(matcher, i, seq);
             // If match failed we must backtrack, so
             // the loop count should NOT be incremented
             if (!result)
                 matcher.locals[countIndex] = count;
             return result;
         }
         return false;
     }
     return next.match(matcher, i, seq);
 }
 internal virtual boolean matchInit(Matcher matcher, int i, CharSequence seq) {
     int save = matcher.locals[countIndex];
     boolean ret = false;
     if (0 < cmin) {
         matcher.locals[countIndex] = 1;
         ret = body.match(matcher, i, seq);
     } else if (0 < cmax) {
         matcher.locals[countIndex] = 1;
         ret = body.match(matcher, i, seq);
         if (ret == false)
             ret = next.match(matcher, i, seq);
     } else {
         ret = next.match(matcher, i, seq);
     }
     matcher.locals[countIndex] = save;
     return ret;
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     // Avoid infinite loop in zero-length case.
     if (i > matcher.locals[beginIndex]) {
         int count = matcher.locals[countIndex];
         // This block is for before we reach the minimum
         // iterations required for the loop to match
         if (count < cmin) {
             matcher.locals[countIndex] = count + 1;
             boolean b = body.match(matcher, i, seq);
             // If match failed we must backtrack, so
             // the loop count should NOT be incremented
             if (!b)
                 matcher.locals[countIndex] = count;
             // Return success or failure since we are under
             // minimum
             return b;
         }
         // This block is for after we have the minimum
         // iterations required for the loop to match
         if (count < cmax) {
             matcher.locals[countIndex] = count + 1;
             boolean b = body.match(matcher, i, seq);
             // If match failed we must backtrack, so
             // the loop count should NOT be incremented
             if (!b)
                 matcher.locals[countIndex] = count;
             else
                 return true;
         }
     }
     return next.match(matcher, i, seq);
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     return loop.matchInit(matcher, i, seq);
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     int tmp = matcher.locals[localIndex];
     if (tmp >= 0) { // This is the normal group case.
         // Save the group so we can unset it if it
         // backs off of a match.
         int groupStart = matcher.groups[groupIndex];
         int groupEnd = matcher.groups[groupIndex+1];
         matcher.groups[groupIndex] = tmp;
         matcher.groups[groupIndex+1] = i;
         if (next.match(matcher, i, seq)) {
             return true;
         }
         matcher.groups[groupIndex] = groupStart;
         matcher.groups[groupIndex+1] = groupEnd;
         return false;
     } else {
         // This is a group reference case. We don't need to save any
         // group info because it isn't really a group.
         matcher.last = i;
         return true;
     }
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     return head.matchRef(matcher, i, seq)
         && next.match(matcher, matcher.last, seq);
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     int rmaxChars = countChars(seq, i, -rmax);
     int rminChars = countChars(seq, i, -rmin);
     int savedFrom = matcher.from;
     int savedLBT = matcher.lookbehindTo;
     boolean conditionMatched = false;
     int startIndex = (!matcher.transparentBounds) ?
                      matcher.from : 0;
     int from = Math.max(i - rmaxChars, startIndex);
     matcher.lookbehindTo = i;
     // Relax transparent region boundaries for lookbehind
     if (matcher.transparentBounds)
         matcher.from = 0;
     for (int j = i - rminChars;
          !conditionMatched && j >= from;
          j -= j>from ? countChars(seq, j, -1) : 1) {
         conditionMatched = cond.match(matcher, j, seq);
     }
     //Reinstate region boundaries
     matcher.from = savedFrom;
     matcher.lookbehindTo = savedLBT;
     return !conditionMatched && next.match(matcher, i, seq);
 }
 int check(Matcher matcher, int i, CharSequence seq) {
     int ch;
     boolean left = false;
     int startIndex = matcher.from;
     int endIndex = matcher.to;
     if (matcher.transparentBounds) {
         startIndex = 0;
         endIndex = matcher.getTextLength();
     }
     if (i > startIndex) {
         ch = Character.codePointBefore(seq, i);
         left = (isWord(ch) ||
             ((Character.getType(ch) == Character.NON_SPACING_MARK)
              && hasBaseCharacter(matcher, i-1, seq)));
     }
     boolean right = false;
     if (i < endIndex) {
         ch = Character.codePointAt(seq, i);
         right = (isWord(ch) ||
             ((Character.getType(ch) == Character.NON_SPACING_MARK)
              && hasBaseCharacter(matcher, i, seq)));
     } else {
         // Tried to access char past the end
         matcher._hitEnd = true;
         // The addition of another char could wreck a boundary
         matcher._requireEnd = true;
     }
     return ((left ^ right) ? (right ? LEFT : RIGHT) : NONE);
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     int j = matcher.groups[groupIndex];
     int k = matcher.groups[groupIndex+1];
     int groupSize = k - j;
     // If the referenced group didn't match, neither can this
     if (j < 0)
         return false;
     // If there isn't enough input left no match
     if (i + groupSize > matcher.to) {
         matcher._hitEnd = true;
         return false;
     }
     // Check each new char to make sure it matches what the group
     // referenced matched last time around
     for (int index=0; index<groupSize; index++)
         if (seq.charAt(i+index) != seq.charAt(j+index))
             return false;
     return next.match(matcher, i+groupSize, seq);
 }
 private static boolean hasBaseCharacter(Matcher matcher, int i,
                                         CharSequence seq)
 {
     int start = (!matcher.transparentBounds) ?
         matcher.from : 0;
     for (int x=i; x >= start; x--) {
         int ch = Character.codePointAt(seq, x);
         if (Character.isLetterOrDigit(ch))
             return true;
         if (Character.getType(ch) == Character.NON_SPACING_MARK)
             continue;
         return false;
     }
     return false;
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     int j = matcher.groups[groupIndex];
     int k = matcher.groups[groupIndex+1];
     int groupSize = k - j;
     // If the referenced group didn't match, neither can this
     if (j < 0)
         return false;
     // If there isn't enough input left no match
     if (i + groupSize > matcher.to) {
         matcher._hitEnd = true;
         return false;
     }
     // Check each new char to make sure it matches what the group
     // referenced matched last time around
     int x = i;
     for (int index=0; index<groupSize; index++) {
         int c1 = Character.codePointAt(seq, x);
         int c2 = Character.codePointAt(seq, j);
         if (c1 != c2) {
             if (doUnicodeCase) {
                 int cc1 = Character.toUpperCase(c1);
                 int cc2 = Character.toUpperCase(c2);
                 if (cc1 != cc2 &&
                     Character.toLowerCase(cc1) !=
                     Character.toLowerCase(cc2))
                     return false;
             } else {
                 if (ASCII.toLower(c1) != ASCII.toLower(c2))
                     return false;
             }
         }
         x += Character.charCount(c1);
         j += Character.charCount(c2);
     }
     return next.match(matcher, i+groupSize, seq);
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     int[] src = buffer;
     int patternLength = src.Length;
     int last = matcher.to - lengthInChars;
     // Loop over all possible match positions in text
     while (i <= last) {
         // Loop over pattern from right to left
         int ch;
         for (int j = countChars(seq, i, patternLength), x = patternLength - 1;
              j > 0; j -= Character.charCount(ch), x--) {
             ch = Character.codePointBefore(seq, i+j);
             if (ch != src[x]) {
                 // Shift search to the right by the maximum of the
                 // bad character shift and the good suffix shift
                 int n = Math.max(x + 1 - lastOcc[ch&0x7F], optoSft[x]);
                 i += countChars(seq, i, n);
                 goto continue5;
             }
         }
         // Entire pattern matched starting at i
         matcher.first = i;
         boolean ret = next.match(matcher, i + lengthInChars, seq);
         if (ret) {
             matcher.first = i;
             matcher.groups[0] = matcher.first;
             matcher.groups[1] = matcher.last;
             return true;
         }
         i += countChars(seq, i, 1);
     continue5:
         ;
     }
     matcher._hitEnd = true;
     return false;
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     if (atom is BnM) {
         return atom.match(matcher, i, seq)
             && next.match(matcher, matcher.last, seq);
     }
     for (;;) {
         if (i > matcher.to) {
             matcher._hitEnd = true;
             return false;
         }
         if (atom.match(matcher, i, seq)) {
             return next.match(matcher, matcher.last, seq);
         }
         i += countChars(seq, i, 1);
         matcher.first++;
     }
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     if (cond.match(matcher, i, seq)) {
         return yes.match(matcher, i, seq);
     } else {
         return not.match(matcher, i, seq);
     }
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     int savedTo = matcher.to;
     boolean conditionMatched = false;
     // Relax transparent region boundaries for lookahead
     if (matcher.transparentBounds)
         matcher.to = matcher.getTextLength();
     try {
         conditionMatched = cond.match(matcher, i, seq);
     } finally {
         // Reinstate region boundaries
         matcher.to = savedTo;
     }
     return conditionMatched && next.match(matcher, i, seq);
 }
示例#25
0
		private void AddGroup (Matcher m, GroupCollection groups, int javaGroupNumber, string text, Match match) {
			int netGroupNumber = _patternData.JavaToNetGroupNumbersMap [javaGroupNumber];
			if (netGroupNumber == -1) {
				return;
			}

			int index = m.start (javaGroupNumber);

			if (index < 0){
				if(groups[netGroupNumber] == null) 
					groups.SetValue (new Group (), netGroupNumber);
				return;
			}

			Group group = new Group (text, index, m.end (javaGroupNumber) - index, match, netGroupNumber);

			groups.SetValue (group, netGroupNumber);
		}
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     int savedTo = matcher.to;
     boolean conditionMatched = false;
     // Relax transparent region boundaries for lookahead
     if (matcher.transparentBounds)
         matcher.to = matcher.getTextLength();
     try {
         if (i < matcher.to) {
             conditionMatched = !cond.match(matcher, i, seq);
         } else {
             // If a negative lookahead succeeds then more input
             // could cause it to fail!
             matcher._requireEnd = true;
             conditionMatched = !cond.match(matcher, i, seq);
         }
     } finally {
         // Reinstate region boundaries
         matcher.to = savedTo;
     }
     return conditionMatched && next.match(matcher, i, seq);
 }
		private string ReplaceGroupNumber (Matcher match,
			string reformattedPattern,
			PatternGrouping patternGrouping,
			RegexOptions options) {
			int groupNumber = int.Parse (match.group (1));
			int javaGroupNumber = groupNumber;
			int groupCount = patternGrouping.GroupCount;

			if (groupCount == -1) {
				if ((options & RegexOptions.ExplicitCapture) == RegexOptions.ExplicitCapture) {
					groupCount = 0;
				}
				else {
					groupCount = JavaUtils.GroupCount (reformattedPattern);
				}
			}
			else {
				javaGroupNumber = patternGrouping.NetToJavaNumbersMap [groupNumber];
			}

			if (groupNumber > groupCount) {
				return null;
			}

			return match.replaceFirst (@"\\" + javaGroupNumber);
		}
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     int savedFrom = matcher.from;
     boolean conditionMatched = false;
     int startIndex = (!matcher.transparentBounds) ?
                      matcher.from : 0;
     int from = Math.max(i - rmax, startIndex);
     // Set end boundary
     int savedLBT = matcher.lookbehindTo;
     matcher.lookbehindTo = i;
     // Relax transparent region boundaries for lookbehind
     if (matcher.transparentBounds)
         matcher.from = 0;
     for (int j = i - rmin; !conditionMatched && j >= from; j--) {
         conditionMatched = cond.match(matcher, j, seq);
     }
     matcher.from = savedFrom;
     matcher.lookbehindTo = savedLBT;
     return conditionMatched && next.match(matcher, i, seq);
 }
 public MatchResult toMatchResult()
 {
     Matcher result = new Matcher(this.parentPattern, text);
     result.first = this.first;
     result.last = this.last;
     result.groups = (int[])this.groups.Clone();
     return result;
 }
 internal override boolean match(Matcher matcher, int i, CharSequence seq)
 {
     int save = matcher.locals[localIndex];
     matcher.locals[localIndex] = i;
     boolean ret = next.match(matcher, i, seq);
     matcher.locals[localIndex] = save;
     return ret;
 }