225 lines
7.2 KiB
EmacsLisp
225 lines
7.2 KiB
EmacsLisp
;;; async-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
|
||
;;
|
||
;;; Code:
|
||
|
||
(add-to-list 'load-path (directory-file-name
|
||
(or (file-name-directory #$) (car load-path))))
|
||
|
||
|
||
;;;### (autoloads nil "async" "async.el" (0 0 0 0))
|
||
;;; Generated autoloads from async.el
|
||
|
||
(autoload 'async-start-process "async" "\
|
||
Start the executable PROGRAM asynchronously named NAME. See `async-start'.
|
||
PROGRAM is passed PROGRAM-ARGS, calling FINISH-FUNC with the
|
||
process object when done. If FINISH-FUNC is nil, the future
|
||
object will return the process object when the program is
|
||
finished. Set DEFAULT-DIRECTORY to change PROGRAM's current
|
||
working directory.
|
||
|
||
\(fn NAME PROGRAM FINISH-FUNC &rest PROGRAM-ARGS)" nil nil)
|
||
|
||
(autoload 'async-start "async" "\
|
||
Execute START-FUNC (often a lambda) in a subordinate Emacs process.
|
||
When done, the return value is passed to FINISH-FUNC. Example:
|
||
|
||
(async-start
|
||
;; What to do in the child process
|
||
(lambda ()
|
||
(message \"This is a test\")
|
||
(sleep-for 3)
|
||
222)
|
||
|
||
;; What to do when it finishes
|
||
(lambda (result)
|
||
(message \"Async process done, result should be 222: %s\"
|
||
result)))
|
||
|
||
If you call `async-send' from a child process, the message will
|
||
be also passed to the FINISH-FUNC. You can test RESULT to see if
|
||
it is a message by using `async-message-p'. If nil, it means
|
||
this is the final result. Example of the FINISH-FUNC:
|
||
|
||
(lambda (result)
|
||
(if (async-message-p result)
|
||
(message \"Received a message from child process: %s\" result)
|
||
(message \"Async process done, result: %s\" result)))
|
||
|
||
If FINISH-FUNC is nil or missing, a future is returned that can
|
||
be inspected using `async-get', blocking until the value is
|
||
ready. Example:
|
||
|
||
(let ((proc (async-start
|
||
;; What to do in the child process
|
||
(lambda ()
|
||
(message \"This is a test\")
|
||
(sleep-for 3)
|
||
222))))
|
||
|
||
(message \"I'm going to do some work here\") ;; ....
|
||
|
||
(message \"Waiting on async process, result should be 222: %s\"
|
||
(async-get proc)))
|
||
|
||
If you don't want to use a callback, and you don't care about any
|
||
return value from the child process, pass the `ignore' symbol as
|
||
the second argument (if you don't, and never call `async-get', it
|
||
will leave *emacs* process buffers hanging around):
|
||
|
||
(async-start
|
||
(lambda ()
|
||
(delete-file \"a remote file on a slow link\" nil))
|
||
\\='ignore)
|
||
|
||
Special case:
|
||
If the output of START-FUNC is a string with properties
|
||
e.g. (buffer-string) RESULT will be transformed in a list where the
|
||
car is the string itself (without props) and the cdr the rest of
|
||
properties, this allows using in FINISH-FUNC the string without
|
||
properties and then apply the properties in cdr to this string (if
|
||
needed).
|
||
Properties handling special objects like markers are returned as
|
||
list to allow restoring them later.
|
||
See <https://github.com/jwiegley/emacs-async/issues/145> for more infos.
|
||
|
||
Note: Even when FINISH-FUNC is present, a future is still
|
||
returned except that it yields no value (since the value is
|
||
passed to FINISH-FUNC). Call `async-get' on such a future always
|
||
returns nil. It can still be useful, however, as an argument to
|
||
`async-ready' or `async-wait'.
|
||
|
||
\(fn START-FUNC &optional FINISH-FUNC)" nil nil)
|
||
|
||
(register-definition-prefixes "async" '("async-"))
|
||
|
||
;;;***
|
||
|
||
;;;### (autoloads nil "async-bytecomp" "async-bytecomp.el" (0 0 0
|
||
;;;;;; 0))
|
||
;;; Generated autoloads from async-bytecomp.el
|
||
|
||
(autoload 'async-byte-recompile-directory "async-bytecomp" "\
|
||
Compile all *.el files in DIRECTORY asynchronously.
|
||
All *.elc files are systematically deleted before proceeding.
|
||
|
||
\(fn DIRECTORY &optional QUIET)" nil nil)
|
||
|
||
(defvar async-bytecomp-package-mode nil "\
|
||
Non-nil if Async-Bytecomp-Package mode is enabled.
|
||
See the `async-bytecomp-package-mode' command
|
||
for a description of this minor mode.
|
||
Setting this variable directly does not take effect;
|
||
either customize it (see the info node `Easy Customization')
|
||
or call the function `async-bytecomp-package-mode'.")
|
||
|
||
(custom-autoload 'async-bytecomp-package-mode "async-bytecomp" nil)
|
||
|
||
(autoload 'async-bytecomp-package-mode "async-bytecomp" "\
|
||
Byte compile asynchronously packages installed with package.el.
|
||
Async compilation of packages can be controlled by
|
||
`async-bytecomp-allowed-packages'.
|
||
|
||
This is a minor mode. If called interactively, toggle the
|
||
`Async-Bytecomp-Package mode' mode. If the prefix argument is
|
||
positive, enable the mode, and if it is zero or negative, disable
|
||
the mode.
|
||
|
||
If called from Lisp, toggle the mode if ARG is `toggle'. Enable
|
||
the mode if ARG is nil, omitted, or is a positive number.
|
||
Disable the mode if ARG is a negative number.
|
||
|
||
To check whether the minor mode is enabled in the current buffer,
|
||
evaluate `(default-value \\='async-bytecomp-package-mode)'.
|
||
|
||
The mode's hook is called both when the mode is enabled and when
|
||
it is disabled.
|
||
|
||
\(fn &optional ARG)" t nil)
|
||
|
||
(autoload 'async-byte-compile-file "async-bytecomp" "\
|
||
Byte compile Lisp code FILE asynchronously.
|
||
|
||
Same as `byte-compile-file' but asynchronous.
|
||
|
||
\(fn FILE)" t nil)
|
||
|
||
(register-definition-prefixes "async-bytecomp" '("async-"))
|
||
|
||
;;;***
|
||
|
||
;;;### (autoloads nil "dired-async" "dired-async.el" (0 0 0 0))
|
||
;;; Generated autoloads from dired-async.el
|
||
|
||
(defvar dired-async-mode nil "\
|
||
Non-nil if Dired-Async mode is enabled.
|
||
See the `dired-async-mode' command
|
||
for a description of this minor mode.
|
||
Setting this variable directly does not take effect;
|
||
either customize it (see the info node `Easy Customization')
|
||
or call the function `dired-async-mode'.")
|
||
|
||
(custom-autoload 'dired-async-mode "dired-async" nil)
|
||
|
||
(autoload 'dired-async-mode "dired-async" "\
|
||
Do dired actions asynchronously.
|
||
|
||
This is a minor mode. If called interactively, toggle the
|
||
`Dired-Async mode' mode. If the prefix argument is positive,
|
||
enable the mode, and if it is zero or negative, disable the mode.
|
||
|
||
If called from Lisp, toggle the mode if ARG is `toggle'. Enable
|
||
the mode if ARG is nil, omitted, or is a positive number.
|
||
Disable the mode if ARG is a negative number.
|
||
|
||
To check whether the minor mode is enabled in the current buffer,
|
||
evaluate `(default-value \\='dired-async-mode)'.
|
||
|
||
The mode's hook is called both when the mode is enabled and when
|
||
it is disabled.
|
||
|
||
\(fn &optional ARG)" t nil)
|
||
|
||
(autoload 'dired-async-do-copy "dired-async" "\
|
||
Run ‘dired-do-copy’ asynchronously.
|
||
|
||
\(fn &optional ARG)" t nil)
|
||
|
||
(autoload 'dired-async-do-symlink "dired-async" "\
|
||
Run ‘dired-do-symlink’ asynchronously.
|
||
|
||
\(fn &optional ARG)" t nil)
|
||
|
||
(autoload 'dired-async-do-hardlink "dired-async" "\
|
||
Run ‘dired-do-hardlink’ asynchronously.
|
||
|
||
\(fn &optional ARG)" t nil)
|
||
|
||
(autoload 'dired-async-do-rename "dired-async" "\
|
||
Run ‘dired-do-rename’ asynchronously.
|
||
|
||
\(fn &optional ARG)" t nil)
|
||
|
||
(register-definition-prefixes "dired-async" '("dired-async-"))
|
||
|
||
;;;***
|
||
|
||
;;;### (autoloads nil "smtpmail-async" "smtpmail-async.el" (0 0 0
|
||
;;;;;; 0))
|
||
;;; Generated autoloads from smtpmail-async.el
|
||
|
||
(register-definition-prefixes "smtpmail-async" '("async-smtpmail-"))
|
||
|
||
;;;***
|
||
|
||
;;;### (autoloads nil nil ("async-pkg.el") (0 0 0 0))
|
||
|
||
;;;***
|
||
|
||
;; Local Variables:
|
||
;; version-control: never
|
||
;; no-byte-compile: t
|
||
;; no-update-autoloads: t
|
||
;; coding: utf-8
|
||
;; End:
|
||
;;; async-autoloads.el ends here
|