/* * 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. */ #include "tclInt.h" /* * Module-scope struct of notifier hooks that are checked in the default * notifier functions (for overriding via Tcl_SetNotifier). */ Tcl_NotifierProcs tclNotifierHooks = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }; /* * 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; /* * Used for performance purposes, threshold to bypass check source (if don't wait) * Value should be approximately correspond 100-ns ranges, if the wide-clicks * supported, it is more precise so e. g. 5 is ca. 0.5 microseconds (500-ns). */ #ifndef TCL_CHECK_EVENT_SOURCE_THRESHOLD #define TCL_CHECK_EVENT_SOURCE_THRESHOLD 5 #endif /* * 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_Event *timerMarkerPtr; /* Weak pointer to last event in the queue, * before timer event generation */ Tcl_Event *firstRetardEv; /* First retarded event, or NULL if none. */ Tcl_Event *lastRetardEv; /* Last retarded event, or NULL if none. */ Tcl_Mutex queueMutex; /* Mutex to protect access to the previous * three fields. */ size_t queueEpoch; /* Epoch of the queue (incremented if changed * using TCL_QUEUE_HEAD or TCL_QUEUE_MARK). */ int serviceMode; /* One of TCL_SERVICE_NONE or * TCL_SERVICE_ALL. */ size_t serviceLevel; /* Current (nested) level of event cycle. */ size_t blockTimeServLev; /* Level of the event cycle block time was set. */ 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. */ #if TCL_CHECK_EVENT_SOURCE_THRESHOLD /* Last "time" source checked, used as threshold * to avoid checking for events too often */ #ifndef TCL_WIDE_CLICKS unsigned long lastCheckClicks; #else Tcl_WideInt lastCheckClicks; #endif #endif } 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 || !tsdPtr->initialized) { /* * Notifier not yet initialized in this thread. */ tsdPtr = TCL_TSD_INIT(&dataKey); tsdPtr->threadId = threadId; tsdPtr->clientData = 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(hold); } for (evPtr = tsdPtr->firstRetardEv; evPtr != NULL; ) { hold = evPtr; evPtr = evPtr->nextPtr; ckfree(hold); } tsdPtr->firstEventPtr = NULL; tsdPtr->lastEventPtr = NULL; tsdPtr->markerEventPtr = NULL; tsdPtr->timerMarkerPtr = NULL; tsdPtr->firstRetardEv = NULL; tsdPtr->lastRetardEv = NULL; Tcl_MutexUnlock(&(tsdPtr->queueMutex)); Tcl_MutexLock(&listLock); 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: * Set the tclNotifierHooks global, which is checked in the default * notifier functions. * *---------------------------------------------------------------------- */ void Tcl_SetNotifier( Tcl_NotifierProcs *notifierProcPtr) { tclNotifierHooks = *notifierProcPtr; } /* *---------------------------------------------------------------------- * * 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 = 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 canceled, 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(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 or TCL_QUEUE_RETARDED. */ { 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 or TCL_QUEUE_RETARDED. */ { 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); } else { ckfree(evPtr); } Tcl_MutexUnlock(&listLock); } static inline void SpliceEventTail( Tcl_Event *evPtr, Tcl_Event **firstEvPtr, Tcl_Event **lastEvPtr) { evPtr->nextPtr = NULL; if (*firstEvPtr == NULL) { *firstEvPtr = evPtr; } else { (*lastEvPtr)->nextPtr = evPtr; } *lastEvPtr = evPtr; } static inline void LinkEvent( ThreadSpecificData *tsdPtr, Tcl_Event *evPtr, Tcl_Event *prevPtr) { if (prevPtr) { evPtr->nextPtr = prevPtr->nextPtr; prevPtr->nextPtr = evPtr; } else { evPtr->nextPtr = tsdPtr->firstEventPtr; tsdPtr->firstEventPtr = evPtr; } if (evPtr->nextPtr == NULL) { tsdPtr->lastEventPtr = evPtr; } } /* *---------------------------------------------------------------------- * * 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 or TCL_QUEUE_RETARDED. */ { Tcl_MutexLock(&(tsdPtr->queueMutex)); switch (position) { case TCL_QUEUE_TAIL: /* * Append the event on the end of the queue. */ SpliceEventTail(evPtr, &tsdPtr->firstEventPtr, &tsdPtr->lastEventPtr); break; case 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; /* move timer event hereafter */ if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) { tsdPtr->timerMarkerPtr = evPtr; } tsdPtr->queueEpoch++; /* queue may be changed in the middle */ break; case TCL_QUEUE_MARK: /* * Insert the event after the current marker event and advance the * marker to the new event. */ LinkEvent(tsdPtr, evPtr, tsdPtr->markerEventPtr); tsdPtr->markerEventPtr = evPtr; /* move timer event hereafter */ if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) { tsdPtr->timerMarkerPtr = evPtr; } tsdPtr->queueEpoch++; /* queue may be changed in the middle */ break; case TCL_QUEUE_RETARDED: /* * Append the event on the end of the retarded list. * This guarantees the service earliest at the next event-cycle. */ SpliceEventTail(evPtr, &tsdPtr->firstRetardEv, &tsdPtr->lastRetardEv); break; } Tcl_MutexUnlock(&(tsdPtr->queueMutex)); } static Tcl_Event * SearchEventInQueue( Tcl_Event *firstEvPtr, Tcl_Event *evPtr, Tcl_Event **prevEvPtr) { Tcl_Event *prevPtr = NULL; /* * Search event in the queue (if not first one). */ if (evPtr != firstEvPtr) { for (prevPtr = firstEvPtr; prevPtr && prevPtr->nextPtr != evPtr; prevPtr = prevPtr->nextPtr) { /* Empty loop body. */ } if (!prevPtr) { /* not in queue */ evPtr = NULL; } } if (prevEvPtr) { *prevEvPtr = prevPtr; } return evPtr; } static void UnlinkEvent( ThreadSpecificData *tsdPtr, Tcl_Event *evPtr, Tcl_Event *prevPtr) { /* * Unlink it. */ if (prevPtr == NULL) { tsdPtr->firstEventPtr = evPtr->nextPtr; } else { prevPtr->nextPtr = evPtr->nextPtr; } if (evPtr->nextPtr == NULL) { tsdPtr->lastEventPtr = prevPtr; } /* queue may be changed in the middle */ tsdPtr->queueEpoch++; /* * Update 'marker' events if either has been deleted. */ if (tsdPtr->markerEventPtr == evPtr) { tsdPtr->markerEventPtr = prevPtr; } if (tsdPtr->timerMarkerPtr == evPtr) { tsdPtr->timerMarkerPtr = prevPtr ? prevPtr : INT2PTR(-1); } } static void InvolveRetardedEvents( ThreadSpecificData *tsdPtr) { /* move retarded events at end of the queue */ if (tsdPtr->firstEventPtr == NULL) { tsdPtr->firstEventPtr = tsdPtr->firstRetardEv; } else { tsdPtr->lastEventPtr->nextPtr = tsdPtr->firstRetardEv; } tsdPtr->lastEventPtr = tsdPtr->lastRetardEv; /* reset retarded list */ tsdPtr->lastRetardEv = tsdPtr->firstRetardEv = NULL; } static void UnlinkRetardedEvent( ThreadSpecificData *tsdPtr, Tcl_Event *evPtr, Tcl_Event *prevPtr) { if (prevPtr == NULL) { tsdPtr->firstRetardEv = evPtr->nextPtr; } else { prevPtr->nextPtr = evPtr->nextPtr; } if (evPtr->nextPtr == NULL) { tsdPtr->lastRetardEv = prevPtr; } } /* *---------------------------------------------------------------------- * * 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; /* Pointer to the event being examined */ Tcl_Event *prevPtr; /* Pointer to evPtr's predecessor, or NULL if * evPtr designates the first event in the * queue for the thread. */ ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); Tcl_MutexLock(&(tsdPtr->queueMutex)); /* * Walk the queue of events for the thread, applying 'proc' to each to * decide whether to eliminate the event. */ prevPtr = NULL; evPtr = tsdPtr->firstEventPtr; while (evPtr != NULL) { Tcl_Event *nextPtr = evPtr->nextPtr; if (proc(evPtr, clientData) == 1) { /* This event should be deleted. Unlink and delete it. */ UnlinkEvent(tsdPtr, evPtr, prevPtr); ckfree(evPtr); } else { /* Event is to be retained. */ prevPtr = evPtr; } evPtr = nextPtr; } /* * Do the same for the retarded list. */ prevPtr = NULL; evPtr = tsdPtr->firstRetardEv; while (evPtr != NULL) { Tcl_Event *nextPtr = evPtr->nextPtr; if (proc(evPtr, clientData) == 1) { /* This event should be deleted. Unlink and delete it. */ UnlinkRetardedEvent(tsdPtr, evPtr, prevPtr); ckfree(evPtr); } else { /* Event is to be retained. */ prevPtr = evPtr; } evPtr = nextPtr; } Tcl_MutexUnlock(&(tsdPtr->queueMutex)); } void TclpCancelEvent( Tcl_Event *evPtr) /* Event to remove from queue. */ { Tcl_Event *prevPtr = NULL; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); Tcl_MutexLock(&(tsdPtr->queueMutex)); /* * Search event to unlink from queue and delete it. * Note the event can be in retarded list. */ if (SearchEventInQueue(tsdPtr->firstEventPtr, evPtr, &prevPtr)) { UnlinkEvent(tsdPtr, evPtr, prevPtr); ckfree(evPtr); } else if (!SearchEventInQueue(tsdPtr->firstRetardEv, evPtr, &prevPtr)) { UnlinkRetardedEvent(tsdPtr, evPtr, prevPtr); ckfree(evPtr); } 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; size_t queueEpoch; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); /* * No event flags is equivalent to TCL_ALL_EVENTS. */ if ((flags & TCL_ALL_EVENTS) == 0) { flags |= TCL_ALL_EVENTS; } /* * 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 ((flags & TCL_ASYNC_EVENTS)) { if (Tcl_AsyncReady()) { (void) Tcl_AsyncInvoke(NULL, 0); return 1; } /* Async only */ if ((flags & TCL_ALL_EVENTS) == TCL_ASYNC_EVENTS) { return 0; } } /* Fast bypass case */ if ( !tsdPtr->firstEventPtr /* no other events */ || ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS) /* timers only */ ) { goto timer; } /* * If timer marker reached, process timer events now. */ if ((flags & TCL_TIMER_EVENTS) && (tsdPtr->timerMarkerPtr == INT2PTR(-1))) { goto processTimer; } /* Lock queue to process events */ Tcl_MutexLock(&(tsdPtr->queueMutex)); /* * Loop through all the events in the queue until we find one that can * actually be handled. */ for (prevPtr = NULL, evPtr = tsdPtr->firstEventPtr; evPtr != NULL && tsdPtr->timerMarkerPtr != INT2PTR(-1); prevPtr = evPtr, evPtr = evPtr->nextPtr ) { repeatCycle: if (tsdPtr->timerMarkerPtr == evPtr) { tsdPtr->timerMarkerPtr = INT2PTR(-1); /* timer marker reached */ } /* * 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; /* Save current queue epoch (if unchanged - the same prevPtr) */ queueEpoch = tsdPtr->queueEpoch; /* * 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 event processed or scheduled to be executed later (retarding) */ if (result || evPtr->proc) { /* * Check the queue was changed. */ if (queueEpoch != tsdPtr->queueEpoch) { /* queue may be changed in the middle */ queueEpoch = tsdPtr->queueEpoch; /* try to find event */ evPtr = SearchEventInQueue(tsdPtr->firstEventPtr, evPtr, &prevPtr); } /* * If the handler set another function to process it later, * do retarding of the event. */ if (evPtr && evPtr->proc) { /* * Reattach the event on the end of the retarded list. */ UnlinkEvent(tsdPtr, evPtr, prevPtr); SpliceEventTail(evPtr, &tsdPtr->firstRetardEv, &tsdPtr->lastRetardEv); /* next event to service */ if (prevPtr == NULL) { /* we stood on begin of list - just repeat from new begin */ evPtr = tsdPtr->firstEventPtr; } else { /* continue from next of previous event */ evPtr = prevPtr->nextPtr; } goto repeatCycle; } /* * The event was processed, so remove it. */ if (evPtr) { /* Detach event from queue */ UnlinkEvent(tsdPtr, evPtr, prevPtr); /* Free event */ ckfree(evPtr); } /* event processed - return with 1 */ 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)); timer: /* * Process timer queue, if alloved and timers are enabled. */ if (flags & TCL_TIMER_EVENTS) { /* If available pending timer-events of new generation */ if (tsdPtr->timerMarkerPtr == INT2PTR(-2)) { /* pending */ /* no other events - process timer-events (next cycle) */ if (!(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) { /* no other events */ tsdPtr->timerMarkerPtr = INT2PTR(-1); } return 0; } if (tsdPtr->timerMarkerPtr == INT2PTR(-1)) { processTimer: /* reset marker */ tsdPtr->timerMarkerPtr = NULL; result = TclServiceTimerEvents(); if (result < 0) { /* * Events processed, but still pending timers (of new generation) * set marker to process timer, if setup- resp. check-proc will * not generate new events. */ if (tsdPtr->timerMarkerPtr == NULL) { /* marker to last event in the queue */ if (!(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr)) { /* * Marker as "pending" - queue is empty, so timers events are first, * if setup-proc resp. check-proc will not generate new events. */ tsdPtr->timerMarkerPtr = INT2PTR(-2); }; } result = 1; } return result; } } return 0; } #if TCL_CHECK_EVENT_SOURCE_THRESHOLD /* *---------------------------------------------------------------------- * * CheckSourceThreshold -- * * Check whether we should iterate over event sources for availability. * * This is used to avoid too unneeded overhead (too often call checkProc). * * Results: * Returns 1 if threshold reached (check event sources), 0 otherwise. * *---------------------------------------------------------------------- */ static inline int CheckSourceThreshold( ThreadSpecificData *tsdPtr) { /* don't need to wait/check for events too often */ #ifndef TCL_WIDE_CLICKS unsigned long clickdiff, clicks = TclpGetClicks(); #else Tcl_WideInt clickdiff, clicks; /* in 100-ns */ clicks = TclpGetWideClicks() * (TclpWideClickInMicrosec() * 10); #endif /* considering possible clicks-jump */ if ( (clickdiff = (clicks - tsdPtr->lastCheckClicks)) >= 0 && clickdiff <= TCL_CHECK_EVENT_SOURCE_THRESHOLD) { return 0; } tsdPtr->lastCheckClicks = clicks; return 1; } #endif static int SetUpEventSources( ThreadSpecificData *tsdPtr, int flags) { int res = 0; EventSource *sourcePtr; /* * Set up all the event sources for new events. This will cause the * block time to be updated if necessary. */ tsdPtr->inTraversal++; for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL; sourcePtr = sourcePtr->nextPtr ) { if (sourcePtr->checkProc) { sourcePtr->setupProc(sourcePtr->clientData, flags); res++; } } tsdPtr->inTraversal--; /* * If we've some retarded events (from last event-cycle), wait non-blocking. */ if ( tsdPtr->firstRetardEv && ( !tsdPtr->blockTimeSet || tsdPtr->blockTimeServLev < tsdPtr->serviceLevel ) ) { tsdPtr->blockTime.sec = 0; tsdPtr->blockTime.usec = 0; tsdPtr->blockTimeSet = 1; } return res; } static int CheckEventSources( ThreadSpecificData *tsdPtr, int flags) { int res = 0; EventSource *sourcePtr; /* * 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); res++; } } /* * If we've some retarded events (from last event-cycle), attach they here * to the tail of the event queue (new event-cycle). */ if (tsdPtr->firstRetardEv) { Tcl_MutexLock(&(tsdPtr->queueMutex)); if (tsdPtr->firstRetardEv) { InvolveRetardedEvents(tsdPtr); res++; } Tcl_MutexUnlock(&(tsdPtr->queueMutex)); } return res; } /* *---------------------------------------------------------------------- * * TclPeekEventQueued -- * * Check whether some event (except idle) available (async, queued, timer). * * This will be used e. g. in TclServiceIdle to stop the processing of the * the idle events if some "normal" event occurred. * * Results: * Returns 1 if some event queued, 0 otherwise. * * Side effects: * None. * *---------------------------------------------------------------------- */ int TclPeekEventQueued( int flags) { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); int repeat = 1; do { /* * Events already pending ? */ if ( Tcl_AsyncReady() || (tsdPtr->firstEventPtr) || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerMarkerPtr) ) { return 1; } /* once from here */ if (!repeat) { break; } if (flags & TCL_DONT_WAIT) { /* don't need to wait/check for events too often */ #if TCL_CHECK_EVENT_SOURCE_THRESHOLD if (!CheckSourceThreshold(tsdPtr)) { return 0; } #endif } /* * Check all the event sources for new events. */ if (!CheckEventSources(tsdPtr, flags)) { return 0; /* no sources - no events could be created at all */ } } while (repeat--); return 0; } /* *---------------------------------------------------------------------- * * TclSetTimerEventMarker -- * * Set timer event marker to the last pending event in the queue. * * Results: * None. * * Side effects: * None. * *---------------------------------------------------------------------- */ void TclSetTimerEventMarker( int flags) { ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); if (tsdPtr->timerMarkerPtr == NULL || tsdPtr->timerMarkerPtr == INT2PTR(-2)) { /* marker to last event in the queue */ if ( !(tsdPtr->timerMarkerPtr = tsdPtr->lastEventPtr) /* no other events */ || ((flags & TCL_ALL_EVENTS) == TCL_TIMER_EVENTS) /* timers only */ ) { /* * Marker as "pending" - queue is empty, so timers events are first, * if setup-proc resp. check-proc will not generate new events. * Force timer execution if flags specified (from checkProc). */ tsdPtr->timerMarkerPtr = flags ? INT2PTR(-1) : INT2PTR(-2); }; } } /* *---------------------------------------------------------------------- * * 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; 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( const 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->blockTimeServLev < tsdPtr->serviceLevel) { /* avoid resetting the blockTime set outside of traversal. */ tsdPtr->blockTimeServLev = tsdPtr->serviceLevel; } Tcl_SetTimer(&tsdPtr->blockTime); } } /* *---------------------------------------------------------------------- * * 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 block time was set using * Tcl_SetMaxBlockTime before 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. * If block time was set (Tcl_SetMaxBlockTime) but another event occurs * and interrupt wait, the function can return early, thereby it resets * the block time (caller should use Tcl_SetMaxBlockTime again). * *---------------------------------------------------------------------- */ 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; Tcl_Time *timePtr; ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); int blockTimeWasSet; /* * No event flags is equivalent to TCL_ALL_EVENTS. */ if ((flags & TCL_ALL_EVENTS) == 0) { flags |= TCL_ALL_EVENTS; } /* Block time was set outside an event source traversal, caller has specified a waittime */ blockTimeWasSet = tsdPtr->blockTimeSet; /* * 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; tsdPtr->serviceLevel++; /* * 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 (flags & TCL_ASYNC_EVENTS) { if (Tcl_AsyncReady()) { (void) Tcl_AsyncInvoke(NULL, 0); result = 1; goto done; } /* Async only and don't wait - return */ if ( (flags & (TCL_ALL_EVENTS|TCL_DONT_WAIT)) == (TCL_ASYNC_EVENTS|TCL_DONT_WAIT) ) { goto done; } } /* * Main loop until servicing exact one event or block time resp. * TCL_DONT_WAIT specified (infinite loop otherwise). */ do { /* * 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) { goto idleEvents; } /* * Ask Tcl to service any asynchronous event handlers or * 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) { /* don't need to wait/check for events too often */ #if TCL_CHECK_EVENT_SOURCE_THRESHOLD if (!CheckSourceThreshold(tsdPtr)) { goto idleEvents; } #endif tsdPtr->blockTime.sec = 0; tsdPtr->blockTime.usec = 0; tsdPtr->blockTimeSet = 1; timePtr = &tsdPtr->blockTime; goto wait; /* for notifier resp. system events */ } /* * Set up all the event sources for new events. This will cause the * block time to be updated if necessary. */ SetUpEventSources(tsdPtr, flags); if (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. */ wait: result = Tcl_WaitForEvent(timePtr); tsdPtr->blockTimeServLev = 0; /* reset block-time level (processed). */ if (result < 0) { if (blockTimeWasSet) { result = 0; } break; } /* * Check all the event sources for new events. */ CheckEventSources(tsdPtr, 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 (TclServiceIdleEx(flags, INT_MAX)) { result = 1; 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). * * We can stop also if works in block to event mode (e. g. block time was * set outside an event source, that means timeout was set so exit loop * also without event/result). */ result = 0; if (blockTimeWasSet) { break; } } while ( !(flags & TCL_DONT_WAIT) ); done: /* * Reset block time earliest at the end of event cycle and restore mode. */ if (tsdPtr->blockTimeServLev < tsdPtr->serviceLevel) { tsdPtr->blockTimeSet = 0; tsdPtr->blockTimeServLev = 0; } tsdPtr->serviceMode = oldMode; tsdPtr->serviceLevel--; 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; 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->blockTimeSet = 0; SetUpEventSources(tsdPtr, TCL_ALL_EVENTS); CheckEventSources(tsdPtr, 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->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) { Tcl_AlertNotifier(tsdPtr->clientData); break; } } Tcl_MutexUnlock(&listLock); } /* *---------------------------------------------------------------------- * * Tcl_Sleep -- * * Delay execution for the specified number of milliseconds. * * Results: * None. * * Side effects: * Time passes. * *---------------------------------------------------------------------- */ void Tcl_Sleep( int ms) /* Number of milliseconds to sleep. */ { TclpUSleep((Tcl_WideInt)ms * 1000); } /* * Local Variables: * mode: c * c-basic-offset: 4 * fill-column: 78 * End: */