;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:12:50 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el
;;; in Emacs version 24.3
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put timer--triggered compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--triggered (aref cl-x 0)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'timer--triggered #[(cl-x) "\301H\207" [cl-x 0] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put timer--high-seconds compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--high-seconds (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'timer--high-seconds #[(cl-x) "\301H\207" [cl-x 1] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put timer--low-seconds compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--low-seconds (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'timer--low-seconds #[(cl-x) "\301H\207" [cl-x 2] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put timer--usecs compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--usecs (aref cl-x 3)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'timer--usecs #[(cl-x) "\301H\207" [cl-x 3] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put timer--repeat-delay compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--repeat-delay (aref cl-x 4)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'timer--repeat-delay #[(cl-x) "\301H\207" [cl-x 4] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put timer--function compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--function (aref cl-x 5)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'timer--function #[(cl-x) "\301H\207" [cl-x 5] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put timer--args compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--args (aref cl-x 6)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'timer--args #[(cl-x) "\301H\207" [cl-x 6] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put timer--idle-delay compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--idle-delay (aref cl-x 7)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'timer--idle-delay #[(cl-x) "\301H\207" [cl-x 7] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put timer--psecs compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--psecs (aref cl-x 8)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'timer--psecs #[(cl-x) "\301H\207" [cl-x 8] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put timer-create compiler-macro #[(_cl-whole-arg) "\300\301\302\301\211\211%\207" [cl--defsubst-expand nil (cl-block timer-create (vector t nil nil nil nil nil nil nil nil))] 6] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/timer.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'timer-create #[nil "\300\301\302\211\211\211\211\211\211\211&	\207" [vector t nil] 10])
(byte-code "\301C\302\303\304\305#\210\302\303\306\307#\210\302\303\310\311#\210\302\303\312\311#\210\302\313\314\315#\210\302\316\314\315#\210\302\317\314\315#\210\302\320\314\315#\210\302\321\314\315#\210\302\322\314\315#\210\302\323\314\315#\210\302\324\314\315#\210\302\325\314\315#\210\302\326\314\315#\207" [cl-struct-timer-tags cl-struct-timer put timer cl-struct-slots ((triggered t) (high-seconds) (low-seconds) (usecs) (repeat-delay) (function) (args) (idle-delay) (psecs)) cl-struct-type (vector nil) cl-struct-include nil cl-struct-print timer-create side-effect-free t timer--psecs timer--idle-delay timer--args timer--function timer--repeat-delay timer--usecs timer--low-seconds timer--high-seconds timer--triggered] 4)
#@32 Return t if OBJECT is a timer.
(defalias 'timerp #[(object) "\301!\205\nG\302U\207" [object vectorp 9] 2 (#$ . 5695)])
(defalias 'timer--time #[(timer) "\301H\302H\303H\304HF\207" [timer 1 2 3 8] 5])
(put 'timer--time 'gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter timer--time #[(val &rest args) "\302\303	C\"B\207" [args val (lambda (timer time) (or (timerp timer) (error "Invalid timer")) (setf (timer--high-seconds timer) (pop time)) (let ((low time) (usecs 0) (psecs 0)) (if (consp time) (progn (setq low (pop time)) (if time (progn (setq usecs (pop time)) (if time (setq psecs (car time))))))) (setf (timer--low-seconds timer) low) (setf (timer--usecs timer) usecs) (setf (timer--psecs timer) psecs))) append] 4]] 5])
#@222 Set the trigger time of TIMER to TIME.
TIME must be in the internal format returned by, e.g., `current-time'.
If optional third argument DELTA is a positive number, make the timer
fire repeatedly that many seconds apart.
(defalias 'timer-set-time #[(timer time &optional delta) "\211\n\306!\204\307\310!\210\211\311\n\211A@I\210)\n\312\211\n:\203@\n\211A@\n\203@\n\211A@\n\203@\n@\211\313I\210)\211\314
I\210)\211\315\fI\210.\211\316\247\205q\312V\205qI\210)\207" [timer #1=#:v time #2=#:v psecs usecs timerp error "Invalid timer" 1 0 2 3 8 4 low #3=#:v #4=#:v #5=#:v #6=#:v delta] 5 (#$ . 6462)])
#@273 Set the trigger idle time of TIMER to SECS.
SECS may be an integer, floating point number, or the internal
time format returned by, e.g., `current-idle-time'.
If optional third argument REPEAT is non-nil, make the timer
fire each time Emacs is idle for that many seconds.
(defalias 'timer-set-idle-time #[(timer secs &optional repeat) ":\203h	\211\306	!\204\307\310!\210	\211\311\211A@I\210)\312\211:\203G\211A@\203G\211A@\203G@	\211\313I\210)	\211\314I\210)	\211\315
I\210.\202\317	\211\316\306	!\204y\307\310!\210	\211\311\211A@I\210)\312\211:\203\254\211A@\203\254\211A@\203\254@	\211\313I\210)	\211\314I\210)	\211\315
I\210.\317	\"\210	\211\320I\210)	\207" [secs timer #1=#:v time #2=#:v psecs timerp error "Invalid timer" 1 0 2 3 8 (0 0 0) timer-inc-time 4 usecs low #3=#:v #4=#:v #5=#:v #6=#:v #7=#:v #8=#:v #9=#:v #10=#:v #11=#:v repeat] 5 (#$ . 7114)])
#@202 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.
(defalias 'timer-next-integral-multiple-of-time #[(time secs) "\306	A@\307	@_\\\310\n[\"\n\311\f!\\\311\310\f\312\"_!\313	8\206(\314\315\316	8_\\\211Z
\nX\203P\314W\203P\310[_\"\\
\317\"\\\310\"\317
\320\"\317\310
\320\"!\317\321\"\317\310\321\"!F.\207" [trillion time time-sec secs delta-sec next-sec 1000000000000.0 65536.0 mod ffloor 1 3 0 1000000.0 2 floor 65536 1000000 next-sec-psec sub-time-psec psec-diff] 8 (#$ . 8074)])
#@145 Advance TIME by SECS seconds and optionally USECS nanoseconds
and PSECS picoseconds.  SECS may be either an integer or a
floating point number.
(defalias 'timer-relative-time #[(time secs &optional usecs psecs) "\305!\203\f\306!\202\307\310\"\311\310\"D\n\204\203/\312	\313\211\n\206'\313\206,\313F\"\312\f	\")\207" [secs delta usecs psecs time floatp seconds-to-time floor 65536 mod time-add 0] 6 (#$ . 8753)])
#@55 Say whether time value T1 is less than time value T2.
(defalias 'timer--time-less-p #[(t1 t2) "\302\303!\303	!\"\207" [t1 t2 time-less-p timer--time] 4 (#$ . 9187)])
#@175 Increment the time set in TIMER by SECS seconds, USECS nanoseconds,
and PSECS picoseconds.  SECS may be a fraction.  If USECS or PSECS are
omitted, they are treated as zero.
(defalias 'timer-inc-time #[(timer secs &optional usecs psecs) "\211\306\307!\n\f$\310!\204\311\312!\210\211\313
\211A@I\210)
\314\211
:\203H
\211A@
\203H
\211A@
\203H
@\211\315I\210)\211\316I\210)\211\317\fI.\207" [timer #1=#:v secs usecs psecs time timer-relative-time timer--time timerp error "Invalid timer" 1 0 2 3 8 #2=#:v low #3=#:v #4=#:v #5=#:v] 7 (#$ . 9361)])
#@305 Set the trigger time of TIMER to TIME plus USECS.
TIME must be in the internal format returned by, e.g., `current-time'.
The microsecond count from TIME is ignored, and USECS is used instead.
If optional fourth argument DELTA is a positive number, make the timer
fire repeatedly that many seconds apart.
(defalias 'timer-set-time-with-usecs #[(timer time usecs &optional delta) "\211\n\306!\204\307\310!\210\211\311\n\211A@I\210)\n\312\211\n:\203@\n\211A@\n\203@\n\211A@\n\203@\n@\211\313I\210)\211\314
I\210)\211\315\fI\210.\211\314
I\210)\211\315\312I\210)\211\316\247\205\203\312V\205\203I\210)\207" [timer #1=#:v time #2=#:v psecs usecs timerp error "Invalid timer" 1 0 2 3 8 4 low #3=#:v #4=#:v #5=#:v #6=#:v #7=#:v #8=#:v delta] 5 (#$ . 9952)])
(make-obsolete 'timer-set-time-with-usecs "use `timer-set-time' and `timer-inc-time' instead." "22.1")
#@62 Make TIMER call FUNCTION with optional ARGS when triggering.
(defalias 'timer-set-function #[(timer function &optional args) "\305!\204\n\306\307!\210\211\310\nI\210)\211\311\fI\210)\207" [timer #1=#:v function #2=#:v args timerp error "Invalid timer" 5 6] 4 (#$ . 10865)])
(defalias 'timer--activate #[(timer &optional triggered-p reuse-cell idle) "\306!\203\216\307H\250\203\216\310H\250\203\216\311H\250\203\216\312H\250\203\216\313H\203\216	\2030\n\2021\314\211\203I\315
@\"\203I

A\211\2048\203[\240\210
\241\210\202`
B\f\203l\f\241\210\202y	\203v\202y\211\316I\210)\211\317	I\210+\314\207\320\321!\207" [timer idle timer-idle-list timer-list last timers timerp 1 2 3 8 5 nil timer--time-less-p 0 7 error "Invalid or uninitialized timer" reuse-cell #1=#:v triggered-p #2=#:v] 4])
#@397 Insert TIMER into `timer-list'.
If TRIGGERED-P is t, make TIMER inactive (put it on the list, but
mark it as already triggered).  To remove it, use `cancel-timer'.

REUSE-CELL, if non-nil, is a cons cell to reuse when inserting
TIMER into `timer-list' (usually a cell removed from that list by
`cancel-timer-internal'; using this reduces consing for repeat
timers).  If nil, allocate a new cell.
(defalias 'timer-activate #[(timer &optional triggered-p reuse-cell) "\303	\n\304$\207" [timer triggered-p reuse-cell timer--activate nil] 5 (#$ . 11719)])
#@743 Insert TIMER into `timer-idle-list'.
This arranges to activate TIMER whenever Emacs is next idle.
If optional argument DONT-WAIT is non-nil, set TIMER to activate
immediately (see below), or at the right time, if Emacs is
already idle.

REUSE-CELL, if non-nil, is a cons cell to reuse when inserting
TIMER into `timer-idle-list' (usually a cell removed from that
list by `cancel-timer-internal'; using this reduces consing for
repeat timers).  If nil, allocate a new cell.

Using non-nil DONT-WAIT is not recommended when activating an
idle timer from an idle timer handler, if the timer being
activated has an idleness time that is smaller or equal to
the time of the current timer.  That's because the activated
timer will fire right away.
(defalias 'timer-activate-when-idle #[(timer &optional dont-wait reuse-cell) "\303	?\n\304$\207" [timer dont-wait reuse-cell timer--activate idle] 5 (#$ . 12279)])
(defalias 'disable-timeout 'cancel-timer)
#@46 Remove TIMER from the list of active timers.
(defalias 'cancel-timer #[(timer) "\303!\204\n\304\305!\210\306	\"\306\n\"\307\207" [timer timer-list timer-idle-list timerp error "Invalid timer" delq nil] 3 (#$ . 13234)])
#@155 Remove TIMER from the list of active timers or idle timers.
Only to be used in this file.  It returns the cons cell
that was removed from the timer list.
(defalias 'cancel-timer-internal #[(timer) "	>\n>\211\203\305	\"\203\305\n\"\f\206*\207" [timer timer-list timer-idle-list cell2 cell1 delq] 4 (#$ . 13466)])
#@178 Cancel all timers which would run FUNCTION.
This affects ordinary timers such as are scheduled by `run-at-time',
and idle timers such as are scheduled by `run-with-idle-timer'.
(defalias 'cancel-function-timers #[(function) "\305\211\203\n@\211\306H=\203\307	\"\nA\211\204*\f\305\211\205@\n@\211\306H=\2038\307	\f\"\nA\211\204(\305*\207" [timer-list timer --dolist-tail-- function timer-idle-list nil 5 delq] 4 (#$ . 13801) "aCancel timers of function: "])
#@26 Last timer that was run.
(defvar timer-event-last nil (#$ . 14287))
#@34 Next-to-last timer that was run.
(defvar timer-event-last-1 nil (#$ . 14361))
#@35 Third-to-last timer that was run.
(defvar timer-event-last-2 nil (#$ . 14445))
#@306 Maximum number of times to repeat a timer, if many repeats are delayed.
Timer invocations can be delayed because Emacs is suspended or busy,
or because the system's time changes.  If such an occurrence makes it
appear that many invocations are overdue, this variable controls
how many will really happen.
(custom-declare-variable 'timer-max-repeats 10 '(#$ . 14531) :type 'integer :group 'internal)
#@165 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.
(defalias 'timer-until #[(timer time) "\302!\302\303	!!Z\207" [time timer float-time timer--time] 4 (#$ . 14937)])
#@97 Call the handler for the timer TIMER.
This function is called, by name, directly by the C code.
(defalias 'timer-event-handler #[(timer) "\n\306\307!\203\200\310\211\311!\312H\203j\313H\203,\314\310
#\210\202j\315\211\312H\316#\210\247\203a\316\317\320 \"W\203a\317\320 \"\312H\245\211V\203`\315\211\312H_\"\210)\321\306
#\210\306\310\322\323\217\210\205|\211\316\310I)*\202\203\324\325!)\207" [timer-event-last-1 timer-event-last-2 timer-event-last timer inhibit-quit cell t timerp nil cancel-timer-internal 4 7 timer-activate-when-idle timer-inc-time 0 timer-until current-time timer-activate (byte-code "r\301\302H\303H\"\210)\301\207" [timer apply 5 6] 4) ((error)) error "Bogus timer event" retrigger timer-max-repeats repeats #1=#:v] 5 (#$ . 15223)])
#@38 Non-nil if EVENT is a timeout event.
(defalias 'timeout-event-p #[(event) "<\205	@\301=\207" [event timer-event] 2 (#$ . 16033)])
#@762 Perform an action at time TIME.
Repeat the action every REPEAT seconds, if REPEAT is non-nil.
TIME should be one of: a string giving an absolute time like
"11:23pm" (the acceptable formats are those recognized by
`diary-entry-time'; note that such times are interpreted as times
today, even if in the past); a string giving a relative time like
"2 hours 35 minutes" (the acceptable formats are those
recognized by `timer-duration'); nil meaning now; a number of
seconds from now; a value from `encode-time'; or t (with non-nil
REPEAT) meaning the next integral multiple of REPEAT.  REPEAT may
be an integer or floating point number.  The action is to call
FUNCTION with arguments ARGS.

This function returns a timer object which you can use in `cancel-timer'.
(defalias 'run-at-time #[(time repeat function &rest args) "\203\247\203\306W\204\307\310!\210	\204\311 	\312=\203*\203*\313\311 \"	\247\2035\314\311 	\"	;\203I\315	!\211\203H\314\311 \n\")	;\203w\316\317!\210\320	!\321 \211\306Y\203v\322\306\f\323\246\f\323\245\3248\3258\3268\3278&*	:\204\200\307\330!\210\331\312\332\211\211\211\211\211\211\211&	\333
	#\210\334
#\210\335
!\210
)\207" [repeat time secs now hhmm timer 0 error "Invalid repetition interval" current-time t timer-next-integral-multiple-of-time timer-relative-time timer-duration require diary-lib diary-entry-time decode-time encode-time 100 3 4 5 8 "Invalid time format" vector nil timer-set-time timer-set-function timer-activate function args] 11 (#$ . 16173) "sRun at time: \nNRepeat interval: \naFunction: "])
#@298 Perform an action after a delay of SECS seconds.
Repeat the action every REPEAT seconds, if REPEAT is non-nil.
SECS and REPEAT may be integers or floating point numbers.
The action is to call FUNCTION with arguments ARGS.

This function returns a timer object which you can use in `cancel-timer'.
(defalias 'run-with-timer #[(secs repeat function &rest args) "\304\305	\n%\207" [secs repeat function args apply run-at-time] 6 (#$ . 17763) "sRun after delay (seconds): \nNRepeat interval: \naFunction: "])
#@195 Add a timer to run SECS seconds from now, to call FUNCTION on OBJECT.
If REPEAT is non-nil, repeat the timer every REPEAT seconds.
This function is for compatibility; see also `run-with-timer'.
(defalias 'add-timeout #[(secs function object &optional repeat) "\304	\n$\207" [secs repeat function object run-with-timer] 5 (#$ . 18277)])
#@719 Perform an action the next time Emacs is idle for SECS seconds.
The action is to call FUNCTION with arguments ARGS.
SECS may be an integer, a floating point number, or the internal
time format returned by, e.g., `current-idle-time'.
If Emacs is currently idle, and has been idle for N seconds (N < SECS),
then it will call FUNCTION in SECS - N seconds from now.  Using
SECS <= N is not recommended if this function is invoked from an idle
timer, because FUNCTION will then be called immediately.

If REPEAT is non-nil, do the action each time Emacs has been idle for
exactly SECS seconds (that is, only once for each time Emacs becomes idle).

This function returns a timer object which you can use in `cancel-timer'.
(defalias 'run-with-idle-timer #[(secs repeat function &rest args) "\305\306\307\211\211\211\211\211\211\211&	\310	\n#\210\311\f#\210\312\306\"\210)\207" [timer function args secs repeat vector t nil timer-set-function timer-set-idle-time timer-activate-when-idle] 10 (#$ . 18622) (list (read-from-minibuffer "Run after idle (seconds): " nil nil t) (y-or-n-p "Repeat each time Emacs is idle? ") (intern (completing-read "Function: " obarray 'fboundp t)))])
#@68 List of all timers used by currently pending `with-timeout' calls.
(defvar with-timeout-timers nil (#$ . 19809))
#@410 Run BODY, but if it doesn't finish in SECONDS seconds, give up.
If we give up, we run the TIMEOUT-FORMS and return the value of the last one.
The timeout is checked whenever Emacs waits for some kind of external
event (such as keyboard input, input from subprocesses, or a certain time);
if the program loops without waiting in any way, the timeout will not
be detected.

(fn (SECONDS TIMEOUT-FORMS...) BODY)
(defalias 'with-timeout '(macro . #[(list &rest body) "@A\305\306!\307\310\311\312	D\313\314\315\316\317\316\320\312	D\312	DEEFD\321B\322\323\fB\324BBEEDC\325\326\310\312	DE\323\nB\327BBBE+\207" [list timeout timeout-forms seconds body make-symbol "timeout" let -with-timeout-value- catch quote let* -with-timeout-timer- run-with-timer nil lambda throw ((with-timeout-timers (cons -with-timeout-timer- with-timeout-timers))) unwind-protect progn ((cancel-timer -with-timeout-timer-)) if eq (-with-timeout-value-)] 15 (#$ . 19929)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put with-timeout lisp-indent-function 1 edebug-form-spec ((form body) body)] 4)
#@283 Stop the clock for `with-timeout'.  Used by debuggers.
The idea is that the time you spend in the debugger should not
count against these timeouts.

The value is a list that the debugger can pass to `with-timeout-unsuspend'
when it exits, to make these timers start counting again.
(defalias 'with-timeout-suspend #[nil "\301\302\"\207" [with-timeout-timers mapcar #[(timer) "\301!\210\302\303!\304 \"D\207" [timer cancel-timer time-subtract timer--time current-time] 4]] 3 (#$ . 21021)])
#@117 Restart the clock for `with-timeout'.
The argument should be a value previously returned by `with-timeout-suspend'.
(defalias 'with-timeout-unsuspend #[(timer-spec-list) "\306\211\205+\n@\211@	\211A@)\307
\310\311 \f\"\"\210\312
!\210*\nA\211\204\306*\207" [timer-spec-list elt --dolist-tail-- x delay timer nil timer-set-time time-add current-time timer-activate] 6 (#$ . 21521)])
#@114 Like (y-or-n-p PROMPT), with a timeout.
If the user does not answer after SECONDS seconds, return DEFAULT-VALUE.
(defalias 'y-or-n-p-with-timeout #[(prompt seconds default-value) "\302\303\215\211\302=\203	\202)\207" [-with-timeout-value- default-value #1=#:timeout (byte-code "\304\305\306#\211\nB\307\216\310!+\207" [seconds -with-timeout-timer- with-timeout-timers prompt run-with-timer nil #[nil "\300\301\211\"\207" [throw #1#] 3] ((cancel-timer -with-timeout-timer-)) y-or-n-p] 5)] 3 (#$ . 21921)])
#@55 Alist mapping temporal words to durations in seconds.
(defconst timer-duration-words (byte-code "\300\301B\302\303B\304\305B\306\307B\310\311B\312\311B\313\314B\315\314B\316\317B\320\321B\322\323B\324\325B\326\327B\330\331B\257\207" ["microsec" 1e-06 "microsecond" 1e-06 "millisec" 0.001 "millisecond" 0.001 "sec" 1 "second" "min" 60 "minute" "hour" 3600 "day" 86400 "week" 604800 "fortnight" 1209600 "month" 2592000 "year" 31557600.0] 15) (#$ . 22442))
#@72 Return number of seconds specified by STRING, or nil if parsing fails.
(defalias 'timer-duration #[(string) "\306\211\307\310\311	#\203B\312\224\203\313\314\312\"!\202\312\315\314\316\"\f\"A
\2039\306\225\n
_\\\202>\317G*\202	GU\203M\n\202d\320\317\307\310	#,\205d\313!+\207" [case-fold-search start secs string timer-duration-words itemsize 0 t string-match "[ 	]*\\([0-9.]+\\)?[ 	]*\\([a-z]+[a-rt-z]\\)s?[ 	]*" 1 string-to-number match-string assoc 2 nil "\\`[0-9.]+\\'" count regexp inhibit-changing-match-data] 5 (#$ . 22903)])
(provide 'timer)