e93/e93/buffer.c

// Handle high level buffer stuff
// 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"

// Some handy notes about buffers:
// shellBusy
//   This is used exclusively by the the shell. It indicates to the
//   shell that it is already doing something with the buffer, and that it is
//   not allowed to affect it in any way (useful when doing search and replace,
//   where replace is a shell script... keeps script from being able to modify
//   the buffer that is in the middle of being modified by replace command)
//   To that end, the buffer should be checked for "busy" before the shell attempts
//   to change the text it contains, or change its selection.
//   It should be set to busy whenever the shell is about to do something to the
//   buffer that could run a Tcl script.

static EDITOR_BUFFER
	*startBuffer;								// pointer to start of editor buffer list

enum
{
	NOT_FROM_FILE,
	DUPLICATE_NAME
};

static const char *errorDescriptions[]=
{
	"Buffer is not linked to a file",
	"Duplicate buffer names are not allowed"
};

static void DisposeBuffer(EDITOR_BUFFER *buffer)
// dispose of a buffer
{
	EDITOR_BUFFER
		*previousBuffer,
		*testBuffer;
	EDITOR_BUFFER_HANDLE
		*handle;

	handle=buffer->bufferHandles;
	while(handle)											// for each handle to this buffer, unlink and clear it
	{
		handle->buffer=NULL;								// this buffer is gone...
		handle=handle->nextHandle;
	}

	UnInitVariableBindingTable(&(buffer->variableTable));	// remove variables hanging off this buffer
	if(buffer->window)
	{
		EditorCloseDocumentWindow(buffer->window);			// close down the window if one exists
	}
	if(buffer->task)
	{
		DisconnectBufferTask(buffer);						// close down the connection to any task that may be attached to this buffer
	}
	if(buffer->syntaxInstance)								// if syntax instance has been assigned, remove it
	{
		CloseSyntaxInstance(buffer->syntaxInstance);
	}
	CloseStyleUniverse(buffer->styleUniverse);
	while(buffer->marks)
	{
		CloseEditorMark(buffer,buffer->marks);				// get rid of all marks on this buffer
	}
	CloseSelectionUniverse(buffer->auxSelectionUniverse);
	CloseSelectionUniverse(buffer->xorSelectionUniverse);
	CloseSelectionUniverse(buffer->selectionUniverse);
	CloseUndoUniverse(buffer->undoUniverse);
	CloseTextUniverse(buffer->textUniverse);
	MDisposePtr(buffer->contentName);

	previousBuffer=NULL;
	testBuffer=startBuffer;
	while(testBuffer&&testBuffer!=buffer)
	{
		previousBuffer=testBuffer;
		testBuffer=testBuffer->nextBuffer;
	}
	if(testBuffer==buffer)									// make sure we found it before trying to unlink
	{
		if(previousBuffer)
		{
			previousBuffer->nextBuffer=buffer->nextBuffer;
		}
		else
		{
			startBuffer=buffer->nextBuffer;
		}
	}

	MDisposePtr(buffer);
}

static EDITOR_BUFFER *CreateBuffer(const char *bufferName)
// create a buffer (buffers contain both text and selection
// universes (which are created here))
// if there is a problem, set the error, and return NULL
{
	EDITOR_BUFFER
		*buffer;

	if((buffer=(EDITOR_BUFFER *)MNewPtr(sizeof(EDITOR_BUFFER))))
	{
		buffer->bufferHandles=NULL;									// not being held
		buffer->shellBusy=false;									// set this to a known value
		buffer->fromFile=false;

		if((buffer->contentName=(char *)MNewPtr(strlen(bufferName)+1)))
		{
			strcpy(buffer->contentName,bufferName);
			if((buffer->textUniverse=OpenTextUniverse()))			// create the text universe
			{
				if((buffer->undoUniverse=OpenUndoUniverse()))		// create the undo universe
				{
					if((buffer->selectionUniverse=OpenSelectionUniverse()))			// create the selection universe
					{
						if((buffer->xorSelectionUniverse=OpenSelectionUniverse()))		// create the XOR selection universe
						{
							if((buffer->auxSelectionUniverse=OpenSelectionUniverse()))	// create the aux selection universe (used for tasks, so they can write data into a place other than at the cursor)
							{
								buffer->marks=NULL;						// no marks on this buffer yet
								if((buffer->styleUniverse=OpenStyleUniverse()))			// create the style universe
								{
									buffer->syntaxInstance=NULL;		// no syntax highlight on this buffer yet
									buffer->task=NULL;
									buffer->taskBytes=0;
									buffer->window=NULL;
									buffer->firstView=NULL;				// no views onto this buffer yet
									InitVariableBindingTable(&(buffer->variableTable));	// initialize the variable table

									buffer->replaceHaveRange=false;
									buffer->replaceStartOffset=0;
									buffer->replaceEndOffset=0;
									buffer->replaceNumBytes=0;

									buffer->anchorStartPosition=0;		// clear selection handling variables
									buffer->anchorEndPosition=0;
									buffer->anchorLine=0;
									buffer->anchorX=0;
									buffer->columnarTopLine=0;
									buffer->columnarBottomLine=0;
									buffer->columnarLeftX=0;
									buffer->columnarRightX=0;
									buffer->haveStartX=false;
									buffer->haveEndX=false;
									buffer->desiredStartX=0;
									buffer->desiredEndX=0;
									buffer->haveCurrentEnd=false;
									buffer->currentIsStart=false;

									buffer->nextBuffer=startBuffer;
									startBuffer=buffer;
									return(buffer);
								}
								CloseSelectionUniverse(buffer->auxSelectionUniverse);
							}
							CloseSelectionUniverse(buffer->xorSelectionUniverse);
						}
						CloseSelectionUniverse(buffer->selectionUniverse);
					}
					CloseUndoUniverse(buffer->undoUniverse);
				}
				CloseTextUniverse(buffer->textUniverse);
			}
			MDisposePtr(buffer->contentName);
		}
		MDisposePtr(buffer);
	}
	return(NULL);
}

