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
= 0; t
&& t
!= timer
; 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
;
201 /* Append two lists of atimers LIST1 and LIST2 and return the
204 static struct atimer
*
205 append_atimer_lists (list1
, list2
)
206 struct atimer
*list1
, *list2
;
210 else if (list2
== NULL
)
216 for (p
= list1
; p
->next
; p
= p
->next
)
224 /* Stop all timers except timer T. T null means stop all timers. */
227 stop_other_atimers (t
)
234 struct atimer
*p
, *prev
;
236 /* See if T is active. */
237 for (p
= atimers
, prev
= 0; p
&& p
!= t
; p
= p
->next
)
243 prev
->next
= t
->next
;
249 /* T is not active. Let's handle this like T == 0. */
253 stopped_atimers
= append_atimer_lists (atimers
, stopped_atimers
);
259 /* Run all timers again, if some have been stopped with a call to
260 stop_other_atimers. */
267 struct atimer
*t
= atimers
;
271 atimers
= stopped_atimers
;
272 stopped_atimers
= NULL
;
286 /* A version of run_all_timers suitable for a record_unwind_protect. */
289 unwind_stop_other_atimers (dummy
)
297 /* Arrange for a SIGALRM to arrive when the next timer is ripe. */
302 #if defined (USG) && !defined (POSIX_SIGNALS)
303 /* USG systems forget handlers when they are used;
304 must reestablish each time. */
305 signal (SIGALRM
, alarm_signal_handler
);
310 EMACS_TIME now
, time
;
311 #ifdef HAVE_SETITIMER
315 /* Determine s/us till the next timer is ripe. */
316 EMACS_GET_TIME (now
);
317 EMACS_SUB_TIME (time
, atimers
->expiration
, now
);
319 #ifdef HAVE_SETITIMER
320 /* Don't set the interval to 0; this disables the timer. */
321 if (EMACS_TIME_LE (atimers
->expiration
, now
))
323 EMACS_SET_SECS (time
, 0);
324 EMACS_SET_USECS (time
, 1000);
327 bzero (&it
, sizeof it
);
329 setitimer (ITIMER_REAL
, &it
, 0);
330 #else /* not HAVE_SETITIMER */
331 alarm (max (EMACS_SECS (time
), 1));
332 #endif /* not HAVE_SETITIMER */
337 /* Insert timer T into the list of active atimers `atimers', keeping
338 the list sorted by expiration time. T must not be in this list
345 struct atimer
*a
= atimers
, *prev
= NULL
;
347 /* Look for the first atimer that is ripe after T. */
348 while (a
&& EMACS_TIME_GT (t
->expiration
, a
->expiration
))
349 prev
= a
, a
= a
->next
;
351 /* Insert T in front of the atimer found, if any. */
361 /* Signal handler for SIGALRM. SIGNO is the signal number, i.e.
365 alarm_signal_handler (signo
)
370 EMACS_GET_TIME (now
);
374 && (pending_atimers
= interrupt_input_blocked
) == 0
375 && EMACS_TIME_LE (atimers
->expiration
, now
))
380 atimers
= atimers
->next
;
383 if (t
->type
== ATIMER_CONTINUOUS
)
385 EMACS_ADD_TIME (t
->expiration
, now
, t
->interval
);
390 t
->next
= free_atimers
;
394 EMACS_GET_TIME (now
);
397 #if defined (USG) && !defined (POSIX_SIGNALS)
398 /* USG systems forget handlers when they are used;
399 must reestablish each time. */
400 signal (SIGALRM
, alarm_signal_handler
);
407 /* Call alarm_signal_handler for pending timers. */
410 do_pending_atimers ()
415 alarm_signal_handler (SIGALRM
);
421 /* Turn alarms on/off. This seems to be temporarily necessary on
422 some systems like HPUX (see process.c). */
430 signal (SIGALRM
, alarm_signal_handler
);
441 free_atimers
= atimers
= NULL
;
443 signal (SIGALRM
, alarm_signal_handler
);