/*
 *		BUFFER.C											vi:ts=4
 *
 *      Copyright (c) Eddy Carroll, September 1994.
 *
 *		This module maintains the review buffer used by SnoopDos to record
 *		the past events that have occurred.
 */		

#define TESTING		0

#include "system.h"
#include "snoopdos.h"
#include "patches.h"

#define INVALID_HUNK		((USHORT)(-1))

#if 0
#define DB(s)	KPrintF(s)
#else
#define DB(s)
#endif

static UBYTE	   *BufferStart;		/* Ptr to start of our buffer		*/
static UBYTE	   *BufferEnd;			/* Ptr to end of our buffer			*/
static UBYTE	   *BufferCur;			/* Ptr to next free loc in buffer	*/
static ULONG		BufferSize;			/* Size of current buffer			*/

/*
 *		This is the mapping that assigns format ID's to the various
 *		fields we can output.
 */
FieldInit FieldTypes[] = {
	EF_ACTION,		'a',	10,		MSG_ACTION_COL,
	EF_CALLADDR,	'c',	8,		MSG_CALL_COL,
	EF_DATE,		'd',	9,		MSG_DATE_COL,
	EF_HUNKOFFSET,	'h',	11,		MSG_HUNK_COL,
	EF_PROCID,		'i',	8,		MSG_PROCESSID_COL,
	EF_FILENAME,	'n',	27,		MSG_FILENAME_COL,
	EF_OPTIONS,		'o',	7,		MSG_OPTIONS_COL,
	EF_PROCNAME,	'p',	18,		MSG_PROCNAME_COL,
	EF_RESULT,		'r',	4,		MSG_RESULT_COL,
	EF_SEGNAME,		's',	20,		MSG_SEGNAME_COL,
	EF_TIME,		't',	8,		MSG_TIME_COL,
	EF_COUNT,		'u',	5,		MSG_COUNT_COL,
	EF_END,			0,		0,		0
};

/*
 *		InitBuffers()
 *
 *		Initialises certain variables associated with the buffer routines.
 *		Must be called before any of the buffer functions are called.
 */
void InitBuffers(void)
{
	InitSemaphore(&BufSem);
	NewList(&EventList);
}

/*
 *		SetTotalBufferSize(size, alloctype)
 *
 *		This function is used to change the size of the buffer. If no buffer
 *		has yet been created, one is allocated. If there is not enough room
 *		to create a new buffer without freeing the existing buffer first,
 *		then FALSE is returned, _unless_ the alloctype parameter is
 *		SETBUF_FORCENEW, in which case it simply frees the existing buffer
 *		first, losing any existing history info.
 *
 *		In general, the old buffer's contents are copied across to the
 *		new buffer so that the user's history isn't destroyed.
 *
 *		The intention is that the caller tries to use this call with
 *		the tryalways flag set to SETBUF_KEEPOLD first; if that fails,
 *		then it can display a requester to the user saying that this will
 *		cause the existing buffer info to be lost permanently if you go
 *		ahead--Yes/No?  and then do a retry with alloctype set to
 *		SETBUF_FORCENEW if the user so chooses.
 *
 *		In any case, when allocating a new buffer, the routine will always
 *		allocate a buffer if possible, even if it can't allocate the full
 *		size requested.
 *
 *		Returns FALSE if there wasn't enough room to allocate the new buffer
 *		(the minimum buffer size is something like 4K.)
 *
 *		Note that if the size of the buffer is being reduced, the caller
 *		is responsible for updating the display to reflect the new status.
 *
 *		Note also that the whole idea of only freeing the buffer if there's
 *		no other option is great in principle; in practise, it turned out to
 *		be too much work to support copying buffers for such an infrequent
 *		operation, so we don't do it after all.
 */
