Current File : //usr/local/share/emacs/27.2/lisp/emacs-lisp/timer.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#@73 compiler-macro for inlining `timer--triggered'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'timer--triggered--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block timer--triggered (progn (aref cl-x 0))) nil] 9 (#$ . 408)])
(put 'timer--triggered 'compiler-macro 'timer--triggered--cmacro)
#@60 Access slot "triggered" of `timer' struct CL-X.
(fn CL-X)
(defalias 'timer--triggered #[257 "\211\300H\207" [0] 3 (#$ . 727)])
(byte-code "\300\301\302\303#\300\207" [function-put timer--triggered side-effect-free t] 4)
#@76 compiler-macro for inlining `timer--high-seconds'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'timer--high-seconds--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block timer--high-seconds (progn (aref cl-x 1))) nil] 9 (#$ . 954)])
(put 'timer--high-seconds 'compiler-macro 'timer--high-seconds--cmacro)
#@63 Access slot "high-seconds" of `timer' struct CL-X.
(fn CL-X)
(defalias 'timer--high-seconds #[257 "\211\300H\207" [1] 3 (#$ . 1288)])
(byte-code "\300\301\302\303#\300\207" [function-put timer--high-seconds side-effect-free t] 4)
#@75 compiler-macro for inlining `timer--low-seconds'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'timer--low-seconds--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block timer--low-seconds (progn (aref cl-x 2))) nil] 9 (#$ . 1525)])
(put 'timer--low-seconds 'compiler-macro 'timer--low-seconds--cmacro)
#@62 Access slot "low-seconds" of `timer' struct CL-X.
(fn CL-X)
(defalias 'timer--low-seconds #[257 "\211\300H\207" [2] 3 (#$ . 1855)])
(byte-code "\300\301\302\303#\300\207" [function-put timer--low-seconds side-effect-free t] 4)
#@69 compiler-macro for inlining `timer--usecs'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'timer--usecs--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block timer--usecs (progn (aref cl-x 3))) nil] 9 (#$ . 2089)])
(put 'timer--usecs 'compiler-macro 'timer--usecs--cmacro)
#@56 Access slot "usecs" of `timer' struct CL-X.
(fn CL-X)
(defalias 'timer--usecs #[257 "\211\300H\207" [3] 3 (#$ . 2389)])
(byte-code "\300\301\302\303#\300\207" [function-put timer--usecs side-effect-free t] 4)
#@76 compiler-macro for inlining `timer--repeat-delay'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'timer--repeat-delay--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block timer--repeat-delay (progn (aref cl-x 4))) nil] 9 (#$ . 2605)])
(put 'timer--repeat-delay 'compiler-macro 'timer--repeat-delay--cmacro)
#@63 Access slot "repeat-delay" of `timer' struct CL-X.
(fn CL-X)
(defalias 'timer--repeat-delay #[257 "\211\300H\207" [4] 3 (#$ . 2940)])
(byte-code "\300\301\302\303#\300\207" [function-put timer--repeat-delay side-effect-free t] 4)
#@72 compiler-macro for inlining `timer--function'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'timer--function--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block timer--function (progn (aref cl-x 5))) nil] 9 (#$ . 3177)])
(put 'timer--function 'compiler-macro 'timer--function--cmacro)
#@59 Access slot "function" of `timer' struct CL-X.
(fn CL-X)
(defalias 'timer--function #[257 "\211\300H\207" [5] 3 (#$ . 3492)])
(byte-code "\300\301\302\303#\300\207" [function-put timer--function side-effect-free t] 4)
#@68 compiler-macro for inlining `timer--args'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'timer--args--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block timer--args (progn (aref cl-x 6))) nil] 9 (#$ . 3717)])
(put 'timer--args 'compiler-macro 'timer--args--cmacro)
#@55 Access slot "args" of `timer' struct CL-X.
(fn CL-X)
(defalias 'timer--args #[257 "\211\300H\207" [6] 3 (#$ . 4012)])
(byte-code "\300\301\302\303#\300\207" [function-put timer--args side-effect-free t] 4)
#@74 compiler-macro for inlining `timer--idle-delay'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'timer--idle-delay--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block timer--idle-delay (progn (aref cl-x 7))) nil] 9 (#$ . 4225)])
(put 'timer--idle-delay 'compiler-macro 'timer--idle-delay--cmacro)
#@61 Access slot "idle-delay" of `timer' struct CL-X.
(fn CL-X)
(defalias 'timer--idle-delay #[257 "\211\300H\207" [7] 3 (#$ . 4550)])
(byte-code "\300\301\302\303#\300\207" [function-put timer--idle-delay side-effect-free t] 4)
#@69 compiler-macro for inlining `timer--psecs'.
(fn CL-WHOLE-ARG CL-X)
(defalias 'timer--psecs--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block timer--psecs (progn (aref cl-x 8))) nil] 9 (#$ . 4781)])
(put 'timer--psecs 'compiler-macro 'timer--psecs--cmacro)
#@56 Access slot "psecs" of `timer' struct CL-X.
(fn CL-X)
(defalias 'timer--psecs #[257 "\211\300H\207" [8] 3 (#$ . 5081)])
(byte-code "\300\301\302\303#\300\207" [function-put timer--psecs side-effect-free t] 4)
#@64 compiler-macro for inlining `timer-create'.
(fn CL-WHOLE-ARG)
(defalias 'timer-create--cmacro #[257 "\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))] 7 (#$ . 5297)])
(put 'timer-create 'compiler-macro 'timer-create--cmacro)
#@42 Constructor for objects of type `timer'.
(defalias 'timer-create #[0 "\300\301\302\211\211\211\211\211\211\211& \207" [vector t nil] 10 (#$ . 5603)])
(byte-code "\300\301\302\303#\304\305\306\211\307\306\310\311\305\306& \207" [function-put timer-create side-effect-free t cl-struct-define timer nil vector ((triggered t) (high-seconds) (low-seconds) (usecs) (repeat-delay) (function) (args) (idle-delay) (psecs)) cl-struct-timer-tags] 11)
#@45 Return t if OBJECT is a timer.
(fn OBJECT)
(defalias 'timerp #[257 "\300!\205\n \211G\301U\207" [vectorp 9] 3 (#$ . 6049)])
#@14
(fn TIMER)
(defalias 'timer--check #[257 "\300!\206\f \301\302\300D\"\207" [timerp signal wrong-type-argument] 5 (#$ . 6181)])
(put 'timer--check 'byte-optimizer 'byte-compile-inline-expand)
#@19
(fn TIMER TIME)
(defalias 'timer--time-setter #[514 "\300!\206
\301\302\300D\"\266\303\304\"\211\305@I\266\211\306A@I\266\211\307\3068I\266\211\310\3078I\266\207" [timerp signal wrong-type-argument time-convert list 1 2 3 8] 8 (#$ . 6382)])
#@14
(fn TIMER)
(defalias 'timer--time #[257 "\211\300H\301H\302H\303HF\207" [1 2 3 8] 6 (#$ . 6650)])
(byte-code "\300\301\302\303#\300\207" [function-put timer--time gv-expander #[385 "\300\301\302$\207" [gv--defsetter timer--time #[385 "\300\301C\"B\207" [timer--time-setter append] 6 "\n\n(fn VAL &rest ARGS)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@216 Set the trigger time of TIMER to TIME.
TIME must be a Lisp time value.
If optional third argument DELTA is a positive number, make the timer
fire repeatedly that many seconds apart.
(fn TIMER TIME &optional DELTA)
(defalias 'timer-set-time #[770 "\300\"\266\211\301\247\205 \302V\205 I\266\207" [timer--time-setter 4 0] 8 (#$ . 7009)])
#@307 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.
(fn TIMER SECS &optional REPEAT)
(defalias 'timer-set-idle-time #[770 "\300\"\266\211\301I\266\207" [timer--time-setter 4] 7 (#$ . 7365)])
#@218 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.
(fn TIME SECS)
(defalias 'timer-next-integral-multiple-of-time #[514 "\300\301\"\211@A\302_\303!\262\211U?\262\203) \304\305\"\262\304\305\"\262\202 \\\300\211\246ZB!\262\207" [time-convert t nil truncate ash 1] 11 (#$ . 7792)])
#@184 Advance TIME by SECS seconds and optionally USECS microseconds
and PSECS picoseconds. SECS may be either an integer or a
floating point number.
(fn TIME SECS &optional USECS PSECS)
(defalias 'timer-relative-time #[1026 "\204 \203 \300\301\211\206 \301\206 \301F\"\262\300\"\207" [time-add 0] 11 (#$ . 8249)])
#@67 Say whether time value T1 is less than time value T2.
(fn T1 T2)
(defalias 'timer--time-less-p #[514 "\300\301!\301!\"\207" [time-less-p timer--time] 6 (#$ . 8581)])
#@215 Increment the time set in TIMER by SECS seconds, USECS microseconds,
and PSECS picoseconds. SECS may be a fraction. If USECS or PSECS are
omitted, they are treated as zero.
(fn TIMER SECS &optional USECS PSECS)
(defalias 'timer-inc-time #[1026 "\300\301\302!$\"\207" [timer--time-setter timer-relative-time timer--time] 12 (#$ . 8757)])
#@98 Make TIMER call FUNCTION with optional ARGS when triggering.
(fn TIMER FUNCTION &optional ARGS)
(defalias 'timer-set-function #[770 "\300!\206
\301\302\300D\"\266\211\303I\266\211\304I\266\207" [timerp signal wrong-type-argument 5 6] 8 (#$ . 9113)])
#@52
(fn TIMER &optional TRIGGERED-P REUSE-CELL IDLE)
(defalias 'timer--activate #[1025 "\302!\203\207 \303H\250\203\207 \304H\250\203\207 \305H\250\203\207 \306H\250\203\207 \307H\203\207 \211\2030 \2021 \310\203I \311@\"\203I \262A\262\2022 \203Y \240\210\241\210\202^ B\262\211\203k \211\211\241\266\202v \203t \202v \211\312I\266\211\313I\266\310\207\314\315!\207" [timer-idle-list timer-list timerp 1 2 3 8 5 nil timer--time-less-p 0 7 error "Invalid or uninitialized timer"] 10 (#$ . 9382)])
#@442 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.
(fn TIMER &optional TRIGGERED-P REUSE-CELL)
(defalias 'timer-activate #[769 "\300\301$\207" [timer--activate nil] 8 (#$ . 9923)])
#@786 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.
(fn TIMER &optional DONT-WAIT REUSE-CELL)
(defalias 'timer-activate-when-idle #[769 "\300?\301$\207" [timer--activate idle] 8 (#$ . 10460)])
(defalias 'disable-timeout 'cancel-timer)
#@58 Remove TIMER from the list of active timers.
(fn TIMER)
(defalias 'cancel-timer #[257 "\211\302!\206
\303\304\302D\"\266\305\"\305 \"\306\207" [timer-list timer-idle-list timerp signal wrong-type-argument delq nil] 6 (#$ . 11395)])
#@167 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.
(fn TIMER)
(defalias 'cancel-timer-internal #[257 "\211> >\203 \302\"\211\203 \302 \"\206 \211\207" [timer-list timer-idle-list delq] 6 (#$ . 11644)])
#@193 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'.
(fn FUNCTION)
(defalias 'cancel-function-timers #[257 "\211\203 \211@\211\302H=\203 \303\"A\266\202\202 \210 \211\2057 \211@\211\302H=\2030 \303 \"A\266\202\202 \207" [timer-list timer-idle-list 5 delq] 6 (#$ . 11969) "aCancel timers of function: "])
#@26 Last timer that was run.
(defvar timer-event-last nil (#$ . 12418))
#@34 Next-to-last timer that was run.
(defvar timer-event-last-1 nil (#$ . 12492))
#@35 Third-to-last timer that was run.
(defvar timer-event-last-2 nil (#$ . 12576))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable timer-max-repeats funcall function #[0 "\300\207" [10] 1] "Maximum number of times to repeat a timer, if many repeats are delayed.\nTimer invocations can be delayed because Emacs is suspended or busy,\nor because the system's time changes. If such an occurrence makes it\nappear that many invocations are overdue, this variable controls\nhow many will really happen." :type integer :group internal] 8)
#@188 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 Lisp time value.
(fn TIMER TIME)
(defalias 'timer-until #[514 "\300\301\302!\"!\207" [float-time time-subtract timer--time] 7 (#$ . 13152)])
#@109 Call the handler for the timer TIMER.
This function is called, by name, directly by the C code.
(fn TIMER)
(defalias 'timer-event-handler #[257 "\n\211\306\211\307!\206 \310\311\307D\"\266\312\313!\211\205\247 \314H\203k \315H\2034 \316\312#\210\202k \317\211\314H\320#\210\f\247\203b \321\322!\312\"\203b \323\312\"\314H\245\211\fV\203a \317\211\314H_\"\210\210\324\306#\210\306\262\3251} r\326\327H\330H\")0\202\225 \331\332\327H9\203\220 \333\334\327H\"\202\221 \335#\262\210\205\247
>\205\247 \211\320\312I\262\266\202)\207" [timer-event-last-1 timer-event-last-2 timer-event-last inhibit-quit timer-max-repeats timer-list t timerp signal wrong-type-argument nil cancel-timer-internal 4 7 timer-activate-when-idle timer-inc-time 0 time-less-p timer--time timer-until timer-activate (debug error) apply 5 6 message "Error running timer%s: %S" format-message " `%s'" ""] 10 (#$ . 13456)])
#@50 Non-nil if EVENT is a timeout event.
(fn EVENT)
(defalias 'timeout-event-p #[257 "\211<\205 \211@\300=\207" [timer-event] 3 (#$ . 14389)])
#@948 Perform an action at time TIME.
Repeat the action every REPEAT seconds, if REPEAT is non-nil.
REPEAT may be an integer or floating point number.
TIME should be one of:
- a string giving today's time like "11:23pm"
(the acceptable formats are HHMM, H:MM, HH:MM, HHam, HHAM,
HHpm, HHPM, HH:MMam, HH:MMAM, HH:MMpm, or HH:MMPM;
a period `.' can be used instead of a colon `:' to separate
the hour and minute parts);
- a string giving a relative time like "90" or "2 hours 35 minutes"
(the acceptable forms are a number of seconds without units
or some combination of values using units in `timer-duration-words');
- 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.
The action is to call FUNCTION with arguments ARGS.
This function returns a timer object which you can use in
`cancel-timer'.
(fn TIME REPEAT FUNCTION &rest ARGS)
(defalias 'run-at-time #[899 "\203 \247\203 \300W\204 \301\302!\210\204 \303 \262\304=\203, \203, \305\303 \"\262\247\2037 \306\307\"\262;\203J \310!\211\203I \306\307\"\262\210;\203{ \311\312!\210\313!\314 \300Y\203y \315\300\316\246\316\245\3178\3208\3218\3228&\262\266\323\211\"\204\206 \301\324!\210\325\304\307\211\211\211\211\211\211\211& \326#\210\327#\210\330!\210\211\207" [0 error "Invalid repetition interval" current-time t timer-next-integral-multiple-of-time timer-relative-time nil timer-duration require diary-lib diary-entry-time decode-time encode-time 100 3 4 5 8 time-equal-p "Invalid time format" vector timer-set-time timer-set-function timer-activate] 15 (#$ . 14537) "sRun at time: \nNRepeat interval: \naFunction: "])
#@336 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'.
(fn SECS REPEAT FUNCTION &rest ARGS)
(defalias 'run-with-timer #[899 "\300\301%\207" [apply run-at-time] 10 (#$ . 16279) "sRun after delay (seconds): \nNRepeat interval: \naFunction: "])
#@314 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 returns a timer object which you can use in `cancel-timer'.
This function is for compatibility; see also `run-with-timer'.
(fn SECS FUNCTION OBJECT &optional REPEAT)
(defalias 'add-timeout #[1027 "\300$\207" [run-with-timer] 9 (#$ . 16775)])
#@757 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'.
(fn SECS REPEAT FUNCTION &rest ARGS)
(defalias 'run-with-idle-timer #[899 "\300\301\302\211\211\211\211\211\211\211& \303#\210\304#\210\305\301\"\210\211\207" [vector t nil timer-set-function timer-set-idle-time timer-activate-when-idle] 14 (#$ . 17175) (byte-code "\301\302\303\211\304$\305\306!\307\310\311\312\304$!E\207" [obarray read-from-minibuffer "Run after idle (seconds): " nil t y-or-n-p "Repeat each time Emacs is idle? " intern completing-read "Function: " fboundp] 8)])
#@68 List of all timers used by currently pending `with-timeout' calls.
(defvar with-timeout-timers nil (#$ . 18394))
#@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 . #[385 "@A\300\301!\302\303\304\305D\306\307\310 \311\312\311\313\305
D\305DEEFD\314B\315\316 B\317BBEEDC\320\321\303\305DE\316B\322BBBE\207" [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-)] 20 (#$ . 18514)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-timeout lisp-indent-function 1 put edebug-form-spec ((form body) body)] 5)
#@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 #[0 "\301\302\"\207" [with-timeout-timers mapcar #[257 "\300!\210\211\301\302!\303\"D\207" [cancel-timer time-subtract timer--time nil] 5 "\n\n(fn TIMER)"]] 3 (#$ . 19561)])
#@139 Restart the clock for `with-timeout'.
The argument should be a value previously returned by `with-timeout-suspend'.
(fn TIMER-SPEC-LIST)
(defalias 'with-timeout-unsuspend #[257 "\211\211\205 \211@\211@A@\300\301\302\"\"\210\303!\266A\266\202\202 \207" [timer-set-time time-add nil timer-activate] 10 (#$ . 20059)])
#@149 Like (y-or-n-p PROMPT), with a timeout.
If the user does not answer after SECONDS seconds, return DEFAULT-VALUE.
(fn PROMPT SECONDS DEFAULT-VALUE)
(defalias 'y-or-n-p-with-timeout #[771 "\3012 \302\303\304#\211B\305\306\307\310\311!\312\"\313$\216\314!*\2620\211\301=\203* \202+ \211\207" [with-timeout-timers #1=#:timeout run-with-timer nil #[0 "\300\301\211\"\207" [throw #1#] 3] make-byte-code 0 "\301\300!\207" vconcat vector [cancel-timer] 2 y-or-n-p] 10 (#$ . 20390)])
#@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\331\332\333\314\211$B\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" * 365.25 24] 19) (#$ . 20880))
#@85 Return number of seconds specified by STRING, or nil if parsing fails.
(fn STRING)
(defalias 'timer-duration #[257 "\303\211\304\305\306#\203B \307\224\203 \310\311\307\"!\202 \307\312\311\313\" \"A\211\2036 \303\225\262_\\\262\202= \314\262G\262\266\202 \211GU\203M \202` \315\314\304\305#)\266\203\205` \310!)\207" [case-fold-search timer-duration-words inhibit-changing-match-data 0 t string-match "[ ]*\\([0-9.]+\\)?[ ]*\\([a-z]+[a-rt-z]\\)s?[ ]*" 1 string-to-number match-string assoc 2 nil "\\`[0-9.]+\\'"] 10 (#$ . 21359)])
#@65 Mark all idle-time timers as once again candidates for running.
(defalias 'internal-timer-start-idle #[0 "\211\205 \211@\301!\203 \211\211\302\303I\266A\266\202\202 \207" [timer-idle-list timerp 0 nil] 6 (#$ . 21926)])
(provide 'timer)
Mini Shell