/[dtapublic]/projs/trunk/shared_source/tcl_base/tcltimer.c
ViewVC logotype

Contents of /projs/trunk/shared_source/tcl_base/tcltimer.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 42 - (show annotations) (download)
Fri Oct 14 01:50:00 2016 UTC (7 years, 8 months ago) by dashley
File MIME type: text/plain
File size: 34525 byte(s)
Move shared source code to commonize.
1 /* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tcl_base/tcltimer.c,v 1.1.1.1 2001/06/13 04:46:38 dtashley Exp $ */
2
3 /*
4 * tclTimer.c --
5 *
6 * This file provides timer event management facilities for Tcl,
7 * including the "after" command.
8 *
9 * Copyright (c) 1997 by Sun Microsystems, Inc.
10 *
11 * See the file "license.terms" for information on usage and redistribution
12 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13 *
14 * RCS: @(#) $Id: tcltimer.c,v 1.1.1.1 2001/06/13 04:46:38 dtashley Exp $
15 */
16
17 #include "tclInt.h"
18 #include "tclPort.h"
19
20 /*
21 * For each timer callback that's pending there is one record of the following
22 * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
23 * together in a list sorted by time (earliest event first).
24 */
25
26 typedef struct TimerHandler {
27 Tcl_Time time; /* When timer is to fire. */
28 Tcl_TimerProc *proc; /* Procedure to call. */
29 ClientData clientData; /* Argument to pass to proc. */
30 Tcl_TimerToken token; /* Identifies handler so it can be
31 * deleted. */
32 struct TimerHandler *nextPtr; /* Next event in queue, or NULL for
33 * end of queue. */
34 } TimerHandler;
35
36 /*
37 * The data structure below is used by the "after" command to remember
38 * the command to be executed later. All of the pending "after" commands
39 * for an interpreter are linked together in a list.
40 */
41
42 typedef struct AfterInfo {
43 struct AfterAssocData *assocPtr;
44 /* Pointer to the "tclAfter" assocData for
45 * the interp in which command will be
46 * executed. */
47 Tcl_Obj *commandPtr; /* Command to execute. */
48 int id; /* Integer identifier for command; used to
49 * cancel it. */
50 Tcl_TimerToken token; /* Used to cancel the "after" command. NULL
51 * means that the command is run as an
52 * idle handler rather than as a timer
53 * handler. NULL means this is an "after
54 * idle" handler rather than a
55 * timer handler. */
56 struct AfterInfo *nextPtr; /* Next in list of all "after" commands for
57 * this interpreter. */
58 } AfterInfo;
59
60 /*
61 * One of the following structures is associated with each interpreter
62 * for which an "after" command has ever been invoked. A pointer to
63 * this structure is stored in the AssocData for the "tclAfter" key.
64 */
65
66 typedef struct AfterAssocData {
67 Tcl_Interp *interp; /* The interpreter for which this data is
68 * registered. */
69 AfterInfo *firstAfterPtr; /* First in list of all "after" commands
70 * still pending for this interpreter, or
71 * NULL if none. */
72 } AfterAssocData;
73
74 /*
75 * There is one of the following structures for each of the
76 * handlers declared in a call to Tcl_DoWhenIdle. All of the
77 * currently-active handlers are linked together into a list.
78 */
79
80 typedef struct IdleHandler {
81 Tcl_IdleProc (*proc); /* Procedure to call. */
82 ClientData clientData; /* Value to pass to proc. */
83 int generation; /* Used to distinguish older handlers from
84 * recently-created ones. */
85 struct IdleHandler *nextPtr;/* Next in list of active handlers. */
86 } IdleHandler;
87
88 /*
89 * The timer and idle queues are per-thread because they are associated
90 * with the notifier, which is also per-thread.
91 *
92 * All static variables used in this file are collected into a single
93 * instance of the following structure. For multi-threaded implementations,
94 * there is one instance of this structure for each thread.
95 *
96 * Notice that different structures with the same name appear in other
97 * files. The structure defined below is used in this file only.
98 */
99
100 typedef struct ThreadSpecificData {
101 TimerHandler *firstTimerHandlerPtr; /* First event in queue. */
102 int lastTimerId; /* Timer identifier of most recently
103 * created timer. */
104 int timerPending; /* 1 if a timer event is in the queue. */
105 IdleHandler *idleList; /* First in list of all idle handlers. */
106 IdleHandler *lastIdlePtr; /* Last in list (or NULL for empty list). */
107 int idleGeneration; /* Used to fill in the "generation" fields
108 * of IdleHandler structures. Increments
109 * each time Tcl_DoOneEvent starts calling
110 * idle handlers, so that all old handlers
111 * can be called without calling any of the
112 * new ones created by old ones. */
113 int afterId; /* For unique identifiers of after events. */
114 } ThreadSpecificData;
115
116 static Tcl_ThreadDataKey dataKey;
117
118 /*
119 * Prototypes for procedures referenced only in this file:
120 */
121
122 static void AfterCleanupProc _ANSI_ARGS_((ClientData clientData,
123 Tcl_Interp *interp));
124 static void AfterProc _ANSI_ARGS_((ClientData clientData));
125 static void FreeAfterPtr _ANSI_ARGS_((AfterInfo *afterPtr));
126 static AfterInfo * GetAfterEvent _ANSI_ARGS_((AfterAssocData *assocPtr,
127 Tcl_Obj *commandPtr));
128 static ThreadSpecificData *InitTimer _ANSI_ARGS_((void));
129 static void TimerExitProc _ANSI_ARGS_((ClientData clientData));
130 static int TimerHandlerEventProc _ANSI_ARGS_((Tcl_Event *evPtr,
131 int flags));
132 static void TimerCheckProc _ANSI_ARGS_((ClientData clientData,
133 int flags));
134 static void TimerSetupProc _ANSI_ARGS_((ClientData clientData,
135 int flags));
136
137 /*
138 *----------------------------------------------------------------------
139 *
140 * InitTimer --
141 *
142 * This function initializes the timer module.
143 *
144 * Results:
145 * A pointer to the thread specific data.
146 *
147 * Side effects:
148 * Registers the idle and timer event sources.
149 *
150 *----------------------------------------------------------------------
151 */
152
153 static ThreadSpecificData *
154 InitTimer()
155 {
156 ThreadSpecificData *tsdPtr =
157 (ThreadSpecificData *) TclThreadDataKeyGet(&dataKey);
158
159 if (tsdPtr == NULL) {
160 tsdPtr = TCL_TSD_INIT(&dataKey);
161 Tcl_CreateEventSource(TimerSetupProc, TimerCheckProc, NULL);
162 Tcl_CreateThreadExitHandler(TimerExitProc, NULL);
163 }
164 return tsdPtr;
165 }
166
167 /*
168 *----------------------------------------------------------------------
169 *
170 * TimerExitProc --
171 *
172 * This function is call at exit or unload time to remove the
173 * timer and idle event sources.
174 *
175 * Results:
176 * None.
177 *
178 * Side effects:
179 * Removes the timer and idle event sources.
180 *
181 *----------------------------------------------------------------------
182 */
183
184 static void
185 TimerExitProc(clientData)
186 ClientData clientData; /* Not used. */
187 {
188 Tcl_DeleteEventSource(TimerSetupProc, TimerCheckProc, NULL);
189 }
190
191 /*
192 *--------------------------------------------------------------
193 *
194 * Tcl_CreateTimerHandler --
195 *
196 * Arrange for a given procedure to be invoked at a particular
197 * time in the future.
198 *
199 * Results:
200 * The return value is a token for the timer event, which
201 * may be used to delete the event before it fires.
202 *
203 * Side effects:
204 * When milliseconds have elapsed, proc will be invoked
205 * exactly once.
206 *
207 *--------------------------------------------------------------
208 */
209
210 Tcl_TimerToken
211 Tcl_CreateTimerHandler(milliseconds, proc, clientData)
212 int milliseconds; /* How many milliseconds to wait
213 * before invoking proc. */
214 Tcl_TimerProc *proc; /* Procedure to invoke. */
215 ClientData clientData; /* Arbitrary data to pass to proc. */
216 {
217 register TimerHandler *timerHandlerPtr, *tPtr2, *prevPtr;
218 Tcl_Time time;
219 ThreadSpecificData *tsdPtr;
220
221 tsdPtr = InitTimer();
222
223 timerHandlerPtr = (TimerHandler *) ckalloc(sizeof(TimerHandler));
224
225 /*
226 * Compute when the event should fire.
227 */
228
229 TclpGetTime(&time);
230 timerHandlerPtr->time.sec = time.sec + milliseconds/1000;
231 timerHandlerPtr->time.usec = time.usec + (milliseconds%1000)*1000;
232 if (timerHandlerPtr->time.usec >= 1000000) {
233 timerHandlerPtr->time.usec -= 1000000;
234 timerHandlerPtr->time.sec += 1;
235 }
236
237 /*
238 * Fill in other fields for the event.
239 */
240
241 timerHandlerPtr->proc = proc;
242 timerHandlerPtr->clientData = clientData;
243 tsdPtr->lastTimerId++;
244 timerHandlerPtr->token = (Tcl_TimerToken) tsdPtr->lastTimerId;
245
246 /*
247 * Add the event to the queue in the correct position
248 * (ordered by event firing time).
249 */
250
251 for (tPtr2 = tsdPtr->firstTimerHandlerPtr, prevPtr = NULL; tPtr2 != NULL;
252 prevPtr = tPtr2, tPtr2 = tPtr2->nextPtr) {
253 if ((tPtr2->time.sec > timerHandlerPtr->time.sec)
254 || ((tPtr2->time.sec == timerHandlerPtr->time.sec)
255 && (tPtr2->time.usec > timerHandlerPtr->time.usec))) {
256 break;
257 }
258 }
259 timerHandlerPtr->nextPtr = tPtr2;
260 if (prevPtr == NULL) {
261 tsdPtr->firstTimerHandlerPtr = timerHandlerPtr;
262 } else {
263 prevPtr->nextPtr = timerHandlerPtr;
264 }
265
266 TimerSetupProc(NULL, TCL_ALL_EVENTS);
267
268 return timerHandlerPtr->token;
269 }
270
271 /*
272 *--------------------------------------------------------------
273 *
274 * Tcl_DeleteTimerHandler --
275 *
276 * Delete a previously-registered timer handler.
277 *
278 * Results:
279 * None.
280 *
281 * Side effects:
282 * Destroy the timer callback identified by TimerToken,
283 * so that its associated procedure will not be called.
284 * If the callback has already fired, or if the given
285 * token doesn't exist, then nothing happens.
286 *
287 *--------------------------------------------------------------
288 */
289
290 void
291 Tcl_DeleteTimerHandler(token)
292 Tcl_TimerToken token; /* Result previously returned by
293 * Tcl_DeleteTimerHandler. */
294 {
295 register TimerHandler *timerHandlerPtr, *prevPtr;
296 ThreadSpecificData *tsdPtr;
297
298 tsdPtr = InitTimer();
299 for (timerHandlerPtr = tsdPtr->firstTimerHandlerPtr, prevPtr = NULL;
300 timerHandlerPtr != NULL; prevPtr = timerHandlerPtr,
301 timerHandlerPtr = timerHandlerPtr->nextPtr) {
302 if (timerHandlerPtr->token != token) {
303 continue;
304 }
305 if (prevPtr == NULL) {
306 tsdPtr->firstTimerHandlerPtr = timerHandlerPtr->nextPtr;
307 } else {
308 prevPtr->nextPtr = timerHandlerPtr->nextPtr;
309 }
310 ckfree((char *) timerHandlerPtr);
311 return;
312 }
313 }
314
315 /*
316 *----------------------------------------------------------------------
317 *
318 * TimerSetupProc --
319 *
320 * This function is called by Tcl_DoOneEvent to setup the timer
321 * event source for before blocking. This routine checks both the
322 * idle and after timer lists.
323 *
324 * Results:
325 * None.
326 *
327 * Side effects:
328 * May update the maximum notifier block time.
329 *
330 *----------------------------------------------------------------------
331 */
332
333 static void
334 TimerSetupProc(data, flags)
335 ClientData data; /* Not used. */
336 int flags; /* Event flags as passed to Tcl_DoOneEvent. */
337 {
338 Tcl_Time blockTime;
339 ThreadSpecificData *tsdPtr = InitTimer();
340
341 if (((flags & TCL_IDLE_EVENTS) && tsdPtr->idleList)
342 || ((flags & TCL_TIMER_EVENTS) && tsdPtr->timerPending)) {
343 /*
344 * There is an idle handler or a pending timer event, so just poll.
345 */
346
347 blockTime.sec = 0;
348 blockTime.usec = 0;
349
350 } else if ((flags & TCL_TIMER_EVENTS) && tsdPtr->firstTimerHandlerPtr) {
351 /*
352 * Compute the timeout for the next timer on the list.
353 */
354
355 TclpGetTime(&blockTime);
356 blockTime.sec = tsdPtr->firstTimerHandlerPtr->time.sec - blockTime.sec;
357 blockTime.usec = tsdPtr->firstTimerHandlerPtr->time.usec -
358 blockTime.usec;
359 if (blockTime.usec < 0) {
360 blockTime.sec -= 1;
361 blockTime.usec += 1000000;
362 }
363 if (blockTime.sec < 0) {
364 blockTime.sec = 0;
365 blockTime.usec = 0;
366 }
367 } else {
368 return;
369 }
370
371 Tcl_SetMaxBlockTime(&blockTime);
372 }
373
374 /*
375 *----------------------------------------------------------------------
376 *
377 * TimerCheckProc --
378 *
379 * This function is called by Tcl_DoOneEvent to check the timer
380 * event source for events. This routine checks both the
381 * idle and after timer lists.
382 *
383 * Results:
384 * None.
385 *
386 * Side effects:
387 * May queue an event and update the maximum notifier block time.
388 *
389 *----------------------------------------------------------------------
390 */
391
392 static void
393 TimerCheckProc(data, flags)
394 ClientData data; /* Not used. */
395 int flags; /* Event flags as passed to Tcl_DoOneEvent. */
396 {
397 Tcl_Event *timerEvPtr;
398 Tcl_Time blockTime;
399 ThreadSpecificData *tsdPtr = InitTimer();
400
401 if ((flags & TCL_TIMER_EVENTS) && tsdPtr->firstTimerHandlerPtr) {
402 /*
403 * Compute the timeout for the next timer on the list.
404 */
405
406 TclpGetTime(&blockTime);
407 blockTime.sec = tsdPtr->firstTimerHandlerPtr->time.sec - blockTime.sec;
408 blockTime.usec = tsdPtr->firstTimerHandlerPtr->time.usec -
409 blockTime.usec;
410 if (blockTime.usec < 0) {
411 blockTime.sec -= 1;
412 blockTime.usec += 1000000;
413 }
414 if (blockTime.sec < 0) {
415 blockTime.sec = 0;
416 blockTime.usec = 0;
417 }
418
419 /*
420 * If the first timer has expired, stick an event on the queue.
421 */
422
423 if (blockTime.sec == 0 && blockTime.usec == 0 &&
424 !tsdPtr->timerPending) {
425 tsdPtr->timerPending = 1;
426 timerEvPtr = (Tcl_Event *) ckalloc(sizeof(Tcl_Event));
427 timerEvPtr->proc = TimerHandlerEventProc;
428 Tcl_QueueEvent(timerEvPtr, TCL_QUEUE_TAIL);
429 }
430 }
431 }
432
433 /*
434 *----------------------------------------------------------------------
435 *
436 * TimerHandlerEventProc --
437 *
438 * This procedure is called by Tcl_ServiceEvent when a timer event
439 * reaches the front of the event queue. This procedure handles
440 * the event by invoking the callbacks for all timers that are
441 * ready.
442 *
443 * Results:
444 * Returns 1 if the event was handled, meaning it should be removed
445 * from the queue. Returns 0 if the event was not handled, meaning
446 * it should stay on the queue. The only time the event isn't
447 * handled is if the TCL_TIMER_EVENTS flag bit isn't set.
448 *
449 * Side effects:
450 * Whatever the timer handler callback procedures do.
451 *
452 *----------------------------------------------------------------------
453 */
454
455 static int
456 TimerHandlerEventProc(evPtr, flags)
457 Tcl_Event *evPtr; /* Event to service. */
458 int flags; /* Flags that indicate what events to
459 * handle, such as TCL_FILE_EVENTS. */
460 {
461 TimerHandler *timerHandlerPtr, **nextPtrPtr;
462 Tcl_Time time;
463 int currentTimerId;
464 ThreadSpecificData *tsdPtr = InitTimer();
465
466 /*
467 * Do nothing if timers aren't enabled. This leaves the event on the
468 * queue, so we will get to it as soon as ServiceEvents() is called
469 * with timers enabled.
470 */
471
472 if (!(flags & TCL_TIMER_EVENTS)) {
473 return 0;
474 }
475
476 /*
477 * The code below is trickier than it may look, for the following
478 * reasons:
479 *
480 * 1. New handlers can get added to the list while the current
481 * one is being processed. If new ones get added, we don't
482 * want to process them during this pass through the list to avoid
483 * starving other event sources. This is implemented using the
484 * token number in the handler: new handlers will have a
485 * newer token than any of the ones currently on the list.
486 * 2. The handler can call Tcl_DoOneEvent, so we have to remove
487 * the handler from the list before calling it. Otherwise an
488 * infinite loop could result.
489 * 3. Tcl_DeleteTimerHandler can be called to remove an element from
490 * the list while a handler is executing, so the list could
491 * change structure during the call.
492 * 4. Because we only fetch the current time before entering the loop,
493 * the only way a new timer will even be considered runnable is if
494 * its expiration time is within the same millisecond as the
495 * current time. This is fairly likely on Windows, since it has
496 * a course granularity clock. Since timers are placed
497 * on the queue in time order with the most recently created
498 * handler appearing after earlier ones with the same expiration
499 * time, we don't have to worry about newer generation timers
500 * appearing before later ones.
501 */
502
503 tsdPtr->timerPending = 0;
504 currentTimerId = tsdPtr->lastTimerId;
505 TclpGetTime(&time);
506 while (1) {
507 nextPtrPtr = &tsdPtr->firstTimerHandlerPtr;
508 timerHandlerPtr = tsdPtr->firstTimerHandlerPtr;
509 if (timerHandlerPtr == NULL) {
510 break;
511 }
512
513 if ((timerHandlerPtr->time.sec > time.sec)
514 || ((timerHandlerPtr->time.sec == time.sec)
515 && (timerHandlerPtr->time.usec > time.usec))) {
516 break;
517 }
518
519 /*
520 * Bail out if the next timer is of a newer generation.
521 */
522
523 if ((currentTimerId - (int)timerHandlerPtr->token) < 0) {
524 break;
525 }
526
527 /*
528 * Remove the handler from the queue before invoking it,
529 * to avoid potential reentrancy problems.
530 */
531
532 (*nextPtrPtr) = timerHandlerPtr->nextPtr;
533 (*timerHandlerPtr->proc)(timerHandlerPtr->clientData);
534 ckfree((char *) timerHandlerPtr);
535 }
536 TimerSetupProc(NULL, TCL_TIMER_EVENTS);
537 return 1;
538 }
539
540 /*
541 *--------------------------------------------------------------
542 *
543 * Tcl_DoWhenIdle --
544 *
545 * Arrange for proc to be invoked the next time the system is
546 * idle (i.e., just before the next time that Tcl_DoOneEvent
547 * would have to wait for something to happen).
548 *
549 * Results:
550 * None.
551 *
552 * Side effects:
553 * Proc will eventually be called, with clientData as argument.
554 * See the manual entry for details.
555 *
556 *--------------------------------------------------------------
557 */
558
559 void
560 Tcl_DoWhenIdle(proc, clientData)
561 Tcl_IdleProc *proc; /* Procedure to invoke. */
562 ClientData clientData; /* Arbitrary value to pass to proc. */
563 {
564 register IdleHandler *idlePtr;
565 Tcl_Time blockTime;
566 ThreadSpecificData *tsdPtr = InitTimer();
567
568 idlePtr = (IdleHandler *) ckalloc(sizeof(IdleHandler));
569 idlePtr->proc = proc;
570 idlePtr->clientData = clientData;
571 idlePtr->generation = tsdPtr->idleGeneration;
572 idlePtr->nextPtr = NULL;
573 if (tsdPtr->lastIdlePtr == NULL) {
574 tsdPtr->idleList = idlePtr;
575 } else {
576 tsdPtr->lastIdlePtr->nextPtr = idlePtr;
577 }
578 tsdPtr->lastIdlePtr = idlePtr;
579
580 blockTime.sec = 0;
581 blockTime.usec = 0;
582 Tcl_SetMaxBlockTime(&blockTime);
583 }
584
585 /*
586 *----------------------------------------------------------------------
587 *
588 * Tcl_CancelIdleCall --
589 *
590 * If there are any when-idle calls requested to a given procedure
591 * with given clientData, cancel all of them.
592 *
593 * Results:
594 * None.
595 *
596 * Side effects:
597 * If the proc/clientData combination were on the when-idle list,
598 * they are removed so that they will never be called.
599 *
600 *----------------------------------------------------------------------
601 */
602
603 void
604 Tcl_CancelIdleCall(proc, clientData)
605 Tcl_IdleProc *proc; /* Procedure that was previously registered. */
606 ClientData clientData; /* Arbitrary value to pass to proc. */
607 {
608 register IdleHandler *idlePtr, *prevPtr;
609 IdleHandler *nextPtr;
610 ThreadSpecificData *tsdPtr = InitTimer();
611
612 for (prevPtr = NULL, idlePtr = tsdPtr->idleList; idlePtr != NULL;
613 prevPtr = idlePtr, idlePtr = idlePtr->nextPtr) {
614 while ((idlePtr->proc == proc)
615 && (idlePtr->clientData == clientData)) {
616 nextPtr = idlePtr->nextPtr;
617 ckfree((char *) idlePtr);
618 idlePtr = nextPtr;
619 if (prevPtr == NULL) {
620 tsdPtr->idleList = idlePtr;
621 } else {
622 prevPtr->nextPtr = idlePtr;
623 }
624 if (idlePtr == NULL) {
625 tsdPtr->lastIdlePtr = prevPtr;
626 return;
627 }
628 }
629 }
630 }
631
632 /*
633 *----------------------------------------------------------------------
634 *
635 * TclServiceIdle --
636 *
637 * This procedure is invoked by the notifier when it becomes
638 * idle. It will invoke all idle handlers that are present at
639 * the time the call is invoked, but not those added during idle
640 * processing.
641 *
642 * Results:
643 * The return value is 1 if TclServiceIdle found something to
644 * do, otherwise return value is 0.
645 *
646 * Side effects:
647 * Invokes all pending idle handlers.
648 *
649 *----------------------------------------------------------------------
650 */
651
652 int
653 TclServiceIdle()
654 {
655 IdleHandler *idlePtr;
656 int oldGeneration;
657 Tcl_Time blockTime;
658 ThreadSpecificData *tsdPtr = InitTimer();
659
660 if (tsdPtr->idleList == NULL) {
661 return 0;
662 }
663
664 oldGeneration = tsdPtr->idleGeneration;
665 tsdPtr->idleGeneration++;
666
667 /*
668 * The code below is trickier than it may look, for the following
669 * reasons:
670 *
671 * 1. New handlers can get added to the list while the current
672 * one is being processed. If new ones get added, we don't
673 * want to process them during this pass through the list (want
674 * to check for other work to do first). This is implemented
675 * using the generation number in the handler: new handlers
676 * will have a different generation than any of the ones currently
677 * on the list.
678 * 2. The handler can call Tcl_DoOneEvent, so we have to remove
679 * the handler from the list before calling it. Otherwise an
680 * infinite loop could result.
681 * 3. Tcl_CancelIdleCall can be called to remove an element from
682 * the list while a handler is executing, so the list could
683 * change structure during the call.
684 */
685
686 for (idlePtr = tsdPtr->idleList;
687 ((idlePtr != NULL)
688 && ((oldGeneration - idlePtr->generation) >= 0));
689 idlePtr = tsdPtr->idleList) {
690 tsdPtr->idleList = idlePtr->nextPtr;
691 if (tsdPtr->idleList == NULL) {
692 tsdPtr->lastIdlePtr = NULL;
693 }
694 (*idlePtr->proc)(idlePtr->clientData);
695 ckfree((char *) idlePtr);
696 }
697 if (tsdPtr->idleList) {
698 blockTime.sec = 0;
699 blockTime.usec = 0;
700 Tcl_SetMaxBlockTime(&blockTime);
701 }
702 return 1;
703 }
704
705 /*
706 *----------------------------------------------------------------------
707 *
708 * Tcl_AfterObjCmd --
709 *
710 * This procedure is invoked to process the "after" Tcl command.
711 * See the user documentation for details on what it does.
712 *
713 * Results:
714 * A standard Tcl result.
715 *
716 * Side effects:
717 * See the user documentation.
718 *
719 *----------------------------------------------------------------------
720 */
721
722 /* ARGSUSED */
723 int
724 Tcl_AfterObjCmd(clientData, interp, objc, objv)
725 ClientData clientData; /* Points to the "tclAfter" assocData for
726 * this interpreter, or NULL if the assocData
727 * hasn't been created yet.*/
728 Tcl_Interp *interp; /* Current interpreter. */
729 int objc; /* Number of arguments. */
730 Tcl_Obj *CONST objv[]; /* Argument objects. */
731 {
732 int ms;
733 AfterInfo *afterPtr;
734 AfterAssocData *assocPtr = (AfterAssocData *) clientData;
735 Tcl_CmdInfo cmdInfo;
736 int length;
737 char *argString;
738 int index;
739 char buf[16 + TCL_INTEGER_SPACE];
740 static char *afterSubCmds[] = {"cancel", "idle", "info", (char *) NULL};
741 enum afterSubCmds {AFTER_CANCEL, AFTER_IDLE, AFTER_INFO};
742 ThreadSpecificData *tsdPtr = InitTimer();
743
744 if (objc < 2) {
745 Tcl_WrongNumArgs(interp, 1, objv, "option ?arg arg ...?");
746 return TCL_ERROR;
747 }
748
749 /*
750 * Create the "after" information associated for this interpreter,
751 * if it doesn't already exist. Associate it with the command too,
752 * so that it will be passed in as the ClientData argument in the
753 * future.
754 */
755
756 if (assocPtr == NULL) {
757 assocPtr = (AfterAssocData *) ckalloc(sizeof(AfterAssocData));
758 assocPtr->interp = interp;
759 assocPtr->firstAfterPtr = NULL;
760 Tcl_SetAssocData(interp, "tclAfter", AfterCleanupProc,
761 (ClientData) assocPtr);
762 cmdInfo.proc = NULL;
763 cmdInfo.clientData = (ClientData) NULL;
764 cmdInfo.objProc = Tcl_AfterObjCmd;
765 cmdInfo.objClientData = (ClientData) assocPtr;
766 cmdInfo.deleteProc = NULL;
767 cmdInfo.deleteData = (ClientData) assocPtr;
768 Tcl_SetCommandInfo(interp, Tcl_GetStringFromObj(objv[0], &length),
769 &cmdInfo);
770 }
771
772 /*
773 * First lets see if the command was passed a number as the first argument.
774 */
775
776 if (objv[1]->typePtr == &tclIntType) {
777 ms = (int) objv[1]->internalRep.longValue;
778 goto processInteger;
779 }
780 argString = Tcl_GetStringFromObj(objv[1], &length);
781 if (isdigit(UCHAR(argString[0]))) { /* INTL: digit */
782 if (Tcl_GetIntFromObj(interp, objv[1], &ms) != TCL_OK) {
783 return TCL_ERROR;
784 }
785 processInteger:
786 if (ms < 0) {
787 ms = 0;
788 }
789 if (objc == 2) {
790 Tcl_Sleep(ms);
791 return TCL_OK;
792 }
793 afterPtr = (AfterInfo *) ckalloc((unsigned) (sizeof(AfterInfo)));
794 afterPtr->assocPtr = assocPtr;
795 if (objc == 3) {
796 afterPtr->commandPtr = objv[2];
797 } else {
798 afterPtr->commandPtr = Tcl_ConcatObj(objc-2, objv+2);
799 }
800 Tcl_IncrRefCount(afterPtr->commandPtr);
801 /*
802 * The variable below is used to generate unique identifiers for
803 * after commands. This id can wrap around, which can potentially
804 * cause problems. However, there are not likely to be problems
805 * in practice, because after commands can only be requested to
806 * about a month in the future, and wrap-around is unlikely to
807 * occur in less than about 1-10 years. Thus it's unlikely that
808 * any old ids will still be around when wrap-around occurs.
809 */
810 afterPtr->id = tsdPtr->afterId;
811 tsdPtr->afterId += 1;
812 afterPtr->token = Tcl_CreateTimerHandler(ms, AfterProc,
813 (ClientData) afterPtr);
814 afterPtr->nextPtr = assocPtr->firstAfterPtr;
815 assocPtr->firstAfterPtr = afterPtr;
816 sprintf(buf, "after#%d", afterPtr->id);
817 Tcl_AppendResult(interp, buf, (char *) NULL);
818 return TCL_OK;
819 }
820
821 /*
822 * If it's not a number it must be a subcommand.
823 */
824
825 if (Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "argument",
826 0, &index) != TCL_OK) {
827 Tcl_AppendResult(interp, "bad argument \"", argString,
828 "\": must be cancel, idle, info, or a number",
829 (char *) NULL);
830 return TCL_ERROR;
831 }
832 switch ((enum afterSubCmds) index) {
833 case AFTER_CANCEL: {
834 Tcl_Obj *commandPtr;
835 char *command, *tempCommand;
836 int tempLength;
837
838 if (objc < 3) {
839 Tcl_WrongNumArgs(interp, 2, objv, "id|command");
840 return TCL_ERROR;
841 }
842 if (objc == 3) {
843 commandPtr = objv[2];
844 } else {
845 commandPtr = Tcl_ConcatObj(objc-2, objv+2);;
846 }
847 command = Tcl_GetStringFromObj(commandPtr, &length);
848 for (afterPtr = assocPtr->firstAfterPtr; afterPtr != NULL;
849 afterPtr = afterPtr->nextPtr) {
850 tempCommand = Tcl_GetStringFromObj(afterPtr->commandPtr,
851 &tempLength);
852 if ((length == tempLength)
853 && (memcmp((void*) command, (void*) tempCommand,
854 (unsigned) length) == 0)) {
855 break;
856 }
857 }
858 if (afterPtr == NULL) {
859 afterPtr = GetAfterEvent(assocPtr, commandPtr);
860 }
861 if (objc != 3) {
862 Tcl_DecrRefCount(commandPtr);
863 }
864 if (afterPtr != NULL) {
865 if (afterPtr->token != NULL) {
866 Tcl_DeleteTimerHandler(afterPtr->token);
867 } else {
868 Tcl_CancelIdleCall(AfterProc, (ClientData) afterPtr);
869 }
870 FreeAfterPtr(afterPtr);
871 }
872 break;
873 }
874 case AFTER_IDLE:
875 if (objc < 3) {
876 Tcl_WrongNumArgs(interp, 2, objv, "script script ...");
877 return TCL_ERROR;
878 }
879 afterPtr = (AfterInfo *) ckalloc((unsigned) (sizeof(AfterInfo)));
880 afterPtr->assocPtr = assocPtr;
881 if (objc == 3) {
882 afterPtr->commandPtr = objv[2];
883 } else {
884 afterPtr->commandPtr = Tcl_ConcatObj(objc-2, objv+2);
885 }
886 Tcl_IncrRefCount(afterPtr->commandPtr);
887 afterPtr->id = tsdPtr->afterId;
888 tsdPtr->afterId += 1;
889 afterPtr->token = NULL;
890 afterPtr->nextPtr = assocPtr->firstAfterPtr;
891 assocPtr->firstAfterPtr = afterPtr;
892 Tcl_DoWhenIdle(AfterProc, (ClientData) afterPtr);
893 sprintf(buf, "after#%d", afterPtr->id);
894 Tcl_AppendResult(interp, buf, (char *) NULL);
895 break;
896 case AFTER_INFO: {
897 Tcl_Obj *resultListPtr;
898
899 if (objc == 2) {
900 for (afterPtr = assocPtr->firstAfterPtr; afterPtr != NULL;
901 afterPtr = afterPtr->nextPtr) {
902 if (assocPtr->interp == interp) {
903 sprintf(buf, "after#%d", afterPtr->id);
904 Tcl_AppendElement(interp, buf);
905 }
906 }
907 return TCL_OK;
908 }
909 if (objc != 3) {
910 Tcl_WrongNumArgs(interp, 2, objv, "?id?");
911 return TCL_ERROR;
912 }
913 afterPtr = GetAfterEvent(assocPtr, objv[2]);
914 if (afterPtr == NULL) {
915 Tcl_AppendResult(interp, "event \"", Tcl_GetString(objv[2]),
916 "\" doesn't exist", (char *) NULL);
917 return TCL_ERROR;
918 }
919 resultListPtr = Tcl_GetObjResult(interp);
920 Tcl_ListObjAppendElement(interp, resultListPtr, afterPtr->commandPtr);
921 Tcl_ListObjAppendElement(interp, resultListPtr, Tcl_NewStringObj(
922 (afterPtr->token == NULL) ? "idle" : "timer", -1));
923 Tcl_SetObjResult(interp, resultListPtr);
924 break;
925 }
926 default: {
927 panic("Tcl_AfterObjCmd: bad subcommand index to afterSubCmds");
928 }
929 }
930 return TCL_OK;
931 }
932
933 /*
934 *----------------------------------------------------------------------
935 *
936 * GetAfterEvent --
937 *
938 * This procedure parses an "after" id such as "after#4" and
939 * returns a pointer to the AfterInfo structure.
940 *
941 * Results:
942 * The return value is either a pointer to an AfterInfo structure,
943 * if one is found that corresponds to "cmdString" and is for interp,
944 * or NULL if no corresponding after event can be found.
945 *
946 * Side effects:
947 * None.
948 *
949 *----------------------------------------------------------------------
950 */
951
952 static AfterInfo *
953 GetAfterEvent(assocPtr, commandPtr)
954 AfterAssocData *assocPtr; /* Points to "after"-related information for
955 * this interpreter. */
956 Tcl_Obj *commandPtr;
957 {
958 char *cmdString; /* Textual identifier for after event, such
959 * as "after#6". */
960 AfterInfo *afterPtr;
961 int id;
962 char *end;
963
964 cmdString = Tcl_GetString(commandPtr);
965 if (strncmp(cmdString, "after#", 6) != 0) {
966 return NULL;
967 }
968 cmdString += 6;
969 id = strtoul(cmdString, &end, 10);
970 if ((end == cmdString) || (*end != 0)) {
971 return NULL;
972 }
973 for (afterPtr = assocPtr->firstAfterPtr; afterPtr != NULL;
974 afterPtr = afterPtr->nextPtr) {
975 if (afterPtr->id == id) {
976 return afterPtr;
977 }
978 }
979 return NULL;
980 }
981
982 /*
983 *----------------------------------------------------------------------
984 *
985 * AfterProc --
986 *
987 * Timer callback to execute commands registered with the
988 * "after" command.
989 *
990 * Results:
991 * None.
992 *
993 * Side effects:
994 * Executes whatever command was specified. If the command
995 * returns an error, then the command "bgerror" is invoked
996 * to process the error; if bgerror fails then information
997 * about the error is output on stderr.
998 *
999 *----------------------------------------------------------------------
1000 */
1001
1002 static void
1003 AfterProc(clientData)
1004 ClientData clientData; /* Describes command to execute. */
1005 {
1006 AfterInfo *afterPtr = (AfterInfo *) clientData;
1007 AfterAssocData *assocPtr = afterPtr->assocPtr;
1008 AfterInfo *prevPtr;
1009 int result;
1010 Tcl_Interp *interp;
1011 char *script;
1012 int numBytes;
1013
1014 /*
1015 * First remove the callback from our list of callbacks; otherwise
1016 * someone could delete the callback while it's being executed, which
1017 * could cause a core dump.
1018 */
1019
1020 if (assocPtr->firstAfterPtr == afterPtr) {
1021 assocPtr->firstAfterPtr = afterPtr->nextPtr;
1022 } else {
1023 for (prevPtr = assocPtr->firstAfterPtr; prevPtr->nextPtr != afterPtr;
1024 prevPtr = prevPtr->nextPtr) {
1025 /* Empty loop body. */
1026 }
1027 prevPtr->nextPtr = afterPtr->nextPtr;
1028 }
1029
1030 /*
1031 * Execute the callback.
1032 */
1033
1034 interp = assocPtr->interp;
1035 Tcl_Preserve((ClientData) interp);
1036 script = Tcl_GetStringFromObj(afterPtr->commandPtr, &numBytes);
1037 result = Tcl_EvalEx(interp, script, numBytes, TCL_EVAL_GLOBAL);
1038 if (result != TCL_OK) {
1039 Tcl_AddErrorInfo(interp, "\n (\"after\" script)");
1040 Tcl_BackgroundError(interp);
1041 }
1042 Tcl_Release((ClientData) interp);
1043
1044 /*
1045 * Free the memory for the callback.
1046 */
1047
1048 Tcl_DecrRefCount(afterPtr->commandPtr);
1049 ckfree((char *) afterPtr);
1050 }
1051
1052 /*
1053 *----------------------------------------------------------------------
1054 *
1055 * FreeAfterPtr --
1056 *
1057 * This procedure removes an "after" command from the list of
1058 * those that are pending and frees its resources. This procedure
1059 * does *not* cancel the timer handler; if that's needed, the
1060 * caller must do it.
1061 *
1062 * Results:
1063 * None.
1064 *
1065 * Side effects:
1066 * The memory associated with afterPtr is released.
1067 *
1068 *----------------------------------------------------------------------
1069 */
1070
1071 static void
1072 FreeAfterPtr(afterPtr)
1073 AfterInfo *afterPtr; /* Command to be deleted. */
1074 {
1075 AfterInfo *prevPtr;
1076 AfterAssocData *assocPtr = afterPtr->assocPtr;
1077
1078 if (assocPtr->firstAfterPtr == afterPtr) {
1079 assocPtr->firstAfterPtr = afterPtr->nextPtr;
1080 } else {
1081 for (prevPtr = assocPtr->firstAfterPtr; prevPtr->nextPtr != afterPtr;
1082 prevPtr = prevPtr->nextPtr) {
1083 /* Empty loop body. */
1084 }
1085 prevPtr->nextPtr = afterPtr->nextPtr;
1086 }
1087 Tcl_DecrRefCount(afterPtr->commandPtr);
1088 ckfree((char *) afterPtr);
1089 }
1090
1091 /*
1092 *----------------------------------------------------------------------
1093 *
1094 * AfterCleanupProc --
1095 *
1096 * This procedure is invoked whenever an interpreter is deleted
1097 * to cleanup the AssocData for "tclAfter".
1098 *
1099 * Results:
1100 * None.
1101 *
1102 * Side effects:
1103 * After commands are removed.
1104 *
1105 *----------------------------------------------------------------------
1106 */
1107
1108 /* ARGSUSED */
1109 static void
1110 AfterCleanupProc(clientData, interp)
1111 ClientData clientData; /* Points to AfterAssocData for the
1112 * interpreter. */
1113 Tcl_Interp *interp; /* Interpreter that is being deleted. */
1114 {
1115 AfterAssocData *assocPtr = (AfterAssocData *) clientData;
1116 AfterInfo *afterPtr;
1117
1118 while (assocPtr->firstAfterPtr != NULL) {
1119 afterPtr = assocPtr->firstAfterPtr;
1120 assocPtr->firstAfterPtr = afterPtr->nextPtr;
1121 if (afterPtr->token != NULL) {
1122 Tcl_DeleteTimerHandler(afterPtr->token);
1123 } else {
1124 Tcl_CancelIdleCall(AfterProc, (ClientData) afterPtr);
1125 }
1126 Tcl_DecrRefCount(afterPtr->commandPtr);
1127 ckfree((char *) afterPtr);
1128 }
1129 ckfree((char *) assocPtr);
1130 }
1131
1132
1133 /* $History: tcltimer.c $
1134 *
1135 * ***************** Version 1 *****************
1136 * User: Dtashley Date: 1/02/01 Time: 1:05a
1137 * Created in $/IjuScripter, IjuConsole/Source/Tcl Base
1138 * Initial check-in.
1139 */
1140
1141 /* End of TCLTIMER.C */

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25