int SetTotalBufferSize(ULONG newsize, int alloctype)
{
	UBYTE *oldbuf = BufferStart;
	ULONG oldsize = BufferSize;
	UBYTE *newbuf;

	ObtainSemaphore(&BufSem);
	ClearBuffer();		/* Clear the existing buffer first */

	/*
	 *		First, work out if we have enough memory to satisfy the request
	 *		without freeing our old buffer first. If we don't, and if
	 *		alloctype is SETBUF_KEEPOLD, then we fail immediately.
	 */
	if (newsize < MIN_BUF_SIZE)
		newsize = MIN_BUF_SIZE;

	newbuf = AllocMem(newsize, MEMF_ANY);
	if (!newbuf) {
		/*
		 *		No memory available -- we _may_ need to bomb out at this
		 *		point. If we didn't have a buffer already, then we
		 *		always go ahead and try and allocate some, regardless
		 *		of alloctype.
		 */
		if (oldbuf && alloctype == SETBUF_KEEPOLD) {
			ReleaseSemaphore(&BufSem);
			return (FALSE);
		}

		/*
		 *		Okay, try and allocate the memory even though it means
		 *		freeing up the old buffer first.
		 */
		if (oldbuf) {
			FreeMem(oldbuf, oldsize);
			oldbuf = NULL;
		}
		newbuf = AllocMem(newsize, MEMF_ANY);
		if (!newbuf) {
			/*
			 *		Couldn't allocate memory on second attempt. Finally,
			 *		we just grab the largest chunk we can and use that
			 *		instead.
			 */
			ULONG freesize;

			Forbid();
			freesize = AvailMem(MEMF_ANY | MEMF_LARGEST);
			if (freesize < MIN_BUF_SIZE) {
				Permit();
				ReleaseSemaphore(&BufSem);
				return (FALSE);
			}
			if (freesize < newsize)	/* freesize > newsize _is_ possible! */
				newsize = freesize;
			newbuf  = AllocMem(newsize, MEMF_ANY);
			Permit();
			if (!newbuf) {
				/*
				 *		Should never happen, but better safe than sorry
				 */
				ReleaseSemaphore(&BufSem);
				return (FALSE);
			}
		}
	}
	/*
	 *		Okay, we finally have some memory so initialise the global
	 *		buffer variables for use by everyone else.
	 */
	BufferStart = newbuf;
	BufferSize  = newsize;
	BufferEnd   = newbuf + newsize;
	BufferCur   = BufferStart;

	if (oldbuf != NULL) {
		// CopyEvents(newbuf, newsize, oldbuf, oldsize);
		FreeMem(oldbuf, oldsize);
	}
	NewList(&EventList);		/* Probably need to delete this eventually */
	ReleaseSemaphore(&BufSem);
	return (TRUE);
}

// void CopyEvents(UBYTE *newbuf, ULONG newsize,
//				UBYTE *oldbuf, ULONG oldsize) {}

/*
 *		ClearBuffer()
 *
 *		Clears the current buffer by a very simple process -- it simply
 *		erases the current list of linked items, and resets RealFirstSeq etc.
 *		to be the next available event number. This means that any events
 *		that were partially in progress will spot, on their completition,
 *		that their associated event number is now < RealFirstSeq, and so
 *		won't try and write into the now-cleared buffer, thus avoiding
 *		corruption.
 *
 *		BaseSeq is used to allow the new buffer count to commence from
 *		1 again, rather than keeping the old number (which might be
 *		into the hundreds by this stage!)
 *
 *		Note: we are a little bit naughty in some of the patches in that
 *		after allocating a brand new event, we sometimes write into it
 *		immediately _without_ semaphore protection (to fill in the
 *		initial details etc.) This is not terribly wise, but since there
 *		is never anything to deliberately cause a task switch, it's
 *		reasonably safe. Adding semaphore protection to all these cases
 *		would complicate things quite a bit.
 */
void ClearBuffer(void)
{
	ObtainSemaphore(&BufSem);
	Delay(5);	/* Just to be safe, let everyone else run for 0.1 seconds */

	NewList(&EventList);
	BufferCur = BufferStart;

	BaseSeq			=
	FirstSeq		=
	RealFirstSeq	=
	TopSeq			=
	LastDrawnTopSeq	=
	BottomSeq		=
	MaxScannedSeq	=
	EndSeq			=
	EndCompleteSeq	= NextSeq;

	ReleaseSemaphore(&BufSem);
}

