e93/e93/search.c

//	Search/replace functions
//	Copyright (C) 2000 Core Technologies.

// This file is part of e93.
//
// e93 is free software; you can redistribute it and/or modify
// it under the terms of the e93 LICENSE AGREEMENT.
//
// e93 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// e93 LICENSE AGREEMENT for more details.
//
// You should have received a copy of the e93 LICENSE AGREEMENT
// along with e93; see the file "LICENSE.TXT".

#include	"includes.h"

enum
{
	MATCHED_NOTHING,
};

static const char *errorDescriptions[]=
{
	"Find matched nothing -- could not continue",
};

typedef struct
{
	bool
		ignoreCase;					// true if we should ignore case, false if not
	TEXT_UNIVERSE
		*searchForText;				// pointer to the search for text universe
	TEXT_UNIVERSE
		*replaceWithText;			// pointer to the replace with text universe
	COMPILED_EXPRESSION
		*expression;				// if type is regex, this points to the compiled expression, otherwise it is NULL
	char
		*procedure;					// if non NULL, this points to a procedure to use instead of the replace text
} SEARCH_RECORD;

bool LiteralMatch(CHUNK_HEADER *chunk,UINT32 offset,CHUNK_HEADER *forTextChunk,UINT32 forTextOffset,UINT32 numToSearch,CHUNK_HEADER **endChunk,UINT32 *endOffset)
// See if the text at chunk/offset matches the text in forTextChunk/forTextOffset
// if there is a match, return true with endChunk, and endOffset filled in to point to one
// past the last place looked in inText
// NOTE: there must be at least numToSearch bytes remaining in both chunk/offset and forTextChunk/forTextOffset
{
	UINT8
		*inPointer,
		*forPointer;
	UINT32
		inTotal,
		forTotal;

	if(numToSearch)
	{
		if(forTextChunk->data[forTextOffset]==chunk->data[offset])			// for speed, make initial check to see if this can match
		{
			inTotal=chunk->totalBytes;										// cache total bytes, and pointer
			inPointer=&(chunk->data[offset+1]);
			forTotal=forTextChunk->totalBytes;
			forPointer=&(forTextChunk->data[forTextOffset+1]);
			if((++offset)>=inTotal)											// move past bytes just checked
			{
				offset=0;
				if((chunk=chunk->nextHeader))
				{
					inTotal=chunk->totalBytes;
					inPointer=chunk->data;
				}
			}
			if((++forTextOffset)>=forTotal)
			{
				forTextOffset=0;
				if((forTextChunk=forTextChunk->nextHeader))
				{
					forTotal=forTextChunk->totalBytes;
					forPointer=forTextChunk->data;
				}
			}
			numToSearch--;
			while(numToSearch&&(*inPointer++==*forPointer++))				// go until mismatch, or until we run out of for data
			{
				if((++offset)>=inTotal)
				{
					offset=0;
					if((chunk=chunk->nextHeader))
					{
						inTotal=chunk->totalBytes;
						inPointer=chunk->data;
					}
				}
				if((++forTextOffset)>=forTotal)
				{
					forTextOffset=0;
					if((forTextChunk=forTextChunk->nextHeader))
					{
						forTotal=forTextChunk->totalBytes;
						forPointer=forTextChunk->data;
					}
				}
				numToSearch--;
			}
			if(!numToSearch)
			{
				*endChunk=chunk;
				*endOffset=offset;
				return(true);
			}
		}
	}
	else
	{
		*endChunk=chunk;
		*endOffset=offset;
		return(true);
	}
	return(false);
}

bool LiteralMatchTT(CHUNK_HEADER *chunk,UINT32 offset,CHUNK_HEADER *forTextChunk,UINT32 forTextOffset,UINT32 numToSearch,const UINT8 *translateTable,CHUNK_HEADER **endChunk,UINT32 *endOffset)
// See if the text at chunk/offset matches the text in forTextChunk/forTextOffset
// if there is a match, return true with endChunk, and endOffset filled in to point to one
// past the last place looked in inText
// NOTE: there must be at least numToSearch bytes remaining in both chunk/offset and forTextChunk/forTextOffset
// NOTE: translate characters when matching
{
	UINT8
		*inPointer,
		*forPointer;
	UINT32
		inTotal,
		forTotal;

	if(numToSearch)
	{
		if(translateTable[forTextChunk->data[forTextOffset]]==translateTable[chunk->data[offset]])		// for speed, make initial check to see if this can match
		{
			inTotal=chunk->totalBytes;										// cache total bytes, and pointer
			inPointer=&(chunk->data[offset+1]);
			forTotal=forTextChunk->totalBytes;
			forPointer=&(forTextChunk->data[forTextOffset+1]);
			if((++offset)>=inTotal)											// move past bytes just checked
			{
				offset=0;
				if((chunk=chunk->nextHeader))
				{
					inTotal=chunk->totalBytes;
					inPointer=chunk->data;
				}
			}
			if((++forTextOffset)>=forTotal)
			{
				forTextOffset=0;
				if((forTextChunk=forTextChunk->nextHeader))
				{
					forTotal=forTextChunk->totalBytes;
					forPointer=forTextChunk->data;
				}
			}
			numToSearch--;
			while(numToSearch&&(translateTable[*inPointer++]==translateTable[*forPointer++]))	// go until mismatch, or until we run out of for data
			{
				if((++offset)>=inTotal)
				{
					offset=0;
					if((chunk=chunk->nextHeader))
					{
						inTotal=chunk->totalBytes;
						inPointer=chunk->data;
					}
				}
				if((++forTextOffset)>=forTotal)
				{
					forTextOffset=0;
					if((forTextChunk=forTextChunk->nextHeader))
					{
						forTotal=forTextChunk->totalBytes;
						forPointer=forTextChunk->data;
					}
				}
				numToSearch--;
			}
			if(!numToSearch)
			{
				*endChunk=chunk;
				*endOffset=offset;
				return(true);
			}
		}
	}
	else
	{
		*endChunk=chunk;
		*endOffset=offset;
		return(true);
	}
	return(false);
}

