1 /* Asynchronous timers.
2 Copyright (C) 2000 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
24 #include <syssignal.h>
26 #include <blockinput.h>
34 #ifdef HAVE_SYS_TIME_H
38 /* The ubiquitous min/max macros. */
40 #define max(X, Y) ((X) > (Y) ? (X) : (Y))
41 #define min(X, Y) ((X) < (Y) ? (X) : (Y))
43 /* Free-list of atimer structures. */
45 static struct atimer
*free_atimers
;
47 /* List of currently not running timers due to a call to
50 static struct atimer
*stopped_atimers
;
52 /* List of active atimers, sorted by expiration time. The timer that
53 will become ripe next is always at the front of this list. */
55 static struct atimer
*atimers
;
57 /* Non-zero means alarm_signal_handler has found ripe timers but
58 interrupt_input_blocked was non-zero. In this case, timer
59 functions are not called until the next UNBLOCK_INPUT because timer
60 functions are expected to call X, and X cannot be assumed to be
65 /* Block/unblock SIGALRM.. */
67 #define BLOCK_ATIMERS sigblock (sigmask (SIGALRM))
68 #define UNBLOCK_ATIMERS sigunblock (sigmask (SIGALRM))
70 /* Function prototypes. */
72 static void set_alarm
P_ ((void));
73 static void schedule_atimer
P_ ((struct atimer
*));
74 static struct atimer
*append_atimer_lists
P_ ((struct atimer
*,
78 /* Start a new atimer of type TYPE. TIME specifies when the timer is
79 ripe. FN is the function to call when the timer fires.
80 CLIENT_DATA is stored in the client_data member of the atimer
81 structure returned and so made available to FN when it is called.
83 If TYPE is ATIMER_ABSOLUTE, TIME is the absolute time at which the
86 If TYPE is ATIMER_RELATIVE, the timer is ripe TIME s/us in the
89 In both cases, the timer is automatically freed after it has fired.
91 If TYPE is ATIMER_CONTINUOUS, the timer fires every TIME s/us.
93 Value is a pointer to the atimer started. It can be used in calls
94 to cancel_atimer; don't free it yourself. */
97 start_atimer (type
, time
, fn
, client_data
)
98 enum atimer_type type
;
105 /* Round TIME up to the next full second if we don't have
107 #ifndef HAVE_SETITIMER
108 if (EMACS_USECS (time
) != 0)
110 EMACS_SET_USECS (time
, 0);
111 EMACS_SET_SECS (time
, EMACS_SECS (time
) + 1);
113 #endif /* not HAVE_SETITIMER */
115 /* Get an atimer structure from the free-list, or allocate
120 free_atimers
= t
->next
;
123 t
= (struct atimer
*) xmalloc (sizeof *t
);
125 /* Fill the atimer structure. */
126 bzero (t
, sizeof *t
);
129 t
->client_data
= client_data
;
133 /* Compute the timer's expiration time. */
136 case ATIMER_ABSOLUTE
:
137 t
->expiration
= time
;
140 case ATIMER_RELATIVE
:
141 EMACS_GET_TIME (t
->expiration
);
142 EMACS_ADD_TIME (t
->expiration
, t
->expiration
, time
);
145 case ATIMER_CONTINUOUS
:
146 EMACS_GET_TIME (t
->expiration
);
147 EMACS_ADD_TIME (t
->expiration
, t
->expiration
, time
);
152 /* Insert the timer in the list of active atimers. */
156 /* Arrange for a SIGALRM at the time the next atimer is ripe. */
163 /* Cancel and free atimer TIMER. */
166 cancel_atimer (timer
)
167 struct atimer
*timer
;
173 for (i
= 0; i
< 2; ++i
)
175 struct atimer
*t
, *prev
;
176 struct atimer
**list
= i
? &stopped_atimers
: &atimers
;
178 /* See if TIMER is active or stopped. */
179 for (t
= *list
, prev
= NULL
; t
&& t
!= timer
; prev
= t
, t
= t
->next
)
182 /* If it is, take it off the its list, and put in on the
183 free-list. We don't bother to arrange for setting a
184 different alarm time, since a too early one doesn't hurt. */
188 prev
->next
= t
->next
;
192 t
->next
= free_atimers
;
202 /* Append two lists of atimers LIST1 and LIST2 and return the
205 static struct atimer
*
206 append_atimer_lists (list1
, list2
)
207 struct atimer
*list1
, *list2
;
211 else if (list2
== NULL
)
217 for (p
= list1
; p
->next
; p
= p
->next
)
225 /* Stop all timers except timer T. T null means stop all timers. */
228 stop_other_atimers (t
)
235 struct atimer
*p
, *prev
;
237 /* See if T is active. */
238 for (p
= atimers
, prev
= 0; p
&& p
!= t
; p
= p
->next
)
244 prev
->next
= t
->next
;
250 /* T is not active. Let's handle this like T == 0. */
254 stopped_atimers
= append_atimer_lists (atimers
, stopped_atimers
);
260 /* Run all timers again, if some have been stopped with a call to
261 stop_other_atimers. */
268 struct atimer
*t
= atimers
;
272 atimers
= stopped_atimers
;
273 stopped_atimers
= NULL
;
287 /* A version of run_all_timers suitable for a record_unwind_protect. */
290 unwind_stop_other_atimers (dummy
)
298 /* Arrange for a SIGALRM to arrive when the next timer is ripe. */
303 #if defined (USG) && !defined (POSIX_SIGNALS)
304 /* USG systems forget handlers when they are used;
305 must reestablish each time. */
306 signal (SIGALRM
, alarm_signal_handler
);
311 EMACS_TIME now
, time
;
312 #ifdef HAVE_SETITIMER
316 /* Determine s/us till the next timer is ripe. */
317 EMACS_GET_TIME (now
);
318 EMACS_SUB_TIME (time
, atimers
->expiration
, now
);
320 #ifdef HAVE_SETITIMER
321 /* Don't set the interval to 0; this disables the timer. */
322 if (EMACS_TIME_LE (atimers
->expiration
, now
))
324 EMACS_SET_SECS (time
, 0);
325 EMACS_SET_USECS (time
, 1000);
328 bzero (&it
, sizeof it
);
330 setitimer (ITIMER_REAL
, &it
, 0);
331 #else /* not HAVE_SETITIMER */
332 alarm (max (EMACS_SECS (time
), 1));
333 #endif /* not HAVE_SETITIMER */
338 /* Insert timer T into the list of active atimers `atimers', keeping
339 the list sorted by expiration time. T must not be in this list
346 struct atimer
*a
= atimers
, *prev
= NULL
;
348 /* Look for the first atimer that is ripe after T. */
349 while (a
&& EMACS_TIME_GT (t
->expiration
, a
->expiration
))
350 prev
= a
, a
= a
->next
;
352 /* Insert T in front of the atimer found, if any. */
362 /* Signal handler for SIGALRM. SIGNO is the signal number, i.e.
366 alarm_signal_handler (signo
)
371 EMACS_GET_TIME (now
);
375 && (pending_atimers
= interrupt_input_blocked
) == 0
376 && EMACS_TIME_LE (atimers
->expiration
, now
))
381 atimers
= atimers
->next
;
384 if (t
->type
== ATIMER_CONTINUOUS
)
386 EMACS_ADD_TIME (t
->expiration
, now
, t
->interval
);
391 t
->next
= free_atimers
;
395 EMACS_GET_TIME (now
);
398 #if defined (USG) && !defined (POSIX_SIGNALS)
399 /* USG systems forget handlers when they are used;
400 must reestablish each time. */
401 signal (SIGALRM
, alarm_signal_handler
);
408 /* Call alarm_signal_handler for pending timers. */
411 do_pending_atimers ()
416 alarm_signal_handler (SIGALRM
);
422 /* Turn alarms on/off. This seems to be temporarily necessary on
423 some systems like HPUX (see process.c). */
431 signal (SIGALRM
, alarm_signal_handler
);
442 free_atimers
= atimers
= NULL
;
444 signal (SIGALRM
, alarm_signal_handler
);