/*
 *		CleanupBuffers()
 *
 *		Frees up the buffer on exit, along with any other pertinent
 *		resources that were allocated by this module.
 */
void CleanupBuffers(void)
{
	if (BufferStart) {
		ObtainSemaphore(&BufSem);
		FreeMem(BufferStart, BufferSize);
		if (BufferSize == 0)
			ShowError("Warning! BufferSize is zero for some reason!");
		BufferStart = NULL;
		BufferSize  = 0;
		NewList(&EventList);
		ReleaseSemaphore(&BufSem);
	}
}

/*
 *		GetNewEvent(stringsize)
 *
 *		Allocates a new event structure from the list from the buffer
 *		and returns a pointer to it. If necessary, one of the existing
 *		buffers will be flushed to make room for the new event.
 *
 *		The stringsize is the maximum amount of extra space to allocate
 *		after the end of the event to accomodate string storage. A pointer
 *		to this data area can be obtained by accessing the first location
 *		after the event itself. For example, GetNewEvent(20) would return
 *		an event with 20 additional data bytes after it. Note that this
 *		_includes_ any terminating zeros that may be present in the
 *		strings.
 */
Event *GetNewEvent(int stringsize)
{
	UBYTE *startev;
	ULONG totalsize;
	Event *ev;

	/* Calculate total size and ensure it's a longword multiple */
	totalsize = (sizeof(Event) + stringsize + 3) & ~3;

	if (BufferStart == NULL || totalsize > (MIN_BUF_SIZE/2))
		return (NULL);	/* Should never happen but doesn't hurt to check */

	DB(" [GNE-Go] ");
	ObtainSemaphore(&BufSem);
#if 0
	ev = (Event *)BufferStart;
	ReleaseSemaphore(&BufSem);
	return (ev);
#endif

	startev = HeadNode(&EventList);
	if (IsListEmpty(&EventList)) {
		/*
		 *		First time being called, so simply begin at the
		 *		start of the buffer.
		 */
		BufferCur = BufferStart;
	} else {
		/*
		 *		There are already some nodes. Try and allocate a new node,
		 *		flushing nodes from the start of the list as necessary.
		 */
		for (;;) {
			if (startev < BufferCur) {
				/*
				 *		From BufferCur to the end of the buffer is free space,
				 *		so we can check for a quick fit. If we get one, then
				 *		we go for it, otherwise we move BufferCur back to the
				 *		start of the buffer and start flushing events from
				 *		there.
				 */
				if (totalsize <= (BufferEnd - BufferCur))
					break;	/* Got it */
				BufferCur = BufferStart;	/* Else wrap to start of list */
			}
			/*
			 *		Now delete events from here to the end of the buffer until
			 *		we finally have enough room in the buffer. If we run off
			 *		the end of the buffer, let the main loop go around again
			 *		to reset everything.
			 */
			while (startev >= BufferCur && (startev - BufferCur) < totalsize) {
				RemHead(&EventList);
				if (IsListEmpty(&EventList)) {
					KPrintF("Uhoh --- list is empty and shouldn't be!\n");
					Delay(50);
					startev = BufferCur = BufferStart;
					break;
				}
				startev = HeadNode(&EventList);
			}
			if (startev > BufferCur)
				break;	/* Got it */
		}
	}
	ev		   = (Event *)BufferCur;
	BufferCur += totalsize;

	/*
	 *		Allocate our new event from the current buffer block (which
	 *		we are now assured will have enough space in it)
	 */
	ev->seqnum	= ++NextSeq;			/* Give it a unique sequence number */
	ev->status	= ES_CREATING;			/* Mark event as not-to-be-touched	*/
	ev->flags   = EFLG_NONE;			/* No date/segment lookup as yet	*/
	AddTail(&EventList, (Node *)ev);
	/*
	 *		Update current first seq num so patch code knows when an
	 *		event currently being created has become invalid
	 */
	RealFirstSeq = ((Event *)HeadNode(&EventList))->seqnum;
	DateStamp(&ev->datestamp);			/* Store current date				*/
	DB(" [GNEEnd] ");
	ReleaseSemaphore(&BufSem);
	return (ev);
}

