Gecko [ 122.154.134.11 ]

Name	Size	Permission
advice.elc	60.71 KB	-rw-r--r--
assoc.elc	4.37 KB	-rw-r--r--
authors.elc	27.41 KB	-rw-r--r--
autoload.elc	15.7 KB	-rw-r--r--
avl-tree.elc	15.92 KB	-rw-r--r--
backquote.elc	4.46 KB	-rw-r--r--
benchmark.elc	3.33 KB	-rw-r--r--
bindat.elc	10.84 KB	-rw-r--r--
byte-opt.elc	34.22 KB	-rw-r--r--
byte-run.elc	6.65 KB	-rw-r--r--
bytecomp.elc	124.99 KB	-rw-r--r--
check-declare.elc	8.77 KB	-rw-r--r--
checkdoc.elc	65.08 KB	-rw-r--r--
cl-compat.elc	4.28 KB	-rw-r--r--
cl-extra.elc	21.48 KB	-rw-r--r--
cl-indent.elc	13.98 KB	-rw-r--r--
cl-loaddefs.el	39.57 KB	-rw-r--r--
cl-macs.elc	99.36 KB	-rw-r--r--
cl-seq.elc	43.98 KB	-rw-r--r--
cl-specs.el	13.87 KB	-rw-r--r--
cl.elc	20.74 KB	-rw-r--r--
copyright.elc	8.64 KB	-rw-r--r--
crm.elc	7.94 KB	-rw-r--r--
cust-print.elc	12.77 KB	-rw-r--r--
debug.elc	24.86 KB	-rw-r--r--
derived.elc	10.72 KB	-rw-r--r--
disass.elc	5.09 KB	-rw-r--r--
easy-mmode.elc	14.85 KB	-rw-r--r--
easymenu.elc	20.15 KB	-rw-r--r--
edebug.elc	100.82 KB	-rw-r--r--
eldoc.elc	15.31 KB	-rw-r--r--
elint.elc	19.76 KB	-rw-r--r--
elp.elc	12.78 KB	-rw-r--r--
ewoc.elc	28.62 KB	-rw-r--r--
find-func.elc	17.26 KB	-rw-r--r--
find-gc.elc	3.74 KB	-rw-r--r--
float-sup.elc	1.39 KB	-rw-r--r--
generic.elc	6.55 KB	-rw-r--r--
gulp.elc	4.82 KB	-rw-r--r--
helper.elc	3.84 KB	-rw-r--r--
levents.elc	10.29 KB	-rw-r--r--
lisp-mnt.elc	21.87 KB	-rw-r--r--
lisp-mode.elc	37.14 KB	-rw-r--r--
lisp.elc	21.61 KB	-rw-r--r--
lmenu.elc	11.67 KB	-rw-r--r--
lucid.elc	6.22 KB	-rw-r--r--
macroexp.elc	4.45 KB	-rw-r--r--
map-ynp.elc	6.3 KB	-rw-r--r--
pp.elc	5.09 KB	-rw-r--r--
re-builder.elc	22.36 KB	-rw-r--r--
regexp-opt.elc	4.43 KB	-rw-r--r--
regi.elc	6.15 KB	-rw-r--r--
ring.elc	6.41 KB	-rw-r--r--
rx.elc	26.61 KB	-rw-r--r--
shadow.elc	5.63 KB	-rw-r--r--
sregex.elc	12.45 KB	-rw-r--r--
syntax.elc	5.18 KB	-rw-r--r--
tcover-ses.elc	14.68 KB	-rw-r--r--
tcover-unsafep.elc	4.09 KB	-rw-r--r--
testcover.elc	13.41 KB	-rw-r--r--
timer.elc	22.73 KB	-rw-r--r--
tq.elc	3.94 KB	-rw-r--r--
trace.elc	5.28 KB	-rw-r--r--
unsafep.elc	5.01 KB	-rw-r--r--
warnings.elc	9.61 KB	-rw-r--r--

Code Editor : timer.elc

