public void CompilePattern(SearchOptions options)
{
RegexOptions regexOptions = RegexOptions.Compiled;
if (options.IgnoreCase) {
regexOptions |= RegexOptions.IgnoreCase;
}
regex = new Regex(options.SearchPattern, regexOptions);
}
public void CompilePattern(SearchOptions options)
{
if (searchPattern != (options.IgnoreCase ? options.SearchPattern.ToUpper() : options.SearchPattern)) {
searchPattern = options.IgnoreCase ? options.SearchPattern.ToUpper() : options.SearchPattern;
overlap = new int[searchPattern.Length + 1];
Preprocessing();
}
}
public ISearchResult FindNext(ITextIterator textIterator, SearchOptions options, bool reverseSearch)
{
if (reverseSearch)
throw new NotSupportedException ();
int charCount = InternalFindNext(textIterator, options);
return charCount != -1 ? new DefaultSearchResult (textIterator, charCount) : null;
}
public ISearchResult FindNext(ITextIterator textIterator, SearchOptions options, bool reverseSearch)
{
if (reverseSearch)
throw new NotSupportedException ();
int pos = textIterator.Position;
int offset = InternalFindNext(textIterator, options);
if (offset == -1) return null;
if (textIterator.GetCharRelative (searchPattern.Length) == char.MinValue) {
if (pos != offset)
return FindNext(textIterator, options, false);
else
return null;
}
return new DefaultSearchResult (textIterator, searchPattern.Length);
}
public ISearchResult FindNext(ITextIterator textIterator, SearchOptions options, bool reverseSearch)
{
if (reverseSearch)
throw new NotSupportedException ();
if (!textIterator.MoveAhead(1)) return null;
if (regex == null) return null;
int pos = textIterator.Position;
string document = textIterator.ReadToEnd ();
textIterator.Position = pos;
Match m = regex.Match (document, 0);
if (m == null || m.Index <= 0 || m.Length <= 0) {
return null;
} else {
if (textIterator.MoveAhead (m.Index)) {
return new DefaultSearchResult (textIterator, m.Length);
} else {
return null;
}
}
}
int InternalFindNext(ITextIterator textIterator, SearchOptions options)
{
int j = 0;
if (!textIterator.MoveAhead(1)) {
return -1;
}
while (true) { // until pattern found or Iterator finished
while (j >= 0 && searchPattern[j] != (options.IgnoreCase ? Char.ToUpper(textIterator.GetCharRelative(j)) : textIterator.GetCharRelative(j))) {
if (!textIterator.MoveAhead(j - overlap[j])) {
return -1;
}
j = overlap[j];
}
if (++j >= searchPattern.Length) {
if ((!options.SearchWholeWordOnly || SearchReplaceUtilities.IsWholeWordAt(textIterator, searchPattern.Length))) {
return textIterator.Position;
}
if (!textIterator.MoveAhead(j - overlap[j])) {
return -1;
}
j = overlap[j];
}
}
}
public bool SupportsReverseSearch (ITextIterator textIterator, SearchOptions options)
{
return textIterator.SupportsSearch (options, true);
}
public bool SupportsReverseSearch(ITextIterator textIterator, SearchOptions options)
{
return false;
}
public ISearchResult Find(SearchOptions options, bool reverse)
{
// insanity check
Debug.Assert(searchStrategy != null);
Debug.Assert(documentIterator != null);
Debug.Assert(options != null);
while (!cancelled)
{
if (info != null && textIterator != null && documentIterator.CurrentFileName != null) {
if (info.FileName != documentIterator.CurrentFileName || lastWasReverse != reverse) {
// create new iterator, if document changed or search direction has changed.
info = documentIterator.Current;
textIterator = info.GetTextIterator ();
reverseSearchMap = null;
lastResultPos = -1;
if (reverse)
textIterator.MoveToEnd ();
}
ISearchResult result;
if (!reverse)
result = searchStrategy.FindNext (textIterator, options, false);
else {
if (searchStrategy.SupportsReverseSearch (textIterator, options)) {
result = searchStrategy.FindNext (textIterator, options, true);
}
else {
if (reverseSearchMap == null) {
reverseSearchMap = new SearchMap ();
reverseSearchMap.Build (searchStrategy, textIterator, options);
}
if (lastResultPos == -1)
lastResultPos = textIterator.Position;
result = reverseSearchMap.GetPreviousMatch (lastResultPos);
if (result != null)
textIterator.Position = result.Position;
}
}
if (result != null) {
matches++;
lastResultPos = result.Position;
lastWasReverse = reverse;
return result;
}
}
if (textIterator != null) textIterator.Close ();
// not found or first start -> move forward to the next document
bool more = !reverse ? documentIterator.MoveForward () : documentIterator.MoveBackward ();
if (more) {
searchedFiles++;
info = documentIterator.Current;
textIterator = info.GetTextIterator ();
reverseSearchMap = null;
lastResultPos = -1;
if (reverse)
textIterator.MoveToEnd ();
}
else
cancelled = true;
lastWasReverse = reverse;
}
cancelled = false;
return null;
}
int InternalFindNext(ITextIterator textIterator, SearchOptions options)
{
int[] compareIndex = new int [searchPattern.Length];
int[] startPositions = new int [searchPattern.Length];
int maxPoss = 0;
bool ignoreCase = options.IgnoreCase;
bool searchWord = options.SearchWholeWordOnly;
CultureInfo cinfo = CultureInfo.InvariantCulture;
int patternLength = searchPattern.Length;
bool wasWordStart = true;
char first = searchPattern[0];
while (textIterator.MoveAhead(1))
{
char c = textIterator.Current;
if (ignoreCase) c = Char.ToUpper (c, cinfo);
int freePos = -1;
for (int n=0; n<maxPoss; n++)
{
int pos = compareIndex[n];
if (pos != 0) {
if (searchPattern[pos] == c) {
pos++;
if (pos == patternLength) {
if (searchWord) {
int curp = textIterator.Position;
bool endw = !textIterator.MoveAhead (1);
endw = endw || SearchReplaceUtilities.IsWordSeparator (textIterator.Current);
textIterator.Position = curp;
if (endw) return startPositions[n];
}
else
return startPositions[n];
}
else {
compareIndex[n] = pos;
continue;
}
}
compareIndex[n] = 0;
if (n == maxPoss-1)
maxPoss = n;
}
if (freePos == -1)
freePos = pos;
}
if (c == first && (!searchWord || wasWordStart)) {
if (patternLength == 1)
return textIterator.Position;
if (freePos == -1) {
freePos = maxPoss;
maxPoss++;
}
compareIndex [freePos] = 1;
startPositions [freePos] = textIterator.Position;
}
wasWordStart = SearchReplaceUtilities.IsWordSeparator (c);
}
return -1;
}
public ISearchResult FindPrevious(SearchOptions options)
{
return Find (options, true);
}
public void Build(ISearchStrategy strategy, ITextIterator it, SearchOptions options)
{
int startPos = it.Position;
it.Reset ();
ISearchResult res = strategy.FindNext (it, options, false);
while (res != null) {
matches.Add (res);
res = strategy.FindNext (it, options, false);
}
it.Position = startPos;
}
public void CompilePattern(SearchOptions options)
{
CompilePattern(options.SearchPattern, options.IgnoreCase);
}
public bool SearchNext(string text, SearchOptions options, bool reverse)
{
throw new NotSupportedException ();
}
public override bool SearchNext(string text, SearchOptions options, bool reverse)
{
// Make sure the backward search finds the first match when that match is just
// at the left of the cursor. Position needs to be incremented in this case because it will be
// at the last char of the match, and BackwardSearch don't return results that include
// the initial search position.
if (reverse && Position < BufferLength && initialBackwardsPosition) {
Position++;
initialBackwardsPosition = false;
}
TextIter it = Buffer.GetIterAtOffset (DocumentOffset);
int limitOffset = EndOffset;
if (reverse)
limitOffset = (limitOffset + text.Length - 1) % BufferLength;
else
limitOffset = (limitOffset + 1) % BufferLength;
// Use special search flags that work for both the old and new API
// of gtksourceview (the enum values where changed in the API).
// See bug #75770
SourceSearchFlags flags = options.IgnoreCase ? (SourceSearchFlags)7 : (SourceSearchFlags)1;
Gtk.TextIter matchStart, matchEnd;
bool res;
Gtk.TextIter limit;
if (reverse) {
if (DocumentOffset <= EndOffset)
limit = Buffer.StartIter;
else
limit = Buffer.GetIterAtOffset (limitOffset);
} else {
if (DocumentOffset >= EndOffset)
limit = Buffer.EndIter;
else
limit = Buffer.GetIterAtOffset (limitOffset);
}
// machEnd is the position of the last matched char + 1
// When searching forward, the limit check is: matchEnd < limit
// When searching backwards, the limit check is: matchEnd > limit
res = Find (reverse, it, text, flags, out matchStart, out matchEnd, limit);
if (!res) {
// Not found in the first half of the document, try not the other half
if (reverse && DocumentOffset <= EndOffset) {
it = Buffer.EndIter;
limit = Buffer.GetIterAtOffset (limitOffset);
res = Find (true, it, text, flags, out matchStart, out matchEnd, limit);
} else if (!reverse && DocumentOffset >= EndOffset) {
it = Buffer.StartIter;
limit = Buffer.GetIterAtOffset (limitOffset);
res = Find (false, it, text, flags, out matchStart, out matchEnd, limit);
}
}
if (!res) return false;
DocumentOffset = matchStart.Offset;
return true;
}
public void CompilePattern(SearchOptions options)
{
searchPattern = options.IgnoreCase ? options.SearchPattern.ToUpper() : options.SearchPattern;
}
public ISearchResult FindNext(ITextIterator textIterator, SearchOptions options, bool reverseSearch)
{
if (textIterator.SupportsSearch (options, reverseSearch)) {
if (textIterator.SearchNext (searchPattern, options, reverseSearch)) {
DefaultSearchResult sr = new DefaultSearchResult (textIterator, searchPattern.Length);
if (!reverseSearch)
textIterator.MoveAhead (searchPattern.Length);
return sr;
} else
return null;
}
if (reverseSearch)
throw new NotSupportedException ();
int offset = InternalFindNext(textIterator, options);
if (offset >= 0) {
int pos = textIterator.Position;
textIterator.Position = offset;
DefaultSearchResult sr = new DefaultSearchResult (textIterator, searchPattern.Length);
textIterator.Position = pos;
return sr;
} else
return null;
}
public override bool SupportsSearch(SearchOptions options, bool reverse)
{
return !options.SearchWholeWordOnly;
}
public ISearchResult FindNext(SearchOptions options)
{
return Find (options, false);
}
public bool SupportsSearch(SearchOptions options, bool reverse)
{
return false;
}
int InternalFindNext(ITextIterator textIterator, SearchOptions options)
{
while (textIterator.MoveAhead(1))
{
int pos = textIterator.Position;
int charCount = Match (textIterator, options.IgnoreCase, 0);
textIterator.Position = pos;
if (charCount != -1) {
if (!options.SearchWholeWordOnly || SearchReplaceUtilities.IsWholeWordAt (textIterator, charCount))
return charCount;
}
}
return -1;
}