/* * BUFFER.C vi:ts=4 * * Copyright (c) Eddy Carroll, September 1994. * Updated 5.3.2000 Thomas Richter, THOR * * 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)) { /* This really shouldn't be printed unless * debugging is turned on. Fixed, * THOR */ DB("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 = ""; 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