/[dtapublic]/projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclnotify.c
ViewVC logotype

Annotation of /projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclnotify.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 66 - (hide annotations) (download)
Sun Oct 30 21:57:38 2016 UTC (7 years, 6 months ago) by dashley
File MIME type: text/plain
File size: 31117 byte(s)
Header and footer cleanup.
1 dashley 66 /* $Header$ */
2 dashley 25 /*
3     * tclNotify.c --
4     *
5     * This file implements the generic portion of the Tcl notifier.
6     * The notifier is lowest-level part of the event system. It
7     * manages an event queue that holds Tcl_Event structures. The
8     * platform specific portion of the notifier is defined in the
9     * tcl*Notify.c files in each platform directory.
10     *
11     * Copyright (c) 1995-1997 Sun Microsystems, Inc.
12     * Copyright (c) 1998 by Scriptics Corporation.
13     *
14     * See the file "license.terms" for information on usage and redistribution
15     * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
16     *
17     * RCS: @(#) $Id: tclnotify.c,v 1.1.1.1 2001/06/13 04:43:48 dtashley Exp $
18     */
19    
20     #include "tclInt.h"
21     #include "tclPort.h"
22    
23     extern TclStubs tclStubs;
24    
25     /*
26     * For each event source (created with Tcl_CreateEventSource) there
27     * is a structure of the following type:
28     */
29    
30     typedef struct EventSource {
31     Tcl_EventSetupProc *setupProc;
32     Tcl_EventCheckProc *checkProc;
33     ClientData clientData;
34     struct EventSource *nextPtr;
35     } EventSource;
36    
37     /*
38     * The following structure keeps track of the state of the notifier on a
39     * per-thread basis. The first three elements keep track of the event queue.
40     * In addition to the first (next to be serviced) and last events in the queue,
41     * we keep track of a "marker" event. This provides a simple priority
42     * mechanism whereby events can be inserted at the front of the queue but
43     * behind all other high-priority events already in the queue (this is used for
44     * things like a sequence of Enter and Leave events generated during a grab in
45     * Tk). These elements are protected by the queueMutex so that any thread
46     * can queue an event on any notifier. Note that all of the values in this
47     * structure will be initialized to 0.
48     */
49    
50     typedef struct ThreadSpecificData {
51     Tcl_Event *firstEventPtr; /* First pending event, or NULL if none. */
52     Tcl_Event *lastEventPtr; /* Last pending event, or NULL if none. */
53     Tcl_Event *markerEventPtr; /* Last high-priority event in queue, or
54     * NULL if none. */
55     Tcl_Mutex queueMutex; /* Mutex to protect access to the previous
56     * three fields. */
57     int serviceMode; /* One of TCL_SERVICE_NONE or
58     * TCL_SERVICE_ALL. */
59     int blockTimeSet; /* 0 means there is no maximum block
60     * time: block forever. */
61     Tcl_Time blockTime; /* If blockTimeSet is 1, gives the
62     * maximum elapsed time for the next block. */
63     int inTraversal; /* 1 if Tcl_SetMaxBlockTime is being
64     * called during an event source traversal. */
65     EventSource *firstEventSourcePtr;
66     /* Pointer to first event source in
67     * list of event sources for this thread. */
68     Tcl_ThreadId threadId; /* Thread that owns this notifier instance. */
69     ClientData clientData; /* Opaque handle for platform specific
70     * notifier. */
71     struct ThreadSpecificData *nextPtr;
72     /* Next notifier in global list of notifiers.
73     * Access is controlled by the listLock global
74     * mutex. */
75     } ThreadSpecificData;
76    
77     static Tcl_ThreadDataKey dataKey;
78    
79     /*
80     * Global list of notifiers. Access to this list is controlled by the
81     * listLock mutex. If this becomes a performance bottleneck, this could
82     * be replaced with a hashtable.
83     */
84    
85     static ThreadSpecificData *firstNotifierPtr;
86     TCL_DECLARE_MUTEX(listLock)
87    
88     /*
89     * Declarations for routines used only in this file.
90     */
91    
92     static void QueueEvent _ANSI_ARGS_((ThreadSpecificData *tsdPtr,
93     Tcl_Event* evPtr, Tcl_QueuePosition position));
94    
95     /*
96     *----------------------------------------------------------------------
97     *
98     * TclInitNotifier --
99     *
100     * Initialize the thread local data structures for the notifier
101     * subsystem.
102     *
103     * Results:
104     * None.
105     *
106     * Side effects:
107     * Adds the current thread to the global list of notifiers.
108     *
109     *----------------------------------------------------------------------
110     */
111    
112     void
113     TclInitNotifier()
114     {
115     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
116    
117     Tcl_MutexLock(&listLock);
118    
119     tsdPtr->threadId = Tcl_GetCurrentThread();
120     tsdPtr->clientData = Tcl_InitNotifier();
121     tsdPtr->nextPtr = firstNotifierPtr;
122     firstNotifierPtr = tsdPtr;
123    
124     Tcl_MutexUnlock(&listLock);
125     }
126    
127     /*
128     *----------------------------------------------------------------------
129     *
130     * TclFinalizeNotifier --
131     *
132     * Finalize the thread local data structures for the notifier
133     * subsystem.
134     *
135     * Results:
136     * None.
137     *
138     * Side effects:
139     * Removes the notifier associated with the current thread from
140     * the global notifier list.
141     *
142     *----------------------------------------------------------------------
143     */
144    
145     void
146     TclFinalizeNotifier()
147     {
148     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
149     ThreadSpecificData **prevPtrPtr;
150    
151     Tcl_MutexLock(&listLock);
152    
153     Tcl_FinalizeNotifier(tsdPtr->clientData);
154     Tcl_MutexFinalize(&(tsdPtr->queueMutex));
155     for (prevPtrPtr = &firstNotifierPtr; *prevPtrPtr != NULL;
156     prevPtrPtr = &((*prevPtrPtr)->nextPtr)) {
157     if (*prevPtrPtr == tsdPtr) {
158     *prevPtrPtr = tsdPtr->nextPtr;
159     break;
160     }
161     }
162    
163     Tcl_MutexUnlock(&listLock);
164     }
165    
166     /*
167     *----------------------------------------------------------------------
168     *
169     * Tcl_SetNotifier --
170     *
171     * Install a set of alternate functions for use with the notifier.
172     # In particular, this can be used to install the Xt-based
173     * notifier for use with the Browser plugin.
174     *
175     * Results:
176     * None.
177     *
178     * Side effects:
179     * Overstomps part of the stub vector. This relies on hooks
180     * added to the default procedures in case those are called
181     * directly (i.e., not through the stub table.)
182     *
183     *----------------------------------------------------------------------
184     */
185    
186     void
187     Tcl_SetNotifier(notifierProcPtr)
188     Tcl_NotifierProcs *notifierProcPtr;
189     {
190     #if !defined(__WIN32__) && !defined(MAC_TCL) /* UNIX */
191     tclStubs.tcl_CreateFileHandler = notifierProcPtr->createFileHandlerProc;
192     tclStubs.tcl_DeleteFileHandler = notifierProcPtr->deleteFileHandlerProc;
193     #endif
194     tclStubs.tcl_SetTimer = notifierProcPtr->setTimerProc;
195     tclStubs.tcl_WaitForEvent = notifierProcPtr->waitForEventProc;
196     }
197    
198     /*
199     *----------------------------------------------------------------------
200     *
201     * Tcl_CreateEventSource --
202     *
203     * This procedure is invoked to create a new source of events.
204     * The source is identified by a procedure that gets invoked
205     * during Tcl_DoOneEvent to check for events on that source
206     * and queue them.
207     *
208     *
209     * Results:
210     * None.
211     *
212     * Side effects:
213     * SetupProc and checkProc will be invoked each time that Tcl_DoOneEvent
214     * runs out of things to do. SetupProc will be invoked before
215     * Tcl_DoOneEvent calls select or whatever else it uses to wait
216     * for events. SetupProc typically calls functions like
217     * Tcl_SetMaxBlockTime to indicate what to wait for.
218     *
219     * CheckProc is called after select or whatever operation was actually
220     * used to wait. It figures out whether anything interesting actually
221     * happened (e.g. by calling Tcl_AsyncReady), and then calls
222     * Tcl_QueueEvent to queue any events that are ready.
223     *
224     * Each of these procedures is passed two arguments, e.g.
225     * (*checkProc)(ClientData clientData, int flags));
226     * ClientData is the same as the clientData argument here, and flags
227     * is a combination of things like TCL_FILE_EVENTS that indicates
228     * what events are of interest: setupProc and checkProc use flags
229     * to figure out whether their events are relevant or not.
230     *
231     *----------------------------------------------------------------------
232     */
233    
234     void
235     Tcl_CreateEventSource(setupProc, checkProc, clientData)
236     Tcl_EventSetupProc *setupProc; /* Procedure to invoke to figure out
237     * what to wait for. */
238     Tcl_EventCheckProc *checkProc; /* Procedure to call after waiting
239     * to see what happened. */
240     ClientData clientData; /* One-word argument to pass to
241     * setupProc and checkProc. */
242     {
243     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
244     EventSource *sourcePtr = (EventSource *) ckalloc(sizeof(EventSource));
245    
246     sourcePtr->setupProc = setupProc;
247     sourcePtr->checkProc = checkProc;
248     sourcePtr->clientData = clientData;
249     sourcePtr->nextPtr = tsdPtr->firstEventSourcePtr;
250     tsdPtr->firstEventSourcePtr = sourcePtr;
251     }
252    
253     /*
254     *----------------------------------------------------------------------
255     *
256     * Tcl_DeleteEventSource --
257     *
258     * This procedure is invoked to delete the source of events
259     * given by proc and clientData.
260     *
261     * Results:
262     * None.
263     *
264     * Side effects:
265     * The given event source is cancelled, so its procedure will
266     * never again be called. If no such source exists, nothing
267     * happens.
268     *
269     *----------------------------------------------------------------------
270     */
271    
272     void
273     Tcl_DeleteEventSource(setupProc, checkProc, clientData)
274     Tcl_EventSetupProc *setupProc; /* Procedure to invoke to figure out
275     * what to wait for. */
276     Tcl_EventCheckProc *checkProc; /* Procedure to call after waiting
277     * to see what happened. */
278     ClientData clientData; /* One-word argument to pass to
279     * setupProc and checkProc. */
280     {
281     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
282     EventSource *sourcePtr, *prevPtr;
283    
284     for (sourcePtr = tsdPtr->firstEventSourcePtr, prevPtr = NULL;
285     sourcePtr != NULL;
286     prevPtr = sourcePtr, sourcePtr = sourcePtr->nextPtr) {
287     if ((sourcePtr->setupProc != setupProc)
288     || (sourcePtr->checkProc != checkProc)
289     || (sourcePtr->clientData != clientData)) {
290     continue;
291     }
292     if (prevPtr == NULL) {
293     tsdPtr->firstEventSourcePtr = sourcePtr->nextPtr;
294     } else {
295     prevPtr->nextPtr = sourcePtr->nextPtr;
296     }
297     ckfree((char *) sourcePtr);
298     return;
299     }
300     }
301    
302     /*
303     *----------------------------------------------------------------------
304     *
305     * Tcl_QueueEvent --
306     *
307     * Queue an event on the event queue associated with the
308     * current thread.
309     *
310     * Results:
311     * None.
312     *
313     * Side effects:
314     * None.
315     *
316     *----------------------------------------------------------------------
317     */
318    
319     void
320     Tcl_QueueEvent(evPtr, position)
321     Tcl_Event* evPtr; /* Event to add to queue. The storage
322     * space must have been allocated the caller
323     * with malloc (ckalloc), and it becomes
324     * the property of the event queue. It
325     * will be freed after the event has been
326     * handled. */
327     Tcl_QueuePosition position; /* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,
328     * TCL_QUEUE_MARK. */
329     {
330     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
331     QueueEvent(tsdPtr, evPtr, position);
332     }
333    
334     /*
335     *----------------------------------------------------------------------
336     *
337     * Tcl_ThreadQueueEvent --
338     *
339     * Queue an event on the specified thread's event queue.
340     *
341     * Results:
342     * None.
343     *
344     * Side effects:
345     * None.
346     *
347     *----------------------------------------------------------------------
348     */
349    
350     void
351     Tcl_ThreadQueueEvent(threadId, evPtr, position)
352     Tcl_ThreadId threadId; /* Identifier for thread to use. */
353     Tcl_Event* evPtr; /* Event to add to queue. The storage
354     * space must have been allocated the caller
355     * with malloc (ckalloc), and it becomes
356     * the property of the event queue. It
357     * will be freed after the event has been
358     * handled. */
359     Tcl_QueuePosition position; /* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,
360     * TCL_QUEUE_MARK. */
361     {
362     ThreadSpecificData *tsdPtr;
363    
364     /*
365     * Find the notifier associated with the specified thread.
366     */
367    
368     Tcl_MutexLock(&listLock);
369     for (tsdPtr = firstNotifierPtr; tsdPtr && tsdPtr->threadId != threadId;
370     tsdPtr = tsdPtr->nextPtr) {
371     /* Empty loop body. */
372     }
373    
374     /*
375     * Queue the event if there was a notifier associated with the thread.
376     */
377    
378     if (tsdPtr) {
379     QueueEvent(tsdPtr, evPtr, position);
380     }
381     Tcl_MutexUnlock(&listLock);
382     }
383    
384     /*
385     *----------------------------------------------------------------------
386     *
387     * QueueEvent --
388     *
389     * Insert an event into the specified thread's event queue at one
390     * of three positions: the head, the tail, or before a floating
391     * marker. Events inserted before the marker will be processed in
392     * first-in-first-out order, but before any events inserted at
393     * the tail of the queue. Events inserted at the head of the
394     * queue will be processed in last-in-first-out order.
395     *
396     * Results:
397     * None.
398     *
399     * Side effects:
400     * None.
401     *
402     *----------------------------------------------------------------------
403     */
404    
405     static void
406     QueueEvent(tsdPtr, evPtr, position)
407     ThreadSpecificData *tsdPtr; /* Handle to thread local data that indicates
408     * which event queue to use. */
409     Tcl_Event* evPtr; /* Event to add to queue. The storage
410     * space must have been allocated the caller
411     * with malloc (ckalloc), and it becomes
412     * the property of the event queue. It
413     * will be freed after the event has been
414     * handled. */
415     Tcl_QueuePosition position; /* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,
416     * TCL_QUEUE_MARK. */
417     {
418     Tcl_MutexLock(&(tsdPtr->queueMutex));
419     if (position == TCL_QUEUE_TAIL) {
420     /*
421     * Append the event on the end of the queue.
422     */
423    
424     evPtr->nextPtr = NULL;
425     if (tsdPtr->firstEventPtr == NULL) {
426     tsdPtr->firstEventPtr = evPtr;
427     } else {
428     tsdPtr->lastEventPtr->nextPtr = evPtr;
429     }
430     tsdPtr->lastEventPtr = evPtr;
431     } else if (position == TCL_QUEUE_HEAD) {
432     /*
433     * Push the event on the head of the queue.
434     */
435    
436     evPtr->nextPtr = tsdPtr->firstEventPtr;
437     if (tsdPtr->firstEventPtr == NULL) {
438     tsdPtr->lastEventPtr = evPtr;
439     }
440     tsdPtr->firstEventPtr = evPtr;
441     } else if (position == TCL_QUEUE_MARK) {
442     /*
443     * Insert the event after the current marker event and advance
444     * the marker to the new event.
445     */
446    
447     if (tsdPtr->markerEventPtr == NULL) {
448     evPtr->nextPtr = tsdPtr->firstEventPtr;
449     tsdPtr->firstEventPtr = evPtr;
450     } else {
451     evPtr->nextPtr = tsdPtr->markerEventPtr->nextPtr;
452     tsdPtr->markerEventPtr->nextPtr = evPtr;
453     }
454     tsdPtr->markerEventPtr = evPtr;
455     if (evPtr->nextPtr == NULL) {
456     tsdPtr->lastEventPtr = evPtr;
457     }
458     }
459     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
460     }
461    
462     /*
463     *----------------------------------------------------------------------
464     *
465     * Tcl_DeleteEvents --
466     *
467     * Calls a procedure for each event in the queue and deletes those
468     * for which the procedure returns 1. Events for which the
469     * procedure returns 0 are left in the queue. Operates on the
470     * queue associated with the current thread.
471     *
472     * Results:
473     * None.
474     *
475     * Side effects:
476     * Potentially removes one or more events from the event queue.
477     *
478     *----------------------------------------------------------------------
479     */
480    
481     void
482     Tcl_DeleteEvents(proc, clientData)
483     Tcl_EventDeleteProc *proc; /* The procedure to call. */
484     ClientData clientData; /* type-specific data. */
485     {
486     Tcl_Event *evPtr, *prevPtr, *hold;
487     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
488    
489     Tcl_MutexLock(&(tsdPtr->queueMutex));
490     for (prevPtr = (Tcl_Event *) NULL, evPtr = tsdPtr->firstEventPtr;
491     evPtr != (Tcl_Event *) NULL;
492     ) {
493     if ((*proc) (evPtr, clientData) == 1) {
494     if (tsdPtr->firstEventPtr == evPtr) {
495     tsdPtr->firstEventPtr = evPtr->nextPtr;
496     if (evPtr->nextPtr == (Tcl_Event *) NULL) {
497     tsdPtr->lastEventPtr = prevPtr;
498     }
499     if (tsdPtr->markerEventPtr == evPtr) {
500     tsdPtr->markerEventPtr = prevPtr;
501     }
502     } else {
503     prevPtr->nextPtr = evPtr->nextPtr;
504     }
505     hold = evPtr;
506     evPtr = evPtr->nextPtr;
507     ckfree((char *) hold);
508     } else {
509     prevPtr = evPtr;
510     evPtr = evPtr->nextPtr;
511     }
512     }
513     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
514     }
515    
516     /*
517     *----------------------------------------------------------------------
518     *
519     * Tcl_ServiceEvent --
520     *
521     * Process one event from the event queue, or invoke an
522     * asynchronous event handler. Operates on event queue for
523     * current thread.
524     *
525     * Results:
526     * The return value is 1 if the procedure actually found an event
527     * to process. If no processing occurred, then 0 is returned.
528     *
529     * Side effects:
530     * Invokes all of the event handlers for the highest priority
531     * event in the event queue. May collapse some events into a
532     * single event or discard stale events.
533     *
534     *----------------------------------------------------------------------
535     */
536    
537     int
538     Tcl_ServiceEvent(flags)
539     int flags; /* Indicates what events should be processed.
540     * May be any combination of TCL_WINDOW_EVENTS
541     * TCL_FILE_EVENTS, TCL_TIMER_EVENTS, or other
542     * flags defined elsewhere. Events not
543     * matching this will be skipped for processing
544     * later. */
545     {
546     Tcl_Event *evPtr, *prevPtr;
547     Tcl_EventProc *proc;
548     int result;
549     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
550    
551     /*
552     * Asynchronous event handlers are considered to be the highest
553     * priority events, and so must be invoked before we process events
554     * on the event queue.
555     */
556    
557     if (Tcl_AsyncReady()) {
558     (void) Tcl_AsyncInvoke((Tcl_Interp *) NULL, 0);
559     return 1;
560     }
561    
562     /*
563     * No event flags is equivalent to TCL_ALL_EVENTS.
564     */
565    
566     if ((flags & TCL_ALL_EVENTS) == 0) {
567     flags |= TCL_ALL_EVENTS;
568     }
569    
570     /*
571     * Loop through all the events in the queue until we find one
572     * that can actually be handled.
573     */
574    
575     Tcl_MutexLock(&(tsdPtr->queueMutex));
576     for (evPtr = tsdPtr->firstEventPtr; evPtr != NULL;
577     evPtr = evPtr->nextPtr) {
578     /*
579     * Call the handler for the event. If it actually handles the
580     * event then free the storage for the event. There are two
581     * tricky things here, both stemming from the fact that the event
582     * code may be re-entered while servicing the event:
583     *
584     * 1. Set the "proc" field to NULL. This is a signal to ourselves
585     * that we shouldn't reexecute the handler if the event loop
586     * is re-entered.
587     * 2. When freeing the event, must search the queue again from the
588     * front to find it. This is because the event queue could
589     * change almost arbitrarily while handling the event, so we
590     * can't depend on pointers found now still being valid when
591     * the handler returns.
592     */
593    
594     proc = evPtr->proc;
595     if (proc == NULL) {
596     continue;
597     }
598     evPtr->proc = NULL;
599    
600     /*
601     * Release the lock before calling the event procedure. This
602     * allows other threads to post events if we enter a recursive
603     * event loop in this thread. Note that we are making the assumption
604     * that if the proc returns 0, the event is still in the list.
605     */
606    
607     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
608     result = (*proc)(evPtr, flags);
609     Tcl_MutexLock(&(tsdPtr->queueMutex));
610    
611     if (result) {
612     /*
613     * The event was processed, so remove it from the queue.
614     */
615    
616     if (tsdPtr->firstEventPtr == evPtr) {
617     tsdPtr->firstEventPtr = evPtr->nextPtr;
618     if (evPtr->nextPtr == NULL) {
619     tsdPtr->lastEventPtr = NULL;
620     }
621     if (tsdPtr->markerEventPtr == evPtr) {
622     tsdPtr->markerEventPtr = NULL;
623     }
624     } else {
625     for (prevPtr = tsdPtr->firstEventPtr;
626     prevPtr && prevPtr->nextPtr != evPtr;
627     prevPtr = prevPtr->nextPtr) {
628     /* Empty loop body. */
629     }
630     if (prevPtr) {
631     prevPtr->nextPtr = evPtr->nextPtr;
632     if (evPtr->nextPtr == NULL) {
633     tsdPtr->lastEventPtr = prevPtr;
634     }
635     if (tsdPtr->markerEventPtr == evPtr) {
636     tsdPtr->markerEventPtr = prevPtr;
637     }
638     } else {
639     evPtr = NULL;
640     }
641     }
642     if (evPtr) {
643     ckfree((char *) evPtr);
644     }
645     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
646     return 1;
647     } else {
648     /*
649     * The event wasn't actually handled, so we have to restore
650     * the proc field to allow the event to be attempted again.
651     */
652    
653     evPtr->proc = proc;
654     }
655     }
656     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
657     return 0;
658     }
659    
660     /*
661     *----------------------------------------------------------------------
662     *
663     * Tcl_GetServiceMode --
664     *
665     * This routine returns the current service mode of the notifier.
666     *
667     * Results:
668     * Returns either TCL_SERVICE_ALL or TCL_SERVICE_NONE.
669     *
670     * Side effects:
671     * None.
672     *
673     *----------------------------------------------------------------------
674     */
675    
676     int
677     Tcl_GetServiceMode()
678     {
679     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
680    
681     return tsdPtr->serviceMode;
682     }
683    
684     /*
685     *----------------------------------------------------------------------
686     *
687     * Tcl_SetServiceMode --
688     *
689     * This routine sets the current service mode of the tsdPtr->
690     *
691     * Results:
692     * Returns the previous service mode.
693     *
694     * Side effects:
695     * Invokes the notifier service mode hook procedure.
696     *
697     *----------------------------------------------------------------------
698     */
699    
700     int
701     Tcl_SetServiceMode(mode)
702     int mode; /* New service mode: TCL_SERVICE_ALL or
703     * TCL_SERVICE_NONE */
704     {
705     int oldMode;
706     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
707    
708     oldMode = tsdPtr->serviceMode;
709     tsdPtr->serviceMode = mode;
710     Tcl_ServiceModeHook(mode);
711     return oldMode;
712     }
713    
714     /*
715     *----------------------------------------------------------------------
716     *
717     * Tcl_SetMaxBlockTime --
718     *
719     * This procedure is invoked by event sources to tell the notifier
720     * how long it may block the next time it blocks. The timePtr
721     * argument gives a maximum time; the actual time may be less if
722     * some other event source requested a smaller time.
723     *
724     * Results:
725     * None.
726     *
727     * Side effects:
728     * May reduce the length of the next sleep in the tsdPtr->
729     *
730     *----------------------------------------------------------------------
731     */
732    
733     void
734     Tcl_SetMaxBlockTime(timePtr)
735     Tcl_Time *timePtr; /* Specifies a maximum elapsed time for
736     * the next blocking operation in the
737     * event tsdPtr-> */
738     {
739     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
740    
741     if (!tsdPtr->blockTimeSet || (timePtr->sec < tsdPtr->blockTime.sec)
742     || ((timePtr->sec == tsdPtr->blockTime.sec)
743     && (timePtr->usec < tsdPtr->blockTime.usec))) {
744     tsdPtr->blockTime = *timePtr;
745     tsdPtr->blockTimeSet = 1;
746     }
747    
748     /*
749     * If we are called outside an event source traversal, set the
750     * timeout immediately.
751     */
752    
753     if (!tsdPtr->inTraversal) {
754     if (tsdPtr->blockTimeSet) {
755     Tcl_SetTimer(&tsdPtr->blockTime);
756     } else {
757     Tcl_SetTimer(NULL);
758     }
759     }
760     }
761    
762     /*
763     *----------------------------------------------------------------------
764     *
765     * Tcl_DoOneEvent --
766     *
767     * Process a single event of some sort. If there's no work to
768     * do, wait for an event to occur, then process it.
769     *
770     * Results:
771     * The return value is 1 if the procedure actually found an event
772     * to process. If no processing occurred, then 0 is returned (this
773     * can happen if the TCL_DONT_WAIT flag is set or if there are no
774     * event handlers to wait for in the set specified by flags).
775     *
776     * Side effects:
777     * May delay execution of process while waiting for an event,
778     * unless TCL_DONT_WAIT is set in the flags argument. Event
779     * sources are invoked to check for and queue events. Event
780     * handlers may produce arbitrary side effects.
781     *
782     *----------------------------------------------------------------------
783     */
784    
785     int
786     Tcl_DoOneEvent(flags)
787     int flags; /* Miscellaneous flag values: may be any
788     * combination of TCL_DONT_WAIT,
789     * TCL_WINDOW_EVENTS, TCL_FILE_EVENTS,
790     * TCL_TIMER_EVENTS, TCL_IDLE_EVENTS, or
791     * others defined by event sources. */
792     {
793     int result = 0, oldMode;
794     EventSource *sourcePtr;
795     Tcl_Time *timePtr;
796     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
797    
798     /*
799     * The first thing we do is to service any asynchronous event
800     * handlers.
801     */
802    
803     if (Tcl_AsyncReady()) {
804     (void) Tcl_AsyncInvoke((Tcl_Interp *) NULL, 0);
805     return 1;
806     }
807    
808     /*
809     * No event flags is equivalent to TCL_ALL_EVENTS.
810     */
811    
812     if ((flags & TCL_ALL_EVENTS) == 0) {
813     flags |= TCL_ALL_EVENTS;
814     }
815    
816     /*
817     * Set the service mode to none so notifier event routines won't
818     * try to service events recursively.
819     */
820    
821     oldMode = tsdPtr->serviceMode;
822     tsdPtr->serviceMode = TCL_SERVICE_NONE;
823    
824     /*
825     * The core of this procedure is an infinite loop, even though
826     * we only service one event. The reason for this is that we
827     * may be processing events that don't do anything inside of Tcl.
828     */
829    
830     while (1) {
831    
832     /*
833     * If idle events are the only things to service, skip the
834     * main part of the loop and go directly to handle idle
835     * events (i.e. don't wait even if TCL_DONT_WAIT isn't set).
836     */
837    
838     if ((flags & TCL_ALL_EVENTS) == TCL_IDLE_EVENTS) {
839     flags = TCL_IDLE_EVENTS|TCL_DONT_WAIT;
840     goto idleEvents;
841     }
842    
843     /*
844     * Ask Tcl to service a queued event, if there are any.
845     */
846    
847     if (Tcl_ServiceEvent(flags)) {
848     result = 1;
849     break;
850     }
851    
852     /*
853     * If TCL_DONT_WAIT is set, be sure to poll rather than
854     * blocking, otherwise reset the block time to infinity.
855     */
856    
857     if (flags & TCL_DONT_WAIT) {
858     tsdPtr->blockTime.sec = 0;
859     tsdPtr->blockTime.usec = 0;
860     tsdPtr->blockTimeSet = 1;
861     } else {
862     tsdPtr->blockTimeSet = 0;
863     }
864    
865     /*
866     * Set up all the event sources for new events. This will
867     * cause the block time to be updated if necessary.
868     */
869    
870     tsdPtr->inTraversal = 1;
871     for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
872     sourcePtr = sourcePtr->nextPtr) {
873     if (sourcePtr->setupProc) {
874     (sourcePtr->setupProc)(sourcePtr->clientData, flags);
875     }
876     }
877     tsdPtr->inTraversal = 0;
878    
879     if ((flags & TCL_DONT_WAIT) || tsdPtr->blockTimeSet) {
880     timePtr = &tsdPtr->blockTime;
881     } else {
882     timePtr = NULL;
883     }
884    
885     /*
886     * Wait for a new event or a timeout. If Tcl_WaitForEvent
887     * returns -1, we should abort Tcl_DoOneEvent.
888     */
889    
890     result = Tcl_WaitForEvent(timePtr);
891     if (result < 0) {
892     result = 0;
893     break;
894     }
895    
896     /*
897     * Check all the event sources for new events.
898     */
899    
900     for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
901     sourcePtr = sourcePtr->nextPtr) {
902     if (sourcePtr->checkProc) {
903     (sourcePtr->checkProc)(sourcePtr->clientData, flags);
904     }
905     }
906    
907     /*
908     * Check for events queued by the notifier or event sources.
909     */
910    
911     if (Tcl_ServiceEvent(flags)) {
912     result = 1;
913     break;
914     }
915    
916     /*
917     * We've tried everything at this point, but nobody we know
918     * about had anything to do. Check for idle events. If none,
919     * either quit or go back to the top and try again.
920     */
921    
922     idleEvents:
923     if (flags & TCL_IDLE_EVENTS) {
924     if (TclServiceIdle()) {
925     result = 1;
926     break;
927     }
928     }
929     if (flags & TCL_DONT_WAIT) {
930     break;
931     }
932    
933     /*
934     * If Tcl_WaitForEvent has returned 1,
935     * indicating that one system event has been dispatched
936     * (and thus that some Tcl code might have been indirectly executed),
937     * we break out of the loop.
938     * We do this to give VwaitCmd for instance a chance to check
939     * if that system event had the side effect of changing the
940     * variable (so the vwait can return and unwind properly).
941     *
942     * NB: We will process idle events if any first, because
943     * otherwise we might never do the idle events if the notifier
944     * always gets system events.
945     */
946    
947     if (result) {
948     break;
949     }
950    
951     }
952    
953     tsdPtr->serviceMode = oldMode;
954     return result;
955     }
956    
957     /*
958     *----------------------------------------------------------------------
959     *
960     * Tcl_ServiceAll --
961     *
962     * This routine checks all of the event sources, processes
963     * events that are on the Tcl event queue, and then calls the
964     * any idle handlers. Platform specific notifier callbacks that
965     * generate events should call this routine before returning to
966     * the system in order to ensure that Tcl gets a chance to
967     * process the new events.
968     *
969     * Results:
970     * Returns 1 if an event or idle handler was invoked, else 0.
971     *
972     * Side effects:
973     * Anything that an event or idle handler may do.
974     *
975     *----------------------------------------------------------------------
976     */
977    
978     int
979     Tcl_ServiceAll()
980     {
981     int result = 0;
982     EventSource *sourcePtr;
983     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
984    
985     if (tsdPtr->serviceMode == TCL_SERVICE_NONE) {
986     return result;
987     }
988    
989     /*
990     * We need to turn off event servicing like we to in Tcl_DoOneEvent,
991     * to avoid recursive calls.
992     */
993    
994     tsdPtr->serviceMode = TCL_SERVICE_NONE;
995    
996     /*
997     * Check async handlers first.
998     */
999    
1000     if (Tcl_AsyncReady()) {
1001     (void) Tcl_AsyncInvoke((Tcl_Interp *) NULL, 0);
1002     }
1003    
1004     /*
1005     * Make a single pass through all event sources, queued events,
1006     * and idle handlers. Note that we wait to update the notifier
1007     * timer until the end so we can avoid multiple changes.
1008     */
1009    
1010     tsdPtr->inTraversal = 1;
1011     tsdPtr->blockTimeSet = 0;
1012    
1013     for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
1014     sourcePtr = sourcePtr->nextPtr) {
1015     if (sourcePtr->setupProc) {
1016     (sourcePtr->setupProc)(sourcePtr->clientData, TCL_ALL_EVENTS);
1017     }
1018     }
1019     for (sourcePtr = tsdPtr->firstEventSourcePtr; sourcePtr != NULL;
1020     sourcePtr = sourcePtr->nextPtr) {
1021     if (sourcePtr->checkProc) {
1022     (sourcePtr->checkProc)(sourcePtr->clientData, TCL_ALL_EVENTS);
1023     }
1024     }
1025    
1026     while (Tcl_ServiceEvent(0)) {
1027     result = 1;
1028     }
1029     if (TclServiceIdle()) {
1030     result = 1;
1031     }
1032    
1033     if (!tsdPtr->blockTimeSet) {
1034     Tcl_SetTimer(NULL);
1035     } else {
1036     Tcl_SetTimer(&tsdPtr->blockTime);
1037     }
1038     tsdPtr->inTraversal = 0;
1039     tsdPtr->serviceMode = TCL_SERVICE_ALL;
1040     return result;
1041     }
1042    
1043     /*
1044     *----------------------------------------------------------------------
1045     *
1046     * Tcl_ThreadAlert --
1047     *
1048     * This function wakes up the notifier associated with the
1049     * specified thread (if there is one).
1050     *
1051     * Results:
1052     * None.
1053     *
1054     * Side effects:
1055     * None.
1056     *
1057     *----------------------------------------------------------------------
1058     */
1059    
1060     void
1061     Tcl_ThreadAlert(threadId)
1062     Tcl_ThreadId threadId; /* Identifier for thread to use. */
1063     {
1064     ThreadSpecificData *tsdPtr;
1065    
1066     /*
1067     * Find the notifier associated with the specified thread.
1068     * Note that we need to hold the listLock while calling
1069     * Tcl_AlertNotifier to avoid a race condition where
1070     * the specified thread might destroy its notifier.
1071     */
1072    
1073     Tcl_MutexLock(&listLock);
1074     for (tsdPtr = firstNotifierPtr; tsdPtr; tsdPtr = tsdPtr->nextPtr) {
1075     if (tsdPtr->threadId == threadId) {
1076     Tcl_AlertNotifier(tsdPtr->clientData);
1077     break;
1078     }
1079     }
1080     Tcl_MutexUnlock(&listLock);
1081     }
1082    
1083 dashley 64 /* End of tclnotify.c */

Properties

Name Value
svn:keywords Header

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25