;ELC���
;;; Compiled by mockbuild@c6b8.bsys.dev.centos.org on Thu Feb 19 13:02:23 2015
;;; from file /builddir/build/BUILD/emacs-23.1/lisp/emacs-lisp/timer.el
;;; in Emacs version 23.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`timer.el' was compiled for Emacs 19.29 or later"))

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

(byte-code "\300\301\302\303#\210\301\304N\204�\300\301\304\305#\210\300\207" [put timer--triggered cl-compiler-macro #[(--cl-whole-arg-- cl-x) "\301\302\303\304\305\211&\207" [cl-x cl-defsubst-expand (cl-x) (block timer--triggered (aref cl-x 0)) t nil] 7] byte-compile cl-byte-compile-compiler-macro] 4)
(defalias 'timer--triggered #[(cl-x) "\301H\207" [cl-x 0] 2])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\304\307N\204�\300\304\307\310#\210\300\207" [put timer--triggered setf-method #[(cl-x) "\301\302\303\304\305%\207" [cl-x cl-struct-setf-expander timer timer--triggered nil 0] 6] timer--high-seconds cl-compiler-macro #[(--cl-whole-arg-- cl-x) "\301\302\303\304\305\211&\207" [cl-x cl-defsubst-expand (cl-x) (block timer--high-seconds (aref cl-x 1)) t nil] 7] byte-compile cl-byte-compile-compiler-macro] 4)
(defalias 'timer--high-seconds #[(cl-x) "\301H\207" [cl-x 1] 2])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\304\307N\204�\300\304\307\310#\210\300\207" [put timer--high-seconds setf-method #[(cl-x) "\301\302\303\304\305%\207" [cl-x cl-struct-setf-expander timer timer--high-seconds nil 1] 6] timer--low-seconds cl-compiler-macro #[(--cl-whole-arg-- cl-x) "\301\302\303\304\305\211&\207" [cl-x cl-defsubst-expand (cl-x) (block timer--low-seconds (aref cl-x 2)) t nil] 7] byte-compile cl-byte-compile-compiler-macro] 4)
(defalias 'timer--low-seconds #[(cl-x) "\301H\207" [cl-x 2] 2])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\304\307N\204�\300\304\307\310#\210\300\207" [put timer--low-seconds setf-method #[(cl-x) "\301\302\303\304\305%\207" [cl-x cl-struct-setf-expander timer timer--low-seconds nil 2] 6] timer--usecs cl-compiler-macro #[(--cl-whole-arg-- cl-x) "\301\302\303\304\305\211&\207" [cl-x cl-defsubst-expand (cl-x) (block timer--usecs (aref cl-x 3)) t nil] 7] byte-compile cl-byte-compile-compiler-macro] 4)
(defalias 'timer--usecs #[(cl-x) "\301H\207" [cl-x 3] 2])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\304\307N\204�\300\304\307\310#\210\300\207" [put timer--usecs setf-method #[(cl-x) "\301\302\303\304\305%\207" [cl-x cl-struct-setf-expander timer timer--usecs nil 3] 6] timer--repeat-delay cl-compiler-macro #[(--cl-whole-arg-- cl-x) "\301\302\303\304\305\211&\207" [cl-x cl-defsubst-expand (cl-x) (block timer--repeat-delay (aref cl-x 4)) t nil] 7] byte-compile cl-byte-compile-compiler-macro] 4)
(defalias 'timer--repeat-delay #[(cl-x) "\301H\207" [cl-x 4] 2])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\304\307N\204�\300\304\307\310#\210\300\207" [put timer--repeat-delay setf-method #[(cl-x) "\301\302\303\304\305%\207" [cl-x cl-struct-setf-expander timer timer--repeat-delay nil 4] 6] timer--function cl-compiler-macro #[(--cl-whole-arg-- cl-x) "\301\302\303\304\305\211&\207" [cl-x cl-defsubst-expand (cl-x) (block timer--function (aref cl-x 5)) t nil] 7] byte-compile cl-byte-compile-compiler-macro] 4)
(defalias 'timer--function #[(cl-x) "\301H\207" [cl-x 5] 2])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\304\307N\204�\300\304\307\310#\210\300\207" [put timer--function setf-method #[(cl-x) "\301\302\303\304\305%\207" [cl-x cl-struct-setf-expander timer timer--function nil 5] 6] timer--args cl-compiler-macro #[(--cl-whole-arg-- cl-x) "\301\302\303\304\305\211&\207" [cl-x cl-defsubst-expand (cl-x) (block timer--args (aref cl-x 6)) t nil] 7] byte-compile cl-byte-compile-compiler-macro] 4)
(defalias 'timer--args #[(cl-x) "\301H\207" [cl-x 6] 2])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\304\307N\204�\300\304\307\310#\210\300\207" [put timer--args setf-method #[(cl-x) "\301\302\303\304\305%\207" [cl-x cl-struct-setf-expander timer timer--args nil 6] 6] timer--idle-delay cl-compiler-macro #[(--cl-whole-arg-- cl-x) "\301\302\303\304\305\211&\207" [cl-x cl-defsubst-expand (cl-x) (block timer--idle-delay (aref cl-x 7)) t nil] 7] byte-compile cl-byte-compile-compiler-macro] 4)
(defalias 'timer--idle-delay #[(cl-x) "\301H\207" [cl-x 7] 2])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\304\307N\204�\300\304\307\310#\210\300\207" [put timer--idle-delay setf-method #[(cl-x) "\301\302\303\304\305%\207" [cl-x cl-struct-setf-expander timer timer--idle-delay nil 7] 6] timer-create cl-compiler-macro #[(--cl-whole-arg--) "\300\301\302\303\301\211%\207" [cl-defsubst-expand nil (block timer-create (vector t nil nil nil nil nil nil nil)) t] 6] byte-compile cl-byte-compile-compiler-macro] 4)
(defalias 'timer-create #[nil "\300\301\302\211\211\211\211\211\211&\207" [vector t nil] 9])
(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#\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)) cl-struct-type (vector nil) cl-struct-include nil cl-struct-print timer-create side-effect-free t 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\n�G\302U\207" [object vectorp 8] 2 (#$ . 5874)])
(defalias 'timer--time #[(timer) "\301H\302H\303HE\207" [timer 1 2 3] 4])
(put 'timer--time 'setf-method #[(&rest args) "\304\305\"\306\307!	\nC	\n\310\311C\"*B\312	B\257*\207" [args --args--temp-- --store--temp-- store mapcar #[(_) "\300\301!\207" [make-symbol "--cl-var--"] 2] make-symbol "--cl-store--" (lambda (timer time) (or (timerp timer) (error "Invalid timer")) (setf (timer--high-seconds timer) (pop time)) (setf (timer--low-seconds timer) (if (consp time) (car time) time)) (setf (timer--usecs timer) (or (and (consp time) (consp (cdr time)) (cadr time)) 0))) append timer--time] 7 "Not documented\n\n(fn &rest ARGS)"])
#@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) "	\306!\204�\307\310!\210	\211A@\n\311I\210*\312	:\203(�	@\202)�	I\210	:\203A�	A:\203A�	\211A@)\206B�\313\f\314I\210,\315\247\205\\�\313V\205\\�I\210\207" [timer time #1=#:--cl-x-- #2=#:--cl-store-- #3=#:--cl-x-- x timerp error "Invalid timer" 1 2 0 3 4 #4=#:--cl-store-- delta] 5 (#$ . 6646)])
#@290 Set the trigger idle time of TIMER to SECS.
SECS may be an integer, floating point number, or the internal
time format (HIGH LOW USECS) 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) ":\203T�	\306	!\204�\307\310!\210	\n\211A@\311\fI\210*	\312\n:\203-�\n@\202.�\nI\210	\n:\203G�\nA:\203G�\n\211A@)\206H�\313
\314I\210,\202\253�	\315\306	!\204b�\307\310!\210	\n\211A@\311I\210*	\312\n:\203\200�\n@\202\201�\nI\210	\n:\203\233�\nA:\203\233�\n\211A@)\206\234�\313\314I\210,\316	\"\210	\317I\210	\207" [secs timer time #1=#:--cl-x-- #2=#:--cl-store-- #3=#:--cl-x-- timerp error "Invalid timer" 1 2 0 3 (0 0 0) timer-inc-time 4 x #4=#:--cl-store-- #5=#:--cl-x-- #6=#:--cl-store-- #7=#:--cl-x-- #8=#:--cl-store-- repeat] 4 (#$ . 7252)])
#@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\307\310\"\311\312!\203V�\313!\314\211	@_A@\\_\3158\\\n
_\316\f\"\fZ\\	\n_\317\"\317\316\"\n\"\317\316\n\"!E.\202\203�\316\211
\"\316@
\"_A@\\
\"A@Z
\\@\317\"\\\316\"\320E*)\207" [time-base float-time-base million time time-usec secs ash 1 16 fboundp atan float 1000000.0 2 mod floor 0 secs-usec mod-usec next-usec time-base-million mod-sec next-1-sec] 7 (#$ . 8198)])
#@123 Advance TIME by SECS seconds and optionally USECS microseconds.
SECS may be either an integer or a floating point number.
(defalias 'timer-relative-time #[(time secs &optional usecs) "@A:\203�A@\202�AA\243\242\247\203�\3068\202�\307\f\203*�	\f\\\310
!\203<�	\311
\311
!Z\312_!\\\n\311
!\\\313\n	\312\245	\307W\203Q�\314\202R�\307#\315	\312\"\313\n\316\245\n\307W\203h�\314\202i�\307#\317\n\320\"\n	\307U?\205z�	E+\207" [time micro low high usecs secs 2 0 floatp floor 1000000 + -1 mod 65536 logand 65535] 5 (#$ . 8892)])
#@55 Say whether time value T1 is less than time value T2.
(defalias 'timer--time-less-p #[(t1 t2) "\306!\211G\307U\203�	\211A@\202�\310\311\312	GD\"	\211A@	@\306
!\211G\307U\203:�\211A@\202B�\310\311\312GD\"\f\211A@
@\n\fW\206r�\n\fU\205r�
W\206r�
U\205r�\fW.\207" [t1 #1=#:--cl-rest-- high1 low1 micro1 t2 timer--time 3 signal wrong-number-of-arguments nil #2=#:--cl-rest-- high2 low2 micro2] 5 (#$ . 9441)])
#@142 Increment the time set in TIMER by SECS seconds and USECS microseconds.
SECS may be a fraction.  If USECS is omitted, that means it is zero.
(defalias 'timer-inc-time #[(timer secs &optional usecs) "\306\307!\n#	\f\310!\204�\311\312!\210
\211A@\313I\210*\314
:\2036�
@\2027�
I\210
:\203Q�
A:\203Q�
\211A@)\206R�\315\316I.\207" [timer #1=#:--cl-var-- secs usecs #2=#:--cl-store-- time timer-relative-time timer--time timerp error "Invalid timer" 1 2 0 3 #3=#:--cl-x-- #4=#:--cl-store-- #5=#:--cl-x-- x #6=#:--cl-store--] 5 (#$ . 9890)])
#@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) "	\306!\204�\307\310!\210	\211A@\n\311I\210*\312	:\203(�	@\202)�	I\210	:\203A�	A:\203A�	\211A@)\206B�\313\f\314I\210,\314I\210\315\247\205b�\313V\205b�I\210\207" [timer time #1=#:--cl-x-- #2=#:--cl-store-- #3=#:--cl-x-- x timerp error "Invalid timer" 1 2 0 3 4 #4=#:--cl-store-- usecs delta] 5 (#$ . 10465)])
(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) "\303!\204\n�\304\305!\210\306	I\210\307\nI\210\207" [timer function args timerp error "Invalid timer" 5 6] 3 (#$ . 11290)])
(defalias 'timer--activate #[(timer &optional triggered-p reuse-cell idle) "\306!\203\200�\307H\250\203\200�\310H\250\203\200�\311H\250\203\200�\312H\203\200�	\203)�\n\202*�\313\211\203B�\314
@\"\203B�

A\211\2041�\203T�\240\210
\241\210\202Y�
B\f\203e�\f\241\210\202r�	\203o�\202r�\315I\210\316	I\210*\313\207\317\320!\207" [timer idle timer-idle-list timer-list last timers timerp 1 2 3 5 nil timer--time-less-p 0 7 error "Invalid or uninitialized timer" reuse-cell triggered-p] 4])
#@284 Put TIMER on the list of active timers.

If TRIGGERED-P is t, that means to make the timer inactive
(put it on the list, but mark it as already triggered).
To remove from the list, use `cancel-timer'.