void SetBufferBusy(EDITOR_BUFFER *buffer)
// set the buffer's busy state
{
	buffer->shellBusy=true;
}

void ClearBufferBusy(EDITOR_BUFFER *buffer)
// clear the buffer's busy state
{
	buffer->shellBusy=false;
}

bool BufferBusy(EDITOR_BUFFER *buffer)
// check the given buffer's busy state
// if busy, return true, else false
{
	return(buffer->shellBusy);
}

EDITOR_BUFFER *EditorGetFirstBuffer()
// return the first buffer, or NULL if none
{
	return(startBuffer);
}

EDITOR_BUFFER *EditorGetNextBuffer(EDITOR_BUFFER *buffer)
// return the next buffer, or NULL if none
{
	return(buffer->nextBuffer);
}

EDITOR_BUFFER *LocateBuffer(const char *bufferName)
// search through the list of buffers, and attempt to locate
// one with the given name
// if one is found, return it, else return NULL
{
	bool
		found;
	EDITOR_BUFFER
		*testBuffer;

	testBuffer=startBuffer;
	found=false;
	while(testBuffer&&!found)
	{
		if(strcmp(testBuffer->contentName,bufferName)==0)
		{
			found=true;
		}
		else
		{
			testBuffer=testBuffer->nextBuffer;
		}
	}
	return(testBuffer);
}

void EditorCloseBuffer(EDITOR_BUFFER *buffer)
// close the given edit buffer
// if the buffer has a task, it will be disconnected
// if the buffer has a window, it will be closed too
// this will close the window without saving, even if the text has been modified
{
	DisposeBuffer(buffer);
}

void EditorReleaseBufferHandle(EDITOR_BUFFER_HANDLE *handle)
// Remove handle from the buffer it was linked to
// NOTE: if handle is already released, this does nothing
{
	EDITOR_BUFFER_HANDLE
		*previousHandle,
		*currentHandle;

	if(handle->buffer)			// make sure this handle is held
	{
		previousHandle=NULL;
		currentHandle=handle->buffer->bufferHandles;
		while(currentHandle&&currentHandle!=handle)
		{
			previousHandle=currentHandle;
			currentHandle=currentHandle->nextHandle;
		}
		if(currentHandle)
		{
			if(previousHandle)
			{
				previousHandle->nextHandle=currentHandle->nextHandle;
			}
			else
			{
				currentHandle->buffer->bufferHandles=currentHandle->nextHandle;
			}
		}
		handle->buffer=NULL;
	}
}

void EditorGrabBufferHandle(EDITOR_BUFFER_HANDLE *handle,EDITOR_BUFFER *buffer)
// grab a handle to buffer
{
	handle->buffer=buffer;
	handle->nextHandle=buffer->bufferHandles;
	buffer->bufferHandles=handle;
}

EDITOR_BUFFER *EditorGetBufferFromHandle(EDITOR_BUFFER_HANDLE *handle)
// return the buffer that handle points to
{
	return(handle->buffer);
}

void EditorInitBufferHandle(EDITOR_BUFFER_HANDLE *handle)
// initialize a buffer handle so that it is in the released state
{
	handle->buffer=NULL;
}