bool SearchForwardLiteral(CHUNK_HEADER *chunk,UINT32 offset,CHUNK_HEADER *forTextChunk,UINT32 forTextOffset,UINT32 forTextLength,UINT32 numToSearch,bool ignoreCase,bool *foundMatch,UINT32 *matchOffset,UINT32 *numMatched,CHUNK_HEADER **startChunk,UINT32 *startOffset,CHUNK_HEADER **endChunk,UINT32 *endOffset,ABORT_TEST_FUNCTION *abortFunction)
// Search forward from chunk/offset for forTextChunk/forTextOffset
// look at up to numToSearch bytes of source data
// if a match is located, return *foundMatch=true, with matchOffset set to the number
// of bytes in from chunk/offset where the match was found, and
// startChunk/startOffset set to the start of the match, and
// endChunk/endOffset set to one past the last byte of source that was matched
// If there is a failure, SetError, and return false.
{
	UINT32
		numSearched;
	bool
		fail;

	fail=false;
	numSearched=0;
	*foundMatch=false;
	if(ignoreCase)
	{
		while(!fail&&!(*foundMatch)&&((forTextLength+numSearched)<=numToSearch))
		{
			if(LiteralMatchTT(chunk,offset,forTextChunk,forTextOffset,forTextLength,upperCaseTable,endChunk,endOffset))
			{
				*matchOffset=numSearched;
				*startChunk=chunk;
				*startOffset=offset;
				*foundMatch=true;
				*numMatched=forTextLength;
			}
			else
			{
				if((++offset)>=chunk->totalBytes)			// move forward in the input
				{
					offset=0;
					chunk=chunk->nextHeader;
					if(abortFunction&&abortFunction())
					{
						SetError("Search Aborted");
						fail=true;
					}
				}
				numSearched++;
			}
		}
	}
	else
	{
		while(!fail&&!(*foundMatch)&&((forTextLength+numSearched)<=numToSearch))
		{
			if(LiteralMatch(chunk,offset,forTextChunk,forTextOffset,forTextLength,endChunk,endOffset))
			{
				*matchOffset=numSearched;
				*startChunk=chunk;
				*startOffset=offset;
				*foundMatch=true;
				*numMatched=forTextLength;
			}
			else
			{
				if((++offset)>=chunk->totalBytes)			// move forward in the input
				{
					offset=0;
					chunk=chunk->nextHeader;
					if(abortFunction&&abortFunction())
					{
						SetError("Search Aborted");
						fail=true;
					}
				}
				numSearched++;
			}
		}
	}
	return(!fail);
}

bool SearchBackwardLiteral(CHUNK_HEADER *chunk,UINT32 offset,CHUNK_HEADER *forTextChunk,UINT32 forTextOffset,UINT32 forTextLength,UINT32 numToSearch,bool ignoreCase,bool *foundMatch,UINT32 *matchOffset,UINT32 *numMatched,CHUNK_HEADER **startChunk,UINT32 *startOffset,CHUNK_HEADER **endChunk,UINT32 *endOffset,ABORT_TEST_FUNCTION *abortFunction)
// Search backward from chunk/offset for forTextChunk/forTextOffset
// look at up to numToSearch bytes of source data
// if a match is located, return *foundMatch=true, with matchOffset set to the number
// of bytes back from chunk/offset where the match was found, and
// startChunk/startOffset set to chunk/offset at the point of the match
// endChunk/endOffset set to position just after the last match
// If there is a failure, SetError, and return false.
{
	UINT32
		numSearched;
	UINT32
		amountToBackUp;
	bool
		fail;

	fail=false;
	numSearched=0;
	*foundMatch=false;
	if(forTextLength<=numToSearch)
	{
		amountToBackUp=forTextLength;				// back up in the source by forTextLength
		while(amountToBackUp)
		{
			if(offset>=amountToBackUp)
			{
				offset-=amountToBackUp;
				amountToBackUp=0;
			}
			else
			{
				amountToBackUp-=(offset+1);
				if((chunk=chunk->previousHeader))
				{
					offset=chunk->totalBytes-1;
				}
			}
		}
		numSearched=forTextLength;
		if(ignoreCase)
		{
			while(!fail&&!(*foundMatch)&&(numSearched<=numToSearch))
			{
				if(LiteralMatchTT(chunk,offset,forTextChunk,forTextOffset,forTextLength,upperCaseTable,endChunk,endOffset))
				{
					*matchOffset=numSearched;
					*startChunk=chunk;
					*startOffset=offset;
					*foundMatch=true;
					*numMatched=forTextLength;
				}
				else
				{
					if(!offset)					// move backward in the input
					{
						if((chunk=chunk->previousHeader))
						{
							offset=chunk->totalBytes;
						}
						if(abortFunction&&abortFunction())
						{
							SetError("Search Aborted");
							fail=true;
						}
					}
					offset--;
					numSearched++;
				}
			}
		}
		else
		{
			while(!fail&&!(*foundMatch)&&(numSearched<=numToSearch))
			{
				if(LiteralMatch(chunk,offset,forTextChunk,forTextOffset,forTextLength,endChunk,endOffset))
				{
					*matchOffset=numSearched;
					*startChunk=chunk;
					*startOffset=offset;
					*foundMatch=true;
					*numMatched=forTextLength;
				}
				else
				{
					if(!offset)					// move backward in the input
					{
						if((chunk=chunk->previousHeader))
						{
							offset=chunk->totalBytes;
						}
						if(abortFunction&&abortFunction())
						{
							SetError("Search Aborted");
							fail=true;
						}
					}
					offset--;
					numSearched++;
				}
			}
		}
	}
	return(!fail);
}

static bool SearchForward(CHUNK_HEADER *chunk,UINT32 offset,SEARCH_RECORD *searchRecord,bool leftEdge,bool rightEdge,UINT32 numToSearch,bool *foundMatch,UINT32 *matchOffset,UINT32 *numMatched,CHUNK_HEADER **startChunk,UINT32 *startOffset,CHUNK_HEADER **endChunk,UINT32 *endOffset,ABORT_TEST_FUNCTION *abortFunction)
// Search forward given searchRecord
// return foundMatch true if a match was found
// return false if there was some sort of hard failure
// if a match is found, startChunk/startOffset point to the start of the match
// matchOffset is the number of bytes searched
// endChunk/endOffset point to one past the end of the matched text
{
	bool
		fail;

	fail=false;
	if(searchRecord->expression)
	{
		fail=!SearchForwardRE(chunk,offset,searchRecord->expression,leftEdge,rightEdge,numToSearch,numToSearch,searchRecord->ignoreCase,foundMatch,matchOffset,numMatched,startChunk,startOffset,endChunk,endOffset,abortFunction);
	}
	else
	{
		fail=!SearchForwardLiteral(chunk,offset,searchRecord->searchForText->firstChunkHeader,0,searchRecord->searchForText->totalBytes,numToSearch,searchRecord->ignoreCase,foundMatch,matchOffset,numMatched,startChunk,startOffset,endChunk,endOffset,abortFunction);
	}
	return(!fail);
}

static bool SearchBackward(CHUNK_HEADER *chunk,UINT32 offset,SEARCH_RECORD *searchRecord,bool leftEdge,bool rightEdge,UINT32 numToSearch,bool *foundMatch,UINT32 *matchOffset,UINT32 *numMatched,CHUNK_HEADER **startChunk,UINT32 *startOffset,CHUNK_HEADER **endChunk,UINT32 *endOffset,ABORT_TEST_FUNCTION *abortFunction)
// Search backward given searchRecord
// return foundMatch true if a match was found
// return false if there was some sort of hard failure
// if a match is found, startChunk/startOffset point to the start of the match
// matchOffset is the number of bytes searched
// endChunk/endOffset point to one past the end of the matched text
{
	bool
		fail;

	fail=false;
	if(searchRecord->expression)
	{
		fail=!SearchBackwardRE(chunk,offset,searchRecord->expression,leftEdge,rightEdge,numToSearch,numToSearch,searchRecord->ignoreCase,foundMatch,matchOffset,numMatched,startChunk,startOffset,endChunk,endOffset,abortFunction);
	}
	else
	{
		fail=!SearchBackwardLiteral(chunk,offset,searchRecord->searchForText->firstChunkHeader,0,searchRecord->searchForText->totalBytes,numToSearch,searchRecord->ignoreCase,foundMatch,matchOffset,numMatched,startChunk,startOffset,endChunk,endOffset,abortFunction);
	}
	return(!fail);
}