REUSE-CELL, if non-nil, is a cons cell to reuse instead
of allocating a new one.
(defalias 'timer-activate #[(timer &optional triggered-p reuse-cell idle) "\303	\n\304$\207" [timer triggered-p reuse-cell timer--activate nil] 5 (#$ . 12069)])
#@276 Arrange to activate TIMER whenever Emacs is next idle.
If optional argument DONT-WAIT is non-nil, then enable the
timer to activate immediately, or at the right time, if Emacs
is already idle.

REUSE-CELL, if non-nil, is a cons cell to reuse instead
of allocating a new one.
(defalias 'timer-activate-when-idle #[(timer &optional dont-wait reuse-cell) "\303	?\n\304$\207" [timer dont-wait reuse-cell timer--activate idle] 5 (#$ . 12521)])
(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 (#$ . 13009)])
#@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 (#$ . 13241)])
#@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) "\306\211\203�\n@\211\307H=\203�\310	\"\nA\211\204�*\f\306\211\203?�
@\211\307H=\2038�\310	\f\"
A\211\204(�*\306\207" [timer-list timer #1=#:--cl-dolist-temp-- function timer-idle-list #2=#:--cl-dolist-temp-- nil 5 delq] 4 (#$ . 13576) "aCancel timers of function: "])
#@26 Last timer that was run.
(defvar timer-event-last nil (#$ . 14092))
#@34 Next-to-last timer that was run.
(defvar timer-event-last-1 nil (#$ . 14166))
#@35 Third-to-last timer that was run.
(defvar timer-event-last-2 nil (#$ . 14250))
#@307 *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.
(defvar timer-max-repeats 10 (#$ . -14336))
#@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) "@	\304HZA@	\305HZ\n\306_\\*\207" [time timer low high 1 2 65536] 4 (#$ . 14693)])
#@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|�\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\205x�\316\310I*\202�\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 "\301\302H\303H\"\207" [timer apply 5 6] 4) ((error)) error "Bogus timer event" retrigger timer-max-repeats repeats] 5 (#$ . 14989)])
#@38 Non-nil if EVENT is a timeout event.
(defalias 'timeout-event-p #[(event) "<\205	�@\301=\207" [event timer-event] 2 (#$ . 15769)])
#@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&\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] 10 (#$ . 15909) "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 (#$ . 17495) "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 (#$ . 18009)])
#@602 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 (HIGH LOW USECS) 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.

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&\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] 9 (#$ . 18354) (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)))])
#@71 This is the timer function used for the timer made by `with-timeout'.
(defalias 'with-timeout-handler #[(tag) "\301\302\"\207" [tag throw timeout] 3 (#$ . 19419)])
(put 'with-timeout 'lisp-indent-function 1)
#@68 List of all timers used by currently pending `with-timeout' calls.
(defvar with-timeout-timers nil (#$ . 19634))
#@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\304\305\306\307\310\311\312\313\314\n\315BBE\316\312\317\311BE\320BBBBE\311	B\321BBBE*\207" [list timeout-forms seconds body let ((with-timeout-tag (cons nil nil)) with-timeout-value with-timeout-timer (with-timeout-timers with-timeout-timers)) if catch with-timeout-tag progn setq with-timeout-timer run-with-timer (nil 'with-timeout-handler with-timeout-tag) (push with-timeout-timer with-timeout-timers) with-timeout-value (nil) ((cancel-timer with-timeout-timer) with-timeout-value)] 12 (#$ . 19754)]))
#@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 (#$ . 20740)])
#@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\203*�\n@\211@	\211A@)\307
\310\311 \f\"\"\210\312
!\210*\nA\211\204�*\306\207" [timer-spec-list elt #1=#:--cl-dolist-temp-- x delay timer nil timer-set-time time-add current-time timer-activate] 6 (#$ . 21240)])
#@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) "\305\211B\305\211\211\306\215\203�\f\202�\307	!\210\n,\207" [with-timeout-timers with-timeout-timer with-timeout-value with-timeout-tag default-value nil (byte-code "\306\307\310	$\211B\311\f!\307\207" [seconds with-timeout-tag with-timeout-timer with-timeout-timers prompt with-timeout-value run-with-timer nil with-timeout-handler y-or-n-p] 6) cancel-timer] 5 (#$ . 21648)])
#@55 Alist mapping temporal words to durations in seconds.
(defvar 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) (#$ . 22223))
#@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 (#$ . 22682)])
(provide 'timer)

${this.title}

Code Editor : timer.elc