fix line endings

1 files changed, 1127 insertions, 1127 deletions

diff --git a/generic/tclNotify.c b/generic/tclNotify.c
index c5a0c3a..56dca6a 100644
--- a/generic/tclNotify.c
+++ b/generic/tclNotify.c
@@ -1,1127 +1,1127 @@
-/*

- * tclNotify.c --

- *

- *	This file implements the generic portion of the Tcl notifier. The

- *	notifier is lowest-level part of the event system. It manages an event

- *	queue that holds Tcl_Event structures. The platform specific portion

- *	of the notifier is defined in the tcl*Notify.c files in each platform

- *	directory.

- *

- * Copyright (c) 1995-1997 Sun Microsystems, Inc.

- * Copyright (c) 1998 by Scriptics Corporation.

- * Copyright (c) 2003 by Kevin B. Kenny.  All rights reserved.

- *

- * See the file "license.terms" for information on usage and redistribution of

- * this file, and for a DISCLAIMER OF ALL WARRANTIES.

- *

- * RCS: @(#) $Id: tclNotify.c,v 1.21 2006/09/25 00:09:34 dkf Exp $

- */

-

-#include "tclInt.h"

-

-extern TclStubs tclStubs;

-

-/*

- * For each event source (created with Tcl_CreateEventSource) there is a

- * structure of the following type:

- */

-

-typedef struct EventSource {

-    Tcl_EventSetupProc *setupProc;

-    Tcl_EventCheckProc *checkProc;

-    ClientData clientData;

-    struct EventSource *nextPtr;

-} EventSource;

-

-/*

- * The following structure keeps track of the state of the notifier on a

- * per-thread basis. The first three elements keep track of the event queue.

- * In addition to the first (next to be serviced) and last events in the

- * queue, we keep track of a "marker" event. This provides a simple priority

- * mechanism whereby events can be inserted at the front of the queue but

- * behind all other high-priority events already in the queue (this is used

- * for things like a sequence of Enter and Leave events generated during a

- * grab in Tk). These elements are protected by the queueMutex so that any

- * thread can queue an event on any notifier. Note that all of the values in

- * this structure will be initialized to 0.

- */

-

-typedef struct ThreadSpecificData {

-    Tcl_Event *firstEventPtr;	/* First pending event, or NULL if none. */

-    Tcl_Event *lastEventPtr;	/* Last pending event, or NULL if none. */

-    Tcl_Event *markerEventPtr;	/* Last high-priority event in queue, or NULL

-				 * if none. */

-    Tcl_Mutex queueMutex;	/* Mutex to protect access to the previous

-				 * three fields. */

-    int serviceMode;		/* One of TCL_SERVICE_NONE or

-				 * TCL_SERVICE_ALL. */

-    int blockTimeSet;		/* 0 means there is no maximum block time:

-				 * block forever. */

-    Tcl_Time blockTime;		/* If blockTimeSet is 1, gives the maximum

-				 * elapsed time for the next block. */

-    int inTraversal;		/* 1 if Tcl_SetMaxBlockTime is being called

-				 * during an event source traversal. */

-    EventSource *firstEventSourcePtr;

-				/* Pointer to first event source in list of

-				 * event sources for this thread. */

-    Tcl_ThreadId threadId;	/* Thread that owns this notifier instance. */

-    ClientData clientData;	/* Opaque handle for platform specific

-				 * notifier. */

-    int initialized;		/* 1 if notifier has been initialized. */

-    struct ThreadSpecificData *nextPtr;

-				/* Next notifier in global list of notifiers.

-				 * Access is controlled by the listLock global

-				 * mutex. */

-} ThreadSpecificData;

-

-static Tcl_ThreadDataKey dataKey;

-

-/*

- * Global list of notifiers. Access to this list is controlled by the listLock

- * mutex. If this becomes a performance bottleneck, this could be replaced

- * with a hashtable.

- */

-

-static ThreadSpecificData *firstNotifierPtr = NULL;

-TCL_DECLARE_MUTEX(listLock)

-

-/*

- * Declarations for routines used only in this file.

- */

-

-static void		QueueEvent(ThreadSpecificData *tsdPtr,

-			    Tcl_Event* evPtr, Tcl_QueuePosition position);

-

-/*

- *----------------------------------------------------------------------

- *

- * TclInitNotifier --

- *

- *	Initialize the thread local data structures for the notifier

- *	subsystem.

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	Adds the current thread to the global list of notifiers.

- *

- *----------------------------------------------------------------------

- */

-

-void

-TclInitNotifier(void)

