;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:10:53 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/eshell/esh-cmd.el
;;; in Emacs version 24.3.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\310\320\321\322\314\307&\210\316\323\324\325\321\326\314\307&\210\316\327\310\330\321\331\314\307&\210\316\332\310\333\321\331\314\307&\210\316\334\310\335\321\331\314\307&\210\316\336\310\337\321\331\314\307&\210\316\340\341\342\321\331\314\307&\210\316\343\344\345\321\331\314\307&\210\316\346\310\347\321\331\314\307&\210\316\350\351\352\321\353\314\307&\210\316\354\310\355\356\357\321\331\314\307&	\210\316\360\310\361\362\363\364\365\321\322\314\307&\210\316\366\367\370\321\371\314\307&\210\316\372\373\374\321\375\314\307&\210\376\377\372\201@#\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 "If non-nil, prefer Lisp functions to external commands." :type boolean eshell-lisp-regexp "\\([(`]\\|#'\\)" "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 "A hook run before each interactive command is invoked." hook eshell-post-command-hook "A hook run after each interactive command is invoked." eshell-prepare-command-hook "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 "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 '(eshell-no-command-conversion eshell-subcommand-arg-values) "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 '(eshell-rewrite-for-command eshell-rewrite-while-command eshell-rewrite-if-command eshell-rewrite-sexp-command eshell-rewrite-initial-subcommand eshell-rewrite-named-command) "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)." eshell-post-rewrite-command-hook "A hook run after command rewriting is finished.\nEach function is passed the symbol containing the rewritten command,\nwhich may be modified directly.  Any return value is ignored." eshell-complex-commands '("ls") "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." (repeat :tag "Commands" (choice (string :tag "Name") (function :tag "Predicate"))) eshell-cmd-load-hook "A hook that gets run when `eshell-cmd' is loaded." :version "24.1" eshell-debug-command "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 #[(symbol value) "	L\210\302\303!\207" [symbol value load-library "esh-cmd"] 2] eshell-deferrable-commands '(eshell-named-command eshell-lisp-command eshell-process-identity) "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 '((eshell-in-subcommand-p t) (default-directory default-directory) (process-environment (eshell-copy-environment))) "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 (#$ . 6058))
(defvar eshell-current-command nil)
(defvar eshell-command-name nil)
(defvar eshell-command-arguments nil)
#@140 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 (#$ . 6368))
(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 (#$ . 6668))
#@56 Return currently running command process, if non-Lisp.
(defalias 'eshell-interactive-process #[nil "\207" [eshell-last-async-proc] 1 (#$ . 6789)])
(put 'eshell-interactive-process 'byte-optimizer 'byte-compile-inline-expand)
#@50 Initialize the Eshell command processing module.
(defalias 'eshell-cmd-initialize #[nil "\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>)\205Q\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 #[nil "\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 module eshell-modules-list] 6 (#$ . 7021)])
#@44 If there is a user reference, complete it.
(defalias 'eshell-complete-lisp-symbols #[nil "\305\211\306\"`{\266\202\307\310	P\"\205$\311\225\305O\312\313\314\315\n\f\316#\")\207" [arg eshell-lisp-regexp pcomplete-stub pcomplete-last-completion-raw obarray nil pcomplete-begin string-match "\\`" 0 t throw pcomplete-completions all-completions boundp] 6 (#$ . 7888)])
#@299 Parse the COMMAND, adding ARGS if given.
COMMAND can either be a string, or a cons cell demarcating a buffer
region.  TOP-LEVEL, 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.
(defalias 'eshell-parse-command #[(command &optional args top-level) "\306\307	:\203\310	@	A\"\2028`\311\312 \311\211\311\306\211\306\313\216	c\210\310`\"`|\210.\n\"\314\315\316\317\306\300$\"\211\211\203hA\203_\320@D\240\210A\211\204P)\321\307\205q\322\204{\202\204\323\324\321BE\325B\"B\203\224\320D\202\226+\207" [sep-terms command inhibit-point-motion-hooks here #1=#:modified buffer-undo-list nil append eshell-parse-arguments t buffer-modified-p ((byte-code "\204\301\302!\210\302\207" [#1# restore-buffer-modified-p nil] 2)) mapcar #[(cmd) "@\203\f@\303\230\203\304	@?\"\202\305\306\304	!DDA\n\203&	\207\307	D\207" [sep-terms cmd eshell-in-pipeline-p ";" eshell-parse-pipeline eshell-do-subjob list eshell-trap-errors] 4] eshell-separate-commands "[&;]" eshell-commands progn ((run-hooks 'eshell-pre-command-hook)) catch 'top-level ((run-hooks 'eshell-post-command-hook)) inhibit-read-only inhibit-modification-hooks deactivate-mark buffer-file-name buffer-file-truename args terms commands cmd top-level] 8 (#$ . 8269)])
#@52 Output a debugging message to '*eshell last cmd*'.
(defalias 'eshell-debug-command #[(tag subform) "\305\306!\307!r\nq\210\204\310 \202(\311\312	\f\203%\312\307\f!P\202&\313\261+\207" [eshell-current-command text buf tag subform get-buffer-create "*eshell last cmd*" eshell-stringify erase-buffer "\n\f\n" "\n\n" ""] 7 (#$ . 9681)])
#@47 Display parsed arguments in the debug buffer.
(defalias 'eshell-debug-show-parsed-args #[(terms) "\302\203\n\300\303	\"\210\207" [eshell-debug-command terms nil "parsed arguments"] 4 (#$ . 10031)])
#@37 Don't convert the command argument.
(defalias 'eshell-no-command-conversion #[(terms) "\302@<\203\211@@)\303=\203\211@\211A@)\240\210\207" [terms x nil eshell-convert] 4 (#$ . 10237)])
#@74 Convert subcommand arguments {x} to ${x}, in order to take their values.
(defalias 'eshell-subcommand-arg-values #[(terms) "A\211\205)@<\203!\211@@)\302=\203!\303\304@DD\240\210A\211\204\305\207" [terms x eshell-as-subcommand eshell-convert eshell-command-to-value nil] 5 (#$ . 10437)])
#@56 Rewrite a sexp in initial position, such as '(+ 1 2)'.
(defalias 'eshell-rewrite-sexp-command #[(terms) "@<\205\211@@)\302=\205\211@A)@\207" [terms x eshell-command-to-value] 3 (#$ . 10744)])
#@62 Rewrite a subcommand in initial position, such as '{+ 1 2}'.
(defalias 'eshell-rewrite-initial-subcommand #[(terms) "@<\205\211@@)\302=\205@\207" [terms x eshell-as-subcommand] 3 (#$ . 10951)])
#@70 If no other rewriting rule transforms TERMS, assume a named command.
(defalias 'eshell-rewrite-named-command #[(terms) "\203\305\202	\306	@	A\n\203\f\307	ABE\202!\fD+\207" [eshell-in-pipeline-p terms args cmd sym eshell-named-command* eshell-named-command list] 4 (#$ . 11159)])
#@343 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.
(defalias 'eshell-invokify-arg #[(arg &optional share-output silent) "<\2037@\304=\2037\211A@)@\305=\2037\n\203(\211A@)\211A@)\207\306\211A@)\211A@)E\207\207" [arg x share-output silent eshell-convert eshell-command-to-value eshell-commands] 4 (#$ . 11457)])
(put 'eshell-invokify-arg 'byte-optimizer 'byte-compile-inline-expand)
#@254 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.
(defalias 'eshell-rewrite-for-command #[(terms) "@\306\232\205\213\3078\310\232\205\213\311!@\311\307\"\312\241\210\313\314\315\316\317\320\211AA)A\"BDD\321B\322\323\313\324\211A@)!\325BC\326	\327\312\211<\203~
@\330=\203~
\211A@)@\331=\203~\f\203m
\211A@)\211A@)\202\332
\211A@)\211A@)E\202
+DE)\333BBB\334BBB\207" [terms body x silent share-output arg "for" 2 "in" last nil let for-items copy-tree append mapcar #[(elem) "<\203\207\301D\207" [elem list] 2] ((eshell-command-body '(nil)) (eshell-test-body '(nil))) while (car for-items) intern ((car for-items)) 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)))] 11 (#$ . 12152)])
#@316 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.

If VOCAL-TEST is non-nil, it means output from the test should be
shown, as well as output from the body.
(defalias 'eshell-structure-basic-command #[(func names keyword test body &optional else vocal-test) "@\306=\204
\307\310BB	\311=\204#	<\203'\n	\211A@)\230\203'\312D\313\314\f
F\315BBB\207" [test names keyword x func body 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))) else] 7 (#$ . 13266)])
#@258 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.
(defalias 'eshell-rewrite-while-command #[(terms) "@;\205\243@\305\235\205\243\306\307\310@\211A@)\311\312\211<\203X\f@\313=\203X\f\211A@)@\314=\203X\203G\f\211A@)\211A@)\202Y\315\f\211A@)\211A@)\nE\202Y\f+\316\317!@\312\311\211<\203\237\f@\313=\203\237\f\211A@)@\314=\203\237\203\216\f\211A@)\211A@)\202\240\315\f\211A@)\211A@)\nE\202\240\f+D%\207" [terms x silent share-output arg ("while" "until") eshell-structure-basic-command while ("while" "until") nil t eshell-convert eshell-command-to-value eshell-commands eshell-protect last] 10 (#$ . 14055)])
#@253 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.
(defalias 'eshell-rewrite-if-command #[(terms) "@;\205\377@\305\235\205\377\306\307\310@\211A@)\311\312\211<\203X\f@\313=\203X\f\211A@)@\314=\203X\203G\f\211A@)\211A@)\202Y\315\f\211A@)\211A@)\nE\202Y\f+\316\317\211G\320U\205e\321\"@\312\311\211<\203\247\f@\313=\203\247\f\211A@)@\314=\203\247\203\226\f\211A@)\211A@)\202\250\315\f\211A@)\211A@)\nE\202\250\f+DG\320U\203\374\316\317!@\311\211\211<\203\366\f@\313=\203\366\f\211A@)@\314=\203\366\203\345\f\211A@)\211A@)\202\367\315\f\211A@)\211A@)\nE\202\367\f+D\202\375\312&\207" [terms x silent share-output arg ("if" "unless") eshell-structure-basic-command if ("if" "unless") nil t eshell-convert eshell-command-to-value eshell-commands eshell-protect last 4 2] 11 (#$ . 14913)])
#@169 Return non-nil if the last command was "successful".
For a bit of Lisp code, this means a return value of non-nil.
For an external command, it means an exit code of 0.
(defalias 'eshell-exit-success-p #[nil "\304 \305\216\306\307	\"*\203\n\207\310U\207" [save-match-data-internal eshell-last-command-name eshell-last-command-result eshell-last-command-status match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "#<\\(Lisp object\\|function .*\\)>" 0] 3 (#$ . 15964)])
#@65 Parse a pipeline from TERMS, return the appropriate Lisp forms.
(defalias 'eshell-parse-pipeline #[(terms &optional final-p) "\306\307	\310\306\300$\211\311C\306\203x@\307\312\"\211\211\203M@\313\314\"\210\315\316\"\313\317\320\"\210\240\210)A\211\204&\fG\321X\203\\@\202m \203g\322\323\324C\"\210\325\326DDC\244\210*A)\202\fA\211\237\211@\fA\237\f\203\262@\204\226\322\323\327C\"\210\330\331@\332\230\333\334\f@D\334
D\306\311&\fAA\202\207
-\207" [sep-terms terms bigpieces bp results final 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 cmd 1 signal cl-assertion-failed (not eshell-in-pipeline-p) eshell-execute-pipeline quote (car sep-terms) eshell-structure-basic-command if "&&" "if" eshell-protect subterms pieces p eshell-in-pipeline-p] 9 (#$ . 16500)])
#@54 Parse a subcommand argument of the form '{command}'.
(defalias 'eshell-parse-subcommand-argument #[nil "?\205U	?\205U\305f\306=\205Ud`TU\204!`Tf\307=?\205U\310\306\307\"\211\2041\311\312\306\"\202T\nT\211\2069`\211dU\206Df\f>*\205T\313\314`T\nB!D\nTb\210)\207" [eshell-current-argument eshell-current-quoted end pos eshell-delimiter-argument-list nil 123 125 eshell-find-delimiter throw eshell-incomplete eshell-as-subcommand eshell-parse-command] 5 (#$ . 17482)])
#@60 Parse a Lisp expression which is specified as an argument.
(defalias 'eshell-parse-lisp-argument #[nil "?\2059	?\2059\306\n!\2059`\307\310\311\217\312`\211dU\206&
f>*\2034\313\314\315\fDDD\2028\312b\210*\207" [eshell-current-argument eshell-current-quoted eshell-lisp-regexp here obj pos looking-at err (byte-code "\300p!\207" [read] 2) ((end-of-file (byte-code "\300\301\302\"\207" [throw eshell-incomplete 40] 3))) nil eshell-command-to-value eshell-lisp-command quote eshell-delimiter-argument-list] 4 (#$ . 17968)])
#@254 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 '(list
nil)' if none).
(defalias 'eshell-separate-commands #[(terms separator &optional reversed last-terms-sym) "\306C\306C\307\203J@:\203=\211@@)\310=\203=\311\312
\313Q@A@\"\203=	@A@C\244\210\nAB\306C\202C\n@C\244\210A\211\204\f\nG\314V\203V\nAB\203l\203h\315	A!L\210\202y\203w	AL\210\237+\207" [subchains eshell-sep-terms sub-terms terms x separator t nil eshell-operator string-match "^" "$" 1 reverse reversed last-terms-sym] 5 (#$ . 18509)])
#@132 Evaluate a command OBJECT as a subjob.
We indicate that the process was run in the background by returning it
ensconced in a list.
(defalias 'eshell-do-subjob '(macro . #[(object) "\301\302E\207" [object let ((eshell-current-subjob-p t))] 3 (#$ . 19235)]))
#@67 Place a valid set of handles, and context, around command OBJECT.
(defalias 'eshell-commands '(macro . #[(object &optional silent) "\302\303\304?\305BBD\306B	E\207" [silent object let eshell-current-handles eshell-create-handles ('append) (eshell-current-subjob-p)] 5 (#$ . 19499)]))
#@381 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'...
(defalias 'eshell-trap-errors '(macro . #[(object) "\301\302\303\304\305\306BB\307BBBE\207" [object 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)))] 7 (#$ . 19791)]))
#@67 Duplicate current I/O handles, so OBJECT works with its own copy.
(defalias 'eshell-copy-handles '(macro . #[(object) "\301\302E\207" [object 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)))] 3 (#$ . 20528)]))
#@71 Protect I/O handles, so they aren't get closed after eval'ing OBJECT.
(defalias 'eshell-protect '(macro . #[(object) "\301\302E\207" [object progn (eshell-protect-handles eshell-current-handles)] 3 (#$ . 20872)]))
#@127 Execute the commands in PIPELINE, connecting each to one another.
This macro calls itself recursively, with NOTFIRST non-nil.
(defalias 'eshell-do-pipelines '(macro . #[(pipeline &optional notfirst) "\211A@)\211\205l\306\307A\205-\310\311\312\313AD\314BBDC\315\n\316BB\315\317BB\320BBBB@\211@\321>\203<\322\f!@\f@
>\205O\323\f\324\325\f@!\326P!\240\210)\310\327\204[\330\202eA\203d\331\202e\332DC@EFD\207" [pipeline x eshell-output-handle eshell-error-handle head 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 notfirst] 9 (#$ . 21094)]))
#@200 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 `start-process' is not supported.
(defalias 'eshell-do-pipelines-synchronously '(macro . #[(pipeline) "\211A@)\211\205e\306A\205\"\307\310\311 DC\312\n\313BB\312\314BBF@\211@\315>\2031\316\f!@\f@
>\205D\317\f\320\321\f@!\322P!\240\210)A?\205L\323\307\324@DC\325A\205^\326\327ADD\330BBBB\257\207" [pipeline x eshell-output-handle eshell-error-handle head 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 (#$ . 21899)]))
(defalias 'eshell-process-identity 'identity)
#@67 Execute the commands in PIPELINE, connecting each to one another.
(defalias 'eshell-execute-pipeline '(macro . #[(pipeline) "\303\304\305\306\307!\203\310D\202*\303\311\312\313\314\315	ED\316\313\314\315\nED\317BBBBDC\320DE\321BBE\207" [pipeline eshell-output-handle eshell-error-handle let ((eshell-in-pipeline-p t) tailproc) progn fboundp start-process eshell-do-pipelines tail-handles eshell-create-handles car aref eshell-current-handles nil (nil) eshell-do-pipelines-synchronously ((eshell-process-identity tailproc))] 12 (#$ . 22871)]))
#@183 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.
(defalias 'eshell-as-subcommand '(macro . #[(command) "\302	E\207" [eshell-subcommand-bindings command let] 3 (#$ . 23426)]))
#@93 Run a subcommand prepared by `eshell-command-to-value'.
This avoids the need to use `let*'.
(defalias 'eshell-do-command-to-value '(macro . #[(object) "\301\302\303\304BBE\207" [object let ((eshell-current-handles (eshell-create-handles value 'overwrite))) progn ((symbol-value value))] 5 (#$ . 23741)]))
#@118 Run OBJECT synchronously, returning its result as a string.
Returns a string comprising the output from the command.
(defalias 'eshell-command-to-value '(macro . #[(object) "\301\302\303DE\207" [object let ((value (make-symbol "eshell-temp"))) eshell-do-command-to-value] 4 (#$ . 24054)]))
#@49 A command for toggling certain debug variables.
(defalias 'eshell/eshell-debug #[(&rest args) "\305\204	\203\306\307\n\"\210)\f\203P\310\307\n\"\210)\207@\311\235\203.\312\307\n\"\210)\207\203P@\313\230\203?	?\202I@\314\230\203I\f?A\211\2042\207" [args eshell-handle-errors object 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"] 5 (#$ . 24351)])
#@37 Completion for the `debug' command.
(defalias 'pcomplete/eshell-mode/eshell-debug #[nil "\300\301\302\211\211$\205\f\202\207" [pcomplete--here #[nil "\300\207" [("errors" "commands")] 1] nil] 5 (#$ . 25126)])
(defalias 'eshell-invoke-directly #[(command input) "\305\211\211A@)88\211A@)\306\211@\307=\2031\211A@)@\310=\2031\211A@)\211A@)\n\205N\n;\205N\n\f\235?\205N\311\312\215\205N\313\314\315\nP!!*\207" [command x name base eshell-complex-commands 2 nil eshell-trap-errors eshell-named-command simple (byte-code "\304\211\203#\n@\305	!\203	!\203\306\307\304\"\210\nA\211\204*\310\207" [eshell-complex-commands pred --dolist-tail-- name nil functionp throw simple t] 4) fboundp intern-soft "eshell/"] 5])
#@41 Evaluate the given COMMAND iteratively.
(defalias 'eshell-eval-command #[(command &optional input) "\203\305A!\306\307	\205\310	\311PD\312\313\314\nDD\257C\241\207\2032r\315\316!q\210\317 \210\320	\321\261\210)\n\322\323\215\211<\203@\f@\f\205O\f\324=?\205O\325\326\f\")\207" [eshell-current-command input command eshell-debug-command delim 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"] 9 (#$ . 25873)])
#@49 Resume the current command when a process ends.
(defalias 'eshell-resume-command #[(proc status) "\205 	;?\206	\304\230\206\305\n	\"?\205 =\205 \306 \207" [proc status eshell-reset-signals eshell-last-async-proc "stopped" string-match eshell-resume-eval] 3 (#$ . 26522)])
#@62 Destructively evaluate a form which may need to be deferred.
(defalias 'eshell-resume-eval #[nil "\300\301\302\217\207" [err (byte-code "\305	\205(\305\306\307\215\211\310\311!\205\311!)\203!\305\202'\n\211A@)*\207" [eshell-last-async-proc eshell-current-command retval proc x nil eshell-defer (byte-code "\302\303!\207" [eshell-current-command retval nil eshell-do-eval] 3) fboundp processp] 3) ((error (byte-code "\301\302!!\207" [err error error-message-string] 3)))] 3 (#$ . 26810)])
#@60 Manipulate a COMMAND form, with TAG as a debug identifier.
(defalias 'eshell-manipulate '(macro . #[(tag &rest commands) "\303\300!\203\n\204\304	B\207\304\300\305\n!\306BB\307	\300\310\305\n!P\311BBC\"BB\207" [eshell-debug-command commands tag boundp progn eval (form) append "done " (form)] 8 (#$ . 27320)]))
(put 'eshell-manipulate 'lisp-indent-function 1)
#@49 Return t if OBJECT is a macro or nil otherwise.
(defalias 'eshell-macrop #[(object) "9\205#\301!\205#\302!\211\205#<\205#@\303=\205#\304A!\207" [object fboundp indirect-function macro functionp] 2 (#$ . 27690)])
(put 'eshell-macrop 'byte-optimizer 'byte-compile-inline-expand)
#@181 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.
(defalias 'eshell-do-eval #[(form &optional synchronous-p) "<\204\306\307!D\207@\310>\203\207@\311=\203'\211A@)\211A@)@\2119\205M\312\n!\205M\313\n!\211\205M\n<\205M\n@\314=\205M\315\nA!)\203b\316\317!!@\240\210A\241\210)A@\320=\203\336
@\203\212*\203|\321\322\323C\"\210\311
@!\210
\324\240\210+\324\240\210+@\204\230+\316\f@!\240\210\311+@!\211A@)\203\330
\f\211AA)\203\270\325\316\fA!B\202\300\316\f\211A@)!\240\210\311
@*\"\210
\324\240\210+\316\f@!\240\210\202\230
\324\240\202\274@\326=\203?

@\203\375*\203\365\321\322\327C\"\210\311
@!\210\2024
+@\204
+\316\f@!\240\210
\316\311+@!\211A@)\203#
\f\211A@)\202*
\f\211AA)@!\240\210\311
@*\"\210
\324\240\210+\324\240\202\274@\330=\203Z
\fA\311\f\211A@)*\"\240\210\307!\202\274@\331=\203u
\fA\311\f\211A@)*\"\240\210\307!\202\274@\332>\203\360
@\333=\203\312
\f\211A@)@\311=\204\312
\f@\324,\211-\203\311
-@\211,<\203\300
,\211A@)\306=\204\300
,\311,\211A@)*\"C\241\210-A\211-\204\232
*@\334=\204\324
\fA\f\211@@)\311=\204\352
\f\311\306\f@D*E\240\210\307!\202\274@\335=\203\f\211AA)\203\336\337!\210\fA\311\f\211A@)*\"\240\210\306\307!D\202\274\f\2039@\340>\2049\f\2039\f\311\f@*\"\240\210\fA\211\204)@\325=\203G\341!@\202\274@\342=\203W\211A@)\202\274\324.\343\344\215\211/\203w/@\240\210/A\241\210\311*\"\202\273@0>\203\2671\204\267.\203\267.2\312\345!\205\227\3452!)\203\267*\203\247\346.!\202\273\347\240\210\324\241\210\350\351.\"\202\273\306.D*)\207" [form x object exp args eshell-command-body quote eval 'function eshell-do-eval fboundp indirect-function macro functionp eshell-copy-tree macroexpand while signal 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 (byte-code "\302\303!\207" [form result nil eval] 3) processp eshell/wait ignore throw eshell-defer synchronous-p eshell-test-body letarg --dolist-tail-- result new-form eshell-deferrable-commands eshell-current-subjob-p proc] 5 (#$ . 27986)])
#@48 Identify the COMMAND, and where it is located.
(defalias 'eshell/which #[(command &rest names) "	B\306\211\205\376@\306\211\211\"\n\307H#=\203$\n\310\306O\311\f\204I\312\211$%>)\203I\313K\n!\211\203I\n\314
\211&A@)\315R\"\"\204\302\316\n!\"\317\n!\211'\206_\320\n!('\204r(\203\301\321(!\203\301)\204{\f\204\301\311*\322 +\323\216\324(!\325\306!\210+\211,\203\246,\307\326\327,\"\206\241,GSO\202\252\330\331\n\",\332\333\334!!\203\270\335\334!\210,\206\276\n\")*\"\204\333\330\336\n\337\340!#-\341-.\"\210)\202\365\"\211--\341-/\"\210)\327-\341-/\"\210*+A\211\204\n\306*\207" [command names name --dolist-tail-- direct alias nil 0 1 t eshell-alias eshell-lookup-alias " is an alias, defined as \"" "\"" eshell-search-path eshell-find-alias-function intern-soft fboundp current-window-configuration ((set-window-configuration #1=#:wconfig)) describe-function message string-match "\n" format "%s is defined, but no documentation was found" buffer-live-p get-buffer "*Help*" kill-buffer "which: no %s in (%s)\n" getenv "PATH" eshell-output-object program eshell-explicit-command-char module eshell-modules-list x esym sym eshell-prefer-lisp-functions inhibit-redisplay #1# desc object eshell-error-handle eshell-output-handle] 6 (#$ . 30392)])
(put 'eshell/which 'eshell-no-numeric-conversions t)
#@116 Insert output from a plain COMMAND, using ARGS.
COMMAND may result in an alias being executed, or a plain command.
(defalias 'eshell-named-command #[(command &optional args) "\304\n!\305\306!\210;\204\307\310\311C\"\210\205%\312\313	#\206%\314	\"\207" [args eshell-last-arguments command eshell-last-command-name eshell-stringify run-hook-with-args eshell-prepare-command-hook signal cl-assertion-failed (stringp eshell-last-command-name) run-hook-with-args-until-success eshell-named-command-hook eshell-plain-command] 4 (#$ . 31761)])
(defalias 'eshell-named-command* 'eshell-named-command)
#@55 Check whether a function called `eshell/NAME' exists.
(defalias 'eshell-find-alias-function #[(name) "\306\307P!\310	\311\"\211\203G\312\n!\211\203G\313\314\n\"\203G\315\316\317\320\n\"P!\321	!\205C\203B\211
>)\204B\322\323!>\205C	)\202N\321	!\205N	*\207" [name sym file module-sym module 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] 6 (#$ . 32371)])
#@142 Insert output from a plain COMMAND, using ARGS.
COMMAND may result in either a Lisp function being executed by name,
or an external command.
(defalias 'eshell-plain-command #[(command args) "\305!\211\206\306!\211\203+\307\n!\203+	\204$\204$\310!\204+\311\n\f\"\202/\312\f\"*\207" [command esym sym eshell-prefer-lisp-functions args eshell-find-alias-function intern-soft fboundp eshell-search-path eshell-lisp-command eshell-external-command] 4 (#$ . 32899)])
#@235 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.
(defalias 'eshell-exec-lisp #[(printer errprint func-or-form args form-p) "\300\301\302\217\207" [err (byte-code "r\203\305	!\202\306	\n\")\211\203\f!\210)\207" [form-p func-or-form args result printer eval apply] 4) ((error (byte-code "\306!\n\204\307\310	\"\203\311\312!\203\312!\313\314\f\")
	!\210)\315\207" [err msg form-p func-or-form func-doc errprint error-message-string string-match "^Wrong number of arguments" fboundp eldoc-get-fnsym-args-string format "usage: %s" nil] 3)))] 3 (#$ . 33382)])
#@151 Call FUNC, with ARGS, trapping errors and return them as output.
PRINTER and ERRPRINT are functions to use for printing regular
messages, and errors.
(defalias 'eshell-apply* #[(printer errprint func args) "\304	\n\305%\207" [printer errprint func args eshell-exec-lisp nil] 6 (#$ . 34149)])
(put 'eshell-apply* 'byte-optimizer 'byte-compile-inline-expand)
#@66 Call FUNC, with ARGS, trapping errors and return them as output.
(defalias 'eshell-funcall* #[(printer errprint func &rest args) "	\n\304	\n\305%,\207" [printer errprint func args eshell-exec-lisp nil] 6 (#$ . 34514)])
(put 'eshell-funcall* 'byte-optimizer 'byte-compile-inline-expand)
#@52 Evaluate FORM, trapping errors and returning them.
(defalias 'eshell-eval* #[(printer errprint form) "\303	\n\304\305%\207" [printer errprint form eshell-exec-lisp nil t] 6 (#$ . 34814)])
(put 'eshell-eval* 'byte-optimizer 'byte-compile-inline-expand)
#@151 Call FUNC, with ARGS, trapping errors and return them as output.
PRINTER and ERRPRINT are functions to use for printing regular
messages, and errors.
(defalias 'eshell-apply #[(func args) "\304\305	\306\n	\307%,\207" [func args errprint printer eshell-print eshell-error eshell-exec-lisp nil] 6 (#$ . 35074)])
(put 'eshell-apply 'byte-optimizer 'byte-compile-inline-expand)
#@66 Call FUNC, with ARGS, trapping errors and return them as output.
(defalias 'eshell-funcall #[(func &rest args) "	\304\305	\306\n	\307%.\207" [func args errprint printer eshell-print eshell-error eshell-exec-lisp nil] 6 (#$ . 35461)])
(put 'eshell-funcall 'byte-optimizer 'byte-compile-inline-expand)
#@52 Evaluate FORM, trapping errors and returning them.
(defalias 'eshell-eval #[(form) "\303\304\305\n	\306\307%+\207" [form errprint printer eshell-print eshell-error eshell-exec-lisp nil t] 6 (#$ . 35778)])
(put 'eshell-eval 'byte-optimizer 'byte-compile-inline-expand)
#@151 Call FUNC, with ARGS, trapping errors and return them as output.
PRINTER and ERRPRINT are functions to use for printing regular
messages, and errors.
(defalias 'eshell-applyn #[(func args) "\304\305	\306\n	\307%,\207" [func args errprint printer eshell-printn eshell-errorn eshell-exec-lisp nil] 6 (#$ . 36058)])
(put 'eshell-applyn 'byte-optimizer 'byte-compile-inline-expand)
#@66 Call FUNC, with ARGS, trapping errors and return them as output.
(defalias 'eshell-funcalln #[(func &rest args) "	\304\305	\306\n	\307%.\207" [func args errprint printer eshell-printn eshell-errorn eshell-exec-lisp nil] 6 (#$ . 36449)])
(put 'eshell-funcalln 'byte-optimizer 'byte-compile-inline-expand)
#@52 Evaluate FORM, trapping errors and returning them.
(defalias 'eshell-evaln #[(form) "\303\304\305\n	\306\307%+\207" [form errprint printer eshell-printn eshell-errorn eshell-exec-lisp nil t] 6 (#$ . 36770)])
(put 'eshell-evaln 'byte-optimizer 'byte-compile-inline-expand)
#@47 Insert Lisp OBJECT, using ARGS if a function.
(defalias 'eshell-lisp-command #[(object &optional args) "\300\301\215\207" [eshell-external (byte-code "\306 \307	!\203d\n\310\311	!\312Q	\313N\204D\n\203D\n@\211;\203<
G\314V\203<\315\314
G\316\317
%\204<\n\320
!\240\210)\nA\211\204	\321\322\n\323\n\324%.\202\200\n\325	\321\322\323\324\317%,\203\231\212b\210n)\204\231\326\327	 \"\210)\330\314\331D\"*\207" [eshell-ensure-newline-p object args eshell-last-arguments eshell-last-command-name arg 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 func errprint printer form result eshell-last-output-end eshell-output-handle] 7)] 2 (#$ . 37053)])
(byte-code "\300\301\302\"\210\303\304!\207" [defalias eshell-lisp-command* eshell-lisp-command provide esh-cmd] 3)