/*
 *		ParseFormatString(formatstr, evformat, maxfields)
 *
 *		Parses a text format string containing a list of format identifiers
 *		(%d, %s, etc.) with optional field widths (%20s, %10d) into an
 *		internal list of formatting codes that can be quickly processed
 *		when displaying output.
 *
 *		formatstr points to the format string. evformat points to the
 *		EventFormat[] array to hold the output.
 *
 *		maxfields is the maximum number of format fields that will
 *		be recognised -- any more than this will be ignored. evformat[]
 *		must be able to hold at least maxfields elements. If a field is
 *		duplicated, only the first occurrance is recognised.
 *
 *		Returns the length any output produced using this format array will
 *		have (including separating spaces)
 */
int ParseFormatString(char *formatstr, EventFormat *evformat, int maxfields)
{
	int evindex = 0;
	int totlen  = 0;
	char *p     = formatstr;

	while (*p) {
		int width = 0;
		int i;
		char type;
		char ch;

		if (*p++ != '%')
			continue;

		/*
		 *		Got a format specifier, so now parse it.
		 *
		 *		We ignore any negative prefix -- in the real printf,
		 *		it means left-align this field, and all our fields are
		 *		left-aligned by default anyway.
		 */
		if (*p == '-')
			p++;
		while (*p >= '0' && *p <= '9') {
			width = (width * 10) + *p - '0';
			p++;
		}
		if (!*p)
			break;

		ch = *p++;
		if (ch >= 'A' && ch <= 'Z')
			ch |= 0x20;

		for (i = 0; FieldTypes[i].type != EF_END; i++) {
			if (FieldTypes[i].idchar == ch)
				break;
		}
		type = FieldTypes[i].type;
		if (type != EF_END) {
			/*
			 *		Matched a field. Now try and insert it. But first,
			 *		make sure we don't have a duplicate.
			 */
			int j;

			for (j = 0; j < evindex; j++)
				if (evformat[j].type == type)	/* Got a duplicate */
					break;

			if (j < evindex)		/* Skip over duplicates */
				continue;	

			if (width == 0)
				width = FieldTypes[i].defwidth;

			if (width < 1)				width = 1;
			if (width > MAX_FIELD_LEN)	width = MAX_FIELD_LEN;

			evformat[evindex].type		 = type;
			evformat[evindex].width		 = width;
			evformat[evindex].titlemsgid = FieldTypes[i].titlemsgid;
			totlen += width + 1;
			evindex++;
			if (evindex >= (maxfields-1))
				break;
		}
	}
	evformat[evindex].type = EF_END;
	if (totlen)				/* Compensate for the extra 'space' we counted */
		totlen--;

	return (totlen);
}

/*
 *		BuildFormatString(evformat, formatstr, maxlen)
 *
 *		Converts an existing event format array into an ascii string
 *		corresponding to the format that can be parsed by ParseFormatString.
 *		The string is guaranteed to be at most maxlen chars in length
 *		(including terminating \0);
 */
void BuildFormatString(EventFormat *evformat, char *formatstr, int maxlen)
{
	char *p	  = formatstr;
	char *end = formatstr + maxlen - 6;	/* Max length of format element is 5 */

	while (evformat->type != EF_END) {
		int j;

		if (p >= end)	/* Never exceed string length */
			break;
		/*
		 *		Find the event type in our mapping array so that we can
		 *		determine the default width. This lets us choose not
		 *		to include the width in the ascii field, for neatness.
		 */
		for (j = 0; FieldTypes[j].type != evformat->type; j++)
			;
		*p++ = '%';
		if (FieldTypes[j].defwidth != evformat->width) {
			mysprintf(p, "%ld", evformat->width);
			p += strlen(p);
		}
		*p++ = FieldTypes[j].idchar;
		*p++ = ' ';	/* Space out entries for neatness */
		evformat++;
	}
	p[-1] = '\0';	/* Replace final space with a terminator instead. */
}