-{

-    ThreadSpecificData *tsdPtr;

-    Tcl_ThreadId threadId = Tcl_GetCurrentThread();

-

-    Tcl_MutexLock(&listLock);

-    for (tsdPtr = firstNotifierPtr; tsdPtr && tsdPtr->threadId != threadId;

-	    tsdPtr = tsdPtr->nextPtr) {

-	/* Empty loop body. */

-    }

-

-    if (NULL == tsdPtr) {

-	/*

-	 * Notifier not yet initialized in this thread.

-	 */

-

-	tsdPtr = TCL_TSD_INIT(&dataKey);

-	tsdPtr->threadId = threadId;

-	tsdPtr->clientData = tclStubs.tcl_InitNotifier();

-	tsdPtr->initialized = 1;

-	tsdPtr->nextPtr = firstNotifierPtr;

-	firstNotifierPtr = tsdPtr;

-    }

-    Tcl_MutexUnlock(&listLock);

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * TclFinalizeNotifier --

- *

- *	Finalize the thread local data structures for the notifier subsystem.

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	Removes the notifier associated with the current thread from the

- *	global notifier list. This is done only if the notifier was

- *	initialized for this thread by call to TclInitNotifier(). This is

- *	always true for threads which have been seeded with an Tcl

- *	interpreter, since the call to Tcl_CreateInterp will, among other

- *	things, call TclInitializeSubsystems() and this one will, in turn,

- *	call the TclInitNotifier() for the thread. For threads created without

- *	the Tcl interpreter, though, nobody is explicitly nor implicitly

- *	calling the TclInitNotifier hence, TclFinalizeNotifier should not be

- *	performed at all.

- *

- *----------------------------------------------------------------------

- */

-

-void

-TclFinalizeNotifier(void)

-{

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-    ThreadSpecificData **prevPtrPtr;

-    Tcl_Event *evPtr, *hold;

-

-    if (!tsdPtr->initialized) {

-	return;		/* Notifier not initialized for the current thread */

-    }

-

-    Tcl_MutexLock(&(tsdPtr->queueMutex));

-    for (evPtr = tsdPtr->firstEventPtr; evPtr != NULL; ) {

-	hold = evPtr;

-	evPtr = evPtr->nextPtr;

-	ckfree((char *) hold);

-    }

-    tsdPtr->firstEventPtr = NULL;

-    tsdPtr->lastEventPtr = NULL;

-    Tcl_MutexUnlock(&(tsdPtr->queueMutex));

-

-    Tcl_MutexLock(&listLock);

-

-    if (tclStubs.tcl_FinalizeNotifier) {

-	tclStubs.tcl_FinalizeNotifier(tsdPtr->clientData);

-    }

-    Tcl_MutexFinalize(&(tsdPtr->queueMutex));

-    for (prevPtrPtr = &firstNotifierPtr; *prevPtrPtr != NULL;

-	    prevPtrPtr = &((*prevPtrPtr)->nextPtr)) {

-	if (*prevPtrPtr == tsdPtr) {

-	    *prevPtrPtr = tsdPtr->nextPtr;

-	    break;

-	}

-    }

-    tsdPtr->initialized = 0;

-

-    Tcl_MutexUnlock(&listLock);

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_SetNotifier --

- *

- *	Install a set of alternate functions for use with the notifier. In

- *	particular, this can be used to install the Xt-based notifier for use

- *	with the Browser plugin.

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	Overstomps part of the stub vector. This relies on hooks added to the

- *	default functions in case those are called directly (i.e., not through

- *	the stub table.)

- *

- *----------------------------------------------------------------------

- */

-

-void

-Tcl_SetNotifier(

-    Tcl_NotifierProcs *notifierProcPtr)

-{

-#if !defined(__WIN32__) /* UNIX */

-    tclStubs.tcl_CreateFileHandler = notifierProcPtr->createFileHandlerProc;

-    tclStubs.tcl_DeleteFileHandler = notifierProcPtr->deleteFileHandlerProc;

-#endif

-    tclStubs.tcl_SetTimer = notifierProcPtr->setTimerProc;

-    tclStubs.tcl_WaitForEvent = notifierProcPtr->waitForEventProc;

-    tclStubs.tcl_InitNotifier = notifierProcPtr->initNotifierProc;

-    tclStubs.tcl_FinalizeNotifier = notifierProcPtr->finalizeNotifierProc;

-    tclStubs.tcl_AlertNotifier = notifierProcPtr->alertNotifierProc;

-    tclStubs.tcl_ServiceModeHook = notifierProcPtr->serviceModeHookProc;

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_CreateEventSource --

- *

- *	This function is invoked to create a new source of events. The source

- *	is identified by a function that gets invoked during Tcl_DoOneEvent to

- *	check for events on that source and queue them.

- *

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	SetupProc and checkProc will be invoked each time that Tcl_DoOneEvent

- *	runs out of things to do. SetupProc will be invoked before

- *	Tcl_DoOneEvent calls select or whatever else it uses to wait for

- *	events. SetupProc typically calls functions like Tcl_SetMaxBlockTime

- *	to indicate what to wait for.

- *

- *	CheckProc is called after select or whatever operation was actually

- *	used to wait. It figures out whether anything interesting actually

- *	happened (e.g. by calling Tcl_AsyncReady), and then calls

- *	Tcl_QueueEvent to queue any events that are ready.

- *

- *	Each of these functions is passed two arguments, e.g.

- *		(*checkProc)(ClientData clientData, int flags));

- *	ClientData is the same as the clientData argument here, and flags is a

- *	combination of things like TCL_FILE_EVENTS that indicates what events

- *	are of interest: setupProc and checkProc use flags to figure out

- *	whether their events are relevant or not.

- *

- *----------------------------------------------------------------------

- */

-

-void

-Tcl_CreateEventSource(

-    Tcl_EventSetupProc *setupProc,

-				/* Function to invoke to figure out what to

-				 * wait for. */

-    Tcl_EventCheckProc *checkProc,

-				/* Function to call after waiting to see what

-				 * happened. */

-    ClientData clientData)	/* One-word argument to pass to setupProc and

-				 * checkProc. */

-{

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-    EventSource *sourcePtr = (EventSource *) ckalloc(sizeof(EventSource));

-

-    sourcePtr->setupProc = setupProc;

-    sourcePtr->checkProc = checkProc;

-    sourcePtr->clientData = clientData;

-    sourcePtr->nextPtr = tsdPtr->firstEventSourcePtr;

-    tsdPtr->firstEventSourcePtr = sourcePtr;

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_DeleteEventSource --

- *

- *	This function is invoked to delete the source of events given by proc

- *	and clientData.

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	The given event source is cancelled, so its function will never again

- *	be called. If no such source exists, nothing happens.

- *

- *----------------------------------------------------------------------

- */

-

-void

-Tcl_DeleteEventSource(

-    Tcl_EventSetupProc *setupProc,

-				/* Function to invoke to figure out what to

-				 * wait for. */

-    Tcl_EventCheckProc *checkProc,

-				/* Function to call after waiting to see what

-				 * happened. */

-    ClientData clientData)	/* One-word argument to pass to setupProc and

-				 * checkProc. */

-{

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-    EventSource *sourcePtr, *prevPtr;

-

-    for (sourcePtr = tsdPtr->firstEventSourcePtr, prevPtr = NULL;

-	    sourcePtr != NULL;

-	    prevPtr = sourcePtr, sourcePtr = sourcePtr->nextPtr) {

-	if ((sourcePtr->setupProc != setupProc)

-		|| (sourcePtr->checkProc != checkProc)

-		|| (sourcePtr->clientData != clientData)) {

-	    continue;

-	}

-	if (prevPtr == NULL) {

-	    tsdPtr->firstEventSourcePtr = sourcePtr->nextPtr;

-	} else {

-	    prevPtr->nextPtr = sourcePtr->nextPtr;

-	}

-	ckfree((char *) sourcePtr);

-	return;

-    }

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_QueueEvent --

- *

- *	Queue an event on the event queue associated with the current thread.

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	None.

- *

- *----------------------------------------------------------------------

- */

-

-void

-Tcl_QueueEvent(

-    Tcl_Event* evPtr,		/* Event to add to queue. The storage space

-				 * must have been allocated the caller with

-				 * malloc (ckalloc), and it becomes the

-				 * property of the event queue. It will be

-				 * freed after the event has been handled. */

-    Tcl_QueuePosition position)	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,

-				 * TCL_QUEUE_MARK. */

-{

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-    QueueEvent(tsdPtr, evPtr, position);

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_ThreadQueueEvent --

- *

- *	Queue an event on the specified thread's event queue.

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	None.

- *

- *----------------------------------------------------------------------

- */

-

-void

-Tcl_ThreadQueueEvent(

-    Tcl_ThreadId threadId,	/* Identifier for thread to use. */

-    Tcl_Event *evPtr,		/* Event to add to queue. The storage space

-				 * must have been allocated the caller with

-				 * malloc (ckalloc), and it becomes the

-				 * property of the event queue. It will be

-				 * freed after the event has been handled. */

-    Tcl_QueuePosition position)	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,

-				 * TCL_QUEUE_MARK. */

-{

-    ThreadSpecificData *tsdPtr;

-

-    /*

-     * Find the notifier associated with the specified thread.

-     */

-

-    Tcl_MutexLock(&listLock);

-    for (tsdPtr = firstNotifierPtr; tsdPtr && tsdPtr->threadId != threadId;

-	    tsdPtr = tsdPtr->nextPtr) {

-	/* Empty loop body. */

-    }

-

-    /*

-     * Queue the event if there was a notifier associated with the thread.

-     */

-

-    if (tsdPtr) {

-	QueueEvent(tsdPtr, evPtr, position);

-    }

-    Tcl_MutexUnlock(&listLock);

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * QueueEvent --

- *

- *	Insert an event into the specified thread's event queue at one of

- *	three positions: the head, the tail, or before a floating marker.

- *	Events inserted before the marker will be processed in first-in-

- *	first-out order, but before any events inserted at the tail of the

- *	queue. Events inserted at the head of the queue will be processed in

- *	last-in-first-out order.

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	None.

- *

- *----------------------------------------------------------------------

- */

-

-static void

-QueueEvent(

-    ThreadSpecificData *tsdPtr,	/* Handle to thread local data that indicates

-				 * which event queue to use. */

-    Tcl_Event *evPtr,		/* Event to add to queue.  The storage space

-				 * must have been allocated the caller with

-				 * malloc (ckalloc), and it becomes the

-				 * property of the event queue. It will be

-				 * freed after the event has been handled. */

-    Tcl_QueuePosition position)	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,

-				 * TCL_QUEUE_MARK. */

-{

-    Tcl_MutexLock(&(tsdPtr->queueMutex));

-    if (position == TCL_QUEUE_TAIL) {

-	/*

-	 * Append the event on the end of the queue.

-	 */

-

-	evPtr->nextPtr = NULL;

-	if (tsdPtr->firstEventPtr == NULL) {

-	    tsdPtr->firstEventPtr = evPtr;

-	} else {

-	    tsdPtr->lastEventPtr->nextPtr = evPtr;

-	}

-	tsdPtr->lastEventPtr = evPtr;

-    } else if (position == TCL_QUEUE_HEAD) {

-	/*

-	 * Push the event on the head of the queue.

-	 */

-

-	evPtr->nextPtr = tsdPtr->firstEventPtr;

-	if (tsdPtr->firstEventPtr == NULL) {

-	    tsdPtr->lastEventPtr = evPtr;

-	}

-	tsdPtr->firstEventPtr = evPtr;

-    } else if (position == TCL_QUEUE_MARK) {

-	/*

-	 * Insert the event after the current marker event and advance the

-	 * marker to the new event.

-	 */

-

-	if (tsdPtr->markerEventPtr == NULL) {

-	    evPtr->nextPtr = tsdPtr->firstEventPtr;

-	    tsdPtr->firstEventPtr = evPtr;

-	} else {

-	    evPtr->nextPtr = tsdPtr->markerEventPtr->nextPtr;

-	    tsdPtr->markerEventPtr->nextPtr = evPtr;

-	}

-	tsdPtr->markerEventPtr = evPtr;

-	if (evPtr->nextPtr == NULL) {

-	    tsdPtr->lastEventPtr = evPtr;

-	}

-    }

-    Tcl_MutexUnlock(&(tsdPtr->queueMutex));

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_DeleteEvents --

- *

- *	Calls a function for each event in the queue and deletes those for

- *	which the function returns 1. Events for which the function returns 0

- *	are left in the queue. Operates on the queue associated with the

- *	current thread.

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	Potentially removes one or more events from the event queue.

- *

- *----------------------------------------------------------------------

- */

-

-void

-Tcl_DeleteEvents(

-    Tcl_EventDeleteProc *proc,	/* The function to call. */

-    ClientData clientData)    	/* The type-specific data. */

-{

-    Tcl_Event *evPtr, *prevPtr, *hold;

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-

-    Tcl_MutexLock(&(tsdPtr->queueMutex));

-    for (prevPtr=NULL, evPtr=tsdPtr->firstEventPtr; evPtr!=NULL; ) {

-	if ((*proc) (evPtr, clientData) == 1) {

-	    if (tsdPtr->firstEventPtr == evPtr) {

-		tsdPtr->firstEventPtr = evPtr->nextPtr;

-	    } else {

-		if (prevPtr == NULL) {

-		    Tcl_Panic("badly connected event list");

-		} else {

-		    prevPtr->nextPtr = evPtr->nextPtr;

-		}

-	    }

-	    if (evPtr->nextPtr == NULL) {

-		tsdPtr->lastEventPtr = prevPtr;

-	    }

-	    if (tsdPtr->markerEventPtr == evPtr) {

-		tsdPtr->markerEventPtr = prevPtr;

-	    }

-	    hold = evPtr;

-	    evPtr = evPtr->nextPtr;

-	    ckfree((char *) hold);

-	} else {

-	    prevPtr = evPtr;

-	    evPtr = evPtr->nextPtr;

-	}

-    }

-    Tcl_MutexUnlock(&(tsdPtr->queueMutex));

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_ServiceEvent --

- *

- *	Process one event from the event queue, or invoke an asynchronous

- *	event handler. Operates on event queue for current thread.

- *

- * Results:

- *	The return value is 1 if the function actually found an event to

- *	process. If no processing occurred, then 0 is returned.

- *

- * Side effects:

- *	Invokes all of the event handlers for the highest priority event in

- *	the event queue. May collapse some events into a single event or

- *	discard stale events.

- *

- *----------------------------------------------------------------------

- */

-

-int

-Tcl_ServiceEvent(

-    int flags)			/* Indicates what events should be processed.

-				 * May be any combination of TCL_WINDOW_EVENTS

-				 * TCL_FILE_EVENTS, TCL_TIMER_EVENTS, or other

-				 * flags defined elsewhere. Events not

-				 * matching this will be skipped for

-				 * processing later. */

-{

-    Tcl_Event *evPtr, *prevPtr;

-    Tcl_EventProc *proc;

-    int result;

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-

-    /*

-     * Asynchronous event handlers are considered to be the highest priority

-     * events, and so must be invoked before we process events on the event

-     * queue.

-     */

-

-    if (Tcl_AsyncReady()) {

-	(void) Tcl_AsyncInvoke(NULL, 0);

-	return 1;

-    }

-

-    /*

-     * No event flags is equivalent to TCL_ALL_EVENTS.

-     */

-

-    if ((flags & TCL_ALL_EVENTS) == 0) {

-	flags |= TCL_ALL_EVENTS;

-    }

-

-    /*

-     * Loop through all the events in the queue until we find one that can

-     * actually be handled.

-     */

-

-    Tcl_MutexLock(&(tsdPtr->queueMutex));

-    for (evPtr = tsdPtr->firstEventPtr; evPtr != NULL;

-	    evPtr = evPtr->nextPtr) {

-	/*

-	 * Call the handler for the event. If it actually handles the event

-	 * then free the storage for the event. There are two tricky things

-	 * here, both stemming from the fact that the event code may be

-	 * re-entered while servicing the event:

-	 *

-	 * 1. Set the "proc" field to NULL.  This is a signal to ourselves

-	 *    that we shouldn't reexecute the handler if the event loop is

-	 *    re-entered.

-	 * 2. When freeing the event, must search the queue again from the

-	 *    front to find it. This is because the event queue could change

-	 *    almost arbitrarily while handling the event, so we can't depend

-	 *    on pointers found now still being valid when the handler

-	 *    returns.

-	 */

-

-	proc = evPtr->proc;

-	if (proc == NULL) {

-	    continue;

-	}

-	evPtr->proc = NULL;

-

-	/*

-	 * Release the lock before calling the event function. This allows

-	 * other threads to post events if we enter a recursive event loop in

-	 * this thread. Note that we are making the assumption that if the

-	 * proc returns 0, the event is still in the list.

-	 */

-

-	Tcl_MutexUnlock(&(tsdPtr->queueMutex));

-	result = (*proc)(evPtr, flags);

-	Tcl_MutexLock(&(tsdPtr->queueMutex));

-

-	if (result) {

-	    /*

-	     * The event was processed, so remove it from the queue.

-	     */

-

-	    if (tsdPtr->firstEventPtr == evPtr) {

-		tsdPtr->firstEventPtr = evPtr->nextPtr;

-		if (evPtr->nextPtr == NULL) {

-		    tsdPtr->lastEventPtr = NULL;

-		}

-		if (tsdPtr->markerEventPtr == evPtr) {

-		    tsdPtr->markerEventPtr = NULL;

-		}

-	    } else {

-		for (prevPtr = tsdPtr->firstEventPtr;

-			prevPtr && prevPtr->nextPtr != evPtr;

-			prevPtr = prevPtr->nextPtr) {

-		    /* Empty loop body. */

-		}

-		if (prevPtr) {

-		    prevPtr->nextPtr = evPtr->nextPtr;

-		    if (evPtr->nextPtr == NULL) {

-			tsdPtr->lastEventPtr = prevPtr;

-		    }

-		    if (tsdPtr->markerEventPtr == evPtr) {

-			tsdPtr->markerEventPtr = prevPtr;

-		    }

-		} else {

-		    evPtr = NULL;

-		}

-	    }

-	    if (evPtr) {

-		ckfree((char *) evPtr);

-	    }

-	    Tcl_MutexUnlock(&(tsdPtr->queueMutex));

-	    return 1;

-	} else {

-	    /*

-	     * The event wasn't actually handled, so we have to restore the

-	     * proc field to allow the event to be attempted again.

-	     */

-

-	    evPtr->proc = proc;

-	}

-    }

-    Tcl_MutexUnlock(&(tsdPtr->queueMutex));

-    return 0;

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_GetServiceMode --

- *

- *	This routine returns the current service mode of the notifier.

- *

- * Results:

- *	Returns either TCL_SERVICE_ALL or TCL_SERVICE_NONE.

- *

- * Side effects:

- *	None.

- *

- *----------------------------------------------------------------------

- */

-

-int

-Tcl_GetServiceMode(void)

-{

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-

-    return tsdPtr->serviceMode;

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_SetServiceMode --

- *

- *	This routine sets the current service mode of the tsdPtr->

- *

- * Results:

- *	Returns the previous service mode.

- *

- * Side effects:

- *	Invokes the notifier service mode hook function.

- *

- *----------------------------------------------------------------------

- */

-

-int

-Tcl_SetServiceMode(

-    int mode)			/* New service mode: TCL_SERVICE_ALL or

-				 * TCL_SERVICE_NONE */

-{

-    int oldMode;

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-

-    oldMode = tsdPtr->serviceMode;

-    tsdPtr->serviceMode = mode;

-    if (tclStubs.tcl_ServiceModeHook) {

-	tclStubs.tcl_ServiceModeHook(mode);

-    }

-    return oldMode;

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_SetMaxBlockTime --

- *

- *	This function is invoked by event sources to tell the notifier how

- *	long it may block the next time it blocks. The timePtr argument gives

- *	a maximum time; the actual time may be less if some other event source

- *	requested a smaller time.

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	May reduce the length of the next sleep in the tsdPtr->

- *

- *----------------------------------------------------------------------

- */

-

-void

-Tcl_SetMaxBlockTime(

-    Tcl_Time *timePtr)		/* Specifies a maximum elapsed time for the

-				 * next blocking operation in the event

-				 * tsdPtr-> */

-{

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-

-    if (!tsdPtr->blockTimeSet || (timePtr->sec < tsdPtr->blockTime.sec)

-	    || ((timePtr->sec == tsdPtr->blockTime.sec)

-	    && (timePtr->usec < tsdPtr->blockTime.usec))) {

-	tsdPtr->blockTime = *timePtr;

-	tsdPtr->blockTimeSet = 1;

-    }

-

-    /*

-     * If we are called outside an event source traversal, set the timeout

-     * immediately.

-     */

-

-    if (!tsdPtr->inTraversal) {

-	if (tsdPtr->blockTimeSet) {

-	    Tcl_SetTimer(&tsdPtr->blockTime);

-	} else {

-	    Tcl_SetTimer(NULL);

-	}

-    }

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_DoOneEvent --

- *

- *	Process a single event of some sort. If there's no work to do, wait

- *	for an event to occur, then process it.

- *

- * Results:

- *	The return value is 1 if the function actually found an event to

- *	process. If no processing occurred, then 0 is returned (this can

- *	happen if the TCL_DONT_WAIT flag is set or if there are no event

- *	handlers to wait for in the set specified by flags).

- *

- * Side effects:

- *	May delay execution of process while waiting for an event, unless

- *	TCL_DONT_WAIT is set in the flags argument. Event sources are invoked

- *	to check for and queue events. Event handlers may produce arbitrary

- *	side effects.

- *

- *----------------------------------------------------------------------

- */

-

-int

-Tcl_DoOneEvent(

-    int flags)			/* Miscellaneous flag values: may be any

-				 * combination of TCL_DONT_WAIT,

-				 * TCL_WINDOW_EVENTS, TCL_FILE_EVENTS,

-				 * TCL_TIMER_EVENTS, TCL_IDLE_EVENTS, or

-				 * others defined by event sources. */

-{

-    int result = 0, oldMode;

-    EventSource *sourcePtr;

-    Tcl_Time *timePtr;

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-

-    /*

-     * The first thing we do is to service any asynchronous event handlers.

-     */

-

-    if (Tcl_AsyncReady()) {

-	(void) Tcl_AsyncInvoke(NULL, 0);

-	return 1;

-    }

-

-    /*

-     * No event flags is equivalent to TCL_ALL_EVENTS.

-     */

-

-    if ((flags & TCL_ALL_EVENTS) == 0) {

-	flags |= TCL_ALL_EVENTS;

-    }

-

-    /*

-     * Set the service mode to none so notifier event routines won't try to

-     * service events recursively.

-     */

-

-    oldMode = tsdPtr->serviceMode;

-    tsdPtr->serviceMode = TCL_SERVICE_NONE;

-

-    /*

-     * The core of this function is an infinite loop, even though we only

-     * service one event. The reason for this is that we may be processing

-     * events that don't do anything inside of Tcl.

-     */

-

-    while (1) {

-	/*

-	 * If idle events are the only things to service, skip the main part

-	 * of the loop and go directly to handle idle events (i.e. don't wait

-	 * even if TCL_DONT_WAIT isn't set).

-	 */

-

-	if ((flags & TCL_ALL_EVENTS) == TCL_IDLE_EVENTS) {

-	    flags = TCL_IDLE_EVENTS | TCL_DONT_WAIT;

-	    goto idleEvents;

-	}

-

-	/*

-	 * Ask Tcl to service a queued event, if there are any.

-	 */

-

-	if (Tcl_ServiceEvent(flags)) {

-	    result = 1;

-	    break;

-	}

-

-	/*

-	 * If TCL_DONT_WAIT is set, be sure to poll rather than blocking,

-	 * otherwise reset the block time to infinity.

-	 */

-

-	if (flags & TCL_DONT_WAIT) {

-	    tsdPtr->blockTime.sec = 0;

-	    tsdPtr->blockTime.usec = 0;

-	    tsdPtr->blockTimeSet = 1;

-	} else {

-	    tsdPtr->blockTimeSet = 0;

-	}

-

-	/*

-	 * Set up all the event sources for new events. This will cause the

-	 * block time to be updated if necessary.

-	 */

-

-	tsdPtr->inTraversal = 1;

-	for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;

-		sourcePtr = sourcePtr->nextPtr) {

-	    if (sourcePtr->setupProc) {

-		(sourcePtr->setupProc)(sourcePtr->clientData, flags);

-	    }

-	}

-	tsdPtr->inTraversal = 0;

-

-	if ((flags & TCL_DONT_WAIT) || tsdPtr->blockTimeSet) {

-	    timePtr = &tsdPtr->blockTime;

-	} else {

-	    timePtr = NULL;

-	}

-

-	/*

-	 * Wait for a new event or a timeout. If Tcl_WaitForEvent returns -1,

-	 * we should abort Tcl_DoOneEvent.

-	 */

-

-	result = Tcl_WaitForEvent(timePtr);

-	if (result < 0) {

-	    result = 0;

-	    break;

-	}

-

-	/*

-	 * Check all the event sources for new events.

-	 */

-

-	for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;

-		sourcePtr = sourcePtr->nextPtr) {

-	    if (sourcePtr->checkProc) {

-		(sourcePtr->checkProc)(sourcePtr->clientData, flags);

-	    }

-	}

-

-	/*

-	 * Check for events queued by the notifier or event sources.

-	 */

-

-	if (Tcl_ServiceEvent(flags)) {

-	    result = 1;

-	    break;

-	}

-

-	/*

-	 * We've tried everything at this point, but nobody we know about had

-	 * anything to do. Check for idle events. If none, either quit or go

-	 * back to the top and try again.

-	 */

-

-    idleEvents:

-	if (flags & TCL_IDLE_EVENTS) {

-	    if (TclServiceIdle()) {

-		result = 1;

-		break;

-	    }

-	}

-	if (flags & TCL_DONT_WAIT) {

-	    break;

-	}

-

-	/*

-	 * If Tcl_WaitForEvent has returned 1, indicating that one system

-	 * event has been dispatched (and thus that some Tcl code might have

-	 * been indirectly executed), we break out of the loop. We do this to

-	 * give VwaitCmd for instance a chance to check if that system event

-	 * had the side effect of changing the variable (so the vwait can

-	 * return and unwind properly).

-	 *

-	 * NB: We will process idle events if any first, because otherwise we

-	 *     might never do the idle events if the notifier always gets

-	 *     system events.

-	 */

-

-	if (result) {

-	    break;

-	}

-    }

-

-    tsdPtr->serviceMode = oldMode;

-    return result;

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_ServiceAll --

- *

- *	This routine checks all of the event sources, processes events that

- *	are on the Tcl event queue, and then calls the any idle handlers.

- *	Platform specific notifier callbacks that generate events should call

- *	this routine before returning to the system in order to ensure that

- *	Tcl gets a chance to process the new events.

- *

- * Results:

- *	Returns 1 if an event or idle handler was invoked, else 0.

- *

- * Side effects:

- *	Anything that an event or idle handler may do.

- *

- *----------------------------------------------------------------------

- */

-

-int

-Tcl_ServiceAll(void)

-{

-    int result = 0;

-    EventSource *sourcePtr;

-    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-

-    if (tsdPtr->serviceMode == TCL_SERVICE_NONE) {

-	return result;

-    }

-

-    /*

-     * We need to turn off event servicing like we to in Tcl_DoOneEvent, to

-     * avoid recursive calls.

-     */

-

-    tsdPtr->serviceMode = TCL_SERVICE_NONE;

-

-    /*

-     * Check async handlers first.

-     */

-

-    if (Tcl_AsyncReady()) {

-	(void) Tcl_AsyncInvoke(NULL, 0);

-    }

-

-    /*

-     * Make a single pass through all event sources, queued events, and idle

-     * handlers. Note that we wait to update the notifier timer until the end

-     * so we can avoid multiple changes.

-     */

-

-    tsdPtr->inTraversal = 1;

-    tsdPtr->blockTimeSet = 0;

-

-    for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;

-	    sourcePtr = sourcePtr->nextPtr) {

-	if (sourcePtr->setupProc) {

-	    (sourcePtr->setupProc)(sourcePtr->clientData, TCL_ALL_EVENTS);

-	}

-    }

-    for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;

-	    sourcePtr = sourcePtr->nextPtr) {

-	if (sourcePtr->checkProc) {

-	    (sourcePtr->checkProc)(sourcePtr->clientData, TCL_ALL_EVENTS);

-	}

-    }

-

-    while (Tcl_ServiceEvent(0)) {

-	result = 1;

-    }

-    if (TclServiceIdle()) {

-	result = 1;

-    }

-

-    if (!tsdPtr->blockTimeSet) {

-	Tcl_SetTimer(NULL);

-    } else {

-	Tcl_SetTimer(&tsdPtr->blockTime);

-    }

-    tsdPtr->inTraversal = 0;

-    tsdPtr->serviceMode = TCL_SERVICE_ALL;

-    return result;

-}

-

-/*

- *----------------------------------------------------------------------

- *

- * Tcl_ThreadAlert --

- *

- *	This function wakes up the notifier associated with the specified

- *	thread (if there is one).

- *

- * Results:

- *	None.

- *

- * Side effects:

- *	None.

- *

- *----------------------------------------------------------------------

- */

-

-void

-Tcl_ThreadAlert(

-    Tcl_ThreadId threadId)	/* Identifier for thread to use. */

-{

-    ThreadSpecificData *tsdPtr;

-

-    /*

-     * Find the notifier associated with the specified thread. Note that we

-     * need to hold the listLock while calling Tcl_AlertNotifier to avoid a

-     * race condition where the specified thread might destroy its notifier.

-     */

-

-    Tcl_MutexLock(&listLock);

-    for (tsdPtr = firstNotifierPtr; tsdPtr; tsdPtr = tsdPtr->nextPtr) {

-	if (tsdPtr->threadId == threadId) {

-	    if (tclStubs.tcl_AlertNotifier) {

-		tclStubs.tcl_AlertNotifier(tsdPtr->clientData);

-	    }

-	    break;

-	}

-    }

-    Tcl_MutexUnlock(&listLock);

-}

-

-/*

- * Local Variables:

- * mode: c

- * c-basic-offset: 4

- * fill-column: 78

- * End:

- */

+/*
+ * tclNotify.c --
+ *
+ *	This file implements the generic portion of the Tcl notifier. The
+ *	notifier is lowest-level part of the event system. It manages an event
+ *	queue that holds Tcl_Event structures. The platform specific portion
+ *	of the notifier is defined in the tcl*Notify.c files in each platform
+ *	directory.
+ *
+ * Copyright (c) 1995-1997 Sun Microsystems, Inc.
+ * Copyright (c) 1998 by Scriptics Corporation.
+ * Copyright (c) 2003 by Kevin B. Kenny.  All rights reserved.
+ *
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * RCS: @(#) $Id: tclNotify.c,v 1.22 2006/09/25 13:35:10 dgp Exp $
+ */
+
+#include "tclInt.h"
+
+extern TclStubs tclStubs;
+
+/*
+ * For each event source (created with Tcl_CreateEventSource) there is a
+ * structure of the following type:
+ */
+
+typedef struct EventSource {
+    Tcl_EventSetupProc *setupProc;
+    Tcl_EventCheckProc *checkProc;
+    ClientData clientData;
+    struct EventSource *nextPtr;
+} EventSource;
+
+/*
+ * The following structure keeps track of the state of the notifier on a
+ * per-thread basis. The first three elements keep track of the event queue.
+ * In addition to the first (next to be serviced) and last events in the
+ * queue, we keep track of a "marker" event. This provides a simple priority
+ * mechanism whereby events can be inserted at the front of the queue but
+ * behind all other high-priority events already in the queue (this is used
+ * for things like a sequence of Enter and Leave events generated during a
+ * grab in Tk). These elements are protected by the queueMutex so that any
+ * thread can queue an event on any notifier. Note that all of the values in
+ * this structure will be initialized to 0.
+ */
+
+typedef struct ThreadSpecificData {
+    Tcl_Event *firstEventPtr;	/* First pending event, or NULL if none. */
+    Tcl_Event *lastEventPtr;	/* Last pending event, or NULL if none. */
+    Tcl_Event *markerEventPtr;	/* Last high-priority event in queue, or NULL
+				 * if none. */
+    Tcl_Mutex queueMutex;	/* Mutex to protect access to the previous
+				 * three fields. */
+    int serviceMode;		/* One of TCL_SERVICE_NONE or
+				 * TCL_SERVICE_ALL. */
+    int blockTimeSet;		/* 0 means there is no maximum block time:
+				 * block forever. */
+    Tcl_Time blockTime;		/* If blockTimeSet is 1, gives the maximum
+				 * elapsed time for the next block. */
+    int inTraversal;		/* 1 if Tcl_SetMaxBlockTime is being called
+				 * during an event source traversal. */
+    EventSource *firstEventSourcePtr;
+				/* Pointer to first event source in list of
+				 * event sources for this thread. */
+    Tcl_ThreadId threadId;	/* Thread that owns this notifier instance. */
+    ClientData clientData;	/* Opaque handle for platform specific
+				 * notifier. */
+    int initialized;		/* 1 if notifier has been initialized. */
+    struct ThreadSpecificData *nextPtr;
+				/* Next notifier in global list of notifiers.
+				 * Access is controlled by the listLock global
+				 * mutex. */
+} ThreadSpecificData;
+
+static Tcl_ThreadDataKey dataKey;
+
+/*
+ * Global list of notifiers. Access to this list is controlled by the listLock
+ * mutex. If this becomes a performance bottleneck, this could be replaced
+ * with a hashtable.
+ */
+
+static ThreadSpecificData *firstNotifierPtr = NULL;
+TCL_DECLARE_MUTEX(listLock)
+
+/*
+ * Declarations for routines used only in this file.
+ */
+
+static void		QueueEvent(ThreadSpecificData *tsdPtr,
+			    Tcl_Event* evPtr, Tcl_QueuePosition position);
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclInitNotifier --
+ *
+ *	Initialize the thread local data structures for the notifier
+ *	subsystem.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Adds the current thread to the global list of notifiers.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TclInitNotifier(void)
+{
+    ThreadSpecificData *tsdPtr;
+    Tcl_ThreadId threadId = Tcl_GetCurrentThread();
+
+    Tcl_MutexLock(&listLock);
+    for (tsdPtr = firstNotifierPtr; tsdPtr && tsdPtr->threadId != threadId;
+	    tsdPtr = tsdPtr->nextPtr) {
+	/* Empty loop body. */
+    }
+
+    if (NULL == tsdPtr) {
+	/*
+	 * Notifier not yet initialized in this thread.
+	 */
+
+	tsdPtr = TCL_TSD_INIT(&dataKey);
+	tsdPtr->threadId = threadId;
+	tsdPtr->clientData = tclStubs.tcl_InitNotifier();
+	tsdPtr->initialized = 1;
+	tsdPtr->nextPtr = firstNotifierPtr;
+	firstNotifierPtr = tsdPtr;
+    }
+    Tcl_MutexUnlock(&listLock);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclFinalizeNotifier --
+ *
+ *	Finalize the thread local data structures for the notifier subsystem.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Removes the notifier associated with the current thread from the
+ *	global notifier list. This is done only if the notifier was
+ *	initialized for this thread by call to TclInitNotifier(). This is
+ *	always true for threads which have been seeded with an Tcl
+ *	interpreter, since the call to Tcl_CreateInterp will, among other
+ *	things, call TclInitializeSubsystems() and this one will, in turn,
+ *	call the TclInitNotifier() for the thread. For threads created without
+ *	the Tcl interpreter, though, nobody is explicitly nor implicitly
+ *	calling the TclInitNotifier hence, TclFinalizeNotifier should not be
+ *	performed at all.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TclFinalizeNotifier(void)
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    ThreadSpecificData **prevPtrPtr;
+    Tcl_Event *evPtr, *hold;
+
+    if (!tsdPtr->initialized) {
+	return;		/* Notifier not initialized for the current thread */
+    }
+
+    Tcl_MutexLock(&(tsdPtr->queueMutex));
+    for (evPtr = tsdPtr->firstEventPtr; evPtr != NULL; ) {
+	hold = evPtr;
+	evPtr = evPtr->nextPtr;
+	ckfree((char *) hold);
+    }
+    tsdPtr->firstEventPtr = NULL;
+    tsdPtr->lastEventPtr = NULL;
+    Tcl_MutexUnlock(&(tsdPtr->queueMutex));
+
+    Tcl_MutexLock(&listLock);
+
+    if (tclStubs.tcl_FinalizeNotifier) {
+	tclStubs.tcl_FinalizeNotifier(tsdPtr->clientData);
+    }
+    Tcl_MutexFinalize(&(tsdPtr->queueMutex));
+    for (prevPtrPtr = &firstNotifierPtr; *prevPtrPtr != NULL;
+	    prevPtrPtr = &((*prevPtrPtr)->nextPtr)) {
+	if (*prevPtrPtr == tsdPtr) {
+	    *prevPtrPtr = tsdPtr->nextPtr;
+	    break;
+	}
+    }
+    tsdPtr->initialized = 0;
+
+    Tcl_MutexUnlock(&listLock);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetNotifier --
+ *
+ *	Install a set of alternate functions for use with the notifier. In
+ *	particular, this can be used to install the Xt-based notifier for use
+ *	with the Browser plugin.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Overstomps part of the stub vector. This relies on hooks added to the
+ *	default functions in case those are called directly (i.e., not through
+ *	the stub table.)
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_SetNotifier(
+    Tcl_NotifierProcs *notifierProcPtr)
+{
+#if !defined(__WIN32__) /* UNIX */
+    tclStubs.tcl_CreateFileHandler = notifierProcPtr->createFileHandlerProc;
+    tclStubs.tcl_DeleteFileHandler = notifierProcPtr->deleteFileHandlerProc;
+#endif
+    tclStubs.tcl_SetTimer = notifierProcPtr->setTimerProc;
+    tclStubs.tcl_WaitForEvent = notifierProcPtr->waitForEventProc;
+    tclStubs.tcl_InitNotifier = notifierProcPtr->initNotifierProc;
+    tclStubs.tcl_FinalizeNotifier = notifierProcPtr->finalizeNotifierProc;
+    tclStubs.tcl_AlertNotifier = notifierProcPtr->alertNotifierProc;
+    tclStubs.tcl_ServiceModeHook = notifierProcPtr->serviceModeHookProc;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CreateEventSource --
+ *
+ *	This function is invoked to create a new source of events. The source
+ *	is identified by a function that gets invoked during Tcl_DoOneEvent to
+ *	check for events on that source and queue them.
+ *
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	SetupProc and checkProc will be invoked each time that Tcl_DoOneEvent
+ *	runs out of things to do. SetupProc will be invoked before
+ *	Tcl_DoOneEvent calls select or whatever else it uses to wait for
+ *	events. SetupProc typically calls functions like Tcl_SetMaxBlockTime
+ *	to indicate what to wait for.
+ *
+ *	CheckProc is called after select or whatever operation was actually
+ *	used to wait. It figures out whether anything interesting actually
+ *	happened (e.g. by calling Tcl_AsyncReady), and then calls
+ *	Tcl_QueueEvent to queue any events that are ready.
+ *
+ *	Each of these functions is passed two arguments, e.g.
+ *		(*checkProc)(ClientData clientData, int flags));
+ *	ClientData is the same as the clientData argument here, and flags is a
+ *	combination of things like TCL_FILE_EVENTS that indicates what events
+ *	are of interest: setupProc and checkProc use flags to figure out
+ *	whether their events are relevant or not.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_CreateEventSource(
+    Tcl_EventSetupProc *setupProc,
+				/* Function to invoke to figure out what to
+				 * wait for. */
+    Tcl_EventCheckProc *checkProc,
+				/* Function to call after waiting to see what
+				 * happened. */
+    ClientData clientData)	/* One-word argument to pass to setupProc and
+				 * checkProc. */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    EventSource *sourcePtr = (EventSource *) ckalloc(sizeof(EventSource));
+
+    sourcePtr->setupProc = setupProc;
+    sourcePtr->checkProc = checkProc;
+    sourcePtr->clientData = clientData;
+    sourcePtr->nextPtr = tsdPtr->firstEventSourcePtr;
+    tsdPtr->firstEventSourcePtr = sourcePtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DeleteEventSource --
+ *
+ *	This function is invoked to delete the source of events given by proc
+ *	and clientData.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The given event source is cancelled, so its function will never again
+ *	be called. If no such source exists, nothing happens.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_DeleteEventSource(
+    Tcl_EventSetupProc *setupProc,
+				/* Function to invoke to figure out what to
+				 * wait for. */
+    Tcl_EventCheckProc *checkProc,
+				/* Function to call after waiting to see what
+				 * happened. */
+    ClientData clientData)	/* One-word argument to pass to setupProc and
+				 * checkProc. */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    EventSource *sourcePtr, *prevPtr;
+
+    for (sourcePtr = tsdPtr->firstEventSourcePtr, prevPtr = NULL;
+	    sourcePtr != NULL;
+	    prevPtr = sourcePtr, sourcePtr = sourcePtr->nextPtr) {
+	if ((sourcePtr->setupProc != setupProc)
+		|| (sourcePtr->checkProc != checkProc)
+		|| (sourcePtr->clientData != clientData)) {
+	    continue;
+	}
+	if (prevPtr == NULL) {
+	    tsdPtr->firstEventSourcePtr = sourcePtr->nextPtr;
+	} else {
+	    prevPtr->nextPtr = sourcePtr->nextPtr;
+	}
+	ckfree((char *) sourcePtr);
+	return;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_QueueEvent --
+ *
+ *	Queue an event on the event queue associated with the current thread.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_QueueEvent(
+    Tcl_Event* evPtr,		/* Event to add to queue. The storage space
+				 * must have been allocated the caller with
+				 * malloc (ckalloc), and it becomes the
+				 * property of the event queue. It will be
+				 * freed after the event has been handled. */
+    Tcl_QueuePosition position)	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,
+				 * TCL_QUEUE_MARK. */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    QueueEvent(tsdPtr, evPtr, position);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ThreadQueueEvent --
+ *
+ *	Queue an event on the specified thread's event queue.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_ThreadQueueEvent(
+    Tcl_ThreadId threadId,	/* Identifier for thread to use. */
+    Tcl_Event *evPtr,		/* Event to add to queue. The storage space
+				 * must have been allocated the caller with
+				 * malloc (ckalloc), and it becomes the
+				 * property of the event queue. It will be
+				 * freed after the event has been handled. */
+    Tcl_QueuePosition position)	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,
+				 * TCL_QUEUE_MARK. */
+{
+    ThreadSpecificData *tsdPtr;
+
+    /*
+     * Find the notifier associated with the specified thread.
+     */
+
+    Tcl_MutexLock(&listLock);
+    for (tsdPtr = firstNotifierPtr; tsdPtr && tsdPtr->threadId != threadId;
+	    tsdPtr = tsdPtr->nextPtr) {
+	/* Empty loop body. */
+    }
+
+    /*
+     * Queue the event if there was a notifier associated with the thread.
+     */
+
+    if (tsdPtr) {
+	QueueEvent(tsdPtr, evPtr, position);
+    }
+    Tcl_MutexUnlock(&listLock);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * QueueEvent --
+ *
+ *	Insert an event into the specified thread's event queue at one of
+ *	three positions: the head, the tail, or before a floating marker.
+ *	Events inserted before the marker will be processed in first-in-
+ *	first-out order, but before any events inserted at the tail of the
+ *	queue. Events inserted at the head of the queue will be processed in
+ *	last-in-first-out order.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+QueueEvent(
+    ThreadSpecificData *tsdPtr,	/* Handle to thread local data that indicates
+				 * which event queue to use. */
+    Tcl_Event *evPtr,		/* Event to add to queue.  The storage space
+				 * must have been allocated the caller with
+				 * malloc (ckalloc), and it becomes the
+				 * property of the event queue. It will be
+				 * freed after the event has been handled. */
+    Tcl_QueuePosition position)	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,
+				 * TCL_QUEUE_MARK. */
+{
+    Tcl_MutexLock(&(tsdPtr->queueMutex));
+    if (position == TCL_QUEUE_TAIL) {
+	/*
+	 * Append the event on the end of the queue.
+	 */
+
+	evPtr->nextPtr = NULL;
+	if (tsdPtr->firstEventPtr == NULL) {
+	    tsdPtr->firstEventPtr = evPtr;
+	} else {
+	    tsdPtr->lastEventPtr->nextPtr = evPtr;
+	}
+	tsdPtr->lastEventPtr = evPtr;
+    } else if (position == TCL_QUEUE_HEAD) {
+	/*
+	 * Push the event on the head of the queue.
+	 */
+
+	evPtr->nextPtr = tsdPtr->firstEventPtr;
+	if (tsdPtr->firstEventPtr == NULL) {
+	    tsdPtr->lastEventPtr = evPtr;
+	}
+	tsdPtr->firstEventPtr = evPtr;
+    } else if (position == TCL_QUEUE_MARK) {
+	/*
+	 * Insert the event after the current marker event and advance the
+	 * marker to the new event.
+	 */
+
+	if (tsdPtr->markerEventPtr == NULL) {
+	    evPtr->nextPtr = tsdPtr->firstEventPtr;
+	    tsdPtr->firstEventPtr = evPtr;
+	} else {
+	    evPtr->nextPtr = tsdPtr->markerEventPtr->nextPtr;
+	    tsdPtr->markerEventPtr->nextPtr = evPtr;
+	}
+	tsdPtr->markerEventPtr = evPtr;
+	if (evPtr->nextPtr == NULL) {
+	    tsdPtr->lastEventPtr = evPtr;
+	}
+    }
+    Tcl_MutexUnlock(&(tsdPtr->queueMutex));
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DeleteEvents --
+ *
+ *	Calls a function for each event in the queue and deletes those for
+ *	which the function returns 1. Events for which the function returns 0
+ *	are left in the queue. Operates on the queue associated with the
+ *	current thread.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Potentially removes one or more events from the event queue.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_DeleteEvents(
+    Tcl_EventDeleteProc *proc,	/* The function to call. */
+    ClientData clientData)    	/* The type-specific data. */
+{
+    Tcl_Event *evPtr, *prevPtr, *hold;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    Tcl_MutexLock(&(tsdPtr->queueMutex));
+    for (prevPtr=NULL, evPtr=tsdPtr->firstEventPtr; evPtr!=NULL; ) {
+	if ((*proc) (evPtr, clientData) == 1) {
+	    if (tsdPtr->firstEventPtr == evPtr) {
+		tsdPtr->firstEventPtr = evPtr->nextPtr;
+	    } else {
+		if (prevPtr == NULL) {
+		    Tcl_Panic("badly connected event list");
+		} else {
+		    prevPtr->nextPtr = evPtr->nextPtr;
+		}
+	    }
+	    if (evPtr->nextPtr == NULL) {
+		tsdPtr->lastEventPtr = prevPtr;
+	    }
+	    if (tsdPtr->markerEventPtr == evPtr) {
+		tsdPtr->markerEventPtr = prevPtr;
+	    }
+	    hold = evPtr;
+	    evPtr = evPtr->nextPtr;
+	    ckfree((char *) hold);
+	} else {
+	    prevPtr = evPtr;
+	    evPtr = evPtr->nextPtr;
+	}
+    }
+    Tcl_MutexUnlock(&(tsdPtr->queueMutex));
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ServiceEvent --
+ *
+ *	Process one event from the event queue, or invoke an asynchronous
+ *	event handler. Operates on event queue for current thread.
+ *
+ * Results:
+ *	The return value is 1 if the function actually found an event to
+ *	process. If no processing occurred, then 0 is returned.
+ *
+ * Side effects:
+ *	Invokes all of the event handlers for the highest priority event in
+ *	the event queue. May collapse some events into a single event or
+ *	discard stale events.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_ServiceEvent(
+    int flags)			/* Indicates what events should be processed.
+				 * May be any combination of TCL_WINDOW_EVENTS
+				 * TCL_FILE_EVENTS, TCL_TIMER_EVENTS, or other
+				 * flags defined elsewhere. Events not
+				 * matching this will be skipped for
+				 * processing later. */
+{
+    Tcl_Event *evPtr, *prevPtr;
+    Tcl_EventProc *proc;
+    int result;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    /*
+     * Asynchronous event handlers are considered to be the highest priority
+     * events, and so must be invoked before we process events on the event
+     * queue.
+     */
+
+    if (Tcl_AsyncReady()) {
+	(void) Tcl_AsyncInvoke(NULL, 0);
+	return 1;
+    }
+
+    /*
+     * No event flags is equivalent to TCL_ALL_EVENTS.
+     */
+
+    if ((flags & TCL_ALL_EVENTS) == 0) {
+	flags |= TCL_ALL_EVENTS;
+    }
+
+    /*
+     * Loop through all the events in the queue until we find one that can
+     * actually be handled.
+     */
+
+    Tcl_MutexLock(&(tsdPtr->queueMutex));
+    for (evPtr = tsdPtr->firstEventPtr; evPtr != NULL;
+	    evPtr = evPtr->nextPtr) {
+	/*
+	 * Call the handler for the event. If it actually handles the event
+	 * then free the storage for the event. There are two tricky things
+	 * here, both stemming from the fact that the event code may be
+	 * re-entered while servicing the event:
+	 *
+	 * 1. Set the "proc" field to NULL.  This is a signal to ourselves
+	 *    that we shouldn't reexecute the handler if the event loop is
+	 *    re-entered.
+	 * 2. When freeing the event, must search the queue again from the
+	 *    front to find it. This is because the event queue could change
+	 *    almost arbitrarily while handling the event, so we can't depend
+	 *    on pointers found now still being valid when the handler
+	 *    returns.
+	 */
+
+	proc = evPtr->proc;
+	if (proc == NULL) {
+	    continue;
+	}
+	evPtr->proc = NULL;
+
+	/*
+	 * Release the lock before calling the event function. This allows
+	 * other threads to post events if we enter a recursive event loop in
+	 * this thread. Note that we are making the assumption that if the
+	 * proc returns 0, the event is still in the list.
+	 */
+
+	Tcl_MutexUnlock(&(tsdPtr->queueMutex));
+	result = (*proc)(evPtr, flags);
+	Tcl_MutexLock(&(tsdPtr->queueMutex));
+
+	if (result) {
+	    /*
+	     * The event was processed, so remove it from the queue.
+	     */
+
+	    if (tsdPtr->firstEventPtr == evPtr) {
+		tsdPtr->firstEventPtr = evPtr->nextPtr;
+		if (evPtr->nextPtr == NULL) {
+		    tsdPtr->lastEventPtr = NULL;
+		}
+		if (tsdPtr->markerEventPtr == evPtr) {
+		    tsdPtr->markerEventPtr = NULL;
+		}
+	    } else {
+		for (prevPtr = tsdPtr->firstEventPtr;
+			prevPtr && prevPtr->nextPtr != evPtr;
+			prevPtr = prevPtr->nextPtr) {
+		    /* Empty loop body. */
+		}
+		if (prevPtr) {
+		    prevPtr->nextPtr = evPtr->nextPtr;
+		    if (evPtr->nextPtr == NULL) {
+			tsdPtr->lastEventPtr = prevPtr;
+		    }
+		    if (tsdPtr->markerEventPtr == evPtr) {
+			tsdPtr->markerEventPtr = prevPtr;
+		    }
+		} else {
+		    evPtr = NULL;
+		}
+	    }
+	    if (evPtr) {
+		ckfree((char *) evPtr);
+	    }
+	    Tcl_MutexUnlock(&(tsdPtr->queueMutex));
+	    return 1;
+	} else {
+	    /*
+	     * The event wasn't actually handled, so we have to restore the
+	     * proc field to allow the event to be attempted again.
+	     */
+
+	    evPtr->proc = proc;
+	}
+    }
+    Tcl_MutexUnlock(&(tsdPtr->queueMutex));
+    return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetServiceMode --
+ *
+ *	This routine returns the current service mode of the notifier.
+ *
+ * Results:
+ *	Returns either TCL_SERVICE_ALL or TCL_SERVICE_NONE.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_GetServiceMode(void)
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    return tsdPtr->serviceMode;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetServiceMode --
+ *
+ *	This routine sets the current service mode of the tsdPtr->
+ *
+ * Results:
+ *	Returns the previous service mode.
+ *
+ * Side effects:
+ *	Invokes the notifier service mode hook function.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_SetServiceMode(
+    int mode)			/* New service mode: TCL_SERVICE_ALL or
+				 * TCL_SERVICE_NONE */
+{
+    int oldMode;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    oldMode = tsdPtr->serviceMode;
+    tsdPtr->serviceMode = mode;
+    if (tclStubs.tcl_ServiceModeHook) {
+	tclStubs.tcl_ServiceModeHook(mode);
+    }
+    return oldMode;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetMaxBlockTime --
+ *
+ *	This function is invoked by event sources to tell the notifier how
+ *	long it may block the next time it blocks. The timePtr argument gives
+ *	a maximum time; the actual time may be less if some other event source
+ *	requested a smaller time.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	May reduce the length of the next sleep in the tsdPtr->
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_SetMaxBlockTime(
+    Tcl_Time *timePtr)		/* Specifies a maximum elapsed time for the
+				 * next blocking operation in the event
+				 * tsdPtr-> */
+{
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if (!tsdPtr->blockTimeSet || (timePtr->sec < tsdPtr->blockTime.sec)
+	    || ((timePtr->sec == tsdPtr->blockTime.sec)
+	    && (timePtr->usec < tsdPtr->blockTime.usec))) {
+	tsdPtr->blockTime = *timePtr;
+	tsdPtr->blockTimeSet = 1;
+    }
+
+    /*
+     * If we are called outside an event source traversal, set the timeout
+     * immediately.
+     */
+
+    if (!tsdPtr->inTraversal) {
+	if (tsdPtr->blockTimeSet) {
+	    Tcl_SetTimer(&tsdPtr->blockTime);
+	} else {
+	    Tcl_SetTimer(NULL);
+	}
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DoOneEvent --
+ *
+ *	Process a single event of some sort. If there's no work to do, wait
+ *	for an event to occur, then process it.
+ *
+ * Results:
+ *	The return value is 1 if the function actually found an event to
+ *	process. If no processing occurred, then 0 is returned (this can
+ *	happen if the TCL_DONT_WAIT flag is set or if there are no event
+ *	handlers to wait for in the set specified by flags).
+ *
+ * Side effects:
+ *	May delay execution of process while waiting for an event, unless
+ *	TCL_DONT_WAIT is set in the flags argument. Event sources are invoked
+ *	to check for and queue events. Event handlers may produce arbitrary
+ *	side effects.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_DoOneEvent(
+    int flags)			/* Miscellaneous flag values: may be any
+				 * combination of TCL_DONT_WAIT,
+				 * TCL_WINDOW_EVENTS, TCL_FILE_EVENTS,
+				 * TCL_TIMER_EVENTS, TCL_IDLE_EVENTS, or
+				 * others defined by event sources. */
+{
+    int result = 0, oldMode;
+    EventSource *sourcePtr;
+    Tcl_Time *timePtr;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    /*
+     * The first thing we do is to service any asynchronous event handlers.
+     */
+
+    if (Tcl_AsyncReady()) {
+	(void) Tcl_AsyncInvoke(NULL, 0);
+	return 1;
+    }
+
+    /*
+     * No event flags is equivalent to TCL_ALL_EVENTS.
+     */
+
+    if ((flags & TCL_ALL_EVENTS) == 0) {
+	flags |= TCL_ALL_EVENTS;
+    }
+
+    /*
+     * Set the service mode to none so notifier event routines won't try to
+     * service events recursively.
+     */
+
+    oldMode = tsdPtr->serviceMode;
+    tsdPtr->serviceMode = TCL_SERVICE_NONE;
+
+    /*
+     * The core of this function is an infinite loop, even though we only
+     * service one event. The reason for this is that we may be processing
+     * events that don't do anything inside of Tcl.
+     */
+
+    while (1) {
+	/*
+	 * If idle events are the only things to service, skip the main part
+	 * of the loop and go directly to handle idle events (i.e. don't wait
+	 * even if TCL_DONT_WAIT isn't set).
+	 */
+
+	if ((flags & TCL_ALL_EVENTS) == TCL_IDLE_EVENTS) {
+	    flags = TCL_IDLE_EVENTS | TCL_DONT_WAIT;
+	    goto idleEvents;
+	}
+
+	/*
+	 * Ask Tcl to service a queued event, if there are any.
+	 */
+
+	if (Tcl_ServiceEvent(flags)) {
+	    result = 1;
+	    break;
+	}
+
+	/*
+	 * If TCL_DONT_WAIT is set, be sure to poll rather than blocking,
+	 * otherwise reset the block time to infinity.
+	 */
+
+	if (flags & TCL_DONT_WAIT) {
+	    tsdPtr->blockTime.sec = 0;
+	    tsdPtr->blockTime.usec = 0;
+	    tsdPtr->blockTimeSet = 1;
+	} else {
+	    tsdPtr->blockTimeSet = 0;
+	}
+
+	/*
+	 * Set up all the event sources for new events. This will cause the
+	 * block time to be updated if necessary.
+	 */
+
+	tsdPtr->inTraversal = 1;
+	for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
+		sourcePtr = sourcePtr->nextPtr) {
+	    if (sourcePtr->setupProc) {
+		(sourcePtr->setupProc)(sourcePtr->clientData, flags);
+	    }
+	}
+	tsdPtr->inTraversal = 0;
+
+	if ((flags & TCL_DONT_WAIT) || tsdPtr->blockTimeSet) {
+	    timePtr = &tsdPtr->blockTime;
+	} else {
+	    timePtr = NULL;
+	}
+
+	/*
+	 * Wait for a new event or a timeout. If Tcl_WaitForEvent returns -1,
+	 * we should abort Tcl_DoOneEvent.
+	 */
+
+	result = Tcl_WaitForEvent(timePtr);
+	if (result < 0) {
+	    result = 0;
+	    break;
+	}
+
+	/*
+	 * Check all the event sources for new events.
+	 */
+
+	for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
+		sourcePtr = sourcePtr->nextPtr) {
+	    if (sourcePtr->checkProc) {
+		(sourcePtr->checkProc)(sourcePtr->clientData, flags);
+	    }
+	}
+
+	/*
+	 * Check for events queued by the notifier or event sources.
+	 */
+
+	if (Tcl_ServiceEvent(flags)) {
+	    result = 1;
+	    break;
+	}
+
+	/*
+	 * We've tried everything at this point, but nobody we know about had
+	 * anything to do. Check for idle events. If none, either quit or go
+	 * back to the top and try again.
+	 */
+
+    idleEvents:
+	if (flags & TCL_IDLE_EVENTS) {
+	    if (TclServiceIdle()) {
+		result = 1;
+		break;
+	    }
+	}
+	if (flags & TCL_DONT_WAIT) {
+	    break;
+	}
+
+	/*
+	 * If Tcl_WaitForEvent has returned 1, indicating that one system
+	 * event has been dispatched (and thus that some Tcl code might have
+	 * been indirectly executed), we break out of the loop. We do this to
+	 * give VwaitCmd for instance a chance to check if that system event
+	 * had the side effect of changing the variable (so the vwait can
+	 * return and unwind properly).
+	 *
+	 * NB: We will process idle events if any first, because otherwise we
+	 *     might never do the idle events if the notifier always gets
+	 *     system events.
+	 */
+
+	if (result) {
+	    break;
+	}
+    }
+
+    tsdPtr->serviceMode = oldMode;
+    return result;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ServiceAll --
+ *
+ *	This routine checks all of the event sources, processes events that
+ *	are on the Tcl event queue, and then calls the any idle handlers.
+ *	Platform specific notifier callbacks that generate events should call
+ *	this routine before returning to the system in order to ensure that
+ *	Tcl gets a chance to process the new events.
+ *
+ * Results:
+ *	Returns 1 if an event or idle handler was invoked, else 0.
+ *
+ * Side effects:
+ *	Anything that an event or idle handler may do.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_ServiceAll(void)
+{
+    int result = 0;
+    EventSource *sourcePtr;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if (tsdPtr->serviceMode == TCL_SERVICE_NONE) {
+	return result;
+    }
+
+    /*
+     * We need to turn off event servicing like we to in Tcl_DoOneEvent, to
+     * avoid recursive calls.
+     */
+
+    tsdPtr->serviceMode = TCL_SERVICE_NONE;
+
+    /*
+     * Check async handlers first.
+     */
+
+    if (Tcl_AsyncReady()) {
+	(void) Tcl_AsyncInvoke(NULL, 0);
+    }
+
+    /*
+     * Make a single pass through all event sources, queued events, and idle
+     * handlers. Note that we wait to update the notifier timer until the end
+     * so we can avoid multiple changes.
+     */
+
+    tsdPtr->inTraversal = 1;
+    tsdPtr->blockTimeSet = 0;
+
+    for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
+	    sourcePtr = sourcePtr->nextPtr) {
+	if (sourcePtr->setupProc) {
+	    (sourcePtr->setupProc)(sourcePtr->clientData, TCL_ALL_EVENTS);
+	}
+    }
+    for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
+	    sourcePtr = sourcePtr->nextPtr) {
+	if (sourcePtr->checkProc) {
+	    (sourcePtr->checkProc)(sourcePtr->clientData, TCL_ALL_EVENTS);
+	}
+    }
+
+    while (Tcl_ServiceEvent(0)) {
+	result = 1;
+    }
+    if (TclServiceIdle()) {
+	result = 1;
+    }
+
+    if (!tsdPtr->blockTimeSet) {
+	Tcl_SetTimer(NULL);
+    } else {
+	Tcl_SetTimer(&tsdPtr->blockTime);
+    }
+    tsdPtr->inTraversal = 0;
+    tsdPtr->serviceMode = TCL_SERVICE_ALL;
+    return result;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ThreadAlert --
+ *
+ *	This function wakes up the notifier associated with the specified
+ *	thread (if there is one).
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_ThreadAlert(
+    Tcl_ThreadId threadId)	/* Identifier for thread to use. */
+{
+    ThreadSpecificData *tsdPtr;
+
+    /*
+     * Find the notifier associated with the specified thread. Note that we
+     * need to hold the listLock while calling Tcl_AlertNotifier to avoid a
+     * race condition where the specified thread might destroy its notifier.
+     */
+
+    Tcl_MutexLock(&listLock);
+    for (tsdPtr = firstNotifierPtr; tsdPtr; tsdPtr = tsdPtr->nextPtr) {
+	if (tsdPtr->threadId == threadId) {
+	    if (tclStubs.tcl_AlertNotifier) {
+		tclStubs.tcl_AlertNotifier(tsdPtr->clientData);
+	    }
+	    break;
+	}
+    }
+    Tcl_MutexUnlock(&listLock);
+}
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */