| 1 | ;;; eshell.el --- the Emacs command shell |
| 2 | |
| 3 | ;; Copyright (C) 1999-2011 Free Software Foundation, Inc. |
| 4 | |
| 5 | ;; Author: John Wiegley <johnw@gnu.org> |
| 6 | ;; Version: 2.4.2 |
| 7 | ;; Keywords: processes |
| 8 | |
| 9 | ;; This file is part of GNU Emacs. |
| 10 | |
| 11 | ;; GNU Emacs is free software: you can redistribute it and/or modify |
| 12 | ;; it under the terms of the GNU General Public License as published by |
| 13 | ;; the Free Software Foundation, either version 3 of the License, or |
| 14 | ;; (at your option) any later version. |
| 15 | |
| 16 | ;; GNU Emacs is distributed in the hope that it will be useful, |
| 17 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 18 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 19 | ;; GNU General Public License for more details. |
| 20 | |
| 21 | ;; You should have received a copy of the GNU General Public License |
| 22 | ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. |
| 23 | |
| 24 | ;;; Commentary: |
| 25 | |
| 26 | ;;;_* What does Eshell offer you? |
| 27 | ;; |
| 28 | ;; Despite the sheer fact that running an Emacs shell can be fun, here |
| 29 | ;; are a few of the unique features offered by Eshell: |
| 30 | ;; |
| 31 | ;; @ Integration with the Emacs Lisp programming environment |
| 32 | ;; |
| 33 | ;; @ A high degree of configurability |
| 34 | ;; |
| 35 | ;; @ The ability to have the same shell on every system Emacs has been |
| 36 | ;; ported to. Since Eshell imposes no external requirements, and |
| 37 | ;; relies upon only the Lisp functions exposed by Emacs, it is quite |
| 38 | ;; operating system independent. Several of the common UNIX |
| 39 | ;; commands, such as ls, mv, rm, ln, etc., have been implemented in |
| 40 | ;; Lisp in order to provide a more consistent work environment. |
| 41 | ;; |
| 42 | ;; For those who might be using an older version of Eshell, version |
| 43 | ;; 2.1 represents an entirely new, module-based architecture. It |
| 44 | ;; supports most of the features offered by modern shells. Here is a |
| 45 | ;; brief list of some of its more visible features: |
| 46 | ;; |
| 47 | ;; @ Command argument completion (tcsh, zsh) |
| 48 | ;; @ Input history management (bash) |
| 49 | ;; @ Intelligent output scrolling |
| 50 | ;; @ Pseudo-devices (such as "/dev/clip" for copying to the clipboard) |
| 51 | ;; @ Extended globbing (zsh) |
| 52 | ;; @ Argument and globbing predication (zsh) |
| 53 | ;; @ I/O redirection to buffers, files, symbols, processes, etc. |
| 54 | ;; @ Many niceties otherwise seen only in 4DOS |
| 55 | ;; @ Alias functions, both Lisp and Eshell-syntax |
| 56 | ;; @ Piping, sequenced commands, background jobs, etc... |
| 57 | ;; |
| 58 | ;;;_* How to begin |
| 59 | ;; |
| 60 | ;; To start using Eshell, simply type `M-x eshell'. |
| 61 | ;; |
| 62 | ;;;_* Philosophy |
| 63 | ;; |
| 64 | ;; A shell is a layer which metaphorically surrounds the kernel, or |
| 65 | ;; heart of an operating system. This kernel can be seen as an engine |
| 66 | ;; of pure functionality, waiting to serve, while the user programs |
| 67 | ;; take advantage of that functionality to accomplish their purpose. |
| 68 | ;; |
| 69 | ;; The shell's role is to make that functionality accessible to the |
| 70 | ;; user in an unformed state. Very roughly, it associates kernel |
| 71 | ;; functionality with textual commands, allowing the user to interact |
| 72 | ;; with the operating system via linguistic constructs. Process |
| 73 | ;; invocation is perhaps the most significant form this takes, using |
| 74 | ;; the kernel's `fork' and `exec' functions. |
| 75 | ;; |
| 76 | ;; Other programs also interact with the functionality of the kernel, |
| 77 | ;; but these user applications typically offer a specific range of |
| 78 | ;; functionality, and thus are not classed as "shells" proper. |
| 79 | ;; (What they lose in quiddity, they gain in rigidity). |
| 80 | ;; |
| 81 | ;; Emacs is also a user application, but it does make the |
| 82 | ;; functionality of the kernel accessible through an interpreted |
| 83 | ;; language -- namely, Lisp. For that reason, there is little |
| 84 | ;; preventing Emacs from serving the same role as a modern shell. It |
| 85 | ;; too can manipulate the kernel in an unpredetermined way to cause |
| 86 | ;; system changes. All it's missing is the shell-ish linguistic |
| 87 | ;; model. |
| 88 | ;; |
| 89 | ;; Enter Eshell. Eshell translates "shell-like" syntax into Lisp |
| 90 | ;; in order to exercise the kernel in the same manner as typical |
| 91 | ;; system shells. There is a fundamental difference here, however, |
| 92 | ;; although it may seem subtle at first... |
| 93 | ;; |
| 94 | ;; Shells like csh and Bourne shell were written several decades ago, |
| 95 | ;; in different times, under more restrictive circumstances. This |
| 96 | ;; confined perspective shows itself in the paradigm used by nearly |
| 97 | ;; all command-line shells since. They are linear in conception, byte |
| 98 | ;; stream-based, sequential, and confined to movement within a single |
| 99 | ;; host machine. |
| 100 | ;; |
| 101 | ;; Emacs, on the other hand, is more than just a limited translator |
| 102 | ;; that can invoke subprocesses and redirect file handles. It also |
| 103 | ;; manages character buffers, windowing frames, network connections, |
| 104 | ;; registers, bookmarks, processes, etc. In other words, it's a very |
| 105 | ;; multi-dimensional environment, within which eshell emulates a highly |
| 106 | ;; linear methodology. |
| 107 | ;; |
| 108 | ;; Taking a moment, let's look at how this could affect the future of |
| 109 | ;; a shell allowed to develop in such a wider field of play: |
| 110 | ;; |
| 111 | ;; @ There is no reason why directory movement should be linear, and |
| 112 | ;; confined to a single file-system. Emacs, through w3 and ange-ftp, |
| 113 | ;; has access to the entire Web. Why not allow a user to cd to |
| 114 | ;; multiple directories simultaneously, for example? It might make |
| 115 | ;; some tasks easier, such as diff'ing files separated by very long |
| 116 | ;; pathnames. |
| 117 | ;; |
| 118 | ;; @ Data sources are available from anywhere Emacs can derive |
| 119 | ;; information from: not just from files or the output of other |
| 120 | ;; processes. |
| 121 | ;; |
| 122 | ;; @ Multiple shell invocations all share the same environment -- even |
| 123 | ;; the same process list! It would be possible to have "process |
| 124 | ;; views", so that one buffer is watching standard output, another |
| 125 | ;; standard error, and another the result of standard output grep'd |
| 126 | ;; through a regular expression... |
| 127 | ;; |
| 128 | ;; @ It is not necessary to "leave" the shell, losing all input and |
| 129 | ;; output history, environment variables, directory stack, etc. |
| 130 | ;; Emacs could save the contents of your eshell environment, and |
| 131 | ;; restore all of it (or at least as much as possible) each time you |
| 132 | ;; restart. This could occur automatically, without requiring |
| 133 | ;; complex initialization scripts. |
| 134 | ;; |
| 135 | ;; @ Typos occur all of the time; many of them are repeats of common |
| 136 | ;; errors, such as 'dri' for `dir'. Since executing non-existent |
| 137 | ;; programs is rarely the intention of the user, eshell could prompt |
| 138 | ;; for the replacement string, and then record that in a database of |
| 139 | ;; known misspellings. (Note: The typo at the beginning of this |
| 140 | ;; paragraph wasn't discovered until two months after I wrote the |
| 141 | ;; text; it was not intentional). |
| 142 | ;; |
| 143 | ;; @ Emacs' register and bookmarking facilities can be used for |
| 144 | ;; remembering where you've been, and what you've seen -- to varying |
| 145 | ;; levels of persistence. They could perhaps even be tied to |
| 146 | ;; specific "moments" during eshell execution, which would include |
| 147 | ;; the environment at that time, as well as other variables. |
| 148 | ;; Although this would require functionality orthogonal to Emacs' |
| 149 | ;; own bookmarking facilities, the interface used could be made to |
| 150 | ;; operate very similarly. |
| 151 | ;; |
| 152 | ;; This presents a brief idea of what the fuller dimensionality of an |
| 153 | ;; Emacs shell could offer. It's not just the language of a shell |
| 154 | ;; that determines how it's used, but also the Weltanschauung |
| 155 | ;; underlying its design -- and which is felt behind even the smallest |
| 156 | ;; feature. I would hope the freedom provided by using Emacs as a |
| 157 | ;; parent environment will invite rich ideas from others. It |
| 158 | ;; certainly feels as though all I've done so far is to tie down the |
| 159 | ;; horse, so to speak, so that he will run at a man's pace. |
| 160 | ;; |
| 161 | ;;;_* Influences |
| 162 | ;; |
| 163 | ;; The author of Eshell has been a long-time user of the following |
| 164 | ;; shells, all of which contributed to Eshell's design: |
| 165 | ;; |
| 166 | ;; @ rc |
| 167 | ;; @ bash |
| 168 | ;; @ zsh |
| 169 | ;; @ sh |
| 170 | ;; @ 4nt |
| 171 | ;; @ csh |
| 172 | |
| 173 | ;;;_* Speeding up load time |
| 174 | ;; |
| 175 | ;; If you find that Eshell loads too slowly, there is something you |
| 176 | ;; can do to speed it up. |
| 177 | ;; |
| 178 | ;; Create a file, named /tmp/elc, containing this filelist: |
| 179 | ;; |
| 180 | ;; esh-util.elc |
| 181 | ;; eshell.elc |
| 182 | ;; esh-module.elc |
| 183 | ;; esh-var.elc |
| 184 | ;; esh-proc.elc |
| 185 | ;; esh-arg.elc |
| 186 | ;; esh-io.elc |
| 187 | ;; esh-ext.elc |
| 188 | ;; esh-cmd.elc |
| 189 | ;; esh-mode.elc |
| 190 | ;; esh-opt.elc |
| 191 | ;; em-alias.elc |
| 192 | ;; em-banner.elc |
| 193 | ;; em-basic.elc |
| 194 | ;; em-cmpl.elc |
| 195 | ;; em-dirs.elc |
| 196 | ;; em-pred.elc |
| 197 | ;; em-glob.elc |
| 198 | ;; em-hist.elc |
| 199 | ;; em-ls.elc |
| 200 | ;; em-prompt.elc |
| 201 | ;; em-rebind.elc |
| 202 | ;; em-script.elc |
| 203 | ;; em-smart.elc |
| 204 | ;; em-term.elc |
| 205 | ;; em-unix.elc |
| 206 | ;; em-xtra.elc |
| 207 | ;; |
| 208 | ;; The order is very important. Remove from the filelist any features |
| 209 | ;; you don't use. These all begin with "em-". If you don't use |
| 210 | ;; Eshell's key rebinding module, you can remove "em-rebind.elc" from |
| 211 | ;; the filelist. The modules you are currently using are listed in |
| 212 | ;; `eshell-modules-list'. |
| 213 | ;; |
| 214 | ;; Now, concatenating all of the above mentioned .elc files, in that |
| 215 | ;; order, to another file. Here is how to do this on UNIX: |
| 216 | ;; |
| 217 | ;; cat `cat /tmp/elc` > tmp.elc ; mv tmp.elc eshell.elc |
| 218 | ;; |
| 219 | ;; Now your eshell.elc file contains all of the .elc files that make |
| 220 | ;; up Eshell, in the right load order. When you next load Eshell, it |
| 221 | ;; will only have to read in this one file, which will greatly speed |
| 222 | ;; things up. |
| 223 | |
| 224 | (eval-when-compile |
| 225 | (require 'cl) |
| 226 | (require 'esh-util)) |
| 227 | (require 'esh-util) |
| 228 | (require 'esh-mode) |
| 229 | |
| 230 | (defgroup eshell nil |
| 231 | "A command shell implemented entirely in Emacs Lisp. |
| 232 | It invokes no external processes beyond those requested by the |
| 233 | user, and is intended to be a functional replacement for command |
| 234 | shells such as bash, zsh, rc, 4dos." |
| 235 | :tag "The Emacs shell" |
| 236 | :link '(info-link "(eshell)Top") |
| 237 | :version "21.1" |
| 238 | :group 'applications) |
| 239 | |
| 240 | ;; This is hack to force make-autoload to put the whole definition |
| 241 | ;; into the autoload file (see esh-module.el). |
| 242 | (defalias 'eshell-defgroup 'defgroup) |
| 243 | |
| 244 | ;;;_* User Options |
| 245 | ;; |
| 246 | ;; The following user options modify the behavior of Eshell overall. |
| 247 | (defvar eshell-buffer-name) |
| 248 | |
| 249 | (defsubst eshell-add-to-window-buffer-names () |
| 250 | "Add `eshell-buffer-name' to `same-window-buffer-names'." |
| 251 | (add-to-list 'same-window-buffer-names eshell-buffer-name)) |
| 252 | |
| 253 | (defsubst eshell-remove-from-window-buffer-names () |
| 254 | "Remove `eshell-buffer-name' from `same-window-buffer-names'." |
| 255 | (setq same-window-buffer-names |
| 256 | (delete eshell-buffer-name same-window-buffer-names))) |
| 257 | |
| 258 | (defcustom eshell-load-hook nil |
| 259 | "A hook run once Eshell has been loaded." |
| 260 | :type 'hook |
| 261 | :group 'eshell) |
| 262 | |
| 263 | (defcustom eshell-unload-hook |
| 264 | '(eshell-remove-from-window-buffer-names |
| 265 | eshell-unload-all-modules) |
| 266 | "A hook run when Eshell is unloaded from memory." |
| 267 | :type 'hook |
| 268 | :group 'eshell) |
| 269 | |
| 270 | (defcustom eshell-buffer-name "*eshell*" |
| 271 | "The basename used for Eshell buffers." |
| 272 | :set (lambda (symbol value) |
| 273 | ;; remove the old value of `eshell-buffer-name', if present |
| 274 | (if (boundp 'eshell-buffer-name) |
| 275 | (eshell-remove-from-window-buffer-names)) |
| 276 | (set symbol value) |
| 277 | ;; add the new value |
| 278 | (eshell-add-to-window-buffer-names) |
| 279 | value) |
| 280 | :type 'string |
| 281 | :group 'eshell) |
| 282 | |
| 283 | (eshell-deftest mode same-window-buffer-names |
| 284 | "`eshell-buffer-name' is a member of `same-window-buffer-names'" |
| 285 | (member eshell-buffer-name same-window-buffer-names)) |
| 286 | |
| 287 | (defcustom eshell-directory-name |
| 288 | (locate-user-emacs-file "eshell/" ".eshell/") |
| 289 | "The directory where Eshell control files should be kept." |
| 290 | :type 'directory |
| 291 | :group 'eshell) |
| 292 | |
| 293 | (eshell-deftest mode eshell-directory-exists |
| 294 | "`eshell-directory-name' exists and is writable" |
| 295 | (file-writable-p eshell-directory-name)) |
| 296 | |
| 297 | (eshell-deftest mode eshell-directory-modes |
| 298 | "`eshell-directory-name' has correct access protections" |
| 299 | (or (eshell-under-windows-p) |
| 300 | (= (file-modes eshell-directory-name) |
| 301 | eshell-private-directory-modes))) |
| 302 | |
| 303 | ;;;_* Running Eshell |
| 304 | ;; |
| 305 | ;; There are only three commands used to invoke Eshell. The first two |
| 306 | ;; are intended for interactive use, while the third is meant for |
| 307 | ;; programmers. They are: |
| 308 | |
| 309 | ;;;###autoload |
| 310 | (defun eshell (&optional arg) |
| 311 | "Create an interactive Eshell buffer. |
| 312 | The buffer used for Eshell sessions is determined by the value of |
| 313 | `eshell-buffer-name'. If there is already an Eshell session active in |
| 314 | that buffer, Emacs will simply switch to it. Otherwise, a new session |
| 315 | will begin. A numeric prefix arg (as in `C-u 42 M-x eshell RET') |
| 316 | switches to the session with that number, creating it if necessary. A |
| 317 | nonnumeric prefix arg means to create a new session. Returns the |
| 318 | buffer selected (or created)." |
| 319 | (interactive "P") |
| 320 | (assert eshell-buffer-name) |
| 321 | (let ((buf (cond ((numberp arg) |
| 322 | (get-buffer-create (format "%s<%d>" |
| 323 | eshell-buffer-name |
| 324 | arg))) |
| 325 | (arg |
| 326 | (generate-new-buffer eshell-buffer-name)) |
| 327 | (t |
| 328 | (get-buffer-create eshell-buffer-name))))) |
| 329 | ;; Simply calling `pop-to-buffer' will not mimic the way that |
| 330 | ;; shell-mode buffers appear, since they always reuse the same |
| 331 | ;; window that that command was invoked from. To achieve this, |
| 332 | ;; it's necessary to add `eshell-buffer-name' to the variable |
| 333 | ;; `same-window-buffer-names', which is done when Eshell is loaded |
| 334 | (assert (and buf (buffer-live-p buf))) |
| 335 | (pop-to-buffer buf) |
| 336 | (unless (eq major-mode 'eshell-mode) |
| 337 | (eshell-mode)) |
| 338 | buf)) |
| 339 | |
| 340 | (defun eshell-return-exits-minibuffer () |
| 341 | (define-key eshell-mode-map [(control ?g)] 'abort-recursive-edit) |
| 342 | (define-key eshell-mode-map [return] 'exit-minibuffer) |
| 343 | (define-key eshell-mode-map [(control ?m)] 'exit-minibuffer) |
| 344 | (define-key eshell-mode-map [(control ?j)] 'exit-minibuffer) |
| 345 | (define-key eshell-mode-map [(meta return)] 'exit-minibuffer) |
| 346 | (define-key eshell-mode-map [(meta control ?m)] 'exit-minibuffer)) |
| 347 | |
| 348 | (defvar eshell-non-interactive-p nil |
| 349 | "A variable which is non-nil when Eshell is not running interactively. |
| 350 | Modules should use this variable so that they don't clutter |
| 351 | non-interactive sessions, such as when using `eshell-command'.") |
| 352 | |
| 353 | ;;;###autoload |
| 354 | (defun eshell-command (&optional command arg) |
| 355 | "Execute the Eshell command string COMMAND. |
| 356 | With prefix ARG, insert output into the current buffer at point." |
| 357 | (interactive) |
| 358 | (require 'esh-cmd) |
| 359 | (unless arg |
| 360 | (setq arg current-prefix-arg)) |
| 361 | (unwind-protect |
| 362 | (let ((eshell-non-interactive-p t)) |
| 363 | (add-hook 'minibuffer-setup-hook 'eshell-mode) |
| 364 | (add-hook 'minibuffer-exit-hook 'eshell-add-command-to-history) |
| 365 | (add-hook 'eshell-mode-hook 'eshell-return-exits-minibuffer) |
| 366 | (unless command |
| 367 | (setq command (read-from-minibuffer "Emacs shell command: ")))) |
| 368 | (remove-hook 'eshell-mode-hook 'eshell-return-exits-minibuffer) |
| 369 | (remove-hook 'minibuffer-exit-hook 'eshell-add-command-to-history) |
| 370 | (remove-hook 'minibuffer-setup-hook 'eshell-mode)) |
| 371 | (unless command |
| 372 | (error "No command specified!")) |
| 373 | ;; redirection into the current buffer is achieved by adding an |
| 374 | ;; output redirection to the end of the command, of the form |
| 375 | ;; 'COMMAND >>> #<buffer BUFFER>'. This will not interfere with |
| 376 | ;; other redirections, since multiple redirections merely cause the |
| 377 | ;; output to be copied to multiple target locations |
| 378 | (if arg |
| 379 | (setq command |
| 380 | (concat command |
| 381 | (format " >>> #<buffer %s>" |
| 382 | (buffer-name (current-buffer)))))) |
| 383 | (save-excursion |
| 384 | (let ((buf (set-buffer (generate-new-buffer " *eshell cmd*"))) |
| 385 | (eshell-non-interactive-p t)) |
| 386 | (eshell-mode) |
| 387 | (let* ((proc (eshell-eval-command |
| 388 | (list 'eshell-commands |
| 389 | (eshell-parse-command command)))) |
| 390 | intr |
| 391 | (bufname (if (and proc (listp proc)) |
| 392 | "*EShell Async Command Output*" |
| 393 | (setq intr t) |
| 394 | "*EShell Command Output*"))) |
| 395 | (if (buffer-live-p (get-buffer bufname)) |
| 396 | (kill-buffer bufname)) |
| 397 | (rename-buffer bufname) |
| 398 | ;; things get a little coarse here, since the desire is to |
| 399 | ;; make the output as attractive as possible, with no |
| 400 | ;; extraneous newlines |
| 401 | (when intr |
| 402 | (if (eshell-interactive-process) |
| 403 | (eshell-wait-for-process (eshell-interactive-process))) |
| 404 | (assert (not (eshell-interactive-process))) |
| 405 | (goto-char (point-max)) |
| 406 | (while (and (bolp) (not (bobp))) |
| 407 | (delete-char -1))) |
| 408 | (assert (and buf (buffer-live-p buf))) |
| 409 | (unless arg |
| 410 | (let ((len (if (not intr) 2 |
| 411 | (count-lines (point-min) (point-max))))) |
| 412 | (cond |
| 413 | ((= len 0) |
| 414 | (message "(There was no command output)") |
| 415 | (kill-buffer buf)) |
| 416 | ((= len 1) |
| 417 | (message "%s" (buffer-string)) |
| 418 | (kill-buffer buf)) |
| 419 | (t |
| 420 | (save-selected-window |
| 421 | (select-window (display-buffer buf)) |
| 422 | (goto-char (point-min)) |
| 423 | ;; cause the output buffer to take up as little screen |
| 424 | ;; real-estate as possible, if temp buffer resizing is |
| 425 | ;; enabled |
| 426 | (and intr temp-buffer-resize-mode |
| 427 | (resize-temp-buffer-window))))))))))) |
| 428 | |
| 429 | ;;;###autoload |
| 430 | (defun eshell-command-result (command &optional status-var) |
| 431 | "Execute the given Eshell COMMAND, and return the result. |
| 432 | The result might be any Lisp object. |
| 433 | If STATUS-VAR is a symbol, it will be set to the exit status of the |
| 434 | command. This is the only way to determine whether the value returned |
| 435 | corresponding to a successful execution." |
| 436 | ;; a null command produces a null, successful result |
| 437 | (if (not command) |
| 438 | (ignore |
| 439 | (if (and status-var (symbolp status-var)) |
| 440 | (set status-var 0))) |
| 441 | (with-temp-buffer |
| 442 | (let ((eshell-non-interactive-p t)) |
| 443 | (eshell-mode) |
| 444 | (let ((result (eshell-do-eval |
| 445 | (list 'eshell-commands |
| 446 | (list 'eshell-command-to-value |
| 447 | (eshell-parse-command command))) t))) |
| 448 | (assert (eq (car result) 'quote)) |
| 449 | (if (and status-var (symbolp status-var)) |
| 450 | (set status-var eshell-last-command-status)) |
| 451 | (cadr result)))))) |
| 452 | |
| 453 | (eshell-deftest mode simple-command-result |
| 454 | "`eshell-command-result' works with a simple command." |
| 455 | (= (eshell-command-result "+ 1 2") 3)) |
| 456 | |
| 457 | ;;;_* Reporting bugs |
| 458 | ;; |
| 459 | ;; If you do encounter a bug, on any system, please report |
| 460 | ;; it -- in addition to any particular oddities in your configuration |
| 461 | ;; -- so that the problem may be corrected for the benefit of others. |
| 462 | |
| 463 | ;;;###autoload |
| 464 | (define-obsolete-function-alias 'eshell-report-bug 'report-emacs-bug "23.1") |
| 465 | |
| 466 | ;;; Code: |
| 467 | |
| 468 | (defun eshell-unload-all-modules () |
| 469 | "Unload all modules that were loaded by Eshell, if possible. |
| 470 | If the user has require'd in any of the modules, or customized a |
| 471 | variable with a :require tag (such as `eshell-prefer-to-shell'), it |
| 472 | will be impossible to unload Eshell completely without restarting |
| 473 | Emacs." |
| 474 | ;; if the user set `eshell-prefer-to-shell' to t, but never loaded |
| 475 | ;; Eshell, then `eshell-subgroups' will be unbound |
| 476 | (when (fboundp 'eshell-subgroups) |
| 477 | (eshell-for module (eshell-subgroups 'eshell) |
| 478 | ;; this really only unloads as many modules as possible, |
| 479 | ;; since other `require' references (such as by customizing |
| 480 | ;; `eshell-prefer-to-shell' to a non-nil value) might make it |
| 481 | ;; impossible to unload Eshell completely |
| 482 | (if (featurep module) |
| 483 | (ignore-errors |
| 484 | (message "Unloading %s..." (symbol-name module)) |
| 485 | (unload-feature module) |
| 486 | (message "Unloading %s...done" (symbol-name module))))) |
| 487 | (message "Unloading eshell...done"))) |
| 488 | |
| 489 | (run-hooks 'eshell-load-hook) |
| 490 | |
| 491 | (provide 'eshell) |
| 492 | |
| 493 | ;;; eshell.el ends here |