/// <summary> /// Replaces all occurrences of the regex in the string with the /// replacement pattern. /// /// Note that the special case of no matches is handled on its own: /// with no matches, the input string is returned unchanged. /// The right-to-left case is split out because StringBuilder /// doesn't handle right-to-left string building directly very well. /// </summary> public string Replace(Regex regex, string input, int count, int startat) { if (count < -1) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.CountTooSmall); } if ((uint)startat > (uint)input.Length) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startat, ExceptionResource.BeginIndexNotNegative); } if (count == 0) { return(input); } var state = (replacement : this, segments : SegmentStringBuilder.Create(), inputMemory : input.AsMemory(), prevat : 0, count); if (!regex.RightToLeft) { regex.Run(input, startat, ref state, (ref (RegexReplacement thisRef, SegmentStringBuilder segments, ReadOnlyMemory <char> inputMemory, int prevat, int count)state, Match match) => { state.segments.Add(state.inputMemory.Slice(state.prevat, match.Index - state.prevat)); state.prevat = match.Index + match.Length; state.thisRef.ReplacementImpl(ref state.segments, match); return(--state.count != 0); }, reuseMatchObject: true);
/// <summary> /// Replaces all occurrences of the regex in the string with the /// replacement evaluator. /// /// Note that the special case of no matches is handled on its own: /// with no matches, the input string is returned unchanged. /// The right-to-left case is split out because StringBuilder /// doesn't handle right-to-left string building directly very well. /// </summary> private static string Replace(MatchEvaluator evaluator, Regex regex, string input, int count, int startat) { if (evaluator is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.evaluator); } if (count < -1) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.CountTooSmall); } if ((uint)startat > (uint)input.Length) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startat, ExceptionResource.BeginIndexNotNegative); } if (count == 0) { return(input); } var state = (segments : SegmentStringBuilder.Create(), evaluator, prevat : 0, input, count); if (!regex.RightToLeft) { regex.Run(input, startat, ref state, static (ref (SegmentStringBuilder segments, MatchEvaluator evaluator, int prevat, string input, int count)state, Match match) => { state.segments.Add(state.input.AsMemory(state.prevat, match.Index - state.prevat)); state.prevat = match.Index + match.Length; state.segments.Add(state.evaluator(match).AsMemory()); return(--state.count != 0); }, reuseMatchObject: false);
private Match?GetMatch(int i) { Debug.Assert(i >= 0, "i cannot be negative."); if (_matches.Count > i) { return(_matches[i]); } if (_done) { return(null); } Match match; do { match = _regex.Run(false, _prevlen, _input, 0, _input.Length, _startat) !; if (!match.Success) { _done = true; return(null); } _matches.Add(match); _prevlen = match.Length; _startat = match._textpos; } while (_matches.Count <= i); return(match); }
/* * Returns the next match */ /// <devdoc> /// <para>Returns a new Match with the results for the next match, starting /// at the position at which the last match ended (at the character beyond the last /// matched character).</para> /// </devdoc> public Match NextMatch() { if (_regex == null) { return(this); } return(_regex.Run(false, _length, _text, _textbeg, _textend - _textbeg, _textpos)); }
/// <summary> /// Does a split. In the right-to-left case we reorder the /// array to be forwards. /// </summary> private static string[] Split(Regex regex, string input, int count, int startat) { if (count < 0) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.CountTooSmall); } if ((uint)startat > (uint)input.Length) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startat, ExceptionResource.BeginIndexNotNegative); } if (count == 1) { return(new[] { input }); } count--; var state = (results : new List <string>(), prevat : 0, input, count); if (!regex.RightToLeft) { regex.Run(input, startat, ref state, (ref (List <string> results, int prevat, string input, int count)state, Match match) => { state.results.Add(state.input.Substring(state.prevat, match.Index - state.prevat)); state.prevat = match.Index + match.Length; // add all matched capture groups to the list. for (int i = 1; i < match.Groups.Count; i++) { if (match.IsMatched(i)) { state.results.Add(match.Groups[i].ToString()); } } return(--state.count != 0); });
internal Match GetMatch(int i) { if (i < 0) { return(null); } if (_matches.Count > i) { return((Match)_matches[i]); } if (_done) { return(null); } Match match; do { match = _regex.Run(false, _prevlen, _input, _beginning, _length, _startat); if (!match.Success) { _done = true; return(null); } _matches.Add(match); _prevlen = match._length; _startat = match._textpos; } while (_matches.Count <= i); return(match); }