static void DisposeSearchRecord(SEARCH_RECORD *searchRecord)
// Get rid of searchRecord, and anything allocated under it
{
	if(searchRecord->expression)		// if there is a selection expression, get rid of it
	{
		REFree(searchRecord->expression);
	}
	if(searchRecord->procedure)			// if there is a procedure, get rid of it
	{
		MDisposePtr(searchRecord->procedure);
	}
	MDisposePtr(searchRecord);
}

static SEARCH_RECORD *CreateSearchRecord(TEXT_UNIVERSE *searchForText,TEXT_UNIVERSE *replaceWithText,bool selectionExpr,bool ignoreCase,bool replaceProc)
// Create a search record that describes the search, and remembers some stuff about it
// if there is a problem, SetError, and return NULL
{
	SEARCH_RECORD
		*searchRecord;
	COMPILED_EXPRESSION
		*compiledExpression;
	UINT8
		*expressionText;
	CHUNK_HEADER
		*chunk;
	UINT32
		offset;
	bool
		fail;

	fail=false;
	if((searchRecord=(SEARCH_RECORD *)MNewPtr(sizeof(SEARCH_RECORD))))
	{
		searchRecord->searchForText=searchForText;			// remember these for later
		searchRecord->replaceWithText=replaceWithText;
		searchRecord->ignoreCase=ignoreCase;
		searchRecord->expression=NULL;						// assume no selection expression yet
		searchRecord->procedure=NULL;						// assume no procedure yet
		if(replaceProc)										// if treating replace as procedure, we need to grab the text from the replace buffer, and place it into memory
		{
			if((searchRecord->procedure=(char *)MNewPtr(replaceWithText->totalBytes+1)))	// make a buffer
			{
				fail=!ExtractUniverseText(replaceWithText,replaceWithText->firstChunkHeader,0,(UINT8 *)searchRecord->procedure,replaceWithText->totalBytes,&chunk,&offset);
				searchRecord->procedure[replaceWithText->totalBytes]='\0';				// terminate the string
			}
			else
			{
				fail=true;
			}
		}
		if(!fail)
		{
			if(selectionExpr)
			{
				if((expressionText=(UINT8 *)MNewPtr(searchForText->totalBytes)))	// make a buffer to temporarily hold the expression text
				{
					if(ExtractUniverseText(searchForText,searchForText->firstChunkHeader,0,expressionText,searchForText->totalBytes,&chunk,&offset))
					{
						if((compiledExpression=RECompile(&(expressionText[0]),searchForText->totalBytes,ignoreCase?upperCaseTable:NULL)))
						{
							searchRecord->expression=compiledExpression;
							MDisposePtr(expressionText);				// get rid of temporary buffer
							return(searchRecord);
						}
					}
					MDisposePtr(expressionText);
				}
			}
			else
			{
				return(searchRecord);
			}
		}
		if(searchRecord->procedure)			// if there is a procedure, get rid of it
		{
			MDisposePtr(searchRecord->procedure);
		}
		MDisposePtr(searchRecord);
	}
	return(NULL);
}

bool EditorFind(EDITOR_BUFFER *buffer,SELECTION_UNIVERSE *selectionUniverse,TEXT_UNIVERSE *searchForText,bool backward,bool wrapAround,bool selectionExpr,bool ignoreCase,bool *foundMatch,SELECTION_UNIVERSE *resultSelectionUniverse,ABORT_TEST_FUNCTION *abortFunction)
// Find searchForText in buffer, starting at the cursor position of selectionUniverse, or the end of
// the current selection
// If anything is found, return it in resultSelectionUniverse, else, do not modify resultSelectionUniverse.
// foundMatch reflects the status of the search.
// if there is some problem during the search, SetError, return false
// NOTE: resultSelectionUniverse must be different from selectionUniverse
{
	CHUNK_HEADER
		*inChunk,
		*startChunk,
		*endChunk;
	UINT32
		inOffset,
		startOffset,
		endOffset;
	SEARCH_RECORD
		*searchRecord;
	UINT32
		startPosition,
		endPosition;
	UINT32
		locatedPosition,
		locatedLength;
	TEXT_UNIVERSE
		*searchInText;
	bool
		fail;

	fail=*foundMatch=false;
	if((searchRecord=CreateSearchRecord(searchForText,NULL,selectionExpr,ignoreCase,false)))
	{
		ShowBusy();
		searchInText=buffer->textUniverse;

		GetSelectionEndPositions(selectionUniverse,&startPosition,&endPosition);		// find ends of old selection, or cursor position
		if(!backward)
		{
			PositionToChunkPosition(searchInText,endPosition,&inChunk,&inOffset);		// locate place to start the search
			if(SearchForward(inChunk,inOffset,searchRecord,endPosition==0,true,searchInText->totalBytes-endPosition,foundMatch,&locatedPosition,&locatedLength,&startChunk,&startOffset,&endChunk,&endOffset,abortFunction))
			{
				locatedPosition+=endPosition;											// make located position absolute
				if((!(*foundMatch))&&wrapAround)
				{
					if(!SearchForward(searchInText->firstChunkHeader,0,searchRecord,true,startPosition==searchInText->totalBytes,startPosition,foundMatch,&locatedPosition,&locatedLength,&startChunk,&startOffset,&endChunk,&endOffset,abortFunction))
					{
						fail=true;
					}
				}
			}
			else
			{
				fail=true;
			}
		}
		else
		{
			PositionToChunkPositionPastEnd(searchInText,startPosition,&inChunk,&inOffset);	// locate place to start the search
			if(SearchBackward(inChunk,inOffset,searchRecord,true,startPosition==searchInText->totalBytes,startPosition,foundMatch,&locatedPosition,&locatedLength,&startChunk,&startOffset,&endChunk,&endOffset,abortFunction))
			{
				locatedPosition=startPosition-locatedPosition;							// make located position absolute
				if((!(*foundMatch))&&wrapAround)
				{
					PositionToChunkPositionPastEnd(searchInText,searchInText->totalBytes,&inChunk,&inOffset);	// locate place to start the search
					if(SearchBackward(inChunk,inOffset,searchRecord,endPosition==0,true,searchInText->totalBytes-endPosition,foundMatch,&locatedPosition,&locatedLength,&startChunk,&startOffset,&endChunk,&endOffset,abortFunction))
					{
						locatedPosition=searchInText->totalBytes-locatedPosition;
					}
					else
					{
						fail=true;
					}
				}
			}
			else
			{
				fail=true;
			}
		}
		if((!fail)&&(*foundMatch))
		{

			DeleteAllSelections(resultSelectionUniverse);	// remove all old selections
			if(SetSelectionRange(resultSelectionUniverse,locatedPosition,locatedLength))
			{
				SetSelectionCursorPosition(resultSelectionUniverse,locatedPosition);
			}
			else
			{
				fail=true;
			}
		}
		DisposeSearchRecord(searchRecord);
		ShowNotBusy();
	}
	else
	{
		fail=true;
	}
	return(!fail);
}