bool EditorRevertBuffer(EDITOR_BUFFER *buffer)
// revert buffer, no questions asked
// if there is a problem, SetError, and return false
// NOTE: the window could be left with only part of the reverted text
// if there was a problem
{
	if(buffer->fromFile)
	{
		if(LoadBuffer(buffer,buffer->contentName))
		{
			return(true);
		}
	}
	else
	{
		if(ClearBuffer(buffer))
		{
			return(true);
		}
	}
	return(false);
}

bool EditorSaveBufferTo(EDITOR_BUFFER *buffer,const char *path)
// save the text of buffer into path
// NOTE: the text will be saved even if it is not dirty
// if there is a problem, SetError, and return false
// NOTE: the buffer "clean" point is not moved by this call
// NOTE: certain problems may cause the text to be only partially saved
// thus corrupting the file
{
	return(SaveBuffer(buffer,path,false));
}

bool EditorSaveBufferAs(EDITOR_BUFFER *buffer,const char *path)
// save the text of buffer into path, change buffer's name
// to the absolute version of path, and update its window if it has one
// NOTE: the text will be saved even if it is not dirty
// if there is a problem, SetError, and return false
// NOTE: certain problems may cause the text to be only partially saved
// thus corrupting the file
// NOTE: if after a save, the buffer's name becomes the same as that
// of another already existing buffer, the name change will fail, even though
// the contents of the buffer have been written into the file
// this is a little ugly, but all editors have to cope with this problem somehow.
{
	EDITOR_BUFFER
		*otherBuffer;
	char
		*absolutePath;

	if(SaveBuffer(buffer,path,true))							// save the file using the regular path, mark it as clean
	{
		if((absolutePath=CreateAbsolutePath(path)))				// attempt to make an absolute path out of the one given (this could fail if someone deleted the file we just saved before we get here!)
		{
			if(!(otherBuffer=LocateBuffer(absolutePath))||(otherBuffer==buffer))	// see if there is another buffer down this path
			{
				MDisposePtr(buffer->contentName);				// wipe out the old content name
				buffer->contentName=absolutePath;				// point it at the new path
				buffer->fromFile=true;							// linked to file now
				EditorReassignDocumentWindowTitle(buffer);		// make new title to reflect new name
				return(true);
			}
			else
			{
				SetError(errorDescriptions[DUPLICATE_NAME]);
			}
			MDisposePtr(absolutePath);
		}
	}
	return(false);
}

bool EditorSaveBuffer(EDITOR_BUFFER *buffer)
// save the text of buffer into its file if it has one
// if it does not have a file, this will fail
{
	if(buffer->fromFile)
	{
		return(SaveBuffer(buffer,buffer->contentName,true));	// save buffer, mark it as clean
	}
	SetError(errorDescriptions[NOT_FROM_FILE]);
	return(false);
}

EDITOR_BUFFER *EditorNewBuffer(const char *bufferName)
// create a new buffer with the given name
// NOTE: if there is already a buffer with the given name, SetError
// if there is a problem, SetError, return NULL
{
	if(!LocateBuffer(bufferName))
	{
		return(CreateBuffer(bufferName));
	}
	else
	{
		SetError(errorDescriptions[DUPLICATE_NAME]);
	}
	return(NULL);
}

EDITOR_BUFFER *EditorOpenBuffer(const char *path)
// open an editor buffer to the file at path
// if possible, open it, and return the buffer
// if there is a problem, set the error, and return NULL
// NOTE: if path points to a buffer that is already open,
// then that buffer is simply returned
{
	EDITOR_BUFFER
		*buffer;
	char
		*absolutePath;

	if((absolutePath=CreateAbsolutePath(path)))				// attempt to make an absolute path out of the one given
	{
		if((buffer=LocateBuffer(absolutePath)))
		{
			MDisposePtr(absolutePath);
			return(buffer);
		}
		else
		{
			if((buffer=CreateBuffer(absolutePath)))
			{
				if(LoadBuffer(buffer,absolutePath))
				{
					buffer->fromFile=true;
					MDisposePtr(absolutePath);
					return(buffer);
				}
				DisposeBuffer(buffer);
			}
		}
		MDisposePtr(absolutePath);
	}
	return(NULL);
}

void UnInitBuffers()
// undo whatever InitBuffers did
{
	while(startBuffer)
	{
		if(startBuffer->bufferHandles)
		{
			fprintf(stderr,"Buffer dying with handles\n");	// this is a bug because no one should have a handle to a buffer at this moment
		}
		EditorCloseBuffer(startBuffer);						// get rid of any buffers left lying about
	}
}

bool InitBuffers()
// initialize buffer handling
// if there is a problem, SetError, and return false
{
	startBuffer=NULL;										// no start buffer as of yet
	return(true);
}