/*
 *		ltoa(buffer, val, numdigits)
 *		ltoap(buffer, val, numdigits)
 *
 *		Converts the given value to an ascii hex string of up to numdigits
 *		(with leading zeros). No zero termination is performed. The output
 *		is stored in the first numdigits characters of buffer.
 *
 *		ltoap is similar, except that it pads leading zeros with spaces.
 *
 *		Returns a pointer to the buffer.
 */
char *ltoa(char *buffer, unsigned long val, int numdigits)
{
	static char HexDigits[] = "0123456789ABCDEF";
	char *p = buffer + numdigits - 1;

	while (p >= buffer) {
		*p-- = HexDigits[val & 0x0F];
		val >>= 4;
	}
	return (buffer);
}

char *ltoap(char *buffer, unsigned long val, int numdigits)
{
	static char HexDigits[] = "0123456789ABCDEF";
	char *p = buffer + numdigits - 1;

	do {
		*p-- = HexDigits[val & 0x0F];
		val >>= 4;
	} while (val && p >= buffer);

	while (p >= buffer)
		*p-- = ' ';

	return (buffer);
}

/*
 *		SetEventDateStr(event)
 *
 *		This function converts the datestamp in the passed event into a date
 *		and time string, also stored in the event.
 */
void SetEventDateStr(Event *ev)
{
	struct DateTime datetime;

	datetime.dat_Stamp		= ev->datestamp;
	datetime.dat_Format		= FORMAT_DOS;
	datetime.dat_Flags		= 0;
	datetime.dat_StrDay		= NULL;
	datetime.dat_StrDate	= ev->date;
	datetime.dat_StrTime	= ev->time;
	DateToStr(&datetime);
}

/*
 *		CheckSegTracker()
 *
 *		Checks to see if SegTracker is loaded and sets the SegTracker
 *		global variable accordingly. Should be called every now and
 *		again to keep us up to date (e.g. whenever a new window is
 *		opened).
 */
void CheckSegTracker(void)
{
	SegTrackerActive = (FindSemaphore("SegTracker") != NULL);
}

/*
 *		SetEventSegmentStr(event)
 *
 *		This function converts the calladdr in the passed event into a segment
 *		name and hunk/offset pair if SegTracker is loaded, or into an invalid
 *		string if SegTracker is not loaded.
 *
 *		See the Enforcer/Segtracker documentation (from Michael Sinz) for
 *		more info on how this works.
 *
 *		Note that if the passed-in event->segname is NULL, then it will
 *		be reset to an "unknown module" string and no attempt to locate
 *		the module will be made. It is thus imperative that the _caller_
 *		only calls this function once for each event. The easiest way
 *		to ensure this is to use the EFLG_DONESEG flag in the ev->flags
 *		register to track whether the call has been made or not.
 *
 *		New: we now detect ROM addresses and search the resident module
 *			 list ourselves looking for the module that contains it.
 */
void SetEventSegmentStr(Event *ev)
{
	typedef char (*__asm SegTrack(reg_a0 ULONG,reg_a1 ULONG *,reg_a2 ULONG *));

	static struct {
		Semaphore	seg_Semaphore;
		SegTrack 	*seg_Find;
	} *segsem;

	ULONG hunk;
	ULONG offset;
	char *segname = NULL;

	ev->hunk = INVALID_HUNK;
	if (ev->segname == NULL) {
		ev->segname	= "Unknown module";
		return;
	}

	Forbid();
	if (!segsem)
		segsem = (void *)FindSemaphore("SegTracker");

	if (segsem)
		segname = segsem->seg_Find(ev->calladdr, &hunk, &offset);

	if (segname) {
		strncpy(ev->segname, segname, MAX_SEGTRACKER_LEN);
		ev->segname[MAX_SEGTRACKER_LEN-1] = 0;
		ev->hunk   = hunk;
		ev->offset = offset;
	} else {
		if (ev->calladdr >= RomStart && ev->calladdr <= RomEnd) {
			/*
			 *		Let's search the resident list for it ourselves.
			 *		and see if we can't do any better.
			 */
			struct Resident *res;
			ULONG *pres = (ULONG *)SysBase->ResModules;
			UBYTE *p;

			while (*pres) {
				if (*pres & 0x80000000) {
					pres = (ULONG *)(*pres & 0x7FFFFFFF);
					continue;
				}
				res = (struct Resident *)*pres++;
				if (ev->calladdr >= (ULONG)res
								&& ev->calladdr <= (ULONG)res->rt_EndSkip) {
					ev->hunk    = 0;
					ev->offset  = ev->calladdr - (ULONG)res;
					strcpy(ev->segname, "ROM: ");
					strncat(ev->segname + 5, res->rt_IdString,
										     MAX_SEGTRACKER_LEN - 6);
					ev->segname[MAX_SEGTRACKER_LEN-1] = 0;
					/*
					 *		Now filter out any remaining carriage returns
					 *		and linefeeds, since they look ugly when printed
					 *		We also convert any open brackets into '\0's
					 *		since these are just dates which we don't care
					 *		about -- it looks neater to just display the
					 *		module name and version.
					 */
					for (p = ev->segname; *p; p++) {
						if (*p < ' ')
							*p = ' ';
						if (*p == '(')
							*p = '\0';
					}
					break;
				}
			}
		}
		if (ev->hunk == INVALID_HUNK)
			ev->segname = MSG(MSG_SEG_MODULE_NOT_FOUND);
	}
	Permit();
}