static bool FindAllForward(TEXT_UNIVERSE *searchInText,bool leftEdge,bool rightEdge,UINT32 lowPosition,UINT32 highPosition,SEARCH_RECORD *searchRecord,SELECTION_UNIVERSE *selectionUniverse,bool *foundMatch,UINT32 *firstMatchPosition,ABORT_TEST_FUNCTION *abortFunction)
// Find all occurrences of searchRecord between lowPosition, and highPosition, adding the selections
// to selectionUniverse
// if there is a problem, SetError and return false
// if a matches were found, return true in foundMatch, and the position of the first match found
// in firstMatchPosition
// NOTE: even if false is returned, foundMatch, firstMatchPosition, and selectionUniverse are
// valid
{
	bool
		fail;
	CHUNK_HEADER
		*inChunk,
		*startChunk;
	UINT32
		inOffset,
		startOffset;
	bool
		matching;
	UINT32
		nextSearchPosition,
		locatedPosition,
		locatedLength;

	fail=*foundMatch=false;
	nextSearchPosition=lowPosition;
	PositionToChunkPosition(searchInText,nextSearchPosition,&inChunk,&inOffset);	// locate place to start the search
	matching=true;
	while(!fail&&matching)
	{
		if(SearchForward(inChunk,inOffset,searchRecord,leftEdge,rightEdge,highPosition-nextSearchPosition,&matching,&locatedPosition,&locatedLength,&startChunk,&startOffset,&inChunk,&inOffset,abortFunction))
		{
			if(matching)
			{
				if(locatedLength)											// finding an empty string is fatal to find all
				{
					leftEdge=false;											// no matter what, we just moved off the left edge
					locatedPosition+=nextSearchPosition;					// make located position absolute
					nextSearchPosition=locatedPosition+locatedLength;		// move to next place to search
					if(!(*foundMatch))
					{
						(*firstMatchPosition)=locatedPosition;
						(*foundMatch)=true;
					}
					fail=!SetSelectionRange(selectionUniverse,locatedPosition,locatedLength);
				}
				else
				{
					SetError(errorDescriptions[MATCHED_NOTHING]);
					fail=true;
				}
			}
		}
		else
		{
			fail=true;
		}
	}
	return(!fail);
}

static bool FindAllBackward(TEXT_UNIVERSE *searchInText,bool leftEdge,bool rightEdge,UINT32 lowPosition,UINT32 highPosition,SEARCH_RECORD *searchRecord,SELECTION_UNIVERSE *selectionUniverse,bool *foundMatch,UINT32 *firstMatchPosition,ABORT_TEST_FUNCTION *abortFunction)
// Find all occurrences of searchRecord between lowPosition, and highPosition, adding the selections
// to selectionUniverse
// if there is a problem, SetError and return false
// if a matches were found, return true in foundMatch, and the position of the first match found
// in firstMatchPosition
// NOTE: even if false is returned, foundMatch, firstMatchPosition, and selectionUniverse are
// valid
{
	bool
		fail;
	UINT32
		nextSearchPosition;
	CHUNK_HEADER
		*inChunk,
		*endChunk;
	UINT32
		inOffset,
		endOffset;
	bool
		matching;
	UINT32
		locatedPosition,
		locatedLength;

	fail=*foundMatch=false;
	nextSearchPosition=highPosition;
	PositionToChunkPositionPastEnd(searchInText,nextSearchPosition,&inChunk,&inOffset);			// locate place to start the search
	matching=true;
	while(!fail&&matching)
	{
		if(SearchBackward(inChunk,inOffset,searchRecord,leftEdge,rightEdge,nextSearchPosition-lowPosition,&matching,&locatedPosition,&locatedLength,&inChunk,&inOffset,&endChunk,&endOffset,abortFunction))
		{
			if(matching)
			{
				if(locatedLength)										// finding an empty string is fatal to find all
				{
					rightEdge=false;									// no matter what, just left the right edge
					locatedPosition=nextSearchPosition-locatedPosition;	// make located position absolute
					nextSearchPosition=locatedPosition;
					if(!(*foundMatch))
					{
						(*firstMatchPosition)=locatedPosition;
						(*foundMatch)=true;
					}
					fail=!SetSelectionRange(selectionUniverse,locatedPosition,locatedLength);
				}
				else
				{
					SetError(errorDescriptions[MATCHED_NOTHING]);
					fail=true;
				}
			}
		}
		else
		{
			fail=true;
		}
	}
	return(!fail);
}

