public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int min = quantifier.Min(); int max = quantifier.Max(); int i = 0; for (; i < min; i++) { if (stringIndex + leaf.CharCount() > matchResult.GetRightBound()) { matchResult.hitEnd = true; return(-1); } int shift = leaf.Accepts(stringIndex, testString); if (shift < 1) { return(-1); } stringIndex += shift; } for (; i < max; i++) { int shift_0; if (stringIndex + leaf.CharCount() > matchResult.GetRightBound() || (shift_0 = leaf.Accepts(stringIndex, testString)) < 1) { break; } stringIndex += shift_0; } return(next.Matches(stringIndex, testString, matchResult)); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int strLength = matchResult.GetRightBound(); int offset = -1; if (stringIndex < strLength) { char high = testString[stringIndex++]; if (Contains(high) && (offset = next.Matches(stringIndex, testString, matchResult)) > 0) { return(offset); } if (stringIndex < strLength) { char low = testString[stringIndex++]; if (System.Char.IsSurrogatePair(high, low) && Contains(Character.ToCodePoint(high, low))) { return(next.Matches(stringIndex, testString, matchResult)); } } } return(-1); }
public override int Find(int stringIndex, String testString, MatchResultImpl matchResult) { int res = 0; int lastIndex = matchResult.GetRightBound(); int startSearch = stringIndex; for (; startSearch <= lastIndex; startSearch++) { int saveStart = matchResult.GetStart(groupIndex); matchResult.SetStart(groupIndex, startSearch); res = kid.Matches(startSearch, testString, matchResult); if (res >= 0) { res = startSearch; break; } else { matchResult.SetStart(groupIndex, saveStart); } } return(res); }
public override int Matches(int strIndex, String testString, MatchResultImpl matchResult) { int rightBound = (matchResult.HasAnchoringBounds()) ? matchResult .GetRightBound() : testString.Length; if (strIndex >= rightBound) { matchResult.SetConsumed(consCounter, 0); return(next.Matches(strIndex, testString, matchResult)); } // check final line terminator; if ((rightBound - strIndex) == 2 && testString[strIndex] == '\r' && testString[strIndex + 1] == '\n') { matchResult.SetConsumed(consCounter, 0); return(next.Matches(strIndex, testString, matchResult)); } char ch; if ((rightBound - strIndex) == 1 && (((ch = testString[strIndex]) == '\n' || ch == '\r' || ch == '\u0085' || (ch | 1) == '\u2029'))) { matchResult.SetConsumed(consCounter, 0); return(next.Matches(strIndex, testString, matchResult)); } return(-1); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { if (stringIndex + 1 > matchResult.GetRightBound()) { matchResult.hitEnd = true; return(-1); } char low_0 = testString[stringIndex]; if (stringIndex > matchResult.GetLeftBound()) { char high = testString[stringIndex - 1]; /* * we consider high surrogate followed by * low surrogate as a codepoint */ if (System.Char.IsHighSurrogate(high)) { return(-1); } } if (this.low == low_0) { return(next.Matches(stringIndex + 1, testString, matchResult)); } return(-1); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int strLength = matchResult.GetRightBound(); if (stringIndex + 1 > strLength) { matchResult.hitEnd = true; return(-1); } char high = testString[stringIndex]; if (System.Char.IsHighSurrogate(high) && (stringIndex + 2 <= strLength)) { char low = testString[stringIndex + 1]; if (System.Char.IsSurrogatePair(high, low)) { return((lt.IsLineTerminator(Character.ToCodePoint(high, low))) ? -1 : next.Matches(stringIndex + 2, testString, matchResult)); } } return((lt.IsLineTerminator(high)) ? -1 : next.Matches(stringIndex + 1, testString, matchResult)); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int strLength = matchResult.GetRightBound(); if (stringIndex + 1 > strLength) { matchResult.hitEnd = true; return(-1); } char high_0 = testString[stringIndex]; if (stringIndex + 1 < strLength) { char low = testString[stringIndex + 1]; /* * we consider high surrogate followed by * low surrogate as a codepoint */ if (System.Char.IsLowSurrogate(low)) { return(-1); } } if (this.high == high_0) { return(next.Matches(stringIndex + 1, testString, matchResult)); } return(-1); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int i = 0; int shift = 0; while (stringIndex + leaf.CharCount() <= matchResult.GetRightBound() && (shift = leaf.Accepts(stringIndex, testString)) > 0) { stringIndex += shift; i++; } for (; i >= 0; i--) { shift = next.Matches(stringIndex, testString, matchResult); if (shift >= 0) { return(shift); } stringIndex -= leaf.CharCount(); } return(-1); }
public override int Find(int strIndex, String testString, MatchResultImpl matchResult) { if (testString is String) { String testStr = (String)testString; int strLength = matchResult.GetRightBound(); while (strIndex < strLength) { strIndex = testStr.IndexOf(high, strIndex); if (strIndex < 0) { return(-1); } strIndex++; if (strIndex < strLength) { char ch_0 = testStr[strIndex]; if ((low == ch_0) && (next.Matches(strIndex + 1, testString, matchResult) >= 0)) { return(--strIndex); } strIndex++; } } return(-1); } return(base.Find(strIndex, testString, matchResult)); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int min = quantifier.Min(); int max = quantifier.Max(); int i = 0; int shift = 0; for (; i < min; i++) { if (stringIndex + leaf.CharCount() > matchResult.GetRightBound()) { matchResult.hitEnd = true; return(-1); } shift = leaf.Accepts(stringIndex, testString); if (shift < 1) { return(-1); } stringIndex += shift; } do { shift = next.Matches(stringIndex, testString, matchResult); if (shift >= 0) { return(shift); } if (stringIndex + leaf.CharCount() <= matchResult.GetRightBound()) { shift = leaf.Accepts(stringIndex, testString); stringIndex += shift; i++; } } while (shift >= 1 && i <= max); return(-1); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int strLength = matchResult.GetRightBound(); if (strLength <= stringIndex) { return(next.Matches(stringIndex, testString, matchResult)); } return(next.FindBack(stringIndex, strLength, testString, matchResult)); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { while (stringIndex + leaf.CharCount() <= matchResult.GetRightBound() && leaf.Accepts(stringIndex, testString) > 0) { stringIndex += leaf.CharCount(); } return(next.Matches(stringIndex, testString, matchResult)); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { if (matchResult.Mode() == Matcher.MODE_FIND || stringIndex == matchResult.GetRightBound()) { matchResult.SetValid(); matchResult.SetEnd(0, stringIndex); return(stringIndex); } return(-1); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int shift = 0; if (stringIndex + leaf.CharCount() <= matchResult.GetRightBound() && (shift = leaf.Accepts(stringIndex, testString)) >= 1) { stringIndex += shift; } return(next.Matches(stringIndex, testString, matchResult)); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { String group = GetString(matchResult); if (group == null || (stringIndex + group.Length) > matchResult.GetRightBound()) return -1; int shift = (ILOG.J2CsMapping.Util.StringUtil.StartsWith(testString.ToString(),group,stringIndex)) ? group.Length : -1; if (shift < 0) { return -1; } matchResult.SetConsumed(consCounter, shift); return next.Matches(stringIndex + shift, testString, matchResult); }
public override int Matches(int strIndex, String testString, MatchResultImpl matchResult) { if (strIndex != matchResult.GetRightBound() && ((strIndex == 0 || (matchResult.HasAnchoringBounds() && strIndex == matchResult .GetLeftBound())) || lt.IsAfterLineTerminator( testString[strIndex - 1], testString[strIndex]))) { return(next.Matches(strIndex, testString, matchResult)); } return(-1); }
public override int Find(int stringIndex, String testString, MatchResultImpl matchResult) { int strLength = matchResult.GetRightBound(); if (next.FindBack(stringIndex, strLength, testString, matchResult) >= 0) { return(stringIndex); } else { return(-1); } }
/// <summary> /// Returns stringIndex+shift, the next position to match /// </summary> /// public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int startStr = matchResult.GetLeftBound(); int strLength = matchResult.GetRightBound(); if (stringIndex + 1 > strLength) { matchResult.hitEnd = true; return(-1); } char ch = testString[stringIndex]; if (!surrChars.Contains(ch)) { return(-1); } if (System.Char.IsHighSurrogate(ch)) { if (stringIndex + 1 < strLength) { char low = testString[stringIndex + 1]; if (System.Char.IsLowSurrogate(low)) { return(-1); } } } else if (System.Char.IsLowSurrogate(ch)) { if (stringIndex > startStr) { char high = testString[stringIndex - 1]; if (System.Char.IsHighSurrogate(high)) { return(-1); } } } return(next.Matches(stringIndex + 1, testString, matchResult)); }
public override int Find(int stringIndex, String testString, MatchResultImpl matchResult) { // String testStr = testString.toString(); int strLength = matchResult.GetRightBound(); // 1. skip line terminators ??? // // // we don't skip line terminators here, but return zero match instead // // // 2. find first occurrence of the searched pattern // // int res = next.Find(stringIndex, testString, matchResult); // 3. Check if we have other occurrences till the end of line // (because .* is greedy and we need last one) // // if (res >= 0) { int nextSearch = FindLineTerminator(res, strLength, testString); // testStr.indexOf('\n', res); if (nextSearch < 0) { nextSearch = strLength; } nextSearch = next .FindBack(res, nextSearch, testString, matchResult); res = (res < nextSearch) ? nextSearch : res; } else { return(-1); } // 4. find left boundary of this search // // int leftBound = (res > 0) ? FindBackLineTerminator(stringIndex, res - 1, testString)/* testStr.lastIndexOf('\n', res - 1) */ : (res == 0) ? 0 : -1; res = (leftBound >= stringIndex) ? ((leftBound < res) ? leftBound + 1 : leftBound) : stringIndex; return(res); }
/// <summary> /// Attempts to apply pattern starting from this set/stringIndex; returns /// index this search was started from, if value is negative, this means that /// this search didn't succeed, additional information could be obtained via /// matchResult; /// Note: this is default implementation for find method, it's based on /// matches, subclasses do not have to override find method unless /// more effective find method exists for a particular node type /// (sequence, i.e. substring, for example). Same applies for find back /// method. /// </summary> /// /// <param name="stringIndex">starting index</param> /// <param name="testString">string to search in</param> /// <param name="matchResult">result of the match</param> /// <returns>last searched index</returns> public virtual int Find(int stringIndex, String testString, MatchResultImpl matchResult) { int length = matchResult.GetRightBound(); while (stringIndex <= length) { if (Matches(stringIndex, testString, matchResult) >= 0) { return(stringIndex); } else { stringIndex++; } } return(-1); }
public override int Matches(int strIndex, String testString, MatchResultImpl matchResult) { int strDif = (matchResult.HasAnchoringBounds()) ? matchResult .GetRightBound() - strIndex : testString.Length - strIndex; if (strDif <= 0) { matchResult.SetConsumed(consCounter, 0); return(next.Matches(strIndex, testString, matchResult)); } else if (testString[strIndex] == '\n') { matchResult.SetConsumed(consCounter, 1); return(next.Matches(strIndex + 1, testString, matchResult)); } return(-1); }
/// <summary> /// Checks if we can enter this state and pass the control to the next one. /// Return positive value if match succeeds, negative otherwise. /// </summary> /// public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { if (stringIndex + CharCount() > matchResult.GetRightBound()) { matchResult.hitEnd = true; return(-1); } int shift = Accepts(stringIndex, testString); if (shift < 0) { return(-1); } return(next.Matches(stringIndex + shift, testString, matchResult)); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int strLength = matchResult.GetRightBound(); int startSearch = /* testString.toString().indexOf('\n', stringIndex); */ FindLineTerminator(stringIndex, strLength, testString); if (startSearch < 0) { startSearch = strLength; } if (startSearch <= stringIndex) { return(next.Matches(stringIndex, testString, matchResult)); } return(next.FindBack(stringIndex, startSearch, testString, matchResult)); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { bool left; bool right; char ch1 = (stringIndex >= matchResult.GetRightBound()) ? ' ' : testString[stringIndex]; char ch2 = (stringIndex == 0) ? ' ' : testString[stringIndex - 1]; int leftBound = (matchResult.HasTransparentBounds()) ? 0 : matchResult .GetLeftBound(); left = (ch1 == ' ') || IsSpace(ch1, stringIndex, leftBound, testString); right = (ch2 == ' ') || IsSpace(ch2, stringIndex - 1, leftBound, testString); return(((left ^ right) ^ positive) ? -1 : next.Matches(stringIndex, testString, matchResult)); }
public override int Find(int strIndex, String testString, MatchResultImpl matchResult) { if (testString is String) { String testStr = (String)testString; int startStr = matchResult.GetLeftBound(); int strLength = matchResult.GetRightBound(); while (strIndex < strLength) { strIndex = testStr.IndexOf(low, strIndex); if (strIndex < 0) { return(-1); } if (strIndex > startStr) { /* * we consider high surrogate followed by * low surrogate as a codepoint */ if (System.Char.IsHighSurrogate(testStr[strIndex - 1])) { strIndex++; continue; } } if (next.Matches(strIndex + 1, testString, matchResult) >= 0) { return(strIndex); } strIndex++; } return(-1); } return(base.Find(strIndex, testString, matchResult)); }
public override int FindBack(int strIndex, int lastIndex, String testString, MatchResultImpl matchResult) { if (testString is String) { String testStr = (String)testString; int strLength = matchResult.GetRightBound(); while (lastIndex >= strIndex) { lastIndex = testStr.LastIndexOf(high, lastIndex); if (lastIndex < 0 || lastIndex < strIndex) { return(-1); } if (lastIndex + 1 < strLength) { /* * we consider high surrogate followed by * low surrogate as a codepoint */ if (System.Char.IsLowSurrogate(testStr[lastIndex + 1])) { lastIndex--; continue; } } if (next.Matches(lastIndex + 1, testString, matchResult) >= 0) { return(lastIndex); } lastIndex--; } return(-1); } return(base.FindBack(strIndex, lastIndex, testString, matchResult)); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { int shift = 0; do { shift = next.Matches(stringIndex, testString, matchResult); if (shift >= 0) { return(shift); } if (stringIndex + leaf.CharCount() <= matchResult.GetRightBound()) { shift = leaf.Accepts(stringIndex, testString); stringIndex += shift; } } while (shift >= 1); return(-1); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { String group = GetString(matchResult); if (group == null || (stringIndex + group.Length) > matchResult.GetRightBound()) { return(-1); } for (int i = 0; i < group.Length; i++) { if (Char.ToLower(Char.ToUpper(group[i])) != Char.ToLower(Char.ToUpper(testString[stringIndex + i]))) { return(-1); } } matchResult.SetConsumed(consCounter, group.Length); return(next.Matches(stringIndex + group.Length, testString, matchResult)); }
public override int Find(int strIndex, String testString, MatchResultImpl matchResult) { int strLength = matchResult.GetRightBound(); while (strIndex <= strLength) { strIndex = IndexOf(testString, strIndex, strLength); if (strIndex < 0) { return(-1); } if (next.Matches(strIndex + charCount, testString, matchResult) >= 0) { return(strIndex); } strIndex++; } return(-1); }
public override int Matches(int stringIndex, String testString, MatchResultImpl matchResult) { String group = GetString(matchResult); if (group == null || (stringIndex + group.Length) > matchResult.GetRightBound()) { return(-1); } for (int i = 0; i < group.Length; i++) { if (group[i] != testString[stringIndex + i] && Pattern.GetSupplement(group[i]) != testString[stringIndex + i]) { return(-1); } } matchResult.SetConsumed(consCounter, group.Length); return(next.Matches(stringIndex + group.Length, testString, matchResult)); }