/*
 *		FormatEvent(eventformat, event, outputstr, start, end)
 *
 *		Formats the specified event according to the passed in format
 *		array. Only that portion of the fully formatted event which
 *		lies from the 'start' to 'end' characters is produced, and
 *		output always starts at the beginning of the outputstr.
 *
 *		For example, a start of 4 and end of 8 will produce a formatted
 *		string of exactly 5 characters.
 *
 *		Each entry in the eventformat array is decoded, and text which
 *		corresponds to the entry type is copied to the output string. If
 *		the text is longer than the entry width setting, it is truncated;
 *		if shorter, it is padded with spaces.
 *
 *		Each event is separated by one space character.
 *
 *		If the event pointer is NULL, then the title headings are returned
 *		instead of the event contents.
 */
void FormatEvent(EventFormat *eventformat, Event *event,
				 char *outstr, int start, int end)
{
	static char hexbuf8[]  = "00000000";
	static char hexbuf13[] = "0000:00000000";
	static char countbuf[] = "             ";

	EventFormat *ef = eventformat;
	int savechar = 0;
	char *savep;
	char *p;
	int col = 0;

	end++;		/* Make exclusive rather than inclusive */

	while (ef->type != EF_END && col < end) {
		int width = ef->width;

		/*
		 *		First skip over any entries that fall before desired section
		 */
		if ((col + width) < start) {
			col += width + 1;
			if (col > start)
				*outstr++ = ' ';	/* Add leading space */
			ef++;
			continue;
		}

		/*
		 *		Now parse our current entry
		 */
		if (event) {
			switch (ef->type) {

			case EF_PROCNAME: 	p = event->procname;					break;
			case EF_ACTION:		p = event->action;						break;
			case EF_OPTIONS:	p = event->options;						break;
			case EF_RESULT:		p = event->result;						break;
			case EF_CALLADDR:
				p = ltoap(hexbuf8, event->calladdr, 8);
				if (*p == ' ')
					p++;
				break;

			case EF_PROCID:
				p = ltoap(hexbuf8, event->processid,8);
				if (*p == ' ')
					p++;
				break;

  			case EF_FILENAME:
			{
				/*
				 *		This is a little trickier since we allow the user
				 *		to view it left-aligned or right-aligned. For
				 *		right-aligned, we temporarily replace the first char
				 *		with a « to indicate there are additional characters
				 *		to the left, then restore it after we've copied the
				 *		string data later on. This is much quicker (and
				 *		safer) than copying the entire string to a temporary
				 *		just so we can patch a single character of it.
				 */
				int len;

				p = event->filename;
				if (RightAligned) {
					len = strlen(p);
					if (len > width) {
						p += len - width;
						if (width > 1) {
							savep    = p;
							savechar = *p;
							*p       = '«';
						}
					}
				}
				break;
			}

			case EF_DATE:
				if ((event->flags & EFLG_DONEDATE) == 0) {
					SetEventDateStr(event);
					event->flags |= EFLG_DONEDATE;
				}
				p = event->date;
				break;

			case EF_TIME:
				if ((event->flags & EFLG_DONEDATE) == 0) {
					SetEventDateStr(event);
					event->flags |= EFLG_DONEDATE;
				}
				p = event->time;
				break;

			case EF_SEGNAME:
				if ((event->flags & EFLG_DONESEG) == 0) {
					SetEventSegmentStr(event);
					event->flags |= EFLG_DONESEG;
				}
				p = event->segname;
				break;

			case EF_COUNT:
				/*
				 *		We subtract BaseSeq from the event number when
				 *		displaying it so that we have a convenient way of
				 *		making the event number appear to return to 1,
				 *		while internally still ensuring that the event
				 *		number is ALWAYS monotonically increasing, even
				 *		across buffer clears and the like.
				 */
				mysprintf(countbuf, "%ld", event->seqnum - BaseSeq);
				p = countbuf;
				break;

			case EF_HUNKOFFSET:
				if ((event->flags & EFLG_DONESEG) == 0) {
					SetEventSegmentStr(event);
					event->flags |= EFLG_DONESEG;
				}
				if (event->hunk == INVALID_HUNK) {
					/*
					 *		If we couldn't locate the module address,
					 *		then don't bother printing the hunk/offset
					 *		info since it will only be zero anyway.
					 */
					p = "";	/* Couldn't find module so don't print hunk addr */
				} else {
					/*
					 *		Only output 6 digits of offset and 2 digits
					 *		of hunk, but arrange that we can handle a
					 *		full 8 / 4 combination if necessary
					 */
					p = ltoa(hexbuf13+7, event->offset, 6);
					*--p = ':';
					p = ltoap(p-2, event->hunk, 2);
				}
				break;

			default:
				p = "<Invalid>";
				break;
			}
		} else {
			/*
			 *		Format column headings instead
			 */
			p = MSG(ef->titlemsgid);
		}

		/*
		 *		Okay, so now we have p pointing to our string. We now need to
		 *		copy a sufficient number of characters into the string to
		 *		fulfill our need.
		 */
		if (col < start) {
			/*
			 *		Our first special case is where we have to skip over some of
			 *		the early characters, i.e. chars to left are clipped.
			 */
			while (col < start && *p) {
				col++;
				width--;
				p++;
			}
			if (col < start) {
				/*
				 *		Ran out of characters in our string, so pretend we
				 *		have a null string and let the following code pad
				 *		the remaining width with spaces.
				 */
				width -= (start - col);
				col    = start;
			}
		}

		/*
		 *		Now copy characters intact into string
		 */
		if ((col + width) > end) {
			/*
			 *		This field needs to be clipped. We do this quite simply
			 *		by adjusting the width to be the remaining number of
			 *		chars in the string.
			 */
			width = end - col;
		}

		/*
		 *		Now copy width chars from our string to the output buffer,
		 *		padding with spaces as necessary.
		 */
		while (width && *p) {
			*outstr++ = *p++;
			width--;
			col++;
		}
		if (width) {
			memset(outstr, ' ', width);
			outstr += width;
			col    += width;
		}
		*outstr++ = ' ';			/* Space in between output fields	*/
		col++;						/* onto next column					*/
		ef++;						/* Onto the next format field		*/
		/*
		 *		Finally, restore the character we replaced with « earlier
		 *		(if any)
		 */
		if (savechar) {
			*savep   = savechar;
			savechar = 0;
		}
	}

	/*
	 *		Okay, we've generated the string as requested. Now check to see if
	 *		we need to pad the remainder of the string with spaces (i.e. the
	 *		number of fields listed wasn't as wide as the whole window).
	 *
	 *		Ideally, we will never be passed in a start/end pair wider than
	 *		the width of the formatted output, but you never know...
	 */
	if (col <= end) {
		memset(outstr, ' ', end-col+1);
		outstr += end-col+1;
	}
	outstr[-1] = '\0';		/* Remove final terminating space */
}