bool EditorFindAll(EDITOR_BUFFER *buffer,SELECTION_UNIVERSE *selectionUniverse,TEXT_UNIVERSE *searchForText,bool backward,bool wrapAround,bool selectionExpr,bool ignoreCase,bool limitScope,bool *foundMatch,SELECTION_UNIVERSE *resultSelectionUniverse,ABORT_TEST_FUNCTION *abortFunction)
// Find all occurrences of searchForText using the given rules, if there is an error,
// or the user aborts, SetError, and return false. If nothing is found, set found to false
// if found returns true, resultSelectionUniverse will be modified to contain the
// list of selections of found text.
// NOTE: resultSelectionUniverse must be different from selectionUniverse
{
	SEARCH_RECORD
		*searchRecord;
	UINT32
		startPosition,
		endPosition,
		selectionLength;
	UINT32
		firstMatchPosition,
		tempFirstMatchPosition;
	TEXT_UNIVERSE
		*searchInText;
	bool
		hadMatch,
		fail;

	fail=*foundMatch=false;
	if((searchRecord=CreateSearchRecord(searchForText,NULL,selectionExpr,ignoreCase,false)))
	{
		ShowBusy();
		searchInText=buffer->textUniverse;
		if(!backward)
		{
			if(!limitScope)
			{
				GetSelectionEndPositions(selectionUniverse,&startPosition,&endPosition);		// find ends of old selection, or cursor position
				if(FindAllForward(searchInText,endPosition==0,true,endPosition,searchInText->totalBytes,searchRecord,resultSelectionUniverse,foundMatch,&firstMatchPosition,abortFunction))
				{
					if(wrapAround)
					{
						fail=!FindAllForward(searchInText,true,startPosition==searchInText->totalBytes,0,startPosition,searchRecord,resultSelectionUniverse,&hadMatch,&tempFirstMatchPosition,abortFunction);
						if(!(*foundMatch))
						{
							*foundMatch=hadMatch;
							firstMatchPosition=tempFirstMatchPosition;
						}
					}
				}
				else
				{
					fail=true;
				}
			}
			else
			{
				startPosition=0;
				selectionLength=0;
				while(!fail&&GetSelectionAtOrAfterPosition(selectionUniverse,startPosition,&startPosition,&selectionLength))
				{
					if(FindAllForward(searchInText,true,true,startPosition,startPosition+selectionLength,searchRecord,resultSelectionUniverse,&hadMatch,&tempFirstMatchPosition,abortFunction))
					{
						if(!(*foundMatch))
						{
							*foundMatch=hadMatch;
							firstMatchPosition=tempFirstMatchPosition;
						}
					}
					else
					{
						fail=true;
					}
					startPosition+=selectionLength;
				}
			}
		}
		else
		{
			if(!limitScope)
			{
				GetSelectionEndPositions(selectionUniverse,&startPosition,&endPosition);		// find ends of old selection, or cursor position
				if(FindAllBackward(searchInText,true,startPosition==searchInText->totalBytes,0,startPosition,searchRecord,resultSelectionUniverse,foundMatch,&firstMatchPosition,abortFunction))
				{
					if(wrapAround)
					{
						fail=!FindAllBackward(searchInText,endPosition==0,true,endPosition,searchInText->totalBytes,searchRecord,resultSelectionUniverse,&hadMatch,&tempFirstMatchPosition,abortFunction);
						if(!(*foundMatch))
						{
							*foundMatch=hadMatch;
							firstMatchPosition=tempFirstMatchPosition;
						}
					}
				}
				else
				{
					fail=true;
				}
			}
			else
			{
				GetSelectionEndPositions(selectionUniverse,&startPosition,&endPosition);
				startPosition=endPosition;	// start at the end

				while(!fail&&startPosition&&GetSelectionAtOrBeforePosition(selectionUniverse,startPosition-1,&startPosition,&selectionLength))
				{
					if(FindAllBackward(searchInText,true,true,startPosition,startPosition+selectionLength,searchRecord,resultSelectionUniverse,&hadMatch,&tempFirstMatchPosition,abortFunction))
					{
						if(!(*foundMatch))
						{
							*foundMatch=hadMatch;
							firstMatchPosition=tempFirstMatchPosition;
						}
					}
					else
					{
						fail=true;
					}
				}
			}
		}
		if(*foundMatch)																				// got something, so change result universe
		{
			SetSelectionCursorPosition(resultSelectionUniverse,firstMatchPosition);
		}
		DisposeSearchRecord(searchRecord);
		ShowNotBusy();
	}
	else
	{
		fail=true;
	}
	return(!fail);
}

static bool ReplaceRegisterReferences(TEXT_UNIVERSE *replaceWithUniverse,SEARCH_RECORD *searchedForText)
// Run through replaceWithUniverse looking for register specifications, if any are seen,
// replace them with what searchForText found
// if there is a problem, SetError, and return false
// NOTE: registers are specified in replaceWithUniverse using \0 through \9
// ignore any other \ in replaceWithUniverse
{
	CHUNK_HEADER
		*foundChunk,
		*currentChunk,
		*nextChunk;
	UINT32
		foundOffset,
		currentOffset,
		currentPosition,
		nextOffset;
	UINT32
		matchLength;
	UINT8
		character;
	bool
		fail;

	fail=false;
	currentChunk=replaceWithUniverse->firstChunkHeader;
	currentPosition=currentOffset=0;
	while(currentChunk&&!fail)
	{
		if(currentChunk->data[currentOffset]!='\\')
		{
			currentPosition++;
			currentOffset++;
			if(currentOffset>currentChunk->totalBytes)
			{
				currentChunk=currentChunk->nextHeader;
				currentOffset=0;
			}
		}
		else
		{
			nextChunk=currentChunk;
			nextOffset=currentOffset+1;
			if(nextOffset>nextChunk->totalBytes)
			{
				nextChunk=nextChunk->nextHeader;
				nextOffset=0;
			}
			if(nextChunk)
			{
				character=nextChunk->data[nextOffset];
				if(character>='0'&&character<='9')
				{
					character-='0';														// make into an index
					if(DeleteUniverseText(replaceWithUniverse,currentPosition,2))		// remove the register specification
					{
						if(GetRERegisterMatchChunkAndOffset(searchedForText->expression,character,&foundChunk,&foundOffset,&matchLength))	// see if anything to insert
						{
							fail=!InsertUniverseChunks(replaceWithUniverse,currentPosition,foundChunk,foundOffset,matchLength);
							currentPosition+=matchLength;								// move past stuff just inserted
						}
						PositionToChunkPosition(replaceWithUniverse,currentPosition,&currentChunk,&currentOffset);		// locate place to continue looking
					}
					else
					{
						fail=true;
					}
				}
				else
				{
					currentChunk=nextChunk;		// push past the quote character
					currentOffset=nextOffset;
					currentPosition++;
				}
			}
			else
			{
				currentChunk=nextChunk;			// \ as last character, just terminate scan
				currentOffset=nextOffset;
			}
		}
	}
	return(!fail);
}

static bool CreateFoundVariable(EDITOR_BUFFER *replaceInUniverse,UINT32 replaceOffset,UINT32 replaceLength,SEARCH_RECORD *searchRecord)
// Create the "found" variable, and $n variables which are passed to the Tcl procedure as
// globals.
// If there is a problem, SetError, and return NULL
// NOTE: this routine, and ReplaceSelectedText are the ONLY routines in this file that
// rely on Tcl...
// if there is a problem, SetError, and return false
{
	CHUNK_HEADER
		*chunk,
		*foundChunk;
	UINT32
		offset,
		foundOffset;
	UINT32
		matchLength;
	char
		*locatedText;
	int
		varCount;
	char
		varName[32];
	bool
		fail;

	fail=false;
	if((locatedText=(char *)MNewPtr(replaceLength+1)))	// make pointer to text that was located (this pointer will used to hold all the extracted text)
	{
		PositionToChunkPosition(replaceInUniverse->textUniverse,replaceOffset,&chunk,&offset);		// locate place where match was found
		if(ExtractUniverseText(replaceInUniverse->textUniverse,chunk,offset,(UINT8 *)locatedText,replaceLength,&chunk,&offset))
		{
			locatedText[replaceLength]='\0';			// terminate the string
			if(!Tcl_SetVar(tclInterpreter,"found",locatedText,TCL_LEAVE_ERR_MSG))
			{
				SetError("%s",Tcl_GetStringResult(tclInterpreter));
				fail=true;
			}
		}
		else
		{
			fail=true;
		}
		MDisposePtr(locatedText);
	}
	else
	{
		fail=true;
	}

	if(!fail&&searchRecord->expression)			// if it is an expression, make a list of 10 more variables (one for each tagged subexpression)
	{
		for(varCount=0;!fail&&varCount<MAX_REGISTERS;varCount++)
		{
			sprintf(varName,"%d",varCount);		// create variable name

			if(GetRERegisterMatchChunkAndOffset(searchRecord->expression,varCount,&foundChunk,&foundOffset,&matchLength))	// see if anything to add
			{
				if((locatedText=(char *)MNewPtr(replaceLength+1)))		// make pointer to the text
				{
					if(ExtractUniverseText(replaceInUniverse->textUniverse,foundChunk,foundOffset,(UINT8 *)locatedText,matchLength,&chunk,&offset))
					{
						locatedText[matchLength]='\0';					// terminate the string
						if(!Tcl_SetVar(tclInterpreter,varName,locatedText,TCL_LEAVE_ERR_MSG))
						{
							SetError("%s",Tcl_GetStringResult(tclInterpreter));
							fail=true;
						}
					}
					else
					{
						fail=true;
					}
					MDisposePtr(locatedText);
				}
				else
				{
					fail=true;
				}
			}
			else
			{
				if(!Tcl_SetVar(tclInterpreter,varName,"",TCL_LEAVE_ERR_MSG))
				{
					SetError("%s",Tcl_GetStringResult(tclInterpreter));
					fail=true;
				}
			}
		}
	}
	return(!fail);
}

