HOME

Mini Shell 1.0
Current File : //usr/share/emacs/26.1/lisp/eshell/esh-cmd.elc
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; 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!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\306\307\310\311\312\313\314\315&\210\316\317\320\321\322DD\323\324\325\314\307&\210\316\326\320\321\327DD\330\324\331\314\307&\210\316\332\320\321\333DD\334\324\335\314\307&\210\316\336\320\321\337DD\340\324\335\314\307&\210\316\341\320\321\342DD\343\324\335\314\307&\210\316\344\320\321\345DD\346\324\335\314\307&\210\316\347\320\321\350DD\351\324\335\314\307&\210\316\352\320\321\353DD\354\324\335\314\307&\207" [require esh-util eldoc esh-arg esh-proc esh-ext custom-declare-group eshell-cmd nil "Executing an Eshell command is as simple as typing it in and\npressing <RET>.  There are several different kinds of commands,\nhowever." :tag "Command invocation" :group eshell custom-declare-variable eshell-prefer-lisp-functions funcall function #[0 "\300\207" [nil] 1] "If non-nil, prefer Lisp functions to external commands." :type boolean eshell-lisp-regexp #[0 "\300\207" [#1="\\([(`]\\|#'\\)"] 1 #1#] "A regexp which, if matched at beginning of an argument, means Lisp.\nSuch arguments will be passed to `read', and then evaluated." regexp eshell-pre-command-hook #[0 "\300\207" [nil] 1] "A hook run before each interactive command is invoked." hook eshell-post-command-hook #[0 "\300\207" [nil] 1] "A hook run after each interactive command is invoked." eshell-prepare-command-hook #[0 "\300\207" [nil] 1] "A set of functions called to prepare a named command.\nThe command name and its argument are in `eshell-last-command-name'\nand `eshell-last-arguments'.  The functions on this hook can change\nthe value of these symbols if necessary.\n\nTo prevent a command from executing at all, set\n`eshell-last-command-name' to nil." eshell-named-command-hook #[0 "\300\207" [nil] 1] "A set of functions called before a named command is invoked.\nEach function will be passed the command name and arguments that were\npassed to `eshell-named-command'.\n\nIf any of the functions returns a non-nil value, the named command\nwill not be invoked, and that value will be returned from\n`eshell-named-command'.\n\nIn order to substitute an alternate command form for execution, the\nhook function should throw it using the tag `eshell-replace-command'.\nFor example:\n\n  (add-hook \\='eshell-named-command-hook \\='subst-with-cd)\n  (defun subst-with-cd (command args)\n    (throw \\='eshell-replace-command\n	   (eshell-parse-command \"cd\" args)))\n\nAlthough useless, the above code will cause any non-glob, non-Lisp\ncommand (i.e., `ls' as opposed to `*ls' or `(ls)') to be replaced by a\ncall to `cd' using the arguments that were passed to the function." eshell-pre-rewrite-command-hook #[0 "\300\207" [(eshell-no-command-conversion eshell-subcommand-arg-values)] 1] "A hook run before command rewriting begins.\nThe terms of the command to be rewritten is passed as arguments, and\nmay be modified in place.  Any return value is ignored." eshell-rewrite-command-hook #[0 "\300\207" [(eshell-rewrite-for-command eshell-rewrite-while-command eshell-rewrite-if-command eshell-rewrite-sexp-command eshell-rewrite-initial-subcommand eshell-rewrite-named-command)] 1] "A set of functions used to rewrite the command argument.\nOnce parsing of a command line is completed, the next step is to\nrewrite the initial argument into something runnable.\n\nA module may wish to associate special behavior with certain argument\nsyntaxes at the beginning of a command line.  They are welcome to do\nso by adding a function to this hook.  The first function to return a\nsubstitute command form is the one used.  Each function is passed the\ncommand's full argument list, which is a list of sexps (typically\nforms or strings)."] 8)
#@152 Function run after command rewriting is finished.
Takes the (rewritten) command, modifies it as it sees fit and returns
the new result to use instead.
(defvar eshell-post-rewrite-command-function 'identity (#$ . 4119))
#@180 A hook run after command rewriting is finished.
Each function is passed the symbol containing the rewritten command,
which may be modified directly.  Any return value is ignored.
(defvar eshell-post-rewrite-command-hook nil (#$ . 4345))
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315&\210\304\316\306\307\317DD\320\321\322\312\323\314\315&	\210\304\324\306\307\325DD\326\327\330\331\332\312\333\314\315&\210\304\334\306\307\335DD\336\312\337\314\315&\210\304\340\306\307\341DD\342\312\343\314\315&\210\344\345\340\346#\207" [make-obsolete-variable eshell-post-rewrite-command-hook eshell-post-rewrite-command-function "24.4" custom-declare-variable eshell-complex-commands funcall function #[0 "\300\207" [("ls")] 1] "A list of commands names or functions, that determine complexity.\nThat is, if a command is defined by a function named eshell/NAME,\nand NAME is part of this list, it is invoked as a complex command.\nComplex commands are always correct, but run much slower.  If a\ncommand works fine without being part of this list, then it doesn't\nneed to be.\n\nIf an entry is a function, it will be called with the name, and should\nreturn non-nil if the command is complex." :type (repeat :tag "Commands" (choice (string :tag "Name") (function :tag "Predicate"))) :group eshell-cmd eshell-cmd-load-hook #[0 "\300\207" [nil] 1] "A hook that gets run when `eshell-cmd' is loaded." :version "24.1" hook eshell-debug-command #[0 "\300\207" [nil] 1] "If non-nil, enable Eshell debugging code.\nThis is slow, and only useful for debugging problems with Eshell.\nIf you change this without using customize after Eshell has loaded,\nyou must re-load `esh-cmd.el'." :initialize custom-initialize-default :set #[514 "L\210\300\301!\207" [load-library "esh-cmd"] 4 "\n\n(fn SYMBOL VALUE)"] boolean eshell-deferrable-commands #[0 "\300\207" [(eshell-named-command eshell-lisp-command eshell-process-identity)] 1] "A list of functions which might return an asynchronous process.\nIf they return a process object, execution of the calling Eshell\ncommand will wait for completion (in the background) before finishing\nthe command." (repeat function) eshell-subcommand-bindings #[0 "\300\207" [((eshell-in-subcommand-p t) (default-directory default-directory) (process-environment (eshell-copy-environment)))] 1] "A list of `let' bindings for subcommand environments." sexp put risky-local-variable t] 12)
#@148 If non-nil, ensure that a newline is emitted after a Lisp form.
This can be changed by Lisp forms that are evaluated from the Eshell
command line.
(defvar eshell-ensure-newline-p nil (#$ . 6787))
(defvar eshell-current-command nil)
(defvar eshell-command-name nil)
(defvar eshell-command-arguments nil)
#@142 Internal Eshell variable, non-nil inside a pipeline.
Has the value `first', `last' for the first/last commands in the pipeline,
otherwise t.
(defvar eshell-in-pipeline-p nil (#$ . 7097))
(defvar eshell-in-subcommand-p nil)
(defvar eshell-last-arguments nil)
(defvar eshell-last-command-name nil)
#@68 When this foreground process completes, resume command evaluation.
(defvar eshell-last-async-proc nil (#$ . 7399))
#@56 Return currently running command process, if non-Lisp.
(defalias 'eshell-interactive-process #[0 "\207" [eshell-last-async-proc] 1 (#$ . 7520)])
(put 'eshell-interactive-process 'byte-optimizer 'byte-compile-inline-expand)
#@50 Initialize the Eshell command processing module.
(defalias 'eshell-cmd-initialize #[0 "\306\300!\210\307\306\301!\210\307\306\302!\210\307\306\303!\210\307\306\304!\210\307\306\305!\210\307\310\311\312\307\313$\210\310\314\315\307\313$\210\310\316\317\307\313$\210\310\316\320\307\313$\210\321\211>\262\205P\310\322\323\307\313$\207" [eshell-current-command eshell-command-name eshell-command-arguments eshell-last-arguments eshell-last-command-name eshell-last-async-proc make-local-variable nil add-hook eshell-kill-hook eshell-resume-command t eshell-post-command-hook #[0 "\302\211\211\207" [eshell-current-command eshell-last-async-proc nil] 3] eshell-parse-argument-hook eshell-parse-subcommand-argument eshell-parse-lisp-argument eshell-cmpl pcomplete-try-first-hook eshell-complete-lisp-symbols eshell-modules-list] 5 (#$ . 7750)])
#@44 If there is a user reference, complete it.
(defalias 'eshell-complete-lisp-symbols #[0 "\304\211\305\"`{\266\202\306\307P\"\205#\211\310\225\304O\311\312\313\314	\315#\"\207" [eshell-lisp-regexp pcomplete-stub pcomplete-last-completion-raw obarray nil pcomplete-begin string-match "\\`" 0 t throw pcomplete-completions all-completions boundp] 7 (#$ . 8608)])
#@336 Parse the COMMAND, adding ARGS if given.
COMMAND can either be a string, or a cons cell demarcating a buffer
region.  TOPLEVEL, if non-nil, means that the outermost command (the
user's input command) is being parsed, and that pre and post command
hooks should be run before and after the command.

(fn COMMAND &optional ARGS TOPLEVEL)
(defalias 'eshell-parse-command #[769 "\305\306:\203\307@A\"\2029`\310\311 \310\211\310\312\313\314\315\316!\317\"\320$\216c\210\307`\"`|\210,\262)\262\"\321\322\323\324\305\300$\"\211\211\203\\\211A\203U\211\325@D\240\210\211A\262\202E\210\203s\325\326\327\330\331\326BE\332BBBD\202v\333!)\207" [eshell--sep-terms inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks nil append eshell-parse-arguments t buffer-modified-p make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 mapcar #[257 "@\203\f@\302\230\203\303!\202\304\305\303!DD\262A	\203#\207\306D\207" [eshell--sep-terms eshell-in-pipeline-p ";" eshell-parse-pipeline eshell-do-subjob list eshell-trap-errors] 5 "\n\n(fn CMD)"] eshell-separate-commands "[&;]" eshell-commands progn (run-hooks 'eshell-pre-command-hook) catch 'top-level ((run-hooks 'eshell-post-command-hook)) macroexp-progn] 13 (#$ . 8982)])
#@70 Output a debugging message to `*eshell last cmd*'.

(fn TAG SUBFORM)
(defalias 'eshell-debug-command #[514 "\301\302!\303!rq\210\204\304 \202(\305\306\203%\306\303!P\202&\307\261)\207" [eshell-current-command get-buffer-create "*eshell last cmd*" eshell-stringify erase-buffer "\n\f\n" "\n\n" ""] 11 (#$ . 10309)])
#@59 Display parsed arguments in the debug buffer.

(fn TERMS)
(defalias 'eshell-debug-show-parsed-args #[257 "\301\203\n\300\302\"\210\207" [eshell-debug-command nil "parsed arguments"] 5 (#$ . 10645)])
#@49 Don't convert the command argument.

(fn TERMS)
(defalias 'eshell-no-command-conversion #[257 "\300@<\203@@\301=\203\211@A@\240\210\207" [nil eshell-convert] 4 (#$ . 10853)])
#@86 Convert subcommand arguments {x} to ${x}, in order to take their values.

(fn TERMS)
(defalias 'eshell-subcommand-arg-values #[257 "\211A\262\211\205&\211@<\203\211@@\300=\203\211\301\302@DD\240\210\211A\262\202\207" [eshell-as-subcommand eshell-convert eshell-command-to-value] 5 (#$ . 11041)])
#@68 Rewrite a sexp in initial position, such as `(+ 1 2)'.

(fn TERMS)
(defalias 'eshell-rewrite-sexp-command #[257 "\211@<\205\211@@\300=\205\211@A@\207" [eshell-command-to-value] 3 (#$ . 11353)])
#@74 Rewrite a subcommand in initial position, such as `{+ 1 2}'.

(fn TERMS)
(defalias 'eshell-rewrite-initial-subcommand #[257 "\211@<\205\211@@\300=\205\211@\207" [eshell-as-subcommand] 3 (#$ . 11557)])
#@82 If no other rewriting rule transforms TERMS, assume a named command.

(fn TERMS)
(defalias 'eshell-rewrite-named-command #[257 "\203\301\202	\302@A\211\203\303ABE\202D\207" [eshell-in-pipeline-p eshell-named-command* eshell-named-command list] 8 (#$ . 11768)])
#@383 Change ARG so it can be invoked from a structured command.

SHARE-OUTPUT, if non-nil, means this invocation should share the
current output stream, which is separately redirectable.  SILENT
means the user and/or any redirections shouldn't see any output
from this command.  If both SHARE-OUTPUT and SILENT are non-nil,
the second is ignored.

(fn ARG &optional SHARE-OUTPUT SILENT)
(defalias 'eshell-invokify-arg #[769 "<\203(@\300=\203(A@@\301=\203(\203A@A@\207\302A@A@E\207\207" [eshell-convert eshell-command-to-value eshell-commands] 6 (#$ . 12052)])
(put 'eshell-invokify-arg 'byte-optimizer 'byte-compile-inline-expand)
#@71 List of locally bound vars that should take precedence over env-vars.
(defvar eshell--local-vars nil (#$ . 12697))
#@266 Rewrite a `for' command into its equivalent Eshell command form.
Because the implementation of `for' relies upon conditional evaluation
of its argument (i.e., use of a Lisp special form), it must be
implemented via rewriting, rather than as a function.

(fn TERMS)
(defalias 'eshell-rewrite-for-command #[257 "\211@\300\232\205\211\3018\302\232\205\211\303!@\303\301\"\304\241\210\305\306\307\310\311\312AAA\"BDD\313B\314\315\305\316A@!\317B\320\321\322\316A@!D\323BBDD\324\325\304<\203z@\326=\203zA@@\327=\203z\203mA@A@\266\203\202}\330A@A@E\266\203\202}\266\203DE\331BBB\332BBB\262\207" ["for" 2 "in" last nil let for-items copy-tree append mapcar #[257 "\211<\203\207\300D\207" [list] 3 "\n\n(fn ELEM)"] ((eshell-command-body '(nil)) (eshell-test-body '(nil))) while (car for-items) intern ((car for-items)) eshell--local-vars cons quote (eshell--local-vars) eshell-protect t eshell-convert eshell-command-to-value eshell-commands ((setcar for-items (cadr for-items)) (setcdr for-items (cddr for-items))) ((eshell-close-handles eshell-last-command-status (list 'quote eshell-last-command-result)))] 15 (#$ . 12819)])
#@259 With TERMS, KEYWORD, and two NAMES, structure a basic command.
The first of NAMES should be the positive form, and the second the
negative.  It's not likely that users should ever need to call this
function.

(fn FUNC NAMES KEYWORD TEST BODY &optional ELSE)
(defalias 'eshell-structure-basic-command #[1541 "@\300=\204\301\302BB\262\303=\204!<\203&A@\230\203&\304D\262\305\306F\307BBB\207" [eshell-convert progn ((eshell-exit-success-p)) nil not let ((eshell-command-body '(nil)) (eshell-test-body '(nil))) ((eshell-close-handles eshell-last-command-status (list 'quote eshell-last-command-result)))] 12 (#$ . 13977)])
#@270 Rewrite a `while' command into its equivalent Eshell command form.
Because the implementation of `while' relies upon conditional
evaluation of its argument (i.e., use of a Lisp special form), it
must be implemented via rewriting, rather than as a function.

(fn TERMS)
(defalias 'eshell-rewrite-while-command #[257 "\211@;\205\207\211@\300\235\205\207\301\302\303@A@\304\305<\203G@\306=\203GA@@\307=\203G\203:A@A@\266\203\202J\310A@A@E\266\203\202J\266\203\311\312!@\305\304<\203\202@\306=\203\202A@@\307=\203\202\203uA@A@\266\203\202\205\310A@A@E\266\203\202\205\266\203D%\207" [("while" "until") eshell-structure-basic-command while ("while" "until") nil t eshell-convert eshell-command-to-value eshell-commands eshell-protect last] 13 (#$ . 14622)])
#@265 Rewrite an `if' command into its equivalent Eshell command form.
Because the implementation of `if' relies upon conditional
evaluation of its argument (i.e., use of a Lisp special form), it
must be implemented via rewriting, rather than as a function.

(fn TERMS)
(defalias 'eshell-rewrite-if-command #[257 "\211@;\205\330\211@\300\235\205\330\301\302\303@A@\304\305<\203G@\306=\203GA@@\307=\203G\203:A@A@\266\203\202J\310A@A@E\266\203\202J\266\203\311\312\211G\313U\205V\314\"@\305\304<\203\212@\306=\203\212A@@\307=\203\212\203}A@A@\266\203\202\215\310A@A@E\266\203\202\215\266\203DG\313U\203\325\311\312!@\304\211<\203\316@\306=\203\316A@@\307=\203\316\203\301A@A@\266\203\202\321\310A@A@E\266\203\202\321\266\203D\202\326\305&\207" [("if" "unless") eshell-structure-basic-command if ("if" "unless") nil t eshell-convert eshell-command-to-value eshell-commands eshell-protect last 4 2] 14 (#$ . 15416)])
#@82 Return non-nil if the last command was successful.
This means an exit code of 0.
(defalias 'eshell-exit-success-p #[0 "\301U\207" [eshell-last-command-status 0] 2 (#$ . 16385)])
#@77 Parse a pipeline from TERMS, return the appropriate Lisp forms.

(fn TERMS)
(defalias 'eshell-parse-pipeline #[257 "\304\305\306\304\300$\211\307C\304\203g@\305\310\"\211\211\203A\211@\311\312\"\210\313\314\"\262\211\311\315\301\"\210	\262)\n!\240\266\211A\262\202G\316X\203N@\202[\203V\317\320!\210\321\322DDC\244\266A\262\210\202\fA\262\237\262@\262A\262\237\203\244@\204\207\317\323!\210\324\325@\326\230\327\330@D\330D%\262A\262A\202z)\207" [eshell--sep-terms eshell--cmd eshell-post-rewrite-command-function eshell-in-pipeline-p nil eshell-separate-commands "\\(&&\\|||\\)" t "|" run-hook-with-args eshell-pre-rewrite-command-hook run-hook-with-args-until-success eshell-rewrite-command-hook eshell-post-rewrite-command-hook 1 cl--assertion-failed (not eshell-in-pipeline-p) eshell-execute-pipeline quote (car eshell--sep-terms) eshell-structure-basic-command if "&&" "if" eshell-protect] 12 (#$ . 16570)])
#@54 Parse a subcommand argument of the form `{command}'.
(defalias 'eshell-parse-subcommand-argument #[0 "?\205T	?\205T\303f\304=\205Td`TU\204!`Tf\305=?\205T\306\304\305\"\211\2040\307\310\304\"\202R\211T\211\2067`\211dU\206A\211f\n>\266\202\205R\311\312`TB!DTb\210\262\207" [eshell-current-argument eshell-current-quoted eshell-delimiter-argument-list nil 123 125 eshell-find-delimiter throw eshell-incomplete eshell-as-subcommand eshell-parse-command] 5 (#$ . 17543)])
#@60 Parse a Lisp expression which is specified as an argument.
(defalias 'eshell-parse-lisp-argument #[0 "?\205F	?\205F\304\n!\205F`\3051\306p!0\202!\210\307\310\311\"\312\211\206'`\211dU\2061\211f>\266\202\203@\313\314\315DDD\202D\312b\210\266\202\207" [eshell-current-argument eshell-current-quoted eshell-lisp-regexp eshell-delimiter-argument-list looking-at (end-of-file) read throw eshell-incomplete 40 nil eshell-command-to-value eshell-lisp-command quote] 6 (#$ . 18030)])
#@303 Separate TERMS using SEPARATOR.
If REVERSED is non-nil, the list of separated term groups will be
returned in reverse order.  If LAST-TERMS-SYM is a symbol, its value
will be set to a list of all the separator operators found (or (nil)
if none).

(fn TERMS SEPARATOR &optional REVERSED LAST-TERMS-SYM)
(defalias 'eshell-separate-commands #[1026 "\300C\300C\301\203N@:\203?@@\302=\203?\303\304\305Q@A@\"\203?@A@C\244\210AB\262\300C\262\202F@C\244\210A\262\202G\306V\203[AB\262\203n\203j\307A!L\210\211\202y\203wAL\210\211\237\207" [t nil eshell-operator string-match "^" "$" 1 reverse] 11 (#$ . 18527)])
#@145 Evaluate a command OBJECT as a subjob.
We indicate that the process was run in the background by returning it
ensconced in a list.

(fn OBJECT)
(defalias 'eshell-do-subjob '(macro . #[257 "\300\301E\207" [let ((eshell-current-subjob-p t))] 4 (#$ . 19183)]))
#@97 Place a valid set of handles, and context, around command OBJECT.

(fn OBJECT &optional SILENT)
(defalias 'eshell-commands '(macro . #[513 "\300\301\302?\303BBD\304BE\207" [let eshell-current-handles eshell-create-handles ('append) (eshell-current-subjob-p)] 7 (#$ . 19448)]))
#@394 Trap any errors that occur, so they are not entirely fatal.
Also, the variable `eshell-this-command-hook' is available for the
duration of OBJECT's evaluation.  Note that functions should be added
to this hook using `nconc', and *not* `add-hook'.

Someday, when Scheme will become the dominant Emacs language, all of
this grossness will be made to disappear by using `call/cc'...

(fn OBJECT)
(defalias 'eshell-trap-errors '(macro . #[257 "\300\301\302\303\304\305BB\306BBBE\207" [let ((eshell-this-command-hook '(ignore))) eshell-condition-case err prog1 ((run-hooks 'eshell-this-command-hook)) ((error (run-hooks 'eshell-this-command-hook) (eshell-errorn (error-message-string err)) (eshell-close-handles 1)))] 8 (#$ . 19734)]))
#@80 Duplicate current I/O handles, so OBJECT works with its own copy.

(fn OBJECT)
(defalias 'eshell-copy-handles '(macro . #[257 "\300\301E\207" [let ((eshell-current-handles (eshell-create-handles (car (aref eshell-current-handles eshell-output-handle)) nil (car (aref eshell-current-handles eshell-error-handle)) nil)))] 4 (#$ . 20472)]))
#@84 Protect I/O handles, so they aren't get closed after eval'ing OBJECT.

(fn OBJECT)
(defalias 'eshell-protect '(macro . #[257 "\300\301E\207" [progn (eshell-protect-handles eshell-current-handles)] 4 (#$ . 20817)]))
#@161 Execute the commands in PIPELINE, connecting each to one another.
This macro calls itself recursively, with NOTFIRST non-nil.

(fn PIPELINE &optional NOTFIRST)
(defalias 'eshell-do-pipelines '(macro . #[513 "A@\211\262\205n\303\304A\205,\305\306\307\310AD\311BBDC\312\313BB\312	\314BB\315BBBB@\211@\316>\203;\317!@\262\211@\n>\205N\320\321\322@!\323P!\240\210\262\305\324\204[\325\202fA\203e\326\202f\327DC@EFD\207" [eshell-output-handle eshell-error-handle eshell-deferrable-commands eshell-copy-handles progn let nextproc eshell-do-pipelines quote (t) eshell-set-output-handle ('append nextproc) ('append nextproc) ((setq tailproc (or tailproc nextproc))) (let progn) last nil intern-soft symbol-name "*" eshell-in-pipeline-p 'first t 'last] 11 (#$ . 21040)]))
#@219 Execute the commands in PIPELINE in sequence synchronously.
Output of each command is passed as input to the next one in the pipeline.
This is used on systems where async subprocesses are not supported.

(fn PIPELINE)
(defalias 'eshell-do-pipelines-synchronously '(macro . #[257 "\211A@\211\262\205g\303A\205 \304\305\306 DC\307\310BB\307	\311BBF@\211@\312>\203/\313!@\262\211@\n>\205B\314\315\316@!\317P!\240\210\262A?\205K\320\304\321@DC\322A\205`\323\324	ADD\325BBBB\257\207" [eshell-output-handle eshell-error-handle eshell-deferrable-commands progn let output-marker point-marker eshell-set-output-handle ('append output-marker) ('append output-marker) (let progn) last nil intern-soft symbol-name "*" (progn (setq eshell-current-handles tail-handles) (setq eshell-in-pipeline-p nil)) result (setq tailproc (or result tailproc)) eshell-do-pipelines-synchronously quote (result)] 11 (#$ . 21836)]))
(defalias 'eshell-process-identity 'identity)
#@82 Execute the commands in PIPELINE, connecting each to one another.

(fn PIPELINE)
(defalias 'eshell-execute-pipeline '(macro . #[257 "\302\303\304\305\306!\203\307D\202+\302\310\311\312\313\314ED\315\312\313\314	ED\316BBBBDC\317DE\320BBE\207" [eshell-output-handle eshell-error-handle let ((eshell-in-pipeline-p t) tailproc) progn fboundp make-process eshell-do-pipelines tail-handles eshell-create-handles car aref eshell-current-handles nil (nil) eshell-do-pipelines-synchronously ((eshell-process-identity tailproc))] 13 (#$ . 22813)]))
#@197 Execute COMMAND using a temp buffer.
This is used so that certain Lisp commands, such as `cd', when
executed in a subshell, do not disturb the environment of the main
Eshell buffer.

(fn COMMAND)
(defalias 'eshell-as-subcommand '(macro . #[257 "\301E\207" [eshell-subcommand-bindings let] 4 (#$ . 23366)]))
#@106 Run a subcommand prepared by `eshell-command-to-value'.
This avoids the need to use `let*'.

(fn OBJECT)
(defalias 'eshell-do-command-to-value '(macro . #[257 "\300\301\302\303BBE\207" [let ((eshell-current-handles (eshell-create-handles value 'overwrite))) progn ((symbol-value value))] 6 (#$ . 23682)]))
#@131 Run OBJECT synchronously, returning its result as a string.
Returns a string comprising the output from the command.

(fn OBJECT)
(defalias 'eshell-command-to-value '(macro . #[257 "\300\301\302DE\207" [let ((value (make-symbol "eshell-temp"))) eshell-do-command-to-value] 5 (#$ . 23996)]))
#@66 A command for toggling certain debug variables.

(fn &rest ARGS)
(defalias 'eshell/eshell-debug #[128 "\303\204\203\304\305	\"\266\n\203M\306\305	\"\266\207@\307\235\203+\310\305	\"\266\207\203M@\311\230\203<?\202F@\312\230\203F\n?A\262\202+\207" [eshell-handle-errors eshell-output-handle eshell-debug-command nil "errors\n" eshell-output-object "commands\n" ("-h" "--help") "usage: eshell-debug [kinds]\n\nThis command is used to aid in debugging problems related to Eshell\nitself.  It is not useful for anything else.  The recognized `kinds'\nat the moment are:\n\n  errors       stops Eshell from trapping errors\n  commands     shows command execution progress in `*eshell last cmd*'\n" "errors" "commands"] 6 (#$ . 24294)])
#@37 Completion for the `debug' command.
(defalias 'pcomplete/eshell-mode/eshell-debug #[0 "\300\301\302\211\211$\205\f\202\207" [pcomplete--here #[0 "\300\207" [("errors" "commands")] 1] nil] 5 (#$ . 25059)])
#@16 

(fn COMMAND)
(defalias 'eshell-invoke-directly #[257 "\301\211A@88A@\302@\303=\203!A@@\304=\203!A@A@\262\211\205a\211;\205a\211\235?\205a\3052W\211\203T\211@\306!\203M\211!\203M\307\305\302\"\210A\266\202\2026\210\3100\205a\311\312\313P!!\207" [eshell-complex-commands 2 nil eshell-trap-errors eshell-named-command simple functionp throw t fboundp intern-soft "eshell/"] 8 (#$ . 25273)])
#@71 Evaluate the given COMMAND iteratively.

(fn COMMAND &optional INPUT)
(defalias 'eshell-eval-command #[513 "\203\302A!\303\304\205\305\306PD\307\310\311DD\257C\241\207	\2033r\312\313!q\210\314 \210\315\316\261\210)\3172<\320 0\211<\203E\211@\262\211\205T\211\321=?\205T\322\323\"\207" [eshell-current-command eshell-debug-command last let ((here (and (eobp) (point)))) insert-and-inherit "\n" (if here (eshell-update-markers here)) eshell-do-eval quote get-buffer-create "*eshell last cmd*" erase-buffer "command: \"" "\"\n" eshell-incomplete eshell-resume-eval t error "Unmatched delimiter: %c"] 10 (#$ . 25691)])
#@67 Resume the current command when a process ends.

(fn PROC STATUS)
(defalias 'eshell-resume-command #[514 "\205 \211;?\206\211\302\230\206\303\"?\205 	=\205 \304 \207" [eshell-reset-signals eshell-last-async-proc "stopped" string-match eshell-resume-eval] 5 (#$ . 26334)])
#@62 Destructively evaluate a form which may need to be deferred.
(defalias 'eshell-resume-eval #[0 "\30212\303	\2050\303\3042\303\305	!\2620\211\306\307!\205 \307!\262\203+\303\202.A@\266\2020\207\310\311!!\207" [eshell-last-async-proc eshell-current-command (debug error) nil eshell-defer eshell-do-eval fboundp processp error error-message-string] 5 (#$ . 26623)])
#@85 Manipulate a COMMAND form, with TAG as a debug identifier.

(fn TAG &rest COMMANDS)
(defalias 'eshell-manipulate '(macro . #[385 "\301\300!\203\n\204\302B\207\302\300\303!\304BB\305\300\306\303!P\307BBC\"BB\207" [eshell-debug-command boundp progn eval (form) append "done " (form)] 10 (#$ . 27007)]))
(byte-code "\300\301\302\303#\300\207" [function-put eshell-manipulate lisp-indent-function 1] 4)
#@216 Evaluate form, simplifying it as we go.
Unless SYNCHRONOUS-P is non-nil, throws `eshell-defer' if it needs to
be finished later after the completion of an asynchronous subprocess.

(fn FORM &optional SYNCHRONOUS-P)
(defalias 'eshell-do-eval #[513 "<\204\304\305!D\207@\306>\203\207@\307=\203\"A@A@\262\310@!\2039\311\312!!@\240\210A\241\266A@\313=\203\242@\203\\\203O\314\315!\210\307@!\210\316\240\210	\316\240\210	@\204h	\311@!\240\210\307	@!A@\203\234AA\203\201\317\311A!B\202\206\311A@!\240\210\307@\"\210\316\240\210	\311@!\240\210\202h\316\240\202;@\320=\203\362@\203\276\203\266\314\321!\210\307@!\210\202\350	@\204\312	\311@!\240\210\311\307	@!A@\203\333A@\202\337AA@!\240\210\307@\"\210\316\240\210	\316\240\202;@\322=\203	\211A\307A@\"\240\210\305!\202;@\323=\203 \211A\307A@\"\240\210\305!\202;@\324>\203\202@\325=\203_\211A@@\307=\204_\211@\211\203^\211@\211<\203W\211A@\304=\204W\211\307A@\"C\241\210A\266\202\2029\210@\326=\204j\211A\262\211@@\307=\204|\211\307\304@DE\240\210\305!\202;@\327=\203\245\211AA\203\223\330\331!\210\211A\307A@\"\240\210\304\305!D\202;\211\203\303@\332>\204\303\211\203\303\211\307@\"\240\210\211A\262\202\260@\317=\203\321\333!@\202;@\334=\203\336A@\202;\316\3352\352\316\305!\2620\211\203\377@\240\210A\241\210\307\"\2029@\n>\2036\2046\2036\336\337!\205\337!\262\2036\203'\340!\2029\341\240\210\316\241\210\342\343\"\2029\304D\266\202\207" [eshell-command-body eshell-test-body eshell-deferrable-commands eshell-current-subjob-p quote eval 'function eshell-do-eval macrop eshell-copy-tree macroexpand while cl--assertion-failed (not synchronous-p) nil progn if (not synchronous-p) setcar setcdr (let catch condition-case unwind-protect) let unwind-protect setq error "Unsupported form (setq X1 E1 X2 E2..)" (run-hooks) last prog1 eshell-replace-command fboundp processp eshell/wait ignore throw eshell-defer] 9 (#$ . 27422)])
#@74 Identify the COMMAND, and where it is located.

(fn COMMAND &rest NAMES)
(defalias 'eshell/which #[385 "B\211\205\275\211@\306\211\211\307H=\203\310\306O\262\311\262\211\204=\312\211	>\262\203=\313K!\211\262\203=\314A@\315R\262\204\221\316!\211\206K\317!\204Y\211\203\211\320!\203\211\n\204a\204\211\321\322\323!!\324\216\325\326!\210\327\330\331\"!\210\332!\210)rq\210\333 +\206\215\202\215\334!\266\202\262\204\245\330\335\336\337!#\340\f\"\266\202\264\211\340
\"\266\341\340
\"\266\266A\266\202\202\207" [eshell-explicit-command-char eshell-modules-list eshell-prefer-lisp-functions standard-output eshell-error-handle eshell-output-handle nil 0 1 t eshell-alias eshell-lookup-alias " is an alias, defined as \"" "\"" eshell-find-alias-function intern-soft fboundp get-buffer-create generate-new-buffer-name " *string-output*" #[0 "\301!\207" [standard-output kill-buffer] 2] require help-fns princ format "%s is " help-fns-function-description-header buffer-string eshell-search-path "which: no %s in (%s)\n" getenv "PATH" eshell-output-object "\n"] 13 (#$ . 29450)])
(put 'eshell/which 'eshell-no-numeric-conversions t)
#@145 Insert output from a plain COMMAND, using ARGS.
COMMAND may result in an alias being executed, or a plain command.

(fn COMMAND &optional ARGS)
(defalias 'eshell-named-command #[513 "\211\302!\303\304!\210	;\204\305\306!\210	\205#\307\310	#\206#\311	\"\207" [eshell-last-arguments eshell-last-command-name eshell-stringify run-hook-with-args eshell-prepare-command-hook cl--assertion-failed (stringp eshell-last-command-name) run-hook-with-args-until-success eshell-named-command-hook eshell-plain-command] 6 (#$ . 30642)])
(defalias 'eshell-named-command* 'eshell-named-command)
#@66 Check whether a function called `eshell/NAME' exists.

(fn NAME)
(defalias 'eshell-find-alias-function #[257 "\301\302P!\303\304\"\211\203F\305!\211\262\203F\306\307\"\203F\310\311\312\313\"P!\314!\205A\211\203@\211\211>\262\204@\211\315\316!>\205A\262\202M\314!\205M\207" [eshell-modules-list intern-soft "eshell/" symbol-file defun file-name-base string-match "\\`\\(em\\|esh\\)-\\([[:alnum:]]+\\)\\'" intern "eshell-" match-string 2 functionp eshell-subgroups eshell] 8 (#$ . 31237)])
#@161 Insert output from a plain COMMAND, using ARGS.
COMMAND may result in either a Lisp function being executed by name,
or an external command.

(fn COMMAND ARGS)
(defalias 'eshell-plain-command #[514 "\301!\211\206\n\302!\211\203)\303!\203)\204\"\204\"\304!\204)\305\"\202-\306\"\207" [eshell-prefer-lisp-functions eshell-find-alias-function intern-soft fboundp eshell-search-path eshell-lisp-command eshell-external-command] 7 (#$ . 31754)])
#@283 Execute a lisp FUNC-OR-FORM, maybe passing ARGS.
PRINTER and ERRPRINT are functions to use for printing regular
messages, and errors.  FORM-P should be non-nil if FUNC-OR-FORM
represent a lisp form; ARGS will be ignored in that case.

(fn PRINTER ERRPRINT FUNC-OR-FORM ARGS FORM-P)
(defalias 'eshell-exec-lisp #[1285 "\3011!r\211\203\302!\202\303\")\211\203!\210\211\2620\207\304\305!\204@\306\307\"\203@\310\311!\203@\311!\312\313\"\266\202!\266\314\207" [eshell-last-command-status (debug error) eval apply 1 error-message-string string-match "^Wrong number of arguments" fboundp eldoc-get-fnsym-args-string format "usage: %s" nil] 11 (#$ . 32219)])
#@184 Call FUNC, with ARGS, trapping errors and return them as output.
PRINTER and ERRPRINT are functions to use for printing regular
messages, and errors.

(fn PRINTER ERRPRINT FUNC ARGS)
(defalias 'eshell-apply* #[1028 "\300\301%\207" [eshell-exec-lisp nil] 10 (#$ . 32903)])
(put 'eshell-apply* 'byte-optimizer 'byte-compile-inline-expand)
#@105 Call FUNC, with ARGS, trapping errors and return them as output.

(fn PRINTER ERRPRINT FUNC &rest ARGS)
(defalias 'eshell-funcall* #[899 "\300\301%\207" [eshell-exec-lisp nil] 14 (#$ . 33251)])
(put 'eshell-funcall* 'byte-optimizer 'byte-compile-inline-expand)
#@80 Evaluate FORM, trapping errors and returning them.

(fn PRINTER ERRPRINT FORM)
(defalias 'eshell-eval* #[771 "\300\301\302%\207" [eshell-exec-lisp nil t] 9 (#$ . 33526)])
(put 'eshell-eval* 'byte-optimizer 'byte-compile-inline-expand)
#@167 Call FUNC, with ARGS, trapping errors and return them as output.
PRINTER and ERRPRINT are functions to use for printing regular
messages, and errors.

(fn FUNC ARGS)
(defalias 'eshell-apply #[514 "\300\301\302\303%\207" [eshell-print eshell-error eshell-exec-lisp nil] 12 (#$ . 33771)])
(put 'eshell-apply 'byte-optimizer 'byte-compile-inline-expand)
#@88 Call FUNC, with ARGS, trapping errors and return them as output.

(fn FUNC &rest ARGS)
(defalias 'eshell-funcall #[385 "\300\301\302\303%\207" [eshell-print eshell-error eshell-exec-lisp nil] 14 (#$ . 34134)])
(put 'eshell-funcall 'byte-optimizer 'byte-compile-inline-expand)
#@63 Evaluate FORM, trapping errors and returning them.

(fn FORM)
(defalias 'eshell-eval #[257 "\300\301\302\303\304%\207" [eshell-print eshell-error eshell-exec-lisp nil t] 10 (#$ . 34424)])
(put 'eshell-eval 'byte-optimizer 'byte-compile-inline-expand)
#@167 Call FUNC, with ARGS, trapping errors and return them as output.
PRINTER and ERRPRINT are functions to use for printing regular
messages, and errors.

(fn FUNC ARGS)
(defalias 'eshell-applyn #[514 "\300\301\302\303%\207" [eshell-printn eshell-errorn eshell-exec-lisp nil] 12 (#$ . 34686)])
(put 'eshell-applyn 'byte-optimizer 'byte-compile-inline-expand)
#@88 Call FUNC, with ARGS, trapping errors and return them as output.

(fn FUNC &rest ARGS)
(defalias 'eshell-funcalln #[385 "\300\301\302\303%\207" [eshell-printn eshell-errorn eshell-exec-lisp nil] 14 (#$ . 35053)])
(put 'eshell-funcalln 'byte-optimizer 'byte-compile-inline-expand)
#@63 Evaluate FORM, trapping errors and returning them.

(fn FORM)
(defalias 'eshell-evaln #[257 "\300\301\302\303\304%\207" [eshell-printn eshell-errorn eshell-exec-lisp nil t] 10 (#$ . 35347)])
(put 'eshell-evaln 'byte-optimizer 'byte-compile-inline-expand)
#@75 Insert Lisp OBJECT, using ARGS if a function.

(fn OBJECT &optional ARGS)
(defalias 'eshell-lisp-command #[513 "\3052\210\306 \307!\203Y\211\310\311!\312Q\313N\204G\211\203G\211@\211;\203?\211G\314V\203?\315\314G\316\317%\204?\320!\240\210\210\211A\262\202	\321\322\323\324%\266\206\202j\211\325\321\322\323\324\317%\266\204\203~\212b\210n)\204~\326\327\f\"\266\330\314\331D\")\2620\207" [eshell-ensure-newline-p eshell-last-arguments eshell-last-command-name eshell-last-output-end eshell-output-handle eshell-external eshell-interactive-output-p functionp "#<function " symbol-name ">" eshell-no-numeric-conversions 0 text-property-not-all number t string-to-number eshell-print eshell-error eshell-exec-lisp nil "#<Lisp object>" "\n" eshell-output-object eshell-close-handles quote] 14 (#$ . 35612)])
(byte-code "\300\301\302\"\210\303\304!\207" [defalias eshell-lisp-command* eshell-lisp-command provide esh-cmd] 3)