;ELC
;;; Compiled
;;; in Emacs version 24.5.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\302\303!\210\302\304!\210\302\305!\210\302\306!\210\302\307!\210\310\311\312\313\314\315\316\317&\210\320\321\322\323\324DD\325\326\327\316\311&\210\320\330\322\323\331DD\332\326\327\316\311&\210\320\333\322\323\334DD\335\326\327\316\311&\210\320\336\322\323\337DD\340\341\342\326\327\316\311&	\210\320\343\322\323\344DD\345\326\346\316\311&\210\320\347\322\323\350DD\351\326\327\316\311&\210\320\352\322\323\353DD\354\326\346\316\311&\210\320\355\322\323\356DD\357\326\327\316\311&\210\320\360\322\323\361DD\362\326\363\316\311&\210\320\364\322\323\365DD\366\326\367\316\311&\210\320\370\322\323\371DD\372\326\346\316\311&\210\320\373\322\323\374DD\375\326\376\316\311&\210\320\377\322\323\201@DD\201A\326\327\316\311&\210\320\201B\322\323\201CDD\201D\326\327\316\311&\210\320\201E\322\323\201FDD\201G\326\201H\316\311&\210\320\201I\322\323\201JDD\201K\326\201L\316\311&\210\201M\201N\201O\312#\210\201P\211\203i
\211@\201N
N\203b
\201O
N\204b
\201Q\201O\201NN#\210
A\266\202\202>
\210\201R\201N\201O\201S#\210\320\201O\322\323\201TDD\201U\326\346\316\311&\207" [provide esh-mode require esh-util esh-module esh-cmd esh-io esh-var custom-declare-group eshell-mode nil "This module contains code for handling input from the user." :tag "User interface" :group eshell custom-declare-variable eshell-mode-unload-hook funcall function #[0 "\300\207" [nil] 1 "\n\n(fn)"] "A hook that gets run when `eshell-mode' is unloaded." :type hook eshell-mode-hook #[0 "\300\207" [nil] 1 "\n\n(fn)"] "A hook that gets run when `eshell-mode' is entered." eshell-first-time-mode-hook #[0 "\300\207" [nil] 1 "\n\n(fn)"] "A hook that gets run the first time `eshell-mode' is entered.\nThat is to say, the first time during an Emacs session." eshell-exit-hook #[0 "\300\207" [nil] 1 "\n\n(fn)"] "A hook that is run whenever `eshell' is exited.\nThis hook is only run if exiting actually kills the buffer." :version "24.1" eshell-kill-on-exit #[0 "\300\207" [t] 1 "\n\n(fn)"] "If non-nil, kill the Eshell buffer on the `exit' command.\nOtherwise, the buffer will simply be buried." boolean eshell-input-filter-functions #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Functions to call before input is processed.\nThe input is contained in the region from `eshell-last-input-start' to\n`eshell-last-input-end'." eshell-send-direct-to-subprocesses #[0 "\300\207" [nil] 1 "\n\n(fn)"] "If t, send any input immediately to a subprocess." eshell-expand-input-functions #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Functions to call before input is parsed.\nEach function is passed two arguments, which bounds the region of the\ncurrent input text." eshell-scroll-to-bottom-on-input #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Controls whether input to interpreter causes window to scroll.\nIf nil, then do not scroll.  If t or `all', scroll all windows showing\nbuffer.  If `this', scroll only the selected window.\n\nSee `eshell-preinput-scroll-to-bottom'." (radio (const :tag "Do not scroll Eshell windows" nil) (const :tag "Scroll all windows showing the buffer" all) (const :tag "Scroll only the selected window" this)) eshell-scroll-to-bottom-on-output #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Controls whether interpreter output causes window to scroll.\nIf nil, then do not scroll.  If t or `all', scroll all windows showing\nbuffer.  If `this', scroll only the selected window.  If `others',\nscroll only those that are not the selected window.\n\nSee variable `eshell-scroll-show-maximum-output' and function\n`eshell-postoutput-scroll-to-bottom'." (radio (const :tag "Do not scroll Eshell windows" nil) (const :tag "Scroll all windows showing the buffer" all) (const :tag "Scroll only the selected window" this) (const :tag "Scroll all windows other than selected" this)) eshell-scroll-show-maximum-output #[0 "\300\207" [t] 1 "\n\n(fn)"] "Controls how interpreter output causes window to scroll.\nIf non-nil, then show the maximum output when the window is scrolled.\n\nSee variable `eshell-scroll-to-bottom-on-output' and function\n`eshell-postoutput-scroll-to-bottom'." eshell-buffer-maximum-lines #[0 "\300\207" [1024] 1 "\n\n(fn)"] "The maximum size in lines for eshell buffers.\nEshell buffers are truncated from the top to be no greater than this\nnumber, if the function `eshell-truncate-buffer' is on\n`eshell-output-filter-functions'." integer eshell-output-filter-functions #[0 "\300\207" [(eshell-postoutput-scroll-to-bottom eshell-handle-control-codes eshell-handle-ansi-color eshell-watch-for-password-prompt)] 1 "\n\n(fn)"] "Functions to call before output is displayed.\nThese functions are only called for output that is displayed\ninteractively, and not for output which is redirected." eshell-preoutput-filter-functions #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Functions to call before output is inserted into the buffer.\nThese functions get one argument, a string containing the text to be\ninserted.  They return the string as it should be inserted." eshell-password-prompt-regexp #[0 "\301\302\303!\"\207" [password-word-equivalents format "\\(%s\\).*:\\s *\\'" regexp-opt] 4 "\n\n(fn)"] "Regexp matching prompts for passwords in the inferior process.\nThis is used by `eshell-watch-for-password-prompt'." regexp eshell-skip-prompt-function #[0 "\300\207" [nil] 1 "\n\n(fn)"] "A function called from beginning of line to skip the prompt." (choice (const nil) function) defvaralias eshell-status-in-modeline eshell-status-in-mode-line (saved-value saved-variable-comment) put make-obsolete-variable "24.3" #[0 "\300\207" [t] 1 "\n\n(fn)"] "If non-nil, let the user know a command is running in the mode line."] 10)
#@62 A variable which is non-nil the first time Eshell is loaded.
(defvar eshell-first-time-p t (#$ . 6067))
(defvar eshell-mode nil)
(defvar eshell-mode-map nil)
(defvar eshell-command-running-string "--")
(defvar eshell-command-map nil)
(defvar eshell-command-prefix nil)
(defvar eshell-last-input-start nil)
(defvar eshell-last-input-end nil)
(defvar eshell-last-output-start nil)
(defvar eshell-last-output-block-begin nil)
(defvar eshell-last-output-end nil)
(defvar eshell-currently-handling-window nil)
(define-abbrev-table 'eshell-mode-abbrev-table nil)
(defvar eshell-mode-syntax-table (byte-code "\300 \301\211\302W\203\303
\304#\210\211T\262
\202\305\262
\211\306W\203,\303
\304#\210\211T\262
\202\307\262
\211\310W\203B\303
\304#\210\211T\262
\202/\311\262
\211\312W\203X\303
\304#\210\211T\262
\202E\303\313\314#\210\303\315\314#\210\303\316\314#\210\303\317\320#\210\303\321\320#\210\303\322\323#\210\303\324\323#\210\303\325\323#\210\303\326\304#\210\303\327\304#\210\303\330\331#\210\303\332\323#\210\303\333\334#\210\303\335\336#\210\303\337\340#\210\303\341\342#\210\303\311\343#\210\303\344\345#\210\303\307\346#\210\303\347\350#\210\351\352\353\354\355\356!\357\"\360\361%\362 \"\210
\207" [make-syntax-table 0 48 modify-syntax-entry "_   " 58 65 91 97 123 128 32 "    " 9 12 10 ">   " 13 96 "'   " 39 44 46 45 124 ".   " 35 34 "\"    " 92 "/   " 40 "()  " 41 ")(  " "(}  " 125 "){  " "(]  " 93 ")[  " map-char-table make-byte-code 514 "
:\203
@\301Y\205(
@z\302U?\202 
\303Y\205(
z\302U?\205(\304\305\300#\207" vconcat vector [128 119 256 modify-syntax-entry "_   "] 6 "\n\n(fn KEY VAL)" standard-syntax-table] 9))
#@152 Function added to `kill-buffer-hook' in Eshell buffers.
This runs the function `eshell-kill-processes-on-exit',
and the hook `eshell-exit-hook'.

(fn)
(defalias 'eshell-kill-buffer-function #[0 "\301\302!\203\302>\204\302 \210\303\300!\207" [eshell-exit-hook fboundp eshell-query-kill-processes run-hooks] 2 (#$ . 7749)])
#@163 Hook run after entering EShell mode.
No problems result if this variable is not bound.
`add-hook' automatically binds it.  (This is true for all hook variables.)
(defvar eshell-mode-hook nil (#$ . 8083))
(byte-code "\300\301!\204\f\302\301\303\304#\210\300\207" [boundp eshell-mode-map put definition-name eshell-mode] 4)
(defvar eshell-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [eshell-mode-map variable-documentation put purecopy "Keymap for `eshell-mode'." boundp eshell-mode-syntax-table definition-name eshell-mode] 5)
(defvar eshell-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [eshell-mode-syntax-table variable-documentation put purecopy "Syntax table for `eshell-mode'." eshell-mode-abbrev-table definition-name eshell-mode] 5)
(defvar eshell-mode-abbrev-table (progn (define-abbrev-table 'eshell-mode-abbrev-table nil) eshell-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [eshell-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `eshell-mode'." eshell-mode derived-mode-parent nil] 5)
#@143 Emacs shell interactive mode.

This mode runs the hook `eshell-mode-hook', as the final step
during initialization.

\{eshell-mode-map}

(fn)
(defalias 'eshell-mode #[0 "\306\300!\210\307\310 \210\311\312\313!\210\314\f!\210
@\306\311!\210\307	\306\303!\210\315 \313!\210A\203J\306\316!\210\317!\306\320!\210\321>\211\203I\211\316\240\210\210\322\323\324#\210\322\325\326#\210\322\327\330#\210\322\331\332#\210\306\333!\210\334\335!\211\315 M\210\306\336!\210K\322\337#\210\340\341!\342=\203\216\322\343\344#\210\322\345\346#\210\322\347\350#\210\322\351\332#\210\322\352\353#\210\322\354\355#\210\322\356\357#\210\322\360\361#\210\322\362\361#\210\322\363\364#\210\322\365\330#\210\322\366\367#\210\322\370\371#\210\322\372\373#\210\322\374\375#\210
@\306\376!\210B>\306\377!\210\201WB!?\306\201C!\210\201XC\201YD\201Z\201E!\203,
\306\201E!\210\201YE\201Z\201F!\203A
\306\201F!\210\201YF\306\201G!\210\201YG\306\201H!\210\201[H]H\306\201I!\210\201\\H]I\306\201J!\210\201] J\306\201K!\210\201] K\306\201L!\210\201] L\306\201M!\210\201] M\306\201N!\210`N\317O!\306\201O!\210\211O\211\203\375
\211@\201^
!\201Y\201_\201`\"\203\325
\201a\201b\201c\"P\262
\211\204\342
\201d\201e\"\210\201f\201g!!\204\364
\201h
!\210\266
A\266\202\202\256
\210\201iP!\204BP\307\201j \201kQ!\210\201l\201m\201n\201o\201p\201q!\201r\"\201s\201t%DC\216\201u\"\210)\266\201v\201w\201x!O\"\211\203\243\211@\201y\201z\201{\"!\201y\201z\201|\"!
\203\213\201Z!\203\213\211J>\203\205\201Y\262
\201}!\210\211\203\232\201~
!\203\232\211 \210\266
A\266\202\202O\210R\203\266\201\201\200\201\201\307\211$\210S\203\310\201\201\200\201\202\307\211$\210T\203\330\306\201U!\210\201\203UA\203\373\201\201\204\201\205\201Y\307$\210\201\201\206\201\207\201Y\307$\210\201\201\210\201\211\307\211$\210V\203\201}\201\212!\210\201}\201\206!\210)\201\213\201\214!\207" [delay-mode-hooks major-mode mode-name eshell-mode-map eshell-mode-syntax-table eshell-mode-abbrev-table make-local-variable t kill-all-local-variables eshell-mode "EShell" use-local-map set-syntax-table make-sparse-keymap eshell-command-running-string copy-sequence mode-line-format mode-line-modified define-key "
" eshell-send-input "\215" eshell-queue-input [(meta control 108)] eshell-show-output [(control 97)] eshell-bol eshell-command-prefix make-symbol "eshell-command-prefix" eshell-command-map [(control 99)] key-binding [(meta 46)] find-tag [(meta 46)] eshell-find-tag [(meta 111)] eshell-mark-output [(meta 100)] eshell-toggle-direct-send [(control 97)] [(control 98)] eshell-backward-argument [(control 101)] eshell-show-maximum-output [(control 102)] eshell-forward-argument [return] eshell-copy-old-input [(control 109)] [(control 111)] eshell-kill-output [(control 114)] [(control 116)] eshell-truncate-buffer [(control 117)] eshell-kill-input [(control 119)] backward-kill-word [(control 121)] eshell-repeat-argument dired-directory list-buffers-directory local-abbrev-table eshell-status-in-mode-line default-directory tab-width auto-fill-function print-length print-level require-final-newline max-lisp-eval-depth max-specpdl-size eshell-last-input-start eshell-last-input-end eshell-last-output-start eshell-last-output-end eshell-last-output-block-begin eshell-modules-list eshell-directory-name eshell-private-directory-modes eshell-send-direct-to-subprocesses eshell-scroll-to-bottom-on-input eshell-scroll-show-maximum-output scroll-conservatively eshell-first-time-p expand-file-name 8 nil boundp 3000 6000 point-marker symbol-name string-match "^eshell-\\(.*\\)" "em-" match-string 1 error "Invalid Eshell module name: %s" featurep intern load file-exists-p default-file-modes set-default-file-modes funcall make-byte-code 0 "\301\300!\207" vconcat vector [set-default-file-modes] 2 "\n\n(fn)" make-directory append eshell-subgroups eshell intern-soft format "%s-load-hook" "%s-initialize" run-hooks fboundp add-hook pre-command-hook eshell-intercept-commands eshell-preinput-scroll-to-bottom 1000 eshell-pre-command-hook eshell-command-started eshell-post-command-hook eshell-command-finished kill-buffer-hook eshell-kill-buffer-function eshell-first-time-mode-hook run-mode-hooks eshell-mode-hook] 11 (#$ . 9317) nil])
(put 'eshell-mode 'mode-class 'special)
#@61 Indicate in the mode line that a command has started.

(fn)
(defalias 'eshell-command-started #[0 "\301\302 \207" [eshell-command-running-string "**" force-mode-line-update] 1 (#$ . 13752)])
#@62 Indicate in the mode line that a command has finished.

(fn)
(defalias 'eshell-command-finished #[0 "\301\302 \207" [eshell-command-running-string "--" force-mode-line-update] 1 (#$ . 13950)])
(defalias 'eshell-toggle-direct-send #[0 "\203\301\302\303\304\305#\210\306\307!\207\305\310\303\304\305\211$\210\306\311!\207" [eshell-send-direct-to-subprocesses nil remove-hook pre-command-hook eshell-intercept-commands t message "Sending subprocess input on RET" add-hook "Sending subprocess input directly"] 5 "\n\n(fn)" nil])
(defalias 'eshell-self-insert-command #[0 "\302\303	9\203	\304N\202	!\"\207" [eshell-last-async-proc last-command-event process-send-string char-to-string ascii-character] 5 "\n\n(fn)" nil])
(defalias 'eshell-intercept-commands #[0 "\205L	\250\205\f	\303>?\205L\304\n!\305\n!\306
G\307V\203'
\310\307O\311\232\204C\203C@G\312V\203<\313\262
\313\262\202'A\262\202'\211\205J\314\211\266\203\207" [eshell-last-async-proc last-input-event this-command (24 3) where-is-internal symbol-name t 7 0 "eshell-" 1 nil eshell-self-insert-command] 6 "\n\n(fn)"])
#@117 A special version of `find-tag' that ignores whether the text is read-only.

(fn &optional TAGNAME NEXT-P REGEXP-P)
(defalias 'eshell-find-tag #[768 "\302\303!\210\304m\305
\306\307\"@\262\310#*\207" [find-tag-default-function inhibit-read-only require etags t ignore find-tag-interactive "Find tag: " find-tag] 9 (#$ . 15060) nil])
#@59 Move forward ARG arguments.

(fn LIMIT FUNC PROPERTY ARG)
(defalias 'eshell-move-argument #[1028 "\300\301\302D\215\210\212\303!\210\211\304V\203/`U\204/\305`\"\203\"\211S\262
\211\304V\203\303!\210\202`)\211b\210\306=\205C\211TU\205C\303u\207" [eshell-incomplete funcall #[0 "\300\212\301 \210`)\302 \"\207" [eshell-parse-arguments eshell-bol line-end-position] 3 "\n\n(fn)"] 1 0 get-text-property forward-char] 7 (#$ . 15406)])
#@49 Move forward ARG arguments.

(fn &optional ARG)
(defalias 'eshell-forward-argument #[256 "\300d\301\302$\207" [eshell-move-argument forward-char arg-end] 6 (#$ . 15857) "p"])
#@50 Move backward ARG arguments.

(fn &optional ARG)
(defalias 'eshell-backward-argument #[256 "\300e\301\302$\207" [eshell-move-argument backward-char arg-begin] 6 (#$ . 16039) "p"])
(defalias 'eshell-repeat-argument #[256 "\212\300
!\210`)\301
`\"\210\302 \207" [eshell-backward-argument kill-ring-save yank] 5 "\n\n(fn &optional ARG)" "p"])
#@74 Goes to the beginning of line, then skips past the prompt, if any.

(fn)
(defalias 'eshell-bol #[0 "\301 \210\205	 \207" [eshell-skip-prompt-function beginning-of-line] 1 (#$ . 16386) nil])
#@54 Push a mark at the end of the last input text.

(fn)
(defalias 'eshell-push-command-mark #[0 "\301S\302\"\207" [eshell-last-input-end push-mark t] 3 (#$ . 16585)])
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [byte-code "\300\301\302\303#\207" [put eshell-push-command-mark byte-optimizer byte-compile-inline-expand] 4 custom-add-option eshell-pre-command-hook eshell-push-command-mark] 4)
#@136 Goto the start of the last command input.
Putting this function on `eshell-pre-command-hook' will mimic Plan 9's
9term behavior.

(fn)
(defalias 'eshell-goto-input-start #[0 "b\207" [eshell-last-input-start] 1 (#$ . 16991)])
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [byte-code "\300\301\302\303#\207" [put eshell-goto-input-start byte-optimizer byte-compile-inline-expand] 4 custom-add-option eshell-pre-command-hook eshell-push-command-mark] 4)
#@57 Print STRING to the eshell display buffer.

(fn STRING)
(defalias 'eshell-interactive-print #[257 "\300\301\"\207" [eshell-output-filter nil] 4 (#$ . 17456)])
(byte-code "\300\301\302\303#\207" [put eshell-interactive-print byte-optimizer byte-compile-inline-expand] 4)
#@68 This function outputs a newline if not at beginning of line.

(fn)
(defalias 'eshell-begin-on-new-line #[0 "\212b\210n\206\301\302\303\"\262
)\207" [eshell-last-output-end "\n" eshell-output-filter nil] 4 (#$ . 17733)])
(byte-code "\300\301\302\303#\207" [put eshell-begin-on-new-line byte-optimizer byte-compile-inline-expand] 4)
#@155 Output a prompt on a new line, aborting any current input.
If NO-HOOKS is non-nil, then `eshell-post-command-hook' won't be run.

(fn &optional NO-HOOKS)
(defalias 'eshell-reset #[256 "db\210\305 \305 \305 `\305 \212\fb\210n\206 \306\307\310\"\262
)\210\211?\205-\311\312!\210db\207" [eshell-last-input-start eshell-last-input-end eshell-last-output-start eshell-last-output-block-begin eshell-last-output-end point-marker "\n" eshell-output-filter nil run-hooks eshell-post-command-hook] 5 (#$ . 18075)])
(byte-code "\300\301\302\303#\207" [put eshell-reset byte-optimizer byte-compile-inline-expand] 4)
#@433 Parse the command input from BEG to END.
The difference is that `eshell-parse-command' expects a complete
command string (and will error if it doesn't get one), whereas this
function will inform the caller whether more input is required.

If nil is returned, more input is necessary (probably because a
multi-line input string wasn't terminated properly).  Otherwise, it
will return the parsed command.

(fn BEG END &optional ARGS)
(defalias 'eshell-parse-command-input #[770 "\300\211C\301\302\303\304\305\306\307\n$\310\"\311\312%D\215\211\262\2033\300\313\314<\203-@\202.\"\210\2025\211\242\207" [nil eshell-incomplete funcall make-byte-code 0 "\304\303\305\300\301B\302\306#\240\210\207" vconcat vector [nil eshell-parse-command t] 6 "\n\n(fn)" message "Expecting completion of delimiter %c ..."] 16 (#$ . 18695)])
#@78 Update the input and output markers relative to point and PMARK.

(fn PMARK)
(defalias 'eshell-update-markers #[257 "
\303\223\210	`\303\223\210\n`\303\223\207" [eshell-last-input-start eshell-last-input-end eshell-last-output-end nil] 4 (#$ . 19535)])
#@172 Queue the current input text for execution by Eshell.
Particularly, don't send the text to the current process, even if it's
waiting for input.

(fn &optional USE-REGION)
(defalias 'eshell-queue-input #[256 "\300
\301\"\207" [eshell-send-input t] 4 (#$ . 19796) "P"])
#@658 Send the input received to Eshell for parsing and processing.
After `eshell-last-output-end', sends all text from that marker to
point as input.  Before that marker, calls `eshell-get-old-input' to
retrieve old input, copies it to the end of the buffer, and sends it.

If USE-REGION is non-nil, the current region (between point and mark)
will be used as input.

If QUEUE-P is non-nil, input will be queued until the next prompt,
rather than sent to the currently active process.  If no process, the
input is processed immediately.

If NO-NEWLINE is non-nil, the input is sent without an implied final
newline.

(fn &optional USE-REGION QUEUE-P NO-NEWLINE)
(defalias 'eshell-send-input #[768 "\205
?\306\307\211\205\310!\311=??\205\245\211\204\"`Y\203(db\210\2023\312!b\210\313
!\266
\204C\f\203?\211\204C\314\315!\210\211\203k\316!\210\f\204V
%U\203b
?\205\245\317\320\"\202\245\321
%#\202\245`U\203w\322\323!\202\245\307C\324\325\326\327\330\331\332!\333\"\315\334%D\335\325\336\324ED\337\325\326\340\341\331\332\n!\342\"\343\344%\324EDD\217\262
*\207" [eshell-last-async-proc after-change-functions inhibit-point-motion-hooks eshell-last-output-end eshell-send-direct-to-subprocesses eshell-last-input-start t nil process-status run eshell-get-old-input insert-and-inherit insert-before-markers-and-inherit 10 eshell-update-markers process-send-string "\n" process-send-region run-hooks eshell-post-command-hook #1=#:err funcall make-byte-code 0 "\300\304	`S\"\240\210\305\306	`S#\210\307	`S\"\211\205?\310	!\210\300\304\nS\"\240\210\311\312!\210\313\314\315\316\317\320\321\300\"\322\"\323\324%D\215\205?\325 \207" vconcat vector [eshell-last-output-end eshell-last-input-start eshell-last-input-end buffer-substring-no-properties run-hook-with-args eshell-expand-input-functions eshell-parse-command-input eshell-update-markers run-hooks eshell-input-filter-functions eshell-terminal funcall make-byte-code 0 "\302\303\301!\203\f\304\301!\210\207\305\301\300\242\"\210\207" vconcat vector [nil eshell-invoke-directly eval eshell-eval-command] 4 "\n\n(fn)" eshell-life-is-too-much] "\n\n(fn)" (debug quit) #[257 "\305db\210\306 \306 \306 `\306 \212\fb\210n\206!\307\310\311\"\262
)\210\211?\205.\312\313!\210db\266\312\313!\210\314\315\311\"\207" [eshell-last-input-start eshell-last-input-end eshell-last-output-start eshell-last-output-block-begin eshell-last-output-end t point-marker #2="\n" eshell-output-filter nil run-hooks eshell-post-command-hook signal quit] 6 "\n\n(fn ERR)"] (debug error) 257 "\306db\210\307 \307 \307 `\307 \212
b\210n\206!\310\311\312\"\262
)\210\211?\205.\313\314!\210db\266\315
!\310P\311\312\"\266\313\314!\210\316\300\242!\207" [eshell-last-input-start eshell-last-input-end eshell-last-output-start eshell-last-output-block-begin eshell-last-output-end t point-marker #2# eshell-output-filter nil run-hooks eshell-post-command-hook error-message-string insert-and-inherit] 6 "\n\n(fn ERR)" eshell-last-input-end] 16 (#$ . 20071) "P"])
#@49 Add the last input text to the kill ring.

(fn)
(defalias 'eshell-kill-new #[0 "\302	\"\207" [eshell-last-input-start eshell-last-input-end kill-ring-save] 3 (#$ . 23114)])
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [byte-code "\300\301\302\303#\207" [put eshell-kill-new byte-optimizer byte-compile-inline-expand] 4 custom-add-option eshell-input-filter-functions eshell-kill-new] 4)
#@146 Send the output from PROCESS (STRING) to the interactive display.
This is done after all necessary filtering has been done.

(fn PROCESS STRING)
(defalias 'eshell-output-filter #[514 "
\203\n\306!\202p\307\310\n\211\203%\203%\211@!\262\211A\262
\202\210
\205\262\211\205\262\311
!\205\262\310\211\211rq\210`\262e\262d\262
\310G\310~\210\fb\210`\262
`X\203^\\\262`W\203i\\\262`X\203t\\\262\312!\210\313 `U\203\210\314\315 `Z\"\210`
U\203\225
\211Z\310\223\210
\310\223\210\f`\310\223\210\316 \210)\266

}\210b\210\317 )\266\203*\207" [after-change-functions inhibit-point-motion-hooks eshell-preoutput-filter-functions buffer-read-only eshell-last-output-end eshell-last-input-end process-buffer t nil buffer-name insert-before-markers window-start set-window-start selected-window force-mode-line-update eshell-run-output-filters eshell-last-output-start] 13 (#$ . 23517)])
#@71 Run the `eshell-output-filter-functions' on the current output.

(fn)
(defalias 'eshell-run-output-filters #[0 "r\302\303!\210)\304!\211\207" [eshell-last-output-end eshell-last-output-block-begin run-hooks eshell-output-filter-functions marker-position] 2 (#$ . 24445)])
#@371 Go to the end of buffer in all windows showing it.
Movement occurs if point in the selected window is not after the
process mark, and `this-command' is an insertion command.  Insertion
commands recognized are `self-insert-command', `yank', and
`hilit-yank'.  Depends on the value of
`eshell-scroll-to-bottom-on-input'.

This function should be a pre-command hook.

(fn)
(defalias 'eshell-preinput-scroll-to-bottom #[0 "\303>\2052\304 p	`\nW\2050\211\305=\203db\2020\306\307\310\311\312\313#\314\"\315\316%\317\320#\266\203\207" [this-command eshell-scroll-to-bottom-on-input eshell-last-output-end (self-insert-command yank hilit-yank) selected-window this walk-windows make-byte-code 257 "\303
!\301=\205\302\304=\204\302\305=\205\306
!\210db\210\306\300!\207" vconcat vector [window-buffer t all select-window] 3 "\n\n(fn WINDOW)" nil t] 12 (#$ . 24726)])
#@298 Go to the end of buffer in all windows showing it.
Does not scroll if the current line is the last line in the buffer.
Depends on the value of `eshell-scroll-to-bottom-on-output' and
`eshell-scroll-show-maximum-output'.

This function should be in the list `eshell-output-filter-functions'.

(fn)
(defalias 'eshell-postoutput-scroll-to-bottom #[0 "\301 p\302\303\304\305\306\307!\310\"\311\312%DC\216\313\303\314\315\306\307#\316\"\317\320%\321\322#)\207" [eshell-scroll-to-bottom-on-output selected-window funcall make-byte-code 0 "\300q\207" vconcat vector [] 1 "\n\n(fn)" walk-windows 257 "\306
!\301=\205U\307
!\210`W\203?\302\310=\204<\302\311=\204<\302\312=\203*\300
=\204<\302\313=\2036\300
=\203<`\fY\203?b\210
\203R`Y\203R\212db\210\314\315!\210)\307\300!\207" [eshell-last-output-end eshell-last-output-start eshell-scroll-show-maximum-output window-buffer select-window t all this others recenter -1] 3 "\n\n(fn WINDOW)" nil t] 12 (#$ . 25609)])
#@63 Return the location of the start of the previous input.

(fn)
(defalias 'eshell-beginning-of-input #[0 "\207" [eshell-last-input-start] 1 (#$ . 26595)])
#@68 Return the location of the end of the previous output block.

(fn)
(defalias 'eshell-beginning-of-output #[0 "\207" [eshell-last-input-end] 1 (#$ . 26755)])
#@68 Return the location of the end of the previous output block.

(fn)
(defalias 'eshell-end-of-output #[0 "\303\211>\262
\203	\207\n\207" [eshell-modules-list eshell-last-output-start eshell-last-output-end eshell-prompt] 3 (#$ . 26919)])
#@86 Kill all output from interpreter since last input.
Does not delete the prompt.

(fn)
(defalias 'eshell-kill-output #[0 "\212\300 b\210\301c\210`\302 |)\207" [eshell-beginning-of-output "*** output flushed ***\n" eshell-end-of-output] 2 (#$ . 27164) nil])
#@210 Display start of this batch of interpreter output at top of window.
Sets mark to the value of point when this command is run.
With a prefix argument, narrows region to last command output.

(fn &optional ARG)
(defalias 'eshell-show-output #[256 "\300 b\210\301\302 \212\303 b\210\304 )\"\210\211\203\300 \305 }\210\305 \207" [eshell-beginning-of-output set-window-start selected-window eshell-beginning-of-input line-beginning-position eshell-end-of-output] 4 (#$ . 27426) "P"])
#@210 Display start of this batch of interpreter output at top of window.
Sets mark to the value of point when this command is run.
With a prefix argument, narrows region to last command output.

(fn &optional ARG)
(defalias 'eshell-mark-output #[256 "\300\301!!\207" [push-mark eshell-show-output] 4 (#$ . 27914) "P"])
#@69 Kill all text from last stuff output by interpreter to point.

(fn)
(defalias 'eshell-kill-input #[0 "`V\203\301`\"\207`\302 \210\301`\"\207" [eshell-last-output-end kill-region eshell-bol] 4 (#$ . 28235) nil])
#@132 Put the end of the buffer at the bottom of the window.
When run interactively, widen the buffer first.

(fn &optional INTERACTIVE)
(defalias 'eshell-show-maximum-output #[256 "\211\203~\210db\210\300\301!\207" [recenter -1] 3 (#$ . 28458) "p"])
#@82 Return the command input on the current line.

(fn &optional USE-CURRENT-REGION)
(defalias 'eshell-get-old-input #[256 "\211\203`\301 ^`\301 ]{\207\212\302 \210\203 \210`\303\210\211`{\262
)\207" [eshell-skip-prompt-function mark beginning-of-line nil] 4 (#$ . 28711)])
#@73 Insert after prompt old input at point as new input to be edited.

(fn)
(defalias 'eshell-copy-old-input #[0 "\301 b\210\302
!\207" [eshell-last-output-end eshell-get-old-input insert-and-inherit] 3 (#$ . 28994) nil])
#@76 Leave or kill the Eshell buffer, depending on `eshell-kill-on-exit'.

(fn)
(defalias 'eshell/exit #[0 "\300\301\302\"\207" [throw eshell-terminal t] 3 (#$ . 29219)])
#@63 Kill the current buffer (or bury it).  Good-bye Eshell.

(fn)
(defalias 'eshell-life-is-too-much #[0 "\204\301 \207\302p!\207" [eshell-kill-on-exit bury-buffer kill-buffer] 2 (#$ . 29391) nil])
#@139 Truncate the buffer to `eshell-buffer-maximum-lines'.
This function could be on `eshell-output-filter-functions' or bound to
a key.

(fn)
(defalias 'eshell-truncate-buffer #[0 "\212b\210\303\304`\"\305\n[y\210\306 \210`o\203\"\307\310!\2054\311\312!\2024e`|\210\307\310!\2054\311\313\n\314\245$\262
)\262
)\207" [eshell-last-output-end inhibit-read-only eshell-buffer-maximum-lines count-lines 1 t beginning-of-line called-interactively-p interactive message "Buffer too short to truncate" "Truncated buffer from %d to %d lines (%.1fk freed)" 1024.0] 8 (#$ . 29595) nil])
(custom-add-option 'eshell-output-filter-functions 'eshell-truncate-buffer)
#@97 Read a string without echoing.
Then send it to the process running in the current buffer.

(fn)
(defalias 'eshell-send-invisible #[0 "\301\302\303\304!\"!\211;\203\305\306P\"\202\307\310!\207" [eshell-last-async-proc read-passwd format "%s Password: " process-name process-send-string "\n" message "Warning: text will be echoed"] 5 (#$ . 30257) nil])
#@317 Prompt in the minibuffer for password and send without echoing.
This function uses `eshell-send-invisible' to read and send a password to the
buffer's process if STRING contains a password prompt defined by
`eshell-password-prompt-regexp'.

This function could be in the list `eshell-output-filter-functions'.

(fn)
(defalias 'eshell-watch-for-password-prompt #[0 "\205\212\305\nb\210\306 \210\307\f\305#\205\310 *\207" [eshell-last-async-proc case-fold-search eshell-last-output-block-begin eshell-password-prompt-regexp eshell-last-output-end t beginning-of-line re-search-forward eshell-send-invisible] 4 (#$ . 30622)])
(custom-add-option 'eshell-output-filter-functions 'eshell-watch-for-password-prompt)
#@57 Act properly when certain control codes are seen.

(fn)
(defalias 'eshell-handle-control-codes #[0 "\212b\210l\204\302 \210`	W\205o\303f\211\304=\203I`T	W\203<`Tf\305>\203/\306\307!\210\202k`T\302 \210`
|\266\202k\310``T\311#\210\303u\210\202k\211\312=\203Y\306\307!\210\313 \210\202k\211\314=\203h`S`T|\210\202k\303u\210\210\202)\207" [eshell-last-output-block-begin eshell-last-output-end beginning-of-line nil 13 (10 13) delete-char 1 add-text-properties (invisible t) 7 beep 8] 5 (#$ . 31344)])
(byte-code "\300\301\302\"\210\303\304\305\"\207" [custom-add-option eshell-output-filter-functions eshell-handle-control-codes autoload ansi-color-apply-on-region "ansi-color"] 3)
#@32 Handle ANSI color codes.

(fn)
(defalias 'eshell-handle-ansi-color #[0 "\302	\"\207" [eshell-last-output-start eshell-last-output-end ansi-color-apply-on-region] 3 (#$ . 32047)])
(custom-add-option 'eshell-output-filter-functions 'eshell-handle-ansi-color)