/*
 *		UnderlineTitles(eventformat, outstr, underchar)
 *
 *		This function creates a string of underlines which matches the
 *		event headings in the passed event format, such that if the
 *		headings were printed out in full, the underline string would
 *		line up properly. underchar is the char used for underlining.
 *
 *		The reason we can't just take the obvious approach and generate
 *		a title string, then convert all non-space chars to minus, is
 *		because we can have titles like "Process Name" and we want the
 *		underline to be continuous, not break between process and name.
 *
 *		Returns a pointer to the newly formatted string (outstr). Outstr
 *		must have room to store the entire width, as defined by the
 *		event format.
 */
char *UnderlineTitles(EventFormat *ef, char *outstr, char underchar)
{
	char *p = outstr;

	while (ef->type != EF_END) {
		int width    = ef->width;
		int titleid  = ef->titlemsgid;
		int titlelen = strlen(MSG(titleid));

		if (titlelen > width)
			titlelen = width;

		memset(p, underchar, titlelen);
		p     += titlelen;
		width -= titlelen-1;		/* Include an extra space between cols */
		if (width) {
			memset(p, ' ', width);
			p += width;
		}
		ef++;
	}
	*--p = 0;						/* Replace final space with a null */
	return (outstr);
}

#if TESTING
/*
 *		TestEventFields()
 *
 *		Simple test function to check out our format conversion routines
 */
