Mercurial > emacs
view lisp/eshell/eshell.el @ 110523:a5ad4f188e19
Synch Semantic to CEDET 1.0.
Move CEDET ChangeLog entries to new file lisp/cedet/ChangeLog.
* semantic.el (semantic-version): Update to 2.0.
(semantic-mode-map): Add "," and "m" bindings.
(navigate-menu): Update.
* semantic/symref.el (semantic-symref-calculate-rootdir):
New function.
(semantic-symref-detect-symref-tool): Use it.
* semantic/symref/grep.el (semantic-symref-grep-shell): New var.
(semantic-symref-perform-search): Use it. Calculate root dir with
semantic-symref-calculate-rootdir.
(semantic-symref-derive-find-filepatterns): Improve error message.
* semantic/symref/list.el
(semantic-symref-results-mode-map): New bindings.
(semantic-symref-auto-expand-results): New option.
(semantic-symref-results-dump): Obey auto-expand.
(semantic-symref-list-expand-all, semantic-symref-regexp)
(semantic-symref-list-contract-all)
(semantic-symref-list-map-open-hits)
(semantic-symref-list-update-open-hits)
(semantic-symref-list-create-macro-on-open-hit)
(semantic-symref-list-call-macro-on-open-hits): New functions.
(semantic-symref-list-menu-entries)
(semantic-symref-list-menu): New vars.
(semantic-symref-list-map-open-hits): Move cursor to beginning of
match before calling the mapped function.
* semantic/doc.el
(semantic-documentation-comment-preceeding-tag): Do nothing if the
mode doesn't provide comment-start-skip.
* semantic/scope.el
(semantic-analyze-scope-nested-tags-default): Strip duplicates.
(semantic-analyze-scoped-inherited-tag-map): Take the tag we are
looking for as part of the scoped tags list.
* semantic/html.el (semantic-default-html-setup): Add
senator-step-at-tag-classes.
* semantic/decorate/include.el
(semantic-decoration-on-unknown-includes): Change light bgcolor.
(semantic-decoration-on-includes-highlight-default): Check that
the include tag has a postion.
* semantic/complete.el (semantic-collector-local-members):
(semantic-complete-read-tag-local-members)
(semantic-complete-jump-local-members): New class and functions.
(semantic-complete-self-insert): Save excursion before completing.
* semantic/analyze/complete.el
(semantic-analyze-possible-completions-default): If no completions
are found, return the raw by-name-only completion list. Add FLAGS
arguments. Add support for 'no-tc (type constraint) and
'no-unique, or no stripping duplicates.
(semantic-analyze-possible-completions-default): Add FLAGS arg.
* semantic/util-modes.el
(semantic-stickyfunc-show-only-functions-p): New option.
(semantic-stickyfunc-fetch-stickyline): Don't show stickytext for
the very first line in a buffer.
* semantic/util.el (semantic-hack-search)
(semantic-recursive-find-nonterminal-by-name)
(semantic-current-tag-interactive): Deleted.
(semantic-describe-buffer): Fix expand-nonterminal. Add
lex-syntax-mods, type relation separator char, and command
separation char.
(semantic-sanity-check): Only message if called interactively.
* semantic/tag.el (semantic-tag-deep-copy-one-tag): Copy the
:filename property and the tag position.
* semantic/lex-spp.el (semantic-lex-spp-lex-text-string):
Add recursion limit.
* semantic/imenu.el (semantic-imenu-bucketize-type-members):
Make this buffer local, not the obsoleted variable.
* semantic/idle.el: Add breadcrumbs support.
(semantic-idle-summary-current-symbol-info-default)
(semantic-idle-tag-highlight)
(semantic-idle-completion-list-default): Use
semanticdb-without-unloaded-file-searches for speed, and to
conform to the controls that specify if the idle timer is supposed
to be parsing unparsed includes.
(semantic-idle-symbol-highlight-face)
(semantic-idle-symbol-maybe-highlight): Rename from *-summary-*.
Callers changed.
(semantic-idle-work-parse-neighboring-files-flag): Default to nil.
(semantic-idle-work-update-headers-flag): New var.
(semantic-idle-work-for-one-buffer): Use it.
(semantic-idle-local-symbol-highlight): Rename from
semantic-idle-tag-highlight.
(semantic-idle-truncate-long-summaries): New option.
* semantic/ia.el (semantic-ia-cache)
(semantic-ia-get-completions): Deleted. Callers changed.
(semantic-ia-show-variants): New command.
(semantic-ia-show-doc): If doc is empty, don't make a temp buffer.
(semantic-ia-show-summary): If there isn't anything to show, say so.
* semantic/grammar.el (semantic-grammar-create-package):
Save the buffer even in batch mode.
* semantic/fw.el
(semanticdb-without-unloaded-file-searches): New macro.
* semantic/dep.el (semantic-dependency-find-file-on-path):
Fix case dereferencing ede-object when it is a list.
* semantic/db-typecache.el (semanticdb-expand-nested-tag)
(semanticdb-typecache-faux-namespace): New functions.
(semanticdb-typecache-file-tags)
(semanticdb-typecache-merge-streams): Use them.
(semanticdb-typecache-file-tags): When deriving tags from a file,
give the mode a chance to monkey with the tag copy.
(semanticdb-typecache-find-default): Wrap find in save-excursion.
(semanticdb-typecache-find-by-name-helper): Merge found names down.
* semantic/db-global.el
(semanticdb-enable-gnu-global-in-buffer): Don't show messages if
GNU Global is not available and we don't want to throw an error.
* semantic/db-find.el (semanticdb-find-result-nth-in-buffer):
When trying to normalize the tag to a buffer, don't error if
set-buffer method doesn't exist.
* semantic/db-file.el (semanticdb-save-db): Simplify msg.
* semantic/db.el (semanticdb-refresh-table): If forcing a
refresh on a file not in a buffer, use semantic-find-file-noselect
and delete the buffer after use.
(semanticdb-current-database-list): When calculating root via
hooks, force it through true-filename and skip the list of
possible roots.
* semantic/ctxt.el (semantic-ctxt-imported-packages): New.
* semantic/analyze/debug.el
(semantic-analyzer-debug-insert-tag): Reset standard output to
current buffer.
(semantic-analyzer-debug-global-symbol)
(semantic-analyzer-debug-missing-innertype): Change "prefix" to
"symbol" in messages.
* semantic/analyze/refs.el: (semantic-analyze-refs-impl)
(semantic-analyze-refs-proto): When calculating value, make sure
the found tag is 'similar' to the originating tag.
(semantic--analyze-refs-find-tags-with-parent): Attempt to
identify matches via imported symbols of parents.
(semantic--analyze-refs-full-lookup-with-parents): Do a deep
search during the brute search.
* semantic/analyze.el
(semantic-analyze-find-tag-sequence-default): Be robust to
calculated scopes being nil.
* semantic/bovine/c.el (semantic-c-describe-environment): Add
project macro symbol array.
(semantic-c-parse-lexical-token): Add recursion limit.
(semantic-ctxt-imported-packages, semanticdb-expand-nested-tag):
New overrides.
(semantic-expand-c-tag-namelist): Split a full type from a typedef
out to its own tag.
(semantic-expand-c-tag-namelist): Do not split out a typedef'd
inline type if it is an anonymous type.
(semantic-c-reconstitute-token): Use the optional initializers as
a clue that some function is probably a constructor. When
defining the type of these constructors, split the parent name,
and use only the class part, if applicable.
* semantic/bovine/c-by.el:
* semantic/wisent/python-wy.el: Regenerate.
author | Chong Yidong <cyd@stupidchicken.com> |
---|---|
date | Sat, 18 Sep 2010 22:49:54 -0400 |
parents | f9121af0ebc9 |
children | d835100c3e8b 376148b31b5e |
line wrap: on
line source
;;; eshell.el --- the Emacs command shell ;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, ;; 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. ;; Author: John Wiegley <johnw@gnu.org> ;; Version: 2.4.2 ;; Keywords: processes ;; This file is part of GNU Emacs. ;; GNU Emacs is free software: you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by ;; the Free Software Foundation, either version 3 of the License, or ;; (at your option) any later version. ;; GNU Emacs is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; GNU General Public License for more details. ;; You should have received a copy of the GNU General Public License ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. ;;; Commentary: ;;;_* What does Eshell offer you? ;; ;; Despite the sheer fact that running an Emacs shell can be fun, here ;; are a few of the unique features offered by Eshell: ;; ;; @ Integration with the Emacs Lisp programming environment ;; ;; @ A high degree of configurability ;; ;; @ The ability to have the same shell on every system Emacs has been ;; ported to. Since Eshell imposes no external requirements, and ;; relies upon only the Lisp functions exposed by Emacs, it is quite ;; operating system independent. Several of the common UNIX ;; commands, such as ls, mv, rm, ln, etc., have been implemented in ;; Lisp in order to provide a more consistent work environment. ;; ;; For those who might be using an older version of Eshell, version ;; 2.1 represents an entirely new, module-based architecture. It ;; supports most of the features offered by modern shells. Here is a ;; brief list of some of its more visible features: ;; ;; @ Command argument completion (tcsh, zsh) ;; @ Input history management (bash) ;; @ Intelligent output scrolling ;; @ Pseudo-devices (such as "/dev/clip" for copying to the clipboard) ;; @ Extended globbing (zsh) ;; @ Argument and globbing predication (zsh) ;; @ I/O redirection to buffers, files, symbols, processes, etc. ;; @ Many niceties otherwise seen only in 4DOS ;; @ Alias functions, both Lisp and Eshell-syntax ;; @ Piping, sequenced commands, background jobs, etc... ;; ;;;_* How to begin ;; ;; To start using Eshell, simply type `M-x eshell'. ;; ;;;_* Philosophy ;; ;; A shell is a layer which metaphorically surrounds the kernel, or ;; heart of an operating system. This kernel can be seen as an engine ;; of pure functionality, waiting to serve, while the user programs ;; take advantage of that functionality to accomplish their purpose. ;; ;; The shell's role is to make that functionality accessible to the ;; user in an unformed state. Very roughly, it associates kernel ;; functionality with textual commands, allowing the user to interact ;; with the operating system via linguistic constructs. Process ;; invocation is perhaps the most significant form this takes, using ;; the kernel's `fork' and `exec' functions. ;; ;; Other programs also interact with the functionality of the kernel, ;; but these user applications typically offer a specific range of ;; functionality, and thus are not classed as "shells" proper. ;; (What they lose in quiddity, they gain in rigidity). ;; ;; Emacs is also a user application, but it does make the ;; functionality of the kernel accessible through an interpreted ;; language -- namely, Lisp. For that reason, there is little ;; preventing Emacs from serving the same role as a modern shell. It ;; too can manipulate the kernel in an unpredetermined way to cause ;; system changes. All it's missing is the shell-ish linguistic ;; model. ;; ;; Enter Eshell. Eshell translates "shell-like" syntax into Lisp ;; in order to exercise the kernel in the same manner as typical ;; system shells. There is a fundamental difference here, however, ;; although it may seem subtle at first... ;; ;; Shells like csh and Bourne shell were written several decades ago, ;; in different times, under more restrictive circumstances. This ;; confined perspective shows itself in the paradigm used by nearly ;; all command-line shells since. They are linear in conception, byte ;; stream-based, sequential, and confined to movement within a single ;; host machine. ;; ;; Emacs, on the other hand, is more than just a limited translator ;; that can invoke subprocesses and redirect file handles. It also ;; manages character buffers, windowing frames, network connections, ;; registers, bookmarks, processes, etc. In other words, it's a very ;; multi-dimensional environment, within which eshell emulates a highly ;; linear methodology. ;; ;; Taking a moment, let's look at how this could affect the future of ;; a shell allowed to develop in such a wider field of play: ;; ;; @ There is no reason why directory movement should be linear, and ;; confined to a single file-system. Emacs, through w3 and ange-ftp, ;; has access to the entire Web. Why not allow a user to cd to ;; multiple directories simultaneously, for example? It might make ;; some tasks easier, such as diff'ing files separated by very long ;; pathnames. ;; ;; @ Data sources are available from anywhere Emacs can derive ;; information from: not just from files or the output of other ;; processes. ;; ;; @ Multiple shell invocations all share the same environment -- even ;; the same process list! It would be possible to have "process ;; views", so that one buffer is watching standard output, another ;; standard error, and another the result of standard output grep'd ;; through a regular expression... ;; ;; @ It is not necessary to "leave" the shell, losing all input and ;; output history, environment variables, directory stack, etc. ;; Emacs could save the contents of your eshell environment, and ;; restore all of it (or at least as much as possible) each time you ;; restart. This could occur automatically, without requiring ;; complex initialization scripts. ;; ;; @ Typos occur all of the time; many of them are repeats of common ;; errors, such as 'dri' for `dir'. Since executing non-existent ;; programs is rarely the intention of the user, eshell could prompt ;; for the replacement string, and then record that in a database of ;; known misspellings. (Note: The typo at the beginning of this ;; paragraph wasn't discovered until two months after I wrote the ;; text; it was not intentional). ;; ;; @ Emacs' register and bookmarking facilities can be used for ;; remembering where you've been, and what you've seen -- to varying ;; levels of persistence. They could perhaps even be tied to ;; specific "moments" during eshell execution, which would include ;; the environment at that time, as well as other variables. ;; Although this would require functionality orthogonal to Emacs' ;; own bookmarking facilities, the interface used could be made to ;; operate very similarly. ;; ;; This presents a brief idea of what the fuller dimensionality of an ;; Emacs shell could offer. It's not just the language of a shell ;; that determines how it's used, but also the Weltanschauung ;; underlying its design -- and which is felt behind even the smallest ;; feature. I would hope the freedom provided by using Emacs as a ;; parent environment will invite rich ideas from others. It ;; certainly feels as though all I've done so far is to tie down the ;; horse, so to speak, so that he will run at a man's pace. ;; ;;;_* Influences ;; ;; The author of Eshell has been a long-time user of the following ;; shells, all of which contributed to Eshell's design: ;; ;; @ rc ;; @ bash ;; @ zsh ;; @ sh ;; @ 4nt ;; @ csh ;;;_* Speeding up load time ;; ;; If you find that Eshell loads too slowly, there is something you ;; can do to speed it up. ;; ;; Create a file, named /tmp/elc, containing this filelist: ;; ;; esh-util.elc ;; eshell.elc ;; esh-module.elc ;; esh-var.elc ;; esh-proc.elc ;; esh-arg.elc ;; esh-io.elc ;; esh-ext.elc ;; esh-cmd.elc ;; esh-mode.elc ;; esh-opt.elc ;; em-alias.elc ;; em-banner.elc ;; em-basic.elc ;; em-cmpl.elc ;; em-dirs.elc ;; em-pred.elc ;; em-glob.elc ;; em-hist.elc ;; em-ls.elc ;; em-prompt.elc ;; em-rebind.elc ;; em-script.elc ;; em-smart.elc ;; em-term.elc ;; em-unix.elc ;; em-xtra.elc ;; ;; The order is very important. Remove from the filelist any features ;; you don't use. These all begin with "em-". If you don't use ;; Eshell's key rebinding module, you can remove "em-rebind.elc" from ;; the filelist. The modules you are currently using are listed in ;; `eshell-modules-list'. ;; ;; Now, concatenating all of the above mentioned .elc files, in that ;; order, to another file. Here is how to do this on UNIX: ;; ;; cat `cat /tmp/elc` > tmp.elc ; mv tmp.elc eshell.elc ;; ;; Now your eshell.elc file contains all of the .elc files that make ;; up Eshell, in the right load order. When you next load Eshell, it ;; will only have to read in this one file, which will greatly speed ;; things up. (eval-when-compile (require 'cl) (require 'esh-util)) (require 'esh-util) (require 'esh-mode) (defgroup eshell nil "A command shell implemented entirely in Emacs Lisp. It invokes no external processes beyond those requested by the user, and is intended to be a functional replacement for command shells such as bash, zsh, rc, 4dos." :tag "The Emacs shell" :link '(info-link "(eshell)Top") :version "21.1" :group 'applications) ;; This is hack to force make-autoload to put the whole definition ;; into the autoload file (see esh-module.el). (defalias 'eshell-defgroup 'defgroup) ;;;_* User Options ;; ;; The following user options modify the behavior of Eshell overall. (defvar eshell-buffer-name) (defsubst eshell-add-to-window-buffer-names () "Add `eshell-buffer-name' to `same-window-buffer-names'." (add-to-list 'same-window-buffer-names eshell-buffer-name)) (defsubst eshell-remove-from-window-buffer-names () "Remove `eshell-buffer-name' from `same-window-buffer-names'." (setq same-window-buffer-names (delete eshell-buffer-name same-window-buffer-names))) (defcustom eshell-load-hook nil "A hook run once Eshell has been loaded." :type 'hook :group 'eshell) (defcustom eshell-unload-hook '(eshell-remove-from-window-buffer-names eshell-unload-all-modules) "A hook run when Eshell is unloaded from memory." :type 'hook :group 'eshell) (defcustom eshell-buffer-name "*eshell*" "The basename used for Eshell buffers." :set (lambda (symbol value) ;; remove the old value of `eshell-buffer-name', if present (if (boundp 'eshell-buffer-name) (eshell-remove-from-window-buffer-names)) (set symbol value) ;; add the new value (eshell-add-to-window-buffer-names) value) :type 'string :group 'eshell) (eshell-deftest mode same-window-buffer-names "`eshell-buffer-name' is a member of `same-window-buffer-names'" (member eshell-buffer-name same-window-buffer-names)) (defcustom eshell-directory-name (convert-standard-filename "~/.eshell/") "The directory where Eshell control files should be kept." :type 'directory :group 'eshell) (eshell-deftest mode eshell-directory-exists "`eshell-directory-name' exists and is writable" (file-writable-p eshell-directory-name)) (eshell-deftest mode eshell-directory-modes "`eshell-directory-name' has correct access protections" (or (eshell-under-windows-p) (= (file-modes eshell-directory-name) eshell-private-directory-modes))) ;;;_* Running Eshell ;; ;; There are only three commands used to invoke Eshell. The first two ;; are intended for interactive use, while the third is meant for ;; programmers. They are: ;;;###autoload (defun eshell (&optional arg) "Create an interactive Eshell buffer. The buffer used for Eshell sessions is determined by the value of `eshell-buffer-name'. If there is already an Eshell session active in that buffer, Emacs will simply switch to it. Otherwise, a new session will begin. A numeric prefix arg (as in `C-u 42 M-x eshell RET') switches to the session with that number, creating it if necessary. A nonnumeric prefix arg means to create a new session. Returns the buffer selected (or created)." (interactive "P") (assert eshell-buffer-name) (let ((buf (cond ((numberp arg) (get-buffer-create (format "%s<%d>" eshell-buffer-name arg))) (arg (generate-new-buffer eshell-buffer-name)) (t (get-buffer-create eshell-buffer-name))))) ;; Simply calling `pop-to-buffer' will not mimic the way that ;; shell-mode buffers appear, since they always reuse the same ;; window that that command was invoked from. To achieve this, ;; it's necessary to add `eshell-buffer-name' to the variable ;; `same-window-buffer-names', which is done when Eshell is loaded (assert (and buf (buffer-live-p buf))) (pop-to-buffer buf) (unless (eq major-mode 'eshell-mode) (eshell-mode)) buf)) (defun eshell-return-exits-minibuffer () (define-key eshell-mode-map [(control ?g)] 'abort-recursive-edit) (define-key eshell-mode-map [return] 'exit-minibuffer) (define-key eshell-mode-map [(control ?m)] 'exit-minibuffer) (define-key eshell-mode-map [(control ?j)] 'exit-minibuffer) (define-key eshell-mode-map [(meta return)] 'exit-minibuffer) (define-key eshell-mode-map [(meta control ?m)] 'exit-minibuffer)) (defvar eshell-non-interactive-p nil "A variable which is non-nil when Eshell is not running interactively. Modules should use this variable so that they don't clutter non-interactive sessions, such as when using `eshell-command'.") ;;;###autoload (defun eshell-command (&optional command arg) "Execute the Eshell command string COMMAND. With prefix ARG, insert output into the current buffer at point." (interactive) (require 'esh-cmd) (unless arg (setq arg current-prefix-arg)) (unwind-protect (let ((eshell-non-interactive-p t)) (add-hook 'minibuffer-setup-hook 'eshell-mode) (add-hook 'minibuffer-exit-hook 'eshell-add-command-to-history) (add-hook 'eshell-mode-hook 'eshell-return-exits-minibuffer) (unless command (setq command (read-from-minibuffer "Emacs shell command: ")))) (remove-hook 'eshell-mode-hook 'eshell-return-exits-minibuffer) (remove-hook 'minibuffer-exit-hook 'eshell-add-command-to-history) (remove-hook 'minibuffer-setup-hook 'eshell-mode)) (unless command (error "No command specified!")) ;; redirection into the current buffer is achieved by adding an ;; output redirection to the end of the command, of the form ;; 'COMMAND >>> #<buffer BUFFER>'. This will not interfere with ;; other redirections, since multiple redirections merely cause the ;; output to be copied to multiple target locations (if arg (setq command (concat command (format " >>> #<buffer %s>" (buffer-name (current-buffer)))))) (save-excursion (let ((buf (set-buffer (generate-new-buffer " *eshell cmd*"))) (eshell-non-interactive-p t)) (eshell-mode) (let* ((proc (eshell-eval-command (list 'eshell-commands (eshell-parse-command command)))) intr (bufname (if (and proc (listp proc)) "*EShell Async Command Output*" (setq intr t) "*EShell Command Output*"))) (if (buffer-live-p (get-buffer bufname)) (kill-buffer bufname)) (rename-buffer bufname) ;; things get a little coarse here, since the desire is to ;; make the output as attractive as possible, with no ;; extraneous newlines (when intr (if (eshell-interactive-process) (eshell-wait-for-process (eshell-interactive-process))) (assert (not (eshell-interactive-process))) (goto-char (point-max)) (while (and (bolp) (not (bobp))) (delete-backward-char 1))) (assert (and buf (buffer-live-p buf))) (unless arg (let ((len (if (not intr) 2 (count-lines (point-min) (point-max))))) (cond ((= len 0) (message "(There was no command output)") (kill-buffer buf)) ((= len 1) (message "%s" (buffer-string)) (kill-buffer buf)) (t (save-selected-window (select-window (display-buffer buf)) (goto-char (point-min)) ;; cause the output buffer to take up as little screen ;; real-estate as possible, if temp buffer resizing is ;; enabled (and intr temp-buffer-resize-mode (resize-temp-buffer-window))))))))))) ;;;###autoload (defun eshell-command-result (command &optional status-var) "Execute the given Eshell COMMAND, and return the result. The result might be any Lisp object. If STATUS-VAR is a symbol, it will be set to the exit status of the command. This is the only way to determine whether the value returned corresponding to a successful execution." ;; a null command produces a null, successful result (if (not command) (ignore (if (and status-var (symbolp status-var)) (set status-var 0))) (with-temp-buffer (let ((eshell-non-interactive-p t)) (eshell-mode) (let ((result (eshell-do-eval (list 'eshell-commands (list 'eshell-command-to-value (eshell-parse-command command))) t))) (assert (eq (car result) 'quote)) (if (and status-var (symbolp status-var)) (set status-var eshell-last-command-status)) (cadr result)))))) (eshell-deftest mode simple-command-result "`eshell-command-result' works with a simple command." (= (eshell-command-result "+ 1 2") 3)) ;;;_* Reporting bugs ;; ;; If you do encounter a bug, on any system, please report ;; it -- in addition to any particular oddities in your configuration ;; -- so that the problem may be corrected for the benefit of others. ;;;###autoload (define-obsolete-function-alias 'eshell-report-bug 'report-emacs-bug "23.1") ;;; Code: (defun eshell-unload-all-modules () "Unload all modules that were loaded by Eshell, if possible. If the user has require'd in any of the modules, or customized a variable with a :require tag (such as `eshell-prefer-to-shell'), it will be impossible to unload Eshell completely without restarting Emacs." ;; if the user set `eshell-prefer-to-shell' to t, but never loaded ;; Eshell, then `eshell-subgroups' will be unbound (when (fboundp 'eshell-subgroups) (eshell-for module (eshell-subgroups 'eshell) ;; this really only unloads as many modules as possible, ;; since other `require' references (such as by customizing ;; `eshell-prefer-to-shell' to a non-nil value) might make it ;; impossible to unload Eshell completely (if (featurep module) (ignore-errors (message "Unloading %s..." (symbol-name module)) (unload-feature module) (message "Unloading %s...done" (symbol-name module))))) (message "Unloading eshell...done"))) (run-hooks 'eshell-load-hook) (provide 'eshell) ;; arch-tag: 9d4d5214-0e4e-4e02-b349-39add640d63f ;;; eshell.el ends here