(byte-decompile-bytecode-1):

[bpt/emacs.git] / lisp / timer.el

diff --git a/lisp/timer.el b/lisp/timer.el
index b728aed..f60763c 100644 (file)
--- a/lisp/timer.el
+++ b/lisp/timer.el
@@ -71,8 +71,9 @@ fire each time Emacs is idle for that many seconds."
   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.
@@ -210,7 +211,9 @@ fire repeatedly that many seconds apart."
        nil)
     (error "Invalid or uninitialized timer")))
 
+;;;###autoload
 (defalias 'disable-timeout 'cancel-timer)
+;;;###autoload
 (defun cancel-timer (timer)
   "Remove TIMER from the list of active timers."
   (or (timerp timer)
@@ -219,6 +222,7 @@ fire repeatedly that many seconds apart."
   (setq timer-idle-list (delq timer timer-idle-list))
   nil)
 
+;;;###autoload
 (defun cancel-function-timers (function)
   "Cancel all timers scheduled by `run-at-time' which would run FUNCTION."
   (interactive "aCancel timers of function: ")
@@ -233,39 +237,54 @@ fire repeatedly that many seconds apart."
           (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.