timer)
(defun timer-next-integral-multiple-of-time (time secs)
- "Yield the next value after TIME that is an integral number of SECS
-since the epoch. SECS may be a fraction."
+ "Yield the next value after TIME that is an integral multiple of SECS.
+More precisely, the next value, after TIME, that is an integral multiple
+of SECS seconds since the epoch. SECS may be a fraction."
(let ((time-base (ash 1 16)))
(if (fboundp 'atan)
;; Use floating point, taking care to not lose precision.
(setq timer-idle-list (delq (car tail) timer-idle-list)))
(setq tail (cdr tail)))))
\f
-;; Set up the common handler for all timer events. Since the event has
-;; the timer as parameter we can still distinguish. Note that using
-;; special-event-map ensures that event timer events that arrive in the
-;; middle of a key sequence being entered are still handled correctly.
-(define-key special-event-map [timer-event] 'timer-event-handler)
-
;; Record the last few events, for debugging.
(defvar timer-event-last-2 nil)
(defvar timer-event-last-1 nil)
(defvar timer-event-last nil)
-(defun timer-event-handler (event)
- "Call the handler for the timer in the event EVENT."
- (interactive "e")
+(defvar timer-max-repeats 10
+ "*Maximum number of times to repeat a timer, if real time jumps.")
+
+(defun timer-until (timer time)
+ "Calculate number of seconds from when TIMER will run, until TIME.
+TIMER is a timer, and stands for the time when its next repeat is scheduled.
+TIME is a time-list."
+ (let ((high (- (car time) (aref timer 1)))
+ (low (- (nth 1 time) (aref timer 2))))
+ (+ low (* high 65536))))
+
+(defun timer-event-handler (timer)
+ "Call the handler for the timer TIMER.
+This function is called, by name, directly by the C code."
(setq timer-event-last-2 timer-event-last-1)
(setq timer-event-last-1 timer-event-last)
- (setq timer-event-last (cons event (copy-sequence event)))
- (let ((inhibit-quit t)
- (timer (car-safe (cdr-safe event))))
+ (setq timer-event-last timer)
+ (let ((inhibit-quit t))
(if (timerp timer)
(progn
;; Delete from queue.
(cancel-timer timer)
- ;; Run handler
- (condition-case nil
- (apply (aref timer 5) (aref timer 6))
- (error nil))
;; Re-schedule if requested.
(if (aref timer 4)
(if (aref timer 7)
(timer-activate-when-idle timer)
(timer-inc-time timer (aref timer 4) 0)
- (timer-activate timer))))
+ ;; If real time has jumped forward,
+ ;; perhaps because Emacs was suspended for a long time,
+ ;; limit how many times things get repeated.
+ (if (and (numberp timer-max-repeats)
+ (< 0 (timer-until timer (current-time))))
+ (let ((repeats (/ (timer-until timer (current-time))
+ (aref timer 4))))
+ (if (> repeats timer-max-repeats)
+ (timer-inc-time timer (* (aref timer 4) repeats)))))
+ (timer-activate timer)))
+ ;; Run handler.
+ ;; We do this after rescheduling so that the handler function
+ ;; can cancel its own timer successfully with cancel-timer.
+ (condition-case nil
+ (apply (aref timer 5) (aref timer 6))
+ (error nil)))
(error "Bogus timer event"))))
;; This function is incompatible with the one in levents.el.