annotate lisp/emacs-lisp/timer.el @ 72863:526dc1f36b09

(produce_image_glyph): Automatically crop wide images at right window edge so we can draw the cursor on the same row to avoid confusing redisplay by placing the cursor outside the visible window area.

 1 ;;; timer.el --- run a function with args at some time in future
 2 
 3 ;; Copyright (C) 1996, 2002, 2003, 2004, 2005,
 4 ;;   2006 Free Software Foundation, Inc.
 5 
 6 ;; Maintainer: FSF
 7 
 8 ;; This file is part of GNU Emacs.
 9 
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation; either version 2, or (at your option)
13 ;; any later version.
14 
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 ;; GNU General Public License for more details.
19 
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
22 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 ;; Boston, MA 02110-1301, USA.
24 
25 ;;; Commentary:
26 
27 ;; This package gives you the capability to run Emacs Lisp commands at
28 ;; specified times in the future, either as one-shots or periodically.
29 
30 ;;; Code:
31 
32 ;; Layout of a timer vector:
33 ;; [triggered-p high-seconds low-seconds usecs repeat-delay
34 ;;  function args idle-delay]
35 ;; triggered-p is nil if the timer is active (waiting to be triggered),
36 ;;  t if it is inactive ("already triggered", in theory)
37 
38 (defun timer-create ()
39   "Create a timer object which can be passed to `timer-activate'."
40   (let ((timer (make-vector 8 nil)))
41     (aset timer 0 t)
42     timer))
43 
44 (defun timerp (object)
45   "Return t if OBJECT is a timer."
46   (and (vectorp object) (= (length object) 8)))
47 
48 (defun timer-set-time (timer time &optional delta)
49   "Set the trigger time of TIMER to TIME.
50 TIME must be in the internal format returned by, e.g., `current-time'.
51 If optional third argument DELTA is a positive number, make the timer
52 fire repeatedly that many seconds apart."
53   (or (timerp timer)
54       (error "Invalid timer"))
55   (aset timer 1 (car time))
56   (aset timer 2 (if (consp (cdr time)) (car (cdr time)) (cdr time)))
57   (aset timer 3 (or (and (consp (cdr time)) (consp (cdr (cdr time)))
58 			 (nth 2 time))
59 		    0))
60   (aset timer 4 (and (numberp delta) (> delta 0) delta))
61   timer)
62 
63 (defun timer-set-idle-time (timer secs &optional repeat)
64   "Set the trigger idle time of TIMER to SECS.
65 SECS may be an integer, floating point number, or the internal
66 time format (HIGH LOW USECS) returned by, e.g., `current-idle-time'.
67 If optional third argument REPEAT is non-nil, make the timer
68 fire each time Emacs is idle for that many seconds."
69   (or (timerp timer)
70       (error "Invalid timer"))
71   (if (consp secs)
72       (progn (aset timer 1 (car secs))
73 	     (aset timer 2 (if (consp (cdr secs)) (car (cdr secs)) (cdr secs)))
74 	     (aset timer 3 (or (and (consp (cdr secs)) (consp (cdr (cdr secs)))
75 				    (nth 2 secs))
76 			       0)))
77     (aset timer 1 0)
78     (aset timer 2 0)
79     (aset timer 3 0)
80     (timer-inc-time timer secs))
81   (aset timer 4 repeat)
82   timer)
83 
84 (defun timer-next-integral-multiple-of-time (time secs)
85   "Yield the next value after TIME that is an integral multiple of SECS.
86 More precisely, the next value, after TIME, that is an integral multiple
87 of SECS seconds since the epoch.  SECS may be a fraction."
88   (let ((time-base (ash 1 16)))
89     (if (fboundp 'atan)
90 	;; Use floating point, taking care to not lose precision.
91 	(let* ((float-time-base (float time-base))
92 	       (million 1000000.0)
93 	       (time-usec (+ (* million
94 				(+ (* float-time-base (nth 0 time))
95 				   (nth 1 time)))
96 			     (nth 2 time)))
97 	       (secs-usec (* million secs))
98 	       (mod-usec (mod time-usec secs-usec))
99 	       (next-usec (+ (- time-usec mod-usec) secs-usec))
100 	       (time-base-million (* float-time-base million)))
101 	  (list (floor next-usec time-base-million)
102 		(floor (mod next-usec time-base-million) million)
103 		(floor (mod next-usec million))))
104       ;; Floating point is not supported.
105       ;; Use integer arithmetic, avoiding overflow if possible.
106       (let* ((mod-sec (mod (+ (* (mod time-base secs)
107 				 (mod (nth 0 time) secs))
108 			      (nth 1 time))
109 			   secs))
110 	     (next-1-sec (+ (- (nth 1 time) mod-sec) secs)))
111 	(list (+ (nth 0 time) (floor next-1-sec time-base))
112 	      (mod next-1-sec time-base)
113 	      0)))))
114 
115 (defun timer-relative-time (time secs &optional usecs)
116   "Advance TIME by SECS seconds and optionally USECS microseconds.
117 SECS may be either an integer or a floating point number."
118   (let ((high (car time))
119 	(low (if (consp (cdr time)) (nth 1 time) (cdr time)))
120 	(micro (if (numberp (car-safe (cdr-safe (cdr time))))
121 		   (nth 2 time)
122 		 0)))
123     ;; Add
124     (if usecs (setq micro (+ micro usecs)))
125     (if (floatp secs)
126 	(setq micro (+ micro (floor (* 1000000 (- secs (floor secs)))))))
127     (setq low (+ low (floor secs)))
128 
129     ;; Normalize
130     ;; `/' rounds towards zero while `mod' returns a positive number,
131     ;; so we can't rely on (= a (+ (* 100 (/ a 100)) (mod a 100))).
132     (setq low (+ low (/ micro 1000000) (if (< micro 0) -1 0)))
133     (setq micro (mod micro 1000000))
134     (setq high (+ high (/ low 65536) (if (< low 0) -1 0)))
135     (setq low (logand low 65535))
136 
137     (list high low (and (/= micro 0) micro))))
138 
139 (defun timer-inc-time (timer secs &optional usecs)
140   "Increment the time set in TIMER by SECS seconds and USECS microseconds.
141 SECS may be a fraction.  If USECS is omitted, that means it is zero."
142   (let ((time (timer-relative-time
143 	       (list (aref timer 1) (aref timer 2) (aref timer 3))
144 	       secs
145 	       usecs)))
146     (aset timer 1 (nth 0 time))
147     (aset timer 2 (nth 1 time))
148     (aset timer 3 (or (nth 2 time) 0))))
149 
150 (defun timer-set-time-with-usecs (timer time usecs &optional delta)
151   "Set the trigger time of TIMER to TIME plus USECS.
152 TIME must be in the internal format returned by, e.g., `current-time'.
153 The microsecond count from TIME is ignored, and USECS is used instead.
154 If optional fourth argument DELTA is a positive number, make the timer
155 fire repeatedly that many seconds apart."
156   (or (timerp timer)
157       (error "Invalid timer"))
158   (aset timer 1 (nth 0 time))
159   (aset timer 2 (nth 1 time))
160   (aset timer 3 usecs)
161   (aset timer 4 (and (numberp delta) (> delta 0) delta))
162   timer)
163 (make-obsolete 'timer-set-time-with-usecs
164                "use `timer-set-time' and `timer-inc-time' instead."
165                "22.1")
166 
167 (defun timer-set-function (timer function &optional args)
168   "Make TIMER call FUNCTION with optional ARGS when triggering."
169   (or (timerp timer)
170       (error "Invalid timer"))
171   (aset timer 5 function)
172   (aset timer 6 args)
173   timer)
174 
175 (defun timer-activate (timer &optional triggered-p reuse-cell)
176   "Put TIMER on the list of active timers.
177 
178 If TRIGGERED-P is t, that means to make the timer inactive
179 \(put it on the list, but mark it as already triggered).
180 To remove from the list, use `cancel-timer'.
181 
182 REUSE-CELL, if non-nil, is a cons cell to reuse instead
183 of allocating a new one."
184   (if (and (timerp timer)
185 	   (integerp (aref timer 1))
186 	   (integerp (aref timer 2))
187 	   (integerp (aref timer 3))
188 	   (aref timer 5))
189       (let ((timers timer-list)
190 	    last)
191 	;; Skip all timers to trigger before the new one.
192 	(while (and timers
193 		    (or (> (aref timer 1) (aref (car timers) 1))
194 			(and (= (aref timer 1) (aref (car timers) 1))
195 			     (> (aref timer 2) (aref (car timers) 2)))
196 			(and (= (aref timer 1) (aref (car timers) 1))
197 			     (= (aref timer 2) (aref (car timers) 2))
198 			     (> (aref timer 3) (aref (car timers) 3)))))
199 	  (setq last timers
200 		timers (cdr timers)))
201 	(if reuse-cell
202 	    (progn
203 	      (setcar reuse-cell timer)
204 	      (setcdr reuse-cell timers))
205 	  (setq reuse-cell (cons timer timers)))
206 	;; Insert new timer after last which possibly means in front of queue.
207 	(if last
208 	    (setcdr last reuse-cell)
209 	  (setq timer-list reuse-cell))
210 	(aset timer 0 triggered-p)
211 	(aset timer 7 nil)
212 	nil)
213     (error "Invalid or uninitialized timer")))
214 
215 (defun timer-activate-when-idle (timer &optional dont-wait reuse-cell)
216   "Arrange to activate TIMER whenever Emacs is next idle.
217 If optional argument DONT-WAIT is non-nil, then enable the
218 timer to activate immediately, or at the right time, if Emacs
219 is already idle.
220 
221 REUSE-CELL, if non-nil, is a cons cell to reuse instead
222 of allocating a new one."
223   (if (and (timerp timer)
224 	   (integerp (aref timer 1))
225 	   (integerp (aref timer 2))
226 	   (integerp (aref timer 3))
227 	   (aref timer 5))
228       (let ((timers timer-idle-list)
229 	    last)
230 	;; Skip all timers to trigger before the new one.
231 	(while (and timers
232 		    (or (> (aref timer 1) (aref (car timers) 1))
233 			(and (= (aref timer 1) (aref (car timers) 1))
234 			     (> (aref timer 2) (aref (car timers) 2)))
235 			(and (= (aref timer 1) (aref (car timers) 1))
236 			     (= (aref timer 2) (aref (car timers) 2))
237 			     (> (aref timer 3) (aref (car timers) 3)))))
238 	  (setq last timers
239 		timers (cdr timers)))
240 	(if reuse-cell
241 	    (progn
242 	      (setcar reuse-cell timer)
243 	      (setcdr reuse-cell timers))
244 	  (setq reuse-cell (cons timer timers)))
245 	;; Insert new timer after last which possibly means in front of queue.
246 	(if last
247 	    (setcdr last reuse-cell)
248 	  (setq timer-idle-list reuse-cell))
249 	(aset timer 0 (not dont-wait))
250 	(aset timer 7 t)
251 	nil)
252     (error "Invalid or uninitialized timer")))
253 
254 ;;;###autoload
255 (defalias 'disable-timeout 'cancel-timer)
256 ;;;###autoload
257 (defun cancel-timer (timer)
258   "Remove TIMER from the list of active timers."
259   (or (timerp timer)
260       (error "Invalid timer"))
261   (setq timer-list (delq timer timer-list))
262   (setq timer-idle-list (delq timer timer-idle-list))
263   nil)
264 
265 (defun cancel-timer-internal (timer)
266   "Remove TIMER from the list of active timers or idle timers.
267 Only to be used in this file.  It returns the cons cell
268 that was removed from the timer list."
269   (let ((cell1 (memq timer timer-list))
270 	(cell2 (memq timer timer-idle-list)))
271     (if cell1
272 	(setq timer-list (delq timer timer-list)))
273     (if cell2
274 	(setq timer-idle-list (delq timer timer-idle-list)))
275     (or cell1 cell2)))
276 
277 ;;;###autoload
278 (defun cancel-function-timers (function)
279   "Cancel all timers which would run FUNCTION.
280 This affects ordinary timers such as are scheduled by `run-at-time',
281 and idle timers such as are scheduled by `run-with-idle-timer'."
282   (interactive "aCancel timers of function: ")
283   (let ((tail timer-list))
284     (while tail
285       (if (eq (aref (car tail) 5) function)
286           (setq timer-list (delq (car tail) timer-list)))
287       (setq tail (cdr tail))))
288   (let ((tail timer-idle-list))
289     (while tail
290       (if (eq (aref (car tail) 5) function)
291           (setq timer-idle-list (delq (car tail) timer-idle-list)))
292       (setq tail (cdr tail)))))
293 
294 ;; Record the last few events, for debugging.
295 (defvar timer-event-last nil
296   "Last timer that was run.")
297 (defvar timer-event-last-1 nil
298   "Next-to-last timer that was run.")
299 (defvar timer-event-last-2 nil
300   "Third-to-last timer that was run.")
301 
302 (defvar timer-max-repeats 10
303   "*Maximum number of times to repeat a timer, if real time jumps.")
304 
305 (defun timer-until (timer time)
306   "Calculate number of seconds from when TIMER will run, until TIME.
307 TIMER is a timer, and stands for the time when its next repeat is scheduled.
308 TIME is a time-list."
309   (let ((high (- (car time) (aref timer 1)))
310 	(low (- (nth 1 time) (aref timer 2))))
311     (+ low (* high 65536))))
312 
313 (defun timer-event-handler (timer)
314   "Call the handler for the timer TIMER.
315 This function is called, by name, directly by the C code."
316   (setq timer-event-last-2 timer-event-last-1)
317   (setq timer-event-last-1 timer-event-last)
318   (setq timer-event-last timer)
319   (let ((inhibit-quit t))
320     (if (timerp timer)
321 	(let (retrigger cell)
322 	  ;; Delete from queue.  Record the cons cell that was used.
323 	  (setq cell (cancel-timer-internal timer))
324 	  ;; Re-schedule if requested.
325 	  (if (aref timer 4)
326 	      (if (aref timer 7)
327 		  (timer-activate-when-idle timer nil cell)
328 		(timer-inc-time timer (aref timer 4) 0)
329 		;; If real time has jumped forward,
330 		;; perhaps because Emacs was suspended for a long time,
331 		;; limit how many times things get repeated.
332 		(if (and (numberp timer-max-repeats)
333 			 (< 0 (timer-until timer (current-time))))
334 		    (let ((repeats (/ (timer-until timer (current-time))
335 				      (aref timer 4))))
336 		      (if (> repeats timer-max-repeats)
337 			  (timer-inc-time timer (* (aref timer 4) repeats)))))
338 		(timer-activate timer t cell)
339 		(setq retrigger t)))
340 	  ;; Run handler.
341 	  ;; We do this after rescheduling so that the handler function
342 	  ;; can cancel its own timer successfully with cancel-timer.
343 	  (condition-case nil
344 	      (apply (aref timer 5) (aref timer 6))
345 	    (error nil))
346 	  (if retrigger
347 	      (aset timer 0 nil)))
348       (error "Bogus timer event"))))
349 
350 ;; This function is incompatible with the one in levents.el.
351 (defun timeout-event-p (event)
352   "Non-nil if EVENT is a timeout event."
353   (and (listp event) (eq (car event) 'timer-event)))
354 
355 ;;;###autoload
356 (defun run-at-time (time repeat function &rest args)
357   "Perform an action at time TIME.
358 Repeat the action every REPEAT seconds, if REPEAT is non-nil.
359 TIME should be a string like \"11:23pm\", nil meaning now, a number of seconds
360 from now, a value from `current-time', or t (with non-nil REPEAT)
361 meaning the next integral multiple of REPEAT.
362 REPEAT may be an integer or floating point number.
363 The action is to call FUNCTION with arguments ARGS.
364 
365 This function returns a timer object which you can use in `cancel-timer'."
366   (interactive "sRun at time: \nNRepeat interval: \naFunction: ")
367 
368   (or (null repeat)
369       (and (numberp repeat) (< 0 repeat))
370       (error "Invalid repetition interval"))
371 
372   ;; Special case: nil means "now" and is useful when repeating.
373   (if (null time)
374       (setq time (current-time)))
375 
376   ;; Special case: t means the next integral multiple of REPEAT.
377   (if (and (eq time t) repeat)
378       (setq time (timer-next-integral-multiple-of-time (current-time) repeat)))
379 
380   ;; Handle numbers as relative times in seconds.
381   (if (numberp time)
382       (setq time (timer-relative-time (current-time) time)))
383 
384   ;; Handle relative times like "2 hours and 35 minutes"
385   (if (stringp time)
386       (let ((secs (timer-duration time)))
387 	(if secs
388 	    (setq time (timer-relative-time (current-time) secs)))))
389 
390   ;; Handle "11:23pm" and the like.  Interpret it as meaning today
391   ;; which admittedly is rather stupid if we have passed that time
392   ;; already.  (Though only Emacs hackers hack Emacs at that time.)
393   (if (stringp time)
394       (progn
395 	(require 'diary-lib)
396 	(let ((hhmm (diary-entry-time time))
397 	      (now (decode-time)))
398 	  (if (>= hhmm 0)
399 	      (setq time
400 		    (encode-time 0 (% hhmm 100) (/ hhmm 100) (nth 3 now)
401 				 (nth 4 now) (nth 5 now) (nth 8 now)))))))
402 
403   (or (consp time)
404       (error "Invalid time format"))
405 
406   (let ((timer (timer-create)))
407     (timer-set-time timer time repeat)
408     (timer-set-function timer function args)
409     (timer-activate timer)
410     timer))
411 
412 ;;;###autoload
413 (defun run-with-timer (secs repeat function &rest args)
414   "Perform an action after a delay of SECS seconds.
415 Repeat the action every REPEAT seconds, if REPEAT is non-nil.
416 SECS and REPEAT may be integers or floating point numbers.
417 The action is to call FUNCTION with arguments ARGS.
418 
419 This function returns a timer object which you can use in `cancel-timer'."
420   (interactive "sRun after delay (seconds): \nNRepeat interval: \naFunction: ")
421   (apply 'run-at-time secs repeat function args))
422 
423 ;;;###autoload
424 (defun add-timeout (secs function object &optional repeat)
425   "Add a timer to run SECS seconds from now, to call FUNCTION on OBJECT.
426 If REPEAT is non-nil, repeat the timer every REPEAT seconds.
427 This function is for compatibility; see also `run-with-timer'."
428   (run-with-timer secs repeat function object))
429 
430 ;;;###autoload
431 (defun run-with-idle-timer (secs repeat function &rest args)
432   "Perform an action the next time Emacs is idle for SECS seconds.
433 The action is to call FUNCTION with arguments ARGS.
434 SECS may be an integer, a floating point number, or the internal
435 time format (HIGH LOW USECS) returned by, e.g., `current-idle-time'.
436 If Emacs is currently idle, and has been idle for N seconds (N < SECS),
437 then it will call FUNCTION in SECS - N seconds from now.
438 
439 If REPEAT is non-nil, do the action each time Emacs has been idle for
440 exactly SECS seconds (that is, only once for each time Emacs becomes idle).
441 
442 This function returns a timer object which you can use in `cancel-timer'."
443   (interactive
444    (list (read-from-minibuffer "Run after idle (seconds): " nil nil t)
445 	 (y-or-n-p "Repeat each time Emacs is idle? ")
446 	 (intern (completing-read "Function: " obarray 'fboundp t))))
447   (let ((timer (timer-create)))
448     (timer-set-function timer function args)
449     (timer-set-idle-time timer secs repeat)
450     (timer-activate-when-idle timer t)
451     timer))
452 
453 (defun with-timeout-handler (tag)
454   "This is the timer function used for the timer made by `with-timeout'."
455   (throw tag 'timeout))
456 
457 ;;;###autoload (put 'with-timeout 'lisp-indent-function 1)
458 
459 (defvar with-timeout-timers nil
460   "List of all timers used by currently pending `with-timeout' calls.")
461 
462 ;;;###autoload
463 (defmacro with-timeout (list &rest body)
464   "Run BODY, but if it doesn't finish in SECONDS seconds, give up.
465 If we give up, we run the TIMEOUT-FORMS and return the value of the last one.
466 The timeout is checked whenever Emacs waits for some kind of external
467 event (such as keyboard input, input from subprocesses, or a certain time);
468 if the program loops without waiting in any way, the timeout will not
469 be detected.
470 \n(fn (SECONDS TIMEOUT-FORMS...) BODY)"
471   (let ((seconds (car list))
472 	(timeout-forms (cdr list)))
473     `(let ((with-timeout-tag (cons nil nil))
474 	   with-timeout-value with-timeout-timer
475 	   (with-timeout-timers with-timeout-timers))
476        (if (catch with-timeout-tag
477 	     (progn
478 	       (setq with-timeout-timer
479 		     (run-with-timer ,seconds nil
480 				      'with-timeout-handler
481 				      with-timeout-tag))
482 	       (push with-timeout-timer with-timeout-timers)
483 	       (setq with-timeout-value (progn . ,body))
484 	       nil))
485 	   (progn . ,timeout-forms)
486 	 (cancel-timer with-timeout-timer)
487 	 with-timeout-value))))
488 
489 (defun with-timeout-suspend ()
490   "Stop the clock for `with-timeout'.  Used by debuggers.
491 The idea is that the time you spend in the debugger should not
492 count against these timeouts.
493 
494 The value is a list that the debugger can pass to `with-timeout-unsuspend'
495 when it exits, to make these timers start counting again."
496   (mapcar (lambda (timer)
497 	    (cancel-timer timer)
498 	    (list timer
499 		  (time-subtract
500 		   ;; The time that this timer will go off.
501 		   (list (aref timer 1) (aref timer 2) (aref timer 3))
502 		   (current-time))))
503 	  with-timeout-timers))
504 
505 (defun with-timeout-unsuspend (timer-spec-list)
506   "Restart the clock for `with-timeout'.
507 The argument should be a value previously returned by `with-timeout-suspend'."
508   (dolist (elt timer-spec-list)
509     (let ((timer (car elt))
510 	  (delay (cadr elt)))
511       (timer-set-time timer (time-add (current-time) delay)) 
512       (timer-activate timer))))
513 
514 (defun y-or-n-p-with-timeout (prompt seconds default-value)
515   "Like (y-or-n-p PROMPT), with a timeout.
516 If the user does not answer after SECONDS seconds, return DEFAULT-VALUE."
517   (with-timeout (seconds default-value)
518     (y-or-n-p prompt)))
519 
520 (defvar timer-duration-words
521   (list (cons "microsec" 0.000001)
522 	(cons "microsecond" 0.000001)
523         (cons "millisec" 0.001)
524 	(cons "millisecond" 0.001)
525         (cons "sec" 1)
526 	(cons "second" 1)
527 	(cons "min" 60)
528 	(cons "minute" 60)
529 	(cons "hour" (* 60 60))
530 	(cons "day" (* 24 60 60))
531 	(cons "week" (* 7 24 60 60))
532 	(cons "fortnight" (* 14 24 60 60))
533 	(cons "month" (* 30 24 60 60))	  ; Approximation
534 	(cons "year" (* 365.25 24 60 60)) ; Approximation
535 	)
536   "Alist mapping temporal words to durations in seconds")
537 
538 (defun timer-duration (string)
539   "Return number of seconds specified by STRING, or nil if parsing fails."
540   (let ((secs 0)
541 	(start 0)
542 	(case-fold-search t))
543     (while (string-match
544 	    "[ \t]*\\([0-9.]+\\)?[ \t]*\\([a-z]+[a-rt-z]\\)s?[ \t]*"
545 	    string start)
546       (let ((count (if (match-beginning 1)
547 		       (string-to-number (match-string 1 string))
548 		     1))
549 	    (itemsize (cdr (assoc (match-string 2 string)
550 				  timer-duration-words))))
551 	(if itemsize
552 	    (setq start (match-end 0)
553 		  secs (+ secs (* count itemsize)))
554 	  (setq secs nil
555 		start (length string)))))
556     (if (= start (length string))
557 	secs
558       (if (string-match "\\`[0-9.]+\\'" string)
559 	  (string-to-number string)))))
560 
561 (provide 'timer)
562 
563 ;;; arch-tag: b1a9237b-7787-4382-9e46-8f2c3b3273e0
564 ;;; timer.el ends here