static bool ReplaceSearchedText(EDITOR_BUFFER *replaceInUniverse,UINT32 replaceOffset,UINT32 replaceLength,CHUNK_HEADER **replaceAtChunk,UINT32 *replaceAtChunkOffset,SEARCH_RECORD *searchRecord,UINT32 *bytesReplaced)
// Given text that was just searched for by searchForText, replace it
// based on the search type
// if there is a problem, attempt to leave the text unmodified
// SetError, and return false
{
	bool
		fail;
	UINT32
		length;
	TEXT_UNIVERSE
		*alternateUniverse;
	char
		*stringResult;

	fail=false;
	if(searchRecord->procedure)								// handle replacement by calling a Tcl procedure
	{
		if(CreateFoundVariable(replaceInUniverse,replaceOffset,replaceLength,searchRecord))
		{
			if(Tcl_Eval(tclInterpreter,searchRecord->procedure)==TCL_OK)
			{
				stringResult=(char *)Tcl_GetStringResult(tclInterpreter);
				length=strlen(stringResult);
				fail=!ReplaceEditorText(replaceInUniverse,replaceOffset,replaceOffset+replaceLength,(UINT8 *)stringResult,length,false);
				(*bytesReplaced)=length;
			}
			else
			{
				SetError("%s",Tcl_GetStringResult(tclInterpreter));
				fail=true;
			}
			Tcl_ResetResult(tclInterpreter);				// do not leave any Tcl result around (other stuff may append to it)
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		if(searchRecord->expression)
		{
			if((alternateUniverse=OpenTextUniverse()))		// create alternate universe where we make the real text to replace
			{
				if(InsertUniverseChunks(alternateUniverse,alternateUniverse->totalBytes,searchRecord->replaceWithText->firstChunkHeader,0,searchRecord->replaceWithText->totalBytes))	// copy replace with text into alternate universe
				{
					if(ReplaceRegisterReferences(alternateUniverse,searchRecord))
					{
						fail=!ReplaceEditorChunks(replaceInUniverse,replaceOffset,replaceOffset+replaceLength,alternateUniverse->firstChunkHeader,0,alternateUniverse->totalBytes,false);
						(*bytesReplaced)=alternateUniverse->totalBytes;
					}
					else
					{
						fail=true;
					}
				}
				else
				{
					fail=true;
				}
				CloseTextUniverse(alternateUniverse);
			}
			else
			{
				fail=true;
			}
		}
		else
		{
			fail=!ReplaceEditorChunks(replaceInUniverse,replaceOffset,replaceOffset+replaceLength,searchRecord->replaceWithText->firstChunkHeader,0,searchRecord->replaceWithText->totalBytes,false);
			(*bytesReplaced)=searchRecord->replaceWithText->totalBytes;
		}
	}
	return(!fail);
}

bool EditorReplace(EDITOR_BUFFER *buffer,SELECTION_UNIVERSE *selectionUniverse,TEXT_UNIVERSE *searchForText,TEXT_UNIVERSE *replaceWithText,bool backward,bool wrapAround,bool selectionExpr,bool ignoreCase,bool replaceProc,bool *foundMatch,SELECTION_UNIVERSE *resultSelectionUniverse,ABORT_TEST_FUNCTION *abortFunction)
// Find searchForText in buffer, starting at the cursor position, or the _start_ of
// the current selection of selectionUniverse
// if searchForText is not located, return false in foundMatch
// if it is located, replace what was found with replaceWithText, modify resultSelectionUniverse to
// be the selection of what was replaced, and return true in foundMatch
// if there is a problem, SetError, and return false
// NOTE: resultSelectionUniverse must be different from selectionUniverse
{
	CHUNK_HEADER
		*inChunk,
		*startChunk,
		*endChunk;
	UINT32
		inOffset,
		startOffset,
		endOffset;
	SEARCH_RECORD
		*searchRecord;
	UINT32
		startPosition,
		endPosition,
		bytesReplaced;
	UINT32
		locatedPosition,
		locatedLength;
	TEXT_UNIVERSE
		*searchInText;
	bool
		fail;

	fail=*foundMatch=false;
	if((searchRecord=CreateSearchRecord(searchForText,replaceWithText,selectionExpr,ignoreCase,replaceProc)))
	{
		ShowBusy();
		searchInText=buffer->textUniverse;

		GetSelectionEndPositions(selectionUniverse,&startPosition,&endPosition);		// find ends of old selection, or cursor position
		if(!backward)
		{
			PositionToChunkPosition(searchInText,startPosition,&inChunk,&inOffset);		// locate place to start the search
			if(SearchForward(inChunk,inOffset,searchRecord,startPosition==0,true,searchInText->totalBytes-startPosition,foundMatch,&locatedPosition,&locatedLength,&startChunk,&startOffset,&endChunk,&endOffset,abortFunction))
			{
				locatedPosition+=startPosition;											// make located position absolute
				if(!(*foundMatch)&&wrapAround)
				{
					if(!SearchForward(searchInText->firstChunkHeader,0,searchRecord,true,startPosition==searchInText->totalBytes,startPosition,foundMatch,&locatedPosition,&locatedLength,&startChunk,&startOffset,&endChunk,&endOffset,abortFunction))
					{
						fail=true;
					}
				}
			}
			else
			{
				fail=true;
			}
		}
		else
		{
			PositionToChunkPositionPastEnd(searchInText,endPosition,&inChunk,&inOffset);	// locate place to start the search
			if(SearchBackward(inChunk,inOffset,searchRecord,true,endPosition==searchInText->totalBytes,endPosition,foundMatch,&locatedPosition,&locatedLength,&startChunk,&startOffset,&endChunk,&endOffset,abortFunction))
			{
				locatedPosition=endPosition-locatedPosition;							// make located position absolute
				if(!(*foundMatch)&&wrapAround)
				{
					PositionToChunkPositionPastEnd(searchInText,searchInText->totalBytes,&inChunk,&inOffset);	// locate place to start the search
					if(SearchBackward(inChunk,inOffset,searchRecord,endPosition==0,true,searchInText->totalBytes-endPosition,foundMatch,&locatedPosition,&locatedLength,&startChunk,&startOffset,&endChunk,&endOffset,abortFunction))
					{
						locatedPosition=searchInText->totalBytes-locatedPosition;
					}
					else
					{
						fail=true;
					}
				}
			}
			else
			{
				fail=true;
			}
		}
		if(!fail&&(*foundMatch))
		{
			BeginUndoGroup(buffer);
			EditorStartReplace(buffer);
			if(!ReplaceSearchedText(buffer,locatedPosition,locatedLength,&startChunk,&startOffset,searchRecord,&bytesReplaced))
			{
				bytesReplaced=0;	// if the replace failed for some reason, select nothing
				fail=true;			// report the failure
			}
			EditorEndReplace(buffer);
			StrictEndUndoGroup(buffer);

			DeleteAllSelections(resultSelectionUniverse);	// remove all old selections
			if(SetSelectionRange(resultSelectionUniverse,locatedPosition,bytesReplaced))
			{
				SetSelectionCursorPosition(resultSelectionUniverse,locatedPosition);
			}
			else
			{
				fail=true;
			}
		}
		DisposeSearchRecord(searchRecord);
		ShowNotBusy();
	}
	else
	{
		fail=true;
	}
	return(!fail);
}

static bool ReplaceAllForward(EDITOR_BUFFER *buffer,bool leftEdge,bool rightEdge,UINT32 lowPosition,UINT32 *highPosition,SEARCH_RECORD *searchRecord,SELECTION_UNIVERSE *selectionUniverse,bool *foundMatch,UINT32 *firstMatchPosition,ABORT_TEST_FUNCTION *abortFunction)
// Replace all occurrences of searchRecord between lowPosition, and highPosition, adding the selections
// to selectionUniverse before selectionChunk, selectionOffset
// if there is a problem, SetError and return false
// if a matches were found, return true in foundMatch, and the position of the first match found
// in firstMatchPosition
// highPosition is modified to reflect the new highPosition after all replacements have been made
// NOTE: even if false is returned, foundMatch, highPosition, and selectionUniverse are
// valid
{
	bool
		fail;
	CHUNK_HEADER
		*inChunk,
		*startChunk;
	UINT32
		inOffset,
		startOffset;
	bool
		matching;
	TEXT_UNIVERSE
		*searchInText;
	UINT32
		nextSearchPosition,
		locatedPosition,
		locatedLength,
		bytesReplaced;
	UINT32
		newHighPosition;

	fail=*foundMatch=false;
	searchInText=buffer->textUniverse;
	nextSearchPosition=lowPosition;
	matching=true;
	newHighPosition=*highPosition;
	while(!fail&&matching)
	{
		PositionToChunkPosition(searchInText,nextSearchPosition,&inChunk,&inOffset);	// locate place to start the search

		if(nextSearchPosition!=lowPosition)
		{
			leftEdge=false;													// no longer at left edge
		}

		if(SearchForward(inChunk,inOffset,searchRecord,leftEdge,rightEdge,newHighPosition-nextSearchPosition,&matching,&locatedPosition,&locatedLength,&startChunk,&startOffset,&inChunk,&inOffset,abortFunction))
		{
			if(matching)													// see if a match was found, if not, we are done
			{
				if(locatedLength)											// finding an empty string is fatal to replace all
				{
					locatedPosition+=nextSearchPosition;					// make located position absolute
					if(!(*foundMatch))
					{
						(*firstMatchPosition)=locatedPosition;				// remember the first match position so we can home to it when done
						(*foundMatch)=true;
					}
					if(ReplaceSearchedText(buffer,locatedPosition,locatedLength,&startChunk,&startOffset,searchRecord,&bytesReplaced))
					{
						inChunk=startChunk;
						inOffset=startOffset;
						nextSearchPosition=locatedPosition+bytesReplaced;	// move to the new position after the replacement
						newHighPosition-=locatedLength;						// subtract off bytes that were replaced
						newHighPosition+=bytesReplaced;						// add back number that replaced them

						DeleteSelectionRange(selectionUniverse,locatedPosition,locatedLength);
						if(InsertSelectionRange(selectionUniverse,locatedPosition,bytesReplaced))
						{
							fail=!SetSelectionRange(selectionUniverse,locatedPosition,bytesReplaced);
						}
						else
						{
							fail=true;
						}
					}
					else
					{
						fail=true;
					}
				}
				else
				{
					SetError(errorDescriptions[MATCHED_NOTHING]);
					fail=true;
				}
			}
		}
		else
		{
			fail=true;
		}
	}
	*highPosition=newHighPosition;
	return(!fail);
}

static bool ReplaceAllBackward(EDITOR_BUFFER *buffer,bool leftEdge,bool rightEdge,UINT32 lowPosition,UINT32 *highPosition,SEARCH_RECORD *searchRecord,SELECTION_UNIVERSE *selectionUniverse,bool *foundMatch,UINT32 *firstMatchPosition,ABORT_TEST_FUNCTION *abortFunction)
// Replace all occurrences of searchRecord between lowPosition, and highPosition, adding the selections
// to selectionUniverse
// if there is a problem, SetError and return false
// if a matches were found, return true in foundMatch, and the position of the first match found
// in firstMatchPosition
// highPosition is modified to reflect the new highPosition after all replacements have been made
// NOTE: even if false is returned, foundMatch, highPosition, and selectionUniverse are
// valid
{
	bool
		fail;
	CHUNK_HEADER
		*inChunk,
		*endChunk;
	UINT32
		inOffset,
		endOffset;
	bool
		matching;
	TEXT_UNIVERSE
		*searchInText;
	UINT32
		nextSearchPosition,
		locatedPosition,
		locatedLength,
		bytesReplaced;
	UINT32
		newHighPosition;

	fail=*foundMatch=false;
	searchInText=buffer->textUniverse;
	nextSearchPosition=*highPosition;
	matching=true;
	newHighPosition=*highPosition;
	while(!fail&&matching)
	{
		PositionToChunkPositionPastEnd(searchInText,nextSearchPosition,&inChunk,&inOffset);		// locate place to start the search

		if(nextSearchPosition!=newHighPosition)
		{
			rightEdge=false;												// no longer at the right edge
		}

		if(SearchBackward(inChunk,inOffset,searchRecord,leftEdge,rightEdge,nextSearchPosition-lowPosition,&matching,&locatedPosition,&locatedLength,&inChunk,&inOffset,&endChunk,&endOffset,abortFunction))
		{
			if(matching)													// see if a match was found, if not, we are done
			{
				if(locatedLength)											// finding an empty string is fatal to replace all
				{
					locatedPosition=nextSearchPosition-locatedPosition;		// make located position absolute
					nextSearchPosition=locatedPosition;
					if(!(*foundMatch))										// if no matches found so far ...
					{
						(*firstMatchPosition)=locatedPosition;				// remember end of selections (sort of, will be adjusted at the end)
						(*foundMatch)=true;
					}
					if(ReplaceSearchedText(buffer,locatedPosition,locatedLength,&inChunk,&inOffset,searchRecord,&bytesReplaced))
					{
						newHighPosition-=locatedLength;						// subtract off bytes that were replaced
						newHighPosition+=bytesReplaced;						// add back number that replaced them

						DeleteSelectionRange(selectionUniverse,locatedPosition,locatedLength);
						if(InsertSelectionRange(selectionUniverse,locatedPosition,bytesReplaced))
						{
							fail=!SetSelectionRange(selectionUniverse,locatedPosition,bytesReplaced);
						}
						else
						{
							fail=true;
						}
					}
					else
					{
						fail=true;
					}
				}
				else
				{
					SetError(errorDescriptions[MATCHED_NOTHING]);
					fail=true;
				}
			}
		}
		else
		{
			fail=true;
		}
	}
	*firstMatchPosition+=newHighPosition-(*highPosition);
	*highPosition=newHighPosition;
	return(!fail);
}

bool EditorReplaceAll(EDITOR_BUFFER *buffer,SELECTION_UNIVERSE *selectionUniverse,TEXT_UNIVERSE *searchForText,TEXT_UNIVERSE *replaceWithText,bool backward,bool wrapAround,bool selectionExpr,bool ignoreCase,bool limitScope,bool replaceProc,bool *foundMatch,SELECTION_UNIVERSE *resultSelectionUniverse,ABORT_TEST_FUNCTION *abortFunction)
// Replace all occurrences of searchForText with replaceWithText using the given rules, if none are found,
// return false in foundMatch
// if foundMatch is true, modify resultSelectionUniverse to be the selection of all replaced text
// if there is a problem, SetError, return false
// NOTE: resultSelectionUniverse must be different from selectionUniverse
{
	SEARCH_RECORD
		*searchRecord;
	INT32
		replaceOffset;
	UINT32
		startPosition,
		endPosition,
		selectionLength;
	UINT32
		firstMatchPosition,
		tempFirstMatchPosition,
		highPosition;
	TEXT_UNIVERSE
		*searchInText;
	bool
		hadMatch,
		fail;
	SELECTION_UNIVERSE
		*oldSelectionUniverse;

	fail=*foundMatch=false;
	if((searchRecord=CreateSearchRecord(searchForText,replaceWithText,selectionExpr,ignoreCase,replaceProc)))
	{
		ShowBusy();
		if((oldSelectionUniverse=OpenSelectionUniverse()))						// copy this, since it must not change during the replacement
		{
			if(CopySelectionUniverse(selectionUniverse,oldSelectionUniverse))	// copy the old one into it
			{
				searchInText=buffer->textUniverse;
				firstMatchPosition=0;
				BeginUndoGroup(buffer);
				EditorStartReplace(buffer);
				if(!backward)
				{
					if(!limitScope)
					{
						GetSelectionEndPositions(oldSelectionUniverse,&startPosition,&endPosition);		// find ends of old selection, or cursor position
						highPosition=searchInText->totalBytes;
						if(ReplaceAllForward(buffer,startPosition==0,true,startPosition,&highPosition,searchRecord,resultSelectionUniverse,foundMatch,&firstMatchPosition,abortFunction))
						{
							if(wrapAround)
							{
								highPosition=startPosition;
								fail=!ReplaceAllForward(buffer,true,highPosition==searchInText->totalBytes,0,&highPosition,searchRecord,resultSelectionUniverse,&hadMatch,&tempFirstMatchPosition,abortFunction);
								if(!(*foundMatch))
								{
									*foundMatch=hadMatch;
									firstMatchPosition=tempFirstMatchPosition;
								}
								else
								{
									firstMatchPosition+=highPosition-startPosition;	// move home position due to text changes above
								}
							}
						}
						else
						{
							fail=true;
						}
					}
					else
					{
						replaceOffset=0;
						startPosition=0;
						selectionLength=0;
						while(!fail&&GetSelectionAtOrAfterPosition(oldSelectionUniverse,startPosition,&startPosition,&selectionLength))
						{
							endPosition=startPosition+replaceOffset+selectionLength;
							if(ReplaceAllForward(buffer,true,true,startPosition+replaceOffset,&endPosition,searchRecord,resultSelectionUniverse,&hadMatch,&tempFirstMatchPosition,abortFunction))
							{
								replaceOffset+=endPosition-(startPosition+replaceOffset+selectionLength);
								if(!(*foundMatch))
								{
									*foundMatch=hadMatch;
									firstMatchPosition=tempFirstMatchPosition;
								}
							}
							else
							{
								fail=true;
							}
							startPosition+=selectionLength;
						}
					}
				}
				else
				{
					if(!limitScope)
					{
						GetSelectionEndPositions(oldSelectionUniverse,&startPosition,&endPosition);		// find ends of old selection, or cursor position
						highPosition=endPosition;
						if(ReplaceAllBackward(buffer,true,highPosition==searchInText->totalBytes,0,&highPosition,searchRecord,resultSelectionUniverse,foundMatch,&firstMatchPosition,abortFunction))
						{
							if(wrapAround)
							{
								endPosition=highPosition;
								highPosition=searchInText->totalBytes;
								fail=!ReplaceAllBackward(buffer,endPosition==0,true,endPosition,&highPosition,searchRecord,resultSelectionUniverse,&hadMatch,&tempFirstMatchPosition,abortFunction);
								if(!(*foundMatch))
								{
									*foundMatch=hadMatch;
									firstMatchPosition=tempFirstMatchPosition;
								}
							}
						}
						else
						{
							fail=true;
						}
					}
					else
					{
						GetSelectionEndPositions(selectionUniverse,&startPosition,&endPosition);
						startPosition=endPosition;	// start at the end

						while(!fail&&startPosition&&GetSelectionAtOrBeforePosition(selectionUniverse,startPosition-1,&startPosition,&selectionLength))
						{
							endPosition=startPosition+selectionLength;
							highPosition=endPosition;
							if(ReplaceAllBackward(buffer,true,true,startPosition,&highPosition,searchRecord,resultSelectionUniverse,&hadMatch,&tempFirstMatchPosition,abortFunction))
							{
								if(!(*foundMatch))
								{
									*foundMatch=hadMatch;
									firstMatchPosition=tempFirstMatchPosition;
								}
								else
								{
									firstMatchPosition+=highPosition-endPosition;		// adjust for any replacements just made
								}
							}
							else
							{
								fail=true;
							}
						}
					}
				}
				EditorEndReplace(buffer);
				StrictEndUndoGroup(buffer);
				if(*foundMatch)																	// got something, so change selection universe
				{
					SetSelectionCursorPosition(resultSelectionUniverse,firstMatchPosition);		// put the cursor at the start
				}
			}
			else
			{
				fail=true;
			}
			CloseSelectionUniverse(oldSelectionUniverse);									// close this universe
		}
		else
		{
			fail=true;
		}
		DisposeSearchRecord(searchRecord);
		ShowNotBusy();
	}
	else
	{
		fail=true;
	}
	return(!fail);
}