void TestEventFields(void)
{
	static char inline[200];
	static char formatstr[200];
	static EventFormat evformat[50];

	while (gets(inline) != NULL) {
		int len;

		if (*inline == 'q')
			break;

		len = ParseFormatString(inline, evformat, 50);
		BuildFormatString(evformat, formatstr, 200);

		printf("Converted string: >>%s<<, length = %d\n", formatstr, len);
	}
}

/*
 *		TestFormat
 *
 *		Test our text formatting routines
 */
void TestFormat()
{
	static char inline[200];
	static char formatstr[200];
	static EventFormat evformat[50];
	static char outstr[500];
	Event *ev;
	int showtitles = 0;

	for (;;) {
		int len;

		printf("Enter a format string (q to quit): ");
		gets(inline);
		if (*inline == 'q')
			return;

		len = ParseFormatString(inline, evformat, 50);
		BuildFormatString(evformat, formatstr, 200);
		printf("Actual string is >> %s << (%d chars)\n", formatstr, len);

		/*
		 *		Get ourselves a new event
		 */
		ev = GetNewEvent(0);
		if (!ev) {
			printf("Uhoh! Couldn't allocate event!\n");
			continue;
		}
		ev->procname  = "[ 1] SAS/C compiler";
		ev->filename  = "s:startup-sequence";
		ev->action    = "Open";
		ev->result    = "Okay";
		ev->calladdr  = 0x12345678;
		ev->processid = 0xDEADBEEF;
		DateStamp(&ev->datestamp);

		for (;;) {
			int start, end;

			printf("Now enter start,end values (-1 to quit, s to toggle): ");
			gets(inline);
			if (*inline == 'q')
				return;
			if (*inline == 's') {
				showtitles = !showtitles;
				printf("Now printing %s\n", showtitles ? "titles" : "contents");
				continue;
			}
			sscanf(inline, "%d,%d", &start, &end);
			if (start == -1)
				break;

			if (showtitles)
				FormatEvent(evformat, NULL, outstr, start, end);
			else
				FormatEvent(evformat, ev, outstr, start, end);
			printf("|%s|\n", outstr);
		}
	}
}

/*
 *		TestEvents
 *
 *		Creates some random events, then prints them out
 */
void TestEvents(void)
{
	int howmany = 0;
	int i;

	printf("Generate how many events? ");
	scanf("%d", &howmany);

	for (i = 0; i < howmany; i++) {
		Event *ev = GetNewEvent((rand() & 63));

		printf("Event head: %8x   Event new: %8x\n",
				(UBYTE *)HeadNode(&EventList) - BufferStart,
				(UBYTE *)ev - BufferStart);
	}
}
#endif