2019-10-09 20:36:55 +02:00
;ELC
;;; Compiled
2019-10-27 19:05:34 +01:00
;;; in Emacs version 26.3
2019-10-09 20:36:55 +02:00
;;; 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 "\300\301\302\303\304\305%\210\306\307\310\311\312DD\313\304\301\314\311&
(defvar async-debug nil)
(defvar async-send-over-pipe t)
(defvar async-in-child-emacs nil)
(defvar async-callback nil)
(defvar async-callback-for-process nil)
(defvar async-callback-value nil)
(defvar async-callback-value-set nil)
(defvar async-current-process nil)
(defvar async--procvar nil)
#@136 Remove text properties in OBJECT.
Argument OBJECT may be a list or a string, if anything else it
is returned unmodified.
(fn OBJECT)
(defalias 'async--purecopy #[257 "\211;\203
#@888 Return a `setq' form that replicates part of the calling environment.
It sets the value for every variable matching INCLUDE-REGEXP and
also PREDICATE. It will not perform injection for any variable
matching EXCLUDE-REGEXP (if present) or representing a syntax-table
i.e. ending by "-syntax-table".
When NOPROPS is non nil it tries to strip out text properties of each
variable's value with `async-variables-noprops-function'.
It is intended to be used as follows:
(async-start
`(lambda ()
(require 'smtpmail)
(with-temp-buffer
(insert ,(buffer-substring-no-properties (point-min) (point-max)))
;; Pass in the variable environment for smtpmail
,(async-inject-variables "\`\(smtpmail\|\(user-\)?mail\)-")
(smtpmail-send-it)))
'ignore)
(fn INCLUDE-REGEXP &optional PREDICATE EXCLUDE-REGEXP NOPROPS)
(defalias 'async-inject-variables #[1025 "\300\301C\302\303\304\305\306\307
(defalias 'async-inject-environment 'async-inject-variables)
#@24
(fn FUNC RESULT BUF)
(defalias 'async-handle-result #[771 "
#@97 Process sentinel used to retrieve the value from the child process.
(fn PROC &optional CHANGE)
(defalias 'async-when-done #[513 "\306
#@25
(fn &optional STREAM)
(defalias 'async--receive-sexp #[256 "\302\303\304
#@13
(fn SEXP)
(defalias 'async--insert-sexp #[257 "\304\211\305\211
#@21
(fn PROCESS SEXP)
(defalias 'async--transmit-sexp #[514 "\301\302!r\211q\210\303\304\305\306\307
#@52 Called from the child Emacs process' command-line.
(defalias 'async-batch-invoke #[0 "\306
#@130 Query a FUTURE to see if it is ready.
I.e., if no blocking
would result from a call to `async-get' on that FUTURE.
(fn FUTURE)
(defalias 'async-ready #[257 "\301
#@47 Wait for FUTURE to become ready.
(fn FUTURE)
(defalias 'async-wait #[257 "\300
#@156 Get the value from process FUTURE when it is ready.
FUTURE is returned by `async-start' or `async-start-process' when
its FINISH-FUNC is nil.
(fn FUTURE)
(defalias 'async-get #[257 "\211\203
#@65 Return true of VALUE is an async.el message packet.
(fn VALUE)
(defalias 'async-message-p #[257 "\211<\205
#@76 Send the given messages to the asychronous Emacs PROCESS.
(fn &rest ARGS)
(defalias 'async-send #[128 "\302
#@59 Send the given messages to the asychronous Emacs PROCESS.
(defalias 'async-receive #[0 "\300 \207" [async--receive-sexp] 1 (#$ . 6988)])
#@376 Start the executable PROGRAM asynchronously. 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)
(defalias 'async-start-process #[899 "\303\304
#@198 The Emacs parameter to use to call emacs without config.
Can be one of "-Q" or "-q".
Default is "-Q" but it is sometimes useful to use "-q" to have a
enhanced config or some more variables loaded.
(defvar async-quiet-switch "-Q" (#$ . 7866))
#@1650 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 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)
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)
(defalias 'async-start #[513 "
#@70 Evaluate FUNC in a separate Emacs process, synchronously.
(fn FUNC)
(defalias 'async-sandbox '(macro . #[257 "\300\301
#@26
(fn FN FORMS BINDINGS)
(defalias 'async--fold-left #[771 "
#@318 Implements `let', but each binding is established asynchronously.
For example:
(async-let ((x (foo))
(y (bar)))
(message "%s %s" x y))
expands to ==>
(async-start (foo)
(lambda (x)
(async-start (bar)
(lambda (y)
(message "%s %s" x y)))))
(fn BINDINGS &rest FORMS)
(defalias 'async-let '(macro . #[385 "\300\301\302
(byte-code "\300\301\302\303#\304\305!\207" [function-put async-let lisp-indent-function 1 provide async] 4)
